From b08006dbb212ecb2ebee9f0d0310a2efde4fd27e Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Fri, 22 Aug 2025 16:39:32 +0200
Subject: [PATCH 01/21] Add Eliom_stream, copy of Lwt_stream

---
 src/lib/eliom_stream.shared.ml  | 983 ++++++++++++++++++++++++++++++++
 src/lib/eliom_stream.shared.mli | 400 +++++++++++++
 2 files changed, 1383 insertions(+)
 create mode 100644 src/lib/eliom_stream.shared.ml
 create mode 100644 src/lib/eliom_stream.shared.mli

diff --git a/src/lib/eliom_stream.shared.ml b/src/lib/eliom_stream.shared.ml
new file mode 100644
index 0000000000..780fb67bff
--- /dev/null
+++ b/src/lib/eliom_stream.shared.ml
@@ -0,0 +1,983 @@
+(* This file is part of Lwt, released under the MIT license. See LICENSE.md for
+   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
+
+open Lwt.Infix
+
+exception Closed
+exception Full
+exception Empty
+
+(* A node in a queue of pending data. *)
+type 'a node =
+  { mutable next : 'a node
+  ; (* Next node in the queue. For the last node it points to itself. *)
+    mutable data : 'a option
+    (* Data of this node. For the last node it is always [None]. *) }
+
+(* Note: a queue for an exhausted stream is represented by a node
+   containing [None] followed by a node with itself as next and [None]
+   as data. *)
+
+let new_node () =
+  let rec node = {next = node; data = None} in
+  node
+
+(* Type of a stream source using a function to create new elements. *)
+type 'a from =
+  { from_create : unit -> 'a option Lwt.t
+  ; (* Function used to create new elements. *)
+    mutable from_thread : unit Lwt.t
+    (* Thread which:
+
+     - wait for the thread returned by the last call to [from_next],
+     - add the next element to the end of the queue.
+
+     If it is a sleeping thread, then it must be used instead of creating a
+     new one with [from_create]. *)
+  }
+
+(* Type of a stream source for push streams. *)
+[@@@ocaml.warning "-69"]
+
+type push =
+  { mutable push_signal : unit Lwt.t
+  ; (* Thread signaled when a new element is added to the stream. *)
+    mutable push_waiting : bool
+  ; (* Is a thread waiting on [push_signal] ? *)
+    mutable push_external : Obj.t [@ocaml.warning "-69"]
+    (* Reference to an external source. *) }
+
+(* Type of a stream source for bounded-push streams. *)
+type 'a push_bounded =
+  { mutable pushb_signal : unit Lwt.t
+  ; (* Thread signaled when a new element is added to the stream. *)
+    mutable pushb_waiting : bool
+  ; (* Is a thread waiting on [pushb_signal] ? *)
+    mutable pushb_size : int
+  ; (* Size of the queue. *)
+    mutable pushb_count : int
+  ; (* Current length of the queue. *)
+    mutable pushb_pending : 'a option
+  ; (* The next element to push if a thread blocked on push. We store it
+     here to be sure it will be the first element to be added when
+     space becomes available. *)
+    mutable pushb_push_waiter : unit Lwt.t
+  ; mutable pushb_push_wakener : unit Lwt.u
+  ; (* Thread blocked on push. *)
+    mutable pushb_external : Obj.t [@ocaml.warning "-69"]
+    (* Reference to an external source. *) }
+
+[@@@ocaml.warning "+69"]
+
+(* Source of a stream. *)
+type 'a source =
+  | From of 'a from
+  | From_direct of (unit -> 'a option)
+  | Push of push
+  | Push_bounded of 'a push_bounded
+
+type 'a t =
+  { source : 'a source
+  ; (* The source of the stream. *)
+    close : unit Lwt.u
+  ; (* A wakener for a thread that sleeps until the stream is closed. *)
+    closed : unit Lwt.t
+  ; (* A waiter for a thread that sleeps until the stream is closed. *)
+    mutable node : 'a node
+  ; (* Pointer to first pending element, or to [last] if there is no
+     pending element. *)
+    last : 'a node ref
+    (* Node marking the end of the queue of pending elements. *) }
+
+class type ['a] bounded_push = object
+  method size : int
+  method resize : int -> unit
+  method push : 'a -> unit Lwt.t
+  method close : unit
+  method count : int
+  method blocked : bool
+  method closed : bool
+  method set_reference : 'a. 'a -> unit
+end
+
+(* The only difference between two clones is the pointer to the first
+   pending element. *)
+let clone s =
+  (match s.source with
+  | Push_bounded _ -> invalid_arg "Lwt_stream.clone"
+  | From _ | From_direct _ | Push _ -> ());
+  { source = s.source
+  ; close = s.close
+  ; closed = s.closed
+  ; node = s.node
+  ; last = s.last }
+
+let from_source source =
+  let node = new_node () in
+  let closed, close = Lwt.wait () in
+  {source; close; closed; node; last = ref node}
+
+let from f = from_source (From {from_create = f; from_thread = Lwt.return_unit})
+let from_direct f = from_source (From_direct f)
+let closed s = s.closed
+let is_closed s = not (Lwt.is_sleeping (closed s))
+
+let enqueue' e last =
+  let node = !last and new_last = new_node () in
+  node.data <- e;
+  node.next <- new_last;
+  last := new_last
+
+let enqueue e s = enqueue' e s.last
+
+let create_with_reference () =
+  (* Create the source for notifications of new elements. *)
+  let source, push_signal_resolver =
+    let push_signal, push_signal_resolver = Lwt.wait () in
+    ( {push_signal; push_waiting = false; push_external = Obj.repr ()}
+    , ref push_signal_resolver )
+  in
+  let t = from_source (Push source) in
+  (* [push] should not close over [t] so that it can be garbage collected even
+   * there are still references to [push]. Unpack all the components of [t]
+   * that [push] needs and reference those identifiers instead. *)
+  let close = t.close and closed = t.closed and last = t.last in
+  (* The push function. It does not keep a reference to the stream. *)
+  let push x =
+    if not (Lwt.is_sleeping closed) then raise Closed;
+    (* Push the element at the end of the queue. *)
+    enqueue' x last;
+    (* Send a signal if at least one thread is waiting for a new
+       element. *)
+    if source.push_waiting
+    then (
+      source.push_waiting <- false;
+      (* Update threads. *)
+      let old_push_signal_resolver = !push_signal_resolver in
+      let new_waiter, new_push_signal_resolver = Lwt.wait () in
+      source.push_signal <- new_waiter;
+      push_signal_resolver := new_push_signal_resolver;
+      (* Signal that a new value has been received. *)
+      Lwt.wakeup_later old_push_signal_resolver ());
+    (* Do this at the end in case one of the function raise an
+       exception. *)
+    if x = None then Lwt.wakeup close ()
+  in
+  t, push, fun x -> source.push_external <- Obj.repr x
+
+let return a =
+  let stream, push, _ = create_with_reference () in
+  push (Some a); push None; stream
+
+let return_lwt a =
+  let source, push, _ = create_with_reference () in
+  Lwt.dont_wait
+    (fun () -> Lwt.bind a (fun x -> push (Some x); push None; Lwt.return_unit))
+    (fun _exc -> push None);
+  source
+
+let of_seq s =
+  let s = ref s in
+  let get () =
+    match !s () with
+    | Seq.Nil -> None
+    | Seq.Cons (elt, s') ->
+        s := s';
+        Some elt
+  in
+  from_direct get
+
+let of_lwt_seq s =
+  let s = ref s in
+  let get () =
+    !s () >|= function
+    | Lwt_seq.Nil -> None
+    | Lwt_seq.Cons (elt, s') ->
+        s := s';
+        Some elt
+  in
+  from get
+
+let create () =
+  let source, push, _ = create_with_reference () in
+  source, push
+
+let of_iter iter i =
+  let stream, push = create () in
+  iter (fun x -> push (Some x)) i;
+  push None;
+  stream
+
+let of_list l = of_iter List.iter l
+let of_array a = of_iter Array.iter a
+let of_string s = of_iter String.iter s
+
+(* Add the pending element to the queue and notify the blocked pushed.
+
+   Precondition: info.pushb_pending = Some _
+
+   This does not modify info.pushb_count. *)
+let notify_pusher info last =
+  (* Push the element at the end of the queue. *)
+  enqueue' info.pushb_pending last;
+  (* Clear pending element. *)
+  info.pushb_pending <- None;
+  (* Wakeup the pusher. *)
+  let old_wakener = info.pushb_push_wakener in
+  let waiter, wakener = Lwt.task () in
+  info.pushb_push_waiter <- waiter;
+  info.pushb_push_wakener <- wakener;
+  Lwt.wakeup_later old_wakener ()
+
+class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
+  object
+    val mutable closed = false
+    method size = info.pushb_size
+
+    method resize size =
+      if size < 0 then invalid_arg "Lwt_stream.bounded_push#resize";
+      info.pushb_size <- size;
+      if info.pushb_count < info.pushb_size && info.pushb_pending <> None
+      then (
+        info.pushb_count <- info.pushb_count + 1;
+        notify_pusher info last)
+
+    method push x =
+      if closed
+      then Lwt.fail Closed
+      else if info.pushb_pending <> None
+      then Lwt.fail Full
+      else if info.pushb_count >= info.pushb_size
+      then (
+        info.pushb_pending <- Some x;
+        Lwt.catch
+          (fun () -> info.pushb_push_waiter)
+          (fun exn ->
+             match exn with
+             | Lwt.Canceled ->
+                 info.pushb_pending <- None;
+                 let waiter, wakener = Lwt.task () in
+                 info.pushb_push_waiter <- waiter;
+                 info.pushb_push_wakener <- wakener;
+                 Lwt.reraise exn
+             | _ -> Lwt.reraise exn))
+      else (
+        (* Push the element at the end of the queue. *)
+        enqueue' (Some x) last;
+        info.pushb_count <- info.pushb_count + 1;
+        (* Send a signal if at least one thread is waiting for a new
+         element. *)
+        if info.pushb_waiting
+        then (
+          info.pushb_waiting <- false;
+          (* Update threads. *)
+          let old_wakener = !wakener_cell in
+          let new_waiter, new_wakener = Lwt.wait () in
+          info.pushb_signal <- new_waiter;
+          wakener_cell := new_wakener;
+          (* Signal that a new value has been received. *)
+          Lwt.wakeup_later old_wakener ());
+        Lwt.return_unit)
+
+    method close =
+      if not closed
+      then (
+        closed <- true;
+        let node = !last and new_last = new_node () in
+        node.data <- None;
+        node.next <- new_last;
+        last := new_last;
+        if info.pushb_pending <> None
+        then (
+          info.pushb_pending <- None;
+          Lwt.wakeup_later_exn info.pushb_push_wakener Closed);
+        (* Send a signal if at least one thread is waiting for a new
+         element. *)
+        if info.pushb_waiting
+        then (
+          info.pushb_waiting <- false;
+          let old_wakener = !wakener_cell in
+          (* Signal that a new value has been received. *)
+          Lwt.wakeup_later old_wakener ());
+        Lwt.wakeup close ())
+
+    method count = info.pushb_count
+    method blocked = info.pushb_pending <> None
+    method closed = closed
+
+    method set_reference : 'a. 'a -> unit =
+      fun x -> info.pushb_external <- Obj.repr x
+  end
+
+let create_bounded size =
+  if size < 0 then invalid_arg "Lwt_stream.create_bounded";
+  (* Create the source for notifications of new elements. *)
+  let info, wakener_cell =
+    let waiter, wakener = Lwt.wait () in
+    let push_waiter, push_wakener = Lwt.task () in
+    ( { pushb_signal = waiter
+      ; pushb_waiting = false
+      ; pushb_size = size
+      ; pushb_count = 0
+      ; pushb_pending = None
+      ; pushb_push_waiter = push_waiter
+      ; pushb_push_wakener = push_wakener
+      ; pushb_external = Obj.repr () }
+    , ref wakener )
+  in
+  let t = from_source (Push_bounded info) in
+  t, new bounded_push_impl info wakener_cell t.last t.close
+
+(* Wait for a new element to be added to the queue of pending element
+   of the stream. *)
+let feed s =
+  match s.source with
+  | From from ->
+      (* There is already a thread started to create a new element,
+       wait for this one to terminate. *)
+      if Lwt.is_sleeping from.from_thread
+      then Lwt.protected from.from_thread
+      else
+        (* Otherwise request a new element. *)
+        let thread =
+          (* The function [from_create] can raise an exception (with
+           [raise], rather than returning a failed promise with
+           [Lwt.fail]). In this case, we have to catch the exception
+           and turn it into a safe failed promise. *)
+          Lwt.catch
+            (fun () ->
+               from.from_create () >>= fun x ->
+               (* Push the element to the end of the queue. *)
+               enqueue x s;
+               if x = None then Lwt.wakeup s.close ();
+               Lwt.return_unit)
+            Lwt.reraise
+        in
+        (* Allow other threads to access this thread. *)
+        from.from_thread <- thread;
+        Lwt.protected thread
+  | From_direct f ->
+      let x = f () in
+      (* Push the element to the end of the queue. *)
+      enqueue x s;
+      if x = None then Lwt.wakeup s.close ();
+      Lwt.return_unit
+  | Push push ->
+      push.push_waiting <- true;
+      Lwt.protected push.push_signal
+  | Push_bounded push ->
+      push.pushb_waiting <- true;
+      Lwt.protected push.pushb_signal
+
+(* Remove [node] from the top of the queue, or do nothing if it was
+   already consumed.
+
+   Precondition: node.data <> None
+*)
+let consume s node =
+  if node == s.node
+  then (
+    s.node <- node.next;
+    match s.source with
+    | Push_bounded info ->
+        if info.pushb_pending = None
+        then info.pushb_count <- info.pushb_count - 1
+        else notify_pusher info s.last
+    | From _ | From_direct _ | Push _ -> ())
+
+let rec peek_rec s node =
+  if node == !(s.last)
+  then feed s >>= fun () -> peek_rec s node
+  else Lwt.return node.data
+
+let peek s = peek_rec s s.node
+
+let rec npeek_rec node acc n s =
+  if n <= 0
+  then Lwt.return (List.rev acc)
+  else if node == !(s.last)
+  then feed s >>= fun () -> npeek_rec node acc n s
+  else
+    match node.data with
+    | Some x -> npeek_rec node.next (x :: acc) (n - 1) s
+    | None -> Lwt.return (List.rev acc)
+
+let npeek n s = npeek_rec s.node [] n s
+
+let rec get_rec s node =
+  if node == !(s.last)
+  then feed s >>= fun () -> get_rec s node
+  else (
+    if node.data <> None then consume s node;
+    Lwt.return node.data)
+
+let get s = get_rec s s.node
+
+let rec get_exn_rec s node =
+  if node == !(s.last)
+  then
+    Lwt.try_bind
+      (fun () -> feed s)
+      (fun () -> get_exn_rec s node)
+      (fun exn -> Lwt.return (Some (Result.Error exn)))
+  else
+    match node.data with
+    | Some value ->
+        consume s node;
+        Lwt.return (Some (Result.Ok value))
+    | None -> Lwt.return_none
+
+let wrap_exn s = from (fun () -> get_exn_rec s s.node)
+
+let rec nget_rec node acc n s =
+  if n <= 0
+  then Lwt.return (List.rev acc)
+  else if node == !(s.last)
+  then feed s >>= fun () -> nget_rec node acc n s
+  else
+    match s.node.data with
+    | Some x ->
+        consume s node;
+        nget_rec node.next (x :: acc) (n - 1) s
+    | None -> Lwt.return (List.rev acc)
+
+let nget n s = nget_rec s.node [] n s
+
+let rec get_while_rec node acc f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> get_while_rec node acc f s
+  else
+    match node.data with
+    | Some x ->
+        let test = f x in
+        if test
+        then (
+          consume s node;
+          get_while_rec node.next (x :: acc) f s)
+        else Lwt.return (List.rev acc)
+    | None -> Lwt.return (List.rev acc)
+
+let get_while f s = get_while_rec s.node [] f s
+
+let rec get_while_s_rec node acc f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> get_while_s_rec node acc f s
+  else
+    match node.data with
+    | Some x -> (
+        f x >>= function
+        | true ->
+            consume s node;
+            get_while_s_rec node.next (x :: acc) f s
+        | false -> Lwt.return (List.rev acc))
+    | None -> Lwt.return (List.rev acc)
+
+let get_while_s f s = get_while_s_rec s.node [] f s
+
+let rec next_rec s node =
+  if node == !(s.last)
+  then feed s >>= fun () -> next_rec s node
+  else
+    match node.data with
+    | Some x -> consume s node; Lwt.return x
+    | None -> Lwt.fail Empty
+
+let next s = next_rec s s.node
+
+let rec last_new_rec node x s =
+  if node == !(s.last)
+  then
+    let thread = feed s in
+    match Lwt.state thread with
+    | Lwt.Return _ -> last_new_rec node x s
+    | Lwt.Fail exn -> Lwt.fail exn
+    | Lwt.Sleep -> Lwt.return x
+  else
+    match node.data with
+    | Some x -> consume s node; last_new_rec node.next x s
+    | None -> Lwt.return x
+
+let last_new s =
+  let node = s.node in
+  if node == !(s.last)
+  then
+    let thread = next s in
+    match Lwt.state thread with
+    | Lwt.Return x -> last_new_rec node x s
+    | Lwt.Fail _ | Lwt.Sleep -> thread
+  else
+    match node.data with
+    | Some x -> consume s node; last_new_rec node.next x s
+    | None -> Lwt.fail Empty
+
+let rec to_list_rec node acc s =
+  if node == !(s.last)
+  then feed s >>= fun () -> to_list_rec node acc s
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        to_list_rec node.next (x :: acc) s
+    | None -> Lwt.return (List.rev acc)
+
+let to_list s = to_list_rec s.node [] s
+
+let rec to_string_rec node buf s =
+  if node == !(s.last)
+  then feed s >>= fun () -> to_string_rec node buf s
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        Buffer.add_char buf x;
+        to_string_rec node.next buf s
+    | None -> Lwt.return (Buffer.contents buf)
+
+let to_string s = to_string_rec s.node (Buffer.create 128) s
+
+let junk s =
+  let node = s.node in
+  if node == !(s.last)
+  then (
+    feed s >>= fun () ->
+    if node.data <> None then consume s node;
+    Lwt.return_unit)
+  else (
+    if node.data <> None then consume s node;
+    Lwt.return_unit)
+
+let rec njunk_rec node n s =
+  if n <= 0
+  then Lwt.return_unit
+  else if node == !(s.last)
+  then feed s >>= fun () -> njunk_rec node n s
+  else
+    match node.data with
+    | Some _ ->
+        consume s node;
+        njunk_rec node.next (n - 1) s
+    | None -> Lwt.return_unit
+
+let njunk n s = njunk_rec s.node n s
+
+let rec junk_while_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> junk_while_rec node f s
+  else
+    match node.data with
+    | Some x ->
+        let test = f x in
+        if test
+        then (
+          consume s node;
+          junk_while_rec node.next f s)
+        else Lwt.return_unit
+    | None -> Lwt.return_unit
+
+let junk_while f s = junk_while_rec s.node f s
+
+let rec junk_while_s_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> junk_while_s_rec node f s
+  else
+    match node.data with
+    | Some x -> (
+        f x >>= function
+        | true ->
+            consume s node;
+            junk_while_s_rec node.next f s
+        | false -> Lwt.return_unit)
+    | None -> Lwt.return_unit
+
+let junk_while_s f s = junk_while_s_rec s.node f s
+
+let rec junk_available_rec node s =
+  if node == !(s.last)
+  then
+    let thread = feed s in
+    match Lwt.state thread with
+    | Lwt.Return _ -> junk_available_rec node s
+    | Lwt.Fail exn -> raise exn
+    | Lwt.Sleep -> ()
+  else
+    match node.data with
+    | Some _ ->
+        consume s node;
+        junk_available_rec node.next s
+    | None -> ()
+
+let junk_available s = junk_available_rec s.node s
+let junk_old s = Lwt.return (junk_available s)
+
+let rec get_available_rec node acc s =
+  if node == !(s.last)
+  then
+    let thread = feed s in
+    match Lwt.state thread with
+    | Lwt.Return _ -> get_available_rec node acc s
+    | Lwt.Fail exn -> raise exn
+    | Lwt.Sleep -> List.rev acc
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        get_available_rec node.next (x :: acc) s
+    | None -> List.rev acc
+
+let get_available s = get_available_rec s.node [] s
+
+let rec get_available_up_to_rec node acc n s =
+  if n <= 0
+  then List.rev acc
+  else if node == !(s.last)
+  then
+    let thread = feed s in
+    match Lwt.state thread with
+    | Lwt.Return _ -> get_available_up_to_rec node acc n s
+    | Lwt.Fail exn -> raise exn
+    | Lwt.Sleep -> List.rev acc
+  else
+    match s.node.data with
+    | Some x ->
+        consume s node;
+        get_available_up_to_rec node.next (x :: acc) (n - 1) s
+    | None -> List.rev acc
+
+let get_available_up_to n s = get_available_up_to_rec s.node [] n s
+
+let rec is_empty s =
+  if s.node == !(s.last)
+  then feed s >>= fun () -> is_empty s
+  else Lwt.return (s.node.data = None)
+
+let map f s =
+  from (fun () ->
+    get s >|= function
+    | Some x ->
+        let x = f x in
+        Some x
+    | None -> None)
+
+let map_s f s =
+  from (fun () ->
+    get s >>= function
+    | Some x -> f x >|= fun x -> Some x
+    | None -> Lwt.return_none)
+
+let filter f s =
+  let rec next () =
+    let t = get s in
+    t >>= function
+    | Some x ->
+        let test = f x in
+        if test then t else next ()
+    | None -> Lwt.return_none
+  in
+  from next
+
+let filter_s f s =
+  let rec next () =
+    let t = get s in
+    t >>= function
+    | Some x -> ( f x >>= function true -> t | false -> next ())
+    | None -> t
+  in
+  from next
+
+let filter_map f s =
+  let rec next () =
+    get s >>= function
+    | Some x -> (
+        let x = f x in
+        match x with Some _ -> Lwt.return x | None -> next ())
+    | None -> Lwt.return_none
+  in
+  from next
+
+let filter_map_s f s =
+  let rec next () =
+    get s >>= function
+    | Some x -> (
+        let t = f x in
+        t >>= function Some _ -> t | None -> next ())
+    | None -> Lwt.return_none
+  in
+  from next
+
+let map_list f s =
+  let pendings = ref [] in
+  let rec next () =
+    match !pendings with
+    | [] -> (
+        get s >>= function
+        | Some x ->
+            let l = f x in
+            pendings := l;
+            next ()
+        | None -> Lwt.return_none)
+    | x :: l ->
+        pendings := l;
+        Lwt.return (Some x)
+  in
+  from next
+
+let map_list_s f s =
+  let pendings = ref [] in
+  let rec next () =
+    match !pendings with
+    | [] -> (
+        get s >>= function
+        | Some x ->
+            f x >>= fun l ->
+            pendings := l;
+            next ()
+        | None -> Lwt.return_none)
+    | x :: l ->
+        pendings := l;
+        Lwt.return (Some x)
+  in
+  from next
+
+let flatten s = map_list (fun l -> l) s
+
+let rec fold_rec node f s acc =
+  if node == !(s.last)
+  then feed s >>= fun () -> fold_rec node f s acc
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        let acc = f x acc in
+        fold_rec node.next f s acc
+    | None -> Lwt.return acc
+
+let fold f s acc = fold_rec s.node f s acc
+
+let rec fold_s_rec node f s acc =
+  if node == !(s.last)
+  then feed s >>= fun () -> fold_s_rec node f s acc
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        f x acc >>= fun acc -> fold_s_rec node.next f s acc
+    | None -> Lwt.return acc
+
+let fold_s f s acc = fold_s_rec s.node f s acc
+
+let rec iter_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> iter_rec node f s
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        let () = f x in
+        iter_rec node.next f s
+    | None -> Lwt.return_unit
+
+let iter f s = iter_rec s.node f s
+
+let rec iter_s_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> iter_s_rec node f s
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        f x >>= fun () -> iter_s_rec node.next f s
+    | None -> Lwt.return_unit
+
+let iter_s f s = iter_s_rec s.node f s
+
+let rec iter_p_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> iter_p_rec node f s
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        let res = f x in
+        let rest = iter_p_rec node.next f s in
+        res >>= fun () -> rest
+    | None -> Lwt.return_unit
+
+let iter_p f s = iter_p_rec s.node f s
+
+let iter_n ?(max_concurrency = 1) f stream =
+  (if max_concurrency <= 0
+   then
+     let message =
+       Printf.sprintf "Lwt_stream.iter_n: max_concurrency must be > 0, %d given"
+         max_concurrency
+     in
+     invalid_arg message);
+  let rec loop running available =
+    (if available > 0
+     then Lwt.return (running, available)
+     else
+       Lwt.nchoose_split running >>= fun (complete, running) ->
+       Lwt.return (running, available + List.length complete))
+    >>= fun (running, available) ->
+    get stream >>= function
+    | None -> Lwt.join running
+    | Some elt -> loop (f elt :: running) (pred available)
+  in
+  loop [] max_concurrency
+
+let rec find_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> find_rec node f s
+  else
+    match node.data with
+    | Some x as opt ->
+        consume s node;
+        let test = f x in
+        if test then Lwt.return opt else find_rec node.next f s
+    | None -> Lwt.return_none
+
+let find f s = find_rec s.node f s
+
+let rec find_s_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> find_s_rec node f s
+  else
+    match node.data with
+    | Some x as opt -> (
+        consume s node;
+        f x >>= function
+        | true -> Lwt.return opt
+        | false -> find_s_rec node.next f s)
+    | None -> Lwt.return_none
+
+let find_s f s = find_s_rec s.node f s
+
+let rec find_map_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> find_map_rec node f s
+  else
+    match node.data with
+    | Some x ->
+        consume s node;
+        let x = f x in
+        if x = None then find_map_rec node.next f s else Lwt.return x
+    | None -> Lwt.return_none
+
+let find_map f s = find_map_rec s.node f s
+
+let rec find_map_s_rec node f s =
+  if node == !(s.last)
+  then feed s >>= fun () -> find_map_s_rec node f s
+  else
+    match node.data with
+    | Some x -> (
+        consume s node;
+        let t = f x in
+        t >>= function None -> find_map_s_rec node.next f s | Some _ -> t)
+    | None -> Lwt.return_none
+
+let find_map_s f s = find_map_s_rec s.node f s
+
+let combine s1 s2 =
+  let next () =
+    let t1 = get s1 and t2 = get s2 in
+    t1 >>= fun n1 ->
+    t2 >>= fun n2 ->
+    match n1, n2 with
+    | Some x1, Some x2 -> Lwt.return (Some (x1, x2))
+    | _ -> Lwt.return_none
+  in
+  from next
+
+let append s1 s2 =
+  let current_s = ref s1 in
+  let rec next () =
+    let t = get !current_s in
+    t >>= function
+    | Some _ -> t
+    | None ->
+        if !current_s == s2
+        then Lwt.return_none
+        else (
+          current_s := s2;
+          next ())
+  in
+  from next
+
+let concat s_top =
+  let current_s = ref (from (fun () -> Lwt.return_none)) in
+  let rec next () =
+    let t = get !current_s in
+    t >>= function
+    | Some _ -> t
+    | None -> (
+        get s_top >>= function
+        | Some s ->
+            current_s := s;
+            next ()
+        | None -> Lwt.return_none)
+  in
+  from next
+
+let choose streams =
+  let source s = s, get s >|= fun x -> s, x in
+  let streams = ref (List.map source streams) in
+  let rec next () =
+    match !streams with
+    | [] -> Lwt.return_none
+    | l -> (
+        Lwt.choose (List.map snd l) >>= fun (s, x) ->
+        let l = List.remove_assq s l in
+        match x with
+        | Some _ ->
+            streams := source s :: l;
+            Lwt.return x
+        | None ->
+            streams := l;
+            next ())
+  in
+  from next
+
+let parse s f =
+  (match s.source with
+  | Push_bounded _ -> invalid_arg "Lwt_stream.parse"
+  | From _ | From_direct _ | Push _ -> ());
+  let node = s.node in
+  Lwt.catch
+    (fun () -> f s)
+    (fun exn ->
+       s.node <- node;
+       Lwt.reraise exn)
+
+let hexdump stream =
+  let buf = Buffer.create 80 and num = ref 0 in
+  from (fun _ ->
+    nget 16 stream >>= function
+    | [] -> Lwt.return_none
+    | l ->
+        Buffer.clear buf;
+        Printf.bprintf buf "%08x|  " !num;
+        num := !num + 16;
+        let rec bytes pos = function
+          | [] -> blanks pos
+          | x :: l ->
+              if pos = 8 then Buffer.add_char buf ' ';
+              Printf.bprintf buf "%02x " (Char.code x);
+              bytes (pos + 1) l
+        and blanks pos =
+          if pos < 16
+          then (
+            if pos = 8
+            then Buffer.add_string buf "    "
+            else Buffer.add_string buf "   ";
+            blanks (pos + 1))
+        in
+        bytes 0 l;
+        Buffer.add_string buf " |";
+        List.iter
+          (fun ch ->
+             Buffer.add_char buf
+               (if ch >= '\x20' && ch <= '\x7e' then ch else '.'))
+          l;
+        Buffer.add_char buf '|';
+        Lwt.return (Some (Buffer.contents buf)))
diff --git a/src/lib/eliom_stream.shared.mli b/src/lib/eliom_stream.shared.mli
new file mode 100644
index 0000000000..6a4c632e08
--- /dev/null
+++ b/src/lib/eliom_stream.shared.mli
@@ -0,0 +1,400 @@
+(* This file is part of Lwt, released under the MIT license. See LICENSE.md for
+   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
+
+(** Data streams *)
+
+type 'a t
+(** A stream holding values of type ['a].
+
+    Naming convention: in this module, all functions applying a function
+    to each element of a stream are suffixed by:
+
+    - [_s] when the function returns a thread and calls are serialised
+    - [_p] when the function returns a thread and calls are parallelised *)
+
+(** {2 Construction} *)
+
+val from : (unit -> 'a option Lwt.t) -> 'a t
+(** [from f] creates a stream from the given input function. [f] is
+    called each time more input is needed, and the stream ends when
+    [f] returns [None].
+
+    If [f], or the thread produced by [f], raises an exception, that exception
+    is forwarded to the consumer of the stream (for example, a caller of
+    {!get}). Note that this does not end the stream. A subsequent attempt to
+    read from the stream will cause another call to [f], which may succeed
+    with a value. *)
+
+val from_direct : (unit -> 'a option) -> 'a t
+(** [from_direct f] does the same as {!from} but with a function
+    that does not return a thread. It is preferred that this
+    function be used rather than wrapping [f] into a function which
+    returns a thread.
+
+    The behavior when [f] raises an exception is the same as for {!from},
+    except that [f] does not produce a thread. *)
+
+exception Closed
+(** Exception raised by the push function of a push-stream when
+    pushing an element after the end of stream ([= None]) has been
+    pushed. *)
+
+val create : unit -> 'a t * ('a option -> unit)
+(** [create ()] returns a new stream and a push function.
+
+    To notify the stream's consumer of errors, either use a separate
+    communication channel, or use a {!Stdlib.result} stream. There is
+    no way to push an exception into a push-stream. *)
+
+val create_with_reference : unit -> 'a t * ('a option -> unit) * ('b -> unit)
+(** [create_with_reference ()] returns a new stream and a push
+    function. The last function allows a reference to be set to an
+    external source. This prevents the external source from being
+    garbage collected.
+
+    For example, to convert a reactive event to a stream:
+
+    {[
+      let stream, push, set_ref = Lwt_stream.create_with_reference () in
+      set_ref (map_event push event)
+    ]}
+*)
+
+exception Full
+(** Exception raised by the push function of a bounded push-stream
+    when the stream queue is full and a thread is already waiting to
+    push an element. *)
+
+(** Type of sources for bounded push-streams. *)
+class type ['a] bounded_push = object
+  method size : int
+  (** Size of the stream. *)
+
+  method resize : int -> unit
+  (** Change the size of the stream queue. Note that the new size
+      can smaller than the current stream queue size.
+
+      It raises {!Stdlib.Invalid_argument} if [size < 0]. *)
+
+  method push : 'a -> unit Lwt.t
+  (** Pushes a new element to the stream. If the stream is full then
+      it will block until one element is consumed. If another thread
+      is already blocked on [push], it raises {!Lwt_stream.Full}. *)
+
+  method close : unit
+  (** Closes the stream. Any thread currently blocked on a call to
+      the [push] method fails with {!Lwt_stream.Closed}. *)
+
+  method count : int
+  (** Number of elements in the stream queue. *)
+
+  method blocked : bool
+  (** Is a thread is blocked on a call to the [push] method? *)
+
+  method closed : bool
+  (** Is the stream closed? *)
+
+  method set_reference : 'a. 'a -> unit
+  (** Set the reference to an external source. *)
+end
+
+val create_bounded : int -> 'a t * 'a bounded_push
+(** [create_bounded size] returns a new stream and a bounded push
+    source. The stream can hold a maximum of [size] elements.  When
+    this limit is reached, pushing a new element will block until
+    one is consumed.
+
+    Note that you cannot clone or parse (with {!parse}) a bounded
+    stream. These functions will raise [Invalid_argument] if you try
+    to do so.
+
+    It raises [Invalid_argument] if [size < 0]. *)
+
+val return : 'a -> 'a t
+(** [return a] creates a stream containing the value [a] and being immediately
+    closed stream (in the sense of {!is_closed}).
+
+    @since 5.5.0 *)
+
+val return_lwt : 'a Lwt.t -> 'a t
+(** [return_lwt l] creates a stream returning the value that [l] resolves to.
+    The value is pushed into the stream immediately after the promise becomes
+    resolved and the stream is then immediately closed (in the sense of
+    {!is_closed}).
+
+    If, instead, [l] becomes rejected, then the stream is closed without any
+    elements in it. Attempting to fetch elements from it will raise {!Empty}.
+
+    @since 5.5.0 *)
+
+val of_seq : 'a Seq.t -> 'a t
+(** [of_seq s] creates a stream returning all elements of [s]. The elements are
+    evaluated from [s] and pushed onto the stream as the stream is consumed.
+
+    @since 4.2.0 *)
+
+val of_lwt_seq : 'a Lwt_seq.t -> 'a t
+(** [of_lwt_seq s] creates a stream returning all elements of [s]. The elements
+    are evaluated from [s] and pushed onto the stream as the stream is consumed.
+
+    @since 5.5.0 *)
+
+val of_list : 'a list -> 'a t
+(** [of_list l] creates a stream returning all elements of [l]. The elements are
+    pushed into the stream immediately, resulting in a closed stream (in the
+    sense of {!is_closed}). *)
+
+val of_array : 'a array -> 'a t
+(** [of_array a] creates a stream returning all elements of [a]. The elements
+    are pushed into the stream immediately, resulting in a closed stream (in the
+    sense of {!is_closed}). *)
+
+val of_string : string -> char t
+(** [of_string str] creates a stream returning all characters of [str]. The
+    characters are pushed into the stream immediately, resulting in a closed
+    stream (in the sense of {!is_closed}). *)
+
+val clone : 'a t -> 'a t
+(** [clone st] clone the given stream. Operations on each stream
+    will not affect the other.
+
+    For example:
+
+    {[
+      # let st1 = Lwt_stream.of_list [1; 2; 3];;
+      val st1 : int Lwt_stream.t = <abstr>
+      # let st2 = Lwt_stream.clone st1;;
+      val st2 : int Lwt_stream.t = <abstr>
+      # lwt x = Lwt_stream.next st1;;
+      val x : int = 1
+      # lwt y = Lwt_stream.next st2;;
+      val y : int = 1
+    ]}
+
+    It raises [Invalid_argument] if [st] is a bounded
+    push-stream. *)
+
+(** {2 Destruction} *)
+
+val to_list : 'a t -> 'a list Lwt.t
+(** Returns the list of elements of the given stream *)
+
+val to_string : char t -> string Lwt.t
+(** Returns the word composed of all characters of the given
+    stream *)
+
+(** {2 Data retrieval} *)
+
+exception Empty
+(** Exception raised when trying to retrieve data from an empty
+    stream. *)
+
+val peek : 'a t -> 'a option Lwt.t
+(** [peek st] returns the first element of the stream, if any,
+    without removing it. *)
+
+val npeek : int -> 'a t -> 'a list Lwt.t
+(** [npeek n st] returns at most the first [n] elements of [st],
+    without removing them. *)
+
+val get : 'a t -> 'a option Lwt.t
+(** [get st] removes and returns the first element of the stream, if
+    any. *)
+
+val nget : int -> 'a t -> 'a list Lwt.t
+(** [nget n st] removes and returns at most the first [n] elements of
+    [st]. *)
+
+val get_while : ('a -> bool) -> 'a t -> 'a list Lwt.t
+
+val get_while_s : ('a -> bool Lwt.t) -> 'a t -> 'a list Lwt.t
+(** [get_while f st] returns the longest prefix of [st] where all
+    elements satisfy [f]. *)
+
+val next : 'a t -> 'a Lwt.t
+(** [next st] removes and returns the next element of the stream or
+    fails with {!Empty}, if the stream is empty. *)
+
+val last_new : 'a t -> 'a Lwt.t
+(** [last_new st] returns the last element that can be obtained
+    without sleeping, or wait for one if none is available.
+
+    It fails with {!Empty} if the stream has no more elements. *)
+
+val junk : 'a t -> unit Lwt.t
+(** [junk st] removes the first element of [st]. *)
+
+val njunk : int -> 'a t -> unit Lwt.t
+(** [njunk n st] removes at most the first [n] elements of the
+    stream. *)
+
+val junk_while : ('a -> bool) -> 'a t -> unit Lwt.t
+
+val junk_while_s : ('a -> bool Lwt.t) -> 'a t -> unit Lwt.t
+(** [junk_while f st] removes all elements at the beginning of the
+    streams which satisfy [f]. *)
+
+val junk_available : 'a t -> unit
+(** [junk_available st] removes all elements that are ready to be read
+    without yielding from [st]. *)
+
+val get_available : 'a t -> 'a list
+(** [get_available st] returns all available elements of [l] without
+    blocking. *)
+
+val get_available_up_to : int -> 'a t -> 'a list
+(** [get_available_up_to n st] returns up to [n] elements of [l]
+    without blocking. *)
+
+val is_empty : 'a t -> bool Lwt.t
+(** [is_empty st] returns whether the given stream is empty. *)
+
+val is_closed : 'a t -> bool
+(** [is_closed st] returns whether the given stream has been closed. A closed
+    stream is not necessarily empty. It may still contain unread elements. If
+    [is_closed s = true], then all subsequent reads until the end of the
+    stream are guaranteed not to block.
+
+    @since 2.6.0 *)
+
+val closed : 'a t -> unit Lwt.t
+(** [closed st] returns a thread that will sleep until the stream has been
+    closed.
+
+    @since 2.6.0 *)
+
+(** {3 Deprecated} *)
+
+val junk_old : 'a t -> unit Lwt.t
+[@@deprecated "Use junk_available instead"]
+(** @deprecated [junk_old st] is [Lwt.return (junk_available st)]. *)
+
+(** {2 Stream transversal} *)
+
+(** Note: all the following functions are destructive.
+
+    For example:
+
+    {[
+      # let st1 = Lwt_stream.of_list [1; 2; 3];;
+      val st1 : int Lwt_stream.t = <abstr>
+      # let st2 = Lwt_stream.map string_of_int st1;;
+      val st2 : string Lwt_stream.t = <abstr>
+      # lwt x = Lwt_stream.next st1;;
+      val x : int = 1
+      # lwt y = Lwt_stream.next st2;;
+      val y : string = "2"
+    ]}
+*)
+
+val choose : 'a t list -> 'a t
+(** [choose l] creates an stream from a list of streams. The
+    resulting stream will return elements returned by any stream of
+    [l] in an unspecified order. *)
+
+val map : ('a -> 'b) -> 'a t -> 'b t
+
+val map_s : ('a -> 'b Lwt.t) -> 'a t -> 'b t
+(** [map f st] maps the value returned by [st] with [f] *)
+
+val filter : ('a -> bool) -> 'a t -> 'a t
+
+val filter_s : ('a -> bool Lwt.t) -> 'a t -> 'a t
+(** [filter f st] keeps only values, [x], such that [f x] is [true] *)
+
+val filter_map : ('a -> 'b option) -> 'a t -> 'b t
+
+val filter_map_s : ('a -> 'b option Lwt.t) -> 'a t -> 'b t
+(** [filter_map f st] filter and map [st] at the same time *)
+
+val map_list : ('a -> 'b list) -> 'a t -> 'b t
+
+val map_list_s : ('a -> 'b list Lwt.t) -> 'a t -> 'b t
+(** [map_list f st] applies [f] on each element of [st] and flattens
+    the lists returned *)
+
+val fold : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b Lwt.t
+
+val fold_s : ('a -> 'b -> 'b Lwt.t) -> 'a t -> 'b -> 'b Lwt.t
+(** [fold f s x] fold_like function for streams. *)
+
+val iter : ('a -> unit) -> 'a t -> unit Lwt.t
+val iter_p : ('a -> unit Lwt.t) -> 'a t -> unit Lwt.t
+
+val iter_s : ('a -> unit Lwt.t) -> 'a t -> unit Lwt.t
+(** [iter f s] iterates over all elements of the stream. *)
+
+val iter_n : ?max_concurrency:int -> ('a -> unit Lwt.t) -> 'a t -> unit Lwt.t
+(** [iter_n ?max_concurrency f s] iterates over all elements of the stream [s].
+    Iteration is performed concurrently with up to [max_threads] concurrent
+    instances of [f].
+
+    Iteration is {b not} guaranteed to be in order as this function will
+    attempt to always process [max_concurrency] elements from [s] at once.
+
+    @param max_concurrency defaults to [1].
+    @raise Invalid_argument if [max_concurrency < 1].
+    @since 3.3.0 *)
+
+val find : ('a -> bool) -> 'a t -> 'a option Lwt.t
+
+val find_s : ('a -> bool Lwt.t) -> 'a t -> 'a option Lwt.t
+(** [find f s] find an element in a stream. *)
+
+val find_map : ('a -> 'b option) -> 'a t -> 'b option Lwt.t
+
+val find_map_s : ('a -> 'b option Lwt.t) -> 'a t -> 'b option Lwt.t
+(** [find_map f s] find and map at the same time. *)
+
+val combine : 'a t -> 'b t -> ('a * 'b) t
+(** [combine s1 s2] combines two streams. The stream will end when
+    either stream ends. *)
+
+val append : 'a t -> 'a t -> 'a t
+(** [append s1 s2] returns a stream which returns all elements of
+    [s1], then all elements of [s2] *)
+
+val concat : 'a t t -> 'a t
+(** [concat st] returns the concatenation of all streams of [st]. *)
+
+val flatten : 'a list t -> 'a t
+(** [flatten st = map_list (fun l -> l) st] *)
+
+val wrap_exn : 'a t -> ('a, exn) result t
+(** [wrap_exn s] is a stream [s'] such that each time [s] yields a value [v],
+    [s'] yields [Result.Ok v], and when the source of [s] raises an exception
+    [e], [s'] yields [Result.Error e].
+
+    Note that push-streams (as returned by {!create}) never raise exceptions.
+
+    If the stream source keeps raising the same exception [e] each time the
+    stream is read, [s'] is unbounded. Reading it will produce [Result.Error e]
+    indefinitely.
+
+    @since 2.7.0 *)
+
+(** {2 Parsing} *)
+
+val parse : 'a t -> ('a t -> 'b Lwt.t) -> 'b Lwt.t
+(** [parse st f] parses [st] with [f]. If [f] raise an exception,
+    [st] is restored to its previous state.
+
+    It raises [Invalid_argument] if [st] is a bounded
+    push-stream. *)
+
+(** {2 Misc} *)
+
+val hexdump : char t -> string t
+(** [hexdump byte_stream] returns a stream which is the same as the
+    output of [hexdump -C].
+
+    Basically, here is a simple implementation of [hexdump -C]:
+
+    {[
+      let () = Lwt_main.run begin
+          Lwt_io.write_lines
+            Lwt_io.stdout
+            (Lwt_stream.hexdump (Lwt_io.read_lines Lwt_io.stdin))
+        end
+    ]}
+*)

From 4e49c2a3719a91a05c8c5fb55ec60b50035abf67 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Wed, 27 Aug 2025 15:28:31 +0200
Subject: [PATCH 02/21] ocamlformating

---
 src/lib/eliom_client_main.eliom     |   2 +-
 src/lib/eliom_comet.server.ml       |   3 +-
 src/lib/eliom_content.eliom         |   4 +-
 src/lib/eliom_cscache.eliom         |   1 -
 src/lib/eliom_form.eliom            | 180 +++++++++++++++++++++++-----
 src/lib/eliom_form.eliomi           |   2 +-
 src/lib/eliom_service_base.eliom    |  43 ++++---
 src/lib/eliom_shared.eliom          | 140 ++++++++++++++--------
 src/lib/eliom_shared_content.eliom  |   4 +-
 src/lib/eliom_shared_content.eliomi |   2 +-
 src/lib/eliom_tools.eliom           |  19 ++-
 src/lib/eliom_tools.eliomi          |   2 +-
 12 files changed, 294 insertions(+), 108 deletions(-)

diff --git a/src/lib/eliom_client_main.eliom b/src/lib/eliom_client_main.eliom
index 3328cebfc9..6049674d32 100644
--- a/src/lib/eliom_client_main.eliom
+++ b/src/lib/eliom_client_main.eliom
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 let%client _ = Eliom_client.init ()
 
diff --git a/src/lib/eliom_comet.server.ml b/src/lib/eliom_comet.server.ml
index 73e890c6c9..930dc50de9 100644
--- a/src/lib/eliom_comet.server.ml
+++ b/src/lib/eliom_comet.server.ml
@@ -598,7 +598,8 @@ end = struct
     try Hashtbl.find handler_ref_table scope_hierarchy
     with Not_found ->
       let eref =
-        Eliom_reference.Volatile.eref ~scope:(`Client_process scope_hierarchy) None
+        Eliom_reference.Volatile.eref ~scope:(`Client_process scope_hierarchy)
+          None
       in
       Hashtbl.add handler_ref_table scope_hierarchy eref;
       eref
diff --git a/src/lib/eliom_content.eliom b/src/lib/eliom_content.eliom
index 08bc84fb17..249a620540 100644
--- a/src/lib/eliom_content.eliom
+++ b/src/lib/eliom_content.eliom
@@ -15,7 +15,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 [%%shared type boxed]
 
@@ -55,7 +55,7 @@ module Svg = struct
            let client_boxed = ~%client_boxed in
            let real = Svg.To_dom.of_element (unboxed client_boxed) in
            Js.Opt.iter dummy_dom##.parentNode (fun parent ->
-             parent ## (replaceChild real dummy_dom))
+             parent##(replaceChild real dummy_dom))
            : unit)]
       in
       init
diff --git a/src/lib/eliom_cscache.eliom b/src/lib/eliom_cscache.eliom
index 5a7287b3fc..1262fb0899 100644
--- a/src/lib/eliom_cscache.eliom
+++ b/src/lib/eliom_cscache.eliom
@@ -37,7 +37,6 @@ let%server find cache get_data id =
   with Not_found ->
     let th =
       let* v = get_data id in
-
       ignore [%client.unsafe (do_cache ~%cache ~%id ~%v : unit)];
       Lwt.return v
     in
diff --git a/src/lib/eliom_form.eliom b/src/lib/eliom_form.eliom
index 5d75aee819..b15d39df86 100644
--- a/src/lib/eliom_form.eliom
+++ b/src/lib/eliom_form.eliom
@@ -16,10 +16,12 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 open%shared Js_of_ocaml
+
 [%%client.start]
+
 open Lwt.Syntax
 
 let read_params form y =
@@ -100,8 +102,17 @@ let get_xhr = function
 module Make_links (Html : Html) = struct
   type +'a attrib = 'a Html.attrib
 
-  let make_uri ?absolute ?absolute_path ?https ~service ?hostname ?port
-      ?fragment ?keep_nl_params ?nl_params gp
+  let make_uri
+        ?absolute
+        ?absolute_path
+        ?https
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?keep_nl_params
+        ?nl_params
+        gp
     =
     Html.uri_of_fun @@ fun () ->
     Eliom_uri.make_string_uri ?absolute ?absolute_path ?https ?fragment ~service
@@ -109,8 +120,20 @@ module Make_links (Html : Html) = struct
 
   let uri_of_string = Html.uri_of_fun
 
-  let a ?absolute ?absolute_path ?https ?(a = []) ~service ?hostname ?port
-      ?fragment ?keep_nl_params ?nl_params ?xhr content getparams
+  let a
+        ?absolute
+        ?absolute_path
+        ?https
+        ?(a = [])
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?keep_nl_params
+        ?nl_params
+        ?xhr
+        content
+        getparams
     =
     let a =
       let a = (a :> Html_types.a_attrib attrib list) in
@@ -230,9 +253,20 @@ module Make (Html : Html) = struct
 
   let make_post_uri_components = Eliom_uri.make_post_uri_components
 
-  let get_form_ bind return ?absolute ?absolute_path ?https ?a ~service
-      ?hostname ?port ?fragment
-      ?(nl_params = Eliom_parameter.empty_nl_params_set) ?keep_nl_params f
+  let get_form_
+        bind
+        return
+        ?absolute
+        ?absolute_path
+        ?https
+        ?a
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?(nl_params = Eliom_parameter.empty_nl_params_set)
+        ?keep_nl_params
+        f
     =
     let issuffix, paramnames =
       Eliom_parameter.make_params_names (Eliom_service.get_params_type service)
@@ -275,8 +309,19 @@ module Make (Html : Html) = struct
     in
     return (Html.lazy_form ~a inside)
 
-  let get_form ?absolute ?absolute_path ?https ?a ~service ?hostname ?port
-      ?fragment ?keep_nl_params ?nl_params ?xhr:_ f
+  let get_form
+        ?absolute
+        ?absolute_path
+        ?https
+        ?a
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?keep_nl_params
+        ?nl_params
+        ?xhr:_
+        f
     =
     get_form_
       (fun x f -> f x)
@@ -284,11 +329,22 @@ module Make (Html : Html) = struct
       ?absolute ?absolute_path ?https ?a ~service ?keep_nl_params ?nl_params
       ?hostname ?port ?fragment f
 
-  let post_form_ bind return ?absolute ?absolute_path ?https ?a ~service
-      ?hostname ?port ?fragment
-      ?(nl_params = Eliom_parameter.empty_nl_params_set)
-      ?(keep_nl_params : [`All | `Persistent | `None] option)
-      ?keep_get_na_params f get_params
+  let post_form_
+        bind
+        return
+        ?absolute
+        ?absolute_path
+        ?https
+        ?a
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?(nl_params = Eliom_parameter.empty_nl_params_set)
+        ?(keep_nl_params : [`All | `Persistent | `None] option)
+        ?keep_get_na_params
+        f
+        get_params
     =
     let _, paramnames =
       Eliom_parameter.make_params_names (Eliom_service.post_params_type service)
@@ -316,9 +372,21 @@ module Make (Html : Html) = struct
     in
     return (make_post_form ?a ~action inside)
 
-  let post_form ?absolute ?absolute_path ?https ?a ~service ?hostname ?port
-      ?fragment ?keep_nl_params ?keep_get_na_params ?nl_params ?xhr:_ f
-      getparams
+  let post_form
+        ?absolute
+        ?absolute_path
+        ?https
+        ?a
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?keep_nl_params
+        ?keep_get_na_params
+        ?nl_params
+        ?xhr:_
+        f
+        getparams
     =
     post_form_
       (fun x f -> f x)
@@ -402,8 +470,14 @@ module Make (Html : Html) = struct
         * 'a soption list
     | Option of 'a soption
 
-  let gen_select ?a ?(multiple = false) ?required ~name (fl : 'a select_opt)
-      (ol : 'a select_opt list) string_of
+  let gen_select
+        ?a
+        ?(multiple = false)
+        ?required
+        ~name
+        (fl : 'a select_opt)
+        (ol : 'a select_opt list)
+        string_of
     =
     let a = (a :> Html_types.select_attrib attrib list option) in
     let a =
@@ -512,8 +586,19 @@ module Make (Html : Html) = struct
 
   let a_onsubmit_service info = Html.attrib_of_service "onsubmit" info
 
-  let get_form ?absolute ?absolute_path ?https ?(a = []) ~service ?hostname
-      ?port ?fragment ?keep_nl_params ?nl_params ?xhr contents
+  let get_form
+        ?absolute
+        ?absolute_path
+        ?https
+        ?(a = [])
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?keep_nl_params
+        ?nl_params
+        ?xhr
+        contents
     =
     let a =
       let a = (a :> Html_types.form_attrib attrib list) in
@@ -529,8 +614,19 @@ module Make (Html : Html) = struct
     get_form ?absolute ?absolute_path ?https ~a ~service ?hostname ?port
       ?fragment ?keep_nl_params ?nl_params contents
 
-  let lwt_get_form ?absolute ?absolute_path ?https ?(a = []) ~service ?hostname
-      ?port ?fragment ?keep_nl_params ?nl_params ?xhr contents
+  let lwt_get_form
+        ?absolute
+        ?absolute_path
+        ?https
+        ?(a = [])
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?keep_nl_params
+        ?nl_params
+        ?xhr
+        contents
     =
     let a =
       let a = (a :> Html_types.form_attrib attrib list) in
@@ -546,9 +642,21 @@ module Make (Html : Html) = struct
     get_form_ Lwt.bind Lwt.return ?absolute ?absolute_path ?https ~a ~service
       ?hostname ?port ?fragment ?nl_params ?keep_nl_params contents
 
-  let post_form ?absolute ?absolute_path ?https ?(a = []) ~service ?hostname
-      ?port ?fragment ?keep_nl_params ?keep_get_na_params ?nl_params ?xhr
-      contents getparams
+  let post_form
+        ?absolute
+        ?absolute_path
+        ?https
+        ?(a = [])
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?keep_nl_params
+        ?keep_get_na_params
+        ?nl_params
+        ?xhr
+        contents
+        getparams
     =
     let a =
       let a = (a :> Html_types.form_attrib attrib list) in
@@ -566,9 +674,21 @@ module Make (Html : Html) = struct
       ?fragment ?keep_nl_params ?keep_get_na_params ?nl_params contents
       getparams
 
-  let lwt_post_form ?absolute ?absolute_path ?https ?(a = []) ~service ?hostname
-      ?port ?fragment ?keep_nl_params ?keep_get_na_params ?nl_params ?xhr
-      contents getparams
+  let lwt_post_form
+        ?absolute
+        ?absolute_path
+        ?https
+        ?(a = [])
+        ~service
+        ?hostname
+        ?port
+        ?fragment
+        ?keep_nl_params
+        ?keep_get_na_params
+        ?nl_params
+        ?xhr
+        contents
+        getparams
     =
     let a =
       let a = (a :> Html_types.form_attrib attrib list) in
diff --git a/src/lib/eliom_form.eliomi b/src/lib/eliom_form.eliomi
index 674b562012..9998309c5e 100644
--- a/src/lib/eliom_form.eliomi
+++ b/src/lib/eliom_form.eliomi
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 [%%client.start]
 
diff --git a/src/lib/eliom_service_base.eliom b/src/lib/eliom_service_base.eliom
index bfe84a5b3e..9e0014e5b7 100644
--- a/src/lib/eliom_service_base.eliom
+++ b/src/lib/eliom_service_base.eliom
@@ -15,7 +15,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 (* Manipulation of services - this code can be use on server or client side. *)
 
@@ -27,18 +27,17 @@ module Url = Eliom_lib.Url
 
 type suff = [`WithSuffix | `WithoutSuffix]
 
-let params_of_meth :
-    type m gp gn pp pn x.
-    (m, gp, gn, pp, pn, 'tipo, x) meth
-    -> (gp, 'tipo, gn) params * (pp, [`WithoutSuffix], pn) params
+let params_of_meth : type m gp gn pp pn x.
+  (m, gp, gn, pp, pn, 'tipo, x) meth
+  -> (gp, 'tipo, gn) params * (pp, [`WithoutSuffix], pn) params
   = function
   | Get gp -> gp, Eliom_parameter.unit
   | Post (gp, pp) -> gp, pp
   | Put gp -> gp, Eliom_parameter.raw_post_data
   | Delete gp -> gp, Eliom_parameter.raw_post_data
 
-let which_meth_internal :
-    type m gp gn pp pn tipo x. (m, gp, gn, pp, pn, tipo, x) meth -> m which_meth
+let which_meth_internal : type m gp gn pp pn tipo x.
+  (m, gp, gn, pp, pn, tipo, x) meth -> m which_meth
   = function
   | Get _ -> Get'
   | Post _ -> Post'
@@ -75,7 +74,7 @@ type att =
 type non_att =
   { na_name : Eliom_common.na_key_serv
   ; keep_get_na_params : bool
-  (* bool is used only for post and means "keep_get_na_params": do we
+    (* bool is used only for post and means "keep_get_na_params": do we
      keep GET non-attached parameters in links (if any) (31/12/2007 -
      experimental - WAS: 'a, but may be removed (was not used)) *)
   }
@@ -123,7 +122,7 @@ type ('get
       (string * Eliommod_parameters.param) list Eliom_lib.String.Table.t
       (* non localized parameters *)
       * (string * Eliommod_parameters.param) list
-        (* regular parameters *)
+    (* regular parameters *)
   ; get_params_type : ('get, 'tipo, 'getnames) Eliom_parameter.params_type
   ; post_params_type :
       ('post, [`WithoutSuffix], 'postnames) Eliom_parameter.params_type
@@ -140,13 +139,13 @@ type ('get
   ; (* force https *)
     keep_nl_params : [`All | `Persistent | `None]
   ; mutable send_appl_content : send_appl_content
-        (* XNever when we create the service, then changed at registration
+    (* XNever when we create the service, then changed at registration
      :/ *)
   ; (* If the service has a client-side implementation, we put the
      generating function here: *)
     mutable client_fun :
       ('get -> 'post -> result Lwt.t) option ref Eliom_client_value.t option
-        (* The function is in a client-side reference, so that it is shared
+    (* The function is in a client-side reference, so that it is shared
      by all occurrences of the service sent from the server.
      For some service, we cannot create the client value immediately;
      this is done later on using [internal_set_client_fun].  *)
@@ -208,8 +207,9 @@ let timeout s = s.timeout
 let https s = s.https
 let priority s = s.priority
 
-let internal_set_client_fun ~service
-    (f : ('get -> 'post -> result Lwt.t) Eliom_client_value.t)
+let internal_set_client_fun
+      ~service
+      (f : ('get -> 'post -> result Lwt.t) Eliom_client_value.t)
   =
   service.client_fun <- Some [%client.unsafe ref (Some ~%f)]
 
@@ -473,9 +473,20 @@ let%client no_client_fun () : _ ref Eliom_client_value.t option =
   Some (ref None)
 
 (** Create a main service (not a coservice), internal or external *)
-let main_service ~https ~prefix ~(path : Url.path) ?force_site_dir ~kind ~meth
-    ?(redirect_suffix = true) ?(keep_nl_params = `None)
-    ?(priority = default_priority) ~get_params ~post_params ~reload_fun ()
+let main_service
+      ~https
+      ~prefix
+      ~(path : Url.path)
+      ?force_site_dir
+      ~kind
+      ~meth
+      ?(redirect_suffix = true)
+      ?(keep_nl_params = `None)
+      ?(priority = default_priority)
+      ~get_params
+      ~post_params
+      ~reload_fun
+      ()
   =
   { pre_applied_parameters = Eliom_lib.String.Table.empty, []
   ; get_params_type = get_params
diff --git a/src/lib/eliom_shared.eliom b/src/lib/eliom_shared.eliom
index 14f33aef9c..8156139a85 100644
--- a/src/lib/eliom_shared.eliom
+++ b/src/lib/eliom_shared.eliom
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 [%%shared
 open Lwt.Syntax
@@ -383,17 +383,22 @@ module React = struct
         (FakeReact.S.map (Value.local f) (Value.local s))
         [%client.unsafe (FakeReact.S.map ?eq:~%eq ~%f ~%s : 'b FakeReact.S.t)]
 
-    let fmap ?(eq : ('b -> 'b -> bool) Value.t option)
-        (f : ('a -> 'b option) Value.t) (i : 'b Value.t)
-        (s : 'a FakeReact.S.t Value.t) : 'b t
+    let fmap
+          ?(eq : ('b -> 'b -> bool) Value.t option)
+          (f : ('a -> 'b option) Value.t)
+          (i : 'b Value.t)
+          (s : 'a FakeReact.S.t Value.t) : 'b t
       =
       Value.create
         (FakeReact.S.fmap (Value.local f) (Value.local i) (Value.local s))
         [%client.unsafe
           (FakeReact.S.fmap ?eq:~%eq ~%f ~%i ~%s : 'b FakeReact.S.t)]
 
-    let merge ?eq (f : ('a -> 'b -> 'a) Value.t) (acc : 'a)
-        (l : 'b FakeReact.S.t Value.t list) : 'a t
+    let merge
+          ?eq
+          (f : ('a -> 'b -> 'a) Value.t)
+          (acc : 'a)
+          (l : 'b FakeReact.S.t Value.t list) : 'a t
       =
       Value.create
         (FakeReact.S.merge (Value.local f) acc (List.map Value.local l))
@@ -405,16 +410,22 @@ module React = struct
         (FakeReact.S.const ~synced:true v)
         [%client.unsafe (React.S.const ~%v : 'a FakeReact.S.t)]
 
-    let l2 ?eq (f : ('a -> 'b -> 'c) Value.t) (s1 : 'a FakeReact.S.t Value.t)
-        (s2 : 'b FakeReact.S.t Value.t) : 'c t
+    let l2
+          ?eq
+          (f : ('a -> 'b -> 'c) Value.t)
+          (s1 : 'a FakeReact.S.t Value.t)
+          (s2 : 'b FakeReact.S.t Value.t) : 'c t
       =
       Value.create
         (FakeReact.S.l2 (Value.local f) (Value.local s1) (Value.local s2))
         [%client.unsafe (React.S.l2 ?eq:~%eq ~%f ~%s1 ~%s2 : 'd FakeReact.S.t)]
 
-    let l3 ?eq (f : ('a -> 'b -> 'c -> 'd) Value.t)
-        (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t)
-        (s3 : 'c FakeReact.S.t Value.t) : 'd t
+    let l3
+          ?eq
+          (f : ('a -> 'b -> 'c -> 'd) Value.t)
+          (s1 : 'a FakeReact.S.t Value.t)
+          (s2 : 'b FakeReact.S.t Value.t)
+          (s3 : 'c FakeReact.S.t Value.t) : 'd t
       =
       Value.create
         (FakeReact.S.l3 (Value.local f) (Value.local s1) (Value.local s2)
@@ -422,9 +433,13 @@ module React = struct
         [%client.unsafe
           (React.S.l3 ?eq:~%eq ~%f ~%s1 ~%s2 ~%s3 : 'd FakeReact.S.t)]
 
-    let l4 ?eq (f : ('a -> 'b -> 'c -> 'd -> 'e) Value.t)
-        (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t)
-        (s3 : 'c FakeReact.S.t Value.t) (s4 : 'd FakeReact.S.t Value.t) : 'e t
+    let l4
+          ?eq
+          (f : ('a -> 'b -> 'c -> 'd -> 'e) Value.t)
+          (s1 : 'a FakeReact.S.t Value.t)
+          (s2 : 'b FakeReact.S.t Value.t)
+          (s3 : 'c FakeReact.S.t Value.t)
+          (s4 : 'd FakeReact.S.t Value.t) : 'e t
       =
       Value.create
         (FakeReact.S.l4 (Value.local f) (Value.local s1) (Value.local s2)
@@ -432,10 +447,14 @@ module React = struct
         [%client.unsafe
           (React.S.l4 ?eq:~%eq ~%f ~%s1 ~%s2 ~%s3 ~%s4 : 'e FakeReact.S.t)]
 
-    let l5 ?eq (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f) Value.t)
-        (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t)
-        (s3 : 'c FakeReact.S.t Value.t) (s4 : 'd FakeReact.S.t Value.t)
-        (s5 : 'e FakeReact.S.t Value.t) : 'f t
+    let l5
+          ?eq
+          (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f) Value.t)
+          (s1 : 'a FakeReact.S.t Value.t)
+          (s2 : 'b FakeReact.S.t Value.t)
+          (s3 : 'c FakeReact.S.t Value.t)
+          (s4 : 'd FakeReact.S.t Value.t)
+          (s5 : 'e FakeReact.S.t Value.t) : 'f t
       =
       Value.create
         (FakeReact.S.l5 (Value.local f) (Value.local s1) (Value.local s2)
@@ -443,10 +462,15 @@ module React = struct
         [%client.unsafe
           (React.S.l5 ?eq:~%eq ~%f ~%s1 ~%s2 ~%s3 ~%s4 ~%s5 : 'f FakeReact.S.t)]
 
-    let l6 ?eq (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g) Value.t)
-        (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t)
-        (s3 : 'c FakeReact.S.t Value.t) (s4 : 'd FakeReact.S.t Value.t)
-        (s5 : 'e FakeReact.S.t Value.t) (s6 : 'f FakeReact.S.t Value.t) : 'g t
+    let l6
+          ?eq
+          (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g) Value.t)
+          (s1 : 'a FakeReact.S.t Value.t)
+          (s2 : 'b FakeReact.S.t Value.t)
+          (s3 : 'c FakeReact.S.t Value.t)
+          (s4 : 'd FakeReact.S.t Value.t)
+          (s5 : 'e FakeReact.S.t Value.t)
+          (s6 : 'f FakeReact.S.t Value.t) : 'g t
       =
       Value.create
         (FakeReact.S.l6 (Value.local f) (Value.local s1) (Value.local s2)
@@ -472,8 +496,10 @@ module React = struct
     end
 
     module Lwt = struct
-      let map_s ?eq (f : ('a -> 'b Lwt.t) Value.t)
-          (s : 'a FakeReact.S.t Value.t) : 'b t Lwt.t
+      let map_s
+            ?eq
+            (f : ('a -> 'b Lwt.t) Value.t)
+            (s : 'a FakeReact.S.t Value.t) : 'b t Lwt.t
         =
         let s' = Value.local s in
         let* server_result = (Value.local f) (FakeReact.S.value s') in
@@ -485,9 +511,11 @@ module React = struct
                (React.S.Lwt.map_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s
                 : 'b FakeReact.S.t)])
 
-      let l2_s ?eq (f : ('a -> 'b -> 'c Lwt.t) Value.t)
-          (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t) :
-          'c t Lwt.t
+      let l2_s
+            ?eq
+            (f : ('a -> 'b -> 'c Lwt.t) Value.t)
+            (s1 : 'a FakeReact.S.t Value.t)
+            (s2 : 'b FakeReact.S.t Value.t) : 'c t Lwt.t
         =
         let s1' = Value.local s1 and s2' = Value.local s2 in
         let* server_result =
@@ -502,9 +530,12 @@ module React = struct
                   ~%s2
                 : 'c FakeReact.S.t)])
 
-      let l3_s ?eq (f : ('a -> 'b -> 'c -> 'd Lwt.t) Value.t)
-          (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t)
-          (s3 : 'c FakeReact.S.t Value.t) : 'd t Lwt.t
+      let l3_s
+            ?eq
+            (f : ('a -> 'b -> 'c -> 'd Lwt.t) Value.t)
+            (s1 : 'a FakeReact.S.t Value.t)
+            (s2 : 'b FakeReact.S.t Value.t)
+            (s3 : 'c FakeReact.S.t Value.t) : 'd t Lwt.t
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
@@ -522,10 +553,13 @@ module React = struct
                   ~%s2 ~%s3
                 : 'd FakeReact.S.t)])
 
-      let l4_s ?eq (f : ('a -> 'b -> 'c -> 'd -> 'e Lwt.t) Value.t)
-          (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t)
-          (s3 : 'c FakeReact.S.t Value.t) (s4 : 'd FakeReact.S.t Value.t) :
-          'e t Lwt.t
+      let l4_s
+            ?eq
+            (f : ('a -> 'b -> 'c -> 'd -> 'e Lwt.t) Value.t)
+            (s1 : 'a FakeReact.S.t Value.t)
+            (s2 : 'b FakeReact.S.t Value.t)
+            (s3 : 'c FakeReact.S.t Value.t)
+            (s4 : 'd FakeReact.S.t Value.t) : 'e t Lwt.t
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
@@ -546,10 +580,14 @@ module React = struct
                   ~%s2 ~%s3 ~%s4
                 : 'e FakeReact.S.t)])
 
-      let l5_s ?eq (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f Lwt.t) Value.t)
-          (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t)
-          (s3 : 'c FakeReact.S.t Value.t) (s4 : 'd FakeReact.S.t Value.t)
-          (s5 : 'e FakeReact.S.t Value.t) : 'f t Lwt.t
+      let l5_s
+            ?eq
+            (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f Lwt.t) Value.t)
+            (s1 : 'a FakeReact.S.t Value.t)
+            (s2 : 'b FakeReact.S.t Value.t)
+            (s3 : 'c FakeReact.S.t Value.t)
+            (s4 : 'd FakeReact.S.t Value.t)
+            (s5 : 'e FakeReact.S.t Value.t) : 'f t Lwt.t
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
@@ -573,11 +611,15 @@ module React = struct
                   ~%s2 ~%s3 ~%s4 ~%s5
                 : 'f FakeReact.S.t)])
 
-      let l6_s ?eq (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g Lwt.t) Value.t)
-          (s1 : 'a FakeReact.S.t Value.t) (s2 : 'b FakeReact.S.t Value.t)
-          (s3 : 'c FakeReact.S.t Value.t) (s4 : 'd FakeReact.S.t Value.t)
-          (s5 : 'e FakeReact.S.t Value.t) (s6 : 'f FakeReact.S.t Value.t) :
-          'g t Lwt.t
+      let l6_s
+            ?eq
+            (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g Lwt.t) Value.t)
+            (s1 : 'a FakeReact.S.t Value.t)
+            (s2 : 'b FakeReact.S.t Value.t)
+            (s3 : 'c FakeReact.S.t Value.t)
+            (s4 : 'd FakeReact.S.t Value.t)
+            (s5 : 'e FakeReact.S.t Value.t)
+            (s6 : 'f FakeReact.S.t Value.t) : 'g t Lwt.t
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
@@ -603,8 +645,11 @@ module React = struct
                   ~%s2 ~%s3 ~%s4 ~%s5 ~%s6
                 : 'g FakeReact.S.t)])
 
-      let merge_s ?eq (f : ('a -> 'b -> 'a Lwt.t) Value.t) (acc : 'a)
-          (l : 'b FakeReact.S.t Value.t list) : 'a t Lwt.t
+      let merge_s
+            ?eq
+            (f : ('a -> 'b -> 'a Lwt.t) Value.t)
+            (acc : 'a)
+            (l : 'b FakeReact.S.t Value.t list) : 'a t Lwt.t
         =
         let* server_result, synced =
           let f (acc, _acc_b) v =
@@ -718,8 +763,9 @@ module ReactiveData = struct
     let synced s = Value.local s |> FakeReactiveData.RList.synced
 
     module Lwt = struct
-      let map_p (f : ('a -> 'b Lwt.t) Value.t)
-          (l : 'a FakeReactiveData.RList.t Value.t) : 'b t Lwt.t
+      let map_p
+            (f : ('a -> 'b Lwt.t) Value.t)
+            (l : 'a FakeReactiveData.RList.t Value.t) : 'b t Lwt.t
         =
         let l' = Value.local l in
         let* server_result =
diff --git a/src/lib/eliom_shared_content.eliom b/src/lib/eliom_shared_content.eliom
index 84a48f9ea2..f260f274f7 100644
--- a/src/lib/eliom_shared_content.eliom
+++ b/src/lib/eliom_shared_content.eliom
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 open%shared Js_of_ocaml
 
@@ -135,7 +135,7 @@ module Xml = struct
            Js.Opt.case e##.firstChild
              (fun () ->
                 Dom.appendChild e
-                  Dom_html.document ## (createTextNode (Js.string x)))
+                  Dom_html.document##(createTextNode (Js.string x)))
              (fun e -> Dom.CoerceTo.text e >>! fun e -> e##.data := Js.string x)
          in
          if not ~%synced then update (React.S.value ~%s);
diff --git a/src/lib/eliom_shared_content.eliomi b/src/lib/eliom_shared_content.eliomi
index d4ff6555d6..5ed5c7092d 100644
--- a/src/lib/eliom_shared_content.eliomi
+++ b/src/lib/eliom_shared_content.eliomi
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 open Js_of_ocaml
 
diff --git a/src/lib/eliom_tools.eliom b/src/lib/eliom_tools.eliom
index 172a2c65c1..d4d84ff657 100644
--- a/src/lib/eliom_tools.eliom
+++ b/src/lib/eliom_tools.eliom
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 [%%shared.start]
 
@@ -349,8 +349,13 @@ module Make (DorF : module type of Eliom_content.Html.F) : HTML5_TOOLS = struct
     try aux service 0 pages
     with Not_found -> find_longest_prefix_in_hierarchy service (main, pages)
 
-  let hierarchical_menu_depth_first ?(classe = []) ?id ?(whole_tree = false)
-      ((_page, pages) as the_menu) ?service ()
+  let hierarchical_menu_depth_first
+        ?(classe = [])
+        ?id
+        ?(whole_tree = false)
+        ((_page, pages) as the_menu)
+        ?service
+        ()
     =
     let rec depth_first_fun pages level pos : [`Ul] elt list =
       let rec one_item first last i s =
@@ -410,8 +415,12 @@ module Make (DorF : module type of Eliom_content.Html.F) : HTML5_TOOLS = struct
       : [`Ul] elt list
       :> [> `Ul] elt list)
 
-  let hierarchical_menu_breadth_first ?(classe = []) ?id
-      ((_page, pages) as the_menu) ?service ()
+  let hierarchical_menu_breadth_first
+        ?(classe = [])
+        ?id
+        ((_page, pages) as the_menu)
+        ?service
+        ()
     =
     let rec breadth_first_fun pages level pos : [`Ul] elt list =
       let rec one_item first last i s =
diff --git a/src/lib/eliom_tools.eliomi b/src/lib/eliom_tools.eliomi
index a2bb328c1f..aec2fd11f2 100644
--- a/src/lib/eliom_tools.eliomi
+++ b/src/lib/eliom_tools.eliomi
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *)
+*)
 
 [%%shared.start]
 

From 946d152bb87adc6d9f0adc36993c14d6b0fad11b Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Tue, 26 Aug 2025 16:34:48 +0200
Subject: [PATCH 03/21] Copy Lwt_react into Eio_react

---
 src/lib/eio_react.shared.ml  | 557 +++++++++++++++++++++++++++++++++++
 src/lib/eio_react.shared.mli | 261 ++++++++++++++++
 2 files changed, 818 insertions(+)
 create mode 100644 src/lib/eio_react.shared.ml
 create mode 100644 src/lib/eio_react.shared.mli

diff --git a/src/lib/eio_react.shared.ml b/src/lib/eio_react.shared.ml
new file mode 100644
index 0000000000..cec021132e
--- /dev/null
+++ b/src/lib/eio_react.shared.ml
@@ -0,0 +1,557 @@
+(* This file is part of Lwt, released under the MIT license. See LICENSE.md for
+   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
+
+open Lwt.Infix
+
+type 'a event = 'a React.event
+type 'a signal = 'a React.signal
+
+module E = struct
+  include React.E
+
+  (* +---------------------------------------------------------------+
+     | Lwt-specific utilities                                        |
+     +---------------------------------------------------------------+ *)
+
+  let finalise f _ = f ()
+
+  let with_finaliser f event =
+    let r = ref () in
+    Gc.finalise (finalise f) r;
+    map
+      (fun x ->
+         ignore (Sys.opaque_identity r);
+         x)
+      event
+
+  let next ev =
+    let waiter, wakener = Lwt.task () in
+    let ev = map (fun x -> Lwt.wakeup wakener x) (once ev) in
+    Lwt.on_cancel waiter (fun () -> stop ev);
+    waiter
+
+  let limit f e =
+    (* Thread which prevents [e] from occurring while it is sleeping *)
+    let limiter = ref Lwt.return_unit in
+    (* The occurrence that is delayed until the limiter returns. *)
+    let delayed = ref None in
+    (* The resulting event. *)
+    let event, push = create () in
+    let iter =
+      fmap
+        (fun x ->
+           if Lwt.is_sleeping !limiter
+           then (
+             (* The limiter is sleeping, we queue the event for later
+                delivering. *)
+             match !delayed with
+             | Some cell ->
+                 (* An occurrence is already queued, replace it. *)
+                 cell := x;
+                 None
+             | None ->
+                 let cell = ref x in
+                 delayed := Some cell;
+                 Lwt.on_success !limiter (fun () ->
+                   if Lwt.is_sleeping !limiter
+                   then delayed := None
+                   else
+                     let x = !cell in
+                     delayed := None;
+                     limiter := f ();
+                     push x);
+                 None)
+           else (
+             (* Set the limiter for future events. *)
+             limiter := f ();
+             (* Send the occurrence now. *)
+             push x;
+             None))
+        e
+    in
+    select [iter; event]
+
+  let cancel_thread t () = Lwt.cancel t
+
+  let from f =
+    let event, push = create () in
+    let rec loop () = f () >>= fun x -> push x; loop () in
+    let t = Lwt.pause () >>= loop in
+    with_finaliser (cancel_thread t) event
+
+  let to_stream event =
+    let stream, push, set_ref = Lwt_stream.create_with_reference () in
+    set_ref (map (fun x -> push (Some x)) event);
+    stream
+
+  let of_stream stream =
+    let event, push = create () in
+    let t =
+      Lwt.pause () >>= fun () ->
+      Lwt_stream.iter
+        (fun v ->
+           try push v
+           with exn when Lwt.Exception_filter.run exn ->
+             !Lwt.async_exception_hook exn)
+        stream
+    in
+    with_finaliser (cancel_thread t) event
+
+  let delay thread =
+    match Lwt.poll thread with
+    | Some e -> e
+    | None ->
+        let event, send = create () in
+        Lwt.on_success thread (fun e -> send e; stop event);
+        switch never event
+
+  let keeped = ref []
+  let keep e = keeped := map ignore e :: !keeped
+
+  (* +---------------------------------------------------------------+
+     | Event transformations                                         |
+     +---------------------------------------------------------------+ *)
+
+  let run_p e =
+    let event, push = create () in
+    let iter =
+      fmap
+        (fun t ->
+           Lwt.on_success t (fun v -> push v);
+           None)
+        e
+    in
+    select [iter; event]
+
+  let run_s e =
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun t ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> t))
+             (fun v -> push v);
+           None)
+        e
+    in
+    select [iter; event]
+
+  let map_p f e =
+    let event, push = create () in
+    let iter =
+      fmap
+        (fun x ->
+           Lwt.on_success (f x) (fun v -> push v);
+           None)
+        e
+    in
+    select [iter; event]
+
+  let map_s f e =
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun x ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (fun v -> push v);
+           None)
+        e
+    in
+    select [iter; event]
+
+  let app_p ef e =
+    let event, push = create () in
+    let iter =
+      fmap
+        (fun (f, x) ->
+           Lwt.on_success (f x) (fun v -> push v);
+           None)
+        (app (map (fun f x -> f, x) ef) e)
+    in
+    select [iter; event]
+
+  let app_s ef e =
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun (f, x) ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (fun v -> push v);
+           None)
+        (app (map (fun f x -> f, x) ef) e)
+    in
+    select [iter; event]
+
+  let filter_p f e =
+    let event, push = create () in
+    let iter =
+      fmap
+        (fun x ->
+           Lwt.on_success (f x) (function true -> push x | false -> ());
+           None)
+        e
+    in
+    select [iter; event]
+
+  let filter_s f e =
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun x ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (function true -> push x | false -> ());
+           None)
+        e
+    in
+    select [iter; event]
+
+  let fmap_p f e =
+    let event, push = create () in
+    let iter =
+      fmap
+        (fun x ->
+           Lwt.on_success (f x) (function Some x -> push x | None -> ());
+           None)
+        e
+    in
+    select [iter; event]
+
+  let fmap_s f e =
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun x ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (function Some x -> push x | None -> ());
+           None)
+        e
+    in
+    select [iter; event]
+
+  let diff_s f e =
+    let previous = ref None in
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun x ->
+           match !previous with
+           | None ->
+               previous := Some x;
+               None
+           | Some y ->
+               previous := Some x;
+               Lwt.on_success
+                 (Lwt_mutex.with_lock mutex (fun () -> f x y))
+                 (fun v -> push v);
+               None)
+        e
+    in
+    select [iter; event]
+
+  let accum_s ef acc =
+    let acc = ref acc in
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun f ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f !acc))
+             (fun x ->
+                acc := x;
+                push x);
+           None)
+        ef
+    in
+    select [iter; event]
+
+  let fold_s f acc e =
+    let acc = ref acc in
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun x ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f !acc x))
+             (fun x ->
+                acc := x;
+                push x);
+           None)
+        e
+    in
+    select [iter; event]
+
+  let rec rev_fold f acc = function
+    | [] -> Lwt.return acc
+    | x :: l -> rev_fold f acc l >>= fun acc -> f acc x
+
+  let merge_s f acc el =
+    let event, push = create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      fmap
+        (fun l ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> rev_fold f acc l))
+             (fun v -> push v);
+           None)
+        (merge (fun acc x -> x :: acc) [] el)
+    in
+    select [iter; event]
+end
+
+module S = struct
+  include React.S
+
+  (* +---------------------------------------------------------------+
+     | Lwt-specific utilities                                        |
+     +---------------------------------------------------------------+ *)
+
+  let finalise f _ = f ()
+
+  let with_finaliser f signal =
+    let r = ref () in
+    Gc.finalise (finalise f) r;
+    map
+      (fun x ->
+         ignore (Sys.opaque_identity r);
+         x)
+      signal
+
+  let limit ?eq f s =
+    (* Thread which prevent [s] to changes while it is sleeping *)
+    let limiter = ref (f ()) in
+    (* The occurrence that is delayed until the limiter returns. *)
+    let delayed = ref None in
+    (* The resulting event. *)
+    let event, push = E.create () in
+    let iter =
+      E.fmap
+        (fun x ->
+           if Lwt.is_sleeping !limiter
+           then (
+             (* The limiter is sleeping, we queue the event for later
+                delivering. *)
+             match !delayed with
+             | Some cell ->
+                 (* An occurrence is already queued, replace it. *)
+                 cell := x;
+                 None
+             | None ->
+                 let cell = ref x in
+                 delayed := Some cell;
+                 Lwt.on_success !limiter (fun () ->
+                   if Lwt.is_sleeping !limiter
+                   then delayed := None
+                   else
+                     let x = !cell in
+                     delayed := None;
+                     limiter := f ();
+                     push x);
+                 None)
+           else (
+             (* Set the limiter for future events. *)
+             limiter := f ();
+             (* Send the occurrence now. *)
+             push x;
+             None))
+        (changes s)
+    in
+    hold ?eq (value s) (E.select [iter; event])
+
+  let keeped = ref []
+  let keep s = keeped := map ignore s :: !keeped
+
+  (* +---------------------------------------------------------------+
+     | Signal transformations                                        |
+     +---------------------------------------------------------------+ *)
+
+  let run_s ?eq s =
+    let event, push = E.create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      E.fmap
+        (fun t ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> t))
+             (fun v -> push v);
+           None)
+        (changes s)
+    in
+    Lwt_mutex.with_lock mutex (fun () -> value s) >>= fun x ->
+    Lwt.return (hold ?eq x (E.select [iter; event]))
+
+  let map_s ?eq f s =
+    let event, push = E.create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      E.fmap
+        (fun x ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (fun v -> push v);
+           None)
+        (changes s)
+    in
+    Lwt_mutex.with_lock mutex (fun () -> f (value s)) >>= fun x ->
+    Lwt.return (hold ?eq x (E.select [iter; event]))
+
+  let app_s ?eq sf s =
+    let event, push = E.create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      E.fmap
+        (fun (f, x) ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (fun v -> push v);
+           None)
+        (E.app (E.map (fun f x -> f, x) (changes sf)) (changes s))
+    in
+    Lwt_mutex.with_lock mutex (fun () -> (value sf) (value s)) >>= fun x ->
+    Lwt.return (hold ?eq x (E.select [iter; event]))
+
+  let filter_s ?eq f i s =
+    let event, push = E.create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      E.fmap
+        (fun x ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (function true -> push x | false -> ());
+           None)
+        (changes s)
+    in
+    let x = value s in
+    Lwt_mutex.with_lock mutex (fun () -> f x) >>= function
+    | true -> Lwt.return (hold ?eq x (E.select [iter; event]))
+    | false -> Lwt.return (hold ?eq i (E.select [iter; event]))
+
+  let fmap_s ?eq f i s =
+    let event, push = E.create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      E.fmap
+        (fun x ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (function Some x -> push x | None -> ());
+           None)
+        (changes s)
+    in
+    Lwt_mutex.with_lock mutex (fun () -> f (value s)) >>= function
+    | Some x -> Lwt.return (hold ?eq x (E.select [iter; event]))
+    | None -> Lwt.return (hold ?eq i (E.select [iter; event]))
+
+  let diff_s f s =
+    let previous = ref (value s) in
+    let event, push = E.create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      E.fmap
+        (fun x ->
+           let y = !previous in
+           previous := x;
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x y))
+             (fun v -> push v);
+           None)
+        (changes s)
+    in
+    E.select [iter; event]
+
+  let sample_s f e s = E.map_s (fun x -> f x (value s)) e
+  let accum_s ?eq ef i = hold ?eq i (E.accum_s ef i)
+  let fold_s ?eq f i e = hold ?eq i (E.fold_s f i e)
+
+  let rec rev_fold f acc = function
+    | [] -> Lwt.return acc
+    | x :: l -> rev_fold f acc l >>= fun acc -> f acc x
+
+  let merge_s ?eq f acc sl =
+    let s = merge (fun acc x -> x :: acc) [] sl in
+    let event, push = E.create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      E.fmap
+        (fun l ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> rev_fold f acc l))
+             (fun v -> push v);
+           None)
+        (changes s)
+    in
+    Lwt_mutex.with_lock mutex (fun () -> rev_fold f acc (value s)) >>= fun x ->
+    Lwt.return (hold ?eq x (E.select [iter; event]))
+
+  let l1_s ?eq f s1 = map_s ?eq f s1
+
+  let l2_s ?eq f s1 s2 =
+    (* Some details about the use of [fun _ _ -> false] on
+       https://github.com/ocsigen/lwt/pull/893#pullrequestreview-783083496 *)
+    map_s ?eq
+      (fun (x1, x2) -> f x1 x2)
+      (l2 ~eq:(fun _ _ -> false) (fun x1 x2 -> x1, x2) s1 s2)
+
+  let l3_s ?eq f s1 s2 s3 =
+    map_s ?eq
+      (fun (x1, x2, x3) -> f x1 x2 x3)
+      (l3 ~eq:(fun _ _ -> false) (fun x1 x2 x3 -> x1, x2, x3) s1 s2 s3)
+
+  let l4_s ?eq f s1 s2 s3 s4 =
+    map_s ?eq
+      (fun (x1, x2, x3, x4) -> f x1 x2 x3 x4)
+      (l4
+         ~eq:(fun _ _ -> false)
+         (fun x1 x2 x3 x4 -> x1, x2, x3, x4)
+         s1 s2 s3 s4)
+
+  let l5_s ?eq f s1 s2 s3 s4 s5 =
+    map_s ?eq
+      (fun (x1, x2, x3, x4, x5) -> f x1 x2 x3 x4 x5)
+      (l5
+         ~eq:(fun _ _ -> false)
+         (fun x1 x2 x3 x4 x5 -> x1, x2, x3, x4, x5)
+         s1 s2 s3 s4 s5)
+
+  let l6_s ?eq f s1 s2 s3 s4 s5 s6 =
+    map_s ?eq
+      (fun (x1, x2, x3, x4, x5, x6) -> f x1 x2 x3 x4 x5 x6)
+      (l6
+         ~eq:(fun _ _ -> false)
+         (fun x1 x2 x3 x4 x5 x6 -> x1, x2, x3, x4, x5, x6)
+         s1 s2 s3 s4 s5 s6)
+
+  (* +---------------------------------------------------------------+
+     | Monadic interface                                             |
+     +---------------------------------------------------------------+ *)
+
+  let return = const
+
+  let bind_s ?eq s f =
+    let event, push = E.create () in
+    let mutex = Lwt_mutex.create () in
+    let iter =
+      E.fmap
+        (fun x ->
+           Lwt.on_success
+             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (fun v -> push v);
+           None)
+        (changes s)
+    in
+    Lwt_mutex.with_lock mutex (fun () -> f (value s)) >>= fun x ->
+    Lwt.return (switch ?eq (hold ~eq:( == ) x (E.select [iter; event])))
+end
diff --git a/src/lib/eio_react.shared.mli b/src/lib/eio_react.shared.mli
new file mode 100644
index 0000000000..ddf47d419c
--- /dev/null
+++ b/src/lib/eio_react.shared.mli
@@ -0,0 +1,261 @@
+(* This file is part of Lwt, released under the MIT license. See LICENSE.md for
+   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
+
+(** React utilities *)
+
+(** This module is an overlay for the [React] module. You can open it
+    instead of the [React] module in order to get all of [React]'s functions
+    plus Lwt ones.
+
+    This module is provided by OPAM package [lwt_react]. Link with ocamlfind
+    package [lwt_react]. *)
+
+type 'a event = 'a React.event
+(** Type of events. *)
+
+type 'a signal = 'a React.signal
+(** Type of signals. *)
+
+module E : sig
+  include module type of React.E
+
+  (** {2 Lwt-specific utilities} *)
+
+  val with_finaliser : (unit -> unit) -> 'a event -> 'a event
+  (** [with_finaliser f e] returns an event [e'] which behave as
+        [e], except that [f] is called when [e'] is garbage
+        collected. *)
+
+  val next : 'a event -> 'a Lwt.t
+  (** [next e] returns the next occurrence of [e].
+
+      Avoid trying to create an “asynchronous loop” by calling [next e] again in
+      a callback attached to the promise returned by [next e]:
+
+      - The callback is called within the React update step, so calling [next e]
+        within it will return a promise that is fulfilled with the same value as
+        the current occurrence.
+      - If you instead arrange for the React update step to end (for example, by
+        calling [Lwt.pause ()] within the callback), multiple React update steps
+        may occur before the callback calls [next e] again, so some occurrences
+        can be effectively “lost.”
+
+      To robustly asynchronously process occurrences of [e] in a loop, use
+      [to_stream e], and repeatedly call {!Lwt_stream.next} on the resulting
+      stream. *)
+
+  val limit : (unit -> unit Lwt.t) -> 'a event -> 'a event
+  (** [limit f e] limits the rate of [e] with [f].
+
+        For example, to limit the rate of an event to 1 per second you
+        can use: [limit (fun () -> Lwt_unix.sleep 1.0) event]. *)
+
+  val from : (unit -> 'a Lwt.t) -> 'a event
+  (** [from f] creates an event which occurs each time [f ()]
+        returns a value. If [f] raises an exception, the event is just
+        stopped. *)
+
+  val to_stream : 'a event -> 'a Lwt_stream.t
+  (** Creates a stream holding all values occurring on the given
+        event *)
+
+  val of_stream : 'a Lwt_stream.t -> 'a event
+  (** [of_stream stream] creates an event which occurs each time a
+        value is available on the stream.
+
+        If updating the event causes an exception at any point during the update
+        step, the exception is passed to [!]{!Lwt.async_exception_hook}, which
+        terminates the process by default. *)
+
+  val delay : 'a event Lwt.t -> 'a event
+  (** [delay promise] is an event which does not occur until
+        [promise] resolves. Then it behaves as the event returned by
+        [promise]. *)
+
+  val keep : 'a event -> unit
+  (** [keep e] keeps a reference to [e] so it will never be garbage
+        collected. *)
+
+  (** {2 Threaded versions of React transformation functions} *)
+
+  (** The following functions behave as their [React] counterpart,
+      except that they take functions that may yield.
+
+      As usual the [_s] suffix is used when calls are serialized, and
+      the [_p] suffix is used when they are not.
+
+      Note that [*_p] functions may not preserve event order. *)
+
+  val app_s : ('a -> 'b Lwt.t) event -> 'a event -> 'b event
+  val app_p : ('a -> 'b Lwt.t) event -> 'a event -> 'b event
+  val map_s : ('a -> 'b Lwt.t) -> 'a event -> 'b event
+  val map_p : ('a -> 'b Lwt.t) -> 'a event -> 'b event
+  val filter_s : ('a -> bool Lwt.t) -> 'a event -> 'a event
+  val filter_p : ('a -> bool Lwt.t) -> 'a event -> 'a event
+  val fmap_s : ('a -> 'b option Lwt.t) -> 'a event -> 'b event
+  val fmap_p : ('a -> 'b option Lwt.t) -> 'a event -> 'b event
+  val diff_s : ('a -> 'a -> 'b Lwt.t) -> 'a event -> 'b event
+  val accum_s : ('a -> 'a Lwt.t) event -> 'a -> 'a event
+  val fold_s : ('a -> 'b -> 'a Lwt.t) -> 'a -> 'b event -> 'a event
+  val merge_s : ('a -> 'b -> 'a Lwt.t) -> 'a -> 'b event list -> 'a event
+  val run_s : 'a Lwt.t event -> 'a event
+  val run_p : 'a Lwt.t event -> 'a event
+end
+
+module S : sig
+  include module type of React.S
+
+  (** {2 Monadic interface} *)
+
+  val return : 'a -> 'a signal
+  (** Same as [const]. *)
+
+  val bind :
+     ?eq:('b -> 'b -> bool)
+    -> 'a signal
+    -> ('a -> 'b signal)
+    -> 'b signal
+  (** [bind ?eq s f] is initially [f x] where [x] is the current
+        value of [s]. Each time [s] changes to a new value [y], [bind
+        signal f] is set to [f y], until the next change of
+        [signal]. *)
+
+  val bind_s :
+     ?eq:('b -> 'b -> bool)
+    -> 'a signal
+    -> ('a -> 'b signal Lwt.t)
+    -> 'b signal Lwt.t
+  (** Same as {!bind} except that [f] returns a promise. Calls to [f]
+        are serialized. *)
+
+  (** {2 Lwt-specific utilities} *)
+
+  val with_finaliser : (unit -> unit) -> 'a signal -> 'a signal
+  (** [with_finaliser f s] returns a signal [s'] which behaves as
+        [s], except that [f] is called when [s'] is garbage
+        collected. *)
+
+  val limit :
+     ?eq:('a -> 'a -> bool)
+    -> (unit -> unit Lwt.t)
+    -> 'a signal
+    -> 'a signal
+  (** [limit f s] limits the rate of [s] update with [f].
+
+        For example, to limit it to 1 per second, you can use: [limit
+        (fun () -> Lwt_unix.sleep 1.0) s]. *)
+
+  val keep : 'a signal -> unit
+  (** [keep s] keeps a reference to [s] so it will never be garbage
+        collected. *)
+
+  (** {2 Threaded versions of React transformation functions} *)
+
+  (** The following functions behave as their [React] counterpart,
+      except that they take functions that may yield.
+
+      The [_s] suffix means that calls are serialized.
+  *)
+
+  val app_s :
+     ?eq:('b -> 'b -> bool)
+    -> ('a -> 'b Lwt.t) signal
+    -> 'a signal
+    -> 'b signal Lwt.t
+
+  val map_s :
+     ?eq:('b -> 'b -> bool)
+    -> ('a -> 'b Lwt.t)
+    -> 'a signal
+    -> 'b signal Lwt.t
+
+  val filter_s :
+     ?eq:('a -> 'a -> bool)
+    -> ('a -> bool Lwt.t)
+    -> 'a
+    -> 'a signal
+    -> 'a signal Lwt.t
+
+  val fmap_s :
+     ?eq:('b -> 'b -> bool)
+    -> ('a -> 'b option Lwt.t)
+    -> 'b
+    -> 'a signal
+    -> 'b signal Lwt.t
+
+  val diff_s : ('a -> 'a -> 'b Lwt.t) -> 'a signal -> 'b event
+  val sample_s : ('b -> 'a -> 'c Lwt.t) -> 'b event -> 'a signal -> 'c event
+
+  val accum_s :
+     ?eq:('a -> 'a -> bool)
+    -> ('a -> 'a Lwt.t) event
+    -> 'a
+    -> 'a signal
+
+  val fold_s :
+     ?eq:('a -> 'a -> bool)
+    -> ('a -> 'b -> 'a Lwt.t)
+    -> 'a
+    -> 'b event
+    -> 'a signal
+
+  val merge_s :
+     ?eq:('a -> 'a -> bool)
+    -> ('a -> 'b -> 'a Lwt.t)
+    -> 'a
+    -> 'b signal list
+    -> 'a signal Lwt.t
+
+  val l1_s :
+     ?eq:('b -> 'b -> bool)
+    -> ('a -> 'b Lwt.t)
+    -> 'a signal
+    -> 'b signal Lwt.t
+
+  val l2_s :
+     ?eq:('c -> 'c -> bool)
+    -> ('a -> 'b -> 'c Lwt.t)
+    -> 'a signal
+    -> 'b signal
+    -> 'c signal Lwt.t
+
+  val l3_s :
+     ?eq:('d -> 'd -> bool)
+    -> ('a -> 'b -> 'c -> 'd Lwt.t)
+    -> 'a signal
+    -> 'b signal
+    -> 'c signal
+    -> 'd signal Lwt.t
+
+  val l4_s :
+     ?eq:('e -> 'e -> bool)
+    -> ('a -> 'b -> 'c -> 'd -> 'e Lwt.t)
+    -> 'a signal
+    -> 'b signal
+    -> 'c signal
+    -> 'd signal
+    -> 'e signal Lwt.t
+
+  val l5_s :
+     ?eq:('f -> 'f -> bool)
+    -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f Lwt.t)
+    -> 'a signal
+    -> 'b signal
+    -> 'c signal
+    -> 'd signal
+    -> 'e signal
+    -> 'f signal Lwt.t
+
+  val l6_s :
+     ?eq:('g -> 'g -> bool)
+    -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g Lwt.t)
+    -> 'a signal
+    -> 'b signal
+    -> 'c signal
+    -> 'd signal
+    -> 'e signal
+    -> 'f signal
+    -> 'g signal Lwt.t
+
+  val run_s : ?eq:('a -> 'a -> bool) -> 'a Lwt.t signal -> 'a signal Lwt.t
+end

From 512fcf7fe02ad713aa46db524fd35934a4e99565 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Tue, 26 Aug 2025 17:41:38 +0200
Subject: [PATCH 04/21] Replace syntactically Lwt_stream by Eliom_stream and
 Lwt_react by Eio_react

---
 src/lib/client/dune.client      |  4 ++++
 src/lib/eio_react.shared.ml     |  4 ++--
 src/lib/eio_react.shared.mli    |  6 +++---
 src/lib/eliom_bus.client.ml     | 10 +++++-----
 src/lib/eliom_bus.client.mli    |  4 ++--
 src/lib/eliom_bus.server.ml     |  8 ++++----
 src/lib/eliom_bus.server.mli    |  4 ++--
 src/lib/eliom_comet.client.ml   | 14 +++++++-------
 src/lib/eliom_comet.client.mli  |  6 +++---
 src/lib/eliom_comet.server.ml   | 30 +++++++++++++++---------------
 src/lib/eliom_comet.server.mli  |  8 ++++----
 src/lib/eliom_react.client.ml   |  6 +++---
 src/lib/eliom_react.server.ml   |  6 +++---
 src/lib/eliom_shared.eliom      | 16 ++++++++--------
 src/lib/eliom_stream.shared.ml  | 11 ++++++-----
 src/lib/eliom_stream.shared.mli | 32 ++++++++++++++++----------------
 src/lib/server/dune.server      |  4 ++++
 17 files changed, 91 insertions(+), 82 deletions(-)

diff --git a/src/lib/client/dune.client b/src/lib/client/dune.client
index 68f8ab59b5..375a16e59f 100644
--- a/src/lib/client/dune.client
+++ b/src/lib/client/dune.client
@@ -1,3 +1,5 @@
+(rule (copy# ../eio_react.shared.ml eio_react.ml))
+(rule (copy# ../eio_react.shared.mli eio_react.mli))
 (rule (copy# ../eliom_bus.client.ml eliom_bus.ml))
 (rule (copy# ../eliom_bus.client.mli eliom_bus.mli))
 (rule (copy# ../eliom_client.client.ml eliom_client.ml))
@@ -90,6 +92,8 @@
     (with-stdout-to %{target}
       (chdir .. (run ppx_eliom_client --as-pp --intf %{deps})))))
 (rule (copy# ../eliom_shared_sigs.shared.mli eliom_shared_sigs.mli))
+(rule (copy# ../eliom_stream.shared.ml eliom_stream.ml))
+(rule (copy# ../eliom_stream.shared.mli eliom_stream.mli))
 (rule (target eliom_tools.ml) (deps ../eliom_tools.eliom)
   (action
     (with-stdout-to %{target}
diff --git a/src/lib/eio_react.shared.ml b/src/lib/eio_react.shared.ml
index cec021132e..4a193f2032 100644
--- a/src/lib/eio_react.shared.ml
+++ b/src/lib/eio_react.shared.ml
@@ -80,7 +80,7 @@ module E = struct
     with_finaliser (cancel_thread t) event
 
   let to_stream event =
-    let stream, push, set_ref = Lwt_stream.create_with_reference () in
+    let stream, push, set_ref = Eliom_stream.create_with_reference () in
     set_ref (map (fun x -> push (Some x)) event);
     stream
 
@@ -88,7 +88,7 @@ module E = struct
     let event, push = create () in
     let t =
       Lwt.pause () >>= fun () ->
-      Lwt_stream.iter
+      Eliom_stream.iter
         (fun v ->
            try push v
            with exn when Lwt.Exception_filter.run exn ->
diff --git a/src/lib/eio_react.shared.mli b/src/lib/eio_react.shared.mli
index ddf47d419c..614f8e4498 100644
--- a/src/lib/eio_react.shared.mli
+++ b/src/lib/eio_react.shared.mli
@@ -41,7 +41,7 @@ module E : sig
         can be effectively “lost.”
 
       To robustly asynchronously process occurrences of [e] in a loop, use
-      [to_stream e], and repeatedly call {!Lwt_stream.next} on the resulting
+      [to_stream e], and repeatedly call {!Eliom_stream.next} on the resulting
       stream. *)
 
   val limit : (unit -> unit Lwt.t) -> 'a event -> 'a event
@@ -55,11 +55,11 @@ module E : sig
         returns a value. If [f] raises an exception, the event is just
         stopped. *)
 
-  val to_stream : 'a event -> 'a Lwt_stream.t
+  val to_stream : 'a event -> 'a Eliom_stream.t
   (** Creates a stream holding all values occurring on the given
         event *)
 
-  val of_stream : 'a Lwt_stream.t -> 'a event
+  val of_stream : 'a Eliom_stream.t -> 'a event
   (** [of_stream stream] creates an event which occurs each time a
         value is available on the stream.
 
diff --git a/src/lib/eliom_bus.client.ml b/src/lib/eliom_bus.client.ml
index 2440901be2..6240ce0287 100644
--- a/src/lib/eliom_bus.client.ml
+++ b/src/lib/eliom_bus.client.ml
@@ -29,7 +29,7 @@ module Ecb = Eliom_comet_base
 
 type ('a, 'b) t =
   { channel : 'b Ecb.wrapped_channel
-  ; stream : 'b Lwt_stream.t Lazy.t
+  ; stream : 'b Eliom_stream.t Lazy.t
   ; queue : 'a Queue.t
   ; mutable max_size : int
   ; write : 'a list -> unit Lwt.t
@@ -42,7 +42,7 @@ type ('a, 'b) t =
 let consume (t, u) s =
   let t' =
     Lwt.catch
-      (fun () -> Lwt_stream.iter (fun _ -> ()) s)
+      (fun () -> Eliom_stream.iter (fun _ -> ()) s)
       (fun e ->
          (match Lwt.state t with Lwt.Sleep -> Lwt.wakeup_exn u e | _ -> ());
          Lwt.fail e)
@@ -50,10 +50,10 @@ let consume (t, u) s =
   Lwt.choose [Lwt.bind t (fun _ -> Lwt.return_unit); t']
 
 let clone_exn (t, u) s =
-  let s' = Lwt_stream.clone s in
-  Lwt_stream.from (fun () ->
+  let s' = Eliom_stream.clone s in
+  Eliom_stream.from (fun () ->
     Lwt.catch
-      (fun () -> Lwt.choose [Lwt_stream.get s'; t])
+      (fun () -> Lwt.choose [Eliom_stream.get s'; t])
       (fun e ->
          (match Lwt.state t with Lwt.Sleep -> Lwt.wakeup_exn u e | _ -> ());
          Lwt.fail e))
diff --git a/src/lib/eliom_bus.client.mli b/src/lib/eliom_bus.client.mli
index 06950d8396..530c9cf692 100644
--- a/src/lib/eliom_bus.client.mli
+++ b/src/lib/eliom_bus.client.mli
@@ -25,14 +25,14 @@
 
 type ('a, 'b) t
 
-val stream : ('a, 'b) t -> 'b Lwt_stream.t
+val stream : ('a, 'b) t -> 'b Eliom_stream.t
 (** [stream b] returns the stream of data sent to bus [b]. A new
     stream is created each time this function is called. Some messages
     from the bus can be lost if they were sent before the call to
     [stream]. If you need to receive every message, use original stream
     instead. *)
 
-val original_stream : ('a, 'b) t -> 'b Lwt_stream.t
+val original_stream : ('a, 'b) t -> 'b Eliom_stream.t
 (** [stream b] returns the stream of data sent to bus [b]. A new
     stream is created each time this function is called. Every
     messages sent to the bus after the generation of the page are
diff --git a/src/lib/eliom_bus.server.ml b/src/lib/eliom_bus.server.ml
index 6ba8b81e20..0e8cae932c 100644
--- a/src/lib/eliom_bus.server.ml
+++ b/src/lib/eliom_bus.server.ml
@@ -23,7 +23,7 @@ open Lwt.Syntax
 module Ecb = Eliom_comet_base
 
 type ('a, 'b) t =
-  { stream : 'b Lwt_stream.t
+  { stream : 'b Eliom_stream.t
   ; scope : Eliom_comet.Channel.comet_scope
   ; name : string option
   ; channel : 'b Eliom_comet.Channel.t option
@@ -46,7 +46,7 @@ let internal_wrap (bus : ('a, 'b) t) :
     | None ->
         Eliom_comet.Channel.create ~scope:bus.scope ?name:bus.name
           ?size:bus.size
-          (Lwt_stream.clone bus.stream)
+          (Eliom_stream.clone bus.stream)
     | Some c -> c
   in
   (match bus.service_registered with
@@ -92,7 +92,7 @@ let deriving_to_list : 'a Deriving_Json.t -> 'a list Deriving_Json.t =
 
 let create_filtered ?scope ?name ?size ~filter typ =
   (*The stream*)
-  let stream, push = Lwt_stream.create () in
+  let stream, push = Eliom_stream.create () in
   let push x =
     let* y = filter x in
     push (Some y); Lwt.return_unit
@@ -107,7 +107,7 @@ let create_filtered ?scope ?name ?size ~filter typ =
     | `Site ->
         Some
           (Eliom_comet.Channel.create ~scope ?name ?size
-             (Lwt_stream.clone stream))
+             (Eliom_stream.clone stream))
     | `Client_process _ -> None
   in
   let typ_list = deriving_to_list typ in
diff --git a/src/lib/eliom_bus.server.mli b/src/lib/eliom_bus.server.mli
index c7debfed13..13dea5e533 100644
--- a/src/lib/eliom_bus.server.mli
+++ b/src/lib/eliom_bus.server.mli
@@ -64,11 +64,11 @@ val create_filtered :
     some information, like IP address, or user id.
 *)
 
-val stream : ('a, 'b) t -> 'b Lwt_stream.t
+val stream : ('a, 'b) t -> 'b Eliom_stream.t
 (** [stream b] returns the stream of data sent to bus [b]. Notice you
     should not use that function multiple times on the same bus, it will
     return the same stream. If you want to receive multiple times the
-    same data, you should copy the stream with [Lwt_stream.clone] *)
+    same data, you should copy the stream with [Eliom_stream.clone] *)
 
 val write : ('a, 'b) t -> 'a -> unit Lwt.t
 (** [write b x] sends the value [x] on the bus [b]. Every participant,
diff --git a/src/lib/eliom_comet.client.ml b/src/lib/eliom_comet.client.ml
index 119d65407e..95eca2d551 100644
--- a/src/lib/eliom_comet.client.ml
+++ b/src/lib/eliom_comet.client.ml
@@ -637,12 +637,12 @@ end
 
 type 'a handler =
   { hd_service_handler : 'a Service_handler.t
-  ; hd_stream : (string * int option * string Ecb.channel_data) Lwt_stream.t }
+  ; hd_stream : (string * int option * string Ecb.channel_data) Eliom_stream.t }
 
 let handler_stream hd =
-  Lwt_stream.map_list
+  Eliom_stream.map_list
     (fun x -> x)
-    (Lwt_stream.from (fun () ->
+    (Eliom_stream.from (fun () ->
        Lwt.try_bind
          (fun () -> Service_handler.wait_data hd)
          (fun s -> Lwt.return_some s)
@@ -745,7 +745,7 @@ let check_and_update_position position msg_pos data =
 let register' hd position (_ : Ecb.comet_service) (chan_id : 'a Ecb.chan_id) =
   let chan_id = Ecb.string_of_chan_id chan_id in
   let stream =
-    Lwt_stream.filter_map_s
+    Eliom_stream.filter_map_s
       (function
         | id, pos, data
           when id = chan_id && check_and_update_position position pos data -> (
@@ -754,7 +754,7 @@ let register' hd position (_ : Ecb.comet_service) (chan_id : 'a Ecb.chan_id) =
           | Ecb.Closed -> Lwt.fail Channel_closed
           | Ecb.Data x -> Lwt.return_some (unmarshal x : 'a))
         | _ -> Lwt.return_none)
-      (Lwt_stream.clone hd.hd_stream)
+      (Eliom_stream.clone hd.hd_stream)
   in
   let protect_and_close t =
     let t' = Lwt.protected t in
@@ -763,7 +763,7 @@ let register' hd position (_ : Ecb.comet_service) (chan_id : 'a Ecb.chan_id) =
     t'
   in
   (* protect the stream from cancels *)
-  Lwt_stream.from (fun () -> protect_and_close (Lwt_stream.get stream))
+  Eliom_stream.from (fun () -> protect_and_close (Eliom_stream.get stream))
 
 let register_stateful ?(wake = true) service chan_id =
   let hd = get_stateful_hd service in
@@ -809,7 +809,7 @@ let is_active () =
     Hashtbl.fold f stateful_handler_table `Active)
 
 module Channel = struct
-  type 'a t = 'a Lwt_stream.t
+  type 'a t = 'a Eliom_stream.t
 end
 
 let force_link = ()
diff --git a/src/lib/eliom_comet.client.mli b/src/lib/eliom_comet.client.mli
index bd12ee9876..2258658d68 100644
--- a/src/lib/eliom_comet.client.mli
+++ b/src/lib/eliom_comet.client.mli
@@ -31,7 +31,7 @@
 
     To stop receiving inputs from a channel, use Lwt.cancel on a
     thread waiting for data. For instance, if you iterate with
-    [ let t = Lwt_stream.iter f %channel ] calling [Lwt.cancel t]
+    [ let t = Eliom_stream.iter f %channel ] calling [Lwt.cancel t]
     will close the channel. *)
 
 exception Channel_full
@@ -115,7 +115,7 @@ module Configuration : sig
 end
 
 module Channel : sig
-  type 'a t = 'a Lwt_stream.t
+  type 'a t = 'a Eliom_stream.t
 end
 
 (**/**)
@@ -123,7 +123,7 @@ end
 val register :
    ?wake:bool
   -> 'a Eliom_comet_base.wrapped_channel
-  -> 'a Lwt_stream.t
+  -> 'a Eliom_stream.t
 (** if wake is false, the registration of the channel won't
     activate the handling loop ( no request will be sent ). Default is true *)
 
diff --git a/src/lib/eliom_comet.server.ml b/src/lib/eliom_comet.server.ml
index 930dc50de9..92c52483b9 100644
--- a/src/lib/eliom_comet.server.ml
+++ b/src/lib/eliom_comet.server.ml
@@ -90,7 +90,7 @@ let timeout () =
 module Stateless : sig
   type channel
 
-  val create : ?name:string -> size:int -> string Lwt_stream.t -> channel
+  val create : ?name:string -> size:int -> string Eliom_stream.t -> channel
   val get_id : channel -> string
   val get_service : unit -> Eliom_comet_base.comet_service
   val get_kind : newest:bool -> channel -> Eliom_comet_base.stateless_kind
@@ -152,7 +152,7 @@ end = struct
     in
     ignore
       (Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-       Lwt_stream.iter_s f stream
+       Eliom_stream.iter_s f stream
        : unit Lwt.t)
 
   let make_name name = "stateless:" ^ name
@@ -313,7 +313,7 @@ module Stateful : sig
   val create_unlimited :
      ?scope:Eliom_common.client_process_scope
     -> ?name:chan_id
-    -> _ Lwt_stream.t
+    -> _ Eliom_stream.t
     -> t
 
   val get_id : t -> string
@@ -347,7 +347,7 @@ end = struct
              get garbage collected *)
           mutable events : Obj.t option }
     | Stream of
-        { mutable stream : string Eliom_comet_base.channel_data Lwt_stream.t
+        { mutable stream : string Eliom_comet_base.channel_data Eliom_stream.t
         ; mutable waiter : waiter }
 
   type handler =
@@ -435,7 +435,7 @@ end = struct
   let stream_waiter s =
     Lwt.with_value Eliom_common.sp_key None @@ fun () ->
     Lwt.no_cancel
-      (let* _ = Lwt_stream.peek s in
+      (let* _ = Eliom_stream.peek s in
        Lwt.return `Data)
 
   (** read up to [n] messages in the list of streams [streams] without blocking. *)
@@ -453,7 +453,7 @@ end = struct
         | (id, Stream ({stream; _} as s)) :: rem ->
             let l =
               Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-              Lwt_stream.get_available_up_to n stream
+              Eliom_stream.get_available_up_to n stream
             in
             if l <> [] then s.waiter <- stream_waiter stream;
             take (n - List.length l) (List.rev_map (fun v -> id, v) l @ acc) rem
@@ -709,7 +709,7 @@ end = struct
     Logs.info ~src:section (fun fmt -> fmt "create channel %s" name);
     let stream =
       Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-      Lwt_stream.map (fun x -> Eliom_comet_base.Data (marshal x)) stream
+      Eliom_stream.map (fun x -> Eliom_comet_base.Data (marshal x)) stream
     in
     let channel = Stream {stream; waiter = stream_waiter stream} in
     if List.mem name handler.hd_registered_chan_id
@@ -748,16 +748,16 @@ module Channel : sig
      ?scope:[< comet_scope]
     -> ?name:string
     -> ?size:int
-    -> 'a Lwt_stream.t
+    -> 'a Eliom_stream.t
     -> 'a t
 
   val create_unlimited :
      ?scope:Eliom_common.client_process_scope
     -> ?name:string
-    -> 'a Lwt_stream.t
+    -> 'a Eliom_stream.t
     -> 'a t
 
-  val create_newest : ?name:string -> 'a Lwt_stream.t -> 'a t
+  val create_newest : ?name:string -> 'a Eliom_stream.t -> 'a t
   val get_wrapped : 'a t -> 'a Eliom_comet_base.wrapped_channel
 
   val external_channel :
@@ -813,13 +813,13 @@ end = struct
     Stateless
       (Stateless.create ?name ~size
          ( Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-           Lwt_stream.map marshal stream ))
+           Eliom_stream.map marshal stream ))
 
   let create_stateless_newest_channel ?name stream =
     Stateless_newest
       (Stateless.create ?name ~size:1
          ( Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-           Lwt_stream.map marshal stream ))
+           Eliom_stream.map marshal stream ))
 
   let create_stateful ?scope ?name ?(size = 1000) events =
     { channel = create_stateful_channel ?scope ?name ~size events
@@ -845,13 +845,13 @@ end = struct
     | None -> create_stateful ?name ~size events
     | Some (`Client_process _ as scope) ->
         create_stateful ~scope ?name ~size events
-    | Some `Site -> create_stateless ?name ~size (Lwt_react.E.to_stream events)
+    | Some `Site -> create_stateless ?name ~size (Eio_react.E.to_stream events)
 
   let create ?scope ?name ?(size = 1000) stream =
     match scope with
-    | None -> create_stateful ?name ~size (Lwt_react.E.of_stream stream)
+    | None -> create_stateful ?name ~size (Eio_react.E.of_stream stream)
     | Some (`Client_process _ as scope) ->
-        create_stateful ~scope ?name ~size (Lwt_react.E.of_stream stream)
+        create_stateful ~scope ?name ~size (Eio_react.E.of_stream stream)
     | Some `Site -> create_stateless ?name ~size stream
 
   let external_channel ?(history = 1) ?(newest = false) ~prefix ~name () =
diff --git a/src/lib/eliom_comet.server.mli b/src/lib/eliom_comet.server.mli
index 77df666d9b..0c3e8b9c1c 100644
--- a/src/lib/eliom_comet.server.mli
+++ b/src/lib/eliom_comet.server.mli
@@ -40,7 +40,7 @@ module Channel : sig
      ?scope:[< comet_scope]
     -> ?name:string
     -> ?size:int
-    -> 'a Lwt_stream.t
+    -> 'a Eliom_stream.t
     -> 'a t
   (** [create s] returns a channel sending the values returned by stream [s].
 
@@ -68,7 +68,7 @@ module Channel : sig
 
       A channel can be used only once on client side. To be able
       to receive the same data multiple times on client side, use
-      [create (Lwt_stream.clone s)] every time.
+      [create (Eliom_stream.clone s)] every time.
 
       To enforce the limit on the buffer size, the data is read into
       [stream] as soon as possible: If you want a channel that reads
@@ -87,7 +87,7 @@ module Channel : sig
   val create_unlimited :
      ?scope:Eliom_common.client_process_scope
     -> ?name:string
-    -> 'a Lwt_stream.t
+    -> 'a Eliom_stream.t
     -> 'a t
   (** [create_unlimited s] creates a channel which does not read
       immediately on the stream. It is read only when the client
@@ -97,7 +97,7 @@ module Channel : sig
       the stream increases and your clients don't read it, you may have
       memory leaks. *)
 
-  val create_newest : ?name:string -> 'a Lwt_stream.t -> 'a t
+  val create_newest : ?name:string -> 'a Eliom_stream.t -> 'a t
   (** [create_newest s] is similar to [create
       ~scope:Eliom_common.site_scope s] but only the last message is
       returned to the client. *)
diff --git a/src/lib/eliom_react.client.ml b/src/lib/eliom_react.client.ml
index 7e111aef95..ba48819212 100644
--- a/src/lib/eliom_react.client.ml
+++ b/src/lib/eliom_react.client.ml
@@ -22,7 +22,7 @@ open Lwt.Syntax
 *)
 
 (* Module for event unwrapping *)
-open Lwt_react
+open Eio_react
 open Lwt.Infix
 
 let section = Logs.Src.create "eliom:comet"
@@ -50,9 +50,9 @@ module Down = struct
     (* We want to catch more exceptions here than the usual exceptions caught
        in Eliom_comet. For example Channel_full. *)
     (* We transform the stream into a stream with exception: *)
-    let stream = Lwt_stream.wrap_exn channel in
+    let stream = Eliom_stream.wrap_exn channel in
     Lwt.async (fun () ->
-      Lwt_stream.iter_s
+      Eliom_stream.iter_s
         (function
           | Error exn ->
               let* () = handle_react_exn ~exn () in
diff --git a/src/lib/eliom_react.server.ml b/src/lib/eliom_react.server.ml
index f80fe58624..025c1ebb05 100644
--- a/src/lib/eliom_react.server.ml
+++ b/src/lib/eliom_react.server.ml
@@ -22,7 +22,7 @@ open Lwt.Syntax
 
 (* Module for event wrapping and related functions *)
 
-open Lwt_react
+open Eio_react
 
 module Down = struct
   type 'a stateful =
@@ -140,7 +140,7 @@ module S = struct
 
     type 'a stateless =
       { channel : 'a Eliom_comet.Channel.t
-      ; stream : 'a Lwt_stream.t
+      ; stream : 'a Eliom_stream.t
       ; (* avoid garbage collection *)
         sl_signal : 'a S.t }
     [@@warning "-69"]
@@ -195,7 +195,7 @@ module S = struct
         | Some t -> S.limit (fun () -> Lwt_unix.sleep t) s
       in
       let store = make_store s in
-      let stream = Lwt_stream.from (read_store store) in
+      let stream = Eliom_stream.from (read_store store) in
       let channel = Eliom_comet.Channel.create_unlimited ?name stream in
       let value : 'a = S.value s in
       ( channel
diff --git a/src/lib/eliom_shared.eliom b/src/lib/eliom_shared.eliom
index 8156139a85..f41155b0ab 100644
--- a/src/lib/eliom_shared.eliom
+++ b/src/lib/eliom_shared.eliom
@@ -21,7 +21,7 @@
 [%%shared
 open Lwt.Syntax
 
-(* put this in Lwt_react? Find a better name? *)
+(* put this in Eio_react? Find a better name? *)
 let to_signal ~init ?eq (th : 'a React.S.t Lwt.t) : 'a React.S.t =
   let s, set = React.S.create ?eq init in
   Lwt.async (fun () ->
@@ -80,43 +80,43 @@ module React = struct
     end
 
     module Lwt = struct
-      let map_s = Lwt_react.S.map_s
+      let map_s = Eio_react.S.map_s
 
       let map_s_init ~init ?eq f s =
         let th = map_s ?eq f s in
         to_signal ~init ?eq th
 
-      let l2_s = Lwt_react.S.l2_s
+      let l2_s = Eio_react.S.l2_s
 
       let l2_s_init ~init ?eq f s1 s2 =
         let th = l2_s ?eq f s1 s2 in
         to_signal ~init ?eq th
 
-      let l3_s = Lwt_react.S.l3_s
+      let l3_s = Eio_react.S.l3_s
 
       let l3_s_init ~init ?eq f s1 s2 s3 =
         let th = l3_s ?eq f s1 s2 s3 in
         to_signal ~init ?eq th
 
-      let l4_s = Lwt_react.S.l4_s
+      let l4_s = Eio_react.S.l4_s
 
       let l4_s_init ~init ?eq f s1 s2 s3 s4 =
         let th = l4_s ?eq f s1 s2 s3 s4 in
         to_signal ~init ?eq th
 
-      let l5_s = Lwt_react.S.l5_s
+      let l5_s = Eio_react.S.l5_s
 
       let l5_s_init ~init ?eq f s1 s2 s3 s4 s5 =
         let th = l5_s ?eq f s1 s2 s3 s4 s5 in
         to_signal ~init ?eq th
 
-      let l6_s = Lwt_react.S.l6_s
+      let l6_s = Eio_react.S.l6_s
 
       let l6_s_init ~init ?eq f s1 s2 s3 s4 s5 s6 =
         let th = l6_s ?eq f s1 s2 s3 s4 s5 s6 in
         to_signal ~init ?eq th
 
-      let merge_s = Lwt_react.S.merge_s
+      let merge_s = Eio_react.S.merge_s
 
       let merge_s_init ~init ?eq f a l =
         let th = merge_s ?eq f a l in
diff --git a/src/lib/eliom_stream.shared.ml b/src/lib/eliom_stream.shared.ml
index 780fb67bff..8b207b83d0 100644
--- a/src/lib/eliom_stream.shared.ml
+++ b/src/lib/eliom_stream.shared.ml
@@ -104,7 +104,7 @@ end
    pending element. *)
 let clone s =
   (match s.source with
-  | Push_bounded _ -> invalid_arg "Lwt_stream.clone"
+  | Push_bounded _ -> invalid_arg "Eliom_stream.clone"
   | From _ | From_direct _ | Push _ -> ());
   { source = s.source
   ; close = s.close
@@ -235,7 +235,7 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
     method size = info.pushb_size
 
     method resize size =
-      if size < 0 then invalid_arg "Lwt_stream.bounded_push#resize";
+      if size < 0 then invalid_arg "Eliom_stream.bounded_push#resize";
       info.pushb_size <- size;
       if info.pushb_count < info.pushb_size && info.pushb_pending <> None
       then (
@@ -310,7 +310,7 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
   end
 
 let create_bounded size =
-  if size < 0 then invalid_arg "Lwt_stream.create_bounded";
+  if size < 0 then invalid_arg "Eliom_stream.create_bounded";
   (* Create the source for notifications of new elements. *)
   let info, wakener_cell =
     let waiter, wakener = Lwt.wait () in
@@ -808,7 +808,8 @@ let iter_n ?(max_concurrency = 1) f stream =
   (if max_concurrency <= 0
    then
      let message =
-       Printf.sprintf "Lwt_stream.iter_n: max_concurrency must be > 0, %d given"
+       Printf.sprintf
+         "Eliom_stream.iter_n: max_concurrency must be > 0, %d given"
          max_concurrency
      in
      invalid_arg message);
@@ -940,7 +941,7 @@ let choose streams =
 
 let parse s f =
   (match s.source with
-  | Push_bounded _ -> invalid_arg "Lwt_stream.parse"
+  | Push_bounded _ -> invalid_arg "Eliom_stream.parse"
   | From _ | From_direct _ | Push _ -> ());
   let node = s.node in
   Lwt.catch
diff --git a/src/lib/eliom_stream.shared.mli b/src/lib/eliom_stream.shared.mli
index 6a4c632e08..62c55d2393 100644
--- a/src/lib/eliom_stream.shared.mli
+++ b/src/lib/eliom_stream.shared.mli
@@ -55,7 +55,7 @@ val create_with_reference : unit -> 'a t * ('a option -> unit) * ('b -> unit)
     For example, to convert a reactive event to a stream:
 
     {[
-      let stream, push, set_ref = Lwt_stream.create_with_reference () in
+      let stream, push, set_ref = Eliom_stream.create_with_reference () in
       set_ref (map_event push event)
     ]}
 *)
@@ -79,11 +79,11 @@ class type ['a] bounded_push = object
   method push : 'a -> unit Lwt.t
   (** Pushes a new element to the stream. If the stream is full then
       it will block until one element is consumed. If another thread
-      is already blocked on [push], it raises {!Lwt_stream.Full}. *)
+      is already blocked on [push], it raises {!Eliom_stream.Full}. *)
 
   method close : unit
   (** Closes the stream. Any thread currently blocked on a call to
-      the [push] method fails with {!Lwt_stream.Closed}. *)
+      the [push] method fails with {!Eliom_stream.Closed}. *)
 
   method count : int
   (** Number of elements in the stream queue. *)
@@ -161,13 +161,13 @@ val clone : 'a t -> 'a t
     For example:
 
     {[
-      # let st1 = Lwt_stream.of_list [1; 2; 3];;
-      val st1 : int Lwt_stream.t = <abstr>
-      # let st2 = Lwt_stream.clone st1;;
-      val st2 : int Lwt_stream.t = <abstr>
-      # lwt x = Lwt_stream.next st1;;
+      # let st1 = Eliom_stream.of_list [1; 2; 3];;
+      val st1 : int Eliom_stream.t = <abstr>
+      # let st2 = Eliom_stream.clone st1;;
+      val st2 : int Eliom_stream.t = <abstr>
+      # lwt x = Eliom_stream.next st1;;
       val x : int = 1
-      # lwt y = Lwt_stream.next st2;;
+      # lwt y = Eliom_stream.next st2;;
       val y : int = 1
     ]}
 
@@ -276,13 +276,13 @@ val junk_old : 'a t -> unit Lwt.t
     For example:
 
     {[
-      # let st1 = Lwt_stream.of_list [1; 2; 3];;
-      val st1 : int Lwt_stream.t = <abstr>
-      # let st2 = Lwt_stream.map string_of_int st1;;
-      val st2 : string Lwt_stream.t = <abstr>
-      # lwt x = Lwt_stream.next st1;;
+      # let st1 = Eliom_stream.of_list [1; 2; 3];;
+      val st1 : int Eliom_stream.t = <abstr>
+      # let st2 = Eliom_stream.map string_of_int st1;;
+      val st2 : string Eliom_stream.t = <abstr>
+      # lwt x = Eliom_stream.next st1;;
       val x : int = 1
-      # lwt y = Lwt_stream.next st2;;
+      # lwt y = Eliom_stream.next st2;;
       val y : string = "2"
     ]}
 *)
@@ -394,7 +394,7 @@ val hexdump : char t -> string t
       let () = Lwt_main.run begin
           Lwt_io.write_lines
             Lwt_io.stdout
-            (Lwt_stream.hexdump (Lwt_io.read_lines Lwt_io.stdin))
+            (Eliom_stream.hexdump (Lwt_io.read_lines Lwt_io.stdin))
         end
     ]}
 *)
diff --git a/src/lib/server/dune.server b/src/lib/server/dune.server
index a0e827aa33..c1646c9f6f 100644
--- a/src/lib/server/dune.server
+++ b/src/lib/server/dune.server
@@ -1,3 +1,5 @@
+(rule (copy# ../eio_react.shared.ml eio_react.ml))
+(rule (copy# ../eio_react.shared.mli eio_react.mli))
 (rule (copy# ../eliom.server.ml eliom.ml))
 (rule (copy# ../eliom.server.mli eliom.mli))
 (rule (copy# ../eliom_bus.server.ml eliom_bus.ml))
@@ -102,6 +104,8 @@
 (rule (copy# ../eliom_shared_sigs.shared.mli eliom_shared_sigs.mli))
 (rule (copy# ../eliom_state.server.ml eliom_state.ml))
 (rule (copy# ../eliom_state.server.mli eliom_state.mli))
+(rule (copy# ../eliom_stream.shared.ml eliom_stream.ml))
+(rule (copy# ../eliom_stream.shared.mli eliom_stream.mli))
 (rule (copy# ../eliom_syntax.server.ml eliom_syntax.ml))
 (rule (copy# ../eliom_syntax.server.mli eliom_syntax.mli))
 (rule (target eliom_tools.ml) (deps ../eliom_tools.eliom)

From a65489fda07e02a6c170aed69eb3f85768c62579 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Wed, 27 Aug 2025 16:27:04 +0200
Subject: [PATCH 05/21] Automatic changes done with ciao-lwt

---
 src/lib/client/eliommod_dom.ml             |  95 ++-
 src/lib/client/eliommod_dom.mli            |   2 +-
 src/lib/eio_react.shared.ml                | 151 +++--
 src/lib/eio_react.shared.mli               | 111 ++--
 src/lib/eliom_bus.client.ml                | 102 +--
 src/lib/eliom_bus.client.mli               |   2 +-
 src/lib/eliom_bus.server.ml                |  12 +-
 src/lib/eliom_bus.server.mli               |   4 +-
 src/lib/eliom_client.client.ml             | 699 +++++++++++----------
 src/lib/eliom_client.client.mli            |  28 +-
 src/lib/eliom_client.server.mli            |   4 +-
 src/lib/eliom_client_core.client.ml        |  33 +-
 src/lib/eliom_client_main.eliom            |  12 +-
 src/lib/eliom_comet.client.ml              | 215 ++++---
 src/lib/eliom_comet.client.mli             |   4 +-
 src/lib/eliom_comet.server.ml              | 205 +++---
 src/lib/eliom_comet.server.mli             |   5 +-
 src/lib/eliom_common.server.ml             |  74 +--
 src/lib/eliom_common.server.mli            |  21 +-
 src/lib/eliom_common_base.shared.ml        |   6 +-
 src/lib/eliom_content.client.mli           |   4 +-
 src/lib/eliom_cscache.eliom                |  14 +-
 src/lib/eliom_cscache.eliomi               |   6 +-
 src/lib/eliom_extension.server.ml          |   6 +-
 src/lib/eliom_extension.server.mli         |   4 +-
 src/lib/eliom_form.eliom                   |  45 +-
 src/lib/eliom_form.eliomi                  |   2 +-
 src/lib/eliom_form_sigs.shared.mli         |   8 +-
 src/lib/eliom_mkreg.server.ml              | 216 ++++---
 src/lib/eliom_notif.server.ml              |  39 +-
 src/lib/eliom_notif.server.mli             |   8 +-
 src/lib/eliom_parameter_base.shared.ml     |  22 +-
 src/lib/eliom_parameter_sigs.shared.mli    |   8 +-
 src/lib/eliom_react.client.ml              |  29 +-
 src/lib/eliom_react.client.mli             |   4 +-
 src/lib/eliom_react.server.ml              |  32 +-
 src/lib/eliom_reference.server.ml          | 124 ++--
 src/lib/eliom_reference.server.mli         |  16 +-
 src/lib/eliom_registration.client.ml       |  74 ++-
 src/lib/eliom_registration.client.mli      |   4 +-
 src/lib/eliom_registration.server.ml       | 171 +++--
 src/lib/eliom_registration.server.mli      |  12 +-
 src/lib/eliom_registration_sigs.shared.mli |  42 +-
 src/lib/eliom_request.client.ml            | 208 +++---
 src/lib/eliom_request.client.mli           |  14 +-
 src/lib/eliom_request_info.client.ml       |  18 +-
 src/lib/eliom_request_info.client.mli      |  10 +-
 src/lib/eliom_request_info.server.ml       |   6 +-
 src/lib/eliom_request_info.server.mli      |  12 +-
 src/lib/eliom_route.client.ml              |   7 +-
 src/lib/eliom_route.server.ml              | 310 +++++----
 src/lib/eliom_route.server.mli             |   6 +-
 src/lib/eliom_route_base.shared.ml         | 183 +++---
 src/lib/eliom_service.client.ml            |   2 +-
 src/lib/eliom_service.client.mli           |   4 +-
 src/lib/eliom_service_base.eliom           |   8 +-
 src/lib/eliom_service_sigs.shared.mli      |   4 +-
 src/lib/eliom_shared.client.mli            |   4 +-
 src/lib/eliom_shared.eliom                 | 250 ++++----
 src/lib/eliom_shared.server.mli            |   4 +-
 src/lib/eliom_shared_sigs.shared.mli       |  32 +-
 src/lib/eliom_state.server.ml              | 416 ++++++------
 src/lib/eliom_state.server.mli             |  99 ++-
 src/lib/eliom_stream.shared.ml             | 141 +++--
 src/lib/eliom_stream.shared.mli            |  72 +--
 src/lib/eliom_tools.eliom                  |   6 +-
 src/lib/eliom_tools.eliomi                 |   8 +-
 src/lib/server/eliommod.ml                 |   2 +-
 src/lib/server/eliommod.mli                |   4 +-
 src/lib/server/eliommod_cookies.ml         | 329 +++++-----
 src/lib/server/eliommod_cookies.mli        |  20 +-
 src/lib/server/eliommod_gc.ml              | 287 ++++-----
 src/lib/server/eliommod_pagegen.ml         | 265 ++++----
 src/lib/server/eliommod_pagegen.mli        |  13 +-
 src/lib/server/eliommod_persess.ml         | 155 +++--
 src/lib/server/eliommod_persess.mli        |   8 +-
 src/lib/server/eliommod_sessadmin.ml       |  46 +-
 src/lib/server/eliommod_sessadmin.mli      |  12 +-
 src/lib/server/eliommod_sessexpl.ml        |  38 +-
 src/lib/server/eliommod_sessexpl.mli       |  28 +-
 src/lib/server/eliommod_sessiongroups.ml   | 261 ++++----
 src/lib/server/eliommod_sessiongroups.mli  |  16 +-
 src/lib/server/eliommod_timeouts.ml        |  16 +-
 src/lib/server/monitor/eliom_monitor.ml    | 124 ++--
 src/lib/server/monitor/eliom_monitor.mli   |   4 +-
 85 files changed, 3089 insertions(+), 3038 deletions(-)

diff --git a/src/lib/client/eliommod_dom.ml b/src/lib/client/eliommod_dom.ml
index 54028c8fb9..14871c251e 100644
--- a/src/lib/client/eliommod_dom.ml
+++ b/src/lib/client/eliommod_dom.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -479,7 +479,7 @@ let fetch_linked_css e =
           let css =
             Eliom_request.http_get href [] Eliom_request.string_result
           in
-          acc @ [e, (e##.media, href, css >|= snd)]
+          acc @ [e, (e##.media, href, snd css)]
     | Dom.Element e ->
         let c = e##.childNodes in
         let acc = ref acc in
@@ -578,26 +578,25 @@ let rewrite_css_url ~prefix css pos =
 let import_re = Regexp.regexp "@import\\s*"
 
 let rec rewrite_css ~max (media, href, css) =
-  Lwt.catch
-    (fun () ->
-       css >>= function
-       | None -> Lwt.return_nil
-       | Some css ->
-           if !Eliom_config.debug_timings
-           then Console.console##(time (Js.string ("rewrite_CSS: " ^ href)));
-           let* imports, css =
-             rewrite_css_import ~max ~prefix:(basedir href) ~media css 0
-           in
-           if !Eliom_config.debug_timings
-           then Console.console##(timeEnd (Js.string ("rewrite_CSS: " ^ href)));
-           Lwt.return (imports @ [media, css]))
-    (fun _ -> Lwt.return [media, Printf.sprintf "@import url(%s);" href])
+  try
+    match css with
+    | None -> []
+    | Some css ->
+        if !Eliom_config.debug_timings
+        then Console.console##(time (Js.string ("rewrite_CSS: " ^ href)));
+        let imports, css =
+          rewrite_css_import ~max ~prefix:(basedir href) ~media css 0
+        in
+        if !Eliom_config.debug_timings
+        then Console.console##(timeEnd (Js.string ("rewrite_CSS: " ^ href)));
+        imports @ [media, css]
+  with _ -> [media, Printf.sprintf "@import url(%s);" href]
 
 and rewrite_css_import ?(charset = "") ~max ~prefix ~media css pos =
   match Regexp.search import_re css pos with
   | None ->
       (* No @import anymore, rewrite url. *)
-      Lwt.return ([], rewrite_css_url ~prefix css pos)
+      [], rewrite_css_url ~prefix css pos
   | Some (i, res) -> (
       (* Found @import rule, try to preload. *)
       let init = String.sub css pos (i - pos) in
@@ -606,45 +605,46 @@ and rewrite_css_import ?(charset = "") ~max ~prefix ~media css pos =
         let i = i + String.length (Regexp.matched_string res) in
         let i, href = parse_url ~prefix css i in
         let i, media' = parse_media css i in
-        let* import =
-          if max = 0
-          then
-            (* Maximum imbrication of @import reached, rewrite url. *)
-            Lwt.return
-              [media, Printf.sprintf "@import url('%s') %s;\n" href media']
-          else if media##.length > 0 && String.length media' > 0
-          then
-            (* TODO combine media if possible...
+        let (imports, css), import =
+          Fiber.pair
+            (fun () -> rewrite_css_import ~charset ~max ~prefix ~media css i)
+            (fun () ->
+               if
+                 (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+                 max = 0
+               then
+                 (* Maximum imbrication of @import reached, rewrite url. *)
+                 [media, Printf.sprintf "@import url('%s') %s;\n" href media']
+               else if media##.length > 0 && String.length media' > 0
+               then
+                 (* TODO combine media if possible...
                in the mean time keep explicit import. *)
-            Lwt.return
-              [media, Printf.sprintf "@import url('%s') %s;\n" href media']
-          else
-            let media =
-              if media##.length > 0 then media else Js.string media'
-            in
-            let css =
-              Eliom_request.http_get href [] Eliom_request.string_result
-            in
-            rewrite_css ~max:(max - 1) (media, href, css >|= snd)
-        and* imports, css =
-          rewrite_css_import ~charset ~max ~prefix ~media css i
+                 [media, Printf.sprintf "@import url('%s') %s;\n" href media']
+               else
+                 let media =
+                   if media##.length > 0 then media else Js.string media'
+                 in
+                 let css =
+                   Eliom_request.http_get href [] Eliom_request.string_result
+                 in
+                 rewrite_css ~max:(max - 1) (media, href, snd css))
         in
-        Lwt.return (import @ imports, css)
+        import @ imports, css
       with
-      | Incorrect_url -> Lwt.return ([], rewrite_css_url ~prefix css pos)
+      | Incorrect_url -> [], rewrite_css_url ~prefix css pos
       | exn ->
           Logs.info ~src:section (fun fmt ->
             fmt
               ("Error while importing css" ^^ "@\n%s")
               (Printexc.to_string exn));
-          Lwt.return ([], rewrite_css_url ~prefix css pos))
+          [], rewrite_css_url ~prefix css pos)
 
 let max_preload_depth = ref 4
 
 let build_style (e, css) =
-  let* css = rewrite_css ~max:!max_preload_depth css in
-  (* lwt css = *)
-  Lwt_list.map_p
+  let css = rewrite_css ~max:!max_preload_depth css in
+  Fiber.List.map
+    (* lwt css = *)
     (fun (media, css) ->
        let style = Dom_html.createStyle Dom_html.document in
        style##._type := Js.string "text/css";
@@ -655,7 +655,7 @@ let build_style (e, css) =
        if Js.Optdef.test styleSheet
        then Js.Unsafe.(set styleSheet (Js.string "cssText") (Js.string css))
        else style##.innerHTML := Js.string css;
-       Lwt.return (e, (style :> Dom.node Js.t)))
+       e, (style :> Dom.node Js.t))
     css
 
 (* IE8 doesn't allow appendChild on noscript-elements *)
@@ -669,7 +669,7 @@ let build_style (e, css) =
 let preload_css (doc : Dom_html.element Js.t) =
   if !Eliom_config.debug_timings
   then Console.console##(time (Js.string "preload_css (fetch+rewrite)"));
-  let* css = Lwt_list.map_p build_style (fetch_linked_css (get_head doc)) in
+  let css = Fiber.List.map build_style (fetch_linked_css (get_head doc)) in
   let css = List.concat css in
   List.iter
     (fun (e, css) ->
@@ -682,8 +682,7 @@ let preload_css (doc : Dom_html.element Js.t) =
              section (fun fmt -> fmt "Unique CSS skipped..."))
     css;
   if !Eliom_config.debug_timings
-  then Console.console##(timeEnd (Js.string "preload_css (fetch+rewrite)"));
-  Lwt.return_unit
+  then Console.console##(timeEnd (Js.string "preload_css (fetch+rewrite)"))
 
 (** Window scrolling *)
 
diff --git a/src/lib/client/eliommod_dom.mli b/src/lib/client/eliommod_dom.mli
index 5286bd8e50..70267dcd90 100644
--- a/src/lib/client/eliommod_dom.mli
+++ b/src/lib/client/eliommod_dom.mli
@@ -71,7 +71,7 @@ val html_document :
 (** Assuming [d] has a body and head element, [html_document d] will
     return the same document as html *)
 
-val preload_css : Dom_html.element Js.t -> unit Lwt.t
+val preload_css : Dom_html.element Js.t -> unit
 (** [preload_css e] downloads every css included in every link
     elements that is a descendant of [e] and replace it and its linked
     css by inline [<style>] elements *)
diff --git a/src/lib/eio_react.shared.ml b/src/lib/eio_react.shared.ml
index 4a193f2032..1a6743de68 100644
--- a/src/lib/eio_react.shared.ml
+++ b/src/lib/eio_react.shared.ml
@@ -1,8 +1,8 @@
+open Eio.Std
+
 (* This file is part of Lwt, released under the MIT license. See LICENSE.md for
    details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
 
-open Lwt.Infix
-
 type 'a event = 'a React.event
 type 'a signal = 'a React.signal
 
@@ -25,14 +25,22 @@ module E = struct
       event
 
   let next ev =
-    let waiter, wakener = Lwt.task () in
-    let ev = map (fun x -> Lwt.wakeup wakener x) (once ev) in
-    Lwt.on_cancel waiter (fun () -> stop ev);
+    let waiter, wakener =
+      Promise.create
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
+    let ev = map (fun x -> Promise.resolve wakener x) (once ev) in
+    Lwt.on_cancel
+      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+      waiter (fun () -> stop ev);
     waiter
 
   let limit f e =
     (* Thread which prevents [e] from occurring while it is sleeping *)
-    let limiter = ref Lwt.return_unit in
+    let limiter = ref () in
     (* The occurrence that is delayed until the limiter returns. *)
     let delayed = ref None in
     (* The resulting event. *)
@@ -71,12 +79,19 @@ module E = struct
     in
     select [iter; event]
 
-  let cancel_thread t () = Lwt.cancel t
+  let cancel_thread t () =
+    Lwt.cancel
+      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+      t
 
   let from f =
     let event, push = create () in
-    let rec loop () = f () >>= fun x -> push x; loop () in
-    let t = Lwt.pause () >>= loop in
+    let rec loop () =
+      let x = f () in
+      push x; loop ()
+    in
+    let t = loop (Fiber.yield ()) in
     with_finaliser (cancel_thread t) event
 
   let to_stream event =
@@ -87,7 +102,7 @@ module E = struct
   let of_stream stream =
     let event, push = create () in
     let t =
-      Lwt.pause () >>= fun () ->
+      Fiber.yield ();
       Eliom_stream.iter
         (fun v ->
            try push v
@@ -125,12 +140,12 @@ module E = struct
 
   let run_s e =
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun t ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> t))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> t))
              (fun v -> push v);
            None)
         e
@@ -150,12 +165,12 @@ module E = struct
 
   let map_s f e =
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun x ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (fun v -> push v);
            None)
         e
@@ -175,12 +190,12 @@ module E = struct
 
   let app_s ef e =
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun (f, x) ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (fun v -> push v);
            None)
         (app (map (fun f x -> f, x) ef) e)
@@ -200,12 +215,12 @@ module E = struct
 
   let filter_s f e =
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun x ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (function true -> push x | false -> ());
            None)
         e
@@ -225,12 +240,12 @@ module E = struct
 
   let fmap_s f e =
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun x ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (function Some x -> push x | None -> ());
            None)
         e
@@ -240,7 +255,7 @@ module E = struct
   let diff_s f e =
     let previous = ref None in
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun x ->
@@ -251,7 +266,7 @@ module E = struct
            | Some y ->
                previous := Some x;
                Lwt.on_success
-                 (Lwt_mutex.with_lock mutex (fun () -> f x y))
+                 (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x y))
                  (fun v -> push v);
                None)
         e
@@ -261,12 +276,12 @@ module E = struct
   let accum_s ef acc =
     let acc = ref acc in
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun f ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f !acc))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f !acc))
              (fun x ->
                 acc := x;
                 push x);
@@ -278,12 +293,12 @@ module E = struct
   let fold_s f acc e =
     let acc = ref acc in
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun x ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f !acc x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f !acc x))
              (fun x ->
                 acc := x;
                 push x);
@@ -293,17 +308,19 @@ module E = struct
     select [iter; event]
 
   let rec rev_fold f acc = function
-    | [] -> Lwt.return acc
-    | x :: l -> rev_fold f acc l >>= fun acc -> f acc x
+    | [] -> acc
+    | x :: l ->
+        let acc = rev_fold f acc l in
+        f acc x
 
   let merge_s f acc el =
     let event, push = create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       fmap
         (fun l ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> rev_fold f acc l))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> rev_fold f acc l))
              (fun v -> push v);
            None)
         (merge (fun acc x -> x :: acc) [] el)
@@ -379,93 +396,95 @@ module S = struct
 
   let run_s ?eq s =
     let event, push = E.create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
         (fun t ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> t))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> t))
              (fun v -> push v);
            None)
         (changes s)
     in
-    Lwt_mutex.with_lock mutex (fun () -> value s) >>= fun x ->
-    Lwt.return (hold ?eq x (E.select [iter; event]))
+    let x = Eio.Mutex.use_rw ~protect:false mutex (fun () -> value s) in
+    hold ?eq x (E.select [iter; event])
 
   let map_s ?eq f s =
     let event, push = E.create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
         (fun x ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (fun v -> push v);
            None)
         (changes s)
     in
-    Lwt_mutex.with_lock mutex (fun () -> f (value s)) >>= fun x ->
-    Lwt.return (hold ?eq x (E.select [iter; event]))
+    let x = Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) in
+    hold ?eq x (E.select [iter; event])
 
   let app_s ?eq sf s =
     let event, push = E.create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
         (fun (f, x) ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (fun v -> push v);
            None)
         (E.app (E.map (fun f x -> f, x) (changes sf)) (changes s))
     in
-    Lwt_mutex.with_lock mutex (fun () -> (value sf) (value s)) >>= fun x ->
-    Lwt.return (hold ?eq x (E.select [iter; event]))
+    let x =
+      Eio.Mutex.use_rw ~protect:false mutex (fun () -> (value sf) (value s))
+    in
+    hold ?eq x (E.select [iter; event])
 
   let filter_s ?eq f i s =
     let event, push = E.create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
         (fun x ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (function true -> push x | false -> ());
            None)
         (changes s)
     in
     let x = value s in
-    Lwt_mutex.with_lock mutex (fun () -> f x) >>= function
-    | true -> Lwt.return (hold ?eq x (E.select [iter; event]))
-    | false -> Lwt.return (hold ?eq i (E.select [iter; event]))
+    match Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x) with
+    | true -> hold ?eq x (E.select [iter; event])
+    | false -> hold ?eq i (E.select [iter; event])
 
   let fmap_s ?eq f i s =
     let event, push = E.create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
         (fun x ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (function Some x -> push x | None -> ());
            None)
         (changes s)
     in
-    Lwt_mutex.with_lock mutex (fun () -> f (value s)) >>= function
-    | Some x -> Lwt.return (hold ?eq x (E.select [iter; event]))
-    | None -> Lwt.return (hold ?eq i (E.select [iter; event]))
+    match Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) with
+    | Some x -> hold ?eq x (E.select [iter; event])
+    | None -> hold ?eq i (E.select [iter; event])
 
   let diff_s f s =
     let previous = ref (value s) in
     let event, push = E.create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
         (fun x ->
            let y = !previous in
            previous := x;
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x y))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x y))
              (fun v -> push v);
            None)
         (changes s)
@@ -477,24 +496,28 @@ module S = struct
   let fold_s ?eq f i e = hold ?eq i (E.fold_s f i e)
 
   let rec rev_fold f acc = function
-    | [] -> Lwt.return acc
-    | x :: l -> rev_fold f acc l >>= fun acc -> f acc x
+    | [] -> acc
+    | x :: l ->
+        let acc = rev_fold f acc l in
+        f acc x
 
   let merge_s ?eq f acc sl =
     let s = merge (fun acc x -> x :: acc) [] sl in
     let event, push = E.create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
         (fun l ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> rev_fold f acc l))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> rev_fold f acc l))
              (fun v -> push v);
            None)
         (changes s)
     in
-    Lwt_mutex.with_lock mutex (fun () -> rev_fold f acc (value s)) >>= fun x ->
-    Lwt.return (hold ?eq x (E.select [iter; event]))
+    let x =
+      Eio.Mutex.use_rw ~protect:false mutex (fun () -> rev_fold f acc (value s))
+    in
+    hold ?eq x (E.select [iter; event])
 
   let l1_s ?eq f s1 = map_s ?eq f s1
 
@@ -542,16 +565,16 @@ module S = struct
 
   let bind_s ?eq s f =
     let event, push = E.create () in
-    let mutex = Lwt_mutex.create () in
+    let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
         (fun x ->
            Lwt.on_success
-             (Lwt_mutex.with_lock mutex (fun () -> f x))
+             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
              (fun v -> push v);
            None)
         (changes s)
     in
-    Lwt_mutex.with_lock mutex (fun () -> f (value s)) >>= fun x ->
-    Lwt.return (switch ?eq (hold ~eq:( == ) x (E.select [iter; event])))
+    let x = Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) in
+    switch ?eq (hold ~eq:( == ) x (E.select [iter; event]))
 end
diff --git a/src/lib/eio_react.shared.mli b/src/lib/eio_react.shared.mli
index 614f8e4498..f58d859471 100644
--- a/src/lib/eio_react.shared.mli
+++ b/src/lib/eio_react.shared.mli
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* This file is part of Lwt, released under the MIT license. See LICENSE.md for
    details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
 
@@ -26,7 +28,7 @@ module E : sig
         [e], except that [f] is called when [e'] is garbage
         collected. *)
 
-  val next : 'a event -> 'a Lwt.t
+  val next : 'a event -> 'a
   (** [next e] returns the next occurrence of [e].
 
       Avoid trying to create an “asynchronous loop” by calling [next e] again in
@@ -44,13 +46,13 @@ module E : sig
       [to_stream e], and repeatedly call {!Eliom_stream.next} on the resulting
       stream. *)
 
-  val limit : (unit -> unit Lwt.t) -> 'a event -> 'a event
+  val limit : (unit -> unit) -> 'a event -> 'a event
   (** [limit f e] limits the rate of [e] with [f].
 
         For example, to limit the rate of an event to 1 per second you
         can use: [limit (fun () -> Lwt_unix.sleep 1.0) event]. *)
 
-  val from : (unit -> 'a Lwt.t) -> 'a event
+  val from : (unit -> 'a) -> 'a event
   (** [from f] creates an event which occurs each time [f ()]
         returns a value. If [f] raises an exception, the event is just
         stopped. *)
@@ -67,7 +69,7 @@ module E : sig
         step, the exception is passed to [!]{!Lwt.async_exception_hook}, which
         terminates the process by default. *)
 
-  val delay : 'a event Lwt.t -> 'a event
+  val delay : 'a event Promise.t -> 'a event
   (** [delay promise] is an event which does not occur until
         [promise] resolves. Then it behaves as the event returned by
         [promise]. *)
@@ -86,20 +88,20 @@ module E : sig
 
       Note that [*_p] functions may not preserve event order. *)
 
-  val app_s : ('a -> 'b Lwt.t) event -> 'a event -> 'b event
-  val app_p : ('a -> 'b Lwt.t) event -> 'a event -> 'b event
-  val map_s : ('a -> 'b Lwt.t) -> 'a event -> 'b event
-  val map_p : ('a -> 'b Lwt.t) -> 'a event -> 'b event
-  val filter_s : ('a -> bool Lwt.t) -> 'a event -> 'a event
-  val filter_p : ('a -> bool Lwt.t) -> 'a event -> 'a event
-  val fmap_s : ('a -> 'b option Lwt.t) -> 'a event -> 'b event
-  val fmap_p : ('a -> 'b option Lwt.t) -> 'a event -> 'b event
-  val diff_s : ('a -> 'a -> 'b Lwt.t) -> 'a event -> 'b event
-  val accum_s : ('a -> 'a Lwt.t) event -> 'a -> 'a event
-  val fold_s : ('a -> 'b -> 'a Lwt.t) -> 'a -> 'b event -> 'a event
-  val merge_s : ('a -> 'b -> 'a Lwt.t) -> 'a -> 'b event list -> 'a event
-  val run_s : 'a Lwt.t event -> 'a event
-  val run_p : 'a Lwt.t event -> 'a event
+  val app_s : ('a -> 'b) event -> 'a event -> 'b event
+  val app_p : ('a -> 'b) event -> 'a event -> 'b event
+  val map_s : ('a -> 'b) -> 'a event -> 'b event
+  val map_p : ('a -> 'b) -> 'a event -> 'b event
+  val filter_s : ('a -> bool) -> 'a event -> 'a event
+  val filter_p : ('a -> bool) -> 'a event -> 'a event
+  val fmap_s : ('a -> 'b option) -> 'a event -> 'b event
+  val fmap_p : ('a -> 'b option) -> 'a event -> 'b event
+  val diff_s : ('a -> 'a -> 'b) -> 'a event -> 'b event
+  val accum_s : ('a -> 'a) event -> 'a -> 'a event
+  val fold_s : ('a -> 'b -> 'a) -> 'a -> 'b event -> 'a event
+  val merge_s : ('a -> 'b -> 'a) -> 'a -> 'b event list -> 'a event
+  val run_s : 'a Promise.t event -> 'a event
+  val run_p : 'a Promise.t event -> 'a event
 end
 
 module S : sig
@@ -123,8 +125,8 @@ module S : sig
   val bind_s :
      ?eq:('b -> 'b -> bool)
     -> 'a signal
-    -> ('a -> 'b signal Lwt.t)
-    -> 'b signal Lwt.t
+    -> ('a -> 'b signal)
+    -> 'b signal
   (** Same as {!bind} except that [f] returns a promise. Calls to [f]
         are serialized. *)
 
@@ -135,11 +137,7 @@ module S : sig
         [s], except that [f] is called when [s'] is garbage
         collected. *)
 
-  val limit :
-     ?eq:('a -> 'a -> bool)
-    -> (unit -> unit Lwt.t)
-    -> 'a signal
-    -> 'a signal
+  val limit : ?eq:('a -> 'a -> bool) -> (unit -> unit) -> 'a signal -> 'a signal
   (** [limit f s] limits the rate of [s] update with [f].
 
         For example, to limit it to 1 per second, you can use: [limit
@@ -159,103 +157,90 @@ module S : sig
 
   val app_s :
      ?eq:('b -> 'b -> bool)
-    -> ('a -> 'b Lwt.t) signal
+    -> ('a -> 'b) signal
     -> 'a signal
-    -> 'b signal Lwt.t
+    -> 'b signal
 
-  val map_s :
-     ?eq:('b -> 'b -> bool)
-    -> ('a -> 'b Lwt.t)
-    -> 'a signal
-    -> 'b signal Lwt.t
+  val map_s : ?eq:('b -> 'b -> bool) -> ('a -> 'b) -> 'a signal -> 'b signal
 
   val filter_s :
      ?eq:('a -> 'a -> bool)
-    -> ('a -> bool Lwt.t)
+    -> ('a -> bool)
     -> 'a
     -> 'a signal
-    -> 'a signal Lwt.t
+    -> 'a signal
 
   val fmap_s :
      ?eq:('b -> 'b -> bool)
-    -> ('a -> 'b option Lwt.t)
+    -> ('a -> 'b option)
     -> 'b
     -> 'a signal
-    -> 'b signal Lwt.t
-
-  val diff_s : ('a -> 'a -> 'b Lwt.t) -> 'a signal -> 'b event
-  val sample_s : ('b -> 'a -> 'c Lwt.t) -> 'b event -> 'a signal -> 'c event
+    -> 'b signal
 
-  val accum_s :
-     ?eq:('a -> 'a -> bool)
-    -> ('a -> 'a Lwt.t) event
-    -> 'a
-    -> 'a signal
+  val diff_s : ('a -> 'a -> 'b) -> 'a signal -> 'b event
+  val sample_s : ('b -> 'a -> 'c) -> 'b event -> 'a signal -> 'c event
+  val accum_s : ?eq:('a -> 'a -> bool) -> ('a -> 'a) event -> 'a -> 'a signal
 
   val fold_s :
      ?eq:('a -> 'a -> bool)
-    -> ('a -> 'b -> 'a Lwt.t)
+    -> ('a -> 'b -> 'a)
     -> 'a
     -> 'b event
     -> 'a signal
 
   val merge_s :
      ?eq:('a -> 'a -> bool)
-    -> ('a -> 'b -> 'a Lwt.t)
+    -> ('a -> 'b -> 'a)
     -> 'a
     -> 'b signal list
-    -> 'a signal Lwt.t
-
-  val l1_s :
-     ?eq:('b -> 'b -> bool)
-    -> ('a -> 'b Lwt.t)
     -> 'a signal
-    -> 'b signal Lwt.t
+
+  val l1_s : ?eq:('b -> 'b -> bool) -> ('a -> 'b) -> 'a signal -> 'b signal
 
   val l2_s :
      ?eq:('c -> 'c -> bool)
-    -> ('a -> 'b -> 'c Lwt.t)
+    -> ('a -> 'b -> 'c)
     -> 'a signal
     -> 'b signal
-    -> 'c signal Lwt.t
+    -> 'c signal
 
   val l3_s :
      ?eq:('d -> 'd -> bool)
-    -> ('a -> 'b -> 'c -> 'd Lwt.t)
+    -> ('a -> 'b -> 'c -> 'd)
     -> 'a signal
     -> 'b signal
     -> 'c signal
-    -> 'd signal Lwt.t
+    -> 'd signal
 
   val l4_s :
      ?eq:('e -> 'e -> bool)
-    -> ('a -> 'b -> 'c -> 'd -> 'e Lwt.t)
+    -> ('a -> 'b -> 'c -> 'd -> 'e)
     -> 'a signal
     -> 'b signal
     -> 'c signal
     -> 'd signal
-    -> 'e signal Lwt.t
+    -> 'e signal
 
   val l5_s :
      ?eq:('f -> 'f -> bool)
-    -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f Lwt.t)
+    -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f)
     -> 'a signal
     -> 'b signal
     -> 'c signal
     -> 'd signal
     -> 'e signal
-    -> 'f signal Lwt.t
+    -> 'f signal
 
   val l6_s :
      ?eq:('g -> 'g -> bool)
-    -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g Lwt.t)
+    -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g)
     -> 'a signal
     -> 'b signal
     -> 'c signal
     -> 'd signal
     -> 'e signal
     -> 'f signal
-    -> 'g signal Lwt.t
+    -> 'g signal
 
-  val run_s : ?eq:('a -> 'a -> bool) -> 'a Lwt.t signal -> 'a signal Lwt.t
+  val run_s : ?eq:('a -> 'a -> bool) -> 'a Promise.t signal -> 'a signal
 end
diff --git a/src/lib/eliom_bus.client.ml b/src/lib/eliom_bus.client.ml
index 6240ce0287..acc4ef6d8a 100644
--- a/src/lib/eliom_bus.client.ml
+++ b/src/lib/eliom_bus.client.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -32,31 +32,40 @@ type ('a, 'b) t =
   ; stream : 'b Eliom_stream.t Lazy.t
   ; queue : 'a Queue.t
   ; mutable max_size : int
-  ; write : 'a list -> unit Lwt.t
-  ; mutable waiter : unit -> unit Lwt.t
-  ; mutable last_wait : unit Lwt.t
+  ; write : 'a list -> unit
+  ; mutable waiter : unit -> unit
+  ; mutable last_wait : unit Promise.t
   ; mutable original_stream_available : bool
-  ; error_h : 'b option Lwt.t * exn Lwt.u }
+  ; error_h : 'b option Promise.t * exn Lwt.u }
 
 (* clone streams such that each clone of the original stream raise the same exceptions *)
 let consume (t, u) s =
   let t' =
-    Lwt.catch
-      (fun () -> Eliom_stream.iter (fun _ -> ()) s)
-      (fun e ->
-         (match Lwt.state t with Lwt.Sleep -> Lwt.wakeup_exn u e | _ -> ());
-         Lwt.fail e)
+    try Eliom_stream.iter (fun _ -> ()) s
+    with e ->
+      (match Promise.peek t with None -> Lwt.wakeup_exn u e | _ -> ());
+      raise e
   in
-  Lwt.choose [Lwt.bind t (fun _ -> Lwt.return_unit); t']
+  Fiber.any
+    (List.map
+       (fun p () -> Promise.await p)
+       (* TODO: ciao-lwt: The list [[ Lwt.bind t (fun _ -> Lwt.return_unit); t' ]] is expected to be a list of promises. Use [Fiber.fork_promise] to make a promise. *)
+       [ (let _ = t in
+          ())
+       ; t' ])
 
 let clone_exn (t, u) s =
   let s' = Eliom_stream.clone s in
   Eliom_stream.from (fun () ->
-    Lwt.catch
-      (fun () -> Lwt.choose [Eliom_stream.get s'; t])
-      (fun e ->
-         (match Lwt.state t with Lwt.Sleep -> Lwt.wakeup_exn u e | _ -> ());
-         Lwt.fail e))
+    try
+      Fiber.any
+        (List.map
+           (fun p () -> Promise.await p)
+           (* TODO: ciao-lwt: The list [[ Eliom_stream.get s'; t ]] is expected to be a list of promises. Use [Fiber.fork_promise] to make a promise. *)
+           [Eliom_stream.get s'; t])
+    with e ->
+      (match Promise.peek t with None -> Lwt.wakeup_exn u e | _ -> ());
+      raise e)
 
 type ('a, 'att, 'co, 'ext, 'reg) callable_bus_service =
   ( unit
@@ -74,25 +83,25 @@ type ('a, 'att, 'co, 'ext, 'reg) callable_bus_service =
 
 let create service channel waiter =
   let write x =
-    Lwt.catch
-      (fun () ->
-         let* _ =
-           Eliom_client.call_service
-             ~service:(service :> ('a, _, _, _, _) callable_bus_service)
-             () x
-         in
-         Lwt.return_unit)
-      (function
-        | Eliom_request.Failed_request 204 -> Lwt.return_unit
-        | exc -> Lwt.reraise exc)
+    try
+      let _ =
+        Eliom_client.call_service
+          ~service:(service :> ('a, _, _, _, _) callable_bus_service)
+          () x
+      in
+      ()
+    with Eliom_request.Failed_request 204 -> ()
   in
   let error_h =
-    let t, u = Lwt.wait () in
-    ( Lwt.catch
-        (fun () ->
-           let* _ = t in
-           assert false)
-        (fun e -> Lwt.fail e)
+    let t, u =
+      Promise.create
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
+    ( (try
+         let _ = t in
+         assert false
+       with e -> raise e)
     , u )
   in
   let stream =
@@ -109,7 +118,7 @@ let create service channel waiter =
     ; max_size = 20
     ; write
     ; waiter
-    ; last_wait = Lwt.return_unit
+    ; last_wait = ()
     ; original_stream_available = true
     ; error_h }
   in
@@ -117,9 +126,8 @@ let create service channel waiter =
      original channel (i.e. without message lost) is only available in
      the first loading phase. *)
   let _ =
-    let* () = Eliom_client.wait_load_end () in
-    t.original_stream_available <- false;
-    Lwt.return_unit
+    let () = Eliom_client.wait_load_end () in
+    t.original_stream_available <- false
   in
   t
 
@@ -145,14 +153,22 @@ let flush t =
   Queue.clear t.queue; t.write l
 
 let try_flush t =
-  Lwt.cancel t.last_wait;
+  Lwt.cancel
+    (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+    (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+    t.last_wait;
   if Queue.length t.queue >= t.max_size
   then flush t
   else
-    let th = Lwt.protected (t.waiter ()) in
+    let th =
+      Lwt.protected
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        (t.waiter ())
+    in
     t.last_wait <- th;
-    let _ = th >>= fun () -> flush t in
-    Lwt.return_unit
+    let _ = th; flush t in
+    ()
 
 let write t v = Queue.add v t.queue; try_flush t
 let close {channel; _} = Eliom_comet.close channel
@@ -160,6 +176,8 @@ let set_queue_size b s = b.max_size <- s
 
 let set_time_before_flush b t =
   b.waiter <-
-    (if t <= 0. then Lwt.pause else fun () -> Js_of_ocaml_lwt.Lwt_js.sleep t)
+    (if t <= 0.
+     then fun x1 -> Fiber.yield x1
+     else fun () -> Js_of_ocaml_lwt.Lwt_js.sleep t)
 
 let force_link = ()
diff --git a/src/lib/eliom_bus.client.mli b/src/lib/eliom_bus.client.mli
index 530c9cf692..b5511523d4 100644
--- a/src/lib/eliom_bus.client.mli
+++ b/src/lib/eliom_bus.client.mli
@@ -39,7 +39,7 @@ val original_stream : ('a, 'b) t -> 'b Eliom_stream.t
     received. This function can be called only in the onload event
     handler, if called outside, it will raise a Failure. *)
 
-val write : ('a, 'b) t -> 'a -> unit Lwt.t
+val write : ('a, 'b) t -> 'a -> unit
 (** [write b v] send [v] to the bus [b]. Every participant of the bus
     will receive [v], including the sender. *)
 
diff --git a/src/lib/eliom_bus.server.ml b/src/lib/eliom_bus.server.ml
index 0e8cae932c..5af198559a 100644
--- a/src/lib/eliom_bus.server.ml
+++ b/src/lib/eliom_bus.server.ml
@@ -1,5 +1,3 @@
-open Lwt.Syntax
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2010
@@ -27,7 +25,7 @@ type ('a, 'b) t =
   ; scope : Eliom_comet.Channel.comet_scope
   ; name : string option
   ; channel : 'b Eliom_comet.Channel.t option
-  ; write : 'a -> unit Lwt.t
+  ; write : 'a -> unit
   ; service : 'a Ecb.bus_send_service
   ; service_registered : bool Eliom_state.volatile_table option
   ; size : int option
@@ -36,7 +34,7 @@ type ('a, 'b) t =
 
 let register_sender scope service write =
   Eliom_registration.Action.register ~scope ~options:`NoReload ~service
-    (fun () x -> Lwt_list.iter_s write x)
+    (fun () x -> List.iter write x)
 
 let internal_wrap (bus : ('a, 'b) t) :
   ('a, 'b) Ecb.wrapped_bus * Eliom_common.unwrapper
@@ -94,8 +92,8 @@ let create_filtered ?scope ?name ?size ~filter typ =
   (*The stream*)
   let stream, push = Eliom_stream.create () in
   let push x =
-    let* y = filter x in
-    push (Some y); Lwt.return_unit
+    let y = filter x in
+    push (Some y)
   in
   let scope =
     match scope with
@@ -144,7 +142,7 @@ let create_filtered ?scope ?name ?size ~filter typ =
   bus
 
 let create ?scope ?name ?size typ =
-  create_filtered ~filter:Lwt.return ?scope ?name ?size typ
+  create_filtered ~filter:(fun x1 -> x1) ?scope ?name ?size typ
 
 let stream bus =
   match bus.scope with `Site -> bus.stream | `Client_process _ -> bus.stream
diff --git a/src/lib/eliom_bus.server.mli b/src/lib/eliom_bus.server.mli
index 13dea5e533..1cf0828641 100644
--- a/src/lib/eliom_bus.server.mli
+++ b/src/lib/eliom_bus.server.mli
@@ -56,7 +56,7 @@ val create_filtered :
    ?scope:[< Eliom_comet.Channel.comet_scope]
   -> ?name:string
   -> ?size:int
-  -> filter:('a -> 'b Lwt.t)
+  -> filter:('a -> 'b)
   -> 'a Deriving_Json.t
   -> ('a, 'b) t
 (** Same as [create], but data is filtered through [filter] function
@@ -70,6 +70,6 @@ val stream : ('a, 'b) t -> 'b Eliom_stream.t
     return the same stream. If you want to receive multiple times the
     same data, you should copy the stream with [Eliom_stream.clone] *)
 
-val write : ('a, 'b) t -> 'a -> unit Lwt.t
+val write : ('a, 'b) t -> 'a -> unit
 (** [write b x] sends the value [x] on the bus [b]. Every participant,
     including the server, will receive [x]. *)
diff --git a/src/lib/eliom_client.client.ml b/src/lib/eliom_client.client.ml
index 857a51b63e..c7788a9874 100644
--- a/src/lib/eliom_client.client.ml
+++ b/src/lib/eliom_client.client.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -39,8 +39,8 @@ type changepage_event =
   ; origin_id : int
   ; target_id : int option }
 
-let run_lwt_callbacks : 'a -> ('a -> unit Lwt.t) list -> unit Lwt.t =
- fun ev handlers -> Lwt_list.iter_s (fun h -> h ev) handlers
+let run_lwt_callbacks : 'a -> ('a -> unit) list -> unit =
+ fun ev handlers -> List.iter (fun h -> h ev) handlers
 
 let (onload, _, flush_onload, _push_onload) :
   ((unit -> unit) -> unit)
@@ -50,9 +50,9 @@ let (onload, _, flush_onload, _push_onload) :
   =
   Eliom_client_core.create_buffer ()
 
-let ( (onchangepage : (changepage_event -> unit Lwt.t) -> unit)
+let ( (onchangepage : (changepage_event -> unit) -> unit)
     , _
-    , (flush_onchangepage : unit -> (changepage_event -> unit Lwt.t) list)
+    , (flush_onchangepage : unit -> (changepage_event -> unit) list)
     , _ )
   =
   Eliom_client_core.create_buffer ()
@@ -77,8 +77,12 @@ let run_onunload_wrapper set_content cancel =
       set_content ()
 
 let lwt_onload () =
-  let t, u = Lwt.wait () in
-  onload (Lwt.wakeup u);
+  let t, u =
+    Promise.create
+      (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+      ()
+  in
+  onload (fun x1 -> Promise.resolve u x1);
   t
 
 (* == Initialize the client values sent with a request *)
@@ -202,7 +206,7 @@ let form_handler :
       if String.lowercase_ascii (Js.to_string form##._method) = "get"
       then `Form_get
       else `Form_post
-    and f _ = Lwt.return_false in
+    and f _ = false in
     Js.bool
       (Eliom_client_core.raw_form_handler form kind
          (get_element_cookies_info form)
@@ -428,17 +432,16 @@ let scroll_to_fragment ?offset fragment =
         let elem = Dom_html.document##(getElementById (Js.string fragment)) in
         Js.Opt.iter elem scroll_to_element)
 
-let with_progress_cursor : 'a Lwt.t -> 'a Lwt.t =
+let with_progress_cursor : 'a Promise.t -> 'a =
  fun t ->
-  Lwt.catch
-    (fun () ->
-       Dom_html.document##.body##.style##.cursor := Js.string "progress";
-       let* res = t in
-       Dom_html.document##.body##.style##.cursor := Js.string "auto";
-       Lwt.return res)
-    (fun exn ->
-       Dom_html.document##.body##.style##.cursor := Js.string "auto";
-       Lwt.fail exn)
+  try
+    Dom_html.document##.body##.style##.cursor := Js.string "progress";
+    let res = t in
+    Dom_html.document##.body##.style##.cursor := Js.string "auto";
+    res
+  with exn ->
+    Dom_html.document##.body##.style##.cursor := Js.string "auto";
+    raise exn
 
 (* Type for partially unwrapped elt. *)
 type tmp_recontent =
@@ -634,8 +637,7 @@ type page =
   ; mutable previous_page : int option
   ; set_page_status : ?step:React.step -> Page_status_t.t -> unit
   ; mutable dom : Dom_html.bodyElement Js.t option
-  ; mutable reload_function :
-      (unit -> unit -> Eliom_service.result Lwt.t) option }
+  ; mutable reload_function : (unit -> unit -> Eliom_service.result) option }
 
 let string_of_page p =
   Printf.sprintf "%d/%d %s %s %d %b" p.page_unique_id p.page_id.state_index
@@ -696,10 +698,10 @@ let set_active_page p =
 
 (* This key serves as a hook to access the page the currently running code is
    generating. *)
-let this_page : page Lwt.key = Lwt.new_key ()
+let this_page : page Lwt.key = Fiber.create_key ()
 
 let get_this_page () =
-  match Lwt.get this_page with
+  match Fiber.get this_page with
   | Some p -> p
   | None ->
       Logs.debug ~src:section_page (fun fmt -> fmt "No page in context");
@@ -713,7 +715,7 @@ let with_new_page ?state_id ?old_page ~replace () f =
     | None -> None, None
   in
   let page = mk_page ?state_id ?url ?previous_page ~status:Generating () in
-  Lwt.with_value this_page (Some page) f
+  Fiber.with_binding this_page page f
 
 module History = struct
   let section = Logs.Src.create "eliom:client:history"
@@ -845,7 +847,7 @@ let update_state () =
 let lock_request_handling = Eliom_request.lock
 let unlock_request_handling = Eliom_request.unlock
 
-type ('a, +'b) server_function = 'a -> 'b Lwt.t
+type ('a, +'b) server_function = 'a -> 'b
 
 let only_replace_body = ref false
 let persist_document_head () = only_replace_body := true
@@ -1006,58 +1008,65 @@ let init () =
         onload_handler := None
     | None -> ());
     Eliom_client_core.set_initial_load ();
-    Lwt.async (fun () ->
-      if !Eliom_config.debug_timings
-      then Console.console##(time (Js.string "onload"));
-      let* () =
-        Eliom_request_info.set_session_info
-          ~uri:
-            (String.concat "/"
-               (Eliom_request_info.get_csp_original_full_path ()))
-          js_data.Eliom_common.ejs_sess_info
-        @@ fun () -> Lwt.return_unit
-      in
-      (* Give the browser the chance to actually display the page NOW *)
-      let* () = Js_of_ocaml_lwt.Lwt_js.sleep 0.001 in
-      (* Ordering matters. See [Eliom_client.set_content] for explanations *)
-      relink_request_nodes Dom_html.document##.documentElement;
-      let root = Dom_html.document##.documentElement in
-      let closure_nodeList, attrib_nodeList =
-        relink_page_but_client_values root
-      in
-      do_request_data js_data.Eliom_common.ejs_request_data;
-      (* XXX One should check that all values have been unwrapped.
+    Fiber.fork
+      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+      (fun () ->
+         if !Eliom_config.debug_timings
+         then Console.console##(time (Js.string "onload"));
+         let () =
+           Eliom_request_info.set_session_info
+             ~uri:
+               (String.concat "/"
+                  (Eliom_request_info.get_csp_original_full_path ()))
+             js_data.Eliom_common.ejs_sess_info
+           @@ fun () -> ()
+         in
+         let
+             (* Give the browser the chance to actually display the page NOW *)
+               ()
+           =
+           Js_of_ocaml_lwt.Lwt_js.sleep 0.001
+         in
+         (* Ordering matters. See [Eliom_client.set_content] for explanations *)
+         relink_request_nodes Dom_html.document##.documentElement;
+         let root = Dom_html.document##.documentElement in
+         let closure_nodeList, attrib_nodeList =
+           relink_page_but_client_values root
+         in
+         do_request_data js_data.Eliom_common.ejs_request_data;
+         (* XXX One should check that all values have been unwrapped.
             In fact, client values should be special and all other values
             should be eagerly unwrapped. *)
-      let () =
-        relink_attribs root js_data.Eliom_common.ejs_client_attrib_table
-          attrib_nodeList
-      in
-      let onload_closure_nodes =
-        relink_closure_nodes root js_data.Eliom_common.ejs_event_handler_table
-          closure_nodeList
-      in
-      Eliom_client_core.reset_request_nodes ();
-      Eliommod_dom.add_formdata_hack_onclick_handler ();
-      if not (is_client_app ()) then dom_history_ready := true;
-      let load_callbacks =
-        flush_onload ()
-        @ [onload_closure_nodes; Eliom_client_core.broadcast_load_end]
-      in
-      Lwt_mutex.unlock Eliom_client_core.load_mutex;
-      run_callbacks load_callbacks;
-      if !Eliom_config.debug_timings
-      then Console.console##(timeEnd (Js.string "onload"));
-      Lwt.return_unit);
+         let () =
+           relink_attribs root js_data.Eliom_common.ejs_client_attrib_table
+             attrib_nodeList
+         in
+         let onload_closure_nodes =
+           relink_closure_nodes root
+             js_data.Eliom_common.ejs_event_handler_table closure_nodeList
+         in
+         Eliom_client_core.reset_request_nodes ();
+         Eliommod_dom.add_formdata_hack_onclick_handler ();
+         if not (is_client_app ()) then dom_history_ready := true;
+         let load_callbacks =
+           flush_onload ()
+           @ [onload_closure_nodes; Eliom_client_core.broadcast_load_end]
+         in
+         Eio.Mutex.unlock Eliom_client_core.load_mutex;
+         run_callbacks load_callbacks;
+         if !Eliom_config.debug_timings
+         then Console.console##(timeEnd (Js.string "onload")));
     Js._false
   in
   Logs.debug ~src:section (fun fmt -> fmt "Set load/onload events");
   if Dom_html.document##.readyState = Js.string "complete"
   then
-    Lwt.async @@ fun () ->
-    let* () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
-    let _ = onload () in
-    Lwt.return_unit
+    Fiber.fork
+      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+      (fun () ->
+         let () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
+         let _ = onload () in
+         ())
   else
     onload_handler :=
       Some
@@ -1165,7 +1174,7 @@ let raw_call_service
      Also set with_credentials to true in CORS configuration.
   *)
   let with_credentials = not (Eliom_service.is_external service) in
-  let* uri, content =
+  let uri, content =
     match
       create_request_ ?absolute ?absolute_path ?https ~service ?hostname ?port
         ?fragment ?keep_nl_params ?nl_params ?keep_get_na_params get_params
@@ -1193,8 +1202,8 @@ let raw_call_service
           Eliom_request.string_result
   in
   match content with
-  | None -> Lwt.fail (Eliom_request.Failed_request 204)
-  | Some content -> Lwt.return (uri, content)
+  | None -> raise (Eliom_request.Failed_request 204)
+  | Some content -> uri, content
 
 let call_service
       ?absolute
@@ -1213,12 +1222,12 @@ let call_service
       get_params
       post_params
   =
-  let* _, content =
+  let _, content =
     raw_call_service ?absolute ?absolute_path ?https ~service ?hostname ?port
       ?fragment ?keep_nl_params ?nl_params ?keep_get_na_params ?progress
       ?upload_progress ?override_mime_type get_params post_params
   in
-  Lwt.return content
+  content
 
 (* == Leave an application. *)
 
@@ -1288,7 +1297,7 @@ let unwrap_caml_content content =
   let r : 'a Eliom_runtime.eliom_caml_service_data =
     Eliom_unwrap.unwrap (Url.decode content) 0
   in
-  Lwt.return (r.Eliom_runtime.ecs_data, r.Eliom_runtime.ecs_request_data)
+  r.Eliom_runtime.ecs_data, r.Eliom_runtime.ecs_request_data
 
 let call_ocaml_service
       ?absolute
@@ -1308,22 +1317,22 @@ let call_ocaml_service
       post_params
   =
   Logs.debug ~src:section (fun fmt -> fmt "Call OCaml service");
-  let* _, content =
+  let _, content =
     raw_call_service ?absolute ?absolute_path ?https ~service ?hostname ?port
       ?fragment ?keep_nl_params ?nl_params ?keep_get_na_params ?progress
       ?upload_progress ?override_mime_type get_params post_params
   in
-  let* () = Lwt_mutex.lock Eliom_client_core.load_mutex in
+  let () = Eio.Mutex.lock Eliom_client_core.load_mutex in
   Eliom_client_core.set_loading_phase ();
-  let* content, request_data = unwrap_caml_content content in
+  let content, request_data = unwrap_caml_content content in
   do_request_data request_data;
   Eliom_client_core.reset_request_nodes ();
   let load_callbacks = [Eliom_client_core.broadcast_load_end] in
-  Lwt_mutex.unlock Eliom_client_core.load_mutex;
+  Eio.Mutex.unlock Eliom_client_core.load_mutex;
   run_callbacks load_callbacks;
   match content with
-  | `Success result -> Lwt.return result
-  | `Failure msg -> Lwt.fail (Eliom_client_value.Exception_on_server msg)
+  | `Success result -> result
+  | `Failure msg -> raise (Eliom_client_value.Exception_on_server msg)
 
 (* == Current uri.
 
@@ -1351,9 +1360,11 @@ let set_current_uri, get_current_uri =
     let current_uri = fst (Url.split_fragment uri) in
     (get_this_page ()).url <- current_uri;
     let path, all_get_params = path_and_args_of_uri current_uri in
-    Lwt.async @@ fun () ->
-    Eliom_request_info.update_session_info ~path ~all_get_params
-      ~all_post_params:None (fun () -> Lwt.return_unit)
+    Fiber.fork
+      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+      (fun () ->
+         Eliom_request_info.update_session_info ~path ~all_get_params
+           ~all_post_params:None (fun () -> ()))
   in
   let get_current_uri () = (get_this_page ()).url in
   set_current_uri, get_current_uri
@@ -1438,11 +1449,22 @@ module Page_status = struct
     @@ Events.inactive ()
 
   let while_active ?now ?(stop = React.E.never) action =
-    let thread = ref Lwt.return_unit in
+    let thread = ref () in
     onactive ?now ~stop (fun () -> thread := action ());
-    oninactive ~stop (fun () -> Lwt.cancel !thread);
+    oninactive ~stop (fun () ->
+      Lwt.cancel
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        !thread);
     Dom_reference.retain_generic (get_this_page ())
-      ~keep:(React.E.map (fun () -> Lwt.cancel !thread) stop)
+      ~keep:
+        (React.E.map
+           (fun () ->
+              Lwt.cancel
+                (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+                (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+                !thread)
+           stop)
 end
 
 let is_in_cache state_id =
@@ -1534,17 +1556,16 @@ let set_template_content ~replace ~uri ?fragment =
     (match fragment with
     | None -> change_url_string ~replace uri
     | Some fragment -> change_url_string ~replace (uri ^ "#" ^ fragment));
-    let* () = Lwt_mutex.lock Eliom_client_core.load_mutex in
-    let* (), request_data = unwrap_caml_content content in
+    let () = Eio.Mutex.lock Eliom_client_core.load_mutex in
+    let (), request_data = unwrap_caml_content content in
     do_request_data request_data;
     Eliom_client_core.reset_request_nodes ();
     let load_callbacks = flush_onload () in
-    Lwt_mutex.unlock Eliom_client_core.load_mutex;
-    run_callbacks load_callbacks;
-    Lwt.return_unit
-  and cancel () = Lwt.return_unit in
+    Eio.Mutex.unlock Eliom_client_core.load_mutex;
+    run_callbacks load_callbacks
+  and cancel () = () in
   function
-  | None -> Lwt.return_unit
+  | None -> ()
   | Some content -> run_onunload_wrapper (really_set content) cancel
 
 let set_uri ~replace ?fragment uri =
@@ -1578,7 +1599,7 @@ let set_content_local ?offset ?fragment new_page =
   Logs.debug ~src:section_page (fun fmt -> fmt "Set content local");
   let locked = ref true in
   let recover () =
-    if !locked then Lwt_mutex.unlock Eliom_client_core.load_mutex;
+    if !locked then Eio.Mutex.unlock Eliom_client_core.load_mutex;
     if !Eliom_config.debug_timings
     then Console.console##(timeEnd (Js.string "set_content_local"))
   and really_set () =
@@ -1586,12 +1607,10 @@ let set_content_local ?offset ?fragment new_page =
        Otherwise, the browser start to display the page before
        loading the CSS. *)
     let preloaded_css =
-      if !only_replace_body
-      then Lwt.return_unit
-      else Eliommod_dom.preload_css new_page
+      if !only_replace_body then () else Eliommod_dom.preload_css new_page
     in
     (* Wait for CSS to be inlined before substituting global nodes: *)
-    let* () = preloaded_css in
+    let () = preloaded_css in
     (* Really change page contents *)
     replace_page ~do_insert_base:true new_page;
     Eliommod_dom.add_formdata_hack_onclick_handler ();
@@ -1600,35 +1619,33 @@ let set_content_local ?offset ?fragment new_page =
       flush_onload () @ [Eliom_client_core.broadcast_load_end]
     in
     locked := false;
-    Lwt_mutex.unlock Eliom_client_core.load_mutex;
+    Eio.Mutex.unlock Eliom_client_core.load_mutex;
     (* run callbacks upon page activation (or now), but just once *)
     Page_status.onactive ~once:true (fun () -> run_callbacks load_callbacks);
     scroll_to_fragment ?offset fragment;
     advance_page ();
     if !Eliom_config.debug_timings
-    then Console.console##(timeEnd (Js.string "set_content_local"));
-    Lwt.return_unit
+    then Console.console##(timeEnd (Js.string "set_content_local"))
   in
-  let cancel () = recover (); Lwt.return_unit in
-  Lwt.catch
-    (fun () ->
-       let* () = Lwt_mutex.lock Eliom_client_core.load_mutex in
-       Eliom_client_core.set_loading_phase ();
-       if !Eliom_config.debug_timings
-       then Console.console##(time (Js.string "set_content_local"));
-       run_onunload_wrapper really_set cancel)
-    (fun exn ->
-       recover ();
-       Logs.debug ~src:section (fun fmt ->
-         fmt ("set_content_local" ^^ "@\n%s") (Printexc.to_string exn));
-       Lwt.fail exn)
+  let cancel () = recover () in
+  try
+    let () = Eio.Mutex.lock Eliom_client_core.load_mutex in
+    Eliom_client_core.set_loading_phase ();
+    if !Eliom_config.debug_timings
+    then Console.console##(time (Js.string "set_content_local"));
+    run_onunload_wrapper really_set cancel
+  with exn ->
+    recover ();
+    Logs.debug ~src:section (fun fmt ->
+      fmt ("set_content_local" ^^ "@\n%s") (Printexc.to_string exn));
+    raise exn
 
 (* Function to be called for server side services: *)
 let set_content ~replace ~uri ?offset ?fragment content =
   Logs.debug ~src:section_page (fun fmt -> fmt "Set content");
   (* TODO: too early? *)
   let target_uri = uri in
-  let* () =
+  let () =
     run_lwt_callbacks
       { in_cache = is_in_cache !active_page.page_id
       ; origin_uri = get_current_uri ()
@@ -1638,8 +1655,8 @@ let set_content ~replace ~uri ?offset ?fragment content =
       (flush_onchangepage ())
   in
   match content with
-  | None -> Lwt.return_unit
-  | Some content ->
+  | None -> ()
+  | Some content -> (
       let locked = ref true in
       let really_set () =
         reload_function := None;
@@ -1654,9 +1671,7 @@ let set_content ~replace ~uri ?offset ?fragment content =
          Otherwise, the browser start to display the page before
          loading the CSS. *)
         let preloaded_css =
-          if !only_replace_body
-          then Lwt.return_unit
-          else Eliommod_dom.preload_css fake_page
+          if !only_replace_body then () else Eliommod_dom.preload_css fake_page
         in
         (* Unique nodes of scope request must be bound before the
          unmarshalling/unwrapping of page data. *)
@@ -1673,8 +1688,12 @@ let set_content ~replace ~uri ?offset ?fragment content =
           | _ -> None
         in
         Eliommod_cookies.update_cookie_table host cookies;
-        (* Wait for CSS to be inlined before substituting global nodes: *)
-        let* () = preloaded_css in
+        let
+            (* Wait for CSS to be inlined before substituting global nodes: *)
+              ()
+          =
+          preloaded_css
+        in
         (* Bind unique node (request and global) and register event
          handler.  Relinking closure nodes must take place after
          initializing the client values *)
@@ -1711,31 +1730,29 @@ let set_content ~replace ~uri ?offset ?fragment content =
           flush_onload ()
           @ [onload_closure_nodes; Eliom_client_core.broadcast_load_end]
         in
-        Lwt_mutex.unlock Eliom_client_core.load_mutex;
+        Eio.Mutex.unlock Eliom_client_core.load_mutex;
         run_callbacks load_callbacks;
         scroll_to_fragment ?offset fragment;
         advance_page ();
         if !Eliom_config.debug_timings
-        then Console.console##(timeEnd (Js.string "set_content"));
-        Lwt.return_unit
+        then Console.console##(timeEnd (Js.string "set_content"))
       and recover () =
-        if !locked then Lwt_mutex.unlock Eliom_client_core.load_mutex;
+        if !locked then Eio.Mutex.unlock Eliom_client_core.load_mutex;
         if !Eliom_config.debug_timings
         then Console.console##(timeEnd (Js.string "set_content"))
       in
-      Lwt.catch
-        (fun () ->
-           let* () = Lwt_mutex.lock Eliom_client_core.load_mutex in
-           Eliom_client_core.set_loading_phase ();
-           if !Eliom_config.debug_timings
-           then Console.console##(time (Js.string "set_content"));
-           let g () = recover (); Lwt.return_unit in
-           run_onunload_wrapper really_set g)
-        (fun exn ->
-           recover ();
-           Logs.debug ~src:section (fun fmt ->
-             fmt ("set_content" ^^ "@\n%s") (Printexc.to_string exn));
-           Lwt.fail exn)
+      try
+        let () = Eio.Mutex.lock Eliom_client_core.load_mutex in
+        Eliom_client_core.set_loading_phase ();
+        if !Eliom_config.debug_timings
+        then Console.console##(time (Js.string "set_content"));
+        let g () = recover () in
+        run_onunload_wrapper really_set g
+      with exn ->
+        recover ();
+        Logs.debug ~src:section (fun fmt ->
+          fmt ("set_content" ^^ "@\n%s") (Printexc.to_string exn));
+        raise exn)
 
 let ocamlify_params =
   List.map (function v, `String s -> v, Js.to_string s | _, _ -> assert false)
@@ -1768,13 +1785,13 @@ let route ({Eliom_route.i_subpath; i_get_params; i_post_params; _} as info) =
   Eliom_request_info.update_session_info ~path:i_subpath
     ~all_get_params:i_get_params ~all_post_params:(Some i_post_params)
   @@ fun () ->
-  let* result =
+  let result =
     Eliom_route.call_service
       { info with
         Eliom_route.i_get_params =
           Eliom_common.(remove_prefixed_param nl_param_prefix) i_get_params }
   in
-  Lwt.return (uri, result)
+  uri, result
 
 let switch_to_https () =
   let info = Eliom_process.get_info () in
@@ -1796,11 +1813,11 @@ let string_of_result result =
       "Reload_action with hidden and https as " ^ values
 
 let rec handle_result ~replace ~uri result =
-  let* result = result in
+  let result = result in
   Logs.debug ~src:section_page (fun fmt ->
     fmt "%s" ("handle_result: result is " ^ string_of_result result));
   match result with
-  | Eliom_service.No_contents -> Lwt.return_unit
+  | Eliom_service.No_contents -> ()
   | Dom d ->
       change_url_string ~replace uri;
       set_content_local d
@@ -1857,7 +1874,7 @@ and change_page :
   -> ?override_mime_type:string
   -> 'get
   -> 'post
-  -> unit Lwt.t
+  -> unit
   =
  fun (type m)
    ?(ignore_client_fun = false)
@@ -1890,10 +1907,9 @@ and change_page :
     let () =
       Logs.debug ~src:section_page (fun fmt -> fmt "change page: xhr is None")
     in
-    Lwt.return
-      (exit_to ?window_name ?window_features ?absolute ?absolute_path ?https
-         ~service ?hostname ?port ?fragment ?keep_nl_params ~nl_params
-         ?keep_get_na_params get_params post_params)
+    exit_to ?window_name ?window_features ?absolute ?absolute_path ?https
+      ~service ?hostname ?port ?fragment ?keep_nl_params ~nl_params
+      ?keep_get_na_params get_params post_params
   else
     with_progress_cursor
       (match xhr with
@@ -1905,7 +1921,7 @@ and change_page :
             Eliom_parameter.add_nl_parameter nl_params Eliom_request.nl_template
               tmpl
           in
-          let* uri, content =
+          let uri, content =
             raw_call_service ?absolute ?absolute_path ?https ~service ?hostname
               ?port ?fragment ?keep_nl_params ~nl_params ?keep_get_na_params
               ?progress ?upload_progress ?override_mime_type get_params
@@ -1939,7 +1955,7 @@ and change_page :
               ~path:(Url.path_of_url_string uri)
               ~all_get_params:l ~all_post_params:l'
             @@ fun () ->
-            let* () =
+            let () =
               run_lwt_callbacks
                 { in_cache = is_in_cache !active_page.page_id
                 ; origin_uri = get_current_uri ()
@@ -1953,10 +1969,9 @@ and change_page :
         | None when is_client_app () ->
             Logs.debug ~src:section_page (fun fmt ->
               fmt "change page: client_fun service is None and is_client_app");
-            Lwt.return
-            @@ exit_to ?absolute ?absolute_path ?https ~service ?hostname ?port
-                 ?fragment ?keep_nl_params ~nl_params ?keep_get_na_params
-                 get_params post_params
+            exit_to ?absolute ?absolute_path ?https ~service ?hostname ?port
+              ?fragment ?keep_nl_params ~nl_params ?keep_get_na_params
+              get_params post_params
         | _ ->
             Logs.debug ~src:section_page (fun fmt ->
               fmt "change page: client_fun service is anything else");
@@ -1969,7 +1984,7 @@ and change_page :
             with_new_page ~replace () @@ fun () ->
             reload_function := None;
             let cookies_info = Eliom_uri.make_cookies_info (https, service) in
-            let* uri, content =
+            let uri, content =
               match
                 create_request_ ?absolute ?absolute_path ?https ~service
                   ?hostname ?port ?fragment ?keep_nl_params ~nl_params
@@ -2009,28 +2024,26 @@ and change_page_unknown
     | _, _ -> `Post
   in
   with_new_page ~replace () @@ fun () ->
-  let* uri, result =
+  let uri, result =
     route
       {Eliom_route.i_sess_info; i_subpath; i_meth; i_get_params; i_post_params}
   in
-  handle_result ~replace ~uri (Lwt.return result)
+  handle_result ~replace ~uri result
 
 and reload ~replace ~uri ~fallback =
   Logs.debug ~src:section_page (fun fmt -> fmt "reload");
   let path, args = path_and_args_of_uri uri in
-  Lwt.catch
-    (fun () -> change_page_unknown ~replace path args [])
-    (fun _ ->
-       change_page ~replace ~ignore_client_fun:true ~service:fallback () ())
+  try change_page_unknown ~replace path args []
+  with _ ->
+    change_page ~replace ~ignore_client_fun:true ~service:fallback () ()
 
 and reload_without_na_params ~replace ~uri ~fallback =
   let path, args = path_and_args_of_uri uri in
   let args = Eliom_common.remove_na_prefix_params args in
   Logs.debug ~src:section_page (fun fmt -> fmt "reload_without_na_params");
-  Lwt.catch
-    (fun () -> change_page_unknown ~replace path args [])
-    (fun _ ->
-       change_page ~replace ~ignore_client_fun:true ~service:fallback () ())
+  try change_page_unknown ~replace path args []
+  with _ ->
+    change_page ~replace ~ignore_client_fun:true ~service:fallback () ()
 
 (* Function used in "onclick" event handler of <a>.  *)
 let change_page_uri_a ?cookies_info ?tmpl ?(get_params = []) full_uri =
@@ -2043,42 +2056,40 @@ let change_page_uri_a ?cookies_info ?tmpl ?(get_params = []) full_uri =
        then failwith "Change_page_uri_a called on client app";
        match tmpl with
        | Some t when tmpl = Eliom_request_info.get_request_template () ->
-           let* uri, content =
+           let uri, content =
              Eliom_request.http_get ?cookies_info uri
                ((Eliom_request.nl_template_string, t) :: get_params)
                Eliom_request.string_result
            in
            set_template_content ~replace:false ~uri ?fragment content
        | _ ->
-           let* uri, content =
+           let uri, content =
              Eliom_request.http_get ~expecting_process_page:true ?cookies_info
                uri get_params Eliom_request.xml_result
            in
            set_content ~replace:false ~uri ?fragment content)
      else (
        change_url_string ~replace:true full_uri;
-       scroll_to_fragment fragment;
-       Lwt.return_unit))
+       scroll_to_fragment fragment))
 
 let change_page_uri ?replace full_uri =
   Logs.debug ~src:section_page (fun fmt -> fmt "Change page uri");
-  Lwt.catch
-    (fun () ->
-       match Url.url_of_string full_uri with
-       | Some (Url.Http url | Url.Https url) ->
-           Logs.debug ~src:section_page (fun fmt ->
-             fmt "change page uri: url is http or https");
-           change_page_unknown ?replace url.Url.hu_path url.Url.hu_arguments []
-       | _ -> failwith "invalid url")
-    (fun _ ->
-       if is_client_app ()
-       then
-         failwith
-           (Printf.sprintf "Change page uri: can't find service for %s" full_uri)
-       else (
-         Logs.debug ~src:section (fun fmt ->
-           fmt "Change page uri: resort to server");
-         change_page_uri_a full_uri))
+  try
+    match Url.url_of_string full_uri with
+    | Some (Url.Http url | Url.Https url) ->
+        Logs.debug ~src:section_page (fun fmt ->
+          fmt "change page uri: url is http or https");
+        change_page_unknown ?replace url.Url.hu_path url.Url.hu_arguments []
+    | _ -> failwith "invalid url"
+  with _ ->
+    if is_client_app ()
+    then
+      failwith
+        (Printf.sprintf "Change page uri: can't find service for %s" full_uri)
+    else (
+      Logs.debug ~src:section (fun fmt ->
+        fmt "Change page uri: resort to server");
+      change_page_uri_a full_uri)
 
 (* Functions used in "onsubmit" event handler of <form>.  *)
 
@@ -2088,14 +2099,14 @@ let change_page_get_form ?cookies_info ?tmpl form full_uri =
      let uri, fragment = Url.split_fragment full_uri in
      match tmpl with
      | Some t when tmpl = Eliom_request_info.get_request_template () ->
-         let* uri, content =
+         let uri, content =
            Eliom_request.send_get_form
              ~get_args:[Eliom_request.nl_template_string, t]
              ?cookies_info form uri Eliom_request.string_result
          in
          set_template_content ~replace:false ~uri ?fragment content
      | _ ->
-         let* uri, content =
+         let uri, content =
            Eliom_request.send_get_form ~expecting_process_page:true
              ?cookies_info form uri Eliom_request.xml_result
          in
@@ -2107,14 +2118,14 @@ let change_page_post_form ?cookies_info ?tmpl form full_uri =
      let uri, fragment = Url.split_fragment full_uri in
      match tmpl with
      | Some t when tmpl = Eliom_request_info.get_request_template () ->
-         let* uri, content =
+         let uri, content =
            Eliom_request.send_post_form
              ~get_args:[Eliom_request.nl_template_string, t]
              ?cookies_info form uri Eliom_request.string_result
          in
          set_template_content ~replace:false ~uri ?fragment content
      | _ ->
-         let* uri, content =
+         let uri, content =
            Eliom_request.send_post_form ~expecting_process_page:true
              ?cookies_info form uri Eliom_request.xml_result
          in
@@ -2123,13 +2134,19 @@ let change_page_post_form ?cookies_info ?tmpl form full_uri =
 let _ =
   (Eliom_client_core.change_page_uri_ :=
      fun ?cookies_info ?tmpl href ->
-       Lwt.ignore_result (change_page_uri_a ?cookies_info ?tmpl href));
+       Fiber.fork
+         ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+         (fun () -> change_page_uri_a ?cookies_info ?tmpl href));
   (Eliom_client_core.change_page_get_form_ :=
      fun ?cookies_info ?tmpl form href ->
-       Lwt.ignore_result (change_page_get_form ?cookies_info ?tmpl form href));
+       Fiber.fork
+         ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+         (fun () -> change_page_get_form ?cookies_info ?tmpl form href));
   Eliom_client_core.change_page_post_form_ :=
     fun ?cookies_info ?tmpl form href ->
-      Lwt.ignore_result (change_page_post_form ?cookies_info ?tmpl form href)
+      Fiber.fork
+        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+        (fun () -> change_page_post_form ?cookies_info ?tmpl form href)
 
 (* == Main (internal) function: change the content of the page without leaving
       the javascript application. *)
@@ -2178,110 +2195,121 @@ let () =
         ; target_id = Some target_id }
       in
       let tmpl = state.template in
-      Lwt.ignore_result @@ with_progress_cursor
-      @@
-      let uri, fragment = Url.split_fragment full_uri in
-      if uri = get_current_uri ()
-      then (
-        Logs.debug ~src:section_page (fun fmt ->
-          fmt "revisit: uri = get_current_uri");
-        !active_page.page_id <- state_id;
-        scroll_to_fragment ~offset:state.position fragment;
-        Lwt.return_unit)
-      else
-        try
-          (* serve cached page from the from history_doms *)
-          Logs.debug ~src:section_page (fun fmt ->
-            fmt "revisit: uri != get_current_uri");
-          if not (is_in_cache state_id) then raise Not_found;
-          let* () = run_lwt_callbacks ev (flush_onchangepage ()) in
-          restore_history_dom target_id;
-          set_current_uri uri;
-          let* () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
-          scroll_to_fragment ~offset:state.position fragment;
-          (* Wait for the dom to be repainted before scrolling *)
-          let* () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
-          scroll_to_fragment ~offset:state.position fragment;
-          (* When we use iPhone, we need to wait for one more
+      Fiber.fork
+        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+        (fun () ->
+           with_progress_cursor
+           (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+           @@
+           let uri, fragment = Url.split_fragment full_uri in
+           if uri = get_current_uri ()
+           then (
+             Logs.debug ~src:section_page (fun fmt ->
+               fmt "revisit: uri = get_current_uri");
+             !active_page.page_id <- state_id;
+             scroll_to_fragment ~offset:state.position fragment)
+           else
+             try
+               (* serve cached page from the from history_doms *)
+               Logs.debug ~src:section_page (fun fmt ->
+                 fmt "revisit: uri != get_current_uri");
+               if not (is_in_cache state_id) then raise Not_found;
+               let () = run_lwt_callbacks ev (flush_onchangepage ()) in
+               restore_history_dom target_id;
+               set_current_uri uri;
+               let () =
+                 Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame ()
+               in
+               scroll_to_fragment ~offset:state.position fragment;
+               let
+                   (* Wait for the dom to be repainted before scrolling *)
+                     ()
+                 =
+                 Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame ()
+               in
+               scroll_to_fragment ~offset:state.position fragment
+               (* When we use iPhone, we need to wait for one more
                    [request_animation_frame] before scrolling.The
                    function [scroll_to_fragment] is called twice. In
                    other words, we want to call [scroll_to_fragment]
                    as early as possible so that the scroll position
                    will not jump after the second [request_animation_frame]
                    if the dom has already be painted after the first one. *)
-          Lwt.return_unit
-        with Not_found -> (
-          let session_changed = state_id.session_id <> session_id in
-          if session_changed && is_client_app ()
-          then
-            failwith
-              (Printf.sprintf
-                 "revisit: session changed on client: %d => %d (%s)"
-                 state_id.session_id session_id full_uri);
-          try
-            (* same session *)
-            if session_changed then raise Not_found;
-            Logs.debug ~src:section_page (fun fmt ->
-              fmt "revisit: session has not changed");
-            let old_page = History.find_by_state_index state_id.state_index in
-            let rf =
-              Option.bind old_page @@ fun {reload_function = rf; _} -> rf
-            in
-            match rf with
-            | None -> raise Not_found
-            | Some f ->
-                reload_function := rf;
-                let* () = run_lwt_callbacks ev (flush_onchangepage ()) in
-                with_new_page ~state_id ?old_page ~replace:false () @@ fun () ->
-                set_current_uri uri;
-                History.replace (get_this_page ());
-                let* () =
-                  Lwt.bind (f () ()) (function
-                    | Eliom_service.Dom d -> set_content_local d
-                    | r ->
-                        handle_result ~uri:(get_current_uri ()) ~replace:true
-                          (Lwt.return r))
-                in
-                scroll_to_fragment ~offset:state.position fragment;
-                Lwt.return_unit
-          with Not_found -> (
-            (* different session ID *)
-            set_current_uri uri;
-            match tmpl with
-            | Some t when tmpl = Eliom_request_info.get_request_template () ->
-                Logs.debug ~src:section_page (fun fmt ->
-                  fmt
-                    "revisit: template is Some and equals to get_request_template");
-                let* uri, content =
-                  Eliom_request.http_get uri
-                    [Eliom_request.nl_template_string, t]
-                    Eliom_request.string_result
-                in
-                let* () = set_template_content content ~replace:true ~uri in
-                scroll_to_fragment ~offset:state.position fragment;
-                Lwt.return_unit
-            | _ ->
-                if is_client_app ()
-                then
-                  failwith
-                    (Printf.sprintf
-                       "revisit: could not generate page client-side (%s)"
-                       full_uri);
-                Logs.debug ~src:section_page (fun fmt ->
-                  fmt "revisit: template is anything else");
-                with_new_page
-                  ?state_id:(if session_changed then None else Some state_id)
-                  ~replace:false ()
-                @@ fun () ->
-                let* uri, content =
-                  Eliom_request.http_get ~expecting_process_page:true uri []
-                    Eliom_request.xml_result
-                in
-                let* () =
-                  set_content ~uri ~replace:true ~offset:state.position
-                    ?fragment content
-                in
-                Lwt.return_unit))
+             with Not_found -> (
+               let session_changed = state_id.session_id <> session_id in
+               if session_changed && is_client_app ()
+               then
+                 failwith
+                   (Printf.sprintf
+                      "revisit: session changed on client: %d => %d (%s)"
+                      state_id.session_id session_id full_uri);
+               try
+                 (* same session *)
+                 if session_changed then raise Not_found;
+                 Logs.debug ~src:section_page (fun fmt ->
+                   fmt "revisit: session has not changed");
+                 let old_page =
+                   History.find_by_state_index state_id.state_index
+                 in
+                 let rf =
+                   Option.bind old_page @@ fun {reload_function = rf; _} -> rf
+                 in
+                 match rf with
+                 | None -> raise Not_found
+                 | Some f ->
+                     reload_function := rf;
+                     let () = run_lwt_callbacks ev (flush_onchangepage ()) in
+                     with_new_page ~state_id ?old_page ~replace:false ()
+                     @@ fun () ->
+                     set_current_uri uri;
+                     History.replace (get_this_page ());
+                     let () =
+                       match f () () with
+                       | Eliom_service.Dom d -> set_content_local d
+                       | r ->
+                           handle_result ~uri:(get_current_uri ()) ~replace:true
+                             r
+                     in
+                     scroll_to_fragment ~offset:state.position fragment
+               with Not_found -> (
+                 (* different session ID *)
+                 set_current_uri uri;
+                 match tmpl with
+                 | Some t when tmpl = Eliom_request_info.get_request_template ()
+                   ->
+                     Logs.debug ~src:section_page (fun fmt ->
+                       fmt
+                         "revisit: template is Some and equals to get_request_template");
+                     let uri, content =
+                       Eliom_request.http_get uri
+                         [Eliom_request.nl_template_string, t]
+                         Eliom_request.string_result
+                     in
+                     let () = set_template_content content ~replace:true ~uri in
+                     scroll_to_fragment ~offset:state.position fragment
+                 | _ ->
+                     if is_client_app ()
+                     then
+                       failwith
+                         (Printf.sprintf
+                            "revisit: could not generate page client-side (%s)"
+                            full_uri);
+                     Logs.debug ~src:section_page (fun fmt ->
+                       fmt "revisit: template is anything else");
+                     with_new_page
+                       ?state_id:
+                         (if session_changed then None else Some state_id)
+                       ~replace:false ()
+                     @@ fun () ->
+                     let uri, content =
+                       Eliom_request.http_get ~expecting_process_page:true uri
+                         [] Eliom_request.xml_result
+                     in
+                     let () =
+                       set_content ~uri ~replace:true ~offset:state.position
+                         ?fragment content
+                     in
+                     ())))
     in
     let revisit_wrapper full_uri state_id =
       Logs.debug ~src:section_page (fun fmt -> fmt "revisit_wrapper");
@@ -2291,20 +2319,26 @@ let () =
       and cancel () = () in
       run_onunload_wrapper f cancel
     in
-    Lwt.ignore_result
-      (let* () = wait_load_end () in
-       Logs.debug ~src:section_page (fun fmt ->
-         fmt "revisit_wrapper: replaceState");
-       Dom_html.window##.history##(replaceState
-                                     (Js.Opt.return
-                                        (Js.string
-                                           (to_json ~typ:[%json: saved_state]
-                                              ( !active_page.page_id
-                                              , Js.to_string
-                                                  Dom_html.window##.location##.href
-                                              ))))
-                                     (Js.string "") Js.null);
-       Lwt.return_unit);
+    Fiber.fork
+      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+      (fun () ->
+         let
+             (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+               ()
+           =
+           wait_load_end ()
+         in
+         Logs.debug ~src:section_page (fun fmt ->
+           fmt "revisit_wrapper: replaceState");
+         Dom_html.window##.history##(replaceState
+                                       (Js.Opt.return
+                                          (Js.string
+                                             (to_json ~typ:[%json: saved_state]
+                                                ( !active_page.page_id
+                                                , Js.to_string
+                                                    Dom_html.window##.location##.
+                                                    href ))))
+                                       (Js.string "") Js.null));
     Dom_html.window##.onpopstate
     := Dom_html.handler (fun event ->
       Logs.debug ~src:section_page (fun fmt ->
@@ -2325,33 +2359,42 @@ let () =
     *)
     let read_fragment () = Js.to_string Dom_html.window##.location##.hash in
     let auto_change_page fragment =
-      Lwt.ignore_result
-        (let l = String.length fragment in
-         if l = 0 || (l > 1 && fragment.[1] = '!')
-         then
-           if fragment <> !current_pseudo_fragment
-           then (
-             current_pseudo_fragment := fragment;
-             let uri =
-               match l with
-               | 2 -> "./" (* fix for firefox *)
-               | 0 | 1 -> fst (Url.split_fragment Url.Current.as_string)
-               | _ -> String.sub fragment 2 (String.length fragment - 2)
-             in
-             Logs.debug ~src:section_page (fun fmt -> fmt "auto_change_page");
-             (* CCC TODO handle templates *)
-             change_page_uri uri)
-           else Lwt.return_unit
-         else Lwt.return_unit)
+      Fiber.fork
+        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+        (fun () ->
+           (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+           let l = String.length fragment in
+           if l = 0 || (l > 1 && fragment.[1] = '!')
+           then
+             if fragment <> !current_pseudo_fragment
+             then (
+               current_pseudo_fragment := fragment;
+               let uri =
+                 match l with
+                 | 2 -> "./" (* fix for firefox *)
+                 | 0 | 1 -> fst (Url.split_fragment Url.Current.as_string)
+                 | _ -> String.sub fragment 2 (String.length fragment - 2)
+               in
+               Logs.debug ~src:section_page (fun fmt -> fmt "auto_change_page");
+               (* CCC TODO handle templates *)
+               change_page_uri uri)
+             else ()
+           else ())
     in
     Eliommod_dom.onhashchange (fun s -> auto_change_page (Js.to_string s));
     let first_fragment = read_fragment () in
     if first_fragment <> !current_pseudo_fragment
     then
-      Lwt.ignore_result
-        (let* () = wait_load_end () in
-         auto_change_page first_fragment;
-         Lwt.return_unit)
+      Fiber.fork
+        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+        (fun () ->
+           let
+               (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+                 ()
+             =
+             wait_load_end ()
+           in
+           auto_change_page first_fragment)
 
 let () =
   Eliom_unwrap.register_unwrapper
diff --git a/src/lib/eliom_client.client.mli b/src/lib/eliom_client.client.mli
index 5ea2a171a1..2ee16b3a14 100644
--- a/src/lib/eliom_client.client.mli
+++ b/src/lib/eliom_client.client.mli
@@ -83,7 +83,7 @@ val change_page :
   -> ?override_mime_type:string
   -> 'a
   -> 'b
-  -> unit Lwt.t
+  -> unit
 (** Call a service and change the current page.  If the service
     belongs to the same application, the client side program is not
     stopped, and only the content (not the container) is reloaded.  If
@@ -123,7 +123,7 @@ val call_ocaml_service :
   -> ?override_mime_type:string
   -> 'a
   -> 'b
-  -> 'return Lwt.t
+  -> 'return
 (** Call a server side service that return an OCaml value.
 
     If the service raises an exception, the call to the
@@ -228,7 +228,7 @@ val call_service :
   -> ?override_mime_type:string
   -> 'a
   -> 'b
-  -> string Lwt.t
+  -> string
 (** (low level) Call a server side service and return the content
     of the resulting HTTP frame as a string. *)
 
@@ -272,7 +272,7 @@ val onload : (unit -> unit) -> unit
 
 *)
 
-val lwt_onload : unit -> unit Lwt.t
+val lwt_onload : unit -> unit
 (** Returns a Lwt thread that waits until the next page is loaded. *)
 
 type changepage_event =
@@ -290,7 +290,7 @@ type changepage_event =
     [target_id] is not [None] if and only if the onchangepage event
     takes place during a navigation in history. *)
 
-val onchangepage : (changepage_event -> unit Lwt.t) -> unit
+val onchangepage : (changepage_event -> unit) -> unit
 (** Run some code *before* the next page change, that is, before each
     call to a page-producing service handler.
     Just like onpreload, handlers registered with onchangepage only
@@ -348,11 +348,7 @@ module Page_status : sig
   val ondead : ?stop:unit React.E.t -> (unit -> unit) -> unit
   val oninactive : ?once:bool -> ?stop:unit React.E.t -> (unit -> unit) -> unit
 
-  val while_active :
-     ?now:bool
-    -> ?stop:unit React.E.t
-    -> (unit -> unit Lwt.t)
-    -> unit
+  val while_active : ?now:bool -> ?stop:unit React.E.t -> (unit -> unit) -> unit
   (** [while_active] initiates an action as [onactive] but cancels it whenever
       the page is not active anymore. *)
 end
@@ -377,7 +373,7 @@ val onunload : (unit -> unit) -> unit
     service calls, and sometimes by the browser [onunload] event.
     [onunload] can be used to register multiple callbacks. *)
 
-val wait_load_end : unit -> unit Lwt.t
+val wait_load_end : unit -> unit
 (** Wait for the initialization phase to terminate *)
 
 val get_application_name : unit -> string
@@ -392,7 +388,7 @@ val persist_document_head : unit -> unit
 
     See the {% <<a_manual chapter="clientserver-communication" fragment="rpc"|manual>> %}.*)
 
-type ('a, +'b) server_function = 'a -> 'b Lwt.t
+type ('a, +'b) server_function = 'a -> 'b
 (** A [('a, 'b) server_function] provides transparently access to a
     server side function which has been created by {% <<a_api
     subproject="server"| val Eliom_client.server_function>> %}.
@@ -404,7 +400,7 @@ type ('a, +'b) server_function = 'a -> 'b Lwt.t
     <<a_api subproject="client"|val Eliom_client.call_ocaml_service>>.
 *)
 
-val change_page_uri : ?replace:bool -> string -> unit Lwt.t
+val change_page_uri : ?replace:bool -> string -> unit
 (** [change_page_uri ?replace uri] identifies and calls the
     client-side service that implements [uri].
 
@@ -428,7 +424,7 @@ val change_page_unknown :
   -> string list
   -> (string * string) list
   -> (string * string) list
-  -> unit Lwt.t
+  -> unit
 (** [change_page_unknown path get_params post_params] calls the
     service corresponding to [(path, get_params, post_params)]. It may
     throw [Eliom_common.Eliom_404] or
@@ -438,7 +434,7 @@ val change_page_unknown :
 (* Documentation rather in eliom_client.ml *)
 
 val init : unit -> unit
-val set_reload_function : (unit -> unit -> Eliom_service.result Lwt.t) -> unit
+val set_reload_function : (unit -> unit -> Eliom_service.result) -> unit
 
 module History : sig
   val past : unit -> string list
@@ -495,7 +491,7 @@ val section : Logs.src
 val middleClick : Dom_html.mouseEvent Js.t -> bool
 (** Is it a middle-click event? *)
 
-type client_form_handler = Dom_html.event Js.t -> bool Lwt.t
+type client_form_handler = Dom_html.event Js.t -> bool
 
 (** headers to add to each of Eliom's HTTP requests. *)
 module Additional_headers : sig
diff --git a/src/lib/eliom_client.server.mli b/src/lib/eliom_client.server.mli
index c15d360796..b1f1f67dcf 100644
--- a/src/lib/eliom_client.server.mli
+++ b/src/lib/eliom_client.server.mli
@@ -34,9 +34,9 @@ val server_function :
   -> ?max_use:int
   -> ?timeout:float
   -> ?https:bool
-  -> ?error_handler:((string * exn) list -> 'b Lwt.t)
+  -> ?error_handler:((string * exn) list -> 'b)
   -> 'a Deriving_Json.t
-  -> ('a -> 'b Lwt.t)
+  -> ('a -> 'b)
   -> ('a, 'b) server_function
 (** [server_function argument_type f] creates a value of type {%
     <<a_api | type Eliom_client.server_function>> %}. This allows
diff --git a/src/lib/eliom_client_core.client.ml b/src/lib/eliom_client_core.client.ml
index 59e94d2cc9..93f9417368 100644
--- a/src/lib/eliom_client_core.client.ml
+++ b/src/lib/eliom_client_core.client.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -263,12 +263,12 @@ let register_request_node, find_request_node, reset_request_nodes =
    *and* to the change_page phase
    *and* to the loading phase after caml services (added 2016-03 --V). *)
 
-let load_mutex = Lwt_mutex.create ()
-let _ = ignore (Lwt_mutex.lock load_mutex)
+let load_mutex = Eio.Mutex.create ()
+let _ = ignore (Eio.Mutex.lock load_mutex)
 
 let in_onload, broadcast_load_end, wait_load_end, set_loading_phase =
   let loading_phase = ref true in
-  let load_end = Lwt_condition.create () in
+  let load_end = Eio.Condition.create () in
   let set () = loading_phase := true in
   let in_onload () = !loading_phase in
   let broadcast_load_end () =
@@ -276,7 +276,11 @@ let in_onload, broadcast_load_end, wait_load_end, set_loading_phase =
     Lwt_condition.broadcast load_end ()
   in
   let wait_load_end () =
-    if !loading_phase then Lwt_condition.wait load_end else Lwt.return_unit
+    if !loading_phase
+    then
+      Eio.Condition.await (* TODO: ciao-lwt: A mutex must be passed *) load_end
+        __mutex__
+    else ()
   in
   in_onload, broadcast_load_end, wait_load_end, set
 
@@ -305,7 +309,7 @@ let change_page_get_form_ :
 let change_page_post_form_ =
   ref (fun ?cookies_info:_ ?tmpl:_ _form _href -> assert false)
 
-type client_form_handler = Dom_html.event Js.t -> bool Lwt.t
+type client_form_handler = Dom_html.event Js.t -> bool
 
 let raw_a_handler node cookies_info tmpl ev =
   let href = (Js.Unsafe.coerce node : Dom_html.anchorElement Js.t)##.href in
@@ -331,10 +335,11 @@ let raw_form_handler form kind cookies_info tmpl ev client_form_handler =
     | `Form_post -> !change_page_post_form_
   in
   let f () =
-    Lwt.async @@ fun () ->
-    let* b = client_form_handler ev in
-    if not b then change_page_form ?cookies_info ?tmpl form action;
-    Lwt.return_unit
+    Fiber.fork
+      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+      (fun () ->
+         let b = client_form_handler ev in
+         if not b then change_page_form ?cookies_info ?tmpl form action)
   in
   (not !Eliom_common.is_client_app)
   && ((https = Some true && not Eliom_request_info.ssl_)
@@ -567,7 +572,13 @@ let rec rebuild_rattrib node ra =
    and the function [Eliommod_dom.test_pageshow_pagehide]. *)
 
 let delay f =
-  Lwt.ignore_result (Lwt.pause () >>= fun () -> f (); Lwt.return_unit)
+  Fiber.fork
+    ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+    (fun () ->
+       Fiber.yield
+         (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+         ();
+       f ())
 
 module ReactState : sig
   type t
diff --git a/src/lib/eliom_client_main.eliom b/src/lib/eliom_client_main.eliom
index 6049674d32..0a151763a7 100644
--- a/src/lib/eliom_client_main.eliom
+++ b/src/lib/eliom_client_main.eliom
@@ -50,20 +50,16 @@ let _force_link =
 let%shared _ =
   Eliom_service.internal_set_client_fun ~service:Eliom_service.reload_action
     [%client
-      fun () () ->
-        Lwt.return (Eliom_service.Reload_action {hidden = false; https = false})];
+      fun () () -> Eliom_service.Reload_action {hidden = false; https = false}];
   Eliom_service.internal_set_client_fun
     ~service:Eliom_service.reload_action_https
     [%client
-      fun () () ->
-        Lwt.return (Eliom_service.Reload_action {hidden = false; https = true})];
+      fun () () -> Eliom_service.Reload_action {hidden = false; https = true}];
   Eliom_service.internal_set_client_fun
     ~service:Eliom_service.reload_action_hidden
     [%client
-      fun () () ->
-        Lwt.return (Eliom_service.Reload_action {hidden = true; https = false})];
+      fun () () -> Eliom_service.Reload_action {hidden = true; https = false}];
   Eliom_service.internal_set_client_fun
     ~service:Eliom_service.reload_action_https_hidden
     [%client
-      fun () () ->
-        Lwt.return (Eliom_service.Reload_action {hidden = true; https = true})]
+      fun () () -> Eliom_service.Reload_action {hidden = true; https = true}]
diff --git a/src/lib/eliom_comet.client.ml b/src/lib/eliom_comet.client.ml
index 95eca2d551..66465776fc 100644
--- a/src/lib/eliom_comet.client.ml
+++ b/src/lib/eliom_comet.client.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -84,16 +84,24 @@ module Configuration = struct
         (first_conf configuration_table)
 
   let update_configuration_waiter, update_configuration_waker =
-    let t, u = Lwt.wait () in
+    let t, u =
+      Promise.create
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
     ref t, ref u
 
   let update_configuration () =
     global_configuration := get_configuration ();
-    let t, u = Lwt.wait () in
+    let t, u =
+      Promise.create
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
     update_configuration_waiter := t;
     let wakener = !update_configuration_waker in
     update_configuration_waker := u;
-    Lwt.wakeup wakener ()
+    Promise.resolve wakener ()
 
   let get () = !global_configuration
 
@@ -159,17 +167,20 @@ module Configuration = struct
       else (get ()).time_between_request
     in
     let rec aux t =
-      let* () =
-        Lwt.pick
-          [ Js_of_ocaml_lwt.Lwt_js.sleep t
-          ; !update_configuration_waiter
-          ; active_waiter () ]
+      let () =
+        Fiber.any
+          [ (fun () -> Js_of_ocaml_lwt.Lwt_js.sleep t)
+          ; (fun () ->
+              !
+                (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+                update_configuration_waiter)
+          ; active_waiter ]
       in
       let remaining_time = sleep_duration () -. (Sys.time () -. time) in
-      if remaining_time > 0. then aux remaining_time else Lwt.return_unit
+      if remaining_time > 0. then aux remaining_time else ()
     in
     let sleep_duration = sleep_duration () in
-    if sleep_duration <= 0. then Lwt.return_unit else aux sleep_duration
+    if sleep_duration <= 0. then () else aux sleep_duration
 end
 
 exception Restart
@@ -186,16 +197,14 @@ let handle_exn, set_handle_exn_function =
       in
       match exn with
       | Some exn -> raise_error ~section ~exn "%s" s
-      | None ->
-          Logs.debug ~src:section (fun fmt -> fmt "%s" s);
-          Lwt.return_unit)
+      | None -> Logs.debug ~src:section (fun fmt -> fmt "%s" s))
   in
   ( (fun ?exn () ->
       if not !closed
       then (
         closed := true;
         !r ?exn ())
-      else Lwt.return_unit)
+      else ())
   , fun f -> r := f )
 
 type chan_id = string
@@ -211,9 +220,7 @@ module Service_handler : sig
   val stateful : stateful kind
   val make : Ecb.comet_service -> 'a kind -> 'a t
 
-  val wait_data :
-     'a t
-    -> (chan_id * int option * string Ecb.channel_data) list Lwt.t
+  val wait_data : 'a t -> (chan_id * int option * string Ecb.channel_data) list
   (** Returns the messages received in the last request. If the
       channel is stateless, it also returns the message number in the [int option] *)
 
@@ -239,10 +246,10 @@ end = struct
     ; mutable focused : float option
       (** [focused] is None when the page is visible and Some [t]
             when the page became hidden at time [t] (in ms) *)
-    ; mutable active_waiter : unit Lwt.t
+    ; mutable active_waiter : unit Promise.t
       (** [active_waiter] terminates when the page get visible *)
     ; mutable active_wakener : unit Lwt.u
-    ; mutable restart_waiter : Ecb.answer Lwt.t
+    ; mutable restart_waiter : Ecb.answer Promise.t
     ; mutable restart_wakener : Ecb.answer Lwt.u
     ; mutable active_channels : Eliom_lib.String.Set.t }
 
@@ -284,11 +291,15 @@ end = struct
       | `Inactive -> hd.hd_activity.active <- `Inactive
       | _ ->
           hd.hd_activity.active <- v;
-          let t, u = Lwt.wait () in
+          let t, u =
+            Promise.create
+              (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+              ()
+          in
           hd.hd_activity.active_waiter <- t;
           let wakener = hd.hd_activity.active_wakener in
           hd.hd_activity.active_wakener <- u;
-          Lwt.wakeup wakener ()
+          Promise.resolve wakener ()
 
   let is_active hd = hd.hd_activity.active
 
@@ -354,7 +365,11 @@ end = struct
 
   let restart hd =
     let act = hd.hd_activity in
-    let t, u = Lwt.wait () in
+    let t, u =
+      Promise.create
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
     act.restart_waiter <- t;
     let wakener = act.restart_wakener in
     act.restart_wakener <- u;
@@ -375,16 +390,16 @@ end = struct
     match p with
     | _, Ecb.Stateful (Ecb.Commands commands) ->
         queue := List.rev_append (Array.to_list commands) !queue;
-        let* () = Eliom_client.wait_load_end () in
+        let () = Eliom_client.wait_load_end () in
         let q = !queue in
         if q <> []
         then (
           queue := [];
           Eliom_client.call_service ~service ()
             (false, Ecb.Stateful (Ecb.Commands (Array.of_list (List.rev q)))))
-        else Lwt.return ""
+        else ""
     | _ ->
-        let* () = Eliom_client.wait_load_end () in
+        let () = Eliom_client.wait_load_end () in
         Eliom_client.call_service ~service () p
 
   let make_request hd =
@@ -466,17 +481,17 @@ end = struct
   let call_service
         ({hd_activity; hd_service = Ecb.Comet_service (srv, queue); _} as hd)
     =
-    let* () =
+    let () =
       Configuration.sleep_before_next_request
         (fun () -> hd_activity.focused)
         (fun () -> hd_activity.active = `Idle)
         (fun () -> hd_activity.active_waiter)
     in
     let request = make_request hd in
-    let* s =
+    let s =
       call_service_after_load_end srv queue (hd_activity.active = `Idle, request)
     in
-    Lwt.return (Deriving_Json.from_string Ecb.answer_json s)
+    Deriving_Json.from_string Ecb.answer_json s
 
   let drop_message_index =
     let aux = function
@@ -501,64 +516,67 @@ end = struct
          || not (Configuration.get ()).Configuration.active_until_timeout)
     then set_activity hd (expected_activity hd)
 
-  let wait_data hd : (string * int option * string Ecb.channel_data) list Lwt.t =
+  let wait_data hd : (string * int option * string Ecb.channel_data) list =
     let rec aux retries =
       if hd.hd_activity.active = `Inactive
       then
-        let* () = hd.hd_activity.active_waiter in
+        let () = hd.hd_activity.active_waiter in
         aux 0
       else
-        Lwt.try_bind
-          (fun () -> Lwt.pick [call_service hd; hd.hd_activity.restart_waiter])
-          (fun s ->
-             match s with
-             | Ecb.Timeout ->
-                 update_activity ~timeout:true hd;
-                 aux 0
-             | Ecb.State_closed -> Lwt.return (close_all_channels hd)
-             | Ecb.Comet_error e -> Lwt.fail (Comet_error e)
-             | Ecb.Stateless_messages l ->
-                 let l = Array.to_list l in
-                 update_stateless_state hd l;
-                 Lwt.return (drop_message_index l)
-             | Ecb.Stateful_messages l ->
-                 let l = Array.to_list l in
-                 update_stateful_state hd l;
-                 Lwt.return (add_no_index l))
-          (fun e ->
-             match e with
-             | Eliom_request.Failed_request (0 | 502 | 504) ->
-                 if retries > max_retries
-                 then (
-                   Logs.app ~src:section (fun fmt -> fmt "connection failure");
-                   set_activity hd `Inactive;
-                   aux 0)
-                 else
-                   let* () = Js_of_ocaml_lwt.Lwt_js.sleep (delay retries) in
-                   aux (retries + 1)
-             | Restart ->
-                 Logs.info ~src:section (fun fmt -> fmt "restart");
-                 aux 0
-             | exn ->
-                 Logs.app ~src:section (fun fmt ->
-                   fmt
-                     ("connection failure" ^^ "@\n%s")
-                     (Printexc.to_string exn));
-                 let* () = handle_exn ~exn () in
-                 Lwt.fail exn)
+        match
+          Fiber.any
+            [ (fun () -> call_service hd)
+            ; (fun () ->
+                hd
+                (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+                  .hd_activity
+                  .restart_waiter) ]
+        with
+        | s -> (
+          match s with
+          | Ecb.Timeout ->
+              update_activity ~timeout:true hd;
+              aux 0
+          | Ecb.State_closed -> close_all_channels hd
+          | Ecb.Comet_error e -> raise (Comet_error e)
+          | Ecb.Stateless_messages l ->
+              let l = Array.to_list l in
+              update_stateless_state hd l;
+              drop_message_index l
+          | Ecb.Stateful_messages l ->
+              let l = Array.to_list l in
+              update_stateful_state hd l; add_no_index l)
+        | exception e -> (
+          match e with
+          | Eliom_request.Failed_request (0 | 502 | 504) ->
+              if retries > max_retries
+              then (
+                Logs.app ~src:section (fun fmt -> fmt "connection failure");
+                set_activity hd `Inactive;
+                aux 0)
+              else
+                let () = Js_of_ocaml_lwt.Lwt_js.sleep (delay retries) in
+                aux (retries + 1)
+          | Restart ->
+              Logs.info ~src:section (fun fmt -> fmt "restart");
+              aux 0
+          | exn ->
+              Logs.app ~src:section (fun fmt ->
+                fmt ("connection failure" ^^ "@\n%s") (Printexc.to_string exn));
+              let () = handle_exn ~exn () in
+              raise exn)
     in
     update_activity hd; aux 0
 
   let call_commands {hd_service = Ecb.Comet_service (srv, queue); _} command =
     ignore
-      (Lwt.catch
-         (fun () ->
-            call_service_after_load_end srv queue
-              (false, Ecb.Stateful (Ecb.Commands command)))
-         (fun exn ->
-            Logs.app ~src:section (fun fmt ->
-              fmt ("request failed" ^^ "@\n%s") (Printexc.to_string exn));
-            Lwt.return ""))
+      (try
+         call_service_after_load_end srv queue
+           (false, Ecb.Stateful (Ecb.Commands command))
+       with exn ->
+         Logs.app ~src:section (fun fmt ->
+           fmt ("request failed" ^^ "@\n%s") (Printexc.to_string exn));
+         "")
 
   let close hd chan_id =
     match hd.hd_state with
@@ -615,8 +633,16 @@ end = struct
         restart hd
 
   let init_activity () =
-    let active_waiter, active_wakener = Lwt.wait () in
-    let restart_waiter, restart_wakener = Lwt.wait () in
+    let active_waiter, active_wakener =
+      Promise.create
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
+    let restart_waiter, restart_wakener =
+      Promise.create
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
     { active = `Inactive
     ; focused = None
     ; active_waiter
@@ -637,16 +663,16 @@ end
 
 type 'a handler =
   { hd_service_handler : 'a Service_handler.t
-  ; hd_stream : (string * int option * string Ecb.channel_data) Eliom_stream.t }
+  ; hd_stream : (string * int option * string Ecb.channel_data) Eliom_stream.t
+  }
 
 let handler_stream hd =
   Eliom_stream.map_list
     (fun x -> x)
     (Eliom_stream.from (fun () ->
-       Lwt.try_bind
-         (fun () -> Service_handler.wait_data hd)
-         (fun s -> Lwt.return_some s)
-         (fun _ -> Lwt.return_none)))
+       match Service_handler.wait_data hd with
+       | s -> Some s
+       | exception _ -> None))
 
 let stateful_handler_table :
   (Ecb.comet_service, Service_handler.stateful handler) Hashtbl.t
@@ -750,16 +776,23 @@ let register' hd position (_ : Ecb.comet_service) (chan_id : 'a Ecb.chan_id) =
         | id, pos, data
           when id = chan_id && check_and_update_position position pos data -> (
           match data with
-          | Ecb.Full -> Lwt.fail Channel_full
-          | Ecb.Closed -> Lwt.fail Channel_closed
-          | Ecb.Data x -> Lwt.return_some (unmarshal x : 'a))
-        | _ -> Lwt.return_none)
+          | Ecb.Full -> raise Channel_full
+          | Ecb.Closed -> raise Channel_closed
+          | Ecb.Data x -> Some (unmarshal x : 'a))
+        | _ -> None)
       (Eliom_stream.clone hd.hd_stream)
   in
   let protect_and_close t =
-    let t' = Lwt.protected t in
-    Lwt.on_cancel t' (fun () ->
-      Service_handler.close hd.hd_service_handler chan_id);
+    let t' =
+      Lwt.protected
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        t
+    in
+    Lwt.on_cancel
+      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+      t' (fun () -> Service_handler.close hd.hd_service_handler chan_id);
     t'
   in
   (* protect the stream from cancels *)
diff --git a/src/lib/eliom_comet.client.mli b/src/lib/eliom_comet.client.mli
index 2258658d68..268441d170 100644
--- a/src/lib/eliom_comet.client.mli
+++ b/src/lib/eliom_comet.client.mli
@@ -52,7 +52,7 @@ val activate : unit -> unit
 (** if the client is inactive [activate ()] launch a new xhr
     connection to start receiving server messages *)
 
-val set_handle_exn_function : (?exn:exn -> unit -> unit Lwt.t) -> unit
+val set_handle_exn_function : (?exn:exn -> unit -> unit) -> unit
 (** Makes possible to customize the function called when comet fails
     for unknown reason.
     The usual practice is to warn the user and ask to reload the page.
@@ -142,7 +142,7 @@ val close : 'a Eliom_comet_base.wrapped_channel -> unit
 
 val force_link : unit
 
-val handle_exn : ?exn:exn -> unit -> unit Lwt.t
+val handle_exn : ?exn:exn -> unit -> unit
 (** This function calls manually the function
     that is usually called automatically when an exception
     is received during communication. *)
diff --git a/src/lib/eliom_comet.server.ml b/src/lib/eliom_comet.server.ml
index 92c52483b9..3b5bf76e91 100644
--- a/src/lib/eliom_comet.server.ml
+++ b/src/lib/eliom_comet.server.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -52,7 +52,7 @@ exception New_connection
 module Comet_param = struct
   type page = string
 
-  let translate content = Lwt.return (content, json_content_type)
+  let translate content = content, json_content_type
 end
 
 module Comet =
@@ -64,16 +64,14 @@ let comet_global_path = ["__eliom_comet_global__"]
 let fallback_service =
   Eliom_common.lazy_site_value_from_fun @@ fun () ->
   Comet.create ~meth:(Eliom_service.Get Eliom_parameter.unit)
-    ~path:(Eliom_service.Path comet_path) (fun () () ->
-    Lwt.return state_closed_msg)
+    ~path:(Eliom_service.Path comet_path) (fun () () -> state_closed_msg)
 
 let fallback_global_service =
   Eliom_common.lazy_site_value_from_fun @@ fun () ->
   Comet.create ~meth:(Eliom_service.Get Eliom_parameter.unit)
     ~path:(Eliom_service.Path comet_global_path) (fun () () ->
-    Lwt.return
-      (error_msg
-         "request with no post parameters, or there isn't any registered site comet channel"))
+    error_msg
+      "request with no post parameters, or there isn't any registered site comet channel")
 
 let new_id = Eliom_lib.make_cryptographic_safe_string
 
@@ -105,7 +103,7 @@ end = struct
     ; mutable ch_index : int
     ; (* the number of messages already added to the channel *)
       ch_content : (string * int) Dlist.t
-    ; ch_wakeup : unit Lwt_condition.t
+    ; ch_wakeup : Eio.Condition.t
       (* condition broadcasted when there is a new message *) }
 
   module Channel_hash = struct
@@ -124,7 +122,7 @@ end = struct
       { ch_id = ""
       ; ch_index = 0
       ; ch_content = Dlist.create 1
-      ; ch_wakeup = Lwt_condition.create () }
+      ; ch_wakeup = Eio.Condition.create () }
     in
     fun ch_id ->
       let dummy = {dummy_channel with ch_id} in
@@ -141,19 +139,18 @@ end = struct
     let f msg =
       match Weak.get channel 0 with
       | None ->
-          Lwt.fail Not_found
+          raise Not_found
           (* terminates the loop: remove reference on the stream, etc ... *)
       | Some channel ->
           channel.ch_index <- succ channel.ch_index;
           ignore
             (Dlist.add (msg, channel.ch_index) channel.ch_content : 'a option);
-          wakeup_waiters channel;
-          Lwt.return_unit
+          wakeup_waiters channel
     in
     ignore
-      (Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-       Eliom_stream.iter_s f stream
-       : unit Lwt.t)
+      (Fiber.without_binding Eliom_common.sp_key (fun () ->
+         Eliom_stream.iter_s f stream)
+       : unit Promise.t)
 
   let make_name name = "stateless:" ^ name
 
@@ -166,7 +163,7 @@ end = struct
       { ch_id = name
       ; ch_index = 0
       ; ch_content = Dlist.create size
-      ; ch_wakeup = Lwt_condition.create () }
+      ; ch_wakeup = Eio.Condition.create () }
     in
     run_channel channel stream;
     match find_channel name with
@@ -240,17 +237,24 @@ end = struct
     let rec make_list = function
       | [] -> []
       | Eliom_lib.Left (channel, _) :: q ->
-          Lwt_condition.wait channel.ch_wakeup :: make_list q
+          Eio.Condition.await
+            (* TODO: ciao-lwt: A mutex must be passed *) channel.ch_wakeup
+            __mutex__
+          :: make_list q
       | Eliom_lib.Right _ :: _ -> assert false
       (* closed channels are considered to have data *)
     in
-    Lwt.pick (make_list requests)
+    Fiber.any
+      ((* TODO: ciao-lwt: This expression is a ['a Lwt.t list] but a [(unit -> 'a) list] is expected. *)
+       make_list requests)
 
   let wait_data requests =
     if List.exists has_data requests
-    then Lwt.return_unit
+    then ()
     else
-      Lwt_unix.with_timeout (timeout ()) (fun () -> really_wait_data requests)
+      Eio.Time.with_timeout_exn
+        (Stdlib.Option.get (Fiber.get Ocsigen_lib.env))#mono_clock (timeout ())
+        (fun () -> really_wait_data requests)
 
   let handle_request () (_, req) =
     match req with
@@ -259,15 +263,13 @@ end = struct
           "attempting to request data on stateless service with a stateful request"
     | Eliom_comet_base.Stateless requests ->
         let requests = List.map get_channel (Array.to_list requests) in
-        let* res =
-          Lwt.catch
-            (fun () ->
-               let* () = wait_data requests in
-               Lwt.return (List.flatten (List.map get_available_data requests)))
-            (function
-              | Lwt_unix.Timeout -> Lwt.return_nil | exc -> Lwt.reraise exc)
+        let res =
+          try
+            let () = wait_data requests in
+            List.flatten (List.map get_available_data requests)
+          with Eio.Time.Timeout -> []
         in
-        Lwt.return (encode_global_downgoing res)
+        encode_global_downgoing res
 
   let global_service =
     Eliom_common.lazy_site_value_from_fun @@ fun () ->
@@ -321,11 +323,7 @@ module Stateful : sig
   type comet_service = Eliom_comet_base.comet_service
 
   val get_service : t -> comet_service
-
-  val wait_timeout :
-     ?scope:Eliom_common.client_process_scope
-    -> float
-    -> unit Lwt.t
+  val wait_timeout : ?scope:Eliom_common.client_process_scope -> float -> unit
 end = struct
   type chan_id = string
   type comet_service = Eliom_comet_base.comet_service
@@ -338,7 +336,7 @@ end = struct
     | Inactive of float
     (** The last request from the client completed at that time *)
 
-  type waiter = [`Data | `Update] Lwt.t
+  type waiter = [`Data | `Update] Promise.t
 
   type channel =
     | Events of
@@ -379,7 +377,7 @@ end = struct
     match handler.hd_activity with
     | Active l ->
         handler.hd_activity <- Inactive (Unix.gettimeofday ());
-        List.iter (fun waiter -> Lwt.wakeup waiter ()) l
+        List.iter (fun waiter -> Promise.resolve waiter ()) l
     | Inactive _ -> ()
 
   let update_inactive handler =
@@ -391,10 +389,15 @@ end = struct
     let rec run () =
       match handler.hd_activity with
       | Active l ->
-          let waiter, waker = Lwt.task () in
+          let waiter, waker =
+            Promise.create
+              (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+              (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+              ()
+          in
           let t =
-            let* () = waiter in
-            let* () = Lwt_unix.sleep t in
+            let () = waiter in
+            let () = Eio_unix.sleep t in
             run ()
           in
           handler.hd_activity <- Active (waker :: l);
@@ -402,9 +405,9 @@ end = struct
       | Inactive inactive_time ->
           let now = Unix.gettimeofday () in
           if now -. inactive_time > t
-          then Lwt.return_unit
+          then ()
           else
-            let* () = Lwt_unix.sleep (t -. (now -. inactive_time)) in
+            let () = Eio_unix.sleep (t -. (now -. inactive_time)) in
             run ()
     in
     run ()
@@ -430,13 +433,15 @@ end = struct
     | None -> ()
     | Some wakener ->
         handler.hd_update_streams_w <- None;
-        Lwt.wakeup wakener event
+        Promise.resolve wakener event
 
   let stream_waiter s =
-    Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-    Lwt.no_cancel
-      (let* _ = Eliom_stream.peek s in
-       Lwt.return `Data)
+    Fiber.without_binding Eliom_common.sp_key (fun () ->
+      Lwt.no_cancel
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        (let _ = Eliom_stream.peek s in
+         `Data))
 
   (** read up to [n] messages in the list of streams [streams] without blocking. *)
   let read_channels n handler =
@@ -452,8 +457,8 @@ end = struct
             else take (n - 1) ((id, Queue.take queue) :: acc) channels
         | (id, Stream ({stream; _} as s)) :: rem ->
             let l =
-              Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-              Eliom_stream.get_available_up_to n stream
+              Fiber.without_binding Eliom_common.sp_key (fun () ->
+                Eliom_stream.get_available_up_to n stream)
             in
             if l <> [] then s.waiter <- stream_waiter stream;
             take (n - List.length l) (List.rev_map (fun v -> id, v) l @ acc) rem
@@ -472,16 +477,22 @@ end = struct
       handles new channels the server creates after that the client
       registered them *)
   let rec wait_data wait_closed_connection handler =
-    Lwt.bind
-      (let hd_update_streams, hd_update_streams_w = Lwt.task () in
-       handler.hd_update_streams_w <- Some hd_update_streams_w;
-       Lwt.choose
-         (wait_closed_connection :: hd_update_streams :: wait_channels handler))
-      (function
-        | `Data ->
-            handler.hd_update_streams_w <- None;
-            Lwt.return_unit
-        | `Update -> wait_data wait_closed_connection handler)
+    match
+      let hd_update_streams, hd_update_streams_w =
+        Promise.create
+          (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+          (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+          ()
+      in
+      handler.hd_update_streams_w <- Some hd_update_streams_w;
+      Fiber.any
+        (List.map
+           (fun p () -> Promise.await p)
+           (* TODO: ciao-lwt: The list [wait_closed_connection :: hd_update_streams :: wait_channels handler] is expected to be a list of promises. Use [Fiber.fork_promise] to make a promise. *)
+           (wait_closed_connection :: hd_update_streams :: wait_channels handler))
+    with
+    | `Data -> handler.hd_update_streams_w <- None
+    | `Update -> wait_data wait_closed_connection handler
 
   let launch_channel handler chan_id channel =
     handler.hd_active_channels <-
@@ -513,10 +524,8 @@ end = struct
       List.filter (( <> ) chan_id) handler.hd_registered_chan_id
 
   let wait_closed_connection () =
-    let* () =
-      Ocsigen_request.connection_closed (Eliom_request_info.get_ri ())
-    in
-    Lwt.fail Connection_closed
+    let () = Ocsigen_request.connection_closed (Eliom_request_info.get_ri ()) in
+    raise Connection_closed
 
   (* register the service handler.hd_service *)
   let run_handler handler =
@@ -525,42 +534,41 @@ end = struct
       | Eliom_comet_base.Stateless _ ->
           failwith
             "attempting to request data on stateful service with a stateless request"
-      | Eliom_comet_base.Stateful (Eliom_comet_base.Request_data number) ->
+      | Eliom_comet_base.Stateful (Eliom_comet_base.Request_data number) -> (
           Logs.info ~src:section (fun fmt -> fmt "received request %i" number);
           (* if a new connection occurs for a service, we reply
            immediately to the previous with no data. *)
           new_connection handler;
           if snd handler.hd_last = number
-          then Lwt.return (fst handler.hd_last)
+          then fst handler.hd_last
           else
-            Lwt.catch
-              (fun () ->
-                 Lwt_unix.with_timeout (timeout ()) (fun () ->
-                   let* messages =
-                     let messages = read_channels 100 handler in
-                     if messages <> [] || idle
-                     then Lwt.return messages
-                     else
-                       let* () =
-                         wait_data (wait_closed_connection ()) handler
-                       in
-                       Lwt.return (read_channels 100 handler)
-                   in
-                   let message = encode_downgoing messages in
-                   handler.hd_last <- message, number;
-                   set_inactive handler;
-                   Lwt.return message))
-              (function
-                | New_connection -> Lwt.return (encode_downgoing [])
+            try
+              Eio.Time.with_timeout_exn
+                (Stdlib.Option.get (Fiber.get Ocsigen_lib.env))#mono_clock
+                (timeout ()) (fun () ->
+                let messages =
+                  let messages = read_channels 100 handler in
+                  if messages <> [] || idle
+                  then messages
+                  else
+                    let () = wait_data (wait_closed_connection ()) handler in
+                    read_channels 100 handler
+                in
+                let message = encode_downgoing messages in
+                handler.hd_last <- message, number;
+                set_inactive handler;
+                message)
+            with
+            | New_connection ->
+                encode_downgoing []
                 (* happens if an other connection has been opened on that service *)
                 (* CCC in this case, it would be beter to return code 204: no content *)
-                | Lwt_unix.Timeout ->
-                    set_inactive handler; Lwt.return timeout_msg
-                | Connection_closed ->
-                    set_inactive handler;
-                    (* it doesn't matter what we do here *)
-                    Lwt.return timeout_msg
-                | e -> set_inactive handler; Lwt.fail e)
+            | Eio.Time.Timeout -> set_inactive handler; timeout_msg
+            | Connection_closed ->
+                set_inactive handler;
+                (* it doesn't matter what we do here *)
+                timeout_msg
+            | e -> set_inactive handler; raise e)
       | Eliom_comet_base.Stateful (Eliom_comet_base.Commands commands) ->
           update_inactive handler;
           List.iter
@@ -571,7 +579,7 @@ end = struct
             (Array.to_list commands);
           (* command connections are replied immediately by an
                  empty answer *)
-          Lwt.return (encode_downgoing [])
+          encode_downgoing []
     in
     let {hd_service = Eliom_comet_base.Internal_comet_service (service, _); _} =
       handler
@@ -708,8 +716,8 @@ end = struct
     let handler = get_handler scope in
     Logs.info ~src:section (fun fmt -> fmt "create channel %s" name);
     let stream =
-      Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-      Eliom_stream.map (fun x -> Eliom_comet_base.Data (marshal x)) stream
+      Fiber.without_binding Eliom_common.sp_key (fun () ->
+        Eliom_stream.map (fun x -> Eliom_comet_base.Data (marshal x)) stream)
     in
     let channel = Stream {stream; waiter = stream_waiter stream} in
     if List.mem name handler.hd_registered_chan_id
@@ -768,10 +776,7 @@ module Channel : sig
     -> unit
     -> 'a t
 
-  val wait_timeout :
-     ?scope:Eliom_common.client_process_scope
-    -> float
-    -> unit Lwt.t
+  val wait_timeout : ?scope:Eliom_common.client_process_scope -> float -> unit
 end = struct
   type 'a channel =
     | Stateless of Stateless.channel
@@ -812,14 +817,14 @@ end = struct
   let create_stateless_channel ?name ~size stream =
     Stateless
       (Stateless.create ?name ~size
-         ( Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-           Eliom_stream.map marshal stream ))
+         (Fiber.without_binding Eliom_common.sp_key (fun () ->
+            Eliom_stream.map marshal stream)))
 
   let create_stateless_newest_channel ?name stream =
     Stateless_newest
       (Stateless.create ?name ~size:1
-         ( Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-           Eliom_stream.map marshal stream ))
+         (Fiber.without_binding Eliom_common.sp_key (fun () ->
+            Eliom_stream.map marshal stream)))
 
   let create_stateful ?scope ?name ?(size = 1000) events =
     { channel = create_stateful_channel ?scope ?name ~size events
diff --git a/src/lib/eliom_comet.server.mli b/src/lib/eliom_comet.server.mli
index 0c3e8b9c1c..c8d4f89a31 100644
--- a/src/lib/eliom_comet.server.mli
+++ b/src/lib/eliom_comet.server.mli
@@ -120,10 +120,7 @@ module Channel : sig
       number of messages retrieved at the first request. The default
       is [1]. *)
 
-  val wait_timeout :
-     ?scope:Eliom_common.client_process_scope
-    -> float
-    -> unit Lwt.t
+  val wait_timeout : ?scope:Eliom_common.client_process_scope -> float -> unit
   (** [wait_timeout ~scope time] waits for a period of inactivity of
       length [time] in the [scope]. Only activity on stateful
       channels is taken into accounts.
diff --git a/src/lib/eliom_common.server.ml b/src/lib/eliom_common.server.ml
index f4a33f5e8c..a287607d8f 100644
--- a/src/lib/eliom_common.server.ml
+++ b/src/lib/eliom_common.server.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -242,11 +242,11 @@ type 'a cookie_info1 =
   (* None = new cookie
       (not sent by the browser) *)
   * one_persistent_cookie_info session_cookie ref)
+    Promise.t
     (* SCNo_data = the session has been closed
       SCData_session_expired = the cookie has not been found in the table.
       For both of them, ask the browser to remove the cookie.
     *)
-    Lwt.t
     Lazy.t
     Full_state_name_table.t
     ref
@@ -383,7 +383,7 @@ and naservice_table_content =
   (* max_use *)
   * (float * float ref) option
   (* timeout and expiration date *)
-  * (server_params -> Ocsigen_response.t Lwt.t)
+  * (server_params -> Ocsigen_response.t)
   * (page_table ref * page_table_key, na_key_serv) leftright
       Ocsigen_cache.Dlist.node
       option
@@ -474,7 +474,7 @@ and sitedata =
   ; (* Limitation of the number of groups per site *)
     mutable remove_session_data : string -> unit
   ; mutable not_bound_in_data_tables : string -> bool
-  ; mutable exn_handler : exn -> Ocsigen_response.t Lwt.t
+  ; mutable exn_handler : exn -> Ocsigen_response.t
   ; mutable unregistered_services : Url.path list
   ; mutable unregistered_na_services : na_key_serv list
   ; mutable max_volatile_data_sessions_per_group : int * bool
@@ -597,11 +597,11 @@ let make_server_params
   ; sp_full_state_name = full_state_name
   ; sp_client_process_info = cpi }
 
-let sp_key = Lwt.new_key ()
-let get_sp_option () = Lwt.get sp_key
+let sp_key = Fiber.create_key ()
+let get_sp_option () = Fiber.get sp_key
 
 let get_sp () =
-  match Lwt.get sp_key with
+  match Fiber.get sp_key with
   | Some sp -> sp
   | None ->
       let msg =
@@ -860,7 +860,6 @@ let get_mask4 sitedata = get_mask4 sitedata.ipv4mask
 let get_mask6 sitedata = get_mask6 sitedata.ipv6mask
 
 (*****************************************************************************)
-open Lwt
 
 (* The cookie name is
 
@@ -940,7 +939,7 @@ let get_session_info ~sitedata ~req previous_extension_err =
       Ocsigen_request.post_params ri ci.Ocsigen_extensions.uploaddir
         ci.Ocsigen_extensions.maxuploadfilesize
     with
-    | None -> true, Lwt.return []
+    | None -> true, []
     | Some v -> false, v
   in
   let no_file_param, file_params =
@@ -948,10 +947,10 @@ let get_session_info ~sitedata ~req previous_extension_err =
       Ocsigen_request.files ri ci.Ocsigen_extensions.uploaddir
         ci.Ocsigen_extensions.maxuploadfilesize
     with
-    | None -> true, Lwt.return []
+    | None -> true, []
     | Some v -> false, v
   in
-  let* post_params = p in
+  let post_params = p in
   let previous_tab_cookies_info, tab_cookies, post_params =
     try
       let tci, utc, tc =
@@ -1027,7 +1026,7 @@ let get_session_info ~sitedata ~req previous_extension_err =
   *)
   let get_params0 = get_params in
   let post_params0 = post_params in
-  let* file_params0 = file_params in
+  let file_params0 = file_params in
   let ( get_params
       , post_params
       , file_params
@@ -1272,10 +1271,9 @@ let get_session_info ~sitedata ~req previous_extension_err =
       ; si_expect_process_data =
           epd (*204FORMS*     si_internal_form= internal_form; *) } )
   in
-  Lwt.return
-    ( {req_whole with Ocsigen_extensions.request_info = ri}
-    , sess
-    , previous_tab_cookies_info )
+  ( {req_whole with Ocsigen_extensions.request_info = ri}
+  , sess
+  , previous_tab_cookies_info )
 
 exception Eliom_retry_with of info
 
@@ -1299,7 +1297,7 @@ module Omit_persistent_storage = struct
     | _ -> false
 
   let not_if_omitting_storage f =
-    if check_if_omitting_storage () then Lwt.return_unit else f ()
+    if check_if_omitting_storage () then () else f ()
 end
 
 module Ocsipersist = struct
@@ -1371,34 +1369,38 @@ module Persistent_tables = struct
 
   (** removes the entry from all opened tables *)
   let remove_key_from_all_tables key =
-    (* doesn't remove entry from Persistent_cookies_expiry_dates; not a problem *)
-    Lwt_list.iter_s
+    List.iter
+      (* doesn't remove entry from Persistent_cookies_expiry_dates; not a problem *)
       (fun (module T : Ocsipersist.TABLE with type key = string) ->
          T.remove key)
-      !functorial_tables
-    >>= fun () ->
-    Lwt_list.iter_s (* could be replaced by iter_p *)
+      !functorial_tables;
+    List.iter
+      (* could be replaced by iter_p *)
       (fun t ->
-         Ocsipersist.Polymorphic.open_table t >>= fun table ->
-         Ocsipersist.Polymorphic.remove table key >>= Lwt.pause)
+         let table = Ocsipersist.Polymorphic.open_table t in
+         Fiber.yield (Ocsipersist.Polymorphic.remove table key))
       !polymorphic_tables
 
   let number_of_tables () =
     List.length !polymorphic_tables + List.length !functorial_tables
 
   let number_of_table_elements () =
-    Lwt_list.map_s
-      (fun t ->
-         Ocsipersist.Polymorphic.open_table t >>= fun table ->
-         Ocsipersist.Polymorphic.length table >>= fun e -> Lwt.return (t, e))
-      !polymorphic_tables
-    >>= fun polymorphic_counts ->
-    Lwt_list.map_s
-      (fun (module T : Ocsipersist.TABLE with type key = string) ->
-         T.length () >>= fun n -> Lwt.return (T.name, n))
-      !functorial_tables
-    >>= fun functorial_counts ->
-    Lwt.return @@ polymorphic_counts @ functorial_counts
+    let polymorphic_counts =
+      List.map
+        (fun t ->
+           let table = Ocsipersist.Polymorphic.open_table t in
+           let e = Ocsipersist.Polymorphic.length table in
+           t, e)
+        !polymorphic_tables
+    in
+    let functorial_counts =
+      List.map
+        (fun (module T : Ocsipersist.TABLE with type key = string) ->
+           let n = T.length () in
+           T.name, n)
+        !functorial_tables
+    in
+    polymorphic_counts @ functorial_counts
 end
 
 (**** Wrapper type shared by client/server side ***)
diff --git a/src/lib/eliom_common.server.mli b/src/lib/eliom_common.server.mli
index 8d8c3c8e69..b2cb39c32c 100644
--- a/src/lib/eliom_common.server.mli
+++ b/src/lib/eliom_common.server.mli
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Module eliom_common.mli
@@ -358,7 +360,7 @@ type 'a cookie_info1 =
       ref
   * ((string * timeout * float option * perssessgrp option) option
     * one_persistent_cookie_info session_cookie ref)
-      Lwt.t
+      Promise.t
       Lazy.t
       Full_state_name_table.t
       ref
@@ -412,7 +414,7 @@ type ('params, 'result) service =
   { s_id : anon_params_type * anon_params_type
   ; mutable s_max_use : int option
   ; s_expire : (float * float ref) option
-  ; s_f : bool -> 'params -> 'result Lwt.t }
+  ; s_f : bool -> 'params -> 'result }
 
 type server_params =
   { sp_request : Ocsigen_extensions.request
@@ -455,7 +457,7 @@ and naservice_table_content =
   (* max_use *)
   * (float * float ref) option
   (* timeout and expiration date *)
-  * (server_params -> Ocsigen_response.t Lwt.t)
+  * (server_params -> Ocsigen_response.t)
   * (page_table ref * page_table_key, na_key_serv) leftright
       Ocsigen_cache.Dlist.node
       option
@@ -537,7 +539,7 @@ and sitedata =
   ; (* Limitation of the number of groups per site *)
     mutable remove_session_data : string -> unit
   ; mutable not_bound_in_data_tables : string -> bool
-  ; mutable exn_handler : exn -> Ocsigen_response.t Lwt.t
+  ; mutable exn_handler : exn -> Ocsigen_response.t
   ; mutable unregistered_services : Url.path list
   ; mutable unregistered_na_services : na_key_serv list
   ; mutable max_volatile_data_sessions_per_group : int * bool
@@ -604,10 +606,9 @@ val get_session_info :
    sitedata:sitedata
   -> req:Ocsigen_extensions.request
   -> int
-  -> (Ocsigen_extensions.request
+  -> Ocsigen_extensions.request
      * sess_info
-     * (tables cookie_info * Ocsigen_cookie_map.t) option)
-       Lwt.t
+     * (tables cookie_info * Ocsigen_cookie_map.t) option
 
 type ('a, 'b) foundornot = Found of 'a | Notfound of 'b
 
@@ -626,15 +627,15 @@ val make_full_state_name2 :
   -> full_state_name
 
 module Persistent_tables : sig
-  val create : string -> 'a Ocsipersist.table Lwt.t
+  val create : string -> 'a Ocsipersist.table
 
   val add_functorial_table :
      (module Ocsipersist.TABLE with type key = string)
     -> unit
 
-  val remove_key_from_all_tables : string -> unit Lwt.t
+  val remove_key_from_all_tables : string -> unit
   val number_of_tables : unit -> int
-  val number_of_table_elements : unit -> (string * int) list Lwt.t
+  val number_of_table_elements : unit -> (string * int) list
 end
 
 val absolute_change_sitedata : sitedata -> unit
diff --git a/src/lib/eliom_common_base.shared.ml b/src/lib/eliom_common_base.shared.ml
index 8b90bc1c34..ac3cc846a5 100644
--- a/src/lib/eliom_common_base.shared.ml
+++ b/src/lib/eliom_common_base.shared.ml
@@ -206,8 +206,8 @@ type sess_info =
       string Full_state_name_table.t
       * string Full_state_name_table.t
       * string Full_state_name_table.t
-    (* the same, but for secure cookies *)
-  ; (* now for tab cookies: *)
+  ; (* the same, but for secure cookies *)
+    (* now for tab cookies: *)
     si_service_session_cookies_tab : string Full_state_name_table.t
   ; si_data_session_cookies_tab : string Full_state_name_table.t
   ; si_persistent_session_cookies_tab : string Full_state_name_table.t
@@ -364,7 +364,7 @@ type ('params, 'result) service =
     s_id : anon_params_type * anon_params_type
   ; mutable s_max_use : int option
   ; s_expire : (float * float ref) option
-  ; s_f : bool -> 'params -> 'result Lwt.t }
+  ; s_f : bool -> 'params -> 'result }
 
 type 'a to_and_of = {of_string : string -> 'a; to_string : 'a -> string}
 
diff --git a/src/lib/eliom_content.client.mli b/src/lib/eliom_content.client.mli
index c9d9b399c2..b438ceaaf5 100644
--- a/src/lib/eliom_content.client.mli
+++ b/src/lib/eliom_content.client.mli
@@ -931,10 +931,10 @@ val force_link : unit
 val set_client_fun :
    ?app:string
   -> service:('a, 'b, _, _, _, _, _, _, _, _, _) Eliom_service.t
-  -> ('a -> 'b -> Eliom_service.result Lwt.t)
+  -> ('a -> 'b -> Eliom_service.result)
   -> unit
 
-val set_form_error_handler : (unit -> bool Lwt.t) -> unit
+val set_form_error_handler : (unit -> bool) -> unit
 (** With [set_form_error_handler f], [f] becomes the action to be
     called when we are unable to call a client-side service due to
     invalid form data.
diff --git a/src/lib/eliom_cscache.eliom b/src/lib/eliom_cscache.eliom
index 1262fb0899..79bbca3e0e 100644
--- a/src/lib/eliom_cscache.eliom
+++ b/src/lib/eliom_cscache.eliom
@@ -1,10 +1,10 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Copyright Vincent Balat *)
 
 [%%shared.start]
 
-type ('a, 'b) t = (unit -> ('a, 'b Lwt.t) Hashtbl.t) Eliom_shared.Value.t
+type ('a, 'b) t = (unit -> ('a, 'b Promise.t) Hashtbl.t) Eliom_shared.Value.t
 
 let%client create_ () =
   let c = Hashtbl.create 100 in
@@ -24,9 +24,9 @@ let do_cache_raw cache id data =
   let c = Eliom_shared.Value.local cache () in
   Hashtbl.replace c id data;
   (* Do not cache exceptions *)
-  ignore (Lwt.catch (fun _ -> data) (fun e -> Hashtbl.remove c id; Lwt.fail e))
+  ignore (try data with e -> Hashtbl.remove c id; raise e)
 
-let do_cache cache id data = do_cache_raw cache id (Lwt.return data)
+let do_cache cache id data = do_cache_raw cache id data
 
 let%server do_cache cache id v =
   do_cache cache id v;
@@ -36,9 +36,9 @@ let%server find cache get_data id =
   try Hashtbl.find ((Eliom_shared.Value.local cache) ()) id
   with Not_found ->
     let th =
-      let* v = get_data id in
+      let v = get_data id in
       ignore [%client.unsafe (do_cache ~%cache ~%id ~%v : unit)];
-      Lwt.return v
+      v
     in
     (* On server side, we put immediately in table the thread that is
        fetching the data.  in order to avoid fetching it several
@@ -62,4 +62,4 @@ let local_find cache id = Hashtbl.find ((Eliom_shared.Value.local cache) ()) id
 
 let find_if_ready cache id =
   let v = local_find cache id in
-  match Lwt.state v with Lwt.Return v -> v | _ -> raise Not_ready
+  match Promise.peek v with Some v -> v | _ -> raise Not_ready
diff --git a/src/lib/eliom_cscache.eliomi b/src/lib/eliom_cscache.eliomi
index edfafed6ee..5d0db53b68 100644
--- a/src/lib/eliom_cscache.eliomi
+++ b/src/lib/eliom_cscache.eliomi
@@ -32,7 +32,7 @@ type ('a, 'b) t
 
 [%%shared.start]
 
-val find : ('a, 'b) t -> ('a -> 'b Lwt.t) -> 'a -> 'b Lwt.t
+val find : ('a, 'b) t -> ('a -> 'b) -> 'a -> 'b
 (** [find cache get_from_db key] returns the value associated to [key]
     in cache.  If not present, it calls [get_from_db] to fetch the
     data from the database. [get_from_db] must be implemented both
@@ -47,7 +47,7 @@ val do_cache : ('a, 'b) t -> 'a -> 'b -> unit
     server side, it will have effect both on the server cache (scope:
     request) and the client side cache.  *)
 
-val local_find : ('a, 'b) t -> 'a -> 'b Lwt.t
+val local_find : ('a, 'b) t -> 'a -> 'b
 (** Find a piece of data in local cache, without trying to fetch it
     from server. Raises [Not_found] instead.  If the value is currently
     being retrieved, it waits for it to be ready before returning.  *)
@@ -61,7 +61,7 @@ val find_if_ready : ('a, 'b) t -> 'a -> 'b
 
 [%%client.start]
 
-val load : ('a, 'b) t -> ('a -> 'b Lwt.t) -> 'a -> 'b Lwt.t
+val load : ('a, 'b) t -> ('a -> 'b) -> 'a -> 'b
 (** Load (or reload) in cache the piece of data from server  *)
 
 [%%server.start]
diff --git a/src/lib/eliom_extension.server.ml b/src/lib/eliom_extension.server.ml
index 4ee5deab6b..5726cd408f 100644
--- a/src/lib/eliom_extension.server.ml
+++ b/src/lib/eliom_extension.server.ml
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2008 Vincent Balat
@@ -23,7 +25,7 @@
 (*****************************************************************************)
 (*****************************************************************************)
 
-type eliom_extension_sig = unit -> Ocsigen_extensions.answer Lwt.t
+type eliom_extension_sig = unit -> Ocsigen_extensions.answer
 
 let module_action : eliom_extension_sig ref =
   ref (fun _ -> failwith "Eliommod_extension")
@@ -33,4 +35,4 @@ let get_eliom_extension () = !module_action
 
 let run_eliom_extension (fext : eliom_extension_sig) _now info sitedata =
   let sp = Eliom_common.make_server_params sitedata info None None in
-  Lwt.with_value Eliom_common.sp_key (Some sp) fext
+  Fiber.with_binding Eliom_common.sp_key sp fext
diff --git a/src/lib/eliom_extension.server.mli b/src/lib/eliom_extension.server.mli
index c873f45f66..9783f7ca9d 100644
--- a/src/lib/eliom_extension.server.mli
+++ b/src/lib/eliom_extension.server.mli
@@ -21,7 +21,7 @@
     manual for more information about {% <<a_manual chapter="workflow-configuration"
     fragment="extensions"| Eliom's extensions>>%} *)
 
-type eliom_extension_sig = unit -> Ocsigen_extensions.answer Lwt.t
+type eliom_extension_sig = unit -> Ocsigen_extensions.answer
 (** Type of the function that must be registered to declare an eliom extension. *)
 
 val register_eliom_extension : eliom_extension_sig -> unit
@@ -35,4 +35,4 @@ val run_eliom_extension :
   -> float
   -> Eliom_common.info
   -> Eliom_common.sitedata
-  -> Ocsigen_extensions.answer Lwt.t
+  -> Ocsigen_extensions.answer
diff --git a/src/lib/eliom_form.eliom b/src/lib/eliom_form.eliom
index b15d39df86..5a6f832c7b 100644
--- a/src/lib/eliom_form.eliom
+++ b/src/lib/eliom_form.eliom
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Module Eliom_form
@@ -22,24 +24,22 @@ open%shared Js_of_ocaml
 
 [%%client.start]
 
-open Lwt.Syntax
-
 let read_params form y =
   Eliom_parameter.reconstruct_params_form (Form.form_elements form) y
 
 let error_handler =
-  ref @@ fun _ -> Lwt.fail_with "Cannot parse params for client-side service"
+  ref @@ fun _ -> failwith "Cannot parse params for client-side service"
 
 let set_error_handler f = error_handler := f
 
 let iter_contents y ev f =
-  let fls () = Lwt.return_false in
+  let fls () = false in
   Js.Opt.case ev##.target fls @@ fun target ->
   Js.Opt.case (Dom_html.CoerceTo.form target) fls @@ fun target ->
   match read_params target y with
   | Some v ->
-      let* () = f v in
-      Lwt.return_true
+      let () = f v in
+      true
   | None -> !error_handler ()
 
 type client_form_handler = Eliom_client.client_form_handler
@@ -47,7 +47,7 @@ type client_form_handler = Eliom_client.client_form_handler
 let make_hdlr_get service : client_form_handler =
  fun ev ->
   match Eliom_service.client_fun service with
-  | None -> Lwt.return_false
+  | None -> false
   | Some _ ->
       iter_contents (Eliom_service.get_params_type service) ev @@ fun g ->
       Eliom_client.change_page ~service g ()
@@ -55,7 +55,7 @@ let make_hdlr_get service : client_form_handler =
 let make_hdlr_post service g : client_form_handler =
  fun ev ->
   match Eliom_service.client_fun service with
-  | None -> Lwt.return_false
+  | None -> false
   | Some _ ->
       iter_contents (Eliom_service.post_params_type service) ev @@ fun p ->
       Eliom_client.change_page ~service g p
@@ -152,12 +152,14 @@ module Make_links (Html : Html) = struct
               then (
                 Dom.preventDefault ev;
                 Dom_html.stopPropagation ev;
-                Lwt.async @@ fun () ->
-                Eliom_client.change_page ?absolute:~%absolute
-                  ?absolute_path:~%absolute_path ?https:~%https
-                  ~service:~%service ?hostname:~%hostname ?port:~%port
-                  ?fragment:~%fragment ?keep_nl_params:~%keep_nl_params
-                  ?nl_params:~%nl_params ~%getparams ())]
+                Fiber.fork
+                  ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+                  (fun () ->
+                     Eliom_client.change_page ?absolute:~%absolute
+                       ?absolute_path:~%absolute_path ?https:~%https
+                       ~service:~%service ?hostname:~%hostname ?port:~%port
+                       ?fragment:~%fragment ?keep_nl_params:~%keep_nl_params
+                       ?nl_params:~%nl_params ~%getparams ()))]
         in
         Html.a_onclick f :: href :: a
       else href :: a
@@ -639,8 +641,11 @@ module Make (Html : Html) = struct
         a_onsubmit_service info :: a
       else a
     in
-    get_form_ Lwt.bind Lwt.return ?absolute ?absolute_path ?https ~a ~service
-      ?hostname ?port ?fragment ?nl_params ?keep_nl_params contents
+    get_form_
+      (fun x1 x2 -> x2 x1)
+      (fun x1 -> x1)
+      ?absolute ?absolute_path ?https ~a ~service ?hostname ?port ?fragment
+      ?nl_params ?keep_nl_params contents
 
   let post_form
         ?absolute
@@ -702,7 +707,9 @@ module Make (Html : Html) = struct
         a_onsubmit_service info :: a
       else a
     in
-    post_form_ Lwt.bind Lwt.return ?absolute ?absolute_path ?https ~a ~service
-      ?hostname ?port ?fragment ?keep_get_na_params ?keep_nl_params ?nl_params
-      contents getparams
+    post_form_
+      (fun x1 x2 -> x2 x1)
+      (fun x1 -> x1)
+      ?absolute ?absolute_path ?https ~a ~service ?hostname ?port ?fragment
+      ?keep_get_na_params ?keep_nl_params ?nl_params contents getparams
 end
diff --git a/src/lib/eliom_form.eliomi b/src/lib/eliom_form.eliomi
index 9998309c5e..5d01da642b 100644
--- a/src/lib/eliom_form.eliomi
+++ b/src/lib/eliom_form.eliomi
@@ -20,7 +20,7 @@
 
 [%%client.start]
 
-val set_error_handler : (unit -> bool Lwt.t) -> unit
+val set_error_handler : (unit -> bool) -> unit
 
 [%%shared.start]
 
diff --git a/src/lib/eliom_form_sigs.shared.mli b/src/lib/eliom_form_sigs.shared.mli
index 440eb8b94b..d3937ad324 100644
--- a/src/lib/eliom_form_sigs.shared.mli
+++ b/src/lib/eliom_form_sigs.shared.mli
@@ -350,8 +350,8 @@ module type S = sig
     -> ?keep_nl_params:[`All | `Persistent | `None]
     -> ?nl_params:Eliom_parameter.nl_params_set
     -> ?xhr:bool
-    -> ('gn -> [< Html_types.form_content] elt list Lwt.t)
-    -> [> Html_types.form] elt Lwt.t
+    -> ('gn -> [< Html_types.form_content] elt list)
+    -> [> Html_types.form] elt
   (** Same as {!get_form} but taking a cooperative function for
       [<form>] content generation. *)
 
@@ -422,9 +422,9 @@ module type S = sig
     -> ?keep_get_na_params:bool
     -> ?nl_params:Eliom_parameter.nl_params_set
     -> ?xhr:bool
-    -> ('pn -> [< Html_types.form_content] elt list Lwt.t)
+    -> ('pn -> [< Html_types.form_content] elt list)
     -> 'get
-    -> [> Html_types.form] elt Lwt.t
+    -> [> Html_types.form] elt
   (** Same as {!post_form} but taking a cooperative function for
       [<form>] content generation. *)
 
diff --git a/src/lib/eliom_mkreg.server.ml b/src/lib/eliom_mkreg.server.ml
index 8da3d9d949..c3c2700bf9 100644
--- a/src/lib/eliom_mkreg.server.ml
+++ b/src/lib/eliom_mkreg.server.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -21,7 +21,6 @@ open Lwt.Syntax
 *)
 
 module S = Eliom_service
-open Lwt.Infix
 
 let suffix_redir_uri_key = Polytables.make_key ()
 
@@ -33,7 +32,7 @@ type ('options, 'page, 'result) param =
       -> ?content_type:string
       -> ?headers:Ocsigen_header.t
       -> 'page
-      -> Ocsigen_response.t Lwt.t
+      -> Ocsigen_response.t
   ; send_appl_content : S.send_appl_content
     (** Whether the service is capable to send application content when
           required. This field is usually [Eliom_service.XNever]. This
@@ -102,7 +101,7 @@ let check_process_redir sp f param =
   if redir
   then
     let ri = Eliom_request_info.get_ri_sp sp in
-    Lwt.fail
+    raise
       (* we answer to the xhr
          by asking an HTTP redirection *)
       (Eliom_common.Eliom_do_half_xhr_redirection
@@ -116,7 +115,7 @@ let check_process_redir sp f param =
      It is ok with half or full xhr redirections. *)
   (* If an action occurred before,
      it may have removed some get params form ri *)
-  else Lwt.return_unit
+  else ()
 
 let send_with_cookies
       sp
@@ -128,11 +127,11 @@ let send_with_cookies
       ?headers
       content
   =
-  let* result =
+  let result =
     pages.send ?options ?charset ?code ?content_type ?headers content
   in
-  let* () = check_process_redir sp check_after result in
-  let* tab_cookies =
+  let () = check_process_redir sp check_after result in
+  let tab_cookies =
     Eliommod_cookies.compute_cookies_to_send sp.Eliom_common.sp_sitedata
       sp.Eliom_common.sp_tab_cookie_info sp.Eliom_common.sp_user_tab_cookies
   in
@@ -151,7 +150,7 @@ let send_with_cookies
       (Eliom_request_info.get_user_cookies ())
       (Ocsigen_response.cookies result)
   in
-  Lwt.return (Ocsigen_response.update result ~cookies ~response)
+  Ocsigen_response.update result ~cookies ~response
 
 let register_aux
       pages
@@ -197,92 +196,88 @@ let register_aux
           ; s_expire
           ; s_f =
               (fun nosuffixversion sp ->
-                Lwt.with_value Eliom_common.sp_key (Some sp) (fun () ->
+                Fiber.with_binding Eliom_common.sp_key sp (fun () ->
                   let ri = Eliom_request_info.get_ri_sp sp
                   and suff = Eliom_request_info.get_suffix_sp sp in
-                  Lwt.catch
-                    (fun () ->
-                       Eliom_parameter.reconstruct_params ~sp sgpt
-                         (Some (Lwt.return (Ocsigen_request.get_params_flat ri)))
-                         (Some (Lwt.return []))
-                         nosuffixversion suff
-                       >>= fun g ->
-                       let post_params =
-                         Eliom_request_info.get_post_params_sp sp
-                       in
-                       let files = Eliom_request_info.get_files_sp sp in
-                       Eliom_parameter.reconstruct_params ~sp sppt post_params
-                         files false None
-                       >>= fun p ->
-                       (* GRGR TODO: avoid
+                  let content =
+                    try
+                      let g =
+                        Eliom_parameter.reconstruct_params ~sp sgpt
+                          (Some (Ocsigen_request.get_params_flat ri))
+                          (Some []) nosuffixversion suff
+                      in
+                      let post_params =
+                        Eliom_request_info.get_post_params_sp sp
+                      in
+                      let files = Eliom_request_info.get_files_sp sp in
+                      let p =
+                        Eliom_parameter.reconstruct_params ~sp sppt post_params
+                          files false None
+                      in
+                      (* GRGR TODO: avoid
                            Eliom_uri.make_string_uri_. But we need to
                            "downcast" the type of service to the
                            correct "get service". *)
-                       (if
-                          Eliom_request_info.get_http_method () = `GET
-                          && nosuffixversion && suffix_with_redirect
-                        then (
-                          if
-                            (* it is a suffix service in version
+                      if
+                        Eliom_request_info.get_http_method () = `GET
+                        && nosuffixversion && suffix_with_redirect
+                      then
+                        if
+                          (* it is a suffix service in version
                                without suffix. We redirect. *)
-                            not (Eliom_request_info.expecting_process_page ())
-                          then
-                            let redir_uri =
-                              Eliom_uri.make_string_uri_ ~absolute:true
-                                ~service:
-                                  (service
-                                    : ( 'a
-                                        , 'b
-                                        , _
-                                        , _
-                                        , _
-                                        , S.non_ext
-                                        , S.reg
-                                        , _
-                                        , 'c
-                                        , 'd
-                                        , 'return )
-                                        S.t
-                                    :> ( 'a
-                                         , 'b
-                                         , _
-                                         , _
-                                         , _
-                                         , _
-                                         , _
-                                         , _
-                                         , 'c
-                                         , 'd
-                                         , 'return )
-                                         S.t)
-                                g
-                            in
-                            Lwt.fail
-                              (Eliom_common.Eliom_do_redirection redir_uri)
-                          else
-                            (* It is an internal application form.
+                          not (Eliom_request_info.expecting_process_page ())
+                        then
+                          let redir_uri =
+                            Eliom_uri.make_string_uri_ ~absolute:true
+                              ~service:
+                                (service
+                                  : ( 'a
+                                      , 'b
+                                      , _
+                                      , _
+                                      , _
+                                      , S.non_ext
+                                      , S.reg
+                                      , _
+                                      , 'c
+                                      , 'd
+                                      , 'return )
+                                      S.t
+                                  :> ( 'a
+                                       , 'b
+                                       , _
+                                       , _
+                                       , _
+                                       , _
+                                       , _
+                                       , _
+                                       , 'c
+                                       , 'd
+                                       , 'return )
+                                       S.t)
+                              g
+                          in
+                          raise (Eliom_common.Eliom_do_redirection redir_uri)
+                        else
+                          (* It is an internal application form.
                                We don't redirect but we set this
                                special information for url to be displayed
                                by the browser
                                (see Eliom_request_info.rebuild_uri_without_iternal_form_info_)
-                            *)
-                            let redir_uri =
-                              Eliom_uri.make_string_uri_ ~service g
-                            in
-                            let rc =
-                              Eliom_request_info.get_request_cache_sp sp
-                            in
-                            Polytables.set ~table:rc ~key:suffix_redir_uri_key
-                              ~value:redir_uri;
-                            Lwt.return_unit)
-                        else Lwt.return_unit)
-                       >>= fun () ->
-                       check_process_redir sp check_before service >>= fun () ->
-                       page_generator g p)
-                    (function
-                      | Eliom_common.Eliom_Typing_Error l -> error_handler l
-                      | e -> Lwt.fail e)
-                  >>= fun content ->
+                          *)
+                          let redir_uri =
+                            Eliom_uri.make_string_uri_ ~service g
+                          in
+                          let rc = Eliom_request_info.get_request_cache_sp sp in
+                          Polytables.set ~table:rc ~key:suffix_redir_uri_key
+                            ~value:redir_uri
+                      else ();
+                      check_process_redir sp check_before service;
+                      page_generator g p
+                    with
+                    | Eliom_common.Eliom_Typing_Error l -> error_handler l
+                    | e -> raise e
+                  in
                   send_with_cookies sp pages ?options ?charset ?code
                     ?content_type ?headers content)) }
       in
@@ -362,30 +357,31 @@ let register_aux
             | None -> None
             | Some t -> Some (t, ref (t +. Unix.time ())))
           , fun sp ->
-              Lwt.with_value Eliom_common.sp_key (Some sp) (fun () ->
+              Fiber.with_binding Eliom_common.sp_key sp (fun () ->
                 let ri = Eliom_request_info.get_ri_sp sp in
-                Lwt.catch
-                  (fun () ->
-                     Eliom_parameter.reconstruct_params ~sp
-                       (S.get_params_type service)
-                       (Some (Lwt.return (Ocsigen_request.get_params_flat ri)))
-                       (Some (Lwt.return []))
-                       false None
-                     >>= fun g ->
-                     let post_params =
-                       Eliom_request_info.get_post_params_sp sp
-                     in
-                     let files = Eliom_request_info.get_files_sp sp in
-                     Eliom_parameter.reconstruct_params ~sp
-                       (S.post_params_type service)
-                       post_params files false None
-                     >>= fun p ->
-                     check_process_redir sp check_before service >>= fun () ->
-                     page_generator g p)
-                  (function
-                    | Eliom_common.Eliom_Typing_Error l -> error_handler l
-                    | e -> Lwt.fail e)
-                >>= fun content ->
+                let content =
+                  try
+                    let g =
+                      Eliom_parameter.reconstruct_params ~sp
+                        (S.get_params_type service)
+                        (Some (Ocsigen_request.get_params_flat ri))
+                        (Some []) false None
+                    in
+                    let post_params =
+                      Eliom_request_info.get_post_params_sp sp
+                    in
+                    let files = Eliom_request_info.get_files_sp sp in
+                    let p =
+                      Eliom_parameter.reconstruct_params ~sp
+                        (S.post_params_type service)
+                        post_params files false None
+                    in
+                    check_process_redir sp check_before service;
+                    page_generator g p
+                  with
+                  | Eliom_common.Eliom_Typing_Error l -> error_handler l
+                  | e -> raise e
+                in
                 send_with_cookies sp pages ?options ?charset ?code ?content_type
                   ?headers content) )
       in
@@ -453,10 +449,10 @@ let register_aux
           f tablereg na_name)
 
 let send pages ?options ?charset ?code ?content_type ?headers content =
-  let* result =
+  let result =
     pages.send ?options ?charset ?code ?content_type ?headers content
   in
-  Lwt.return (pages.result_of_http_result result)
+  pages.result_of_http_result result
 
 let register
       pages
diff --git a/src/lib/eliom_notif.server.ml b/src/lib/eliom_notif.server.ml
index 41e6e1cf46..2a994e68b5 100644
--- a/src/lib/eliom_notif.server.ml
+++ b/src/lib/eliom_notif.server.ml
@@ -1,4 +1,4 @@
-open Lwt
+open Eio.Std
 
 (* We use a hashtable associating resourceid to a weak set of
    (userid option, notif_ev) corresponding to each tab that want to
@@ -12,7 +12,7 @@ module type S = sig
   type server_notif
   type client_notif
 
-  val init : unit -> unit Lwt.t
+  val init : unit -> unit
   val deinit : unit -> unit
   val listen : key -> unit
   val unlisten : key -> unit
@@ -36,10 +36,10 @@ module type ARG = sig
   type server_notif
   type client_notif
 
-  val prepare : identity -> server_notif -> client_notif option Lwt.t
+  val prepare : identity -> server_notif -> client_notif option
   val equal_key : key -> key -> bool
   val equal_identity : identity -> identity -> bool
-  val get_identity : unit -> identity Lwt.t
+  val get_identity : unit -> identity
   val max_resource : int
   val max_identity_per_resource : int
 end
@@ -102,16 +102,20 @@ module Make (A : ARG) :
       if not (Weak_tbl.mem wt v) then Weak_tbl.add wt v
 
     let iter =
-      let iter (f : Weak_tbl.data -> unit Lwt.t) wt : unit =
-        Weak_tbl.iter (fun data -> Lwt.async (fun () -> f data)) wt
+      let iter (f : Weak_tbl.data -> unit) wt : unit =
+        Weak_tbl.iter
+          (fun data ->
+             Fiber.fork
+               ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+               (fun () -> f data))
+          wt
       in
       fun f key ->
         try
           let wt = Notif_hashtbl.find tbl key in
           let g data =
             match data with
-            | None ->
-                Weak_tbl.remove wt data; remove_if_empty wt key; Lwt.return_unit
+            | None -> Weak_tbl.remove wt data; remove_if_empty wt key
             | Some v -> f v
           in
           iter g wt
@@ -149,9 +153,10 @@ module Make (A : ARG) :
     Eliom_reference.Volatile.set identity_r (Some (identity, notif_e))
 
   let set_current_identity () =
-    A.get_identity () >>= fun identity -> set_identity identity; Lwt.return_unit
+    let identity = A.get_identity () in
+    set_identity identity
 
-  let init : unit -> unit Lwt.t = fun () -> set_current_identity ()
+  let init : unit -> unit = fun () -> set_current_identity ()
   let deinit () = Eliom_reference.Volatile.set identity_r None
 
   let listen (key : A.key) =
@@ -180,14 +185,10 @@ module Make (A : ARG) :
         | None -> false
       in
       if blocked
-      then Lwt.return_unit
+      then ()
       else
-        A.prepare identity content >>= fun content ->
-        match content with
-        | Some content ->
-            send_e (key, content);
-            Lwt.return_unit
-        | None -> Lwt.return_unit
+        let content = A.prepare identity content in
+        match content with Some content -> send_e (key, content) | None -> ()
     in
     (* on all tabs listening on this resource *)
     I.iter f key
@@ -208,7 +209,7 @@ module type ARG_SIMPLE = sig
   type key
   type notification
 
-  val get_identity : unit -> identity Lwt.t
+  val get_identity : unit -> identity
 end
 
 module Make_Simple (A : ARG_SIMPLE) = Make (struct
@@ -217,7 +218,7 @@ module Make_Simple (A : ARG_SIMPLE) = Make (struct
     type server_notif = A.notification
     type client_notif = A.notification
 
-    let prepare _ n = Lwt.return_some n
+    let prepare _ n = Some n
     let equal_key = ( = )
     let equal_identity = ( = )
     let get_identity = A.get_identity
diff --git a/src/lib/eliom_notif.server.mli b/src/lib/eliom_notif.server.mli
index cb408d9aac..f3e07eaf13 100644
--- a/src/lib/eliom_notif.server.mli
+++ b/src/lib/eliom_notif.server.mli
@@ -48,7 +48,7 @@ module type S = sig
   type client_notif
   (** client notification type; Can be different from [server_notif]. *)
 
-  val init : unit -> unit Lwt.t
+  val init : unit -> unit
   (** Initialise the notification module for the current client. This function
       needs to be called before using most other functions of this module. It
       isn't called implicitly during module instantiation because it relies on
@@ -126,7 +126,7 @@ module type ARG = sig
   type client_notif
   (** see [S.client_notif] *)
 
-  val prepare : identity -> server_notif -> client_notif option Lwt.t
+  val prepare : identity -> server_notif -> client_notif option
   (** [prepare f] transforms server notifications into client
       notifications. It provides the [identity] as a parameter which identifies
       the client. You can suppress notifications for a specific client (for
@@ -140,7 +140,7 @@ module type ARG = sig
   (** [equal_identity] is the same as [equal_key] but for values of type
       [identity].*)
 
-  val get_identity : unit -> identity Lwt.t
+  val get_identity : unit -> identity
   (** [get_identity] is a function returning a value of type [identity]
       corresponding to a client. *)
 
@@ -187,7 +187,7 @@ module type ARG_SIMPLE = sig
 
   type notification
 
-  val get_identity : unit -> identity Lwt.t
+  val get_identity : unit -> identity
   (** see {!ARG.equal_key} *)
 end
 
diff --git a/src/lib/eliom_parameter_base.shared.ml b/src/lib/eliom_parameter_base.shared.ml
index 7d655fc0a7..17f0340503 100644
--- a/src/lib/eliom_parameter_base.shared.ml
+++ b/src/lib/eliom_parameter_base.shared.ml
@@ -1,5 +1,3 @@
-open Lwt.Syntax
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2007 Vincent Balat
@@ -864,22 +862,16 @@ let reconstruct_params
       params
       files
       nosuffixversion
-      urlsuffix : a Lwt.t
+      urlsuffix : a
   =
   match typ, params, files with
   (* FIXME *)
   | TRaw_post_data, None, None -> Eliom_request_info.raw_post_data sp
   | typ, None, None -> (
-    try Lwt.return (reconstruct_params_ typ [] [] nosuffixversion urlsuffix)
-    with e -> Lwt.fail e)
+    try reconstruct_params_ typ [] [] nosuffixversion urlsuffix
+    with e -> raise e)
   | typ, _, _ -> (
-      let* params =
-        match params with Some params -> params | None -> Lwt.return_nil
-      in
-      let* files =
-        match files with Some files -> files | None -> Lwt.return_nil
-      in
-      try
-        Lwt.return
-          (reconstruct_params_ typ params files nosuffixversion urlsuffix)
-      with e -> Lwt.fail e)
+      let params = match params with Some params -> params | None -> [] in
+      let files = match files with Some files -> files | None -> [] in
+      try reconstruct_params_ typ params files nosuffixversion urlsuffix
+      with e -> raise e)
diff --git a/src/lib/eliom_parameter_sigs.shared.mli b/src/lib/eliom_parameter_sigs.shared.mli
index a87209ee7c..1373847192 100644
--- a/src/lib/eliom_parameter_sigs.shared.mli
+++ b/src/lib/eliom_parameter_sigs.shared.mli
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2007-2016 Vincent Balat
@@ -377,11 +379,11 @@ module type S = sig
   val reconstruct_params :
      sp:Eliom_common.server_params
     -> ('a, [< `WithSuffix | `WithoutSuffix], 'c) params_type
-    -> (string * string) list Lwt.t option
-    -> (string * Eliom_lib.file_info) list Lwt.t option
+    -> (string * string) list Promise.t option
+    -> (string * Eliom_lib.file_info) list Promise.t option
     -> bool
     -> Eliom_lib.Url.path option
-    -> 'a Lwt.t
+    -> 'a
 
   val make_params_names : ('a, 'b, 'c) params_type -> bool * 'c
   (* bool = contains a suffix *)
diff --git a/src/lib/eliom_react.client.ml b/src/lib/eliom_react.client.ml
index ba48819212..d3ce718438 100644
--- a/src/lib/eliom_react.client.ml
+++ b/src/lib/eliom_react.client.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -23,7 +23,6 @@ open Lwt.Syntax
 
 (* Module for event unwrapping *)
 open Eio_react
-open Lwt.Infix
 
 let section = Logs.Src.create "eliom:comet"
 
@@ -41,8 +40,7 @@ module Down = struct
           "Exception during comet with react. Customize this with Eliom_react.set_handle_react_exn_function. "
         in
         Logs.msg ~src:section Logs.Debug (fun fmt ->
-          fmt "%s%a" s pp_exn_option exn);
-        Lwt.return_unit)
+          fmt "%s%a" s pp_exn_option exn))
     in
     (fun ~exn () -> !r ~exn ()), fun f -> r := f
 
@@ -51,14 +49,16 @@ module Down = struct
        in Eliom_comet. For example Channel_full. *)
     (* We transform the stream into a stream with exception: *)
     let stream = Eliom_stream.wrap_exn channel in
-    Lwt.async (fun () ->
-      Eliom_stream.iter_s
-        (function
-          | Error exn ->
-              let* () = handle_react_exn ~exn () in
-              Lwt.fail exn
-          | Ok () -> Lwt.return_unit)
-        stream);
+    Fiber.fork
+      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+      (fun () ->
+         Eliom_stream.iter_s
+           (function
+             | Error exn ->
+                 let () = handle_react_exn ~exn () in
+                 raise exn
+             | Ok () -> ())
+           stream);
     E.of_stream channel
 
   let () =
@@ -67,10 +67,11 @@ module Down = struct
 end
 
 module Up = struct
-  type 'a t = 'a -> unit Lwt.t
+  type 'a t = 'a -> unit
 
   let internal_unwrap (service, _unwrapper) x =
-    Eliom_client.call_service ~service () x >|= fun _ -> ()
+    let _ = Eliom_client.call_service ~service () x in
+    ()
 
   let () =
     Eliom_unwrap.register_unwrapper Eliom_common.react_up_unwrap_id
diff --git a/src/lib/eliom_react.client.mli b/src/lib/eliom_react.client.mli
index 9fef00ad03..29dfc9d593 100644
--- a/src/lib/eliom_react.client.mli
+++ b/src/lib/eliom_react.client.mli
@@ -25,7 +25,7 @@
 module Down : sig
   type 'a t = 'a React.E.t
 
-  val set_handle_react_exn_function : (?exn:exn -> unit -> unit Lwt.t) -> unit
+  val set_handle_react_exn_function : (?exn:exn -> unit -> unit) -> unit
   (** Makes possible to customize the function called when comet fails
       in Eliom_react, for example because a channel is full or closed.
       It is called for each exception.
@@ -33,7 +33,7 @@ module Down : sig
 end
 
 module Up : sig
-  type 'a t = 'a -> unit Lwt.t
+  type 'a t = 'a -> unit
 end
 
 module S : sig
diff --git a/src/lib/eliom_react.server.ml b/src/lib/eliom_react.server.ml
index 025c1ebb05..aaad25674d 100644
--- a/src/lib/eliom_react.server.ml
+++ b/src/lib/eliom_react.server.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -40,10 +40,10 @@ module Down = struct
 
   let wrap_stateful {throttling = t; scope; react = e; name; size} =
     let ee =
-      Lwt.with_value Eliom_common.sp_key None @@ fun () ->
-      match t with
-      | None -> e
-      | Some t -> E.limit (fun () -> Lwt_unix.sleep t) e
+      Fiber.without_binding Eliom_common.sp_key (fun () ->
+        match t with
+        | None -> e
+        | Some t -> E.limit (fun () -> Eio_unix.sleep t) e)
     in
     let channel =
       Eliom_comet.Channel.create_from_events ?scope ?name ?size ee
@@ -66,7 +66,7 @@ module Down = struct
     let ee =
       match throttling with
       | None -> e
-      | Some t -> E.limit (fun () -> Lwt_unix.sleep t) e
+      | Some t -> E.limit (fun () -> Eio_unix.sleep t) e
     in
     Stateless
       (Eliom_comet.Channel.create_from_events ~scope:`Site ?name ?size ee)
@@ -125,7 +125,7 @@ module Up = struct
         ~path:Eliom_service.No_path ()
     in
     Eliom_registration.Action.register ~scope ~options:`NoReload
-      ~service:e_writer (fun () value -> push value; Lwt.return_unit);
+      ~service:e_writer (fun () value -> push value);
     {event = e; service = e_writer; wrapper = up_event_wrapper ()}
 end
 
@@ -155,14 +155,14 @@ module S = struct
       ; (* to avoid signal GC *)
         mutable value : 'a
       ; mutable read : bool
-      ; condition : unit Lwt_condition.t }
+      ; condition : Eio.Condition.t }
 
     let make_store signal =
       let rec store =
         { s = s'
         ; value = S.value signal
         ; read = false
-        ; condition = Lwt_condition.create () }
+        ; condition = Eio.Condition.create () }
       and s' =
         lazy
           (S.map
@@ -180,19 +180,23 @@ module S = struct
       let rec aux () =
         if store.read
         then
-          let* () = Lwt_condition.wait store.condition in
+          let () =
+            Eio.Condition.await
+              (* TODO: ciao-lwt: A mutex must be passed *) store.condition
+              __mutex__
+          in
           aux ()
         else (
           store.read <- true;
-          Lwt.return_some store.value)
+          Some store.value)
       in
-      fun () -> Lwt.with_value Eliom_common.sp_key None @@ aux
+      fun () -> Fiber.without_binding Eliom_common.sp_key aux
 
     let wrap_stateful {throttling = t; signal = s; name; _} =
       let s : 'a S.t =
         match t with
         | None -> s
-        | Some t -> S.limit (fun () -> Lwt_unix.sleep t) s
+        | Some t -> S.limit (fun () -> Eio_unix.sleep t) s
       in
       let store = make_store s in
       let stream = Eliom_stream.from (read_store store) in
@@ -221,7 +225,7 @@ module S = struct
       let s =
         match throttling with
         | None -> s
-        | Some t -> S.limit (fun () -> Lwt_unix.sleep t) s
+        | Some t -> S.limit (fun () -> Eio_unix.sleep t) s
       in
       let e = S.changes s in
       let stream = E.to_stream e in
diff --git a/src/lib/eliom_reference.server.ml b/src/lib/eliom_reference.server.ml
index ba7855b9d9..3443629a31 100644
--- a/src/lib/eliom_reference.server.ml
+++ b/src/lib/eliom_reference.server.ml
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2010 Vincent Balat
@@ -21,7 +23,6 @@
 (** {2 Eliom references} *)
 
 open Eliom_state
-open Lwt.Infix
 
 module Ocsipersist = struct
   include Eliom_common.Ocsipersist.Store
@@ -35,9 +36,9 @@ type 'a eref_kind =
   | Sit of 'a Polytables.key
   | Ref of 'a lazy_t ref (* Ocaml reference *)
   | Vol of 'a volatile_table Lazy.t (* Vol. table (group, session, process) *)
-  | Ocsiper of 'a option Ocsipersist.t Lwt.t (* Global persist. table *)
-  | Ocsiper_sit of 'a Ocsipersist.table Lwt.t (* Persist. table for site *)
-  | Per of 'a persistent_table Lwt.t
+  | Ocsiper of 'a option Ocsipersist.t Promise.t (* Global persist. table *)
+  | Ocsiper_sit of 'a Ocsipersist.table Promise.t (* Persist. table for site *)
+  | Per of 'a persistent_table Promise.t
 (* Persist. table for group session or process *)
 
 type volatile = [`Volatile]
@@ -174,8 +175,8 @@ let eref_from_fun_ ~ext ~scope ?secure ?persistent f : 'a eref =
         ( f
         , ext
         , Ocsiper
-            ( pers_ref_store >>= fun store ->
-              Ocsipersist.make_persistent ~store ~name ~default:None ) ))
+            (let store = pers_ref_store in
+             Ocsipersist.make_persistent ~store ~name ~default:None) ))
   | `Site -> (
     match persistent with
     | None -> (Volatile.eref_from_fun_ ~ext ~scope ?secure f :> _ eref)
@@ -201,86 +202,99 @@ let get_site_id () =
 let get ((f, _, table) as eref) =
   match table with
   | Per t -> (
-      t >>= fun t ->
-      get_persistent_data ~table:t () >>= function
-      | Data d -> Lwt.return d
+      let t = t in
+      match get_persistent_data ~table:t () with
+      | Data d -> d
       | _ ->
           let value = f () in
-          set_persistent_data ~table:t value >>= fun () -> Lwt.return value)
+          set_persistent_data ~table:t value;
+          value)
   | Ocsiper r -> (
-      r >>= fun r ->
-      Ocsipersist.get r >>= function
-      | Some v -> Lwt.return v
+      let r = r in
+      match Ocsipersist.get r with
+      | Some v -> v
       | None ->
           let value = f () in
-          Ocsipersist.set r (Some value) >>= fun () -> Lwt.return value)
-  | Ocsiper_sit t ->
-      t >>= fun t ->
+          Ocsipersist.set r (Some value);
+          value)
+  | Ocsiper_sit t -> (
+      let t = t in
       let site_id = get_site_id () in
-      Lwt.catch
-        (fun () -> Ocsipersist.find t site_id)
-        (function
-          | Not_found ->
-              let value = f () in
-              Ocsipersist.add t site_id value >>= fun () -> Lwt.return value
-          | exc -> Lwt.reraise exc)
-  | _ -> Lwt.return (Volatile.get eref)
+      try Ocsipersist.find t site_id
+      with Not_found ->
+        let value = f () in
+        Ocsipersist.add t site_id value;
+        value)
+  | _ -> Volatile.get eref
 
 let set ((_, _, table) as eref) value =
   match table with
-  | Per t -> t >>= fun t -> set_persistent_data ~table:t value
-  | Ocsiper r -> r >>= fun r -> Ocsipersist.set r (Some value)
-  | Ocsiper_sit t -> t >>= fun t -> Ocsipersist.add t (get_site_id ()) value
-  | _ -> Lwt.return (Volatile.set eref value)
+  | Per t ->
+      let t = t in
+      set_persistent_data ~table:t value
+  | Ocsiper r ->
+      let r = r in
+      Ocsipersist.set r (Some value)
+  | Ocsiper_sit t ->
+      let t = t in
+      Ocsipersist.add t (get_site_id ()) value
+  | _ -> Volatile.set eref value
 
-let modify eref f = get eref >>= fun x -> set eref (f x)
+let modify eref f =
+  let x = get eref in
+  set eref (f x)
 
 let unset ((_, _, table) as eref) =
   match table with
-  | Per t -> t >>= fun t -> remove_persistent_data ~table:t ()
-  | Ocsiper r -> r >>= fun r -> Ocsipersist.set r None
-  | Ocsiper_sit t -> t >>= fun t -> Ocsipersist.remove t (get_site_id ())
-  | _ -> Lwt.return (Volatile.unset eref)
+  | Per t ->
+      let t = t in
+      remove_persistent_data ~table:t ()
+  | Ocsiper r ->
+      let r = r in
+      Ocsipersist.set r None
+  | Ocsiper_sit t ->
+      let t = t in
+      Ocsipersist.remove t (get_site_id ())
+  | _ -> Volatile.unset eref
 
 module Ext = struct
   let get state ((f, ext, table) as r) =
     let state = Eliom_state.Ext.untype_state state in
     match table with
-    | Vol _ -> Lwt.return (Volatile.Ext.get state r)
-    | Per t ->
-        t >>= fun t ->
-        Lwt.catch
-          (fun () ->
-             Eliom_state.Ext.Low_level.get_persistent_data ~state ~table:t)
-          (function
-            | Not_found ->
-                if ext (* We can run the function from another state *)
-                then
-                  let value = f () in
-                  Eliom_state.Ext.Low_level.set_persistent_data ~state ~table:t
-                    value
-                  >>= fun () -> Lwt.return value
-                else Lwt.fail Eref_not_initialized
-            | e -> Lwt.fail e)
+    | Vol _ -> Volatile.Ext.get state r
+    | Per t -> (
+        let t = t in
+        try Eliom_state.Ext.Low_level.get_persistent_data ~state ~table:t with
+        | Not_found ->
+            if ext (* We can run the function from another state *)
+            then (
+              let value = f () in
+              Eliom_state.Ext.Low_level.set_persistent_data ~state ~table:t
+                value;
+              value)
+            else raise Eref_not_initialized
+        | e -> raise e)
     | _ -> failwith "wrong eref for this function"
 
   let set state ((_, _, table) as r) value =
     let state = Eliom_state.Ext.untype_state state in
     match table with
-    | Vol _ -> Lwt.return (Volatile.Ext.set state r value)
+    | Vol _ -> Volatile.Ext.set state r value
     | Per t ->
-        t >>= fun t ->
+        let t = t in
         Eliom_state.Ext.Low_level.set_persistent_data ~state ~table:t value
-    | _ -> Lwt.fail (Failure "wrong eref for this function")
+    | _ -> raise (Failure "wrong eref for this function")
 
-  let modify state eref f = get state eref >>= fun v -> set state eref (f v)
+  let modify state eref f =
+    let v = get state eref in
+    set state eref (f v)
 
   let unset state ((_, _, table) as r) =
     let state = Eliom_state.Ext.untype_state state in
     match table with
-    | Vol _ -> Lwt.return (Volatile.Ext.unset state r)
+    | Vol _ -> Volatile.Ext.unset state r
     | Per t ->
-        t >>= fun t ->
+        let t = t in
         Eliom_state.Ext.Low_level.remove_persistent_data ~state ~table:t
     | _ -> failwith "wrong eref for this function"
 end
diff --git a/src/lib/eliom_reference.server.mli b/src/lib/eliom_reference.server.mli
index cfa2db91dc..f3972e40d8 100644
--- a/src/lib/eliom_reference.server.mli
+++ b/src/lib/eliom_reference.server.mli
@@ -97,7 +97,7 @@ val eref_from_fun :
     if the value has not been set explicitly before (by {!Eliom_reference.set}).
   *)
 
-val get : 'a eref -> 'a Lwt.t
+val get : 'a eref -> 'a
 (** The function [get eref] returns the current value of the Eliom
     reference [eref].
 
@@ -111,7 +111,7 @@ val get : 'a eref -> 'a Lwt.t
 (* That function introduces a Lwt cooperation point only for persistent
    references. *)
 
-val set : 'a eref -> 'a -> unit Lwt.t
+val set : 'a eref -> 'a -> unit
 (** The function [set eref v] set [v] as current value of the Eliom
     reference [eref].
 
@@ -125,7 +125,7 @@ val set : 'a eref -> 'a -> unit Lwt.t
 (* That function introduces a Lwt cooperation point only for persistent
    references. *)
 
-val modify : 'a eref -> ('a -> 'a) -> unit Lwt.t
+val modify : 'a eref -> ('a -> 'a) -> unit
 (** The function [modify eref f] modifies the content of the Eliom
     reference [eref] by applying the function [f] on it.
 
@@ -139,7 +139,7 @@ val modify : 'a eref -> ('a -> 'a) -> unit Lwt.t
 (* That function introduces a Lwt cooperation point only for persistent
    references. *)
 
-val unset : 'a eref -> unit Lwt.t
+val unset : 'a eref -> unit
 (** The function [unset eref] reset the content of the Eliom reference
     [eref] to its initial value.
 
@@ -231,7 +231,7 @@ module Ext : sig
        , [< `Data | `Pers] )
        Eliom_state.Ext.state
     -> 'a eref
-    -> 'a Lwt.t
+    -> 'a
   (** get the value of a reference from outside the state.
       If the value has not been set yet for this state,
       it will raise exception [Eref_not_initialized].
@@ -243,7 +243,7 @@ module Ext : sig
        Eliom_state.Ext.state
     -> 'a eref
     -> 'a
-    -> unit Lwt.t
+    -> unit
 
   val modify :
      ( [< `Session_group | `Session | `Client_process]
@@ -251,7 +251,7 @@ module Ext : sig
        Eliom_state.Ext.state
     -> 'a eref
     -> ('a -> 'a)
-    -> unit Lwt.t
+    -> unit
   (** Warning: the function will be executed with the current context *)
 
   val unset :
@@ -259,5 +259,5 @@ module Ext : sig
        , [< `Data | `Pers] )
        Eliom_state.Ext.state
     -> 'a eref
-    -> unit Lwt.t
+    -> unit
 end
diff --git a/src/lib/eliom_registration.client.ml b/src/lib/eliom_registration.client.ml
index 8f08609602..2eab3ab059 100644
--- a/src/lib/eliom_registration.client.ml
+++ b/src/lib/eliom_registration.client.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -51,27 +51,36 @@ module type PARAM = sig
   type result
 
   val reset_reload_fun : bool
-  val send : ?options:options -> page -> [`Browser] kind Lwt.t
+  val send : ?options:options -> page -> [`Browser] kind
 end
 
 let typed_apply ~service f gp pp l l' suffix =
-  Lwt.catch
-    (fun () ->
-       let* g =
-         let l = Some (Lwt.return l) in
-         Eliom_parameter.reconstruct_params ~sp:() gp l None true suffix
-       and* p =
-         let l' = Some (Lwt.return l') in
-         Eliom_parameter.reconstruct_params ~sp:() pp l' None true suffix
-       in
-       (match Eliom_service.reload_fun service with
-       | Some _ -> Eliom_client.set_reload_function (fun () () -> f g p)
-       | None -> ());
-       f g p)
-    (function
-      | Eliom_common.Eliom_Wrong_parameter ->
-          Lwt.fail Eliom_common.Eliom_Wrong_parameter
-      | exc -> Lwt.reraise exc)
+  try
+    let p, g =
+      Fiber.pair
+        (fun () ->
+           let
+               (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+                 l'
+             =
+             Some l'
+           in
+           Eliom_parameter.reconstruct_params ~sp:() pp l' None true suffix)
+        (fun () ->
+           let
+               (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+                 l
+             =
+             Some l
+           in
+           Eliom_parameter.reconstruct_params ~sp:() gp l None true suffix)
+    in
+    (match Eliom_service.reload_fun service with
+    | Some _ -> Eliom_client.set_reload_function (fun () () -> f g p)
+    | None -> ());
+    f g p
+  with Eliom_common.Eliom_Wrong_parameter ->
+    raise Eliom_common.Eliom_Wrong_parameter
 
 let wrap service att f _ suffix =
   let gp = Eliom_service.get_params_type service
@@ -90,8 +99,8 @@ let wrap service att f _ suffix =
       and l' = List.remove_assoc "__eliom__" l' in
       if eliom_name = s
       then typed_apply ~service f gp pp l l' suffix
-      else Lwt.fail Eliom_common.Eliom_Wrong_parameter
-    with Not_found -> Lwt.fail Eliom_common.Eliom_Wrong_parameter)
+      else raise Eliom_common.Eliom_Wrong_parameter
+    with Not_found -> raise Eliom_common.Eliom_Wrong_parameter)
   | _ -> typed_apply ~service f gp pp l l' suffix
 
 let wrap_na
@@ -172,7 +181,7 @@ module Make (P : PARAM) = struct
         (f : g -> p -> _)
     =
     let f g p =
-      let* page = f g p in
+      let page = f g p in
       P.send ?options page
     in
     register ~service f;
@@ -189,7 +198,7 @@ module Html = Make (struct
     let reset_reload_fun = false
 
     let send ?options:_ page =
-      Lwt.return (Eliom_service.Dom (Eliom_content.Html.To_dom.of_element page))
+      Eliom_service.Dom (Eliom_content.Html.To_dom.of_element page)
   end)
 
 module Action = Make (struct
@@ -203,9 +212,8 @@ module Action = Make (struct
     let send ?options _page =
       match options with
       | Some `Reload | None ->
-          Lwt.return
-            Eliom_service.(Reload_action {hidden = false; https = false})
-      | _ -> Lwt.return Eliom_service.No_contents
+          Eliom_service.(Reload_action {hidden = false; https = false})
+      | _ -> Eliom_service.No_contents
   end)
 
 module Unit = Make (struct
@@ -215,7 +223,7 @@ module Unit = Make (struct
     type result = browser_content kind
 
     let reset_reload_fun = true
-    let send ?options:_ _page = Lwt.return Eliom_service.No_contents
+    let send ?options:_ _page = Eliom_service.No_contents
   end)
 
 type appl_service_options = {do_not_launch : bool}
@@ -234,8 +242,7 @@ module App (P : Eliom_registration_sigs.APP_PARAM) = struct
       let reset_reload_fun = false
 
       let send ?options:_ page =
-        Lwt.return
-          (Eliom_service.Dom (Eliom_content.Html.To_dom.of_element page))
+        Eliom_service.Dom (Eliom_content.Html.To_dom.of_element page)
     end)
 end
 
@@ -279,7 +286,7 @@ module Redirection = struct
         ?headers:_
         (Redirection service)
     =
-    Lwt.return (Eliom_service.Redirect service)
+    Eliom_service.Redirect service
 
   let register
         ?app
@@ -296,7 +303,7 @@ module Redirection = struct
         (f : g -> p -> _)
     =
     let f g p =
-      let* page = f g p in
+      let page = f g p in
       send ?options page
     in
     register ~service f;
@@ -309,8 +316,7 @@ module Any = struct
   type 'a result = 'a kind
   type options = unit
 
-  let send ?options:_ ?charset:_ ?code:_ ?content_type:_ ?headers:_ page =
-    Lwt.return page
+  let send ?options:_ ?charset:_ ?code:_ ?content_type:_ ?headers:_ page = page
 
   let register
         ?app
@@ -326,7 +332,7 @@ module Any = struct
         f
     =
     let f g p =
-      let* page = f g p in
+      let page = f g p in
       send page
     in
     register ~service f;
diff --git a/src/lib/eliom_registration.client.mli b/src/lib/eliom_registration.client.mli
index 2648d4de93..61405520b6 100644
--- a/src/lib/eliom_registration.client.mli
+++ b/src/lib/eliom_registration.client.mli
@@ -106,9 +106,9 @@ module Any :
    and type 'a result = 'a kind
 
 val appl_self_redirect :
-   ('page -> [< 'a application_content | browser_content] kind Lwt.t)
+   ('page -> [< 'a application_content | browser_content] kind)
   -> 'page
-  -> 'appl application_content kind Lwt.t
+  -> 'appl application_content kind
 (** For compatibility with server-side [appl_self_redirect] *)
 
 (**/**)
diff --git a/src/lib/eliom_registration.server.ml b/src/lib/eliom_registration.server.ml
index b281c0c583..547ac1488a 100644
--- a/src/lib/eliom_registration.server.ml
+++ b/src/lib/eliom_registration.server.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -20,8 +20,6 @@ open Lwt.Syntax
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *)
 
-open Lwt.Infix
-
 let headers_with_content_type ?charset ?content_type headers =
   match content_type with
   | Some content_type ->
@@ -60,20 +58,16 @@ let result_of_content ?charset ?content_type ?headers ?status body =
       "cache-control" "no-cache"
   in
   let response = Cohttp.Response.make ?status ~headers () in
-  Lwt.return (Ocsigen_response.make ~body response)
+  Ocsigen_response.make ~body response
 
 module Result_types : sig
   type 'a kind
 
   val cast_result : Ocsigen_response.t -> 'a kind
   val cast_kind : 'a kind -> Ocsigen_response.t
-  val cast_kind_lwt : 'a kind Lwt.t -> Ocsigen_response.t Lwt.t
-  val cast_result_lwt : Ocsigen_response.t Lwt.t -> 'a kind Lwt.t
-
-  val cast_function_http :
-     ('c -> 'a kind Lwt.t)
-    -> 'c
-    -> Ocsigen_response.t Lwt.t
+  val cast_kind_lwt : 'a kind Promise.t -> Ocsigen_response.t
+  val cast_result_lwt : Ocsigen_response.t Promise.t -> 'a kind
+  val cast_function_http : ('c -> 'a kind) -> 'c -> Ocsigen_response.t
 end = struct
   type 'a kind = Ocsigen_response.t
 
@@ -149,7 +143,7 @@ module Flow5_base = struct
 
   let body l =
     Ocsigen_response.Body.make Cohttp.Transfer.Unknown (fun write ->
-      Lwt_list.iter_s (fun x -> write (Format.asprintf "%a" out x)) l)
+      List.iter (fun x -> write (Format.asprintf "%a" out x)) l)
 
   let send ?options:_ ?charset ?code ?content_type ?headers c =
     let status = Eliom_lib.Option.map Cohttp.Code.status_of_code code
@@ -283,16 +277,16 @@ module Action_base = struct
         | ( Eliom_common.RNa_no
           , (Eliom_common.RAtt_no, Eliom_common.RAtt_no)
           , `GET ) ->
-            Lwt.return (Ocsigen_response.make (Cohttp.Response.make ()))
+            Ocsigen_response.make (Cohttp.Response.make ())
         | _ ->
             let all_cookie_info = sp.Eliom_common.sp_cookie_info in
-            let* ric =
+            let ric =
               Eliommod_cookies.compute_new_ri_cookies (Unix.time ())
                 (Ocsigen_request.sub_path ri.request_info)
                 (Ocsigen_request.cookies ri.request_info)
                 all_cookie_info user_cookies
             in
-            let* all_new_cookies =
+            let all_new_cookies =
               Eliommod_cookies.compute_cookies_to_send sitedata all_cookie_info
                 user_cookies
             in
@@ -331,7 +325,7 @@ module Action_base = struct
             (*VVV Also put all_cookie_info in this, to avoid
           update_cookie_table and get_cookie_info (?) *)
             let ri = update_request ri.request_info si ric in
-            let* () =
+            let () =
               Eliommod_pagegen.update_cookie_table sitedata all_cookie_info
             in
             send_directly ri
@@ -387,7 +381,7 @@ module Any_base = struct
         (Cohttp.Response.headers cohttp_response)
     in
     let response = {cohttp_response with Cohttp.Response.headers} in
-    Lwt.return (Ocsigen_response.update ~response result)
+    Ocsigen_response.update ~response result
 end
 
 module Any = struct
@@ -413,10 +407,10 @@ let appl_self_redirect send page =
       in
       Cohttp.Response.make ~headers ()
     in
-    Ocsigen_response.make response |> Result_types.cast_result |> Lwt.return
+    Ocsigen_response.make response |> Result_types.cast_result
   else
-    let* r = (Result_types.cast_function_http send) page in
-    Lwt.return (Result_types.cast_result r)
+    let r = (Result_types.cast_function_http send) page in
+    Result_types.cast_result r
 
 (* File is a module allowing to register services that send files *)
 module File_base = struct
@@ -441,7 +435,7 @@ module File_base = struct
         raise Eliom_common.Eliom_404
     with
     | Ocsigen_local_files.RFile fname ->
-        let* res =
+        let res =
           let headers =
             Ocsigen_header.of_option headers
             |> add_cache_header options
@@ -449,7 +443,7 @@ module File_base = struct
           in
           Cohttp_lwt_unix.Server.respond_file ~headers ~fname ()
         in
-        Lwt.return (Ocsigen_response.of_cohttp res)
+        Ocsigen_response.of_cohttp res
     | Ocsigen_local_files.RDir _ ->
         (* FIXME COHTTP TRANSITION: implement directories *)
         raise Ocsigen_local_files.Failed_404
@@ -508,7 +502,7 @@ module Customize
     (T : sig
        type page
 
-       val translate : page -> R.page Lwt.t
+       val translate : page -> R.page
      end) =
 struct
   type page = T.page
@@ -518,12 +512,12 @@ struct
 
   let make_eh = function
     | None -> None
-    | Some eh -> Some (fun l -> eh l >>= T.translate)
+    | Some eh -> Some (fun l -> T.translate (eh l))
 
-  let make_service_handler f g p = f g p >>= T.translate
+  let make_service_handler f g p = T.translate (f g p)
 
   let send ?options ?charset ?code ?content_type ?headers content =
-    T.translate content >>= fun c ->
+    let c = T.translate content in
     R.send ?options ?charset ?code ?content_type ?headers c
 
   let register
@@ -537,7 +531,7 @@ struct
         ?secure_session
         ~service
         ?error_handler
-        (f : 'get -> 'post -> 'return Lwt.t)
+        (f : 'get -> 'post -> 'return)
     =
     R.register ?app ?scope ?options ?charset ?code ?content_type ?headers
       ?secure_session ~service ?error_handler:(make_eh error_handler)
@@ -658,52 +652,51 @@ module Ocaml = struct
     in
     (*     debug_client_value_data (debug "%s") client_value_data; *)
     let r = {Eliom_runtime.ecs_request_data; ecs_data = data} in
-    Lwt.return (Eliom_types.encode_eliom_data r)
+    Eliom_types.encode_eliom_data r
 
   let make_eh = function
     | None -> None
-    | Some eh -> Some (fun l -> eh l >>= prepare_data)
+    | Some eh -> Some (fun l -> prepare_data (eh l))
 
   let string_regexp = Str.regexp "\"\\([^\\\"]\\|\\\\.\\)*\""
 
   let make_service_handler ~name f g p =
-    let* data =
-      Lwt.catch
-        (fun () ->
-           let* res = f g p in
-           Lwt.return (`Success res))
-        (fun exn ->
-           let code = Printf.sprintf "%06x" (Random.int 0x1000000) in
-           let argument =
-             let sp = Eliom_common.get_sp () in
-             let si = Eliom_request_info.get_si sp in
-             let post_params =
-               match si.Eliom_common.si_all_post_params with
-               | None -> []
-               | Some l -> l
-             in
-             try Printf.sprintf " (%s)" (List.assoc "argument" post_params)
-             with Not_found -> ""
-           in
-           (match name with
-           | Some name ->
-               Logs.err (fun fmt ->
-                 fmt
-                   ("Uncaught exception in service %s [%s]%s" ^^ "@\n%s")
-                   name code
-                   (Str.global_replace string_regexp "\"xxx\"" argument)
-                   (Printexc.to_string exn))
-           | None ->
-               Logs.err (fun fmt ->
-                 fmt
-                   ("Uncaught exception [%s]%s" ^^ "@\n%s")
-                   code argument (Printexc.to_string exn)));
-           Lwt.return (`Failure code))
+    let data =
+      try
+        let res = f g p in
+        `Success res
+      with exn ->
+        let code = Printf.sprintf "%06x" (Random.int 0x1000000) in
+        let argument =
+          let sp = Eliom_common.get_sp () in
+          let si = Eliom_request_info.get_si sp in
+          let post_params =
+            match si.Eliom_common.si_all_post_params with
+            | None -> []
+            | Some l -> l
+          in
+          try Printf.sprintf " (%s)" (List.assoc "argument" post_params)
+          with Not_found -> ""
+        in
+        (match name with
+        | Some name ->
+            Logs.err (fun fmt ->
+              fmt
+                ("Uncaught exception in service %s [%s]%s" ^^ "@\n%s")
+                name code
+                (Str.global_replace string_regexp "\"xxx\"" argument)
+                (Printexc.to_string exn))
+        | None ->
+            Logs.err (fun fmt ->
+              fmt
+                ("Uncaught exception [%s]%s" ^^ "@\n%s")
+                code argument (Printexc.to_string exn)));
+        `Failure code
     in
     prepare_data data
 
   let send ?options ?charset ?code ?content_type ?headers content =
-    let* content = prepare_data content in
+    let content = prepare_data content in
     Result_types.cast_result_lwt
       (M.send ?options ?charset ?code ?content_type ?headers content)
 
@@ -729,8 +722,8 @@ module Ocaml = struct
              , _
              , 'return Eliom_service.ocaml )
              Eliom_service.t)
-        ?(error_handler : ((string * exn) list -> 'return Lwt.t) option)
-        (f : 'get -> 'post -> 'return Lwt.t)
+        ?(error_handler : ((string * exn) list -> 'return) option)
+        (f : 'get -> 'post -> 'return)
     =
     M.register ?app ?scope ?options ?charset ?code ?content_type ?headers
       ?secure_session
@@ -942,10 +935,9 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
         (Eliom_lib.jsmarshal (Eliommod_cli.client_sitedata sp))
         (Eliom_lib.jsmarshal sp.Eliom_common.sp_client_process_info)
     in
-    Lwt.return
-      Eliom_content.Html.(
-        Id.create_named_elt ~id:eliom_appl_data_script_id
-          (F.script (F.cdata_script script)))
+    Eliom_content.Html.(
+      Id.create_named_elt ~id:eliom_appl_data_script_id
+        (F.script (F.cdata_script script)))
 
   let make_eliom_data_script ?(keep_debug = false) ~sp page =
     let ejs_global_data =
@@ -980,11 +972,11 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
               (Eliom_content.Html.D.toelt page)
         ; ejs_sess_info = Eliommod_cli.client_si sp.Eliom_common.sp_si }
     in
-    let* tab_cookies =
+    let tab_cookies =
       Eliommod_cookies.compute_cookies_to_send sp.Eliom_common.sp_sitedata
         sp.Eliom_common.sp_tab_cookie_info sp.Eliom_common.sp_user_tab_cookies
     in
-    let* template = Eliom_reference.get request_template in
+    let template = Eliom_reference.get request_template in
     let script =
       Printf.sprintf
         "__eliom_request_data = \'%s\';\n__eliom_request_cookies = \'%s\';\n__eliom_request_template = \'%s\';"
@@ -992,7 +984,7 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
         (Eliom_lib.jsmarshal tab_cookies)
         (Eliom_lib.jsmarshal (template : string option))
     in
-    Lwt.return Eliom_content.Html.(F.script (F.cdata_script script))
+    Eliom_content.Html.(F.script (F.cdata_script script))
 
   let global_data_service =
     lazy
@@ -1012,7 +1004,7 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
        String.create ~options:max_age
          ~path:(Eliom_service.Path (path @ [name]))
          ~meth:(Get Eliom_parameter.unit)
-         (fun _ _ -> Lwt.return (script, "application/x-javascript")))
+         (fun _ _ -> script, "application/x-javascript"))
 
   let add_eliom_global_data_script rem =
     if global_data_cache_options () <> None
@@ -1054,7 +1046,7 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
     | _ -> assert false
 
   let add_eliom_scripts ~sp page =
-    let* appl_data_script = make_eliom_appl_data_script ~sp in
+    let appl_data_script = make_eliom_appl_data_script ~sp in
     (* First we build a fake page to build the ref_tree... *)
     let html_attribs, (head_attribs, title, head_elts), body =
       split_page (Eliom_content.Html.D.toelt page)
@@ -1097,7 +1089,7 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
         (Eliom_content.Html.F.head ~a:head_attribs title head_elts)
         body
     in
-    let* data_script =
+    let data_script =
       make_eliom_data_script
         ~keep_debug:(Ocsigen_config.get_debugmode ())
         ~sp fake_page
@@ -1109,10 +1101,9 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
       List.hd head_elts :: data_script
       :: add_eliom_global_data_script (List.tl head_elts)
     in
-    Lwt.return
-      (Eliom_content.Html.F.html ~a:html_attribs
-         (Eliom_content.Html.F.head ~a:head_attribs title head_elts)
-         body)
+    Eliom_content.Html.F.html ~a:html_attribs
+      (Eliom_content.Html.F.head ~a:head_attribs title head_elts)
+      body
 
   let remove_eliom_scripts page =
     let html_attribs, (head_attribs, title, head_elts), body =
@@ -1121,10 +1112,9 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
     let head_elts =
       List.filter (fun x -> not (is_eliom_appl_script x)) head_elts
     in
-    Lwt.return
-      (Eliom_content.Html.F.html ~a:html_attribs
-         (Eliom_content.Html.F.head ~a:head_attribs title head_elts)
-         body)
+    Eliom_content.Html.F.html ~a:html_attribs
+      (Eliom_content.Html.F.head ~a:head_attribs title head_elts)
+      body
 
   let send_appl_content =
     Eliom_service.XSame_appl (App_param.application_name, None)
@@ -1149,11 +1139,12 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
       Eliom_state.set_cookie ~cookie_level:`Client_process
         ~name:Eliom_common.appl_name_cookie_name
         ~value:App_param.application_name ();
-    let* body =
-      (match sp.Eliom_common.sp_client_appl_name, options.do_not_launch with
+    let body =
+      let body =
+        match sp.Eliom_common.sp_client_appl_name, options.do_not_launch with
         | None, true -> remove_eliom_scripts content
-        | _ -> add_eliom_scripts ~sp content)
-      >|= fun body ->
+        | _ -> add_eliom_scripts ~sp content
+      in
       Ocsigen_response.Body.of_string (Format.asprintf "%a" out body)
     in
     let headers =
@@ -1188,7 +1179,7 @@ module App (App_param : Eliom_registration_sigs.APP_PARAM) = struct
   let typed_name = App_param.application_name
 
   let data_service_handler () () =
-    Lwt.return (get_global_data ~keep_debug:(Ocsigen_config.get_debugmode ()))
+    get_global_data ~keep_debug:(Ocsigen_config.get_debugmode ())
 
   let _ =
     match App_param.global_data_path with
@@ -1203,7 +1194,7 @@ module type TMPL_PARAMS = sig
   type t
 
   val name : string
-  val make_page : t -> Html_types.html Eliom_content.Html.elt Lwt.t
+  val make_page : t -> Html_types.html Eliom_content.Html.elt
   val update : t -> unit Eliom_client_value.t
 end
 
@@ -1233,8 +1224,8 @@ struct
     =
     match Eliom_parameter.get_non_localized_get_parameters nl_template with
     | None ->
-        let* () = Eliom_reference.set request_template (Some Tmpl_param.name) in
-        let* content = Tmpl_param.make_page content in
+        let () = Eliom_reference.set request_template (Some Tmpl_param.name) in
+        let content = Tmpl_param.make_page content in
         Result_types.cast_kind_lwt
           (Appl.send ~options ?charset ?code ?content_type ?headers content)
     | Some _ ->
diff --git a/src/lib/eliom_registration.server.mli b/src/lib/eliom_registration.server.mli
index 59a68f5caf..3d70f32630 100644
--- a/src/lib/eliom_registration.server.mli
+++ b/src/lib/eliom_registration.server.mli
@@ -163,7 +163,7 @@ module type TMPL_PARAMS = sig
   type t
 
   val name : string
-  val make_page : t -> Html_types.html Eliom_content.Html.elt Lwt.t
+  val make_page : t -> Html_types.html Eliom_content.Html.elt
   val update : t -> unit Eliom_client_value.t
 end
 
@@ -301,7 +301,7 @@ module Redirection : sig
     -> ?content_type:string
     -> ?headers:Ocsigen_header.t
     -> _ page
-    -> _ kind Lwt.t
+    -> _ kind
   (** More polymorphic version of {!Eliom_registration_sigs.send} *)
 end
 
@@ -387,9 +387,9 @@ module Any :
    and type 'a result = 'a kind
 
 val appl_self_redirect :
-   ('page -> [< 'a application_content | browser_content] kind Lwt.t)
+   ('page -> [< 'a application_content | browser_content] kind)
   -> 'page
-  -> 'appl application_content kind Lwt.t
+  -> 'appl application_content kind
 (** The function [appl_self_redirect send page] is an helper function
     required for defining {!Any} service usable inside an Eliom
     application ({!App}). It allows casting an Eliom senders that do
@@ -446,7 +446,7 @@ module Customize
     (T : sig
        type page
 
-       val translate : page -> R.page Lwt.t
+       val translate : page -> R.page
      end) :
   Eliom_registration_sigs.S_with_create
   with type options = R.options
@@ -456,7 +456,7 @@ module Customize
 
 (** {2 Using your own error pages} *)
 
-val set_exn_handler : (exn -> browser_content kind Lwt.t) -> unit
+val set_exn_handler : (exn -> browser_content kind) -> unit
 (** The [set_exn_handler handler] allows redefinition of error pages:
     [404] or any exception during page generation.
 
diff --git a/src/lib/eliom_registration_sigs.shared.mli b/src/lib/eliom_registration_sigs.shared.mli
index d7b688a4b5..38fecc185c 100644
--- a/src/lib/eliom_registration_sigs.shared.mli
+++ b/src/lib/eliom_registration_sigs.shared.mli
@@ -32,7 +32,7 @@ module type PARAM = sig
     -> ?content_type:string
     -> ?headers:Cohttp.Header.t
     -> page
-    -> frame Lwt.t
+    -> frame
 
   val send_appl_content : Eliom_service.send_appl_content
   (** Whether the service is capable of sending application content
@@ -56,7 +56,7 @@ module type PARAM_POLY = sig
     -> ?content_type:string
     -> ?headers:Cohttp.Header.t
     -> _ page
-    -> frame Lwt.t
+    -> frame
 
   val send_appl_content : Eliom_service.send_appl_content
   (** See {!Eliom_reg_sigs.PARAM.send_appl_content}. *)
@@ -104,8 +104,8 @@ module type S = sig
            , _
            , return )
            Eliom_service.t
-    -> ?error_handler:((string * exn) list -> page Lwt.t)
-    -> ('get -> 'post -> page Lwt.t)
+    -> ?error_handler:((string * exn) list -> page)
+    -> ('get -> 'post -> page)
     -> unit
   (** The function [register ~service handler] associates the
       [service] to the function [handler]. The [handler] function takes
@@ -147,7 +147,7 @@ module type S = sig
     -> ?content_type:string
     -> ?headers:Cohttp.Header.t
     -> page
-    -> result Lwt.t
+    -> result
   (** The function [send page] builds the HTTP frame corresponding to
       [page]. This may be used for example in a service handler
       registered with {!Eliom_registration.Any.register}, or when
@@ -175,8 +175,8 @@ module type S_with_create = sig
     -> ?timeout:float
     -> meth:('m, 'gp, 'gn, 'pp, 'pn, 'tipo, 'gp_) Eliom_service.meth
     -> path:('att, 'co, 'gp_) Eliom_service.path_option
-    -> ?error_handler:((string * exn) list -> page Lwt.t)
-    -> ('gp -> 'pp -> page Lwt.t)
+    -> ?error_handler:((string * exn) list -> page)
+    -> ('gp -> 'pp -> page)
     -> ( 'gp
          , 'pp
          , 'm
@@ -224,8 +224,8 @@ module type S_with_create = sig
            , return )
            Eliom_service.t
     -> get_params:('gp, [`WithoutSuffix], 'gn) Eliom_parameter.params_type
-    -> ?error_handler:((string * exn) list -> page Lwt.t)
-    -> ('gp -> unit -> page Lwt.t)
+    -> ?error_handler:((string * exn) list -> page)
+    -> ('gp -> unit -> page)
     -> ( 'gp
          , unit
          , Eliom_service.get
@@ -273,8 +273,8 @@ module type S_with_create = sig
            , return )
            Eliom_service.t
     -> post_params:('pp, [`WithoutSuffix], 'pn) Eliom_parameter.params_type
-    -> ?error_handler:((string * exn) list -> page Lwt.t)
-    -> ('gp -> 'pp -> page Lwt.t)
+    -> ?error_handler:((string * exn) list -> page)
+    -> ('gp -> 'pp -> page)
     -> ( 'gp
          , 'pp
          , Eliom_service.post
@@ -320,8 +320,8 @@ module type S_poly = sig
            , _
            , 'a return )
            Eliom_service.t
-    -> ?error_handler:((string * exn) list -> 'a page Lwt.t)
-    -> ('get -> 'post -> 'a page Lwt.t)
+    -> ?error_handler:((string * exn) list -> 'a page)
+    -> ('get -> 'post -> 'a page)
     -> unit
   (** See {!S.register}. *)
 end
@@ -347,8 +347,8 @@ module type S_poly_with_create = sig
     -> ?timeout:float
     -> meth:('m, 'gp, 'gn, 'pp, 'pn, 'tipo, 'gp_) Eliom_service.meth
     -> path:('att, 'co, 'gp_) Eliom_service.path_option
-    -> ?error_handler:((string * exn) list -> 'a page Lwt.t)
-    -> ('gp -> 'pp -> 'a page Lwt.t)
+    -> ?error_handler:((string * exn) list -> 'a page)
+    -> ('gp -> 'pp -> 'a page)
     -> ( 'gp
          , 'pp
          , 'm
@@ -393,8 +393,8 @@ module type S_poly_with_create = sig
            , 'a return )
            Eliom_service.t
     -> get_params:('gp, [`WithoutSuffix], 'gn) Eliom_parameter.params_type
-    -> ?error_handler:((string * exn) list -> 'a page Lwt.t)
-    -> ('gp -> unit -> 'a page Lwt.t)
+    -> ?error_handler:((string * exn) list -> 'a page)
+    -> ('gp -> unit -> 'a page)
     -> ( 'gp
          , unit
          , Eliom_service.get
@@ -439,8 +439,8 @@ module type S_poly_with_create = sig
            , 'a return )
            Eliom_service.t
     -> post_params:('pp, [`WithoutSuffix], 'pn) Eliom_parameter.params_type
-    -> ?error_handler:((string * exn) list -> 'a page Lwt.t)
-    -> ('gp -> 'pp -> 'a page Lwt.t)
+    -> ?error_handler:((string * exn) list -> 'a page)
+    -> ('gp -> 'pp -> 'a page)
     -> ( 'gp
          , 'pp
          , Eliom_service.post
@@ -468,7 +468,7 @@ module type S_poly_with_send = sig
     -> ?content_type:string
     -> ?headers:Cohttp.Header.t
     -> 'a page
-    -> 'a result Lwt.t
+    -> 'a result
 end
 
 module type S_poly_with_create_with_send = sig
@@ -483,5 +483,5 @@ module type S_poly_with_create_with_send = sig
     -> ?content_type:string
     -> ?headers:Cohttp.Header.t
     -> 'a page
-    -> 'a result Lwt.t
+    -> 'a result
 end
diff --git a/src/lib/eliom_request.client.ml b/src/lib/eliom_request.client.ml
index fe42ebc5f3..81ece45ef8 100644
--- a/src/lib/eliom_request.client.ml
+++ b/src/lib/eliom_request.client.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -258,123 +258,117 @@ let send
           = Some (Eliom_process.get_application_name ())
       else true
     in
-    Lwt.catch
-      (fun () ->
-         let* r =
-           let contents =
-             match post_args with
-             | Some post_args -> Some (`POST_form post_args)
-             | None -> None
-           in
-           XmlHttpRequest.perform_raw_url ?with_credentials
-             ?headers:(Some headers) ?content_type:None ?contents ~get_args
-             ~check_headers ?progress ?upload_progress ?override_mime_type url
-         in
-         let wait_for_unlock, unlock = Lwt.wait () in
-         (if not @@ React.S.value locked
-          then Lwt.wakeup unlock ()
-          else
-            let unlock_event = React.E.once @@ React.S.changes locked in
-            Dom_reference.retain_generic wait_for_unlock
-              ~keep:(React.E.map (fun _ -> Lwt.wakeup unlock ()) unlock_event));
-         let* () = wait_for_unlock in
-         (if Js.Optdef.test Js.Unsafe.global##.___eliom_use_cookie_substitutes_
-          then
-            match
-              (* Cookie substitutes are for iOS WKWebView *)
-              r.XmlHttpRequest.headers
-                Eliom_common.set_cookie_substitutes_header_name
-            with
-            | None | Some "" -> ()
-            | Some cookie_substitutes ->
-                Eliommod_cookies.update_cookie_table ~in_local_storage:true host
-                  (Eliommod_cookies.cookieset_of_json cookie_substitutes));
-         (match
-            r.XmlHttpRequest.headers Eliom_common.set_tab_cookies_header_name
-          with
-         | None | Some "" -> () (* Empty tab_cookies for IE compat *)
-         | Some tab_cookies ->
-             let tab_cookies = Eliommod_cookies.cookieset_of_json tab_cookies in
-             Eliommod_cookies.update_cookie_table host tab_cookies);
-         if r.XmlHttpRequest.code = 204
-         then
-           match
-             r.XmlHttpRequest.headers Eliom_common.full_xhr_redir_header
-           with
-           | None | Some "" -> (
-             match
-               r.XmlHttpRequest.headers Eliom_common.half_xhr_redir_header
-             with
-             | None | Some "" -> Lwt.return (r.XmlHttpRequest.url, None)
-             | Some _uri ->
-                 redirect_post url
-                   (match post_args with
-                   | Some post_args -> post_args
-                   | None -> []);
-                 Lwt.fail Program_terminated)
-           | Some uri ->
-               if i < max_redirection_level
-               then aux (i + 1) (Url.resolve uri)
-               else Lwt.fail Looping_redirection
-         else if expecting_process_page
-         then
-           let url =
-             match
-               r.XmlHttpRequest.headers Eliom_common.response_url_header
-             with
-             | None | Some "" -> Url.add_get_args url (List.tl get_args)
-             | Some url -> Url.resolve url
-           in
-           Lwt.return (url, Some (result r))
-         else if
-           r.XmlHttpRequest.code = 200
-           || XmlHttpRequest.(r.code = 0 && r.content <> "")
-           (* HACK for file access within Cordova which yields code 0.
+    try
+      let r =
+        let contents =
+          match post_args with
+          | Some post_args -> Some (`POST_form post_args)
+          | None -> None
+        in
+        XmlHttpRequest.perform_raw_url ?with_credentials ?headers:(Some headers)
+          ?content_type:None ?contents ~get_args ~check_headers ?progress
+          ?upload_progress ?override_mime_type url
+      in
+      let wait_for_unlock, unlock =
+        Promise.create
+          (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+          ()
+      in
+      (if not @@ React.S.value locked
+       then Promise.resolve unlock ()
+       else
+         let unlock_event = React.E.once @@ React.S.changes locked in
+         Dom_reference.retain_generic wait_for_unlock
+           ~keep:(React.E.map (fun _ -> Promise.resolve unlock ()) unlock_event));
+      let () = wait_for_unlock in
+      (if Js.Optdef.test Js.Unsafe.global##.___eliom_use_cookie_substitutes_
+       then
+         match
+           (* Cookie substitutes are for iOS WKWebView *)
+           r.XmlHttpRequest.headers
+             Eliom_common.set_cookie_substitutes_header_name
+         with
+         | None | Some "" -> ()
+         | Some cookie_substitutes ->
+             Eliommod_cookies.update_cookie_table ~in_local_storage:true host
+               (Eliommod_cookies.cookieset_of_json cookie_substitutes));
+      (match
+         r.XmlHttpRequest.headers Eliom_common.set_tab_cookies_header_name
+       with
+      | None | Some "" -> () (* Empty tab_cookies for IE compat *)
+      | Some tab_cookies ->
+          let tab_cookies = Eliommod_cookies.cookieset_of_json tab_cookies in
+          Eliommod_cookies.update_cookie_table host tab_cookies);
+      if r.XmlHttpRequest.code = 204
+      then
+        match r.XmlHttpRequest.headers Eliom_common.full_xhr_redir_header with
+        | None | Some "" -> (
+          match r.XmlHttpRequest.headers Eliom_common.half_xhr_redir_header with
+          | None | Some "" -> r.XmlHttpRequest.url, None
+          | Some _uri ->
+              redirect_post url
+                (match post_args with
+                | Some post_args -> post_args
+                | None -> []);
+              raise Program_terminated)
+        | Some uri ->
+            if i < max_redirection_level
+            then aux (i + 1) (Url.resolve uri)
+            else raise Looping_redirection
+      else if expecting_process_page
+      then
+        let url =
+          match r.XmlHttpRequest.headers Eliom_common.response_url_header with
+          | None | Some "" -> Url.add_get_args url (List.tl get_args)
+          | Some url -> Url.resolve url
+        in
+        url, Some (result r)
+      else if
+        r.XmlHttpRequest.code = 200
+        || XmlHttpRequest.(r.code = 0 && r.content <> "")
+        (* HACK for file access within Cordova which yields code 0.
                     Code 0 might mean a network error, but then we have no
                     content. *)
-         then Lwt.return (r.XmlHttpRequest.url, Some (result r))
-         else Lwt.fail (Failed_request r.XmlHttpRequest.code))
-      (function
-        | XmlHttpRequest.Wrong_headers (code, headers) -> (
-          (* We are requesting application content and the headers tels
+      then r.XmlHttpRequest.url, Some (result r)
+      else raise (Failed_request r.XmlHttpRequest.code)
+    with XmlHttpRequest.Wrong_headers (code, headers) -> (
+      (* We are requesting application content and the headers tels
            us that the answer is not application content *)
-          match headers Eliom_common.appl_name_header_name with
-          | None | Some "" ->
-              (* Empty appl_name for IE compat. *)
-              (match post_args with
-              | None -> redirect_get url
-              | _ ->
-                  raise_error ~section
-                    "can't silently redirect a Post request to non application content");
-              Lwt.fail Program_terminated
-          | Some appl_name ->
-              let current_appl_name = Eliom_process.get_application_name () in
-              if appl_name = current_appl_name
-              then
-                assert false
-                (* we can't go here:
+      match headers Eliom_common.appl_name_header_name with
+      | None | Some "" ->
+          (* Empty appl_name for IE compat. *)
+          (match post_args with
+          | None -> redirect_get url
+          | _ ->
+              raise_error ~section
+                "can't silently redirect a Post request to non application content");
+          raise Program_terminated
+      | Some appl_name ->
+          let current_appl_name = Eliom_process.get_application_name () in
+          if appl_name = current_appl_name
+          then
+            assert false
+            (* we can't go here:
                                      this case is already handled before *)
-              else (
-                Logs.warn ~src:section (fun fmt ->
-                  fmt
-                    "received content for application %S when running application %s"
-                    appl_name current_appl_name);
-                Lwt.fail (Failed_request code)))
-        | exc -> Lwt.reraise exc)
+          else (
+            Logs.warn ~src:section (fun fmt ->
+              fmt
+                "received content for application %S when running application %s"
+                appl_name current_appl_name);
+            raise (Failed_request code)))
   in
-  let* url, content = aux 0 ?cookies_info ?get_args ?post_args url in
+  let url, content = aux 0 ?cookies_info ?get_args ?post_args url in
   let filter_url url =
     { url with
       Url.hu_arguments =
         List.filter (fun (e, _) -> e <> nl_template_string) url.Url.hu_arguments
     }
   in
-  Lwt.return
-    ( (match Url.url_of_string url with
-      | Some (Url.Http url) -> Url.string_of_url (Url.Http (filter_url url))
-      | Some (Url.Https url) -> Url.string_of_url (Url.Https (filter_url url))
-      | _ -> url)
-    , content )
+  ( (match Url.url_of_string url with
+    | Some (Url.Http url) -> Url.string_of_url (Url.Http (filter_url url))
+    | Some (Url.Https url) -> Url.string_of_url (Url.Https (filter_url url))
+    | _ -> url)
+  , content )
 
 (* BEGIN FORMDATA HACK *)
 let add_button_arg inj args form =
diff --git a/src/lib/eliom_request.client.mli b/src/lib/eliom_request.client.mli
index a6b91d2990..ae221f9b36 100644
--- a/src/lib/eliom_request.client.mli
+++ b/src/lib/eliom_request.client.mli
@@ -72,7 +72,7 @@ val send :
   -> ?override_mime_type:string
   -> string
   -> 'a result
-  -> (string * 'a option) Lwt.t
+  -> string * 'a option
 
 val send_get_form :
    ?with_credentials:bool
@@ -86,7 +86,7 @@ val send_get_form :
   -> Dom_html.formElement Js.t
   -> string
   -> 'a result
-  -> (string * 'a option) Lwt.t
+  -> string * 'a option
 
 val send_post_form :
    ?with_credentials:bool
@@ -100,7 +100,7 @@ val send_post_form :
   -> Dom_html.formElement Js.t
   -> string
   -> 'a result
-  -> (string * 'a option) Lwt.t
+  -> string * 'a option
 
 val http_get :
    ?with_credentials:bool
@@ -112,7 +112,7 @@ val http_get :
   -> string
   -> (string * string) list
   -> 'a result
-  -> (string * 'a option) Lwt.t
+  -> string * 'a option
 
 val http_post :
    ?with_credentials:bool
@@ -124,7 +124,7 @@ val http_post :
   -> string
   -> (string * Eliommod_parameters.param) list
   -> 'a result
-  -> (string * 'a option) Lwt.t
+  -> string * 'a option
 
 val http_put :
    ?with_credentials:bool
@@ -136,7 +136,7 @@ val http_put :
   -> string
   -> (string * Eliommod_parameters.param) list
   -> 'a result
-  -> (string * 'a option) Lwt.t
+  -> string * 'a option
 
 val http_delete :
    ?with_credentials:bool
@@ -148,7 +148,7 @@ val http_delete :
   -> string
   -> (string * Eliommod_parameters.param) list
   -> 'a result
-  -> (string * 'a option) Lwt.t
+  -> string * 'a option
 
 val get_cookie_info_for_uri_js : Js.js_string Js.t -> bool * string list
 val max_redirection_level : int
diff --git a/src/lib/eliom_request_info.client.ml b/src/lib/eliom_request_info.client.ml
index 1283096eb4..425b837114 100644
--- a/src/lib/eliom_request_info.client.ml
+++ b/src/lib/eliom_request_info.client.ml
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Module eliom_sessions.ml
@@ -35,10 +37,10 @@ let client_app_initialised = ref false
 type t = {path : string list; si : Eliom_common.sess_info}
 
 let default_ri = ref None
-let ri_key = Lwt.new_key ()
+let ri_key = Fiber.create_key ()
 
 let get_ri () =
-  match Lwt.get ri_key with
+  match Fiber.get ri_key with
   | Some p -> p
   | None -> (
     match !default_ri with
@@ -53,7 +55,10 @@ let set_session_info ~uri si f =
   let path = Url.path_of_url_string (if uri = "./" then "" else uri) in
   let ri = Some {path; si} in
   default_ri := ri;
-  Lwt.with_value ri_key ri f
+  (Option.fold ~none:Fiber.without_binding
+     ~some:(Fun.flip Fiber.with_binding)
+     ri)
+    ri_key f
 
 let matches_regexp name re =
   try
@@ -99,7 +104,10 @@ let update_session_info ~path ~all_get_params ~all_post_params cont =
   in
   let ri = Some {path; si} in
   default_ri := ri;
-  Lwt.with_value ri_key ri cont
+  (Option.fold ~none:Fiber.without_binding
+     ~some:(Fun.flip Fiber.with_binding)
+     ri)
+    ri_key cont
 
 let remove_first_slash path = match path with "" :: l -> l | l -> l
 
@@ -220,7 +228,7 @@ let get_request_data () =
 
 exception Eliom_no_raw_post_data_on_client
 
-let raw_post_data _ = Lwt.fail Eliom_no_raw_post_data_on_client
+let raw_post_data _ = raise Eliom_no_raw_post_data_on_client
 
 type raw_post_data = unit
 
diff --git a/src/lib/eliom_request_info.client.mli b/src/lib/eliom_request_info.client.mli
index e6f4ea7f95..0707a146d5 100644
--- a/src/lib/eliom_request_info.client.mli
+++ b/src/lib/eliom_request_info.client.mli
@@ -76,7 +76,7 @@ val ssl_ : bool
 
 type raw_post_data = unit
 
-val raw_post_data : unit -> _ Lwt.t
+val raw_post_data : unit -> _
 val client_app_initialised : bool ref
 val get_request_data : unit -> Eliom_common.eliom_js_page_data
 val get_request_cookies : unit -> Ocsigen_cookie_map.t
@@ -101,12 +101,12 @@ val get_sess_info : unit -> Eliom_common.sess_info
 val set_session_info :
    uri:string
   -> Eliom_common.sess_info
-  -> (unit -> 'a Lwt.t)
-  -> 'a Lwt.t
+  -> (unit -> 'a)
+  -> 'a
 
 val update_session_info :
    path:Url.path
   -> all_get_params:(string * string) list
   -> all_post_params:(string * string) list option
-  -> (unit -> 'a Lwt.t)
-  -> 'a Lwt.t
+  -> (unit -> 'a)
+  -> 'a
diff --git a/src/lib/eliom_request_info.server.ml b/src/lib/eliom_request_info.server.ml
index d67cabaeb5..f162e7bd62 100644
--- a/src/lib/eliom_request_info.server.ml
+++ b/src/lib/eliom_request_info.server.ml
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2010 Vincent Balat
@@ -311,7 +313,7 @@ let get_site_dir_option () =
     None
 
 let get_site_dir_sp sp = Eliom_common.get_site_dir sp.Eliom_common.sp_sitedata
-let in_request_handler () = Lwt.get Eliom_common.sp_key <> None
+let in_request_handler () = Fiber.get Eliom_common.sp_key <> None
 
 let get_request () =
   let sp = Eliom_common.get_sp () in
@@ -342,4 +344,4 @@ type raw_post_data =
 
 let raw_post_data sp =
   let ri = get_ri_sp sp in
-  Lwt.return (Ocsigen_request.content_type ri, Ocsigen_request.body ri)
+  Ocsigen_request.content_type ri, Ocsigen_request.body ri
diff --git a/src/lib/eliom_request_info.server.mli b/src/lib/eliom_request_info.server.mli
index 4557d27eb7..2f34f9852e 100644
--- a/src/lib/eliom_request_info.server.mli
+++ b/src/lib/eliom_request_info.server.mli
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Module eliomsessions.mli
@@ -185,7 +187,7 @@ val get_persistent_nl_get_params :
 val get_nl_post_params : unit -> (string * string) list Eliom_lib.String.Table.t
 (** returns non localized POST parameters. *)
 
-val get_post_params : unit -> (string * string) list Lwt.t option
+val get_post_params : unit -> (string * string) list Promise.t option
 (** returns the parameters in the body of the HTTP request (POST parameters)
     that concern the running service. None means that POST data where
     neither urlencoded form data or multipart data. *)
@@ -318,7 +320,7 @@ val get_sp_client_process_info : unit -> Eliom_common.client_process_info
 
 val set_site_handler :
    Eliom_common.sitedata
-  -> (exn -> Ocsigen_response.t Lwt.t)
+  -> (exn -> Ocsigen_response.t)
   -> unit
 
 val get_request_sp : Eliom_common.server_params -> Ocsigen_extensions.request
@@ -350,11 +352,11 @@ val get_ri_sp : Eliom_common.server_params -> Ocsigen_request.t
 
 val get_post_params_sp :
    Eliom_common.server_params
-  -> (string * string) list Lwt.t option
+  -> (string * string) list Promise.t option
 
 val get_files_sp :
    Eliom_common.server_params
-  -> (string * Ocsigen_extensions.file_info) list Lwt.t option
+  -> (string * Ocsigen_extensions.file_info) list Promise.t option
 
 val get_suffix_sp : Eliom_common.server_params -> Eliom_lib.Url.path option
 val get_request_cache_sp : Eliom_common.server_params -> Polytables.t
@@ -362,4 +364,4 @@ val get_request_cache_sp : Eliom_common.server_params -> Polytables.t
 type raw_post_data =
   ((string * string) * (string * string) list) option * Cohttp_lwt.Body.t
 
-val raw_post_data : Eliom_common.server_params -> raw_post_data Lwt.t
+val raw_post_data : Eliom_common.server_params -> raw_post_data
diff --git a/src/lib/eliom_route.client.ml b/src/lib/eliom_route.client.ml
index a0d93e93fd..f4aa0d96e3 100644
--- a/src/lib/eliom_route.client.ml
+++ b/src/lib/eliom_route.client.ml
@@ -70,8 +70,7 @@ module A = struct
           (int * int * Table.t Eliom_common.dircontent ref) list
       ; mutable t_contains_timeout : bool
       ; mutable t_na_services :
-          (Eliom_common.na_key_serv, bool -> params -> result Lwt.t) Hashtbl.t
-      }
+          (Eliom_common.na_key_serv, bool -> params -> result) Hashtbl.t }
 
     let get {t_services; _} = t_services
     let set_contains_timeout a b = a.t_contains_timeout <- b
@@ -79,7 +78,7 @@ module A = struct
     let dlist_add ?sp:_ _tables _srv = ()
   end
 
-  let handle_directory _ = Lwt.return Eliom_service.No_contents
+  let handle_directory _ = Eliom_service.No_contents
 end
 
 include Eliom_route_base.Make (A)
@@ -95,7 +94,7 @@ let add_naservice k f {A.Container.t_na_services; _} =
 
 let call_naservice k {A.Container.t_na_services; _} =
   try (Hashtbl.find t_na_services k) true None
-  with Not_found -> Lwt.fail Eliom_common.Eliom_404
+  with Not_found -> raise Eliom_common.Eliom_404
 
 let rec na_key_of_params ~get = function
   | (k, v) :: _ when k = Eliom_common.naservice_name ->
diff --git a/src/lib/eliom_route.server.ml b/src/lib/eliom_route.server.ml
index 1b943081ae..016e18c24e 100644
--- a/src/lib/eliom_route.server.ml
+++ b/src/lib/eliom_route.server.ml
@@ -1,5 +1,4 @@
 open Eliom_lib
-open Lwt
 open Ocsigen_extensions
 include Eliom_route_base
 
@@ -61,30 +60,28 @@ include Eliom_route_base.Make (struct
     let make_params = Eliom_common.make_server_params
 
     let handle_directory {Eliom_common.request = r; _} =
-      Lwt.fail
-      @@ Ocsigen_extensions.Ocsigen_is_dir
-           (Ocsigen_extensions.new_url_of_directory_request r)
+      raise
+        (Ocsigen_extensions.Ocsigen_is_dir
+           (Ocsigen_extensions.new_url_of_directory_request r))
 
     let get_number_of_reloads () = Ocsigen_extensions.get_numberofreloads ()
   end)
 
-let find_aux now sitedata info _ sci : Ocsigen_response.t Lwt.t =
+let find_aux now sitedata info _ sci : Ocsigen_response.t =
   Eliom_common.Full_state_name_table.fold
     (fun fullsessname (_, r) beg ->
-       Lwt.catch
-         (fun () -> beg)
-         (function
-           | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter -> (
-             match !r with
-             | Eliom_common.SCData_session_expired
-             | Eliom_common.SCNo_data (* cookie removed *) ->
-                 beg
-             | Eliom_common.SC c ->
-                 find_service now !(c.Eliom_common.sc_table) (Some fullsessname)
-                   sitedata info)
-           | e -> fail e))
+       try beg with
+       | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter -> (
+         match !r with
+         | Eliom_common.SCData_session_expired
+         | Eliom_common.SCNo_data (* cookie removed *) ->
+             beg
+         | Eliom_common.SC c ->
+             find_service now !(c.Eliom_common.sc_table) (Some fullsessname)
+               sitedata info)
+       | e -> raise e)
     sci
-    (fail Eliom_common.Eliom_404)
+    (raise Eliom_common.Eliom_404)
 
 let session_tables {Eliom_common.all_cookie_info; tab_cookie_info; _} =
   let (service_cookies_info, _, _), (secure_service_cookies_info, _, _) =
@@ -104,89 +101,82 @@ let drop_most_params ri si =
 let get_page
       now
       ({Eliom_common.request = ri; session_info = si; _} as info)
-      sitedata : Ocsigen_response.t Lwt.t
+      sitedata : Ocsigen_response.t
   =
   let tables = session_tables info in
-  catch
-    (fun () ->
-       List.fold_left
-         (fun beg (table, table_name) ->
-            Lwt.catch
-              (fun () -> beg)
-              (function
-                | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter ->
-                    Logs.info ~src:section (fun fmt ->
-                      fmt "Looking for %s in the %s:"
-                        (Url.string_of_url_path ~encode:true
-                           (Ocsigen_request.sub_path ri.request_info))
-                        table_name);
-                    find_aux now sitedata info Eliom_common.Eliom_404 table
-                | e -> Lwt.fail e))
-         (Lwt.fail Eliom_common.Eliom_404)
-         tables)
-    (function
-      | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter ->
-          catch (* ensuite dans la table globale *)
-            (fun () ->
-               Logs.info ~src:section (fun fmt ->
-                 fmt "Searching in the global table:");
-               find_service now sitedata.Eliom_common.global_services None
-                 sitedata info)
-            (function
-              | (Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter) as
-                exn -> (
-                (* si pas trouvé avec, on essaie sans l'état *)
-                match si.Eliom_common.si_state_info with
-                | Eliom_common.RAtt_no, Eliom_common.RAtt_no -> fail exn
-                | g, Eliom_common.RAtt_anon _ | g, Eliom_common.RAtt_named _ ->
-                    (* There was a POST state.
+  try
+    List.fold_left
+      (fun beg (table, table_name) ->
+         try beg with
+         | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter ->
+             Logs.info ~src:section (fun fmt ->
+               fmt "Looking for %s in the %s:"
+                 (Url.string_of_url_path ~encode:true
+                    (Ocsigen_request.sub_path ri.request_info))
+                 table_name);
+             find_aux now sitedata info Eliom_common.Eliom_404 table
+         | e -> raise e)
+      (raise Eliom_common.Eliom_404)
+      tables
+  with
+  | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter -> (
+    try
+      (* ensuite dans la table globale *)
+      Logs.info ~src:section (fun fmt -> fmt "Searching in the global table:");
+      find_service now sitedata.Eliom_common.global_services None sitedata info
+    with
+    | (Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter) as exn -> (
+      (* si pas trouvé avec, on essaie sans l'état *)
+      match si.Eliom_common.si_state_info with
+      | Eliom_common.RAtt_no, Eliom_common.RAtt_no -> raise exn
+      | g, Eliom_common.RAtt_anon _ | g, Eliom_common.RAtt_named _ ->
+          (* There was a POST state.
                           We remove it, and remove POST parameters.
-                    *)
-                    Logs.info ~src:section (fun fmt ->
-                      fmt "Link too old. Try without POST parameters:");
-                    Polytables.set
-                      ~table:(Ocsigen_request.request_cache ri.request_info)
-                      ~key:Eliom_common.eliom_link_too_old ~value:true;
-                    let request =
-                      { ri with
-                        request_info =
-                          Ocsigen_request.update ri.request_info ~post_data:None
-                            ~meth:`GET }
-                    and session_info =
-                      { si with
-                        Eliom_common.si_nonatt_info = Eliom_common.RNa_no
-                      ; Eliom_common.si_state_info = g, Eliom_common.RAtt_no }
-                    in
-                    fail
-                    @@ Eliom_common.Eliom_retry_with
-                         {info with Eliom_common.request; session_info}
-                | Eliom_common.RAtt_named _, Eliom_common.RAtt_no
-                | Eliom_common.RAtt_anon _, Eliom_common.RAtt_no ->
-                    (* There was a GET state, but no POST state.
+          *)
+          Logs.info ~src:section (fun fmt ->
+            fmt "Link too old. Try without POST parameters:");
+          Polytables.set
+            ~table:(Ocsigen_request.request_cache ri.request_info)
+            ~key:Eliom_common.eliom_link_too_old ~value:true;
+          let request =
+            { ri with
+              request_info =
+                Ocsigen_request.update ri.request_info ~post_data:None
+                  ~meth:`GET }
+          and session_info =
+            { si with
+              Eliom_common.si_nonatt_info = Eliom_common.RNa_no
+            ; Eliom_common.si_state_info = g, Eliom_common.RAtt_no }
+          in
+          raise
+            (Eliom_common.Eliom_retry_with
+               {info with Eliom_common.request; session_info})
+      | Eliom_common.RAtt_named _, Eliom_common.RAtt_no
+      | Eliom_common.RAtt_anon _, Eliom_common.RAtt_no ->
+          (* There was a GET state, but no POST state.
                      We remove it with its parameters,
                      and remove POST parameters.
-                    *)
-                    Logs.info ~src:section (fun fmt ->
-                      fmt
-                        "Link to old. Trying without GET state parameters and POST parameters:");
-                    Polytables.set
-                      ~table:(Ocsigen_request.request_cache ri.request_info)
-                      ~key:Eliom_common.eliom_link_too_old ~value:true;
-                    let request =
-                      { ri with
-                        request_info = drop_most_params ri.request_info si }
-                    and session_info =
-                      let open Eliom_common in
-                      { si with
-                        si_nonatt_info = RNa_no
-                      ; si_state_info = RAtt_no, RAtt_no
-                      ; si_other_get_params = [] }
-                    in
-                    fail
-                    @@ Eliom_common.Eliom_retry_with
-                         {info with Eliom_common.request; session_info})
-              | e -> fail e)
-      | e -> fail e)
+          *)
+          Logs.info ~src:section (fun fmt ->
+            fmt
+              "Link to old. Trying without GET state parameters and POST parameters:");
+          Polytables.set
+            ~table:(Ocsigen_request.request_cache ri.request_info)
+            ~key:Eliom_common.eliom_link_too_old ~value:true;
+          let request =
+            {ri with request_info = drop_most_params ri.request_info si}
+          and session_info =
+            let open Eliom_common in
+            { si with
+              si_nonatt_info = RNa_no
+            ; si_state_info = RAtt_no, RAtt_no
+            ; si_other_get_params = [] }
+          in
+          raise
+            (Eliom_common.Eliom_retry_with
+               {info with Eliom_common.request; session_info}))
+    | e -> raise e)
+  | e -> raise e
 
 let add_naservice_table at (key, elt) =
   match at with
@@ -309,70 +299,72 @@ let make_naservice
     | Eliom_common.Notfound _ -> raise Not_found
   in
   let tables = session_tables info in
-  (try
-     try
-       let rec f = function
-         | [] -> raise Not_found
-         | (table, table_name) :: l -> (
-             Logs.info ~src:section (fun fmt ->
-               fmt "Looking for a non attached service in the %s:" table_name);
-             try return (find_aux table) with Not_found -> f l)
-       in
-       f tables
-     with Not_found ->
-       Logs.info ~src:section (fun fmt ->
-         fmt "Looking for a non attached service in the global table");
-       return
-         ( find_naservice now sitedata.Eliom_common.global_services
-             (Eliom_common.na_key_serv_of_req si.Eliom_common.si_nonatt_info)
-         , sitedata.Eliom_common.global_services
-         , None )
-   with Not_found -> (
-     (* The non-attached service has not been found.
-      We call the same URL without non-attached parameters.
-     *)
-     match si.Eliom_common.si_nonatt_info with
-     | Eliom_common.RNa_no -> assert false
-     | Eliom_common.RNa_post_ _ | Eliom_common.RNa_post' _ ->
-         (*VVV (Some, Some) or (_, Some)? *)
-         Logs.info ~src:section (fun fmt ->
-           fmt
-             "Link too old to a non-attached POST coservice. Try without POST parameters:");
-         Polytables.set
-           ~table:(Ocsigen_request.request_cache ri.request_info)
-           ~key:Eliom_common.eliom_link_too_old ~value:true;
-         Eliom_common.get_session_info ~sitedata
-           ~req:
-             { ri with
-               Ocsigen_extensions.request_info =
-                 drop_most_params ri.request_info si }
-           si.Eliom_common.si_previous_extension_error
-         >>= fun (ri', si', _previous_tab_cookies_info) ->
-         Lwt.fail
-         @@ Eliom_common.Eliom_retry_with
-              {info with request = ri'; session_info = si'}
-     | Eliom_common.RNa_get_ _ | Eliom_common.RNa_get' _ ->
-         Logs.info ~src:section (fun fmt ->
-           fmt "Link too old. Try without non-attached parameters:");
-         Polytables.set
-           ~table:(Ocsigen_request.request_cache ri.request_info)
-           ~key:Eliom_common.eliom_link_too_old ~value:true;
-         Eliom_common.get_session_info ~sitedata
-           ~req:
-             { ri with
-               Ocsigen_extensions.request_info =
-                 drop_most_params ri.request_info si }
-           si.Eliom_common.si_previous_extension_error
-         >>= fun (ri', si', _previous_tab_cookies_info) ->
-         Lwt.fail
-         @@ Eliom_common.Eliom_retry_with
-              {info with request = ri'; session_info = si'}))
-  >>=
-  fun ( (_, max_use, expdate, naservice, node)
+  let ( (_, max_use, expdate, naservice, node)
       , tablewhereithasbeenfound
-      , fullsessname ) ->
+      , fullsessname )
+    =
+    try
+      try
+        let rec f = function
+          | [] -> raise Not_found
+          | (table, table_name) :: l -> (
+              Logs.info ~src:section (fun fmt ->
+                fmt "Looking for a non attached service in the %s:" table_name);
+              try find_aux table with Not_found -> f l)
+        in
+        f tables
+      with Not_found ->
+        Logs.info ~src:section (fun fmt ->
+          fmt "Looking for a non attached service in the global table");
+        ( find_naservice now sitedata.Eliom_common.global_services
+            (Eliom_common.na_key_serv_of_req si.Eliom_common.si_nonatt_info)
+        , sitedata.Eliom_common.global_services
+        , None )
+    with Not_found -> (
+      (* The non-attached service has not been found.
+      We call the same URL without non-attached parameters.
+      *)
+      match si.Eliom_common.si_nonatt_info with
+      | Eliom_common.RNa_no -> assert false
+      | Eliom_common.RNa_post_ _ | Eliom_common.RNa_post' _ ->
+          (*VVV (Some, Some) or (_, Some)? *)
+          Logs.info ~src:section (fun fmt ->
+            fmt
+              "Link too old to a non-attached POST coservice. Try without POST parameters:");
+          Polytables.set
+            ~table:(Ocsigen_request.request_cache ri.request_info)
+            ~key:Eliom_common.eliom_link_too_old ~value:true;
+          let ri', si', _previous_tab_cookies_info =
+            Eliom_common.get_session_info ~sitedata
+              ~req:
+                { ri with
+                  Ocsigen_extensions.request_info =
+                    drop_most_params ri.request_info si }
+              si.Eliom_common.si_previous_extension_error
+          in
+          raise
+            (Eliom_common.Eliom_retry_with
+               {info with request = ri'; session_info = si'})
+      | Eliom_common.RNa_get_ _ | Eliom_common.RNa_get' _ ->
+          Logs.info ~src:section (fun fmt ->
+            fmt "Link too old. Try without non-attached parameters:");
+          Polytables.set
+            ~table:(Ocsigen_request.request_cache ri.request_info)
+            ~key:Eliom_common.eliom_link_too_old ~value:true;
+          let ri', si', _previous_tab_cookies_info =
+            Eliom_common.get_session_info ~sitedata
+              ~req:
+                { ri with
+                  Ocsigen_extensions.request_info =
+                    drop_most_params ri.request_info si }
+              si.Eliom_common.si_previous_extension_error
+          in
+          raise
+            (Eliom_common.Eliom_retry_with
+               {info with request = ri'; session_info = si'}))
+  in
   let sp = Eliom_common.make_server_params sitedata info None fullsessname in
-  naservice sp >>= fun r ->
+  let r = naservice sp in
   Logs.info ~src:section (fun fmt ->
     fmt "Non attached page found and generated successfully");
   (match expdate with Some (timeout, e) -> e := timeout +. now | None -> ());
@@ -385,4 +377,4 @@ let make_naservice
           (Eliom_common.na_key_serv_of_req si.Eliom_common.si_nonatt_info)
           node
       else r := !r - 1);
-  return r
+  r
diff --git a/src/lib/eliom_route.server.mli b/src/lib/eliom_route.server.mli
index aded0025e3..c9b4fb7799 100644
--- a/src/lib/eliom_route.server.mli
+++ b/src/lib/eliom_route.server.mli
@@ -24,7 +24,7 @@ val get_page :
    float
   -> Eliom_common.info
   -> Eliom_common.sitedata
-  -> Ocsigen_response.t Lwt.t
+  -> Ocsigen_response.t
 
 val add_service :
    int
@@ -46,7 +46,7 @@ val add_naservice :
   -> Eliom_common.NAserv_Table.key
   -> int ref option
      * (float * float ref) option
-     * (Eliom_common.server_params -> Ocsigen_response.t Lwt.t)
+     * (Eliom_common.server_params -> Ocsigen_response.t)
   -> unit
 
 val remove_naservice :
@@ -58,4 +58,4 @@ val make_naservice :
    float
   -> Eliom_common.info
   -> Eliom_common.sitedata
-  -> Ocsigen_response.t Lwt.t
+  -> Ocsigen_response.t
diff --git a/src/lib/eliom_route_base.shared.ml b/src/lib/eliom_route_base.shared.ml
index 10a5a2bfbb..96eb4b735f 100644
--- a/src/lib/eliom_route_base.shared.ml
+++ b/src/lib/eliom_route_base.shared.ml
@@ -19,7 +19,6 @@
 *)
 
 open Eliom_lib
-open Lwt
 
 let section = Logs.Src.create "eliom:service"
 
@@ -40,7 +39,7 @@ module type PARAM = sig
     -> Eliom_common.full_state_name option
     -> params
 
-  val handle_directory : info -> result Lwt.t
+  val handle_directory : info -> result
   val get_number_of_reloads : unit -> int
 
   module Node : sig
@@ -100,61 +99,60 @@ module Make (P : PARAM) = struct
         (site_data : P.site_data)
         (info : P.info)
         (urlsuffix : _ option)
-        k : P.result Lwt.t
+        k : P.result
     =
     let sp = P.make_params site_data info urlsuffix fullsessname in
-    Lwt.catch
-      (fun () -> Lwt.return (P.Table.find k !pagetableref))
-      (function Not_found -> fail Eliom_common.Eliom_404 | e -> fail e)
-    >>= fun (node, l) ->
+    let node, l =
+      try P.Table.find k !pagetableref with
+      | Not_found -> raise Eliom_common.Eliom_404
+      | e -> raise e
+    in
     let rec aux toremove = function
-      | [] ->
-          Lwt.return
-            (Eliom_common.Notfound Eliom_common.Eliom_Wrong_parameter, [])
+      | [] -> Eliom_common.Notfound Eliom_common.Eliom_Wrong_parameter, []
       | ({Eliom_common.s_max_use; s_expire; s_f; _} as a) :: l -> (
         match s_expire with
         | Some (_, e) when !e < now ->
             (* Service expired. Removing it. *)
             Logs.info ~src:section (fun fmt ->
               fmt "Service expired. Removing it");
-            aux toremove l >>= fun (r, toremove) -> Lwt.return (r, a :: toremove)
-        | _ ->
-            catch
-              (fun () ->
-                 Logs.info ~src:section (fun fmt -> fmt "Trying a service");
-                 s_f nosuffixversion sp >>= fun p ->
-                 (* warning: the list ll may change during funct
+            let r, toremove = aux toremove l in
+            r, a :: toremove
+        | _ -> (
+          try
+            Logs.info ~src:section (fun fmt -> fmt "Trying a service");
+            let p = s_f nosuffixversion sp in
+            (* warning: the list ll may change during funct
                   if funct register something on the same URL!! *)
-                 Logs.info ~src:section (fun fmt ->
-                   fmt "Page found and generated successfully");
-                 (* If this is an anonymous coservice,
+            Logs.info ~src:section (fun fmt ->
+              fmt "Page found and generated successfully");
+            (* If this is an anonymous coservice,
                   we place it at the top of the dlist
                   (limitation of number of coservices) *)
-                 (match node with
-                 | None -> ()
-                 | Some node -> P.Node.up node);
-                 (* We update the expiration date *)
-                 (match s_expire with
-                 | Some (timeout, e) -> e := timeout +. now
-                 | None -> ());
-                 let newtoremove =
-                   match s_max_use with
-                   | Some s_max_use ->
-                       if s_max_use = 1
-                       then a :: toremove
-                       else (
-                         a.s_max_use <- Some (s_max_use - 1);
-                         toremove)
-                   | _ -> toremove
-                 in
-                 Lwt.return (Eliom_common.Found p, newtoremove))
-              (function
-                | Eliom_common.Eliom_Wrong_parameter ->
-                    aux toremove l >>= fun (r, toremove) ->
-                    Lwt.return (r, toremove)
-                | e -> Lwt.return (Eliom_common.Notfound e, toremove)))
+            (match node with
+            | None -> ()
+            | Some node -> P.Node.up node);
+            (* We update the expiration date *)
+            (match s_expire with
+            | Some (timeout, e) -> e := timeout +. now
+            | None -> ());
+            let newtoremove =
+              match s_max_use with
+              | Some s_max_use ->
+                  if s_max_use = 1
+                  then a :: toremove
+                  else (
+                    a.s_max_use <- Some (s_max_use - 1);
+                    toremove)
+              | _ -> toremove
+            in
+            Eliom_common.Found p, newtoremove
+          with
+          | Eliom_common.Eliom_Wrong_parameter ->
+              let r, toremove = aux toremove l in
+              r, toremove
+          | e -> Eliom_common.Notfound e, toremove))
     in
-    aux [] l >>= fun (r, toremove) ->
+    let r, toremove = aux [] l in
     (match node, toremove with
     | _, [] -> ()
     | Some node, _ ->
@@ -184,8 +182,8 @@ module Make (P : PARAM) = struct
           | newlist -> P.Table.add k (None, newlist) newptr
       with Not_found -> ()));
     match r with
-    | Eliom_common.Found r -> Lwt.return (r : P.result)
-    | Eliom_common.Notfound e -> fail e
+    | Eliom_common.Found r -> (r : P.result)
+    | Eliom_common.Notfound e -> raise e
 
   let remove_id services id =
     List.filter (fun {Eliom_common.s_id; _} -> s_id <> id) services
@@ -355,8 +353,8 @@ module Make (P : PARAM) = struct
 
   exception Exn1
 
-  let find_service now tables fullsessname sitedata info : P.result Lwt.t =
-    let rec search_page_table dircontent : _ -> P.result Lwt.t =
+  let find_service now tables fullsessname sitedata info : P.result =
+    let rec search_page_table dircontent : _ -> P.result =
       let find nosuffixversion page_table_ref suffix =
         let si = P.sess_info_of_info info in
         find_page_table nosuffixversion now page_table_ref fullsessname sitedata
@@ -372,37 +370,35 @@ module Make (P : PARAM) = struct
         let aa =
           match a with None -> Eliom_common.defaultpagename | Some aa -> aa
         in
-        Lwt.catch
-          (fun () ->
-             let dc =
-               try !(find_dircontent dircontent aa)
-               with Not_found -> raise Exn1
-             in
-             match dc with
-             | Eliom_common.Dir dircontentref2 ->
-                 search_page_table !dircontentref2 l
-             | Eliom_common.File page_table_ref -> (
-               match l with
-               | [] -> find false page_table_ref None
-               | _ ->
-                   (* We have a file with suffix *)
-                   raise Eliom_common.Eliom_Wrong_parameter))
-          (function
-            | (Exn1 | Eliom_common.Eliom_Wrong_parameter) as e -> (
-              (* If no service matches, we try a suffix service *)
-              try
-                match
-                  !(try
-                      find_dircontent dircontent
-                        Eliom_common.eliom_suffix_internal_name
-                    with Not_found -> raise e)
-                with
-                | Eliom_common.Dir _ -> Lwt.fail Exn1
-                | Eliom_common.File page_table_ref ->
-                    find false page_table_ref
-                      (if a = None then Some [] else Some (aa :: l))
-              with e -> Lwt.fail e)
-            | e -> Lwt.fail e)
+        try
+          let dc =
+            try !(find_dircontent dircontent aa) with Not_found -> raise Exn1
+          in
+          match dc with
+          | Eliom_common.Dir dircontentref2 ->
+              search_page_table !dircontentref2 l
+          | Eliom_common.File page_table_ref -> (
+            match l with
+            | [] -> find false page_table_ref None
+            | _ ->
+                (* We have a file with suffix *)
+                raise Eliom_common.Eliom_Wrong_parameter)
+        with
+        | (Exn1 | Eliom_common.Eliom_Wrong_parameter) as e -> (
+          (* If no service matches, we try a suffix service *)
+          try
+            match
+              !(try
+                  find_dircontent dircontent
+                    Eliom_common.eliom_suffix_internal_name
+                with Not_found -> raise e)
+            with
+            | Eliom_common.Dir _ -> raise Exn1
+            | Eliom_common.File page_table_ref ->
+                find false page_table_ref
+                  (if a = None then Some [] else Some (aa :: l))
+          with e -> raise e)
+        | e -> raise e
       in
       function
       | [] ->
@@ -418,9 +414,9 @@ module Make (P : PARAM) = struct
                   Eliom_common.eliom_suffix_internal_name
               with Not_found -> raise Exn1)
           with
-          | Eliom_common.Dir _ -> Lwt.fail Exn1
+          | Eliom_common.Dir _ -> raise Exn1
           | Eliom_common.File page_table_ref -> find true page_table_ref None
-        with e -> Lwt.fail e)
+        with e -> raise e)
       (*      | ""::l -> search_page_table dircontent l *)
       (* We do not remove "//" any more
            because of optional suffixes *)
@@ -431,18 +427,17 @@ module Make (P : PARAM) = struct
          (generation, priority) *)
       List.fold_left
         (fun prev (_prio, _gen, table) ->
-           Lwt.catch
-             (fun () -> prev)
-             (function
-               | Exn1 | Eliom_common.Eliom_404
-               | Eliom_common.Eliom_Wrong_parameter ->
-                   search_page_table !table path
-               | e -> fail e))
-        (fail Exn1) tables
+           try prev with
+           | Exn1 | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter
+             ->
+               search_page_table !table path
+           | e -> raise e)
+        (raise Exn1) tables
     in
-    Lwt.catch
-      (fun () ->
-         search_by_priority_generation (P.Container.get tables)
-           (Url.change_empty_list (P.subpath_of_info info)))
-      (function Exn1 -> Lwt.fail Eliom_common.Eliom_404 | e -> Lwt.fail e)
+    try
+      search_by_priority_generation (P.Container.get tables)
+        (Url.change_empty_list (P.subpath_of_info info))
+    with
+    | Exn1 -> raise Eliom_common.Eliom_404
+    | e -> raise e
 end
diff --git a/src/lib/eliom_service.client.ml b/src/lib/eliom_service.client.ml
index 0af2fb6908..d8a9ebefcc 100644
--- a/src/lib/eliom_service.client.ml
+++ b/src/lib/eliom_service.client.ml
@@ -44,7 +44,7 @@ let set_client_fun ?app ~service f =
   | None -> service.client_fun <- Some (ref (Some f))
 
 let reload_fun : type gp pp.
-  (gp, pp, _, _, _, _, _, _, _, _, _) t -> (gp -> unit -> result Lwt.t) option
+  (gp, pp, _, _, _, _, _, _, _, _, _) t -> (gp -> unit -> result) option
   =
  fun service ->
   match Eliom_parameter.is_unit (post_params_type service) with
diff --git a/src/lib/eliom_service.client.mli b/src/lib/eliom_service.client.mli
index 08df8b5669..21b837be3a 100644
--- a/src/lib/eliom_service.client.mli
+++ b/src/lib/eliom_service.client.mli
@@ -31,7 +31,7 @@ include Eliom_service_sigs.S
 val set_client_fun :
    ?app:string
   -> service:('a, 'b, _, _, _, _, _, _, _, _, _) t
-  -> ('a -> 'b -> result Lwt.t)
+  -> ('a -> 'b -> result)
   -> unit
 
 (**/**)
@@ -45,7 +45,7 @@ val pre_applied_parameters :
 
 val reload_fun :
    ('a, _, _, _, _, _, _, _, _, _, _) t
-  -> ('a -> unit -> result Lwt.t) Eliom_client_value.t option
+  -> ('a -> unit -> result) Eliom_client_value.t option
 
 module Cohttp : sig
   module Header : sig
diff --git a/src/lib/eliom_service_base.eliom b/src/lib/eliom_service_base.eliom
index 9e0014e5b7..e7f480d80b 100644
--- a/src/lib/eliom_service_base.eliom
+++ b/src/lib/eliom_service_base.eliom
@@ -139,12 +139,12 @@ type ('get
   ; (* force https *)
     keep_nl_params : [`All | `Persistent | `None]
   ; mutable send_appl_content : send_appl_content
-    (* XNever when we create the service, then changed at registration
+  ; (* XNever when we create the service, then changed at registration
      :/ *)
-  ; (* If the service has a client-side implementation, we put the
+    (* If the service has a client-side implementation, we put the
      generating function here: *)
     mutable client_fun :
-      ('get -> 'post -> result Lwt.t) option ref Eliom_client_value.t option
+      ('get -> 'post -> result) option ref Eliom_client_value.t option
     (* The function is in a client-side reference, so that it is shared
      by all occurrences of the service sent from the server.
      For some service, we cannot create the client value immediately;
@@ -209,7 +209,7 @@ let priority s = s.priority
 
 let internal_set_client_fun
       ~service
-      (f : ('get -> 'post -> result Lwt.t) Eliom_client_value.t)
+      (f : ('get -> 'post -> result) Eliom_client_value.t)
   =
   service.client_fun <- Some [%client.unsafe ref (Some ~%f)]
 
diff --git a/src/lib/eliom_service_sigs.shared.mli b/src/lib/eliom_service_sigs.shared.mli
index 064029c7a6..5b48d733eb 100644
--- a/src/lib/eliom_service_sigs.shared.mli
+++ b/src/lib/eliom_service_sigs.shared.mli
@@ -424,7 +424,7 @@ module type S = sig
 
   val client_fun :
      ('a, 'b, _, _, _, _, _, _, _, _, _) t
-    -> ('a -> 'b -> result Lwt.t) Eliom_client_value.t option
+    -> ('a -> 'b -> result) Eliom_client_value.t option
 
   val has_client_fun : (_, _, _, _, _, _, _, _, _, _, _) t -> bool
 
@@ -481,6 +481,6 @@ module type S = sig
 
   val internal_set_client_fun :
      service:('a, 'b, _, _, _, _, _, _, _, _, _) t
-    -> ('a -> 'b -> result Lwt.t) Eliom_client_value.t
+    -> ('a -> 'b -> result) Eliom_client_value.t
     -> unit
 end
diff --git a/src/lib/eliom_shared.client.mli b/src/lib/eliom_shared.client.mli
index ff5edd3752..71dd50a3a7 100644
--- a/src/lib/eliom_shared.client.mli
+++ b/src/lib/eliom_shared.client.mli
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2014
@@ -30,7 +32,7 @@
 val to_signal :
    init:'a
   -> ?eq:('a -> 'a -> bool)
-  -> 'a React.S.t Lwt.t
+  -> 'a React.S.t Promise.t
   -> 'a React.S.t
 (** [to_signal ~init s] converts the Lwt-wrapped signal [s] into a
     regular signal with initial value [init]. *)
diff --git a/src/lib/eliom_shared.eliom b/src/lib/eliom_shared.eliom
index f41155b0ab..421412ce8d 100644
--- a/src/lib/eliom_shared.eliom
+++ b/src/lib/eliom_shared.eliom
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2014
@@ -19,16 +21,15 @@
 *)
 
 [%%shared
-open Lwt.Syntax
-
 (* put this in Eio_react? Find a better name? *)
-let to_signal ~init ?eq (th : 'a React.S.t Lwt.t) : 'a React.S.t =
+let to_signal ~init ?eq (th : 'a React.S.t Promise.t) : 'a React.S.t =
   let s, set = React.S.create ?eq init in
-  Lwt.async (fun () ->
-    let* ss = th in
-    let effectful_signal = React.S.map (fun v -> set v) ss in
-    ignore (React.S.retain s (fun () -> ignore effectful_signal));
-    Lwt.return_unit);
+  Fiber.fork
+    ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+    (fun () ->
+       let ss = th in
+       let effectful_signal = React.S.map (fun v -> set v) ss in
+       ignore (React.S.retain s (fun () -> ignore effectful_signal)));
   s]
 
 [%%client
@@ -132,57 +133,67 @@ module ReactiveData = struct
     include ReactiveData.RList
 
     module Lwt = struct
-      let map_data_p_lwt = Lwt_list.map_p
+      let map_data_p_lwt = Fiber.List.map
 
       let map_patch_p_lwt f = function
         | I (i, x) ->
-            let* p = f x in
-            Lwt.return (I (i, p))
-        | R i -> Lwt.return (R i)
-        | X (i, j) -> Lwt.return (X (i, j))
+            let p = f x in
+            I (i, p)
+        | R i -> R i
+        | X (i, j) -> X (i, j)
         | U (i, x) ->
-            let* p = f x in
-            Lwt.return (U (i, p))
+            let p = f x in
+            U (i, p)
 
-      let map_patch_p_lwt f = Lwt_list.map_p (map_patch_p_lwt f)
+      let map_patch_p_lwt f = Fiber.List.map (map_patch_p_lwt f)
 
       let map_msg_p_lwt f = function
         | Set l ->
-            let* p = map_data_p_lwt f l in
-            Lwt.return (Set p)
+            let p = map_data_p_lwt f l in
+            Set p
         | Patch p ->
-            let* p = map_patch_p_lwt f p in
-            Lwt.return (Patch p)
+            let p = map_patch_p_lwt f p in
+            Patch p
 
       let map_p_aux r_th f l =
         (* We react to all events occurring on initial list *)
         let event = ReactiveData.RList.event l in
         (* the waiter is used a a lock to keep the order of events *)
-        let waiter = ref (Lwt.wait ()) in
-        Lwt.wakeup (snd !waiter) ();
+        let waiter =
+          ref
+            (Promise.create
+               (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+               ())
+        in
+        Promise.resolve (snd !waiter) ();
         React.E.map
           (fun msg ->
-             Lwt.async (fun () ->
-               let waiter1 = !waiter in
-               let new_waiter = Lwt.wait () in
-               waiter := new_waiter;
-               let* new_msg = map_msg_p_lwt f msg in
-               let* _, rhandle = r_th in
-               let* () = fst waiter1 in
-               (match new_msg with
-               | ReactiveData.RList.Set s -> ReactiveData.RList.set rhandle s
-               | ReactiveData.RList.Patch p ->
-                   ReactiveData.RList.patch rhandle p);
-               Lwt.wakeup (snd new_waiter) ();
-               Lwt.return_unit))
+             Fiber.fork
+               ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+               (fun () ->
+                  let waiter1 = !waiter in
+                  let new_waiter =
+                    Promise.create
+                      (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+                      ()
+                  in
+                  waiter := new_waiter;
+                  let new_msg = map_msg_p_lwt f msg in
+                  let _, rhandle = r_th in
+                  let () = fst waiter1 in
+                  (match new_msg with
+                  | ReactiveData.RList.Set s -> ReactiveData.RList.set rhandle s
+                  | ReactiveData.RList.Patch p ->
+                      ReactiveData.RList.patch rhandle p);
+                  Promise.resolve (snd new_waiter) ()))
           event
 
       (** Same as map_p but we do not compute the initial list.
           Instead, we give the initial list as parameter.  To be used
           when the initial list has been computed on server side.  *)
-      let map_p_init ~init (f : 'a -> 'b Lwt.t) (l : 'a t) : 'b t =
+      let map_p_init ~init (f : 'a -> 'b) (l : 'a t) : 'b t =
         let ((rr, _) as r) = ReactiveData.RList.create init in
-        let effectul_event = map_p_aux (Lwt.return r) f l in
+        let effectul_event = map_p_aux r f l in
         (* We keep a reference to the effectul_event in the resulting
            reactive list in order that the effectul_event is garbage
            collected only if the resulting list is garbage
@@ -197,14 +208,14 @@ module ReactiveData = struct
           the previous one has not finished to be computed, we launch
           the computation of [f] in parallel, but we wait for the
           previous one to be applied before applying it.  *)
-      let map_p (f : 'a -> 'b Lwt.t) (l : 'a t) : 'b t Lwt.t =
+      let map_p (f : 'a -> 'b) (l : 'a t) : 'b t =
         (* First we build the initial value of the result list *)
         let r_th =
-          let* r = Lwt_list.map_p f (ReactiveData.RList.value l) in
-          Lwt.return (ReactiveData.RList.create r)
+          let r = Fiber.List.map f (ReactiveData.RList.value l) in
+          ReactiveData.RList.create r
         in
         let effectul_event = map_p_aux r_th f l in
-        let* rr, _ = r_th in
+        let rr, _ = r_th in
         (* We keep a reference to the effectul_event in the resulting
            reactive list in order that the effectul_event is garbage
            collected only if the resulting list is garbage
@@ -212,7 +223,7 @@ module ReactiveData = struct
         ignore
           (React.E.retain (ReactiveData.RList.event rr) (fun () ->
              ignore effectul_event));
-        Lwt.return rr
+        rr
     end
 
     let create ?default ?(reset_default = false) v =
@@ -496,105 +507,98 @@ module React = struct
     end
 
     module Lwt = struct
-      let map_s
-            ?eq
-            (f : ('a -> 'b Lwt.t) Value.t)
-            (s : 'a FakeReact.S.t Value.t) : 'b t Lwt.t
+      let map_s ?eq (f : ('a -> 'b) Value.t) (s : 'a FakeReact.S.t Value.t) :
+        'b t
         =
         let s' = Value.local s in
-        let* server_result = (Value.local f) (FakeReact.S.value s') in
+        let server_result = (Value.local f) (FakeReact.S.value s') in
         let synced = FakeReact.S.synced s' in
-        Lwt.return
-          (Value.create
-             (fst (FakeReact.S.create ~synced server_result))
-             [%client.unsafe
-               (React.S.Lwt.map_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s
-                : 'b FakeReact.S.t)])
+        Value.create
+          (fst (FakeReact.S.create ~synced server_result))
+          [%client.unsafe
+            (React.S.Lwt.map_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s
+             : 'b FakeReact.S.t)]
 
       let l2_s
             ?eq
-            (f : ('a -> 'b -> 'c Lwt.t) Value.t)
+            (f : ('a -> 'b -> 'c) Value.t)
             (s1 : 'a FakeReact.S.t Value.t)
-            (s2 : 'b FakeReact.S.t Value.t) : 'c t Lwt.t
+            (s2 : 'b FakeReact.S.t Value.t) : 'c t
         =
         let s1' = Value.local s1 and s2' = Value.local s2 in
-        let* server_result =
+        let server_result =
           (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
         in
         let synced = FakeReact.S.(synced s1' && synced s2') in
-        Lwt.return
-          (Value.create
-             (fst (FakeReact.S.create ~synced server_result))
-             [%client.unsafe
-               (React.S.Lwt.l2_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s1
-                  ~%s2
-                : 'c FakeReact.S.t)])
+        Value.create
+          (fst (FakeReact.S.create ~synced server_result))
+          [%client.unsafe
+            (React.S.Lwt.l2_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s1 ~%s2
+             : 'c FakeReact.S.t)]
 
       let l3_s
             ?eq
-            (f : ('a -> 'b -> 'c -> 'd Lwt.t) Value.t)
+            (f : ('a -> 'b -> 'c -> 'd) Value.t)
             (s1 : 'a FakeReact.S.t Value.t)
             (s2 : 'b FakeReact.S.t Value.t)
-            (s3 : 'c FakeReact.S.t Value.t) : 'd t Lwt.t
+            (s3 : 'c FakeReact.S.t Value.t) : 'd t
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
         and s3' = Value.local s3 in
-        let* server_result =
+        let server_result =
           (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
             (FakeReact.S.value s3')
         in
         let synced = FakeReact.S.(synced s1' && synced s2' && synced s3') in
-        Lwt.return
-          (Value.create
-             (fst (FakeReact.S.create ~synced server_result))
-             [%client.unsafe
-               (React.S.Lwt.l3_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1
-                  ~%s2 ~%s3
-                : 'd FakeReact.S.t)])
+        Value.create
+          (fst (FakeReact.S.create ~synced server_result))
+          [%client.unsafe
+            (React.S.Lwt.l3_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1 ~%s2
+               ~%s3
+             : 'd FakeReact.S.t)]
 
       let l4_s
             ?eq
-            (f : ('a -> 'b -> 'c -> 'd -> 'e Lwt.t) Value.t)
+            (f : ('a -> 'b -> 'c -> 'd -> 'e) Value.t)
             (s1 : 'a FakeReact.S.t Value.t)
             (s2 : 'b FakeReact.S.t Value.t)
             (s3 : 'c FakeReact.S.t Value.t)
-            (s4 : 'd FakeReact.S.t Value.t) : 'e t Lwt.t
+            (s4 : 'd FakeReact.S.t Value.t) : 'e t
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
         and s3' = Value.local s3
         and s4' = Value.local s4 in
-        let* server_result =
+        let server_result =
           (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
             (FakeReact.S.value s3') (FakeReact.S.value s4')
         in
         let synced =
           FakeReact.S.(synced s1' && synced s2' && synced s3' && synced s4')
         in
-        Lwt.return
-          (Value.create
-             (fst (FakeReact.S.create ~synced server_result))
-             [%client.unsafe
-               (React.S.Lwt.l4_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1
-                  ~%s2 ~%s3 ~%s4
-                : 'e FakeReact.S.t)])
+        Value.create
+          (fst (FakeReact.S.create ~synced server_result))
+          [%client.unsafe
+            (React.S.Lwt.l4_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1 ~%s2
+               ~%s3 ~%s4
+             : 'e FakeReact.S.t)]
 
       let l5_s
             ?eq
-            (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f Lwt.t) Value.t)
+            (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f) Value.t)
             (s1 : 'a FakeReact.S.t Value.t)
             (s2 : 'b FakeReact.S.t Value.t)
             (s3 : 'c FakeReact.S.t Value.t)
             (s4 : 'd FakeReact.S.t Value.t)
-            (s5 : 'e FakeReact.S.t Value.t) : 'f t Lwt.t
+            (s5 : 'e FakeReact.S.t Value.t) : 'f t
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
         and s3' = Value.local s3
         and s4' = Value.local s4
         and s5' = Value.local s5 in
-        let* server_result =
+        let server_result =
           (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
             (FakeReact.S.value s3') (FakeReact.S.value s4')
             (FakeReact.S.value s5')
@@ -603,23 +607,22 @@ module React = struct
           FakeReact.S.(
             synced s1' && synced s2' && synced s3' && synced s4' && synced s5')
         in
-        Lwt.return
-          (Value.create
-             (fst (FakeReact.S.create ~synced server_result))
-             [%client.unsafe
-               (React.S.Lwt.l5_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1
-                  ~%s2 ~%s3 ~%s4 ~%s5
-                : 'f FakeReact.S.t)])
+        Value.create
+          (fst (FakeReact.S.create ~synced server_result))
+          [%client.unsafe
+            (React.S.Lwt.l5_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1 ~%s2
+               ~%s3 ~%s4 ~%s5
+             : 'f FakeReact.S.t)]
 
       let l6_s
             ?eq
-            (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g Lwt.t) Value.t)
+            (f : ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g) Value.t)
             (s1 : 'a FakeReact.S.t Value.t)
             (s2 : 'b FakeReact.S.t Value.t)
             (s3 : 'c FakeReact.S.t Value.t)
             (s4 : 'd FakeReact.S.t Value.t)
             (s5 : 'e FakeReact.S.t Value.t)
-            (s6 : 'f FakeReact.S.t Value.t) : 'g t Lwt.t
+            (s6 : 'f FakeReact.S.t Value.t) : 'g t
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
@@ -627,7 +630,7 @@ module React = struct
         and s4' = Value.local s4
         and s5' = Value.local s5
         and s6' = Value.local s6 in
-        let* server_result =
+        let server_result =
           (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
             (FakeReact.S.value s3') (FakeReact.S.value s4')
             (FakeReact.S.value s5') (FakeReact.S.value s6')
@@ -637,36 +640,34 @@ module React = struct
             synced s1' && synced s2' && synced s3' && synced s4' && synced s5'
             && synced s6')
         in
-        Lwt.return
-          (Value.create
-             (fst (FakeReact.S.create ~synced server_result))
-             [%client.unsafe
-               (React.S.Lwt.l6_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1
-                  ~%s2 ~%s3 ~%s4 ~%s5 ~%s6
-                : 'g FakeReact.S.t)])
+        Value.create
+          (fst (FakeReact.S.create ~synced server_result))
+          [%client.unsafe
+            (React.S.Lwt.l6_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1 ~%s2
+               ~%s3 ~%s4 ~%s5 ~%s6
+             : 'g FakeReact.S.t)]
 
       let merge_s
             ?eq
-            (f : ('a -> 'b -> 'a Lwt.t) Value.t)
+            (f : ('a -> 'b -> 'a) Value.t)
             (acc : 'a)
-            (l : 'b FakeReact.S.t Value.t list) : 'a t Lwt.t
+            (l : 'b FakeReact.S.t Value.t list) : 'a t
         =
-        let* server_result, synced =
+        let server_result, synced =
           let f (acc, _acc_b) v =
             let v = Value.local v and f = Value.local f in
-            let* acc = f acc (FakeReact.S.value v) in
+            let acc = f acc (FakeReact.S.value v) in
             let acc_b = FakeReact.S.synced v in
-            Lwt.return (acc, acc_b)
+            acc, acc_b
           in
-          Lwt_list.fold_left_s f (acc, true) l
+          List.fold_left f (acc, true) l
         in
-        Lwt.return
-          (Value.create
-             (fst (FakeReact.S.create ~synced server_result))
-             [%client.unsafe
-               (React.S.Lwt.merge_s_init ~init:~%server_result ?eq:~%eq ~%f
-                  ~%acc ~%l
-                : 'a FakeReact.S.t)])
+        Value.create
+          (fst (FakeReact.S.create ~synced server_result))
+          [%client.unsafe
+            (React.S.Lwt.merge_s_init ~init:~%server_result ?eq:~%eq ~%f ~%acc
+               ~%l
+             : 'a FakeReact.S.t)]
     end
   end
 end
@@ -764,19 +765,18 @@ module ReactiveData = struct
 
     module Lwt = struct
       let map_p
-            (f : ('a -> 'b Lwt.t) Value.t)
-            (l : 'a FakeReactiveData.RList.t Value.t) : 'b t Lwt.t
+            (f : ('a -> 'b) Value.t)
+            (l : 'a FakeReactiveData.RList.t Value.t) : 'b t
         =
         let l' = Value.local l in
-        let* server_result =
-          Lwt_list.map_p (Value.local f) (FakeReactiveData.RList.value l')
+        let server_result =
+          Fiber.List.map (Value.local f) (FakeReactiveData.RList.value l')
         in
         let synced = FakeReactiveData.RList.synced l' in
-        Lwt.return
-          (Value.create
-             (fst (FakeReactiveData.RList.create ~synced server_result))
-             [%client.unsafe
-               ReactiveData.RList.Lwt.map_p_init ~init:~%server_result ~%f ~%l])
+        Value.create
+          (fst (FakeReactiveData.RList.create ~synced server_result))
+          [%client.unsafe
+            ReactiveData.RList.Lwt.map_p_init ~init:~%server_result ~%f ~%l]
     end
   end
 end]
diff --git a/src/lib/eliom_shared.server.mli b/src/lib/eliom_shared.server.mli
index 12e3d450f0..7f28dfe65e 100644
--- a/src/lib/eliom_shared.server.mli
+++ b/src/lib/eliom_shared.server.mli
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2014
@@ -32,7 +34,7 @@
 val to_signal :
    init:'a
   -> ?eq:('a -> 'a -> bool)
-  -> 'a React.S.t Lwt.t
+  -> 'a React.S.t Promise.t
   -> 'a React.S.t
 (** [to_signal ~init s] converts the Lwt-wrapped signal [s] into a
     regular signal with initial value [init]. *)
diff --git a/src/lib/eliom_shared_sigs.shared.mli b/src/lib/eliom_shared_sigs.shared.mli
index c3fe877dd4..8f73f1718c 100644
--- a/src/lib/eliom_shared_sigs.shared.mli
+++ b/src/lib/eliom_shared_sigs.shared.mli
@@ -111,63 +111,59 @@ module type S = sig
 
   (** Cooperative versions of the React operators *)
   module Lwt : sig
-    val map_s :
-       ?eq:('b -> 'b -> bool) sv
-      -> ('a -> 'b Lwt.t) sv
-      -> 'a t
-      -> 'b t Lwt.t
+    val map_s : ?eq:('b -> 'b -> bool) sv -> ('a -> 'b) sv -> 'a t -> 'b t
 
     val l2_s :
        ?eq:('c -> 'c -> bool) sv
-      -> ('a -> 'b -> 'c Lwt.t) sv
+      -> ('a -> 'b -> 'c) sv
       -> 'a t
       -> 'b t
-      -> 'c t Lwt.t
+      -> 'c t
 
     val l3_s :
        ?eq:('d -> 'd -> bool) sv
-      -> ('a -> 'b -> 'c -> 'd Lwt.t) sv
+      -> ('a -> 'b -> 'c -> 'd) sv
       -> 'a t
       -> 'b t
       -> 'c t
-      -> 'd t Lwt.t
+      -> 'd t
 
     val l4_s :
        ?eq:('e -> 'e -> bool) sv
-      -> ('a -> 'b -> 'c -> 'd -> 'e Lwt.t) sv
+      -> ('a -> 'b -> 'c -> 'd -> 'e) sv
       -> 'a t
       -> 'b t
       -> 'c t
       -> 'd t
-      -> 'e t Lwt.t
+      -> 'e t
 
     val l5_s :
        ?eq:('f -> 'f -> bool) sv
-      -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f Lwt.t) sv
+      -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f) sv
       -> 'a t
       -> 'b t
       -> 'c t
       -> 'd t
       -> 'e t
-      -> 'f t Lwt.t
+      -> 'f t
 
     val l6_s :
        ?eq:('g -> 'g -> bool) sv
-      -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g Lwt.t) sv
+      -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g) sv
       -> 'a t
       -> 'b t
       -> 'c t
       -> 'd t
       -> 'e t
       -> 'f t
-      -> 'g t Lwt.t
+      -> 'g t
 
     val merge_s :
        ?eq:('a -> 'a -> bool) sv
-      -> ('a -> 'b -> 'a Lwt.t) sv
+      -> ('a -> 'b -> 'a) sv
       -> 'a
       -> 'b t list
-      -> 'a t Lwt.t
+      -> 'a t
   end
 end
 
@@ -217,6 +213,6 @@ module type RLIST = sig
 
   (** Cooperative versions of the ReactiveData operators *)
   module Lwt : sig
-    val map_p : ('a -> 'b Lwt.t) sv -> 'a t -> 'b t Lwt.t
+    val map_p : ('a -> 'b) sv -> 'a t -> 'b t
   end
 end
diff --git a/src/lib/eliom_state.server.ml b/src/lib/eliom_state.server.ml
index f4afdbaef4..8bab520107 100644
--- a/src/lib/eliom_state.server.ml
+++ b/src/lib/eliom_state.server.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -20,7 +20,6 @@ open Lwt.Syntax
 *)
 
 open Eliom_lib
-open Lwt
 
 (* Expired session? *)
 type state_status = Alive_state | Empty_state | Expired_state
@@ -48,15 +47,16 @@ let volatile_data_state_status ~scope ?secure () =
 
 let persistent_data_state_status ~scope ?secure () =
   let cookie_scope = Eliom_common.cookie_scope_of_user_scope scope in
-  catch
-    (fun () ->
-       Eliommod_persess.find_persistent_cookie_only ~cookie_scope
-         ~secure_o:secure ()
-       >>= fun _ -> return Alive_state)
-    (function
-      | Not_found -> Lwt.return Empty_state
-      | Eliom_common.Eliom_Session_expired -> Lwt.return Expired_state
-      | e -> fail e)
+  try
+    let _ =
+      Eliommod_persess.find_persistent_cookie_only ~cookie_scope
+        ~secure_o:secure ()
+    in
+    Alive_state
+  with
+  | Not_found -> Empty_state
+  | Eliom_common.Eliom_Session_expired -> Expired_state
+  | e -> raise e
 
 (************)
 (*
@@ -261,54 +261,44 @@ let get_volatile_data_state_timeout ~cookie_scope ?secure () =
     Eliommod_timeouts.get_global ~kind:`Data ~cookie_scope ~secure sitedata
 
 let set_persistent_data_state_timeout ~cookie_scope ?secure t =
-  let* c =
+  let c =
     Eliommod_persess.find_or_create_persistent_cookie ~cookie_scope
       ~secure_o:secure ()
   in
   let tor = c.Eliom_common.pc_timeout in
-  return
-    (match t with
-    | None -> tor := Eliom_common.TNone
-    | Some t -> tor := Eliom_common.TSome t)
+  match t with
+  | None -> tor := Eliom_common.TNone
+  | Some t -> tor := Eliom_common.TSome t
 
 let unset_persistent_data_state_timeout ~cookie_scope ?secure () =
-  Lwt.catch
-    (fun () ->
-       let* c =
-         Eliommod_persess.find_persistent_cookie_only ~cookie_scope
-           ~secure_o:secure ()
-       in
-       let tor = c.Eliom_common.pc_timeout in
-       tor := Eliom_common.TGlobal;
-       return_unit)
-    (function
-      | Not_found | Eliom_common.Eliom_Session_expired -> return_unit
-      | exc -> Lwt.reraise exc)
+  try
+    let c =
+      Eliommod_persess.find_persistent_cookie_only ~cookie_scope
+        ~secure_o:secure ()
+    in
+    let tor = c.Eliom_common.pc_timeout in
+    tor := Eliom_common.TGlobal
+  with Not_found | Eliom_common.Eliom_Session_expired -> ()
 
 let get_persistent_data_state_timeout ~cookie_scope ?secure () =
   let sp = Eliom_common.get_sp () in
   let sitedata = Eliom_request_info.get_sitedata_sp ~sp in
   let secure = Eliom_common.get_secure ~secure_o:secure ~sitedata () in
-  Lwt.catch
-    (fun () ->
-       let* c =
-         Eliommod_persess.find_persistent_cookie_only ~cookie_scope
-           ~secure_o:(Some secure) ~sp ()
-       in
-       let tor = c.Eliom_common.pc_timeout in
-       return
-         (match !tor with
-         | Eliom_common.TGlobal ->
-             Eliommod_timeouts.get_global ~kind:`Persistent ~cookie_scope
-               ~secure sitedata
-         | Eliom_common.TNone -> None
-         | Eliom_common.TSome t -> Some t))
-    (function
-      | Not_found | Eliom_common.Eliom_Session_expired ->
-          return
-            (Eliommod_timeouts.get_global ~kind:`Persistent ~cookie_scope
-               ~secure sitedata)
-      | exc -> Lwt.reraise exc)
+  try
+    let c =
+      Eliommod_persess.find_persistent_cookie_only ~cookie_scope
+        ~secure_o:(Some secure) ~sp ()
+    in
+    let tor = c.Eliom_common.pc_timeout in
+    match !tor with
+    | Eliom_common.TGlobal ->
+        Eliommod_timeouts.get_global ~kind:`Persistent ~cookie_scope ~secure
+          sitedata
+    | Eliom_common.TNone -> None
+    | Eliom_common.TSome t -> Some t
+  with Not_found | Eliom_common.Eliom_Session_expired ->
+    Eliommod_timeouts.get_global ~kind:`Persistent ~cookie_scope ~secure
+      sitedata
 
 (* Preventing memory leaks: we must close empty sessions *)
 
@@ -396,7 +386,7 @@ let rec close_volatile_state_if_empty ~scope ?secure () =
           ()
   with Not_found -> ()
 
-let close_persistent_state_if_empty ~scope:_ ?secure:_ () = Lwt.return_unit
+let close_persistent_state_if_empty ~scope:_ ?secure:_ () = ()
 (*VVV Can we implement this function? *)
 
 (* session groups *)
@@ -585,7 +575,7 @@ let set_persistent_data_session_group
   =
   let sp = Eliom_common.get_sp () in
   let sitedata = Eliom_request_info.get_sitedata_sp ~sp in
-  let* c =
+  let c =
     Eliommod_persess.find_or_create_persistent_cookie
       ~cookie_scope:(scope :> Eliom_common.cookie_scope)
       ~secure_o:secure ~sp ()
@@ -597,21 +587,20 @@ let set_persistent_data_session_group
       (Some n)
   in
   let grp = c.Eliom_common.pc_session_group in
-  let* l =
+  let l =
     Eliommod_sessiongroups.Pers.move sitedata ?set_max
       (fst sitedata.Eliom_common.max_persistent_data_sessions_per_group)
       Eliom_common.(Hashed_cookies.to_string c.pc_hvalue)
       !grp n
   in
-  let* () =
-    Lwt_list.iter_p
+  let () =
+    Fiber.List.iter
       (Eliommod_persess.close_persistent_state2
          ~scope:(scope :> Eliom_common.user_scope)
          sitedata None)
       l
   in
-  grp := n;
-  Lwt.return_unit
+  grp := n
 
 let unset_persistent_data_session_group
       ?(scope = Eliom_common.default_session_scope)
@@ -620,49 +609,42 @@ let unset_persistent_data_session_group
   =
   let sp = Eliom_common.get_sp () in
   let sitedata = Eliom_request_info.get_sitedata_sp ~sp in
-  Lwt.catch
-    (fun () ->
-       let* c =
-         Eliommod_persess.find_persistent_cookie_only
-           ~cookie_scope:(scope :> Eliom_common.cookie_scope)
-           ~secure_o:secure ~sp ()
-       in
-       let grp = c.Eliom_common.pc_session_group in
-       let* () =
-         Eliommod_sessiongroups.Pers.remove sitedata
-           Eliom_common.(Hashed_cookies.to_string c.pc_hvalue)
-           !grp
-       in
-       grp := None;
-       close_persistent_state_if_empty
-         ~scope:(scope :> Eliom_common.user_scope)
-         ?secure ())
-    (function
-      | Not_found | Eliom_common.Eliom_Session_expired -> Lwt.return_unit
-      | exc -> Lwt.reraise exc)
+  try
+    let c =
+      Eliommod_persess.find_persistent_cookie_only
+        ~cookie_scope:(scope :> Eliom_common.cookie_scope)
+        ~secure_o:secure ~sp ()
+    in
+    let grp = c.Eliom_common.pc_session_group in
+    let () =
+      Eliommod_sessiongroups.Pers.remove sitedata
+        Eliom_common.(Hashed_cookies.to_string c.pc_hvalue)
+        !grp
+    in
+    grp := None;
+    close_persistent_state_if_empty
+      ~scope:(scope :> Eliom_common.user_scope)
+      ?secure ()
+  with Not_found | Eliom_common.Eliom_Session_expired -> ()
 
 let get_persistent_data_session_group
       ?(scope = Eliom_common.default_session_scope)
       ?secure
       ()
   =
-  Lwt.catch
-    (fun () ->
-       let* c =
-         Eliommod_persess.find_persistent_cookie_only
-           ~cookie_scope:(scope :> Eliom_common.cookie_scope)
-           ~secure_o:secure ()
-       in
-       Lwt.return
-         (match !(c.Eliom_common.pc_session_group) with
-         | None -> None
-         | Some v -> (
-           match Eliommod_sessiongroups.getperssessgrp v with
-           | _, _, Left s -> Some s
-           | _ -> None)))
-    (function
-      | Not_found | Eliom_common.Eliom_Session_expired -> Lwt.return_none
-      | exc -> Lwt.reraise exc)
+  try
+    let c =
+      Eliommod_persess.find_persistent_cookie_only
+        ~cookie_scope:(scope :> Eliom_common.cookie_scope)
+        ~secure_o:secure ()
+    in
+    match !(c.Eliom_common.pc_session_group) with
+    | None -> None
+    | Some v -> (
+      match Eliommod_sessiongroups.getperssessgrp v with
+      | _, _, Left s -> Some s
+      | _ -> None)
+  with Not_found | Eliom_common.Eliom_Session_expired -> None
 
 (* max *)
 let set_default_max_service_sessions_per_group ?(override_configfile = false) n =
@@ -853,15 +835,14 @@ let set_volatile_data_cookie_exp_date ~cookie_scope ?secure t =
   | Some t -> exp := Eliom_common.CESome t
 
 let set_persistent_data_cookie_exp_date ~cookie_scope ?secure t =
-  let* c =
+  let c =
     Eliommod_persess.find_or_create_persistent_cookie ~cookie_scope
       ~secure_o:secure ()
   in
   let exp = c.Eliom_common.pc_cookie_exp in
-  return
-    (match t with
-    | None -> exp := Eliom_common.CEBrowser
-    | Some t -> exp := Eliom_common.CESome t)
+  match t with
+  | None -> exp := Eliom_common.CEBrowser
+  | Some t -> exp := Eliom_common.CESome t
 
 (* *)
 let get_global_table () =
@@ -913,11 +894,11 @@ module Ocsipersist = Eliom_common.Ocsipersist.Polymorphic
 type 'a persistent_table =
   Eliom_common.user_scope * bool * (int64 * 'a) Ocsipersist.table
 
-let create_persistent_table ~scope ?secure name : 'a persistent_table Lwt.t =
+let create_persistent_table ~scope ?secure name : 'a persistent_table =
   let sitedata = Eliom_request_info.find_sitedata "create_persistent_table" in
   let secure = Eliom_common.get_secure ~secure_o:secure ~sitedata () in
-  Eliom_common.Persistent_tables.create name >>= fun t ->
-  Lwt.return (scope, secure, t)
+  let t = Eliom_common.Persistent_tables.create name in
+  scope, secure, t
 
 let get_p_table_key_
       ~table:(scope, secure, table)
@@ -926,59 +907,57 @@ let get_p_table_key_
         -> secure_o:bool option
         -> ?sp:Eliom_common.server_params
         -> unit
-        -> Eliom_common.one_persistent_cookie_info Lwt.t)
+        -> Eliom_common.one_persistent_cookie_info)
   =
   let get_cookie () =
     let cookie_scope = Eliom_common.cookie_scope_of_user_scope scope in
-    let* c = find_cookie ~cookie_scope ~secure_o:(Some secure) () in
-    Lwt.return Eliom_common.(Hashed_cookies.to_string c.pc_hvalue)
+    let c = find_cookie ~cookie_scope ~secure_o:(Some secure) () in
+    Eliom_common.(Hashed_cookies.to_string c.pc_hvalue)
   in
-  let* key =
+  let key =
     match scope with
-    | `Session_group state_name ->
-        Lwt.bind
-          (get_persistent_data_session_group ~scope:(`Session state_name)
-             ~secure ())
-          (function
-            | Some a -> Lwt.return a
-            | None ->
-                (* No session group. We use the session cookie as key. *)
-                get_cookie ())
+    | `Session_group state_name -> (
+      match
+        get_persistent_data_session_group ~scope:(`Session state_name) ~secure
+          ()
+      with
+      | Some a -> a
+      | None ->
+          (* No session group. We use the session cookie as key. *)
+          get_cookie ())
     | _ -> get_cookie ()
   in
-  Lwt.return (table, key)
+  table, key
 
 let get_persistent_data ~table () =
-  catch
-    (fun () ->
-       get_p_table_key_ ~table Eliommod_persess.find_persistent_cookie_only
-       >>= fun (table, key) ->
-       Ocsipersist.find table key >>= fun (_, v) -> Lwt.return (Data v))
-    (function
-      | Eliom_common.Eliom_Session_expired -> return Data_session_expired
-      | Not_found -> return No_data
-      | e -> fail e)
+  try
+    let table, key =
+      get_p_table_key_ ~table Eliommod_persess.find_persistent_cookie_only
+    in
+    let _, v = Ocsipersist.find table key in
+    Data v
+  with
+  | Eliom_common.Eliom_Session_expired -> Data_session_expired
+  | Not_found -> No_data
+  | e -> raise e
 
 let set_persistent_data ~table value =
   let f__ ~cookie_scope ~secure_o ?sp () =
     Eliommod_persess.find_or_create_persistent_cookie ~cookie_scope ~secure_o
       ?sp ()
   in
-  get_p_table_key_ ~table f__ >>= fun (table, key) ->
+  let table, key = get_p_table_key_ ~table f__ in
   Ocsipersist.add table key (Int64.zero, value)
 
 let remove_persistent_data ~table () =
-  Lwt.catch
-    (fun () ->
-       let scope, secure, _ = table in
-       let* table, key =
-         get_p_table_key_ ~table Eliommod_persess.find_persistent_cookie_only
-       in
-       let* () = Ocsipersist.remove table key in
-       close_persistent_state_if_empty ~scope ~secure ())
-    (function
-      | Not_found | Eliom_common.Eliom_Session_expired -> return_unit
-      | exc -> Lwt.reraise exc)
+  try
+    let scope, secure, _ = table in
+    let table, key =
+      get_p_table_key_ ~table Eliommod_persess.find_persistent_cookie_only
+    in
+    let () = Ocsipersist.remove table key in
+    close_persistent_state_if_empty ~scope ~secure ()
+  with Not_found | Eliom_common.Eliom_Session_expired -> ()
 
 (*****************************************************************************)
 (** {2 session data in memory} *)
@@ -1069,8 +1048,7 @@ let remove_volatile_data ~table () =
 let discard_persistent_data ~scope ?secure () =
   match secure with
   | None ->
-      Eliommod_persess.close_persistent_state ~scope ~secure_o:(Some true) ()
-      >>= fun () ->
+      Eliommod_persess.close_persistent_state ~scope ~secure_o:(Some true) ();
       Eliommod_persess.close_persistent_state ~scope ~secure_o:(Some false) ()
   | _ -> Eliommod_persess.close_persistent_state ~scope ~secure_o:secure ()
 
@@ -1090,7 +1068,7 @@ let discard_volatile_data ~scope ?secure () =
 
 let discard_request_data () =
   let table = Eliom_request_info.get_request_cache () in
-  Polytables.clear ~table; Lwt.return_unit
+  Polytables.clear ~table
 
 let discard_data ?persistent ~scope ?secure () =
   match scope with
@@ -1101,7 +1079,7 @@ let discard_data ?persistent ~scope ?secure () =
       | _ -> ());
       match persistent with
       | None | Some true -> discard_persistent_data ~scope ?secure ()
-      | _ -> Lwt.return_unit)
+      | _ -> ())
 
 let discard ~scope ?secure () =
   match scope with
@@ -1113,12 +1091,12 @@ let discard ~scope ?secure () =
 
 let discard_all_scopes ?secure () =
   let discard_name scope_hierarchy =
-    let* () = discard ?secure ~scope:(`Session_group scope_hierarchy) () in
-    let* () = discard ?secure ~scope:(`Session scope_hierarchy) () in
+    let () = discard ?secure ~scope:(`Session_group scope_hierarchy) () in
+    let () = discard ?secure ~scope:(`Session scope_hierarchy) () in
     discard ?secure ~scope:(`Client_process scope_hierarchy) ()
   in
-  let* () = discard_request_data () in
-  Lwt_list.iter_p discard_name (Eliom_common.list_scope_hierarchies ())
+  let () = discard_request_data () in
+  Fiber.List.iter discard_name (Eliom_common.list_scope_hierarchies ())
 
 let discard_all_volatile_data ~scope ?secure () =
   let sitedata = Eliom_request_info.find_sitedata "discard_all_volatile_data" in
@@ -1135,14 +1113,14 @@ let discard_all_persistent_data ~scope ?secure () =
 (*VVV missing: scope group *)
 
 let discard_all_data ?persistent ~scope ?secure () =
-  let* () =
+  let () =
     match persistent with
     | None | Some false -> discard_all_volatile_data ~scope ?secure ()
-    | _ -> Lwt.return_unit
+    | _ -> ()
   in
   match persistent with
   | None | Some true -> discard_all_persistent_data ~scope ?secure ()
-  | _ -> Lwt.return_unit
+  | _ -> ()
 
 let discard_all_services ~scope ?secure () =
   let sitedata =
@@ -1153,17 +1131,17 @@ let discard_all_services ~scope ?secure () =
 (*VVV missing: scope group *)
 
 let discard_all ~scope ?secure () =
-  let* () = discard_all_services ~scope ?secure () in
+  let () = discard_all_services ~scope ?secure () in
   discard_all_data ~scope ?secure ()
 
 let discard_everything () =
   let discard_name scope_hierarchy =
-    let* () = discard_all ~scope:(`Session_group scope_hierarchy) () in
-    let* () = discard_all ~scope:(`Session scope_hierarchy) () in
+    let () = discard_all ~scope:(`Session_group scope_hierarchy) () in
+    let () = discard_all ~scope:(`Session scope_hierarchy) () in
     discard_all ~scope:(`Client_process scope_hierarchy) ()
   in
-  let* () = discard_request_data () in
-  Lwt_list.iter_p discard_name (Eliom_common.list_scope_hierarchies ())
+  let () = discard_request_data () in
+  Fiber.List.iter discard_name (Eliom_common.list_scope_hierarchies ())
 
 (*****************************************************************************)
 (* Administration *)
@@ -1248,22 +1226,18 @@ module Ext = struct
     =
     let scope = (scope :> Eliom_common.user_scope) in
     match scope with
-    | `Session_group h ->
-        Lwt.bind
-          (get_persistent_data_session_group ~scope:(`Session h) ?secure ())
-          (function
-            | Some g ->
-                persistent_data_group_state ~scope:(`Session_group h) g
-                |> Lwt.return
-            | None -> Lwt.fail Not_found)
+    | `Session_group h -> (
+      match
+        get_persistent_data_session_group ~scope:(`Session h) ?secure ()
+      with
+      | Some g -> persistent_data_group_state ~scope:(`Session_group h) g
+      | None -> raise Not_found)
     | #Eliom_common.cookie_scope as cookie_scope ->
-        Eliommod_persess.find_or_create_persistent_cookie ~secure_o:secure
-          ~cookie_scope ()
-        >>= fun cookie ->
-        Lwt.return
-          ( scope
-          , `Pers
-          , Eliom_common.(Hashed_cookies.to_string cookie.pc_hvalue) )
+        let cookie =
+          Eliommod_persess.find_or_create_persistent_cookie ~secure_o:secure
+            ~cookie_scope ()
+        in
+        scope, `Pers, Eliom_common.(Hashed_cookies.to_string cookie.pc_hvalue)
 
   let current_service_state
         ?secure
@@ -1308,8 +1282,8 @@ module Ext = struct
   let get_persistent_cookie_info
         ((_, _, cookie) : ([< Eliom_common.cookie_level], [`Pers]) state)
     =
-    Eliommod_cookies.Persistent_cookies.Cookies.find cookie >>= fun v ->
-    Lwt.return (cookie, v)
+    let v = Eliommod_cookies.Persistent_cookies.Cookies.find cookie in
+    cookie, v
 
   let discard_state
         ?(sitedata =
@@ -1321,22 +1295,20 @@ module Ext = struct
       Eliom_common.get_site_dir_string sitedata, `Session, Left n
     in
     match state with
-    | `Session_group _, `Data, group_name ->
-        (match
-           Eliommod_sessiongroups.Data.find_node_in_group_of_groups
-             (make_sessgrp group_name)
-         with
-        | Some node -> Eliommod_sessiongroups.Data.remove node
-        | None -> ());
-        Lwt.return_unit
-    | `Session_group _, `Service, group_name ->
-        (match
-           Eliommod_sessiongroups.Serv.find_node_in_group_of_groups
-             (make_sessgrp group_name)
-         with
-        | Some (_, node) -> Eliommod_sessiongroups.Serv.remove node
-        | None -> ());
-        Lwt.return_unit
+    | `Session_group _, `Data, group_name -> (
+      match
+        Eliommod_sessiongroups.Data.find_node_in_group_of_groups
+          (make_sessgrp group_name)
+      with
+      | Some node -> Eliommod_sessiongroups.Data.remove node
+      | None -> ())
+    | `Session_group _, `Service, group_name -> (
+      match
+        Eliommod_sessiongroups.Serv.find_node_in_group_of_groups
+          (make_sessgrp group_name)
+      with
+      | Some (_, node) -> Eliommod_sessiongroups.Serv.remove node
+      | None -> ())
     | `Session_group _, `Pers, group_name ->
         let sgr_o =
           Eliom_common.make_persistent_full_group_name ~cookie_level:`Session
@@ -1352,7 +1324,7 @@ module Ext = struct
           | _, {Eliom_common.Service_cookie.session_group_node; _} ->
               Eliommod_sessiongroups.Serv.remove session_group_node
         in
-        Lwt.return_unit
+        ()
     | _, `Data, _cookie ->
         let () =
           match get_volatile_data_cookie_info ~sitedata state with
@@ -1360,19 +1332,15 @@ module Ext = struct
           | _, {Eliom_common.Data_cookie.session_group_node; _} ->
               Eliommod_sessiongroups.Data.remove session_group_node
         in
-        Lwt.return_unit
-    | _, `Pers, _cookie ->
-        Lwt.try_bind
-          (fun () -> get_persistent_cookie_info state)
-          (function
-            | cookie, {Eliommod_cookies.full_state_name; session_group; _} ->
-                let scope = full_state_name.Eliom_common.user_scope in
-                let cookie_level =
-                  Eliom_common.cookie_level_of_user_scope scope
-                in
-                Eliommod_sessiongroups.Pers.close_persistent_session2
-                  ~cookie_level sitedata session_group cookie)
-          (function Not_found -> Lwt.return_unit | exc -> Lwt.reraise exc)
+        ()
+    | _, `Pers, _cookie -> (
+      match get_persistent_cookie_info state with
+      | cookie, {Eliommod_cookies.full_state_name; session_group; _} ->
+          let scope = full_state_name.Eliom_common.user_scope in
+          let cookie_level = Eliom_common.cookie_level_of_user_scope scope in
+          Eliommod_sessiongroups.Pers.close_persistent_session2 ~cookie_level
+            sitedata session_group cookie
+      | exception Not_found -> ())
   (*VVV!!! est-ce que session_group est fullsessgrp ? *)
 
   let fold_sub_states_aux_aux
@@ -1435,8 +1403,8 @@ module Ext = struct
 
   (** Fold over the snapshot of a Dlist. *)
   let dlist_lwt_fold f acc dlist =
-    Ocsigen_cache.Dlist.fold (fun acc x -> x :: acc) [] dlist
-    |> List.rev |> Lwt_list.fold_left_s f acc
+    List.fold_left f acc
+      (Ocsigen_cache.Dlist.fold (fun acc x -> x :: acc) [] dlist |> List.rev)
 
   let fold_sub_states ?sitedata ~state f e =
     let ((sitedata, sub_states_level, id, f) as a) =
@@ -1444,13 +1412,15 @@ module Ext = struct
     in
     match state with
     | _, `Pers, _ ->
-        Eliommod_sessiongroups.Pers.find
-          (Eliom_common.make_persistent_full_group_name
-             ~cookie_level:sub_states_level
-             (Eliom_common.get_site_dir_string sitedata)
-             (Some id))
-        >>= fun l -> Lwt_list.fold_left_s f e l
-    | _ -> fold_sub_states_aux dlist_lwt_fold Lwt.return a e state
+        let l =
+          Eliommod_sessiongroups.Pers.find
+            (Eliom_common.make_persistent_full_group_name
+               ~cookie_level:sub_states_level
+               (Eliom_common.get_site_dir_string sitedata)
+               (Some id))
+        in
+        List.fold_left f e l
+    | _ -> fold_sub_states_aux dlist_lwt_fold (fun x1 -> x1) a e state
 
   let iter_volatile_sub_states ?sitedata ~state f =
     fold_volatile_sub_states ?sitedata ~state (fun () -> f) ()
@@ -1470,8 +1440,7 @@ module Ext = struct
     let check_scopes table_scope state_scope =
       if table_scope <> state_scope then raise Wrong_scope
 
-    let lwt_check_scopes a b =
-      try check_scopes a b; Lwt.return_unit with e -> Lwt.fail e
+    let lwt_check_scopes a b = try check_scopes a b with e -> raise e
 
     (*VVV Does not work with volatile group data *)
     let get_volatile_data
@@ -1485,8 +1454,9 @@ module Ext = struct
           ~state:((state_scope, _, cookie) : ('s, [`Pers]) state)
           ~table:((table_scope, _, t) : 'a persistent_table)
       =
-      lwt_check_scopes table_scope state_scope >>= fun () ->
-      Ocsipersist.find t cookie >>= fun (_, a) -> Lwt.return a
+      lwt_check_scopes table_scope state_scope;
+      let _, a = Ocsipersist.find t cookie in
+      a
 
     let set_volatile_data
           ~state:((state_scope, _, cookie) : ('s, [`Data]) state)
@@ -1501,7 +1471,7 @@ module Ext = struct
           ~table:((table_scope, _, t) : 'a persistent_table)
           value
       =
-      lwt_check_scopes table_scope state_scope >>= fun () ->
+      lwt_check_scopes table_scope state_scope;
       Ocsipersist.add t cookie (Int64.zero, value)
 
     let remove_volatile_data
@@ -1515,7 +1485,7 @@ module Ext = struct
           ~state:((state_scope, _, cookie) : ('s, [`Pers]) state)
           ~table:((table_scope, _, t) : 'a persistent_table)
       =
-      lwt_check_scopes table_scope state_scope >>= fun () ->
+      lwt_check_scopes table_scope state_scope;
       Ocsipersist.remove t cookie
   end
 
@@ -1558,8 +1528,7 @@ module Ext = struct
 
   let unset_persistent_data_cookie_timeout ~cookie:(c, cookie) =
     Eliommod_cookies.Persistent_cookies.Cookies.add c
-      {cookie with Eliommod_cookies.timeout = TGlobal}
-    >>= fun () ->
+      {cookie with Eliommod_cookies.timeout = TGlobal};
     let {Eliommod_cookies.expiry; _} = cookie in
     Eliommod_cookies.Persistent_cookies.Expiry_dates.remove_cookie expiry c
 
@@ -1625,16 +1594,13 @@ let get_volatile_data_cookie ~cookie_scope ?secure () =
   with Not_found | Eliom_common.Eliom_Session_expired -> None
 
 let get_persistent_data_cookie ~cookie_scope ?secure () =
-  Lwt.catch
-    (fun () ->
-       let* c =
-         Eliommod_persess.find_persistent_cookie_only ~cookie_scope
-           ~secure_o:secure ()
-       in
-       return_some c.Eliom_common.pc_hvalue)
-    (function
-      | Not_found | Eliom_common.Eliom_Session_expired -> return_none
-      | exc -> Lwt.reraise exc)
+  try
+    let c =
+      Eliommod_persess.find_persistent_cookie_only ~cookie_scope
+        ~secure_o:secure ()
+    in
+    Some c.Eliom_common.pc_hvalue
+  with Not_found | Eliom_common.Eliom_Session_expired -> None
 
 (*****************************************************************************)
 (** {2 User cookies} *)
diff --git a/src/lib/eliom_state.server.mli b/src/lib/eliom_state.server.mli
index 1139b8ed4a..a3d1bc7803 100644
--- a/src/lib/eliom_state.server.mli
+++ b/src/lib/eliom_state.server.mli
@@ -36,7 +36,7 @@ val discard :
    scope:[< Eliom_common.user_scope | Eliom_common.request_scope]
   -> ?secure:bool
   -> unit
-  -> unit Lwt.t
+  -> unit
 (** Delete server-side (volatile and persistent) state data and services
     for a session,
     a group of sessions, a client process or a request.
@@ -55,14 +55,14 @@ val discard :
 
 (* Discard services and (volatile and persistent) data
    for all user and request scopes *)
-val discard_all_scopes : ?secure:bool -> unit -> unit Lwt.t
+val discard_all_scopes : ?secure:bool -> unit -> unit
 
 val discard_data :
    ?persistent:bool
   -> scope:[< Eliom_common.user_scope | Eliom_common.request_scope]
   -> ?secure:bool
   -> unit
-  -> unit Lwt.t
+  -> unit
 (** Remove current state data.
 
     If the optional parameter [?persistent] is not present, will
@@ -109,7 +109,7 @@ val persistent_data_state_status :
    scope:[< Eliom_common.user_scope]
   -> ?secure:bool
   -> unit
-  -> state_status Lwt.t
+  -> state_status
 
 (*****************************************************************************)
 (** {3 User cookies}
@@ -259,7 +259,7 @@ val set_persistent_data_session_group :
   -> ?scope:Eliom_common.session_scope
   -> ?secure:bool
   -> string
-  -> unit Lwt.t
+  -> unit
 (** sets the group to which belong the persistent session.
 
     If the optional [?set_max] parameter is present, also sets the
@@ -273,7 +273,7 @@ val unset_persistent_data_session_group :
    ?scope:Eliom_common.session_scope
   -> ?secure:bool
   -> unit
-  -> unit Lwt.t
+  -> unit
 (** Remove the session from its group.
     Will not close the session if it contains data. *)
 
@@ -281,7 +281,7 @@ val get_persistent_data_session_group :
    ?scope:Eliom_common.session_scope
   -> ?secure:bool
   -> unit
-  -> string option Lwt.t
+  -> string option
 (** returns the group to which belong the persistent session.
     If the session does not belong to any group, or if no session is opened,
     return [None].
@@ -481,7 +481,7 @@ val set_persistent_data_cookie_exp_date :
    cookie_scope:Eliom_common.cookie_scope
   -> ?secure:bool
   -> float option
-  -> unit Lwt.t
+  -> unit
 (** Sets the cookie expiration date for the persistent state (see
     above).
 *)
@@ -658,7 +658,7 @@ val set_persistent_data_state_timeout :
    cookie_scope:[< Eliom_common.cookie_scope]
   -> ?secure:bool
   -> float option
-  -> unit Lwt.t
+  -> unit
 (** sets the (server side) timeout for persistent state for current user,
    in seconds. [None] = no timeout *)
 
@@ -666,7 +666,7 @@ val unset_persistent_data_state_timeout :
    cookie_scope:[< Eliom_common.cookie_scope]
   -> ?secure:bool
   -> unit
-  -> unit Lwt.t
+  -> unit
 (** remove the persistent state timeout for current user
    (and turn back to the default). *)
 
@@ -674,7 +674,7 @@ val get_persistent_data_state_timeout :
    cookie_scope:[< Eliom_common.cookie_scope]
   -> ?secure:bool
   -> unit
-  -> float option Lwt.t
+  -> float option
 (** returns the persistent state timeout for current user.
     [None] = no timeout *)
 
@@ -698,16 +698,12 @@ type 'a volatile_table
 type 'a persistent_table
 (** The type of persistent state data tables. *)
 
-val discard_everything : unit -> unit Lwt.t
+val discard_everything : unit -> unit
 (** Discard all services and persistent and volatile data for every scopes. *)
 
 (*CCC missing ~secure? *)
 
-val discard_all :
-   scope:Eliom_common.user_scope
-  -> ?secure:bool
-  -> unit
-  -> unit Lwt.t
+val discard_all : scope:Eliom_common.user_scope -> ?secure:bool -> unit -> unit
 (** Discard all services and persistent and volatile data for one scope. *)
 
 (*VVV missing: scope group *)
@@ -717,7 +713,7 @@ val discard_all_data :
   -> scope:Eliom_common.user_scope
   -> ?secure:bool
   -> unit
-  -> unit Lwt.t
+  -> unit
 (** Discard server side data for all clients, for the given scope.
 
     If the optional parameter [?persistent] is not present,
@@ -731,7 +727,7 @@ val discard_all_services :
    scope:Eliom_common.user_scope
   -> ?secure:bool
   -> unit
-  -> unit Lwt.t
+  -> unit
 (** Remove all services registered for clients for the given scope. *)
 
 (*VVV missing: scope group *)
@@ -795,7 +791,7 @@ module Ext : sig
      ?secure:bool
     -> ?scope:Eliom_common.user_scope
     -> unit
-    -> ([< Eliom_common.user_level], [< `Pers]) state Lwt.t
+    -> ([< Eliom_common.user_level], [< `Pers]) state
   (** Same for persistent data *)
 
   val current_service_state :
@@ -809,7 +805,7 @@ module Ext : sig
      ?sitedata:Eliom_common.sitedata
     -> state:('a, 'b) state
     -> unit
-    -> unit Lwt.t
+    -> unit
   (** Discard external states.
       See {!fold_volatile_sub_states} for explanation about the [?sitedata]
       parameter.
@@ -845,9 +841,9 @@ module Ext : sig
          ( [< `Session_group | `Session]
            , ([< `Data | `Pers | `Service] as 'k) )
            state
-    -> ('a -> ([< `Session | `Client_process], 'k) state -> 'a Lwt.t)
+    -> ('a -> ([< `Session | `Client_process], 'k) state -> 'a)
+    -> 'a
     -> 'a
-    -> 'a Lwt.t
   (** Fold all sessions in a groups, or all client processes in a session
       (volatile and persistent).
       See {!fold_volatile_sub_states} for explanation about the [?sitedata]
@@ -857,8 +853,8 @@ module Ext : sig
   val iter_sub_states :
      ?sitedata:Eliom_common.sitedata
     -> state:([< `Session_group | `Session], 'k) state
-    -> (([< `Session | `Client_process], 'k) state -> unit Lwt.t)
-    -> unit Lwt.t
+    -> (([< `Session | `Client_process], 'k) state -> unit)
+    -> unit
   (** Iter on all sessions in a groups, or all client processes in a session
       (volatile and persistent).
       See {!fold_volatile_sub_states} for explanation about the [?sitedata]
@@ -878,7 +874,7 @@ module Ext : sig
     val get_persistent_data :
        state:([< `Session_group | `Session | `Client_process], [< `Pers]) state
       -> table:'a persistent_table
-      -> 'a Lwt.t
+      -> 'a
     (** Fails with lwt exception [Not_found]
         if no data in the table for the cookie. *)
 
@@ -892,7 +888,7 @@ module Ext : sig
        state:([< `Session_group | `Session | `Client_process], [< `Pers]) state
       -> table:'a persistent_table
       -> 'a
-      -> unit Lwt.t
+      -> unit
     (** Fails with lwt exception [Not_found]
         if no data in the table for the cookie. *)
 
@@ -904,7 +900,7 @@ module Ext : sig
     val remove_persistent_data :
        state:([< `Session_group | `Session | `Client_process], [< `Pers]) state
       -> table:'a persistent_table
-      -> unit Lwt.t
+      -> unit
   end
 
   val get_service_cookie_info :
@@ -926,7 +922,7 @@ module Ext : sig
 
   val get_persistent_cookie_info :
      ([< Eliom_common.cookie_level], [`Pers]) state
-    -> persistent_cookie_info Lwt.t
+    -> persistent_cookie_info
 
   val get_service_cookie_scope :
      cookie:service_cookie_info
@@ -953,7 +949,7 @@ module Ext : sig
   val set_persistent_data_cookie_timeout :
      cookie:persistent_cookie_info
     -> float option
-    -> unit Lwt.t
+    -> unit
 
   val get_service_cookie_timeout : cookie:service_cookie_info -> timeout
   val get_volatile_data_cookie_timeout : cookie:data_cookie_info -> timeout
@@ -967,50 +963,40 @@ module Ext : sig
 
   val unset_persistent_data_cookie_timeout :
      cookie:persistent_cookie_info
-    -> unit Lwt.t
+    -> unit
 
   val get_session_group_list : unit -> string list
   (** Returns a list containing the names of all session group
       that are available for this site. *)
 
-  val iter_service_cookies : (service_cookie_info -> unit Lwt.t) -> unit Lwt.t
+  val iter_service_cookies : (service_cookie_info -> unit) -> unit
   (** Iterator on all active service cookies.
       [Lwt.pause] is called automatically after each iteration.
    *)
 
-  val iter_volatile_data_cookies :
-     (data_cookie_info -> unit Lwt.t)
-    -> unit Lwt.t
+  val iter_volatile_data_cookies : (data_cookie_info -> unit) -> unit
   (** Iterator on data cookies. [Lwt.pause] is called automatically
       after each iteration.
    *)
 
-  val iter_persistent_data_cookies :
-     (persistent_cookie_info -> unit Lwt.t)
-    -> unit Lwt.t
+  val iter_persistent_data_cookies : (persistent_cookie_info -> unit) -> unit
   (** Iterator on persistent cookies. [Lwt.pause] is called automatically
       after each iteration. *)
 
-  val fold_service_cookies :
-     (service_cookie_info -> 'b -> 'b Lwt.t)
-    -> 'b
-    -> 'b Lwt.t
+  val fold_service_cookies : (service_cookie_info -> 'b -> 'b) -> 'b -> 'b
   (** Iterator on service cookies. [Lwt.pause] is called automatically
       after each iteration.
   *)
 
-  val fold_volatile_data_cookies :
-     (data_cookie_info -> 'b -> 'b Lwt.t)
-    -> 'b
-    -> 'b Lwt.t
+  val fold_volatile_data_cookies : (data_cookie_info -> 'b -> 'b) -> 'b -> 'b
   (** Iterator on data cookies. [Lwt.pause] is called automatically
      after each iteration.
    *)
 
   val fold_persistent_data_cookies :
-     (persistent_cookie_info -> 'b -> 'b Lwt.t)
+     (persistent_cookie_info -> 'b -> 'b)
+    -> 'b
     -> 'b
-    -> 'b Lwt.t
   (** Iterator on persistent cookies. [Lwt.pause] is called automatically
      after each iteration. *)
 
@@ -1073,22 +1059,19 @@ val create_persistent_table :
    scope:Eliom_common.user_scope
   -> ?secure:bool
   -> string
-  -> 'a persistent_table Lwt.t
+  -> 'a persistent_table
 (** creates a table on hard disk where you can store the session data
     for all users. It uses {!Ocsipersist}.  (low level) *)
 
-val get_persistent_data :
-   table:'a persistent_table
-  -> unit
-  -> 'a state_data Lwt.t
+val get_persistent_data : table:'a persistent_table -> unit -> 'a state_data
 (** gets persistent session data for the current persistent session (if any).
     (low level) *)
 
-val set_persistent_data : table:'a persistent_table -> 'a -> unit Lwt.t
+val set_persistent_data : table:'a persistent_table -> 'a -> unit
 (** sets persistent session data for the current persistent session.
     (low level) *)
 
-val remove_persistent_data : table:'a persistent_table -> unit -> unit Lwt.t
+val remove_persistent_data : table:'a persistent_table -> unit -> unit
 (** removes session data for the current persistent session
     (but does not close the session).
     If the session does not exist, does nothing.
@@ -1170,7 +1153,7 @@ val get_persistent_data_cookie :
    cookie_scope:Eliom_common.cookie_scope
   -> ?secure:bool
   -> unit
-  -> Eliom_common.Hashed_cookies.t option Lwt.t
+  -> Eliom_common.Hashed_cookies.t option
 (** returns the hashed value of the Eliom's cookies for one persistent session.
     Returns [None] is no session is active.
  *)
@@ -1202,9 +1185,9 @@ val number_of_service_cookies : unit -> int
 val number_of_volatile_data_cookies : unit -> int
 val number_of_tables : unit -> int
 val number_of_table_elements : unit -> int list
-val number_of_persistent_data_cookies : unit -> int Lwt.t
+val number_of_persistent_data_cookies : unit -> int
 val number_of_persistent_tables : unit -> int
-val number_of_persistent_table_elements : unit -> (string * int) list Lwt.t
+val number_of_persistent_table_elements : unit -> (string * int) list
 (* Because of Dbm implementation, the result may be less than the expected
    result in some case (with a version of ocsipersist based on Dbm) *)
 
diff --git a/src/lib/eliom_stream.shared.ml b/src/lib/eliom_stream.shared.ml
index 8b207b83d0..878f679399 100644
--- a/src/lib/eliom_stream.shared.ml
+++ b/src/lib/eliom_stream.shared.ml
@@ -1,8 +1,8 @@
+open Eio.Std
+
 (* This file is part of Lwt, released under the MIT license. See LICENSE.md for
    details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
 
-open Lwt.Infix
-
 exception Closed
 exception Full
 exception Empty
@@ -24,9 +24,9 @@ let new_node () =
 
 (* Type of a stream source using a function to create new elements. *)
 type 'a from =
-  { from_create : unit -> 'a option Lwt.t
+  { from_create : unit -> 'a option
   ; (* Function used to create new elements. *)
-    mutable from_thread : unit Lwt.t
+    mutable from_thread : unit Promise.t
     (* Thread which:
 
      - wait for the thread returned by the last call to [from_next],
@@ -40,7 +40,7 @@ type 'a from =
 [@@@ocaml.warning "-69"]
 
 type push =
-  { mutable push_signal : unit Lwt.t
+  { mutable push_signal : unit Promise.t
   ; (* Thread signaled when a new element is added to the stream. *)
     mutable push_waiting : bool
   ; (* Is a thread waiting on [push_signal] ? *)
@@ -49,7 +49,7 @@ type push =
 
 (* Type of a stream source for bounded-push streams. *)
 type 'a push_bounded =
-  { mutable pushb_signal : unit Lwt.t
+  { mutable pushb_signal : unit Promise.t
   ; (* Thread signaled when a new element is added to the stream. *)
     mutable pushb_waiting : bool
   ; (* Is a thread waiting on [pushb_signal] ? *)
@@ -61,7 +61,7 @@ type 'a push_bounded =
   ; (* The next element to push if a thread blocked on push. We store it
      here to be sure it will be the first element to be added when
      space becomes available. *)
-    mutable pushb_push_waiter : unit Lwt.t
+    mutable pushb_push_waiter : unit Promise.t
   ; mutable pushb_push_wakener : unit Lwt.u
   ; (* Thread blocked on push. *)
     mutable pushb_external : Obj.t [@ocaml.warning "-69"]
@@ -81,7 +81,7 @@ type 'a t =
   ; (* The source of the stream. *)
     close : unit Lwt.u
   ; (* A wakener for a thread that sleeps until the stream is closed. *)
-    closed : unit Lwt.t
+    closed : unit Promise.t
   ; (* A waiter for a thread that sleeps until the stream is closed. *)
     mutable node : 'a node
   ; (* Pointer to first pending element, or to [last] if there is no
@@ -92,7 +92,7 @@ type 'a t =
 class type ['a] bounded_push = object
   method size : int
   method resize : int -> unit
-  method push : 'a -> unit Lwt.t
+  method push : 'a -> unit
   method close : unit
   method count : int
   method blocked : bool
@@ -114,10 +114,14 @@ let clone s =
 
 let from_source source =
   let node = new_node () in
-  let closed, close = Lwt.wait () in
+  let closed, close =
+    Promise.create
+      (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+      ()
+  in
   {source; close; closed; node; last = ref node}
 
-let from f = from_source (From {from_create = f; from_thread = Lwt.return_unit})
+let from f = from_source (From {from_create = f; from_thread = ()})
 let from_direct f = from_source (From_direct f)
 let closed s = s.closed
 let is_closed s = not (Lwt.is_sleeping (closed s))
@@ -133,7 +137,11 @@ let enqueue e s = enqueue' e s.last
 let create_with_reference () =
   (* Create the source for notifications of new elements. *)
   let source, push_signal_resolver =
-    let push_signal, push_signal_resolver = Lwt.wait () in
+    let push_signal, push_signal_resolver =
+      Promise.create
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
     ( {push_signal; push_waiting = false; push_external = Obj.repr ()}
     , ref push_signal_resolver )
   in
@@ -154,14 +162,19 @@ let create_with_reference () =
       source.push_waiting <- false;
       (* Update threads. *)
       let old_push_signal_resolver = !push_signal_resolver in
-      let new_waiter, new_push_signal_resolver = Lwt.wait () in
+      let new_waiter, new_push_signal_resolver =
+        Promise.create
+          (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+          ()
+      in
       source.push_signal <- new_waiter;
       push_signal_resolver := new_push_signal_resolver;
-      (* Signal that a new value has been received. *)
-      Lwt.wakeup_later old_push_signal_resolver ());
+      Promise.resolve
+        (* Signal that a new value has been received. *)
+        old_push_signal_resolver ());
     (* Do this at the end in case one of the function raise an
        exception. *)
-    if x = None then Lwt.wakeup close ()
+    if x = None then Promise.resolve close ()
   in
   t, push, fun x -> source.push_external <- Obj.repr x
 
@@ -172,7 +185,9 @@ let return a =
 let return_lwt a =
   let source, push, _ = create_with_reference () in
   Lwt.dont_wait
-    (fun () -> Lwt.bind a (fun x -> push (Some x); push None; Lwt.return_unit))
+    (fun () ->
+       let x = a in
+       push (Some x); push None)
     (fun _exc -> push None);
   source
 
@@ -190,7 +205,7 @@ let of_seq s =
 let of_lwt_seq s =
   let s = ref s in
   let get () =
-    !s () >|= function
+    match !s () with
     | Lwt_seq.Nil -> None
     | Lwt_seq.Cons (elt, s') ->
         s := s';
@@ -224,10 +239,15 @@ let notify_pusher info last =
   info.pushb_pending <- None;
   (* Wakeup the pusher. *)
   let old_wakener = info.pushb_push_wakener in
-  let waiter, wakener = Lwt.task () in
+  let waiter, wakener =
+    Promise.create
+      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+      (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+      ()
+  in
   info.pushb_push_waiter <- waiter;
   info.pushb_push_wakener <- wakener;
-  Lwt.wakeup_later old_wakener ()
+  Promise.resolve old_wakener ()
 
 class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
   object
@@ -244,23 +264,27 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
 
     method push x =
       if closed
-      then Lwt.fail Closed
+      then raise Closed
       else if info.pushb_pending <> None
-      then Lwt.fail Full
+      then raise Full
       else if info.pushb_count >= info.pushb_size
       then (
         info.pushb_pending <- Some x;
-        Lwt.catch
-          (fun () -> info.pushb_push_waiter)
-          (fun exn ->
-             match exn with
-             | Lwt.Canceled ->
-                 info.pushb_pending <- None;
-                 let waiter, wakener = Lwt.task () in
-                 info.pushb_push_waiter <- waiter;
-                 info.pushb_push_wakener <- wakener;
-                 Lwt.reraise exn
-             | _ -> Lwt.reraise exn))
+        try info.pushb_push_waiter
+        with exn -> (
+          match exn with
+          | Lwt.Canceled ->
+              info.pushb_pending <- None;
+              let waiter, wakener =
+                Promise.create
+                  (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+                  (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+                  ()
+              in
+              info.pushb_push_waiter <- waiter;
+              info.pushb_push_wakener <- wakener;
+              Lwt.reraise exn
+          | _ -> Lwt.reraise exn))
       else (
         (* Push the element at the end of the queue. *)
         enqueue' (Some x) last;
@@ -272,12 +296,16 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
           info.pushb_waiting <- false;
           (* Update threads. *)
           let old_wakener = !wakener_cell in
-          let new_waiter, new_wakener = Lwt.wait () in
+          let new_waiter, new_wakener =
+            Promise.create
+              (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+              ()
+          in
           info.pushb_signal <- new_waiter;
           wakener_cell := new_wakener;
-          (* Signal that a new value has been received. *)
-          Lwt.wakeup_later old_wakener ());
-        Lwt.return_unit)
+          Promise.resolve
+            (* Signal that a new value has been received. *)
+            old_wakener ()))
 
     method close =
       if not closed
@@ -298,8 +326,8 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
           info.pushb_waiting <- false;
           let old_wakener = !wakener_cell in
           (* Signal that a new value has been received. *)
-          Lwt.wakeup_later old_wakener ());
-        Lwt.wakeup close ())
+          Promise.resolve old_wakener ());
+        Promise.resolve close ())
 
     method count = info.pushb_count
     method blocked = info.pushb_pending <> None
@@ -313,8 +341,17 @@ let create_bounded size =
   if size < 0 then invalid_arg "Eliom_stream.create_bounded";
   (* Create the source for notifications of new elements. *)
   let info, wakener_cell =
-    let waiter, wakener = Lwt.wait () in
-    let push_waiter, push_wakener = Lwt.task () in
+    let waiter, wakener =
+      Promise.create
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
+    let push_waiter, push_wakener =
+      Promise.create
+        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+        ()
+    in
     ( { pushb_signal = waiter
       ; pushb_waiting = false
       ; pushb_size = size
@@ -336,22 +373,24 @@ let feed s =
       (* There is already a thread started to create a new element,
        wait for this one to terminate. *)
       if Lwt.is_sleeping from.from_thread
-      then Lwt.protected from.from_thread
+      then
+        Lwt.protected
+          (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+          (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
+          from.from_thread
       else
         (* Otherwise request a new element. *)
         let thread =
-          (* The function [from_create] can raise an exception (with
+         (* The function [from_create] can raise an exception (with
            [raise], rather than returning a failed promise with
            [Lwt.fail]). In this case, we have to catch the exception
            and turn it into a safe failed promise. *)
-          Lwt.catch
-            (fun () ->
-               from.from_create () >>= fun x ->
-               (* Push the element to the end of the queue. *)
-               enqueue x s;
-               if x = None then Lwt.wakeup s.close ();
-               Lwt.return_unit)
-            Lwt.reraise
+         fun () ->
+          from.from_create () >>= fun x ->
+          (* Push the element to the end of the queue. *)
+          enqueue x s;
+          if x = None then Lwt.wakeup s.close ();
+          Lwt.return_unit
         in
         (* Allow other threads to access this thread. *)
         from.from_thread <- thread;
diff --git a/src/lib/eliom_stream.shared.mli b/src/lib/eliom_stream.shared.mli
index 62c55d2393..2b918399e8 100644
--- a/src/lib/eliom_stream.shared.mli
+++ b/src/lib/eliom_stream.shared.mli
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* This file is part of Lwt, released under the MIT license. See LICENSE.md for
    details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
 
@@ -14,7 +16,7 @@ type 'a t
 
 (** {2 Construction} *)
 
-val from : (unit -> 'a option Lwt.t) -> 'a t
+val from : (unit -> 'a option) -> 'a t
 (** [from f] creates a stream from the given input function. [f] is
     called each time more input is needed, and the stream ends when
     [f] returns [None].
@@ -76,7 +78,7 @@ class type ['a] bounded_push = object
 
       It raises {!Stdlib.Invalid_argument} if [size < 0]. *)
 
-  method push : 'a -> unit Lwt.t
+  method push : 'a -> unit
   (** Pushes a new element to the stream. If the stream is full then
       it will block until one element is consumed. If another thread
       is already blocked on [push], it raises {!Eliom_stream.Full}. *)
@@ -116,7 +118,7 @@ val return : 'a -> 'a t
 
     @since 5.5.0 *)
 
-val return_lwt : 'a Lwt.t -> 'a t
+val return_lwt : 'a Promise.t -> 'a t
 (** [return_lwt l] creates a stream returning the value that [l] resolves to.
     The value is pushed into the stream immediately after the promise becomes
     resolved and the stream is then immediately closed (in the sense of
@@ -176,10 +178,10 @@ val clone : 'a t -> 'a t
 
 (** {2 Destruction} *)
 
-val to_list : 'a t -> 'a list Lwt.t
+val to_list : 'a t -> 'a list
 (** Returns the list of elements of the given stream *)
 
-val to_string : char t -> string Lwt.t
+val to_string : char t -> string
 (** Returns the word composed of all characters of the given
     stream *)
 
@@ -189,48 +191,48 @@ exception Empty
 (** Exception raised when trying to retrieve data from an empty
     stream. *)
 
-val peek : 'a t -> 'a option Lwt.t
+val peek : 'a t -> 'a option
 (** [peek st] returns the first element of the stream, if any,
     without removing it. *)
 
-val npeek : int -> 'a t -> 'a list Lwt.t
+val npeek : int -> 'a t -> 'a list
 (** [npeek n st] returns at most the first [n] elements of [st],
     without removing them. *)
 
-val get : 'a t -> 'a option Lwt.t
+val get : 'a t -> 'a option
 (** [get st] removes and returns the first element of the stream, if
     any. *)
 
-val nget : int -> 'a t -> 'a list Lwt.t
+val nget : int -> 'a t -> 'a list
 (** [nget n st] removes and returns at most the first [n] elements of
     [st]. *)
 
-val get_while : ('a -> bool) -> 'a t -> 'a list Lwt.t
+val get_while : ('a -> bool) -> 'a t -> 'a list
 
-val get_while_s : ('a -> bool Lwt.t) -> 'a t -> 'a list Lwt.t
+val get_while_s : ('a -> bool) -> 'a t -> 'a list
 (** [get_while f st] returns the longest prefix of [st] where all
     elements satisfy [f]. *)
 
-val next : 'a t -> 'a Lwt.t
+val next : 'a t -> 'a
 (** [next st] removes and returns the next element of the stream or
     fails with {!Empty}, if the stream is empty. *)
 
-val last_new : 'a t -> 'a Lwt.t
+val last_new : 'a t -> 'a
 (** [last_new st] returns the last element that can be obtained
     without sleeping, or wait for one if none is available.
 
     It fails with {!Empty} if the stream has no more elements. *)
 
-val junk : 'a t -> unit Lwt.t
+val junk : 'a t -> unit
 (** [junk st] removes the first element of [st]. *)
 
-val njunk : int -> 'a t -> unit Lwt.t
+val njunk : int -> 'a t -> unit
 (** [njunk n st] removes at most the first [n] elements of the
     stream. *)
 
-val junk_while : ('a -> bool) -> 'a t -> unit Lwt.t
+val junk_while : ('a -> bool) -> 'a t -> unit
 
-val junk_while_s : ('a -> bool Lwt.t) -> 'a t -> unit Lwt.t
+val junk_while_s : ('a -> bool) -> 'a t -> unit
 (** [junk_while f st] removes all elements at the beginning of the
     streams which satisfy [f]. *)
 
@@ -246,7 +248,7 @@ val get_available_up_to : int -> 'a t -> 'a list
 (** [get_available_up_to n st] returns up to [n] elements of [l]
     without blocking. *)
 
-val is_empty : 'a t -> bool Lwt.t
+val is_empty : 'a t -> bool
 (** [is_empty st] returns whether the given stream is empty. *)
 
 val is_closed : 'a t -> bool
@@ -257,7 +259,7 @@ val is_closed : 'a t -> bool
 
     @since 2.6.0 *)
 
-val closed : 'a t -> unit Lwt.t
+val closed : 'a t -> unit
 (** [closed st] returns a thread that will sleep until the stream has been
     closed.
 
@@ -265,7 +267,7 @@ val closed : 'a t -> unit Lwt.t
 
 (** {3 Deprecated} *)
 
-val junk_old : 'a t -> unit Lwt.t
+val junk_old : 'a t -> unit
 [@@deprecated "Use junk_available instead"]
 (** @deprecated [junk_old st] is [Lwt.return (junk_available st)]. *)
 
@@ -294,37 +296,37 @@ val choose : 'a t list -> 'a t
 
 val map : ('a -> 'b) -> 'a t -> 'b t
 
-val map_s : ('a -> 'b Lwt.t) -> 'a t -> 'b t
+val map_s : ('a -> 'b) -> 'a t -> 'b t
 (** [map f st] maps the value returned by [st] with [f] *)
 
 val filter : ('a -> bool) -> 'a t -> 'a t
 
-val filter_s : ('a -> bool Lwt.t) -> 'a t -> 'a t
+val filter_s : ('a -> bool) -> 'a t -> 'a t
 (** [filter f st] keeps only values, [x], such that [f x] is [true] *)
 
 val filter_map : ('a -> 'b option) -> 'a t -> 'b t
 
-val filter_map_s : ('a -> 'b option Lwt.t) -> 'a t -> 'b t
+val filter_map_s : ('a -> 'b option) -> 'a t -> 'b t
 (** [filter_map f st] filter and map [st] at the same time *)
 
 val map_list : ('a -> 'b list) -> 'a t -> 'b t
 
-val map_list_s : ('a -> 'b list Lwt.t) -> 'a t -> 'b t
+val map_list_s : ('a -> 'b list) -> 'a t -> 'b t
 (** [map_list f st] applies [f] on each element of [st] and flattens
     the lists returned *)
 
-val fold : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b Lwt.t
+val fold : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
 
-val fold_s : ('a -> 'b -> 'b Lwt.t) -> 'a t -> 'b -> 'b Lwt.t
+val fold_s : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
 (** [fold f s x] fold_like function for streams. *)
 
-val iter : ('a -> unit) -> 'a t -> unit Lwt.t
-val iter_p : ('a -> unit Lwt.t) -> 'a t -> unit Lwt.t
+val iter : ('a -> unit) -> 'a t -> unit
+val iter_p : ('a -> unit) -> 'a t -> unit
 
-val iter_s : ('a -> unit Lwt.t) -> 'a t -> unit Lwt.t
+val iter_s : ('a -> unit) -> 'a t -> unit
 (** [iter f s] iterates over all elements of the stream. *)
 
-val iter_n : ?max_concurrency:int -> ('a -> unit Lwt.t) -> 'a t -> unit Lwt.t
+val iter_n : ?max_concurrency:int -> ('a -> unit) -> 'a t -> unit
 (** [iter_n ?max_concurrency f s] iterates over all elements of the stream [s].
     Iteration is performed concurrently with up to [max_threads] concurrent
     instances of [f].
@@ -336,14 +338,14 @@ val iter_n : ?max_concurrency:int -> ('a -> unit Lwt.t) -> 'a t -> unit Lwt.t
     @raise Invalid_argument if [max_concurrency < 1].
     @since 3.3.0 *)
 
-val find : ('a -> bool) -> 'a t -> 'a option Lwt.t
+val find : ('a -> bool) -> 'a t -> 'a option
 
-val find_s : ('a -> bool Lwt.t) -> 'a t -> 'a option Lwt.t
+val find_s : ('a -> bool) -> 'a t -> 'a option
 (** [find f s] find an element in a stream. *)
 
-val find_map : ('a -> 'b option) -> 'a t -> 'b option Lwt.t
+val find_map : ('a -> 'b option) -> 'a t -> 'b option
 
-val find_map_s : ('a -> 'b option Lwt.t) -> 'a t -> 'b option Lwt.t
+val find_map_s : ('a -> 'b option) -> 'a t -> 'b option
 (** [find_map f s] find and map at the same time. *)
 
 val combine : 'a t -> 'b t -> ('a * 'b) t
@@ -375,7 +377,7 @@ val wrap_exn : 'a t -> ('a, exn) result t
 
 (** {2 Parsing} *)
 
-val parse : 'a t -> ('a t -> 'b Lwt.t) -> 'b Lwt.t
+val parse : 'a t -> ('a t -> 'b) -> 'b
 (** [parse st f] parses [st] with [f]. If [f] raise an exception,
     [st] is restored to its previous state.
 
diff --git a/src/lib/eliom_tools.eliom b/src/lib/eliom_tools.eliom
index d4d84ff657..142027a8f1 100644
--- a/src/lib/eliom_tools.eliom
+++ b/src/lib/eliom_tools.eliom
@@ -530,6 +530,6 @@ module F = Make (Html.F)
 module D = Make (Html.D)
 
 let wrap_handler information none some get post =
-  Lwt.bind (information ()) (function
-    | None -> none get post
-    | Some value -> some value get post)
+  match information () with
+  | None -> none get post
+  | Some value -> some value get post
diff --git a/src/lib/eliom_tools.eliomi b/src/lib/eliom_tools.eliomi
index aec2fd11f2..2903a29ddd 100644
--- a/src/lib/eliom_tools.eliomi
+++ b/src/lib/eliom_tools.eliomi
@@ -249,12 +249,12 @@ val with_css_file : string list -> unit
 (** {2 Other tools} *)
 
 val wrap_handler :
-   (unit -> 'a option Lwt.t)
-  -> ('get -> 'post -> 'res Lwt.t)
-  -> ('a -> 'get -> 'post -> 'res Lwt.t)
+   (unit -> 'a option)
+  -> ('get -> 'post -> 'res)
+  -> ('a -> 'get -> 'post -> 'res)
   -> 'get
   -> 'post
-  -> 'res Lwt.t
+  -> 'res
 (** This function allows one to wrap a service handler easily depending
     on whether certain information is available or not.
 
diff --git a/src/lib/server/eliommod.ml b/src/lib/server/eliommod.ml
index 3a8fed3ada..234eabebea 100644
--- a/src/lib/server/eliommod.ml
+++ b/src/lib/server/eliommod.ml
@@ -759,7 +759,7 @@ let load_eliom_module _sitedata cmo_or_name parent_tag content =
 (* If page has already been generated becauise there are several <eliom>
    tags in the same site:
 *)
-let gen_nothing () _ = Lwt.return Ocsigen_extensions.Ext_do_nothing
+let gen_nothing () _ = Ocsigen_extensions.Ext_do_nothing
 
 (*****************************************************************************)
 let default_module_action _ = failwith "default_module_action"
diff --git a/src/lib/server/eliommod.mli b/src/lib/server/eliommod.mli
index 2074431bce..98820fed77 100644
--- a/src/lib/server/eliommod.mli
+++ b/src/lib/server/eliommod.mli
@@ -162,7 +162,7 @@ val load_eliom_module :
   -> Xml_light_types.xml list
   -> unit
 
-val gen_nothing : unit -> 'a -> Ocsigen_extensions.answer Lwt.t
+val gen_nothing : unit -> 'a -> Ocsigen_extensions.answer
 val default_module_action : 'a -> 'b
 
 val set_timeout :
@@ -189,4 +189,4 @@ val parse_config :
   -> 'c
   -> Xml_light_types.xml
   -> Ocsigen_extensions.request_state
-  -> Ocsigen_extensions.answer Lwt.t
+  -> Ocsigen_extensions.answer
diff --git a/src/lib/server/eliommod_cookies.ml b/src/lib/server/eliommod_cookies.ml
index d6d002f2b7..de9ed6c15a 100644
--- a/src/lib/server/eliommod_cookies.ml
+++ b/src/lib/server/eliommod_cookies.ml
@@ -21,7 +21,6 @@
 open Eliom_lib
 (** Cookie management                                                       *)
 
-open Lwt
 include Eliom_cookies_base
 
 (*****************************************************************************)
@@ -90,7 +89,7 @@ module Persistent_cookies = struct
 
     let remove_cookie exp_o cookie =
       match exp_o with
-      | None -> Lwt.return_unit
+      | None -> ()
       | Some exp -> (
           modify_opt exp @@ function
           | None -> None
@@ -101,16 +100,20 @@ module Persistent_cookies = struct
   end
 
   let add cookie ({expiry; _} as content) =
-    (match expiry with
+    let _ =
+      match expiry with
       | Some t -> Expiry_dates.add_cookie t cookie
-      | None -> Lwt.return_unit)
-    >>= fun _ -> Cookies.add cookie content
+      | None -> ()
+    in
+    Cookies.add cookie content
 
   let replace_if_exists cookie ({expiry; _} as content) =
-    (match expiry with
+    let _ =
+      match expiry with
       | Some t -> Expiry_dates.add_cookie t cookie
-      | None -> Lwt.return_unit)
-    >>= fun _ -> Cookies.replace_if_exists cookie content
+      | None -> ()
+    in
+    Cookies.replace_if_exists cookie content
 
   let garbage_collect ~section gc_cookie =
     let now = Unix.time () in
@@ -121,7 +124,8 @@ module Persistent_cookies = struct
     in
     Logs.info ~src:section (fun fmt ->
       fmt "potentially expired cookies %.0f: %s" date cookies_log);
-    Lwt_list.iter_s gc_cookie cookies >>= fun _ -> Expiry_dates.remove date
+    let _ = List.iter gc_cookie cookies in
+    Expiry_dates.remove date
 end
 
 (*****************************************************************************)
@@ -258,95 +262,88 @@ let get_cookie_info
     Eliom_common.Full_state_name_table.map
       (fun value ->
          lazy
-           (catch
-              (fun () ->
-                 let hvalue = Eliom_common.Hashed_cookies.hash value in
-                 let hvalue_string =
-                   Eliom_common.Hashed_cookies.to_string hvalue
-                 in
-                 Persistent_cookies.Cookies.find
-                   (Eliom_common.Hashed_cookies.to_string hvalue)
-                 >>=
-                 fun { expiry = persexp
-                     ; timeout = perstimeout
-                     ; session_group = sessgrp
-                     ; _ } ->
-                 Eliommod_sessiongroups.Pers.up hvalue_string sessgrp
-                 >>= fun () ->
-                 match persexp with
-                 | Some t when t < now ->
-                     (* session expired by timeout *)
-                     Eliom_common.Persistent_tables.remove_key_from_all_tables
-                       hvalue_string
-                     >>= fun () ->
-                     return
-                       ( Some
-                           ( value
-                             (* value at the beginning
+           (try
+              let hvalue = Eliom_common.Hashed_cookies.hash value in
+              let hvalue_string =
+                Eliom_common.Hashed_cookies.to_string hvalue
+              in
+              let { expiry = persexp
+                  ; timeout = perstimeout
+                  ; session_group = sessgrp
+                  ; _ }
+                =
+                Persistent_cookies.Cookies.find
+                  (Eliom_common.Hashed_cookies.to_string hvalue)
+              in
+              Eliommod_sessiongroups.Pers.up hvalue_string sessgrp;
+              match persexp with
+              | Some t when t < now ->
+                  (* session expired by timeout *)
+                  Eliom_common.Persistent_tables.remove_key_from_all_tables
+                    hvalue_string;
+                  ( Some
+                      ( value
+                        (* value at the beginning
                                                  of the request *)
-                           , perstimeout
-                             (* user persistent timeout
+                      , perstimeout
+                        (* user persistent timeout
                                                  at the beginning
                                                  of the request *)
-                           , persexp
-                             (* expiration date (server)
+                      , persexp
+                        (* expiration date (server)
                                                  at the beginning
                                                  of the request *)
-                           , sessgrp (* session group at beginning *) )
-                       , ref Eliom_common.SCData_session_expired
-                         (* ask the browser to
+                      , sessgrp (* session group at beginning *) )
+                  , ref Eliom_common.SCData_session_expired
+                    (* ask the browser to
                                                  remove the cookie *)
-                       )
-                 | _ ->
-                     return
-                       ( Some
-                           ( value
-                             (* value at the beginning
+                  )
+              | _ ->
+                  ( Some
+                      ( value
+                        (* value at the beginning
                                               of the request *)
-                           , perstimeout
-                             (* user persistent timeout
+                      , perstimeout
+                        (* user persistent timeout
                                               at the beginning
                                               of the request *)
-                           , persexp
-                             (* expiration date (server)
+                      , persexp
+                        (* expiration date (server)
                                               at the beginning
                                               of the request *)
-                           , sessgrp (* session group at beginning *) )
-                       , ref
-                           (Eliom_common.SC
-                              { Eliom_common.pc_hvalue = hvalue (* value *)
-                              ; Eliom_common.pc_set_value = None
-                              ; Eliom_common.pc_timeout =
-                                  ref perstimeout
-                                  (* user persistent timeout ref *)
-                              ; Eliom_common.pc_cookie_exp =
-                                  ref Eliom_common.CENothing
-                                  (* persistent cookie expiration
+                      , sessgrp (* session group at beginning *) )
+                  , ref
+                      (Eliom_common.SC
+                         { Eliom_common.pc_hvalue = hvalue (* value *)
+                         ; Eliom_common.pc_set_value = None
+                         ; Eliom_common.pc_timeout =
+                             ref perstimeout (* user persistent timeout ref *)
+                         ; Eliom_common.pc_cookie_exp =
+                             ref Eliom_common.CENothing
+                             (* persistent cookie expiration
                                     date ref to send to the browser:
                                     We don't change it *)
-                              ; Eliom_common.pc_session_group = ref sessgrp })
-                       ))
-              (function
-                | Not_found ->
-                    return
-                      ( Some
-                          ( value
-                            (* value at the beginning
+                         ; Eliom_common.pc_session_group = ref sessgrp }) )
+            with
+           | Not_found ->
+               ( Some
+                   ( value
+                     (* value at the beginning
                                              of the request *)
-                          , Eliom_common.TGlobal
-                            (* user persistent timeout
+                   , Eliom_common.TGlobal
+                     (* user persistent timeout
                                              at the beginning
                                              of the request *)
-                          , Some 0.
-                            (* expiration date (server)
+                   , Some 0.
+                     (* expiration date (server)
                                              at the beginning
                                              of the request *)
-                          , None (* session group at beginning *) )
-                      , ref Eliom_common.SCData_session_expired
-                        (* ask the browser
+                   , None (* session group at beginning *) )
+               , ref Eliom_common.SCData_session_expired
+                 (* ask the browser
                                              to remove the cookie *)
-                      )
-                | e -> fail e)))
+               )
+           | e -> raise e))
       persistent_cookies
     (* the persistent cookies sent by the request *)
   in
@@ -384,104 +381,96 @@ let compute_session_cookies_to_send
       (endlist : Ocsigen_cookie_map.t)
   =
   let getservvexp (old, newi) =
-    return
-      (let newinfo =
-         match !newi with
-         | Eliom_common.SCNo_data | Eliom_common.SCData_session_expired -> None
-         | Eliom_common.SC c ->
-             Some
-               ( c.Eliom_common.sc_hvalue
-               , c.Eliom_common.sc_set_value
-               , !(c.Eliom_common.sc_cookie_exp) )
-       in
-       old, newinfo)
+    let newinfo =
+      match !newi with
+      | Eliom_common.SCNo_data | Eliom_common.SCData_session_expired -> None
+      | Eliom_common.SC c ->
+          Some
+            ( c.Eliom_common.sc_hvalue
+            , c.Eliom_common.sc_set_value
+            , !(c.Eliom_common.sc_cookie_exp) )
+    in
+    old, newinfo
   in
   let getdatavexp v =
     if Lazy.is_val v
     then
-      return
-        (let old, newi = Lazy.force v in
-         let newinfo =
-           match !newi with
-           | Eliom_common.SCNo_data | Eliom_common.SCData_session_expired ->
-               None
-           | Eliom_common.SC c ->
-               Some
-                 ( c.Eliom_common.dc_hvalue
-                 , c.Eliom_common.dc_set_value
-                 , !(c.Eliom_common.dc_cookie_exp) )
-         in
-         old, newinfo)
-    else fail Not_found
+      let old, newi = Lazy.force v in
+      let newinfo =
+        match !newi with
+        | Eliom_common.SCNo_data | Eliom_common.SCData_session_expired -> None
+        | Eliom_common.SC c ->
+            Some
+              ( c.Eliom_common.dc_hvalue
+              , c.Eliom_common.dc_set_value
+              , !(c.Eliom_common.dc_cookie_exp) )
+      in
+      old, newinfo
+    else raise Not_found
   in
   let getpersvexp v =
     if Lazy.is_val v
     then
-      Lazy.force v >>= fun (old, newi) ->
-      return
-        (let oldinfo =
-           match old with None -> None | Some (v, _, _, _) -> Some v
-         in
-         let newinfo =
-           match !newi with
-           | Eliom_common.SCNo_data | Eliom_common.SCData_session_expired ->
-               None
-           | Eliom_common.SC c ->
-               Some
-                 ( c.Eliom_common.pc_hvalue
-                 , c.Eliom_common.pc_set_value
-                 , !(c.Eliom_common.pc_cookie_exp) )
-         in
-         oldinfo, newinfo)
-    else fail Not_found
+      let old, newi = Lazy.force v in
+      let oldinfo =
+        match old with None -> None | Some (v, _, _, _) -> Some v
+      in
+      let newinfo =
+        match !newi with
+        | Eliom_common.SCNo_data | Eliom_common.SCData_session_expired -> None
+        | Eliom_common.SC c ->
+            Some
+              ( c.Eliom_common.pc_hvalue
+              , c.Eliom_common.pc_set_value
+              , !(c.Eliom_common.pc_cookie_exp) )
+      in
+      oldinfo, newinfo
+    else raise Not_found
   in
   let ch_exp = function
     | Eliom_common.CENothing | Eliom_common.CEBrowser -> None
     | Eliom_common.CESome a -> Some a
   in
   let aux f cookiekind secure tab2 cooktab =
-    cooktab >>= fun cooktab ->
+    let cooktab = cooktab in
     Eliom_common.Full_state_name_table.fold
       (fun full_st_name value beg ->
-         beg >>= fun beg ->
-         catch
-           (fun () ->
-              f value >>= fun (old, newc) ->
-              return
-                (match old, newc with
-                | None, None -> beg
-                | Some _, None ->
-                    Ocsigen_cookie_map.add
-                      ~path:(Eliom_common.get_site_dir sitedata)
-                      (Eliom_common.make_full_cookie_name cookiekind
-                         full_st_name)
-                      OUnset beg
-                (* the path is always site_dir because the cookie cannot
+         let beg = beg in
+         try
+           let old, newc = f value in
+           match old, newc with
+           | None, None -> beg
+           | Some _, None ->
+               Ocsigen_cookie_map.add
+                 ~path:(Eliom_common.get_site_dir sitedata)
+                 (Eliom_common.make_full_cookie_name cookiekind full_st_name)
+                 OUnset beg
+           (* the path is always site_dir because the cookie cannot
                  have been unset by a service outside
                  this site directory *)
-                | _, Some (_, Some v, exp) ->
-                    (* New value *)
-                    Ocsigen_cookie_map.add
-                      ~path:(Eliom_common.get_site_dir sitedata)
-                      (Eliom_common.make_full_cookie_name cookiekind
-                         full_st_name)
-                      (OSet (ch_exp exp, v, secure))
-                      beg
-                | Some oldv, Some (_, None, exp) ->
-                    if exp = Eliom_common.CENothing
-                    then beg
-                    else
-                      Ocsigen_cookie_map.add
-                        ~path:(Eliom_common.get_site_dir sitedata)
-                        (Eliom_common.make_full_cookie_name cookiekind
-                           full_st_name)
-                        (OSet (ch_exp exp, oldv, secure))
-                        beg
-                | None, Some (_, None, _) ->
-                    (* Should not happen *)
-                    beg))
-           (function Not_found -> return beg | e -> fail e))
-      tab2 (return cooktab)
+           | _, Some (_, Some v, exp) ->
+               (* New value *)
+               Ocsigen_cookie_map.add
+                 ~path:(Eliom_common.get_site_dir sitedata)
+                 (Eliom_common.make_full_cookie_name cookiekind full_st_name)
+                 (OSet (ch_exp exp, v, secure))
+                 beg
+           | Some oldv, Some (_, None, exp) ->
+               if exp = Eliom_common.CENothing
+               then beg
+               else
+                 Ocsigen_cookie_map.add
+                   ~path:(Eliom_common.get_site_dir sitedata)
+                   (Eliom_common.make_full_cookie_name cookiekind full_st_name)
+                   (OSet (ch_exp exp, oldv, secure))
+                   beg
+           | None, Some (_, None, _) ->
+               (* Should not happen *)
+               beg
+         with
+         | Not_found -> beg
+         | e -> raise e)
+      tab2 cooktab
   in
   aux getpersvexp Eliom_common.persistentcookiename false !pers_cookies_info
     (aux getdatavexp Eliom_common.datacookiename false !data_cookie_info
@@ -494,7 +483,7 @@ let compute_session_cookies_to_send
              !pers_cookies_info
              (aux getdatavexp Eliom_common.datacookiename true !data_cookie_info
                 (aux getservvexp Eliom_common.servicecookiename true
-                   !service_cookie_info (return endlist))))))
+                   !service_cookie_info endlist)))))
 
 let compute_cookies_to_send = compute_session_cookies_to_send
 
@@ -532,7 +521,7 @@ let compute_new_ri_cookies
       (ricookies : string Ocsigen_cookie_map.Map_inner.t)
       ((ci, secure_ci) : Eliom_common.tables Eliom_common.cookie_info)
       (cookies_set_by_page : Ocsigen_cookie_map.t) :
-  string Ocsigen_cookie_map.Map_inner.t Lwt.t
+  string Ocsigen_cookie_map.Map_inner.t
   =
   (* first we add cookies set by page: *)
   let ric = compute_new_ri_cookies' now ripath ricookies cookies_set_by_page in
@@ -591,22 +580,22 @@ let compute_new_ri_cookies
                Eliom_common.make_full_cookie_name
                  Eliom_common.persistentcookiename full_st_name
              in
-             beg >>= fun beg ->
+             let beg = beg in
              if Lazy.is_val v
              then
-               Lazy.force v >>= fun (_, v) ->
+               let _, v = Lazy.force v in
                match !v with
                | Eliom_common.SCData_session_expired | Eliom_common.SCNo_data ->
-                   Lwt.return (Ocsigen_cookie_map.Map_inner.remove n beg)
+                   Ocsigen_cookie_map.Map_inner.remove n beg
                | Eliom_common.SC {Eliom_common.pc_set_value = Some v; _} ->
-                   Lwt.return (Ocsigen_cookie_map.Map_inner.add n v beg)
-               | Eliom_common.SC {Eliom_common.pc_set_value = None; _} ->
-                   Lwt.return beg
-             else return beg)
-        !pers_cookie_info (Lwt.return ric)
+                   Ocsigen_cookie_map.Map_inner.add n v beg
+               | Eliom_common.SC {Eliom_common.pc_set_value = None; _} -> beg
+             else beg)
+        !pers_cookie_info ric
     in
     ric
   in
-  f false ci ric >>= fun ric -> f true secure_ci ric
+  let ric = f false ci ric in
+  f true secure_ci ric
 (*VVV We always keep secure cookies, even if the protocol is not secure,
   because this function is for actions only. Is that right? *)
diff --git a/src/lib/server/eliommod_cookies.mli b/src/lib/server/eliommod_cookies.mli
index dcc3824cef..a1d14ef762 100644
--- a/src/lib/server/eliommod_cookies.mli
+++ b/src/lib/server/eliommod_cookies.mli
@@ -43,13 +43,13 @@ val compute_session_cookies_to_send :
    Eliom_common.sitedata
   -> Eliom_common.tables Eliom_common.cookie_info
   -> Ocsigen_cookie_map.t
-  -> Ocsigen_cookie_map.t Lwt.t
+  -> Ocsigen_cookie_map.t
 
 val compute_cookies_to_send :
    Eliom_common.sitedata
   -> Eliom_common.tables Eliom_common.cookie_info
   -> Ocsigen_cookie_map.t
-  -> Ocsigen_cookie_map.t Lwt.t
+  -> Ocsigen_cookie_map.t
 
 val compute_new_ri_cookies :
    float
@@ -57,7 +57,7 @@ val compute_new_ri_cookies :
   -> string Ocsigen_cookie_map.Map_inner.t
   -> Eliom_common.tables Eliom_common.cookie_info
   -> Ocsigen_cookie_map.t
-  -> string Ocsigen_cookie_map.Map_inner.t Lwt.t
+  -> string Ocsigen_cookie_map.Map_inner.t
 
 type date = float
 
@@ -74,15 +74,11 @@ module Persistent_cookies : sig
   module Expiry_dates : sig
     include Ocsipersist.TABLE with type key = date and type value = string
 
-    val add_cookie : date -> string -> unit Lwt.t
-    val remove_cookie : date option -> string -> unit Lwt.t
+    val add_cookie : date -> string -> unit
+    val remove_cookie : date option -> string -> unit
   end
 
-  val add : string -> cookie -> unit Lwt.t
-  val replace_if_exists : string -> cookie -> unit Lwt.t
-
-  val garbage_collect :
-     section:Logs.src
-    -> (Cookies.key -> unit Lwt.t)
-    -> unit Lwt.t
+  val add : string -> cookie -> unit
+  val replace_if_exists : string -> cookie -> unit
+  val garbage_collect : section:Logs.src -> (Cookies.key -> unit) -> unit
 end
diff --git a/src/lib/server/eliommod_gc.ml b/src/lib/server/eliommod_gc.ml
index f686e2e59f..58f010ebc4 100644
--- a/src/lib/server/eliommod_gc.ml
+++ b/src/lib/server/eliommod_gc.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -25,7 +25,6 @@ open Lwt.Syntax
 let section = Logs.Src.create "eliom:gc"
 
 open Eliom_lib
-open Lwt
 
 (*****************************************************************************)
 let servicesessiongcfrequency = ref (Some 1200.) (* 20 min ? *)
@@ -41,12 +40,12 @@ let get_persistentsessiongcfrequency () = !persistentsessiongcfrequency
 (* garbage collection of timeouted sessions *)
 let gc_timeouted_services now tables =
   let rec aux t filename direltr thr =
-    thr >>= fun () ->
+    thr;
     (* we wait for the previous one to be completed *)
     match !direltr with
-    | Eliom_common.Dir r ->
-        empty_one r >>= fun () ->
-        (match !r with
+    | Eliom_common.Dir r -> (
+        empty_one r;
+        match !r with
         | Eliom_common.Vide -> (
           match !t with
           | Eliom_common.Vide -> ()
@@ -55,13 +54,12 @@ let gc_timeouted_services now tables =
               if String.Table.is_empty newr
               then t := Eliom_common.Vide
               else t := Eliom_common.Table newr)
-        | _ -> ());
-        Lwt.return_unit
-    | Eliom_common.File ptr ->
+        | _ -> ())
+    | Eliom_common.File ptr -> (
         Eliom_common.Serv_Table.fold
           (*VVV not tail recursive: may be a problem if lots of coservices *)
           (fun ptk (`Ptc (nodeopt, l)) thr ->
-             let* _ = thr in
+             let _ = thr in
              (* we wait for the previous one to be completed *)
              (match nodeopt, l with
              | Some node, {Eliom_common.s_expire = Some (_, e); _} :: _
@@ -98,58 +96,49 @@ let gc_timeouted_services now tables =
                            (`Ptc (nodeopt, newl))
                            ll
                with Not_found -> ()));
-             Lwt.pause ())
-          !ptr return_unit
-        >>= fun () ->
-        (if Eliom_common.Serv_Table.is_empty !ptr
-         then
-           match !t with
-           | Eliom_common.Vide -> ()
-           | Eliom_common.Table tr ->
-               let newr = String.Table.remove filename tr in
-               if String.Table.is_empty newr
-               then t := Eliom_common.Vide
-               else t := Eliom_common.Table newr);
-        Lwt.return_unit
+             Fiber.yield ())
+          !ptr ();
+        if Eliom_common.Serv_Table.is_empty !ptr
+        then
+          match !t with
+          | Eliom_common.Vide -> ()
+          | Eliom_common.Table tr ->
+              let newr = String.Table.remove filename tr in
+              if String.Table.is_empty newr
+              then t := Eliom_common.Vide
+              else t := Eliom_common.Table newr)
   and empty_one t =
     match !t with
-    | Eliom_common.Vide -> Lwt.return_unit
-    | Eliom_common.Table r -> (
+    | Eliom_common.Vide -> ()
+    | Eliom_common.Table r ->
         if String.Table.is_empty r
-        then (
-          t := Eliom_common.Vide;
-          Lwt.return_unit)
-        else
-          String.Table.fold (aux t) r Lwt.return_unit >>= fun () ->
+        then t := Eliom_common.Vide
+        else (
+          String.Table.fold (aux t) r ();
           match !t with
           (* !t has probably changed *)
-          | Eliom_common.Vide -> Lwt.return_unit
+          | Eliom_common.Vide -> ()
           | Eliom_common.Table r ->
-              if String.Table.is_empty r then t := Eliom_common.Vide;
-              Lwt.return_unit)
+              if String.Table.is_empty r then t := Eliom_common.Vide)
   in
-  Lwt_list.iter_s
+  List.iter
     (fun (_, _prio, t) -> empty_one t)
-    tables.Eliom_common.table_services
-  >>= fun () ->
+    tables.Eliom_common.table_services;
   tables.Eliom_common.table_services <-
     List.filter
       (fun r -> !(Tuple3.thd r) <> Eliom_common.Vide)
-      tables.Eliom_common.table_services;
-  Lwt.return_unit
+      tables.Eliom_common.table_services
 
 let gc_timeouted_naservices now tr =
   match !tr with
-  | Eliom_common.AVide -> return_unit
+  | Eliom_common.AVide -> ()
   | Eliom_common.ATable t ->
       if Eliom_common.NAserv_Table.is_empty t
-      then (
-        tr := Eliom_common.AVide;
-        Lwt.return_unit)
+      then tr := Eliom_common.AVide
       else
         Eliom_common.NAserv_Table.fold
           (fun k (_, _, expdate, _, nodeopt) thr ->
-             thr >>= fun () ->
+             thr;
              (match expdate with
              | Some (_, e) when !e < now -> (
                match nodeopt with
@@ -158,8 +147,8 @@ let gc_timeouted_naservices now tr =
                    (* will remove from the table automatically *)
                | _ -> tr := Eliom_common.remove_naservice_table !tr k)
              | _ -> ());
-             Lwt.pause ())
-          t return_unit
+             Fiber.yield ())
+          t ()
 
 (* This is a thread that will work for example every hour. *)
 let service_session_gc sitedata =
@@ -168,70 +157,68 @@ let service_session_gc sitedata =
   | None -> () (* No garbage collection *)
   | Some t ->
       let rec f () =
-        Lwt_unix.sleep t >>= fun () ->
+        Eio_unix.sleep t;
         let service_cookie_table = sitedata.Eliom_common.session_services in
         let now = Unix.time () in
         Logs.info ~src:section (fun fmt -> fmt "GC of service sessions");
         (* public continuation tables: *)
-        (if tables.Eliom_common.table_contains_services_with_timeout
-         then gc_timeouted_services now tables
-         else return_unit)
-        >>= fun () ->
-        (if tables.Eliom_common.table_contains_naservices_with_timeout
-         then gc_timeouted_naservices now tables.Eliom_common.table_naservices
-         else return_unit)
-        >>= fun () ->
-        (* private continuation tables: *)
-        Eliom_common.SessionCookies.fold
-          (fun k
-            { Eliom_common.Service_cookie.session_table = tables
-            ; expiry
-            ; session_group
-            ; session_group_node
-            ; _ }
-            thr ->
-             thr >>= fun () ->
-             (match !expiry with
-               | Some exp when exp < now ->
-                   Eliommod_sessiongroups.Serv.remove session_group_node;
-                   Lwt.return_unit
-               | _ ->
-                   (if tables.Eliom_common.table_contains_services_with_timeout
-                    then gc_timeouted_services now tables
-                    else return_unit)
-                   >>= fun () ->
-                   (if
-                      tables.Eliom_common.table_contains_naservices_with_timeout
-                    then
-                      gc_timeouted_naservices now
-                        tables.Eliom_common.table_naservices
-                    else return_unit)
-                   >>= fun () ->
-                   (match !session_group with
-                   | _, _scope, Right _
-                   (* no group *)
-                   (*VVV check this *)
-                     when Eliommod_sessiongroups.Serv.group_size
-                            ( Eliom_common.get_site_dir_string sitedata
-                            , `Client_process
-                            , Left k )
-                          = 0
-                          (* no tab sessions *)
-                          && Eliom_common.service_tables_are_empty tables ->
-                       (* The session is not used in any table
+        if tables.Eliom_common.table_contains_services_with_timeout
+        then gc_timeouted_services now tables
+        else ();
+        if tables.Eliom_common.table_contains_naservices_with_timeout
+        then gc_timeouted_naservices now tables.Eliom_common.table_naservices
+        else ();
+        f
+          (* private continuation tables: *)
+          (Eliom_common.SessionCookies.fold
+             (fun k
+               { Eliom_common.Service_cookie.session_table = tables
+               ; expiry
+               ; session_group
+               ; session_group_node
+               ; _ }
+               thr ->
+                thr;
+                Fiber.yield
+                  (match !expiry with
+                  | Some exp when exp < now ->
+                      Eliommod_sessiongroups.Serv.remove session_group_node
+                  | _ -> (
+                      if
+                        tables.Eliom_common.table_contains_services_with_timeout
+                      then gc_timeouted_services now tables
+                      else ();
+                      if
+                        tables
+                          .Eliom_common.table_contains_naservices_with_timeout
+                      then
+                        gc_timeouted_naservices now
+                          tables.Eliom_common.table_naservices
+                      else ();
+                      match !session_group with
+                      | _, _scope, Right _
+                      (* no group *)
+                      (*VVV check this *)
+                        when Eliommod_sessiongroups.Serv.group_size
+                               ( Eliom_common.get_site_dir_string sitedata
+                               , `Client_process
+                               , Left k )
+                             = 0
+                             (* no tab sessions *)
+                             && Eliom_common.service_tables_are_empty tables ->
+                          (* The session is not used in any table
                    and is not in a group
                    (scope must be `Session,
                    as all tab sessions are in a group),
                    and is not associated to any tab session.
                    We can remove it. *)
-                       Eliommod_sessiongroups.Serv.remove session_group_node
-                   | _ -> () (*VVV enough? *));
-                   return_unit)
-             >>= Lwt.pause)
-          service_cookie_table return_unit
-        >>= f
+                          Eliommod_sessiongroups.Serv.remove session_group_node
+                      | _ -> () (*VVV enough? *))))
+             service_cookie_table ())
       in
-      Lwt.async f
+      Fiber.fork
+        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+        f
 
 (* This is a thread that will work for example every hour. *)
 let data_session_gc sitedata =
@@ -239,58 +226,58 @@ let data_session_gc sitedata =
   | None -> () (* No garbage collection *)
   | Some t ->
       let rec f () =
-        Lwt_unix.sleep t >>= fun () ->
+        Eio_unix.sleep t;
         let data_cookie_table = sitedata.Eliom_common.session_data in
         let not_bound_in_data_tables =
           sitedata.Eliom_common.not_bound_in_data_tables
         in
         let now = Unix.time () in
         Logs.info ~src:section (fun fmt -> fmt "GC of session data");
-        (* private continuation tables: *)
-        Eliom_common.SessionCookies.fold
-          (fun k
-            { Eliom_common.Data_cookie.expiry
-            ; session_group
-            ; session_group_node
-            ; _ }
-            thr ->
-             thr >>= fun () ->
-             (match !expiry with
-               | Some exp when exp < now ->
-                   Eliommod_sessiongroups.Data.remove session_group_node;
-                   return_unit
-               | _ -> (
-                 match !session_group with
-                 | _, scope, Right _
-                 (* no group *)
-                   when Eliommod_sessiongroups.Data.group_size
-                          ( Eliom_common.get_site_dir_string sitedata
-                          , `Client_process
-                          , Left k )
-                        = 0
-                        (* no tab sessions *)
-                        && not_bound_in_data_tables k ->
-                     (* The session is not used in any table
+        f
+          (* private continuation tables: *)
+          (Eliom_common.SessionCookies.fold
+             (fun k
+               { Eliom_common.Data_cookie.expiry
+               ; session_group
+               ; session_group_node
+               ; _ }
+               thr ->
+                thr;
+                Fiber.yield
+                  (match !expiry with
+                  | Some exp when exp < now ->
+                      Eliommod_sessiongroups.Data.remove session_group_node
+                  | _ -> (
+                    match !session_group with
+                    | _, scope, Right _
+                    (* no group *)
+                      when Eliommod_sessiongroups.Data.group_size
+                             ( Eliom_common.get_site_dir_string sitedata
+                             , `Client_process
+                             , Left k )
+                           = 0
+                           (* no tab sessions *)
+                           && not_bound_in_data_tables k ->
+                        (* The session is not used in any table
                           and is not in a group
                           (scope must be `Session,
                           as all tab sessions are in a group),
                           and is not associated to any tab session.
                           We can remove it. *)
-                     if scope <> `Session
-                     then
-                       Logs.err ~src:section (fun fmt ->
-                         fmt
-                           "Eliom: Group associated to IP has scope different from `Session. Please report the problem.");
-                     Eliommod_sessiongroups.Data.remove session_group_node;
-                     (* See also the finalisers in Eliommod_sessiongroups
+                        if scope <> `Session
+                        then
+                          Logs.err ~src:section (fun fmt ->
+                            fmt
+                              "Eliom: Group associated to IP has scope different from `Session. Please report the problem.");
+                        Eliommod_sessiongroups.Data.remove session_group_node
+                        (* See also the finalisers in Eliommod_sessiongroups
                           and Eliommod.ml *)
-                     Lwt.return_unit
-                 | _ -> Lwt.return_unit))
-             >>= Lwt.pause)
-          data_cookie_table return_unit
-        >>= f
+                    | _ -> ())))
+             data_cookie_table ())
       in
-      Lwt.async f
+      Fiber.fork
+        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+        f
 
 (* garbage collection of timeouted persistent sessions *)
 (* This is a thread that will work every hour/day *)
@@ -312,19 +299,15 @@ let persistent_session_gc sitedata =
       (*WAS: remove_from_all_persistent_tables k *)
       | _ ->
           Logs.info ~src:section (fun fmt ->
-            fmt "cookie not expired: %s" (log_hash cookie));
-          return_unit
+            fmt "cookie not expired: %s" (log_hash cookie))
     in
     let gc_cookie c =
-      Lwt.try_bind
-        (fun () -> Eliommod_cookies.Persistent_cookies.Cookies.find c)
-        (do_gc_cookie c)
-        (function
-          | Not_found ->
-              Logs.info ~src:section (fun fmt ->
-                fmt "cookie does not exist: %s" (log_hash c));
-              Lwt.return_unit
-          | exn -> Lwt.fail exn)
+      match Eliommod_cookies.Persistent_cookies.Cookies.find c with
+      | v -> (do_gc_cookie c) v
+      | exception Not_found ->
+          Logs.info ~src:section (fun fmt ->
+            fmt "cookie does not exist: %s" (log_hash c))
+      | exception exn -> raise exn
     in
     Logs.info ~src:section (fun fmt -> fmt "GC of persistent sessions");
     Eliommod_cookies.Persistent_cookies.garbage_collect ~section gc_cookie
@@ -332,5 +315,7 @@ let persistent_session_gc sitedata =
   match get_persistentsessiongcfrequency () with
   | None -> () (* No garbage collection *)
   | Some t ->
-      let rec f () = Lwt_unix.sleep t >>= gc >>= f in
-      Lwt.async f
+      let rec f () = f (gc (Eio_unix.sleep t)) in
+      Fiber.fork
+        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+        f
diff --git a/src/lib/server/eliommod_pagegen.ml b/src/lib/server/eliommod_pagegen.ml
index 0de9ab2a46..5929bc2d61 100644
--- a/src/lib/server/eliommod_pagegen.ml
+++ b/src/lib/server/eliommod_pagegen.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -20,8 +20,6 @@ open Lwt.Syntax
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *)
 
-open Lwt.Infix
-
 let headers_with_content_type headers =
   Cohttp.Header.add_opt headers
     Ocsigen_header.Name.(to_string content_type)
@@ -38,13 +36,13 @@ let make_response ?headers ~status body =
     let headers = headers_with_content_type headers in
     Cohttp.Response.make ~status ~headers ()
   in
-  Lwt.return (Ocsigen_response.make ~body response)
+  Ocsigen_response.make ~body response
 
 (* module Html_content = Ocsigen_senders.Make_XML_Content(Xml)(Html.F) *)
 
 (* Exception handler for the site *)
 
-let def_handler e = Lwt.fail e
+let def_handler e = raise e
 
 (* Update cookie tables *)
 let update_cookie_table ?now sitedata (ci, sci) =
@@ -124,11 +122,11 @@ let update_cookie_table ?now sitedata (ci, sci) =
       Eliom_common.Full_state_name_table.fold
         (fun name v thr ->
            let thr2 =
-             Lazy.force v >>= fun (oldvalue, newr) ->
+             let oldvalue, newr = Lazy.force v in
              match !newr with
              | Eliom_common.SCData_session_expired | Eliom_common.SCNo_data ->
                  (* The cookie has been removed *)
-                 Lwt.return ()
+                 ()
              | Eliom_common.SC newc -> (
                  let newexp =
                    match !(newc.Eliom_common.pc_timeout) with
@@ -148,30 +146,27 @@ let update_cookie_table ?now sitedata (ci, sci) =
                         && oldti = !(newc.Eliom_common.pc_timeout)
                         && oldgrp = !(newc.Eliom_common.pc_session_group)
                         && newc.Eliom_common.pc_set_value = None ->
-                     Lwt.return ()
+                     ()
                  (* nothing to do *)
                  | Some (_, _oldti, oldexp, _oldgrp)
-                   when newc.Eliom_common.pc_set_value = None ->
-                     Lwt.catch
-                       (fun () ->
-                          let cookieid =
-                            Eliom_common.(
-                              Hashed_cookies.to_string newc.pc_hvalue)
-                          in
-                          Eliommod_cookies.Persistent_cookies.replace_if_exists
-                            cookieid
-                            { Eliommod_cookies.full_state_name = name
-                            ; expiry = newexp
-                            ; timeout = !(newc.Eliom_common.pc_timeout)
-                            ; session_group =
-                                !(newc.Eliom_common.pc_session_group) }
-                          >>= fun () ->
-                          Eliommod_cookies.Persistent_cookies.Expiry_dates
-                          .remove_cookie oldexp cookieid)
-                       (function
-                         | Not_found -> Lwt.return ()
-                         (* someone else closed the session *)
-                         | e -> Lwt.fail e)
+                   when newc.Eliom_common.pc_set_value = None -> (
+                   try
+                     let cookieid =
+                       Eliom_common.(Hashed_cookies.to_string newc.pc_hvalue)
+                     in
+                     Eliommod_cookies.Persistent_cookies.replace_if_exists
+                       cookieid
+                       { Eliommod_cookies.full_state_name = name
+                       ; expiry = newexp
+                       ; timeout = !(newc.Eliom_common.pc_timeout)
+                       ; session_group = !(newc.Eliom_common.pc_session_group)
+                       };
+                     Eliommod_cookies.Persistent_cookies.Expiry_dates
+                     .remove_cookie oldexp cookieid
+                   with
+                   | Not_found -> ()
+                   (* someone else closed the session *)
+                   | e -> raise e)
                  | _ ->
                      Eliommod_cookies.Persistent_cookies.add
                        Eliom_common.(Hashed_cookies.to_string newc.pc_hvalue)
@@ -185,11 +180,11 @@ let update_cookie_table ?now sitedata (ci, sci) =
           otherwise the server will crash!!!
              *)
            in
-           thr >>= fun () -> thr2)
-        !pers_cookies_info Lwt.return_unit
-    else Lwt.return_unit
+           thr; thr2)
+        !pers_cookies_info ()
+    else ()
   in
-  update_exp ci >>= fun () ->
+  update_exp ci;
   (* the same, for secure cookies: *)
   update_exp sci
 
@@ -203,14 +198,13 @@ let execute
       ({Eliom_common.all_cookie_info; tab_cookie_info; _} as info)
       sitedata
   =
-  let* result =
-    Lwt.catch
-      (fun () -> generate_page now info sitedata)
-      (fun e -> sitedata.Eliom_common.exn_handler e)
+  let result =
+    try generate_page now info sitedata
+    with e -> sitedata.Eliom_common.exn_handler e
   in
-  let* () = update_cookie_table ~now sitedata all_cookie_info in
-  let* () = update_cookie_table ~now sitedata tab_cookie_info in
-  Lwt.return result
+  let () = update_cookie_table ~now sitedata all_cookie_info in
+  let () = update_cookie_table ~now sitedata tab_cookie_info in
+  result
 
 (** Set expired sessions in request data *)
 let set_expired_sessions ri closedservsessions =
@@ -236,13 +230,13 @@ let do_redirection header_id status uri =
         in
         Cohttp.Response.make ~status ~headers ()
       in
-      Lwt.return (Ocsigen_response.make response))
+      Ocsigen_response.make response)
 
 let gen_req_not_found ~is_eliom_extension ~sitedata ~previous_extension_err ~req
   =
   let req = Eliom_common.patch_request_info req in
   let now = Unix.gettimeofday () in
-  let* ri, si, previous_tab_cookies_info =
+  let ri, si, previous_tab_cookies_info =
     Eliom_common.get_session_info ~sitedata ~req 404
   in
   let all_cookie_info, closedsessions =
@@ -275,105 +269,96 @@ let gen_req_not_found ~is_eliom_extension ~sitedata ~previous_extension_err ~req
     let sp = Eliom_common.make_server_params sitedata info None None in
     (* The last two arguments are not yet available, so for now we use None.
        This value will later be overwritten once this information is available. *)
-    Lwt.with_value Eliom_common.sp_key (Some sp) @@ fun () ->
-    let genfun =
-      match si.Eliom_common.si_nonatt_info with
-      | Eliom_common.RNa_no ->
-          (* page generation *)
-          Eliom_route.get_page
-      | _ ->
-          (* anonymous service *)
-          Eliom_route.make_naservice
-    in
-    Lwt.catch
-      (fun () ->
-         let* res = execute now genfun info sitedata in
-         let response = Ocsigen_response.response res
-         and all_user_cookies = Ocsigen_response.cookies res in
-         let* cookies =
-           Eliommod_cookies.compute_cookies_to_send sitedata all_cookie_info
-             all_user_cookies
-         in
-         let res =
-           match
-             Ocsigen_request.header ri.Ocsigen_extensions.request_info
-               (Ocsigen_header.Name.of_string
-                  Eliom_common_base.cookie_substitutes_header_name)
-           with
-           | Some _ ->
-               let response =
-                 let headers =
-                   Cohttp.Header.add
-                     (Cohttp.Response.headers response)
-                     Eliom_common_base.set_cookie_substitutes_header_name
-                     (Eliommod_cookies.cookieset_to_json cookies)
-                 in
-                 {response with Cohttp.Response.headers}
-               in
-               Ocsigen_response.update ~response ~cookies res
-           | None -> Ocsigen_response.update ~cookies res
-         in
-         try
-           Polytables.get
-             ~table:
-               (Ocsigen_request.request_cache ri.Ocsigen_extensions.request_info)
-             ~key:Eliom_common.found_stop_key;
-           (* if we find this information in request cache,
+    Fiber.with_binding Eliom_common.sp_key sp (fun () ->
+      let genfun =
+        match si.Eliom_common.si_nonatt_info with
+        | Eliom_common.RNa_no ->
+            (* page generation *)
+            Eliom_route.get_page
+        | _ ->
+            (* anonymous service *)
+            Eliom_route.make_naservice
+      in
+      try
+        let res = execute now genfun info sitedata in
+        let response = Ocsigen_response.response res
+        and all_user_cookies = Ocsigen_response.cookies res in
+        let cookies =
+          Eliommod_cookies.compute_cookies_to_send sitedata all_cookie_info
+            all_user_cookies
+        in
+        let res =
+          match
+            Ocsigen_request.header ri.Ocsigen_extensions.request_info
+              (Ocsigen_header.Name.of_string
+                 Eliom_common_base.cookie_substitutes_header_name)
+          with
+          | Some _ ->
+              let response =
+                let headers =
+                  Cohttp.Header.add
+                    (Cohttp.Response.headers response)
+                    Eliom_common_base.set_cookie_substitutes_header_name
+                    (Eliommod_cookies.cookieset_to_json cookies)
+                in
+                {response with Cohttp.Response.headers}
+              in
+              Ocsigen_response.update ~response ~cookies res
+          | None -> Ocsigen_response.update ~cookies res
+        in
+        try
+          Polytables.get
+            ~table:
+              (Ocsigen_request.request_cache ri.Ocsigen_extensions.request_info)
+            ~key:Eliom_common.found_stop_key;
+          (* if we find this information in request cache,
               the request has already been completed.
               (used after an action).
               Do not try the following extensions.
-           *)
-           Lwt.return
-             (Ocsigen_extensions.Ext_found_stop (fun () -> Lwt.return res))
-         with Not_found ->
-           Lwt.return (Ocsigen_extensions.Ext_found (fun () -> Lwt.return res)))
-      (function
-        (* FIXME COHTTP transition ; restore all that *)
-        | Eliom_common.Eliom_Typing_Error l ->
-            Lwt.return
-              (Ocsigen_extensions.Ext_found
-                 (fun () ->
-                   make_response ~status:`Bad_request
-                     (Eliom_error_pages.page_error_param_type l)))
-        | Eliom_common.Eliom_Wrong_parameter ->
-            let* ripp =
-              match
-                Ocsigen_request.post_params req.request_info
-                  ri.request_config.Ocsigen_extensions.uploaddir
-                  ri.request_config.Ocsigen_extensions.maxuploadfilesize
-              with
-              | None -> Lwt.return []
-              | Some l -> l
-            in
-            let response =
-              Eliom_error_pages.page_bad_param
-                (try
-                   ignore
-                   @@ Polytables.get
-                        ~table:(Ocsigen_request.request_cache ri.request_info)
-                        ~key:Eliom_common.eliom_params_after_action;
-                   true
-                 with Not_found -> false)
-                (Ocsigen_request.get_params_flat ri.request_info)
-                (List.map fst ripp)
-            in
-            Lwt.return
-            @@ Ocsigen_extensions.Ext_found
-                 (fun () -> make_response ~status:`Bad_request response)
-        | Eliom_common.Eliom_404 ->
-            Lwt.return (Ocsigen_extensions.Ext_next previous_extension_err)
-        | Eliom_common.Eliom_retry_with a -> gen_aux a
-        | Eliom_common.Eliom_do_redirection uri ->
-            Lwt.return
-            @@ do_redirection Ocsigen_header.Name.location `Temporary_redirect
-                 uri
-        | Eliom_common.Eliom_do_half_xhr_redirection uri ->
-            Lwt.return
-            @@ do_redirection
-                 (Ocsigen_header.Name.of_string
-                    Eliom_common.half_xhr_redir_header)
-                 `No_content uri
-        | e -> Lwt.fail e)
+          *)
+          Ocsigen_extensions.Ext_found_stop (fun () -> res)
+        with Not_found -> Ocsigen_extensions.Ext_found (fun () -> res)
+      with
+      (* FIXME COHTTP transition ; restore all that *)
+      | Eliom_common.Eliom_Typing_Error l ->
+          Ocsigen_extensions.Ext_found
+            (fun () ->
+              make_response ~status:`Bad_request
+                (Eliom_error_pages.page_error_param_type l))
+      | Eliom_common.Eliom_Wrong_parameter ->
+          let ripp =
+            match
+              Ocsigen_request.post_params req.request_info
+                ri.request_config.Ocsigen_extensions.uploaddir
+                ri.request_config.Ocsigen_extensions.maxuploadfilesize
+            with
+            | None -> []
+            | Some l -> l
+          in
+          let response =
+            Eliom_error_pages.page_bad_param
+              (try
+                 ignore
+                 @@ Polytables.get
+                      ~table:(Ocsigen_request.request_cache ri.request_info)
+                      ~key:Eliom_common.eliom_params_after_action;
+                 true
+               with Not_found -> false)
+              (Ocsigen_request.get_params_flat ri.request_info)
+              (List.map fst ripp)
+          in
+          Ocsigen_extensions.Ext_found
+            (fun () -> make_response ~status:`Bad_request response)
+      | Eliom_common.Eliom_404 ->
+          Ocsigen_extensions.Ext_next previous_extension_err
+      | Eliom_common.Eliom_retry_with a -> gen_aux a
+      | Eliom_common.Eliom_do_redirection uri ->
+          do_redirection Ocsigen_header.Name.location `Temporary_redirect uri
+      | Eliom_common.Eliom_do_half_xhr_redirection uri ->
+          do_redirection
+            (Ocsigen_header.Name.of_string Eliom_common.half_xhr_redir_header)
+            `No_content uri
+      | e -> raise e)
   in
   let info =
     { Eliom_common.request = ri
@@ -389,9 +374,9 @@ let gen_req_not_found ~is_eliom_extension ~sitedata ~previous_extension_err ~req
 let gen is_eliom_extension sitedata =
   let open Ocsigen_extensions in
   function
-  | Req_found _ -> Lwt.return Ext_do_nothing
+  | Req_found _ -> Ext_do_nothing
   | Req_not_found ((`Not_found as previous_extension_err), req)
     when handled_method (Ocsigen_request.meth req.request_info) ->
       gen_req_not_found ~is_eliom_extension ~sitedata ~previous_extension_err
         ~req
-  | Req_not_found (_, _ri) -> Lwt.return Ext_do_nothing
+  | Req_not_found (_, _ri) -> Ext_do_nothing
diff --git a/src/lib/server/eliommod_pagegen.mli b/src/lib/server/eliommod_pagegen.mli
index b10b1997b6..a9371f1c2c 100644
--- a/src/lib/server/eliommod_pagegen.mli
+++ b/src/lib/server/eliommod_pagegen.mli
@@ -17,26 +17,23 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *)
-val def_handler : exn -> 'b Lwt.t
+val def_handler : exn -> 'b
 
 val execute :
    float
-  -> (float
-      -> Eliom_common.info
-      -> Eliom_common.sitedata
-      -> Ocsigen_response.t Lwt.t)
+  -> (float -> Eliom_common.info -> Eliom_common.sitedata -> Ocsigen_response.t)
   -> Eliom_common.info
   -> Eliom_common.sitedata
-  -> Ocsigen_response.t Lwt.t
+  -> Ocsigen_response.t
 
 val gen :
    Eliom_extension.eliom_extension_sig option
   -> Eliom_common.sitedata
   -> Ocsigen_extensions.request_state
-  -> Ocsigen_extensions.answer Lwt.t
+  -> Ocsigen_extensions.answer
 
 val update_cookie_table :
    ?now:float
   -> Eliom_common.sitedata
   -> Eliom_common.tables Eliom_common.cookie_info
-  -> unit Lwt.t
+  -> unit
diff --git a/src/lib/server/eliommod_persess.ml b/src/lib/server/eliommod_persess.ml
index 91dd54471f..491040490b 100644
--- a/src/lib/server/eliommod_persess.ml
+++ b/src/lib/server/eliommod_persess.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -31,8 +31,6 @@ open Lwt.Syntax
 (*****************************************************************************)
 (* Persistent sessions: *)
 
-open Lwt
-
 let compute_cookie_info sitedata secure_o secure_ci cookie_info =
   let secure = Eliom_common.get_secure ~secure_o ~sitedata () in
   if secure
@@ -56,34 +54,32 @@ let close_persistent_state2 ~(scope : [< Eliom_common.user_scope]) sitedata sg v
 (* close current persistent session *)
 let close_persistent_state ~scope ~secure_o ?sp () =
   let sp = Eliom_common.sp_of_option sp in
-  catch
-    (fun () ->
-       let cookie_level = Eliom_common.cookie_level_of_user_scope scope in
-       let (_, _, cookie_info), secure_ci =
-         Eliom_common.get_cookie_info sp cookie_level
-       in
-       let sitedata = Eliom_request_info.get_sitedata_sp ~sp in
-       let cookie_info, secure =
-         compute_cookie_info sitedata secure_o secure_ci cookie_info
-       in
-       let full_st_name =
-         Eliom_common.make_full_state_name ~sp ~secure ~scope
-       in
-       Lazy.force
-         (Eliom_common.Full_state_name_table.find full_st_name !cookie_info)
-       >>= fun (_, ior) ->
-       match !ior with
-       | Eliom_common.SC c ->
-           close_persistent_state2
-             ~scope:(scope :> Eliom_common.user_scope)
-             sp.Eliom_common.sp_sitedata
-             !(c.Eliom_common.pc_session_group)
-             Eliom_common.(Hashed_cookies.to_string c.pc_hvalue)
-           >>= fun () ->
-           ior := Eliom_common.SCNo_data;
-           return_unit
-       | _ -> return_unit)
-    (function Not_found -> return_unit | e -> fail e)
+  try
+    let cookie_level = Eliom_common.cookie_level_of_user_scope scope in
+    let (_, _, cookie_info), secure_ci =
+      Eliom_common.get_cookie_info sp cookie_level
+    in
+    let sitedata = Eliom_request_info.get_sitedata_sp ~sp in
+    let cookie_info, secure =
+      compute_cookie_info sitedata secure_o secure_ci cookie_info
+    in
+    let full_st_name = Eliom_common.make_full_state_name ~sp ~secure ~scope in
+    let _, ior =
+      Lazy.force
+        (Eliom_common.Full_state_name_table.find full_st_name !cookie_info)
+    in
+    match !ior with
+    | Eliom_common.SC c ->
+        close_persistent_state2
+          ~scope:(scope :> Eliom_common.user_scope)
+          sp.Eliom_common.sp_sitedata
+          !(c.Eliom_common.pc_session_group)
+          Eliom_common.(Hashed_cookies.to_string c.pc_hvalue);
+        ior := Eliom_common.SCNo_data
+    | _ -> ()
+  with
+  | Not_found -> ()
+  | e -> raise e
 
 let fullsessgrp ~cookie_level ~sp session_group =
   Eliommod_sessiongroups.make_persistent_full_group_name ~cookie_level
@@ -101,13 +97,15 @@ let rec find_or_create_persistent_cookie_
   (* if it exists, do not create it, but returns its value *)
   let cookie_level = Eliom_common.cookie_level_of_user_scope cookie_scope in
   let new_persistent_cookie sitedata full_state_name =
-    let* set_session_group =
+    let set_session_group =
       match cookie_scope with
       | `Client_process n ->
-          (* We create a group whose name is the
+          let
+              (* We create a group whose name is the
                    browser session cookie
                    and put the tab session into it. *)
-          let* r =
+                r
+            =
             find_or_create_persistent_cookie_
               ~set_max_in_group:
                 (fst
@@ -115,8 +113,8 @@ let rec find_or_create_persistent_cookie_
                      .Eliom_common.max_persistent_data_tab_sessions_per_group)
               ~cookie_scope:(`Session n) ~secure_o ~sp ()
           in
-          Lwt.return_some Eliom_common.(Hashed_cookies.to_string r.pc_hvalue)
-      | _ -> Lwt.return set_session_group
+          Some Eliom_common.(Hashed_cookies.to_string r.pc_hvalue)
+      | _ -> set_session_group
     in
     let fullsessgrp = fullsessgrp ~cookie_level ~sp set_session_group in
     let c = Eliommod_cookies.make_new_session_id () in
@@ -128,7 +126,7 @@ let rec find_or_create_persistent_cookie_
       ref Eliom_common.TGlobal
       (* See global table *)
     in
-    let* () =
+    let () =
       Eliommod_cookies.Persistent_cookies.add hc_string
         { Eliommod_cookies.full_state_name
         ; expiry = None
@@ -136,23 +134,22 @@ let rec find_or_create_persistent_cookie_
           timeout = Eliom_common.TGlobal
         ; session_group = fullsessgrp }
     in
-    Eliommod_sessiongroups.Pers.add ?set_max:set_max_in_group
-      (fst sitedata.Eliom_common.max_persistent_data_sessions_per_group)
-      hc_string fullsessgrp
-    >>= fun l ->
-    Lwt_list.iter_p
+    let l =
+      Eliommod_sessiongroups.Pers.add ?set_max:set_max_in_group
+        (fst sitedata.Eliom_common.max_persistent_data_sessions_per_group)
+        hc_string fullsessgrp
+    in
+    Fiber.List.iter
       (close_persistent_state2
          ~scope:(cookie_scope :> Eliom_common.user_scope)
          sitedata None)
-      l
-    >>= fun () ->
-    Lwt.return
-      { Eliom_common.pc_hvalue = hc
-      ; Eliom_common.pc_set_value = Some c
-      ; Eliom_common.pc_timeout = usertimeout
-      ; Eliom_common.pc_cookie_exp =
-          ref (Eliom_common.default_client_cookie_exp ()) (* exp on client *)
-      ; Eliom_common.pc_session_group = ref fullsessgrp }
+      l;
+    { Eliom_common.pc_hvalue = hc
+    ; Eliom_common.pc_set_value = Some c
+    ; Eliom_common.pc_timeout = usertimeout
+    ; Eliom_common.pc_cookie_exp =
+        ref (Eliom_common.default_client_cookie_exp ()) (* exp on client *)
+    ; Eliom_common.pc_session_group = ref fullsessgrp }
   in
   let (_, _, cookie_info), secure_ci =
     Eliom_common.get_cookie_info sp cookie_level
@@ -164,29 +161,29 @@ let rec find_or_create_persistent_cookie_
   let full_st_name =
     Eliom_common.make_full_state_name ~sp ~secure ~scope:cookie_scope
   in
-  catch
-    (fun () ->
-       Lazy.force
-         (Eliom_common.Full_state_name_table.find full_st_name !cookie_info)
-       >>= fun (_old, ior) ->
-       match !ior with
-       | Eliom_common.SCData_session_expired
-         (* We do not trust the value sent by the client,
+  try
+    let _old, ior =
+      Lazy.force
+        (Eliom_common.Full_state_name_table.find full_st_name !cookie_info)
+    in
+    match !ior with
+    | Eliom_common.SCData_session_expired
+      (* We do not trust the value sent by the client,
              for security reasons *)
-       | Eliom_common.SCNo_data ->
-           new_persistent_cookie sitedata full_st_name >>= fun v ->
-           ior := Eliom_common.SC v;
-           return v
-       | Eliom_common.SC v -> return v)
-    (function
-      | Not_found ->
-          new_persistent_cookie sitedata full_st_name >>= fun v ->
-          cookie_info :=
-            Eliom_common.Full_state_name_table.add full_st_name
-              (Lazy.from_val (return (None, ref (Eliom_common.SC v))))
-              !cookie_info;
-          return v
-      | e -> fail e)
+    | Eliom_common.SCNo_data ->
+        let v = new_persistent_cookie sitedata full_st_name in
+        ior := Eliom_common.SC v;
+        v
+    | Eliom_common.SC v -> v
+  with
+  | Not_found ->
+      let v = new_persistent_cookie sitedata full_st_name in
+      cookie_info :=
+        Eliom_common.Full_state_name_table.add full_st_name
+          (Lazy.from_val (None, ref (Eliom_common.SC v)))
+          !cookie_info;
+      v
+  | e -> raise e
 
 let find_or_create_persistent_cookie
       ?set_session_group
@@ -206,13 +203,13 @@ let find_or_create_persistent_cookie =
       -> secure_o:bool option
       -> ?sp:Eliom_common.server_params
       -> unit
-      -> Eliom_common.one_persistent_cookie_info Lwt.t
+      -> Eliom_common.one_persistent_cookie_info
     :> ?set_session_group:string
        -> cookie_scope:[< Eliom_common.cookie_scope]
        -> secure_o:bool option
        -> ?sp:Eliom_common.server_params
        -> unit
-       -> Eliom_common.one_persistent_cookie_info Lwt.t)
+       -> Eliom_common.one_persistent_cookie_info)
 
 let find_persistent_cookie_only ~cookie_scope ~secure_o ?sp () =
   (* If the cookie does not exist, do not create it, raise Not_found.
@@ -229,10 +226,12 @@ let find_persistent_cookie_only ~cookie_scope ~secure_o ?sp () =
   let full_st_name =
     Eliom_common.make_full_state_name ~sp ~secure ~scope:cookie_scope
   in
-  Lazy.force (Eliom_common.Full_state_name_table.find full_st_name !cookie_info)
-  >>= fun (_, ior) ->
+  let _, ior =
+    Lazy.force
+      (Eliom_common.Full_state_name_table.find full_st_name !cookie_info)
+  in
   match !ior with
   | Eliom_common.SCNo_data -> raise Not_found
   | Eliom_common.SCData_session_expired ->
       raise Eliom_common.Eliom_Session_expired
-  | Eliom_common.SC v -> return v
+  | Eliom_common.SC v -> v
diff --git a/src/lib/server/eliommod_persess.mli b/src/lib/server/eliommod_persess.mli
index e5cd1aed0e..2c10664ee3 100644
--- a/src/lib/server/eliommod_persess.mli
+++ b/src/lib/server/eliommod_persess.mli
@@ -23,14 +23,14 @@ val close_persistent_state2 :
   -> Eliom_common.sitedata
   -> Eliom_common.perssessgrp option
   -> string
-  -> unit Lwt.t
+  -> unit
 
 val close_persistent_state :
    scope:[< Eliom_common.user_scope]
   -> secure_o:bool option
   -> ?sp:Eliom_common.server_params
   -> unit
-  -> unit Lwt.t
+  -> unit
 
 val find_or_create_persistent_cookie :
    ?set_session_group:string
@@ -38,11 +38,11 @@ val find_or_create_persistent_cookie :
   -> secure_o:bool option
   -> ?sp:Eliom_common.server_params
   -> unit
-  -> Eliom_common.one_persistent_cookie_info Lwt.t
+  -> Eliom_common.one_persistent_cookie_info
 
 val find_persistent_cookie_only :
    cookie_scope:[< Eliom_common.cookie_scope]
   -> secure_o:bool option
   -> ?sp:Eliom_common.server_params
   -> unit
-  -> Eliom_common.one_persistent_cookie_info Lwt.t
+  -> Eliom_common.one_persistent_cookie_info
diff --git a/src/lib/server/eliommod_sessadmin.ml b/src/lib/server/eliommod_sessadmin.ml
index f1cf2176d0..f0a8c17273 100644
--- a/src/lib/server/eliommod_sessadmin.ml
+++ b/src/lib/server/eliommod_sessadmin.ml
@@ -1,4 +1,4 @@
-open Lwt.Syntax
+open Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -28,8 +28,6 @@ open Lwt.Syntax
 (*****************************************************************************)
 (*****************************************************************************)
 
-open Lwt
-
 let section = Logs.Src.create "eliom:admin"
 
 (*
@@ -48,11 +46,11 @@ let close_all_service_states2 full_st_name sitedata =
       ; session_group_node
       ; _ }
       thr ->
-       let* () = thr in
+       let () = thr in
        if full_st_name = full_state_name && !timeout = Eliom_common.TGlobal
        then Eliommod_sessiongroups.Serv.remove session_group_node;
-       Lwt.pause ())
-    sitedata.Eliom_common.session_services return_unit
+       Fiber.yield ())
+    sitedata.Eliom_common.session_services ()
 
 (** Close all service states for one session name.
     If the optional parameter [?state_name] (session name) is not present,
@@ -76,11 +74,11 @@ let close_all_data_states2 full_st_name sitedata =
     (fun _
       {Eliom_common.Data_cookie.full_state_name; timeout; session_group_node; _}
       thr ->
-       thr >>= fun () ->
+       thr;
        if full_st_name = full_state_name && !timeout = Eliom_common.TGlobal
        then Eliommod_sessiongroups.Data.remove session_group_node;
-       Lwt.pause ())
-    sitedata.Eliom_common.session_data return_unit
+       Fiber.yield ())
+    sitedata.Eliom_common.session_data ()
 
 (** Close all in memory data sessions for one session name.
     If the optional parameter [?state_name] (session name) is not present,
@@ -108,10 +106,10 @@ let close_all_persistent_states2 full_st_name sitedata =
        let scope = full_state_name.Eliom_common.user_scope in
        if full_st_name = full_state_name && old_t = Eliom_common.TGlobal
        then
-         Eliommod_persess.close_persistent_state2 ~scope sitedata session_group
-           k
-         >>= Lwt.pause
-       else return_unit)
+         Fiber.yield
+           (Eliommod_persess.close_persistent_state2 ~scope sitedata
+              session_group k)
+       else ())
 
 (** Close all persistent sessions for one session name.
     If the optional parameter [?state_name] (session name) is not present,
@@ -148,7 +146,7 @@ let update_serv_exp full_st_name sitedata old_glob_timeout new_glob_timeout =
           ; session_group_node
           ; _ }
           thr ->
-           let* () = thr in
+           let () = thr in
            (if full_st_name = full_state_name && !timeout = Eliom_common.TGlobal
             then
               let newexp =
@@ -161,8 +159,8 @@ let update_serv_exp full_st_name sitedata old_glob_timeout new_glob_timeout =
               | Some t when t <= now ->
                   Eliommod_sessiongroups.Serv.remove session_group_node
               | _ -> expiry := newexp);
-           Lwt.pause ())
-        sitedata.Eliom_common.session_services return_unit
+           Fiber.yield ())
+        sitedata.Eliom_common.session_services ()
 
 (* Update the expiration date for all in memory data sessions                *)
 let update_data_exp full_st_name sitedata old_glob_timeout new_glob_timeout =
@@ -182,7 +180,7 @@ let update_data_exp full_st_name sitedata old_glob_timeout new_glob_timeout =
           ; session_group_node
           ; _ }
           thr ->
-           thr >>= fun () ->
+           thr;
            (if full_st_name = full_state_name && !timeout = Eliom_common.TGlobal
             then
               let newexp =
@@ -195,8 +193,8 @@ let update_data_exp full_st_name sitedata old_glob_timeout new_glob_timeout =
               | Some t when t <= now ->
                   Eliommod_sessiongroups.Data.remove session_group_node
               | _ -> expiry := newexp);
-           Lwt.pause ())
-        sitedata.Eliom_common.session_data return_unit
+           Fiber.yield ())
+        sitedata.Eliom_common.session_data ()
 
 (* Update the expiration date for all sessions                               *)
 let update_pers_exp full_st_name sitedata old_glob_timeout new_glob_timeout =
@@ -230,14 +228,14 @@ let update_pers_exp full_st_name sitedata old_glob_timeout new_glob_timeout =
                  Eliommod_persess.close_persistent_state2 ~scope sitedata
                    session_group k
              | _ ->
-                 let* () =
+                 let () =
                    Eliommod_cookies.Persistent_cookies.add k
                      { Eliommod_cookies.full_state_name
                      ; expiry = newexp
                      ; timeout = Eliom_common.TGlobal
                      ; session_group }
                  in
-                 Eliommod_cookies.Persistent_cookies.Expiry_dates.remove_cookie
-                   old_exp k
-                 >>= Lwt.pause
-           else return_unit)
+                 Fiber.yield
+                   (Eliommod_cookies.Persistent_cookies.Expiry_dates
+                    .remove_cookie old_exp k)
+           else ())
diff --git a/src/lib/server/eliommod_sessadmin.mli b/src/lib/server/eliommod_sessadmin.mli
index 2a7683bc76..2213c43730 100644
--- a/src/lib/server/eliommod_sessadmin.mli
+++ b/src/lib/server/eliommod_sessadmin.mli
@@ -22,39 +22,39 @@ val close_all_service_states :
    scope:Eliom_common.user_scope
   -> secure:bool
   -> Eliom_common.sitedata
-  -> unit Lwt.t
+  -> unit
 
 val close_all_data_states :
    scope:Eliom_common.user_scope
   -> secure:bool
   -> Eliom_common.sitedata
-  -> unit Lwt.t
+  -> unit
 
 val close_all_persistent_states :
    scope:Eliom_common.user_scope
   -> secure:bool
   -> Eliom_common.sitedata
-  -> unit Lwt.t
+  -> unit
 
 val update_serv_exp :
    Eliom_common.full_state_name
   -> Eliom_common.sitedata
   -> float option
   -> float option
-  -> unit Lwt.t
+  -> unit
 
 val update_data_exp :
    Eliom_common.full_state_name
   -> Eliom_common.sitedata
   -> float option
   -> float option
-  -> unit Lwt.t
+  -> unit
 
 val update_pers_exp :
    Eliom_common.full_state_name
   -> Eliom_common.sitedata
   -> float option
   -> float option
-  -> unit Lwt.t
+  -> unit
 
 val section : Logs.src
diff --git a/src/lib/server/eliommod_sessexpl.ml b/src/lib/server/eliommod_sessexpl.ml
index 04cada3d14..ca07d2d02e 100644
--- a/src/lib/server/eliommod_sessexpl.ml
+++ b/src/lib/server/eliommod_sessexpl.ml
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Module eliommod_sessexpl.ml
@@ -26,8 +28,6 @@
 (*****************************************************************************)
 (*****************************************************************************)
 
-open Lwt
-
 (*****************************************************************************)
 (* Iterators on cookies *)
 
@@ -37,8 +37,10 @@ let iter_service_cookies f =
     Eliom_request_info.find_sitedata "Eliommod_sessexpl.iter_service_cookies"
   in
   Eliom_common.SessionCookies.fold
-    (fun k v thr -> thr >>= fun () -> f (k, v) >>= Lwt.pause)
-    sitedata.Eliom_common.session_services return_unit
+    (fun k v thr ->
+       thr;
+       Fiber.yield (f (k, v)))
+    sitedata.Eliom_common.session_services ()
 
 (** Iterator on data cookies *)
 let iter_data_cookies f =
@@ -46,13 +48,15 @@ let iter_data_cookies f =
     Eliom_request_info.find_sitedata "Eliommod_sessexpl.iter_data_cookies"
   in
   Eliom_common.SessionCookies.fold
-    (fun k v thr -> thr >>= fun () -> f (k, v) >>= Lwt.pause)
-    sitedata.Eliom_common.session_data return_unit
+    (fun k v thr ->
+       thr;
+       Fiber.yield (f (k, v)))
+    sitedata.Eliom_common.session_data ()
 
 (** Iterator on persistent cookies *)
 let iter_persistent_cookies f =
   Eliommod_cookies.Persistent_cookies.Cookies.iter (fun k v ->
-    f (k, v) >>= Lwt.pause)
+    Fiber.yield (f (k, v)))
 
 (** Iterator on service cookies *)
 let fold_service_cookies f beg =
@@ -61,10 +65,10 @@ let fold_service_cookies f beg =
   in
   Eliom_common.SessionCookies.fold
     (fun k v thr ->
-       thr >>= fun res1 ->
-       f (k, v) res1 >>= fun res ->
-       Lwt.pause () >>= fun () -> return res)
-    sitedata.Eliom_common.session_services (return beg)
+       let res1 = thr in
+       let res = f (k, v) res1 in
+       Fiber.yield (); res)
+    sitedata.Eliom_common.session_services beg
 
 (** Iterator on data cookies *)
 let fold_data_cookies f beg =
@@ -73,17 +77,17 @@ let fold_data_cookies f beg =
   in
   Eliom_common.SessionCookies.fold
     (fun k v thr ->
-       thr >>= fun res1 ->
-       f (k, v) res1 >>= fun res ->
-       Lwt.pause () >>= fun () -> return res)
-    sitedata.Eliom_common.session_data (return beg)
+       let res1 = thr in
+       let res = f (k, v) res1 in
+       Fiber.yield (); res)
+    sitedata.Eliom_common.session_data beg
 
 (** Iterator on persistent cookies *)
 let fold_persistent_cookies f beg =
   Eliommod_cookies.Persistent_cookies.Cookies.fold
     (fun k v beg ->
-       f (k, v) beg >>= fun res ->
-       Lwt.pause () >>= fun () -> return res)
+       let res = f (k, v) beg in
+       Fiber.yield (); res)
     beg
 
 (*****************************************************************************)
diff --git a/src/lib/server/eliommod_sessexpl.mli b/src/lib/server/eliommod_sessexpl.mli
index e4ee7fa672..58b9337b9f 100644
--- a/src/lib/server/eliommod_sessexpl.mli
+++ b/src/lib/server/eliommod_sessexpl.mli
@@ -21,39 +21,35 @@
 val iter_service_cookies :
    (Eliom_common.SessionCookies.key
     * Eliom_common.tables Eliom_common.Service_cookie.t
-    -> unit Lwt.t)
-  -> unit Lwt.t
+    -> unit)
+  -> unit
 
 val iter_data_cookies :
-   (Eliom_common.SessionCookies.key * Eliom_common.Data_cookie.t -> unit Lwt.t)
-  -> unit Lwt.t
+   (Eliom_common.SessionCookies.key * Eliom_common.Data_cookie.t -> unit)
+  -> unit
 
-val iter_persistent_cookies :
-   (string * Eliommod_cookies.cookie -> unit Lwt.t)
-  -> unit Lwt.t
+val iter_persistent_cookies : (string * Eliommod_cookies.cookie -> unit) -> unit
 
 val fold_service_cookies :
    (Eliom_common.SessionCookies.key
     * Eliom_common.tables Eliom_common.Service_cookie.t
     -> 'a
-    -> 'a Lwt.t)
+    -> 'a)
+  -> 'a
   -> 'a
-  -> 'a Lwt.t
 
 val fold_data_cookies :
-   (Eliom_common.SessionCookies.key * Eliom_common.Data_cookie.t
-    -> 'a
-    -> 'a Lwt.t)
+   (Eliom_common.SessionCookies.key * Eliom_common.Data_cookie.t -> 'a -> 'a)
+  -> 'a
   -> 'a
-  -> 'a Lwt.t
 
 val fold_persistent_cookies :
-   (string * Eliommod_cookies.cookie -> 'a -> 'a Lwt.t)
+   (string * Eliommod_cookies.cookie -> 'a -> 'a)
+  -> 'a
   -> 'a
-  -> 'a Lwt.t
 
 val number_of_service_cookies : unit -> int
 val number_of_data_cookies : unit -> int
 val number_of_tables : unit -> int
 val number_of_table_elements : unit -> int list
-val number_of_persistent_cookies : unit -> int Lwt.t
+val number_of_persistent_cookies : unit -> int
diff --git a/src/lib/server/eliommod_sessiongroups.ml b/src/lib/server/eliommod_sessiongroups.ml
index cd8bce041e..9c919c486f 100644
--- a/src/lib/server/eliommod_sessiongroups.ml
+++ b/src/lib/server/eliommod_sessiongroups.ml
@@ -1,3 +1,5 @@
+open Eio.Std
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Module eliomsessiongroups.ml
@@ -419,7 +421,7 @@ module Pers = struct
 
   module Ocsipersist = Eliom_common.Ocsipersist.Polymorphic
 
-  let grouptable : (nbmax * string list) Ocsipersist.table Lwt.t Lazy.t =
+  let grouptable : (nbmax * string list) Ocsipersist.table Promise.t Lazy.t =
     lazy (Ocsipersist.open_table "__eliom_session_group_table")
   (* It is lazy because if the module is linked statically,
          the creation of the table must happen after initialisation
@@ -428,162 +430,167 @@ module Pers = struct
 
   let find g =
     match g with
-    | None -> Lwt.return_nil
-    | Some g ->
-        Lwt.catch
-          (fun () ->
-             !!grouptable >>= fun grouptable ->
-             Ocsipersist.find grouptable (Eliom_common.string_of_perssessgrp g)
-             >>= fun (_, a) -> Lwt.return a)
-          (function Not_found -> Lwt.return_nil | e -> Lwt.fail e)
+    | None -> []
+    | Some g -> (
+      try
+        let grouptable = !!grouptable in
+        let _, a =
+          Ocsipersist.find grouptable (Eliom_common.string_of_perssessgrp g)
+        in
+        a
+      with
+      | Not_found -> []
+      | e -> raise e)
 
   let add ?set_max defaultmax sess_id sess_grp =
     match sess_grp with
-    | Some sg ->
+    | Some sg -> (
         let sg = Eliom_common.string_of_perssessgrp sg in
-        Lwt.catch
-          (fun () ->
-             !!grouptable >>= fun grouptable ->
-             Ocsipersist.find grouptable sg >>= fun (max2, cl) ->
-             let max, newmax =
-               match set_max with
-               | None ->
-                   ( (match max2 with
-                     | Default -> defaultmax
-                     | Nolimit -> None
-                     | Val m -> Some m)
-                   , max2 )
-               | Some None -> None, Nolimit
-               | Some (Some v) -> Some v, Val v
-             in
-             let cl, toclose = cut max cl in
-             Ocsipersist.replace_if_exists grouptable sg (newmax, sess_id :: cl)
-             >>= fun () -> Lwt.return toclose)
-          (function
-            | Not_found ->
-                let max =
-                  match set_max with
-                  | None -> Default
-                  | Some None -> Nolimit
-                  | Some (Some v) -> Val v
-                in
-                !!grouptable >>= fun grouptable ->
-                Ocsipersist.add grouptable sg (max, [sess_id]) >>= fun () ->
-                Lwt.return_nil
-            | e -> Lwt.fail e)
-    | None -> Lwt.return_nil
+        try
+          let grouptable = !!grouptable in
+          let max2, cl = Ocsipersist.find grouptable sg in
+          let max, newmax =
+            match set_max with
+            | None ->
+                ( (match max2 with
+                  | Default -> defaultmax
+                  | Nolimit -> None
+                  | Val m -> Some m)
+                , max2 )
+            | Some None -> None, Nolimit
+            | Some (Some v) -> Some v, Val v
+          in
+          let cl, toclose = cut max cl in
+          Ocsipersist.replace_if_exists grouptable sg (newmax, sess_id :: cl);
+          toclose
+        with
+        | Not_found ->
+            let max =
+              match set_max with
+              | None -> Default
+              | Some None -> Nolimit
+              | Some (Some v) -> Val v
+            in
+            let grouptable = !!grouptable in
+            Ocsipersist.add grouptable sg (max, [sess_id]);
+            []
+        | e -> raise e)
+    | None -> []
 
   let rec remove_group ~cookie_level sitedata sess_grp =
-    (* cookie_level is the scope of group members *)
-    (*VVV NEW 201007 closing all sessions in the group and removing group data *)
-    (*VVV VERIFY concurrent access *)
-    (*VVV Check this carefully!!!! Verify the order of actions. *)
-    Lwt.catch
-      (fun () ->
-         (* First we close all sessions in the group *)
-         find sess_grp >>= fun cl ->
-         Lwt_list.iter_p
-           (close_persistent_session2
-              ~cookie_level:
-                (match cookie_level with
-                | `Client_process _ -> `Client_process
-                | `Session -> `Session)
-              sitedata None)
-           cl
-         (* None because we will close the group *)
-         >>= fun () ->
-         (* Then, we remove group data: *)
-         (match sess_grp with
-           | None -> Lwt.return_unit
-           | Some sg -> (
-             match Eliom_common.getperssessgrp sg with
-             | _, _, Right _ ->
-                 (* No group has been set. No group table.
+    try
+      let cl =
+        (* cookie_level is the scope of group members *)
+        (*VVV NEW 201007 closing all sessions in the group and removing group data *)
+        (*VVV VERIFY concurrent access *)
+        (*VVV Check this carefully!!!! Verify the order of actions. *)
+
+        (* First we close all sessions in the group *)
+        find sess_grp
+      in
+      Fiber.List.iter
+        (close_persistent_session2
+           ~cookie_level:
+             (match cookie_level with
+             | `Client_process _ -> `Client_process
+             | `Session -> `Session)
+           sitedata None)
+        cl (* None because we will close the group *);
+      (* Then, we remove group data: *)
+      (match sess_grp with
+      | None -> ()
+      | Some sg -> (
+        match Eliom_common.getperssessgrp sg with
+        | _, _, Right _ -> ()
+        (* No group has been set. No group table.
                  Data associated to default (automatic) groups
                  is removed when closing associated sessions. *)
-                 Lwt.return_unit
-             | _, _, Left group_name -> (
-                 Eliom_common.Persistent_tables.remove_key_from_all_tables
-                   group_name
-                 >>= fun () ->
-                 (* If it is associated to a session,
+        | _, _, Left group_name -> (
+            Eliom_common.Persistent_tables.remove_key_from_all_tables group_name;
+            (* If it is associated to a session,
                  we remove the session from its group,
                  and we remove cookie info: *)
-                 match cookie_level with
-                 | `Client_process grp ->
-                     (* We are closing a browser session,
+            match cookie_level with
+            | `Client_process grp ->
+                (* We are closing a browser session,
                                            belonging to the group grp *)
-                     (* group_name is the cookie value *)
-                     remove sitedata group_name grp
-                 | _ -> Lwt.return_unit)))
-         >>= fun () ->
-         (* Then, we remove group from group table: *)
-         match sess_grp with
-         | Some sg ->
-             let sg = Eliom_common.string_of_perssessgrp sg in
-             !!grouptable >>= fun grouptable -> Ocsipersist.remove grouptable sg
-         | None -> Lwt.return_unit)
-      (function Not_found -> Lwt.return_unit | e -> Lwt.fail e)
+                (* group_name is the cookie value *)
+                remove sitedata group_name grp
+            | _ -> ())));
+      (* Then, we remove group from group table: *)
+      match sess_grp with
+      | Some sg ->
+          let sg = Eliom_common.string_of_perssessgrp sg in
+          let grouptable = !!grouptable in
+          Ocsipersist.remove grouptable sg
+      | None -> ()
+    with
+    | Not_found -> ()
+    | e -> raise e
 
   (* close a persistent session (tab or browser)
      and the associated group (if browser session) by cookie value *)
   and close_persistent_session2 ~cookie_level sitedata fullsessgrp cookie =
-    (*VVV Check this carefully!!!! *)
-    (*VVV Optimize the number of marshal/unmarshal (getperssessgrp) *)
-    Lwt.catch
-      (fun () ->
-         match cookie_level with
-         | `Client_process ->
-             (* We remove the session from its group: *)
-             remove sitedata cookie fullsessgrp >>= fun () ->
-             (* Then, we remove session data: *)
-             Eliom_common.Persistent_tables.remove_key_from_all_tables cookie
-         | `Session ->
-             remove_group ~cookie_level:(`Client_process fullsessgrp) sitedata
-               (Eliom_common.make_persistent_full_group_name
-                  ~cookie_level:`Client_process
-                  (Eliom_common.get_site_dir_string sitedata)
-                  (Some cookie)))
-      (function Not_found -> Lwt.return_unit | e -> Lwt.fail e)
+    try
+      (*VVV Check this carefully!!!! *)
+      (*VVV Optimize the number of marshal/unmarshal (getperssessgrp) *)
+      match cookie_level with
+      | `Client_process ->
+          (* We remove the session from its group: *)
+          remove sitedata cookie fullsessgrp;
+          (* Then, we remove session data: *)
+          Eliom_common.Persistent_tables.remove_key_from_all_tables cookie
+      | `Session ->
+          remove_group ~cookie_level:(`Client_process fullsessgrp) sitedata
+            (Eliom_common.make_persistent_full_group_name
+               ~cookie_level:`Client_process
+               (Eliom_common.get_site_dir_string sitedata)
+               (Some cookie))
+    with
+    | Not_found -> ()
+    | e -> raise e
 
   and remove _sitedata sess_id sess_grp =
     match sess_grp with
-    | Some sg0 ->
+    | Some sg0 -> (
         let sg = Eliom_common.string_of_perssessgrp sg0 in
-        Lwt.catch
-          (fun () ->
-             !!grouptable >>= fun grouptable ->
-             Ocsipersist.find grouptable sg >>= fun (max, cl) ->
-             let newcl = List.remove_first_if_any sess_id cl in
-             (* Before 2018-10-18, we were closing the session group
+        try
+          let grouptable = !!grouptable in
+          let max, cl = Ocsipersist.find grouptable sg in
+          let newcl = List.remove_first_if_any sess_id cl in
+          (* Before 2018-10-18, we were closing the session group
              when newcl was empty (no more session in the group).
              But persistent session groups are usually used to store persistent
              information about users. It makes no sense cleaning this
              information when user closes all their sessions.
              I remove this. -- Vincent
-             *)
-             Ocsipersist.replace_if_exists grouptable sg (max, newcl))
-          (function Not_found -> Lwt.return_unit | e -> Lwt.fail e)
-    | None -> Lwt.return_unit
+          *)
+          Ocsipersist.replace_if_exists grouptable sg (max, newcl)
+        with
+        | Not_found -> ()
+        | e -> raise e)
+    | None -> ()
 
   let up sess_id grp =
     match grp with
-    | None -> Lwt.return_unit
-    | Some sg ->
+    | None -> ()
+    | Some sg -> (
         let sg = Eliom_common.string_of_perssessgrp sg in
-        Lwt.catch
-          (fun () ->
-             !!grouptable >>= fun grouptable ->
-             Ocsipersist.find grouptable sg >>= fun (max, cl) ->
-             let newcl = List.remove_first_if_any sess_id cl in
-             Ocsipersist.replace_if_exists grouptable sg (max, sess_id :: newcl))
-          (function Not_found -> Lwt.return_unit | e -> Lwt.fail e)
+        try
+          let grouptable = !!grouptable in
+          let max, cl = Ocsipersist.find grouptable sg in
+          let newcl = List.remove_first_if_any sess_id cl in
+          Ocsipersist.replace_if_exists grouptable sg (max, sess_id :: newcl)
+        with
+        | Not_found -> ()
+        | e -> raise e)
 
   let move sitedata ?set_max max sess_id grp1 grp2 =
     if set_max <> None || grp1 <> grp2
-    then
-      remove sitedata sess_id grp1 >>= fun () -> add ?set_max max sess_id grp2
-    else Lwt.return_nil
+    then (
+      remove sitedata sess_id grp1;
+      add ?set_max max sess_id grp2)
+    else []
 
-  let nb_of_groups () = !!grouptable >>= Ocsipersist.length
+  let nb_of_groups () = Ocsipersist.length !!grouptable
 end
diff --git a/src/lib/server/eliommod_sessiongroups.mli b/src/lib/server/eliommod_sessiongroups.mli
index fd3b59b612..baf72317f2 100644
--- a/src/lib/server/eliommod_sessiongroups.mli
+++ b/src/lib/server/eliommod_sessiongroups.mli
@@ -99,26 +99,26 @@ module Data :
     [`Session] Eliom_common.sessgrp Ocsigen_cache.Dlist.node
 
 module Pers : sig
-  val find : Eliom_common.perssessgrp option -> string list Lwt.t
+  val find : Eliom_common.perssessgrp option -> string list
 
   val add :
      ?set_max:int option
     -> int option
     -> string
     -> Eliom_common.perssessgrp option
-    -> string list Lwt.t
+    -> string list
 
   val remove :
      Eliom_common.sitedata
     -> string
     -> Eliom_common.perssessgrp option
-    -> unit Lwt.t
+    -> unit
 
   val remove_group :
      cookie_level:[`Session | `Client_process of Eliom_common.perssessgrp option]
     -> Eliom_common.sitedata
     -> Eliom_common.perssessgrp option
-    -> unit Lwt.t
+    -> unit
 
   val move :
      Eliom_common.sitedata
@@ -127,15 +127,15 @@ module Pers : sig
     -> string
     -> Eliom_common.perssessgrp option
     -> Eliom_common.perssessgrp option
-    -> string list Lwt.t
+    -> string list
 
-  val up : string -> Eliom_common.perssessgrp option -> unit Lwt.t
-  val nb_of_groups : unit -> int Lwt.t
+  val up : string -> Eliom_common.perssessgrp option -> unit
+  val nb_of_groups : unit -> int
 
   val close_persistent_session2 :
      cookie_level:Eliom_common.cookie_level
     -> Eliom_common.sitedata
     -> Eliom_common.perssessgrp option
     -> string
-    -> unit Lwt.t
+    -> unit
 end
diff --git a/src/lib/server/eliommod_timeouts.ml b/src/lib/server/eliommod_timeouts.ml
index 56381c5bfa..511ab5a484 100644
--- a/src/lib/server/eliommod_timeouts.ml
+++ b/src/lib/server/eliommod_timeouts.ml
@@ -26,7 +26,6 @@
 (*****************************************************************************)
 
 open Eliom_lib
-open Lwt
 
 type kind = [`Service | `Data | `Persistent]
 
@@ -131,15 +130,12 @@ let set_timeout_
             | _, _, ct -> get_default ct)
         in
         ignore
-          (catch
-             (fun () -> update full_st_name sitedata oldt t)
-             (function
-               | exn ->
-               Logs.warn ~src:eliom_logs_src (fun fmt ->
-                 fmt
-                   ("Error while updating timeouts" ^^ "@\n%s")
-                   (Printexc.to_string exn));
-               Lwt.return_unit))
+          (try update full_st_name sitedata oldt t
+           with exn ->
+             Logs.warn ~src:eliom_logs_src (fun fmt ->
+               fmt
+                 ("Error while updating timeouts" ^^ "@\n%s")
+                 (Printexc.to_string exn)))
 (*VVV Check possible exceptions raised *)
 
 (* global timeout = timeout for the whole site (may be changed dynamically) *)
diff --git a/src/lib/server/monitor/eliom_monitor.ml b/src/lib/server/monitor/eliom_monitor.ml
index 9e29633f17..5cbc189f72 100644
--- a/src/lib/server/monitor/eliom_monitor.ml
+++ b/src/lib/server/monitor/eliom_monitor.ml
@@ -1,5 +1,3 @@
-open Lwt.Syntax
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2014 Hugo Heuzard
@@ -108,72 +106,68 @@ let http_stats () =
            hosts) ]
 
 let eliom_stats () =
-  let* persist_nb_of_groups = Eliommod_sessiongroups.Pers.nb_of_groups () in
-  let* number_of_persistent_data_cookies =
+  let persist_nb_of_groups = Eliommod_sessiongroups.Pers.nb_of_groups () in
+  let number_of_persistent_data_cookies =
     Eliom_state.number_of_persistent_data_cookies ()
   in
-  Lwt.return
-    (div
-       [ h3 [ppf "Sessions"]
-       ; ul
-           [ li
-               [ ppf "%d service cookies."
-                   (Eliom_state.number_of_service_cookies ()) ]
-           ; li
-               [ ppf "%d volatile data cookies."
-                   (Eliom_state.number_of_volatile_data_cookies ()) ]
-           ; li
-               [ ppf "%d volatile data tables (volatile Eliom references)."
-                   (Eliom_state.number_of_tables ()) ]
-           ; li
-               [ ppf "%d persistent data cookies."
-                   number_of_persistent_data_cookies ]
-           ; li
-               [ ppf "%d persistent data tables (persistent data reference)."
-                   (Eliom_state.number_of_persistent_tables ()) ] ]
-       ; h3 [ppf "Client processes"]
-       ; p [em [txt "Not implemented yet"]]
-       ; h3 [ppf "Session groups"]
-       ; ul
-           [ li
-               [ ppf "%d service session groups."
-                   (Eliommod_sessiongroups.Serv.nb_of_groups ()) ]
-           ; li
-               [ ppf "%d volatile data session groups."
-                   (Eliommod_sessiongroups.Data.nb_of_groups ()) ]
-           ; li [ppf "%d persistent data session groups." persist_nb_of_groups]
-           ; li
-               [ ppf "Session groups: %s"
-                   (String.concat ", "
-                      (Eliom_state.Ext.get_session_group_list ())) ] ] ])
+  div
+    [ h3 [ppf "Sessions"]
+    ; ul
+        [ li
+            [ ppf "%d service cookies."
+                (Eliom_state.number_of_service_cookies ()) ]
+        ; li
+            [ ppf "%d volatile data cookies."
+                (Eliom_state.number_of_volatile_data_cookies ()) ]
+        ; li
+            [ ppf "%d volatile data tables (volatile Eliom references)."
+                (Eliom_state.number_of_tables ()) ]
+        ; li
+            [ppf "%d persistent data cookies." number_of_persistent_data_cookies]
+        ; li
+            [ ppf "%d persistent data tables (persistent data reference)."
+                (Eliom_state.number_of_persistent_tables ()) ] ]
+    ; h3 [ppf "Client processes"]
+    ; p [em [txt "Not implemented yet"]]
+    ; h3 [ppf "Session groups"]
+    ; ul
+        [ li
+            [ ppf "%d service session groups."
+                (Eliommod_sessiongroups.Serv.nb_of_groups ()) ]
+        ; li
+            [ ppf "%d volatile data session groups."
+                (Eliommod_sessiongroups.Data.nb_of_groups ()) ]
+        ; li [ppf "%d persistent data session groups." persist_nb_of_groups]
+        ; li
+            [ ppf "Session groups: %s"
+                (String.concat ", " (Eliom_state.Ext.get_session_group_list ()))
+            ] ] ]
 
 let content_div () =
-  let* eliom_stats = eliom_stats () in
-  Lwt.return
-    (div
-       [ h1 [ppf "Ocsigen server monitoring"]
-       ; general_stats ()
-       ; h2 [ppf "HTTP connexions"]
-       ; http_stats ()
-       ; h2 [ppf "Eliom sessions"]
-       ; eliom_stats
-       ; h2 [ppf "GC"]
-       ; gc_stats () ])
+  let eliom_stats = eliom_stats () in
+  div
+    [ h1 [ppf "Ocsigen server monitoring"]
+    ; general_stats ()
+    ; h2 [ppf "HTTP connexions"]
+    ; http_stats ()
+    ; h2 [ppf "Eliom sessions"]
+    ; eliom_stats
+    ; h2 [ppf "GC"]
+    ; gc_stats () ]
 
 let content_html () =
-  let* content_div = content_div () in
-  Lwt.return
-    (html
-       (head
-          (title (txt "Server monitoring"))
-          [ link ~rel:[`Stylesheet]
-              ~href:
-                (uri_of_string (fun () ->
-                   "//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css"))
-              ()
-          ; link ~rel:[`Stylesheet]
-              ~href:
-                (uri_of_string (fun () ->
-                   "//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap-theme.min.css"))
-              () ])
-       (body [div ~a:[a_class ["container"]] [content_div]]))
+  let content_div = content_div () in
+  html
+    (head
+       (title (txt "Server monitoring"))
+       [ link ~rel:[`Stylesheet]
+           ~href:
+             (uri_of_string (fun () ->
+                "//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css"))
+           ()
+       ; link ~rel:[`Stylesheet]
+           ~href:
+             (uri_of_string (fun () ->
+                "//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap-theme.min.css"))
+           () ])
+    (body [div ~a:[a_class ["container"]] [content_div]])
diff --git a/src/lib/server/monitor/eliom_monitor.mli b/src/lib/server/monitor/eliom_monitor.mli
index 79a648bf81..051bd2af01 100644
--- a/src/lib/server/monitor/eliom_monitor.mli
+++ b/src/lib/server/monitor/eliom_monitor.mli
@@ -20,5 +20,5 @@
 val uptime : unit -> float
 val pid : unit -> int
 val fd : pid:int -> [`Ok of int | `Error of string]
-val content_div : unit -> [> Html_types.div] Eliom_content.Html.elt Lwt.t
-val content_html : unit -> [> Html_types.html] Eliom_content.Html.elt Lwt.t
+val content_div : unit -> [> Html_types.div] Eliom_content.Html.elt
+val content_html : unit -> [> Html_types.html] Eliom_content.Html.elt

From e70fd6570f78ab5271dcb2fbd14a83c637564923 Mon Sep 17 00:00:00 2001
From: Jules Aguillon <jules@j3s.fr>
Date: Thu, 19 Jun 2025 19:30:18 +0200
Subject: [PATCH 06/21] Manual changes

- Remove `Eliom_bus.stream` and `Eliom_bus.original_stream`
---
 src/lib/client/dune                      |  3 +-
 src/lib/eliom_comet.client.ml            |  5 +--
 src/lib/eliom_common.server.ml           |  6 ++--
 src/lib/eliom_common.server.mli          |  1 -
 src/lib/eliom_cscache.eliom              | 30 +++++++++-------
 src/lib/eliom_cscache.eliomi             |  4 +--
 src/lib/eliom_form.eliom                 |  3 +-
 src/lib/eliom_lib.client.ml              |  9 +----
 src/lib/eliom_parameter.server.mli       |  2 +-
 src/lib/eliom_parameter_sigs.shared.mli  |  6 ++--
 src/lib/eliom_reference.server.ml        | 44 ++++++++++++------------
 src/lib/eliom_registration.server.ml     | 31 ++++++-----------
 src/lib/eliom_request.client.ml          |  2 +-
 src/lib/eliom_request_info.server.ml     |  2 +-
 src/lib/eliom_request_info.server.mli    | 10 +++---
 src/lib/eliom_shared.eliom               |  2 +-
 src/lib/server/dune                      |  2 +-
 src/lib/server/eliommod_sessiongroups.ml |  2 +-
 18 files changed, 73 insertions(+), 91 deletions(-)

diff --git a/src/lib/client/dune b/src/lib/client/dune
index dace844303..3edced7df5 100644
--- a/src/lib/client/dune
+++ b/src/lib/client/dune
@@ -28,7 +28,8 @@
   logs.browser
   cohttp
   tyxml
-  reactiveData)
+  reactiveData
+  eio)
  (foreign_stubs
   (language c)
   (names eliom_stubs))
diff --git a/src/lib/eliom_comet.client.ml b/src/lib/eliom_comet.client.ml
index 66465776fc..bb184e4551 100644
--- a/src/lib/eliom_comet.client.ml
+++ b/src/lib/eliom_comet.client.ml
@@ -170,10 +170,7 @@ module Configuration = struct
       let () =
         Fiber.any
           [ (fun () -> Js_of_ocaml_lwt.Lwt_js.sleep t)
-          ; (fun () ->
-              !
-                (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
-                update_configuration_waiter)
+          ; (fun () -> Promise.await !update_configuration_waiter)
           ; active_waiter ]
       in
       let remaining_time = sleep_duration () -. (Sys.time () -. time) in
diff --git a/src/lib/eliom_common.server.ml b/src/lib/eliom_common.server.ml
index a287607d8f..4b79f16a7c 100644
--- a/src/lib/eliom_common.server.ml
+++ b/src/lib/eliom_common.server.ml
@@ -242,7 +242,6 @@ type 'a cookie_info1 =
   (* None = new cookie
       (not sent by the browser) *)
   * one_persistent_cookie_info session_cookie ref)
-    Promise.t
     (* SCNo_data = the session has been closed
       SCData_session_expired = the cookie has not been found in the table.
       For both of them, ask the browser to remove the cookie.
@@ -300,7 +299,8 @@ let network_of_ip k mask4 mask6 =
 
 let network_of_request r ~mask4 ~mask6 =
   match Ocsigen_request.client_conn r with
-  | `Inet (ip, _) -> network_of_ip ip mask4 mask6
+  | `Inet (ip, _) ->
+      network_of_ip (Ipaddr.of_string_exn (ip :> string)) mask4 mask6
   | _ -> Ipaddr.(V6 V6.localhost)
 
 module Net_addr_Hashtbl : sig
@@ -831,7 +831,7 @@ let empty_tables max forsession =
                      Ocsigen_request.client_conn
                        sp.sp_request.Ocsigen_extensions.request_info
                    with
-                   | `Inet (ip, _) -> ip
+                   | `Inet (ip, _) -> Ipaddr.of_string_exn (ip :> string)
                    | _ -> default_ip_table_key
                  in
                  ( ip
diff --git a/src/lib/eliom_common.server.mli b/src/lib/eliom_common.server.mli
index b2cb39c32c..2d6976da8b 100644
--- a/src/lib/eliom_common.server.mli
+++ b/src/lib/eliom_common.server.mli
@@ -360,7 +360,6 @@ type 'a cookie_info1 =
       ref
   * ((string * timeout * float option * perssessgrp option) option
     * one_persistent_cookie_info session_cookie ref)
-      Promise.t
       Lazy.t
       Full_state_name_table.t
       ref
diff --git a/src/lib/eliom_cscache.eliom b/src/lib/eliom_cscache.eliom
index 79bbca3e0e..2ddcef7a0d 100644
--- a/src/lib/eliom_cscache.eliom
+++ b/src/lib/eliom_cscache.eliom
@@ -1,10 +1,11 @@
-open Eio.Std
+open%server Eio.Std
 
 (* Copyright Vincent Balat *)
 
 [%%shared.start]
 
-type ('a, 'b) t = (unit -> ('a, 'b Promise.t) Hashtbl.t) Eliom_shared.Value.t
+type ('a, 'b) t =
+  (unit -> ('a, 'b Promise.or_exn) Hashtbl.t) Eliom_shared.Value.t
 
 let%client create_ () =
   let c = Hashtbl.create 100 in
@@ -33,24 +34,26 @@ let%server do_cache cache id v =
   ignore [%client.unsafe (do_cache ~%cache ~%id ~%v : unit)]
 
 let%server find cache get_data id =
-  try Hashtbl.find ((Eliom_shared.Value.local cache) ()) id
+  try Promise.await_exn (Hashtbl.find ((Eliom_shared.Value.local cache) ()) id)
   with Not_found ->
     let th =
-      let v = get_data id in
-      ignore [%client.unsafe (do_cache ~%cache ~%id ~%v : unit)];
-      v
+      Fiber.fork_promise
+        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+        (fun () ->
+           let v = get_data id in
+           ignore [%client.unsafe (do_cache ~%cache ~%id ~%v : unit)];
+           v)
     in
-    (* On server side, we put immediately in table the thread that is
-       fetching the data.  in order to avoid fetching it several
-       times. *)
-    do_cache_raw cache id th; th
+    (* On server side, we put immediately in table the thread that is fetching
+       the data. in order to avoid fetching it several times. *)
+    do_cache_raw cache id th; Promise.await_exn th
 
 let%client load cache get_data id =
   let th = get_data id in
   (* On client side, we put immediately in table the thread that is
      fetching the data.  Thus, [get_data_from_cache] returns
      immediately (in order to display a spinner). *)
-  do_cache_raw cache id th; th
+  do_cache_raw cache id th; Promise.await_exn th
 
 let%client find cache get_data id =
   try Hashtbl.find ((Eliom_shared.Value.local cache) ()) id
@@ -62,4 +65,7 @@ let local_find cache id = Hashtbl.find ((Eliom_shared.Value.local cache) ()) id
 
 let find_if_ready cache id =
   let v = local_find cache id in
-  match Promise.peek v with Some v -> v | _ -> raise Not_ready
+  match Promise.peek v with
+  | Some (Ok v) -> v
+  | Some (Error e) -> raise e
+  | _ -> raise Not_ready
diff --git a/src/lib/eliom_cscache.eliomi b/src/lib/eliom_cscache.eliomi
index 5d0db53b68..06a7be3008 100644
--- a/src/lib/eliom_cscache.eliomi
+++ b/src/lib/eliom_cscache.eliomi
@@ -40,14 +40,14 @@ val find : ('a, 'b) t -> ('a -> 'b) -> 'a -> 'b
     result in a single call to [get_from_db]. Exceptions are not
     cached.  *)
 
-val do_cache : ('a, 'b) t -> 'a -> 'b -> unit
+val do_cache : ('a, 'b) t -> 'a -> 'b Eio.Promise.or_exn -> unit
 (** [do_cache cache key value] adds the association from [key] to
     [value] in [cache], or replaces it if not already present.  Called
     from client side, it affects only client side cache.  Called from
     server side, it will have effect both on the server cache (scope:
     request) and the client side cache.  *)
 
-val local_find : ('a, 'b) t -> 'a -> 'b
+val local_find : ('a, 'b) t -> 'a -> 'b Eio.Promise.or_exn
 (** Find a piece of data in local cache, without trying to fetch it
     from server. Raises [Not_found] instead.  If the value is currently
     being retrieved, it waits for it to be ready before returning.  *)
diff --git a/src/lib/eliom_form.eliom b/src/lib/eliom_form.eliom
index 5a6f832c7b..ed6b6ecfbf 100644
--- a/src/lib/eliom_form.eliom
+++ b/src/lib/eliom_form.eliom
@@ -1,5 +1,3 @@
-open Eio.Std
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Module Eliom_form
@@ -148,6 +146,7 @@ module Make_links (Html : Html) = struct
         let f =
           [%client.unsafe
             fun ev ->
+              let open Eio.Std in
               if not (Eliom_client.middleClick ev)
               then (
                 Dom.preventDefault ev;
diff --git a/src/lib/eliom_lib.client.ml b/src/lib/eliom_lib.client.ml
index 13c2abbc7f..ba775cf357 100644
--- a/src/lib/eliom_lib.client.ml
+++ b/src/lib/eliom_lib.client.ml
@@ -88,14 +88,7 @@ let raise_error ?exn ?section fmt =
 
 let log_inspect obj = Console.console##log (Obj.repr obj)
 let eliom_logs_src = Logs.Src.create "eliom"
-
-let _ =
-  Logs.set_reporter (Logs_browser.console_reporter ());
-  Lwt.async_exception_hook :=
-    fun exn ->
-      Console.console##error_3 (Js.string "Lwt.async:")
-        (Js.string (Printexc.to_string exn))
-        exn
+let _ = Logs.set_reporter (Logs_browser.console_reporter ())
 
 let trace fmts =
   if Eliom_config.get_tracing ()
diff --git a/src/lib/eliom_parameter.server.mli b/src/lib/eliom_parameter.server.mli
index bf7b609604..4e13733af0 100644
--- a/src/lib/eliom_parameter.server.mli
+++ b/src/lib/eliom_parameter.server.mli
@@ -20,7 +20,7 @@
 include
   Eliom_parameter_sigs.S
   with type raw_post_data =
-    ((string * string) * (string * string) list) option * Cohttp_lwt.Body.t
+    ((string * string) * (string * string) list) option * Cohttp_eio.Body.t
 
 val user_type :
    ?client_to_and_of:'a to_and_of Eliom_client_value.t
diff --git a/src/lib/eliom_parameter_sigs.shared.mli b/src/lib/eliom_parameter_sigs.shared.mli
index 1373847192..295cc30d91 100644
--- a/src/lib/eliom_parameter_sigs.shared.mli
+++ b/src/lib/eliom_parameter_sigs.shared.mli
@@ -1,5 +1,3 @@
-open Eio.Std
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2007-2016 Vincent Balat
@@ -379,8 +377,8 @@ module type S = sig
   val reconstruct_params :
      sp:Eliom_common.server_params
     -> ('a, [< `WithSuffix | `WithoutSuffix], 'c) params_type
-    -> (string * string) list Promise.t option
-    -> (string * Eliom_lib.file_info) list Promise.t option
+    -> (string * string) list option
+    -> (string * Eliom_lib.file_info) list option
     -> bool
     -> Eliom_lib.Url.path option
     -> 'a
diff --git a/src/lib/eliom_reference.server.ml b/src/lib/eliom_reference.server.ml
index 3443629a31..bab70b167e 100644
--- a/src/lib/eliom_reference.server.ml
+++ b/src/lib/eliom_reference.server.ml
@@ -1,5 +1,3 @@
-open Eio.Std
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2010 Vincent Balat
@@ -29,16 +27,16 @@ module Ocsipersist = struct
   include Eliom_common.Ocsipersist.Polymorphic
 end
 
-let pers_ref_store = Ocsipersist.open_store "eliom__persistent_refs"
+let pers_ref_store = lazy (Ocsipersist.open_store "eliom__persistent_refs")
 
 type 'a eref_kind =
   | Req of 'a Polytables.key
   | Sit of 'a Polytables.key
   | Ref of 'a lazy_t ref (* Ocaml reference *)
   | Vol of 'a volatile_table Lazy.t (* Vol. table (group, session, process) *)
-  | Ocsiper of 'a option Ocsipersist.t Promise.t (* Global persist. table *)
-  | Ocsiper_sit of 'a Ocsipersist.table Promise.t (* Persist. table for site *)
-  | Per of 'a persistent_table Promise.t
+  | Ocsiper of 'a option Ocsipersist.t Lazy.t (* Global persist. table *)
+  | Ocsiper_sit of 'a Ocsipersist.table Lazy.t (* Persist. table for site *)
+  | Per of 'a persistent_table Lazy.t
 (* Persist. table for group session or process *)
 
 type volatile = [`Volatile]
@@ -175,18 +173,20 @@ let eref_from_fun_ ~ext ~scope ?secure ?persistent f : 'a eref =
         ( f
         , ext
         , Ocsiper
-            (let store = pers_ref_store in
-             Ocsipersist.make_persistent ~store ~name ~default:None) ))
+            (lazy
+              (let (lazy store) = pers_ref_store in
+               Ocsipersist.make_persistent ~store ~name ~default:None)) ))
   | `Site -> (
     match persistent with
     | None -> (Volatile.eref_from_fun_ ~ext ~scope ?secure f :> _ eref)
     | Some name ->
         (*VVV!!! ??? CHECK! *)
-        f, ext, Ocsiper_sit (Ocsipersist.open_table name))
+        f, ext, Ocsiper_sit (lazy (Ocsipersist.open_table name)))
   | #Eliom_common.user_scope as scope -> (
     match persistent with
     | None -> (Volatile.eref_from_fun_ ~ext ~scope ?secure f :> _ eref)
-    | Some name -> f, ext, Per (create_persistent_table ~scope ?secure name))
+    | Some name ->
+        f, ext, Per (lazy (create_persistent_table ~scope ?secure name)))
 
 let eref_from_fun ~scope ?secure ?persistent f : 'a eref =
   eref_from_fun_ ~ext:false ~scope ?secure ?persistent f
@@ -202,7 +202,7 @@ let get_site_id () =
 let get ((f, _, table) as eref) =
   match table with
   | Per t -> (
-      let t = t in
+      let (lazy t) = t in
       match get_persistent_data ~table:t () with
       | Data d -> d
       | _ ->
@@ -210,7 +210,7 @@ let get ((f, _, table) as eref) =
           set_persistent_data ~table:t value;
           value)
   | Ocsiper r -> (
-      let r = r in
+      let (lazy r) = r in
       match Ocsipersist.get r with
       | Some v -> v
       | None ->
@@ -218,7 +218,7 @@ let get ((f, _, table) as eref) =
           Ocsipersist.set r (Some value);
           value)
   | Ocsiper_sit t -> (
-      let t = t in
+      let (lazy t) = t in
       let site_id = get_site_id () in
       try Ocsipersist.find t site_id
       with Not_found ->
@@ -230,13 +230,13 @@ let get ((f, _, table) as eref) =
 let set ((_, _, table) as eref) value =
   match table with
   | Per t ->
-      let t = t in
+      let (lazy t) = t in
       set_persistent_data ~table:t value
   | Ocsiper r ->
-      let r = r in
+      let (lazy r) = r in
       Ocsipersist.set r (Some value)
   | Ocsiper_sit t ->
-      let t = t in
+      let (lazy t) = t in
       Ocsipersist.add t (get_site_id ()) value
   | _ -> Volatile.set eref value
 
@@ -247,13 +247,13 @@ let modify eref f =
 let unset ((_, _, table) as eref) =
   match table with
   | Per t ->
-      let t = t in
+      let (lazy t) = t in
       remove_persistent_data ~table:t ()
   | Ocsiper r ->
-      let r = r in
+      let (lazy r) = r in
       Ocsipersist.set r None
   | Ocsiper_sit t ->
-      let t = t in
+      let (lazy t) = t in
       Ocsipersist.remove t (get_site_id ())
   | _ -> Volatile.unset eref
 
@@ -263,7 +263,7 @@ module Ext = struct
     match table with
     | Vol _ -> Volatile.Ext.get state r
     | Per t -> (
-        let t = t in
+        let (lazy t) = t in
         try Eliom_state.Ext.Low_level.get_persistent_data ~state ~table:t with
         | Not_found ->
             if ext (* We can run the function from another state *)
@@ -281,7 +281,7 @@ module Ext = struct
     match table with
     | Vol _ -> Volatile.Ext.set state r value
     | Per t ->
-        let t = t in
+        let (lazy t) = t in
         Eliom_state.Ext.Low_level.set_persistent_data ~state ~table:t value
     | _ -> raise (Failure "wrong eref for this function")
 
@@ -294,7 +294,7 @@ module Ext = struct
     match table with
     | Vol _ -> Volatile.Ext.unset state r
     | Per t ->
-        let t = t in
+        let (lazy t) = t in
         Eliom_state.Ext.Low_level.remove_persistent_data ~state ~table:t
     | _ -> failwith "wrong eref for this function"
 end
diff --git a/src/lib/eliom_registration.server.ml b/src/lib/eliom_registration.server.ml
index 547ac1488a..15e55cbd54 100644
--- a/src/lib/eliom_registration.server.ml
+++ b/src/lib/eliom_registration.server.ml
@@ -1,5 +1,3 @@
-open Eio.Std
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Module Eliom_registration
@@ -65,16 +63,12 @@ module Result_types : sig
 
   val cast_result : Ocsigen_response.t -> 'a kind
   val cast_kind : 'a kind -> Ocsigen_response.t
-  val cast_kind_lwt : 'a kind Promise.t -> Ocsigen_response.t
-  val cast_result_lwt : Ocsigen_response.t Promise.t -> 'a kind
   val cast_function_http : ('c -> 'a kind) -> 'c -> Ocsigen_response.t
 end = struct
   type 'a kind = Ocsigen_response.t
 
   let cast_result x = x
   let cast_kind x = x
-  let cast_kind_lwt x = x
-  let cast_result_lwt x = x
   let cast_function_http x = x
 end
 
@@ -390,7 +384,7 @@ module Any = struct
   type 'a result = 'a kind
 
   let send ?options ?charset ?code ?content_type ?headers content =
-    Result_types.cast_result_lwt
+    Result_types.cast_result
       (Any_base.send ?options ?charset ?code ?content_type ?headers content)
 end
 
@@ -435,15 +429,12 @@ module File_base = struct
         raise Eliom_common.Eliom_404
     with
     | Ocsigen_local_files.RFile fname ->
-        let res =
-          let headers =
-            Ocsigen_header.of_option headers
-            |> add_cache_header options
-            |> headers_with_content_type ?charset ?content_type
-          in
-          Cohttp_lwt_unix.Server.respond_file ~headers ~fname ()
+        let headers =
+          Ocsigen_header.of_option headers
+          |> add_cache_header options
+          |> headers_with_content_type ?charset ?content_type
         in
-        Ocsigen_response.of_cohttp res
+        Ocsigen_response.respond_file ~headers fname
     | Ocsigen_local_files.RDir _ ->
         (* FIXME COHTTP TRANSITION: implement directories *)
         raise Ocsigen_local_files.Failed_404
@@ -625,7 +616,7 @@ module Ocaml_base = struct
   let send_appl_content = Eliom_service.XNever
 
   let send ?options:_ ?charset ?code ?content_type ?headers content =
-    Result_types.cast_kind_lwt
+    Result_types.cast_kind
       (String.send ?charset ?code ?content_type ?headers
          (content, Eliom_service.eliom_appl_answer_content_type))
 end
@@ -697,7 +688,7 @@ module Ocaml = struct
 
   let send ?options ?charset ?code ?content_type ?headers content =
     let content = prepare_data content in
-    Result_types.cast_result_lwt
+    Result_types.cast_result
       (M.send ?options ?charset ?code ?content_type ?headers content)
 
   let register
@@ -1226,11 +1217,11 @@ struct
     | None ->
         let () = Eliom_reference.set request_template (Some Tmpl_param.name) in
         let content = Tmpl_param.make_page content in
-        Result_types.cast_kind_lwt
+        Result_types.cast_kind
           (Appl.send ~options ?charset ?code ?content_type ?headers content)
     | Some _ ->
         ignore (Tmpl_param.update content);
-        Result_types.cast_kind_lwt
+        Result_types.cast_kind
           (Ocaml.send ?charset ?code ?content_type ?headers ())
 end
 
@@ -1392,7 +1383,7 @@ module Redirection = struct
   include Eliom_mkreg.Make_poly (Redirection_base)
 
   let send ?options ?charset ?code ?content_type ?headers content =
-    Result_types.cast_result_lwt
+    Result_types.cast_result
       (Redirection_base.send ?options ?charset ?code ?content_type ?headers
          content)
 end
diff --git a/src/lib/eliom_request.client.ml b/src/lib/eliom_request.client.ml
index 81ece45ef8..3945548a38 100644
--- a/src/lib/eliom_request.client.ml
+++ b/src/lib/eliom_request.client.ml
@@ -280,7 +280,7 @@ let send
          let unlock_event = React.E.once @@ React.S.changes locked in
          Dom_reference.retain_generic wait_for_unlock
            ~keep:(React.E.map (fun _ -> Promise.resolve unlock ()) unlock_event));
-      let () = wait_for_unlock in
+      let () = Promise.await wait_for_unlock in
       (if Js.Optdef.test Js.Unsafe.global##.___eliom_use_cookie_substitutes_
        then
          match
diff --git a/src/lib/eliom_request_info.server.ml b/src/lib/eliom_request_info.server.ml
index f162e7bd62..6070998cb9 100644
--- a/src/lib/eliom_request_info.server.ml
+++ b/src/lib/eliom_request_info.server.ml
@@ -340,7 +340,7 @@ let set_site_handler sitedata handler =
   sitedata.Eliom_common.exn_handler <- handler
 
 type raw_post_data =
-  ((string * string) * (string * string) list) option * Cohttp_lwt.Body.t
+  ((string * string) * (string * string) list) option * Cohttp_eio.Body.t
 
 let raw_post_data sp =
   let ri = get_ri_sp sp in
diff --git a/src/lib/eliom_request_info.server.mli b/src/lib/eliom_request_info.server.mli
index 2f34f9852e..c48ebb7a52 100644
--- a/src/lib/eliom_request_info.server.mli
+++ b/src/lib/eliom_request_info.server.mli
@@ -1,5 +1,3 @@
-open Eio.Std
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Module eliomsessions.mli
@@ -187,7 +185,7 @@ val get_persistent_nl_get_params :
 val get_nl_post_params : unit -> (string * string) list Eliom_lib.String.Table.t
 (** returns non localized POST parameters. *)
 
-val get_post_params : unit -> (string * string) list Promise.t option
+val get_post_params : unit -> (string * string) list option
 (** returns the parameters in the body of the HTTP request (POST parameters)
     that concern the running service. None means that POST data where
     neither urlencoded form data or multipart data. *)
@@ -352,16 +350,16 @@ val get_ri_sp : Eliom_common.server_params -> Ocsigen_request.t
 
 val get_post_params_sp :
    Eliom_common.server_params
-  -> (string * string) list Promise.t option
+  -> (string * string) list option
 
 val get_files_sp :
    Eliom_common.server_params
-  -> (string * Ocsigen_extensions.file_info) list Promise.t option
+  -> (string * Ocsigen_extensions.file_info) list option
 
 val get_suffix_sp : Eliom_common.server_params -> Eliom_lib.Url.path option
 val get_request_cache_sp : Eliom_common.server_params -> Polytables.t
 
 type raw_post_data =
-  ((string * string) * (string * string) list) option * Cohttp_lwt.Body.t
+  ((string * string) * (string * string) list) option * Cohttp_eio.Body.t
 
 val raw_post_data : Eliom_common.server_params -> raw_post_data
diff --git a/src/lib/eliom_shared.eliom b/src/lib/eliom_shared.eliom
index 421412ce8d..fab32be96c 100644
--- a/src/lib/eliom_shared.eliom
+++ b/src/lib/eliom_shared.eliom
@@ -27,7 +27,7 @@ let to_signal ~init ?eq (th : 'a React.S.t Promise.t) : 'a React.S.t =
   Fiber.fork
     ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
     (fun () ->
-       let ss = th in
+       let ss = Promise.await th in
        let effectful_signal = React.S.map (fun v -> set v) ss in
        ignore (React.S.retain s (fun () -> ignore effectful_signal)));
   s]
diff --git a/src/lib/server/dune b/src/lib/server/dune
index 5d9de4f93b..59567d6639 100644
--- a/src/lib/server/dune
+++ b/src/lib/server/dune
@@ -17,7 +17,7 @@
    (:include type_includes)))
  (library_flags
   (:standard -linkall))
- (libraries lwt_react ocsigenserver logs ocsipersist tyxml))
+ (libraries lwt_react ocsigenserver logs ocsipersist tyxml eio eio.unix))
 
 (include dune.server)
 
diff --git a/src/lib/server/eliommod_sessiongroups.ml b/src/lib/server/eliommod_sessiongroups.ml
index 9c919c486f..362c127da3 100644
--- a/src/lib/server/eliommod_sessiongroups.ml
+++ b/src/lib/server/eliommod_sessiongroups.ml
@@ -421,7 +421,7 @@ module Pers = struct
 
   module Ocsipersist = Eliom_common.Ocsipersist.Polymorphic
 
-  let grouptable : (nbmax * string list) Ocsipersist.table Promise.t Lazy.t =
+  let grouptable : (nbmax * string list) Ocsipersist.table Lazy.t =
     lazy (Ocsipersist.open_table "__eliom_session_group_table")
   (* It is lazy because if the module is linked statically,
          the creation of the table must happen after initialisation

From 03cf9b2ffd5619f4bff7db94cd1e6ac7cd3bebf7 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Thu, 21 Aug 2025 14:38:08 +0200
Subject: [PATCH 07/21] Using Js_of_ocaml_eio.Eio_js.start from eio_js instead
 of Fiber.fork on client side

---
 dune-project                        |   3 +-
 eliom.opam                          |   1 +
 src/lib/client/dune                 |   2 +-
 src/lib/eliom_client.client.ml      | 428 +++++++++++++---------------
 src/lib/eliom_client_core.client.ml |  20 +-
 src/lib/eliom_react.client.ml       |  18 +-
 6 files changed, 222 insertions(+), 250 deletions(-)

diff --git a/dune-project b/dune-project
index 91fcfcfdca..f09acf3010 100644
--- a/dune-project
+++ b/dune-project
@@ -41,4 +41,5 @@ The client-side code is compiled to JS using Ocsigen Js_of_ocaml or to Wasm usin
   base-bytes
   (ocsipersist (and (>= 2.0) (< 3.0)))
   ppx_optcomp
-  (xml-light (>= "2.5"))))
+  (xml-light (>= "2.5"))
+  js_of_ocaml-eio))
diff --git a/eliom.opam b/eliom.opam
index 0a5a479070..4a09b952a0 100644
--- a/eliom.opam
+++ b/eliom.opam
@@ -38,6 +38,7 @@ depends: [
   "ocsipersist" {>= "2.0" & < "3.0"}
   "ppx_optcomp"
   "xml-light" {>= "2.5"}
+  "js_of_ocaml-eio"
   "odoc" {with-doc}
 ]
 build: [
diff --git a/src/lib/client/dune b/src/lib/client/dune
index 3edced7df5..f7866e3921 100644
--- a/src/lib/client/dune
+++ b/src/lib/client/dune
@@ -29,7 +29,7 @@
   cohttp
   tyxml
   reactiveData
-  eio)
+  js_of_ocaml-eio)
  (foreign_stubs
   (language c)
   (names eliom_stubs))
diff --git a/src/lib/eliom_client.client.ml b/src/lib/eliom_client.client.ml
index c7788a9874..a106ca19de 100644
--- a/src/lib/eliom_client.client.ml
+++ b/src/lib/eliom_client.client.ml
@@ -1008,65 +1008,61 @@ let init () =
         onload_handler := None
     | None -> ());
     Eliom_client_core.set_initial_load ();
-    Fiber.fork
-      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-      (fun () ->
-         if !Eliom_config.debug_timings
-         then Console.console##(time (Js.string "onload"));
-         let () =
-           Eliom_request_info.set_session_info
-             ~uri:
-               (String.concat "/"
-                  (Eliom_request_info.get_csp_original_full_path ()))
-             js_data.Eliom_common.ejs_sess_info
-           @@ fun () -> ()
-         in
-         let
-             (* Give the browser the chance to actually display the page NOW *)
-               ()
-           =
-           Js_of_ocaml_lwt.Lwt_js.sleep 0.001
-         in
-         (* Ordering matters. See [Eliom_client.set_content] for explanations *)
-         relink_request_nodes Dom_html.document##.documentElement;
-         let root = Dom_html.document##.documentElement in
-         let closure_nodeList, attrib_nodeList =
-           relink_page_but_client_values root
-         in
-         do_request_data js_data.Eliom_common.ejs_request_data;
-         (* XXX One should check that all values have been unwrapped.
+    Js_of_ocaml_eio.Eio_js.start (fun () ->
+      if !Eliom_config.debug_timings
+      then Console.console##(time (Js.string "onload"));
+      let () =
+        Eliom_request_info.set_session_info
+          ~uri:
+            (String.concat "/"
+               (Eliom_request_info.get_csp_original_full_path ()))
+          js_data.Eliom_common.ejs_sess_info
+        @@ fun () -> ()
+      in
+      let
+          (* Give the browser the chance to actually display the page NOW *)
+            ()
+        =
+        Js_of_ocaml_lwt.Lwt_js.sleep 0.001
+      in
+      (* Ordering matters. See [Eliom_client.set_content] for explanations *)
+      relink_request_nodes Dom_html.document##.documentElement;
+      let root = Dom_html.document##.documentElement in
+      let closure_nodeList, attrib_nodeList =
+        relink_page_but_client_values root
+      in
+      do_request_data js_data.Eliom_common.ejs_request_data;
+      (* XXX One should check that all values have been unwrapped.
             In fact, client values should be special and all other values
             should be eagerly unwrapped. *)
-         let () =
-           relink_attribs root js_data.Eliom_common.ejs_client_attrib_table
-             attrib_nodeList
-         in
-         let onload_closure_nodes =
-           relink_closure_nodes root
-             js_data.Eliom_common.ejs_event_handler_table closure_nodeList
-         in
-         Eliom_client_core.reset_request_nodes ();
-         Eliommod_dom.add_formdata_hack_onclick_handler ();
-         if not (is_client_app ()) then dom_history_ready := true;
-         let load_callbacks =
-           flush_onload ()
-           @ [onload_closure_nodes; Eliom_client_core.broadcast_load_end]
-         in
-         Eio.Mutex.unlock Eliom_client_core.load_mutex;
-         run_callbacks load_callbacks;
-         if !Eliom_config.debug_timings
-         then Console.console##(timeEnd (Js.string "onload")));
+      let () =
+        relink_attribs root js_data.Eliom_common.ejs_client_attrib_table
+          attrib_nodeList
+      in
+      let onload_closure_nodes =
+        relink_closure_nodes root js_data.Eliom_common.ejs_event_handler_table
+          closure_nodeList
+      in
+      Eliom_client_core.reset_request_nodes ();
+      Eliommod_dom.add_formdata_hack_onclick_handler ();
+      if not (is_client_app ()) then dom_history_ready := true;
+      let load_callbacks =
+        flush_onload ()
+        @ [onload_closure_nodes; Eliom_client_core.broadcast_load_end]
+      in
+      Eio.Mutex.unlock Eliom_client_core.load_mutex;
+      run_callbacks load_callbacks;
+      if !Eliom_config.debug_timings
+      then Console.console##(timeEnd (Js.string "onload")));
     Js._false
   in
   Logs.debug ~src:section (fun fmt -> fmt "Set load/onload events");
   if Dom_html.document##.readyState = Js.string "complete"
   then
-    Fiber.fork
-      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-      (fun () ->
-         let () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
-         let _ = onload () in
-         ())
+    Js_of_ocaml_eio.Eio_js.start (fun () ->
+      let () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
+      let _ = onload () in
+      ())
   else
     onload_handler :=
       Some
@@ -1360,11 +1356,9 @@ let set_current_uri, get_current_uri =
     let current_uri = fst (Url.split_fragment uri) in
     (get_this_page ()).url <- current_uri;
     let path, all_get_params = path_and_args_of_uri current_uri in
-    Fiber.fork
-      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-      (fun () ->
-         Eliom_request_info.update_session_info ~path ~all_get_params
-           ~all_post_params:None (fun () -> ()))
+    Js_of_ocaml_eio.Eio_js.start (fun () ->
+      Eliom_request_info.update_session_info ~path ~all_get_params
+        ~all_post_params:None (fun () -> ()))
   in
   let get_current_uri () = (get_this_page ()).url in
   set_current_uri, get_current_uri
@@ -2134,19 +2128,16 @@ let change_page_post_form ?cookies_info ?tmpl form full_uri =
 let _ =
   (Eliom_client_core.change_page_uri_ :=
      fun ?cookies_info ?tmpl href ->
-       Fiber.fork
-         ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-         (fun () -> change_page_uri_a ?cookies_info ?tmpl href));
+       Js_of_ocaml_eio.Eio_js.start (fun () ->
+         change_page_uri_a ?cookies_info ?tmpl href));
   (Eliom_client_core.change_page_get_form_ :=
      fun ?cookies_info ?tmpl form href ->
-       Fiber.fork
-         ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-         (fun () -> change_page_get_form ?cookies_info ?tmpl form href));
+       Js_of_ocaml_eio.Eio_js.start (fun () ->
+         change_page_get_form ?cookies_info ?tmpl form href));
   Eliom_client_core.change_page_post_form_ :=
     fun ?cookies_info ?tmpl form href ->
-      Fiber.fork
-        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-        (fun () -> change_page_post_form ?cookies_info ?tmpl form href)
+      Js_of_ocaml_eio.Eio_js.start (fun () ->
+        change_page_post_form ?cookies_info ?tmpl form href)
 
 (* == Main (internal) function: change the content of the page without leaving
       the javascript application. *)
@@ -2195,121 +2186,112 @@ let () =
         ; target_id = Some target_id }
       in
       let tmpl = state.template in
-      Fiber.fork
-        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-        (fun () ->
-           with_progress_cursor
-           (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
-           @@
-           let uri, fragment = Url.split_fragment full_uri in
-           if uri = get_current_uri ()
-           then (
-             Logs.debug ~src:section_page (fun fmt ->
-               fmt "revisit: uri = get_current_uri");
-             !active_page.page_id <- state_id;
-             scroll_to_fragment ~offset:state.position fragment)
-           else
-             try
-               (* serve cached page from the from history_doms *)
-               Logs.debug ~src:section_page (fun fmt ->
-                 fmt "revisit: uri != get_current_uri");
-               if not (is_in_cache state_id) then raise Not_found;
-               let () = run_lwt_callbacks ev (flush_onchangepage ()) in
-               restore_history_dom target_id;
-               set_current_uri uri;
-               let () =
-                 Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame ()
-               in
-               scroll_to_fragment ~offset:state.position fragment;
-               let
-                   (* Wait for the dom to be repainted before scrolling *)
-                     ()
-                 =
-                 Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame ()
-               in
-               scroll_to_fragment ~offset:state.position fragment
-               (* When we use iPhone, we need to wait for one more
+      Js_of_ocaml_eio.Eio_js.start (fun () ->
+        with_progress_cursor
+        (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+        @@
+        let uri, fragment = Url.split_fragment full_uri in
+        if uri = get_current_uri ()
+        then (
+          Logs.debug ~src:section_page (fun fmt ->
+            fmt "revisit: uri = get_current_uri");
+          !active_page.page_id <- state_id;
+          scroll_to_fragment ~offset:state.position fragment)
+        else
+          try
+            (* serve cached page from the from history_doms *)
+            Logs.debug ~src:section_page (fun fmt ->
+              fmt "revisit: uri != get_current_uri");
+            if not (is_in_cache state_id) then raise Not_found;
+            let () = run_lwt_callbacks ev (flush_onchangepage ()) in
+            restore_history_dom target_id;
+            set_current_uri uri;
+            let () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
+            scroll_to_fragment ~offset:state.position fragment;
+            let
+                (* Wait for the dom to be repainted before scrolling *)
+                  ()
+              =
+              Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame ()
+            in
+            scroll_to_fragment ~offset:state.position fragment
+            (* When we use iPhone, we need to wait for one more
                    [request_animation_frame] before scrolling.The
                    function [scroll_to_fragment] is called twice. In
                    other words, we want to call [scroll_to_fragment]
                    as early as possible so that the scroll position
                    will not jump after the second [request_animation_frame]
                    if the dom has already be painted after the first one. *)
-             with Not_found -> (
-               let session_changed = state_id.session_id <> session_id in
-               if session_changed && is_client_app ()
-               then
-                 failwith
-                   (Printf.sprintf
-                      "revisit: session changed on client: %d => %d (%s)"
-                      state_id.session_id session_id full_uri);
-               try
-                 (* same session *)
-                 if session_changed then raise Not_found;
-                 Logs.debug ~src:section_page (fun fmt ->
-                   fmt "revisit: session has not changed");
-                 let old_page =
-                   History.find_by_state_index state_id.state_index
-                 in
-                 let rf =
-                   Option.bind old_page @@ fun {reload_function = rf; _} -> rf
-                 in
-                 match rf with
-                 | None -> raise Not_found
-                 | Some f ->
-                     reload_function := rf;
-                     let () = run_lwt_callbacks ev (flush_onchangepage ()) in
-                     with_new_page ~state_id ?old_page ~replace:false ()
-                     @@ fun () ->
-                     set_current_uri uri;
-                     History.replace (get_this_page ());
-                     let () =
-                       match f () () with
-                       | Eliom_service.Dom d -> set_content_local d
-                       | r ->
-                           handle_result ~uri:(get_current_uri ()) ~replace:true
-                             r
-                     in
-                     scroll_to_fragment ~offset:state.position fragment
-               with Not_found -> (
-                 (* different session ID *)
-                 set_current_uri uri;
-                 match tmpl with
-                 | Some t when tmpl = Eliom_request_info.get_request_template ()
-                   ->
-                     Logs.debug ~src:section_page (fun fmt ->
-                       fmt
-                         "revisit: template is Some and equals to get_request_template");
-                     let uri, content =
-                       Eliom_request.http_get uri
-                         [Eliom_request.nl_template_string, t]
-                         Eliom_request.string_result
-                     in
-                     let () = set_template_content content ~replace:true ~uri in
-                     scroll_to_fragment ~offset:state.position fragment
-                 | _ ->
-                     if is_client_app ()
-                     then
-                       failwith
-                         (Printf.sprintf
-                            "revisit: could not generate page client-side (%s)"
-                            full_uri);
-                     Logs.debug ~src:section_page (fun fmt ->
-                       fmt "revisit: template is anything else");
-                     with_new_page
-                       ?state_id:
-                         (if session_changed then None else Some state_id)
-                       ~replace:false ()
-                     @@ fun () ->
-                     let uri, content =
-                       Eliom_request.http_get ~expecting_process_page:true uri
-                         [] Eliom_request.xml_result
-                     in
-                     let () =
-                       set_content ~uri ~replace:true ~offset:state.position
-                         ?fragment content
-                     in
-                     ())))
+          with Not_found -> (
+            let session_changed = state_id.session_id <> session_id in
+            if session_changed && is_client_app ()
+            then
+              failwith
+                (Printf.sprintf
+                   "revisit: session changed on client: %d => %d (%s)"
+                   state_id.session_id session_id full_uri);
+            try
+              (* same session *)
+              if session_changed then raise Not_found;
+              Logs.debug ~src:section_page (fun fmt ->
+                fmt "revisit: session has not changed");
+              let old_page = History.find_by_state_index state_id.state_index in
+              let rf =
+                Option.bind old_page @@ fun {reload_function = rf; _} -> rf
+              in
+              match rf with
+              | None -> raise Not_found
+              | Some f ->
+                  reload_function := rf;
+                  let () = run_lwt_callbacks ev (flush_onchangepage ()) in
+                  with_new_page ~state_id ?old_page ~replace:false ()
+                  @@ fun () ->
+                  set_current_uri uri;
+                  History.replace (get_this_page ());
+                  let () =
+                    match f () () with
+                    | Eliom_service.Dom d -> set_content_local d
+                    | r ->
+                        handle_result ~uri:(get_current_uri ()) ~replace:true r
+                  in
+                  scroll_to_fragment ~offset:state.position fragment
+            with Not_found -> (
+              (* different session ID *)
+              set_current_uri uri;
+              match tmpl with
+              | Some t when tmpl = Eliom_request_info.get_request_template () ->
+                  Logs.debug ~src:section_page (fun fmt ->
+                    fmt
+                      "revisit: template is Some and equals to get_request_template");
+                  let uri, content =
+                    Eliom_request.http_get uri
+                      [Eliom_request.nl_template_string, t]
+                      Eliom_request.string_result
+                  in
+                  let () = set_template_content content ~replace:true ~uri in
+                  scroll_to_fragment ~offset:state.position fragment
+              | _ ->
+                  if is_client_app ()
+                  then
+                    failwith
+                      (Printf.sprintf
+                         "revisit: could not generate page client-side (%s)"
+                         full_uri);
+                  Logs.debug ~src:section_page (fun fmt ->
+                    fmt "revisit: template is anything else");
+                  with_new_page
+                    ?state_id:(if session_changed then None else Some state_id)
+                    ~replace:false ()
+                  @@ fun () ->
+                  let uri, content =
+                    Eliom_request.http_get ~expecting_process_page:true uri []
+                      Eliom_request.xml_result
+                  in
+                  let () =
+                    set_content ~uri ~replace:true ~offset:state.position
+                      ?fragment content
+                  in
+                  ())))
     in
     let revisit_wrapper full_uri state_id =
       Logs.debug ~src:section_page (fun fmt -> fmt "revisit_wrapper");
@@ -2319,26 +2301,24 @@ let () =
       and cancel () = () in
       run_onunload_wrapper f cancel
     in
-    Fiber.fork
-      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-      (fun () ->
-         let
-             (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
-               ()
-           =
-           wait_load_end ()
-         in
-         Logs.debug ~src:section_page (fun fmt ->
-           fmt "revisit_wrapper: replaceState");
-         Dom_html.window##.history##(replaceState
-                                       (Js.Opt.return
-                                          (Js.string
-                                             (to_json ~typ:[%json: saved_state]
-                                                ( !active_page.page_id
-                                                , Js.to_string
-                                                    Dom_html.window##.location##.
-                                                    href ))))
-                                       (Js.string "") Js.null));
+    Js_of_ocaml_eio.Eio_js.start (fun () ->
+      let
+          (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+            ()
+        =
+        wait_load_end ()
+      in
+      Logs.debug ~src:section_page (fun fmt ->
+        fmt "revisit_wrapper: replaceState");
+      Dom_html.window##.history##(replaceState
+                                    (Js.Opt.return
+                                       (Js.string
+                                          (to_json ~typ:[%json: saved_state]
+                                             ( !active_page.page_id
+                                             , Js.to_string
+                                                 Dom_html.window##.location##.href
+                                             ))))
+                                    (Js.string "") Js.null));
     Dom_html.window##.onpopstate
     := Dom_html.handler (fun event ->
       Logs.debug ~src:section_page (fun fmt ->
@@ -2359,42 +2339,38 @@ let () =
     *)
     let read_fragment () = Js.to_string Dom_html.window##.location##.hash in
     let auto_change_page fragment =
-      Fiber.fork
-        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-        (fun () ->
-           (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
-           let l = String.length fragment in
-           if l = 0 || (l > 1 && fragment.[1] = '!')
-           then
-             if fragment <> !current_pseudo_fragment
-             then (
-               current_pseudo_fragment := fragment;
-               let uri =
-                 match l with
-                 | 2 -> "./" (* fix for firefox *)
-                 | 0 | 1 -> fst (Url.split_fragment Url.Current.as_string)
-                 | _ -> String.sub fragment 2 (String.length fragment - 2)
-               in
-               Logs.debug ~src:section_page (fun fmt -> fmt "auto_change_page");
-               (* CCC TODO handle templates *)
-               change_page_uri uri)
-             else ()
-           else ())
+      Js_of_ocaml_eio.Eio_js.start (fun () ->
+        (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+        let l = String.length fragment in
+        if l = 0 || (l > 1 && fragment.[1] = '!')
+        then
+          if fragment <> !current_pseudo_fragment
+          then (
+            current_pseudo_fragment := fragment;
+            let uri =
+              match l with
+              | 2 -> "./" (* fix for firefox *)
+              | 0 | 1 -> fst (Url.split_fragment Url.Current.as_string)
+              | _ -> String.sub fragment 2 (String.length fragment - 2)
+            in
+            Logs.debug ~src:section_page (fun fmt -> fmt "auto_change_page");
+            (* CCC TODO handle templates *)
+            change_page_uri uri)
+          else ()
+        else ())
     in
     Eliommod_dom.onhashchange (fun s -> auto_change_page (Js.to_string s));
     let first_fragment = read_fragment () in
     if first_fragment <> !current_pseudo_fragment
     then
-      Fiber.fork
-        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-        (fun () ->
-           let
-               (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
-                 ()
-             =
-             wait_load_end ()
-           in
-           auto_change_page first_fragment)
+      Js_of_ocaml_eio.Eio_js.start (fun () ->
+        let
+            (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+              ()
+          =
+          wait_load_end ()
+        in
+        auto_change_page first_fragment)
 
 let () =
   Eliom_unwrap.register_unwrapper
diff --git a/src/lib/eliom_client_core.client.ml b/src/lib/eliom_client_core.client.ml
index 93f9417368..1cb9ff12d7 100644
--- a/src/lib/eliom_client_core.client.ml
+++ b/src/lib/eliom_client_core.client.ml
@@ -335,11 +335,9 @@ let raw_form_handler form kind cookies_info tmpl ev client_form_handler =
     | `Form_post -> !change_page_post_form_
   in
   let f () =
-    Fiber.fork
-      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-      (fun () ->
-         let b = client_form_handler ev in
-         if not b then change_page_form ?cookies_info ?tmpl form action)
+    Js_of_ocaml_eio.Eio_js.start (fun () ->
+      let b = client_form_handler ev in
+      if not b then change_page_form ?cookies_info ?tmpl form action)
   in
   (not !Eliom_common.is_client_app)
   && ((https = Some true && not Eliom_request_info.ssl_)
@@ -572,13 +570,11 @@ let rec rebuild_rattrib node ra =
    and the function [Eliommod_dom.test_pageshow_pagehide]. *)
 
 let delay f =
-  Fiber.fork
-    ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-    (fun () ->
-       Fiber.yield
-         (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
-         ();
-       f ())
+  Js_of_ocaml_eio.Eio_js.start (fun () ->
+    Fiber.yield
+      (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+      ();
+    f ())
 
 module ReactState : sig
   type t
diff --git a/src/lib/eliom_react.client.ml b/src/lib/eliom_react.client.ml
index d3ce718438..c03e7390b1 100644
--- a/src/lib/eliom_react.client.ml
+++ b/src/lib/eliom_react.client.ml
@@ -49,16 +49,14 @@ module Down = struct
        in Eliom_comet. For example Channel_full. *)
     (* We transform the stream into a stream with exception: *)
     let stream = Eliom_stream.wrap_exn channel in
-    Fiber.fork
-      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-      (fun () ->
-         Eliom_stream.iter_s
-           (function
-             | Error exn ->
-                 let () = handle_react_exn ~exn () in
-                 raise exn
-             | Ok () -> ())
-           stream);
+    Js_of_ocaml_eio.Eio_js.start (fun () ->
+      Eliom_stream.iter_s
+        (function
+          | Error exn ->
+              let () = handle_react_exn ~exn () in
+              raise exn
+          | Ok () -> ())
+        stream);
     E.of_stream channel
 
   let () =

From 37d25860cc36634d099545b72a5a3bda79626e90 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Wed, 27 Aug 2025 19:27:42 +0200
Subject: [PATCH 08/21] Use Js_of_ocaml_eio instead of Js_of_ocaml_lwt

---
 src/lib/eliom_bus.client.ml     | 4 ++--
 src/lib/eliom_client.client.ml  | 8 ++++----
 src/lib/eliom_comet.client.ml   | 4 ++--
 src/lib/eliom_request.client.ml | 2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/lib/eliom_bus.client.ml b/src/lib/eliom_bus.client.ml
index acc4ef6d8a..65d56d3073 100644
--- a/src/lib/eliom_bus.client.ml
+++ b/src/lib/eliom_bus.client.ml
@@ -132,7 +132,7 @@ let create service channel waiter =
   t
 
 let internal_unwrap ((wrapped_bus : ('a, 'b) Ecb.wrapped_bus), _unwrapper) =
-  let waiter () = Js_of_ocaml_lwt.Lwt_js.sleep 0.05 in
+  let waiter () = Js_of_ocaml_eio.Eio_js.sleep 0.05 in
   let channel, Eliom_comet_base.Bus_send_service service = wrapped_bus in
   create service channel waiter
 
@@ -178,6 +178,6 @@ let set_time_before_flush b t =
   b.waiter <-
     (if t <= 0.
      then fun x1 -> Fiber.yield x1
-     else fun () -> Js_of_ocaml_lwt.Lwt_js.sleep t)
+     else fun () -> Js_of_ocaml_eio.Eio_js.sleep t)
 
 let force_link = ()
diff --git a/src/lib/eliom_client.client.ml b/src/lib/eliom_client.client.ml
index a106ca19de..4635bc4d0b 100644
--- a/src/lib/eliom_client.client.ml
+++ b/src/lib/eliom_client.client.ml
@@ -1023,7 +1023,7 @@ let init () =
           (* Give the browser the chance to actually display the page NOW *)
             ()
         =
-        Js_of_ocaml_lwt.Lwt_js.sleep 0.001
+        Js_of_ocaml_eio.Eio_js.sleep 0.001
       in
       (* Ordering matters. See [Eliom_client.set_content] for explanations *)
       relink_request_nodes Dom_html.document##.documentElement;
@@ -1060,7 +1060,7 @@ let init () =
   if Dom_html.document##.readyState = Js.string "complete"
   then
     Js_of_ocaml_eio.Eio_js.start (fun () ->
-      let () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
+      let () = Js_of_ocaml_eio.Eio_js_events.request_animation_frame () in
       let _ = onload () in
       ())
   else
@@ -2206,13 +2206,13 @@ let () =
             let () = run_lwt_callbacks ev (flush_onchangepage ()) in
             restore_history_dom target_id;
             set_current_uri uri;
-            let () = Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame () in
+            let () = Js_of_ocaml_eio.Eio_js_events.request_animation_frame () in
             scroll_to_fragment ~offset:state.position fragment;
             let
                 (* Wait for the dom to be repainted before scrolling *)
                   ()
               =
-              Js_of_ocaml_lwt.Lwt_js_events.request_animation_frame ()
+              Js_of_ocaml_eio.Eio_js_events.request_animation_frame ()
             in
             scroll_to_fragment ~offset:state.position fragment
             (* When we use iPhone, we need to wait for one more
diff --git a/src/lib/eliom_comet.client.ml b/src/lib/eliom_comet.client.ml
index bb184e4551..3f3546dc75 100644
--- a/src/lib/eliom_comet.client.ml
+++ b/src/lib/eliom_comet.client.ml
@@ -169,7 +169,7 @@ module Configuration = struct
     let rec aux t =
       let () =
         Fiber.any
-          [ (fun () -> Js_of_ocaml_lwt.Lwt_js.sleep t)
+          [ (fun () -> Js_of_ocaml_eio.Eio_js.sleep t)
           ; (fun () -> Promise.await !update_configuration_waiter)
           ; active_waiter ]
       in
@@ -552,7 +552,7 @@ end = struct
                 set_activity hd `Inactive;
                 aux 0)
               else
-                let () = Js_of_ocaml_lwt.Lwt_js.sleep (delay retries) in
+                let () = Js_of_ocaml_eio.Eio_js.sleep (delay retries) in
                 aux (retries + 1)
           | Restart ->
               Logs.info ~src:section (fun fmt -> fmt "restart");
diff --git a/src/lib/eliom_request.client.ml b/src/lib/eliom_request.client.ml
index 3945548a38..a2e8dd5279 100644
--- a/src/lib/eliom_request.client.ml
+++ b/src/lib/eliom_request.client.ml
@@ -27,7 +27,7 @@ exception Failed_request of int
 exception Program_terminated
 exception Non_xml_content
 
-module XmlHttpRequest = Js_of_ocaml_lwt.XmlHttpRequest
+module XmlHttpRequest = Js_of_ocaml_eio.XmlHttpRequest
 
 let section = Logs.Src.create "eliom:request"
 (* == ... *)

From 26ba325c89679807be70f1c6ae68700d7c6138bc Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Thu, 21 Aug 2025 18:50:45 +0200
Subject: [PATCH 09/21] Fix use of Fiber.without_binding

---
 src/lib/eliom_request_info.client.ml | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/src/lib/eliom_request_info.client.ml b/src/lib/eliom_request_info.client.ml
index 425b837114..32f1c1cbed 100644
--- a/src/lib/eliom_request_info.client.ml
+++ b/src/lib/eliom_request_info.client.ml
@@ -53,12 +53,9 @@ let get_sess_info () = (get_ri ()).si
 
 let set_session_info ~uri si f =
   let path = Url.path_of_url_string (if uri = "./" then "" else uri) in
-  let ri = Some {path; si} in
-  default_ri := ri;
-  (Option.fold ~none:Fiber.without_binding
-     ~some:(Fun.flip Fiber.with_binding)
-     ri)
-    ri_key f
+  let ri = {path; si} in
+  default_ri := Some ri;
+  Fiber.with_binding ri_key ri f
 
 let matches_regexp name re =
   try
@@ -102,12 +99,9 @@ let update_session_info ~path ~all_get_params ~all_post_params cont =
     ; si_ignored_get_params = ignored_get
     ; si_ignored_post_params = ignored_post }
   in
-  let ri = Some {path; si} in
-  default_ri := ri;
-  (Option.fold ~none:Fiber.without_binding
-     ~some:(Fun.flip Fiber.with_binding)
-     ri)
-    ri_key cont
+  let ri = {path; si} in
+  default_ri := Some ri;
+  Fiber.with_binding ri_key ri cont
 
 let remove_first_slash path = match path with "" :: l -> l | l -> l
 

From 80af5405492e79ed4676dd093d12b93795fcb7a0 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Fri, 22 Aug 2025 22:48:17 +0200
Subject: [PATCH 10/21] Adding fork function in Eliom_lib (different
 implementation on client and server)

---
 src/lib/eliom_lib.client.ml  | 2 ++
 src/lib/eliom_lib.client.mli | 2 ++
 src/lib/eliom_lib.server.ml  | 5 +++++
 src/lib/eliom_lib.server.mli | 2 ++
 4 files changed, 11 insertions(+)

diff --git a/src/lib/eliom_lib.client.ml b/src/lib/eliom_lib.client.ml
index ba775cf357..d454eaf5d4 100644
--- a/src/lib/eliom_lib.client.ml
+++ b/src/lib/eliom_lib.client.ml
@@ -201,3 +201,5 @@ module Dom_reference = struct
          Js.Optdef.iter (m##get key) (fun keep -> retain dst ~key ~keep);
          m##delete key)
 end
+
+let fork = Js_of_ocaml_eio.Eio_js.start
diff --git a/src/lib/eliom_lib.client.mli b/src/lib/eliom_lib.client.mli
index 67cee52e13..6a7153b4bb 100644
--- a/src/lib/eliom_lib.client.mli
+++ b/src/lib/eliom_lib.client.mli
@@ -120,3 +120,5 @@ module Dom_reference : sig
       value [src] and the value associated to key [key] to value
       [dst]. *)
 end
+
+val fork : (unit -> unit) -> unit
diff --git a/src/lib/eliom_lib.server.ml b/src/lib/eliom_lib.server.ml
index 7fb3d6ca74..68d6a94ecd 100644
--- a/src/lib/eliom_lib.server.ml
+++ b/src/lib/eliom_lib.server.ml
@@ -63,3 +63,8 @@ let make_cryptographic_safe_string ?len () =
   match len with
   | None -> Ocsigen_lib.make_cryptographic_safe_string ()
   | Some l -> String.sub (Ocsigen_lib.make_cryptographic_safe_string ()) 0 l
+
+let fork f =
+  Eio.Fiber.fork
+    ~sw:(Stdlib.Option.get (Eio.Fiber.get Ocsigen_lib.current_switch))
+    f
diff --git a/src/lib/eliom_lib.server.mli b/src/lib/eliom_lib.server.mli
index 8df89e1a3e..6625ce0787 100644
--- a/src/lib/eliom_lib.server.mli
+++ b/src/lib/eliom_lib.server.mli
@@ -53,3 +53,5 @@ val eliom_logs_src : Logs.src
 val make_cryptographic_safe_string : ?len:int -> unit -> string
 (** Return a base-64 encoded cryptographic safe string of the given length.
     Not implemented client-side. *)
+
+val fork : (unit -> unit) -> unit

From b4fb12f4a63ff27967f7d1d399b5f57823a729fc Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Sun, 21 Sep 2025 12:48:00 +0200
Subject: [PATCH 11/21] Adding function Eliom_lib.fork_promise

---
 src/lib/eliom_lib.client.ml  | 9 +++++++++
 src/lib/eliom_lib.client.mli | 1 +
 src/lib/eliom_lib.server.ml  | 5 +++++
 src/lib/eliom_lib.server.mli | 1 +
 4 files changed, 16 insertions(+)

diff --git a/src/lib/eliom_lib.client.ml b/src/lib/eliom_lib.client.ml
index d454eaf5d4..3afa0cbaa4 100644
--- a/src/lib/eliom_lib.client.ml
+++ b/src/lib/eliom_lib.client.ml
@@ -203,3 +203,12 @@ module Dom_reference = struct
 end
 
 let fork = Js_of_ocaml_eio.Eio_js.start
+
+let fork_promise f =
+  let p, u = Eio.Promise.create () in
+  Js_of_ocaml_eio.Eio_js.start (fun () ->
+    try
+      let v = f () in
+      Eio.Promise.resolve_ok u v
+    with e -> Eio.Promise.resolve_error u e);
+  p
diff --git a/src/lib/eliom_lib.client.mli b/src/lib/eliom_lib.client.mli
index 6a7153b4bb..9d4ee7ebf4 100644
--- a/src/lib/eliom_lib.client.mli
+++ b/src/lib/eliom_lib.client.mli
@@ -122,3 +122,4 @@ module Dom_reference : sig
 end
 
 val fork : (unit -> unit) -> unit
+val fork_promise : (unit -> 'a) -> 'a Eio.Promise.or_exn
diff --git a/src/lib/eliom_lib.server.ml b/src/lib/eliom_lib.server.ml
index 68d6a94ecd..a1afb8b640 100644
--- a/src/lib/eliom_lib.server.ml
+++ b/src/lib/eliom_lib.server.ml
@@ -68,3 +68,8 @@ let fork f =
   Eio.Fiber.fork
     ~sw:(Stdlib.Option.get (Eio.Fiber.get Ocsigen_lib.current_switch))
     f
+
+let fork_promise f =
+  Eio.Fiber.fork_promise
+    ~sw:(Stdlib.Option.get (Eio.Fiber.get Ocsigen_lib.current_switch))
+    f
diff --git a/src/lib/eliom_lib.server.mli b/src/lib/eliom_lib.server.mli
index 6625ce0787..035a31f794 100644
--- a/src/lib/eliom_lib.server.mli
+++ b/src/lib/eliom_lib.server.mli
@@ -55,3 +55,4 @@ val make_cryptographic_safe_string : ?len:int -> unit -> string
     Not implemented client-side. *)
 
 val fork : (unit -> unit) -> unit
+val fork_promise : (unit -> 'a) -> 'a Eio.Promise.or_exn

From 1eaa3eb01b5049c6c5e6d9089c7c6c3465b397f4 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Wed, 27 Aug 2025 20:01:00 +0200
Subject: [PATCH 12/21] Use Eliom_lib.fork (on client and shared sections at
 least)

---
 src/lib/eliom_form.eliom   | 14 ++++++------
 src/lib/eliom_shared.eliom | 44 +++++++++++++++++---------------------
 2 files changed, 26 insertions(+), 32 deletions(-)

diff --git a/src/lib/eliom_form.eliom b/src/lib/eliom_form.eliom
index ed6b6ecfbf..6438dc2d09 100644
--- a/src/lib/eliom_form.eliom
+++ b/src/lib/eliom_form.eliom
@@ -151,14 +151,12 @@ module Make_links (Html : Html) = struct
               then (
                 Dom.preventDefault ev;
                 Dom_html.stopPropagation ev;
-                Fiber.fork
-                  ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-                  (fun () ->
-                     Eliom_client.change_page ?absolute:~%absolute
-                       ?absolute_path:~%absolute_path ?https:~%https
-                       ~service:~%service ?hostname:~%hostname ?port:~%port
-                       ?fragment:~%fragment ?keep_nl_params:~%keep_nl_params
-                       ?nl_params:~%nl_params ~%getparams ()))]
+                Eliom_lib.fork (fun () ->
+                  Eliom_client.change_page ?absolute:~%absolute
+                    ?absolute_path:~%absolute_path ?https:~%https
+                    ~service:~%service ?hostname:~%hostname ?port:~%port
+                    ?fragment:~%fragment ?keep_nl_params:~%keep_nl_params
+                    ?nl_params:~%nl_params ~%getparams ()))]
         in
         Html.a_onclick f :: href :: a
       else href :: a
diff --git a/src/lib/eliom_shared.eliom b/src/lib/eliom_shared.eliom
index fab32be96c..a7e194411d 100644
--- a/src/lib/eliom_shared.eliom
+++ b/src/lib/eliom_shared.eliom
@@ -24,12 +24,10 @@ open Eio.Std
 (* put this in Eio_react? Find a better name? *)
 let to_signal ~init ?eq (th : 'a React.S.t Promise.t) : 'a React.S.t =
   let s, set = React.S.create ?eq init in
-  Fiber.fork
-    ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-    (fun () ->
-       let ss = Promise.await th in
-       let effectful_signal = React.S.map (fun v -> set v) ss in
-       ignore (React.S.retain s (fun () -> ignore effectful_signal)));
+  Eliom_lib.fork (fun () ->
+    let ss = Promise.await th in
+    let effectful_signal = React.S.map (fun v -> set v) ss in
+    ignore (React.S.retain s (fun () -> ignore effectful_signal)));
   s]
 
 [%%client
@@ -168,24 +166,22 @@ module ReactiveData = struct
         Promise.resolve (snd !waiter) ();
         React.E.map
           (fun msg ->
-             Fiber.fork
-               ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-               (fun () ->
-                  let waiter1 = !waiter in
-                  let new_waiter =
-                    Promise.create
-                      (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
-                      ()
-                  in
-                  waiter := new_waiter;
-                  let new_msg = map_msg_p_lwt f msg in
-                  let _, rhandle = r_th in
-                  let () = fst waiter1 in
-                  (match new_msg with
-                  | ReactiveData.RList.Set s -> ReactiveData.RList.set rhandle s
-                  | ReactiveData.RList.Patch p ->
-                      ReactiveData.RList.patch rhandle p);
-                  Promise.resolve (snd new_waiter) ()))
+             Eliom_lib.fork (fun () ->
+               let waiter1 = !waiter in
+               let new_waiter =
+                 Promise.create
+                   (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
+                   ()
+               in
+               waiter := new_waiter;
+               let new_msg = map_msg_p_lwt f msg in
+               let _, rhandle = r_th in
+               let () = fst waiter1 in
+               (match new_msg with
+               | ReactiveData.RList.Set s -> ReactiveData.RList.set rhandle s
+               | ReactiveData.RList.Patch p ->
+                   ReactiveData.RList.patch rhandle p);
+               Promise.resolve (snd new_waiter) ()))
           event
 
       (** Same as map_p but we do not compute the initial list.

From fcfd471558304c043879a8bbed295de3e906f65c Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Fri, 22 Aug 2025 20:13:44 +0200
Subject: [PATCH 13/21] Switch Eliom_stream to Eio

---
 src/lib/eliom_stream.shared.ml  | 572 ++++++++++++++------------------
 src/lib/eliom_stream.shared.mli |  67 +---
 2 files changed, 253 insertions(+), 386 deletions(-)

diff --git a/src/lib/eliom_stream.shared.ml b/src/lib/eliom_stream.shared.ml
index 878f679399..ac43452af6 100644
--- a/src/lib/eliom_stream.shared.ml
+++ b/src/lib/eliom_stream.shared.ml
@@ -1,11 +1,15 @@
 open Eio.Std
 
 (* This file is part of Lwt, released under the MIT license. See LICENSE.md for
-   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
+   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. 
+   
+   It is a (partial) translation of Lwt_stream to Eio
+*)
 
 exception Closed
 exception Full
 exception Empty
+exception Cancelled
 
 (* A node in a queue of pending data. *)
 type 'a node =
@@ -26,13 +30,13 @@ let new_node () =
 type 'a from =
   { from_create : unit -> 'a option
   ; (* Function used to create new elements. *)
-    mutable from_thread : unit Promise.t
-    (* Thread which:
+    mutable from_promise : unit Eio.Promise.or_exn
+    (* Promise that is currently being computed:
 
      - wait for the thread returned by the last call to [from_next],
      - add the next element to the end of the queue.
 
-     If it is a sleeping thread, then it must be used instead of creating a
+     If it is not resolved, then it must be used instead of creating a
      new one with [from_create]. *)
   }
 
@@ -40,8 +44,8 @@ type 'a from =
 [@@@ocaml.warning "-69"]
 
 type push =
-  { mutable push_signal : unit Promise.t
-  ; (* Thread signaled when a new element is added to the stream. *)
+  { mutable push_signal : unit Eio.Promise.or_exn
+  ; (* Promise resolved when a new element is added to the stream. *)
     mutable push_waiting : bool
   ; (* Is a thread waiting on [push_signal] ? *)
     mutable push_external : Obj.t [@ocaml.warning "-69"]
@@ -49,7 +53,7 @@ type push =
 
 (* Type of a stream source for bounded-push streams. *)
 type 'a push_bounded =
-  { mutable pushb_signal : unit Promise.t
+  { mutable pushb_signal : unit Eio.Promise.or_exn
   ; (* Thread signaled when a new element is added to the stream. *)
     mutable pushb_waiting : bool
   ; (* Is a thread waiting on [pushb_signal] ? *)
@@ -61,8 +65,8 @@ type 'a push_bounded =
   ; (* The next element to push if a thread blocked on push. We store it
      here to be sure it will be the first element to be added when
      space becomes available. *)
-    mutable pushb_push_waiter : unit Promise.t
-  ; mutable pushb_push_wakener : unit Lwt.u
+    mutable pushb_push_waiter : unit Eio.Promise.or_exn
+  ; mutable pushb_push_wakener : (unit, exn) Stdlib.result Eio.Promise.u
   ; (* Thread blocked on push. *)
     mutable pushb_external : Obj.t [@ocaml.warning "-69"]
     (* Reference to an external source. *) }
@@ -79,7 +83,7 @@ type 'a source =
 type 'a t =
   { source : 'a source
   ; (* The source of the stream. *)
-    close : unit Lwt.u
+    close : unit Eio.Promise.u
   ; (* A wakener for a thread that sleeps until the stream is closed. *)
     closed : unit Promise.t
   ; (* A waiter for a thread that sleeps until the stream is closed. *)
@@ -121,10 +125,13 @@ let from_source source =
   in
   {source; close; closed; node; last = ref node}
 
-let from f = from_source (From {from_create = f; from_thread = ()})
+let from f =
+  from_source
+    (From {from_create = f; from_promise = Eio.Promise.create_resolved (Ok ())})
+
 let from_direct f = from_source (From_direct f)
-let closed s = s.closed
-let is_closed s = not (Lwt.is_sleeping (closed s))
+let closed s = Eio.Promise.await s.closed
+let is_closed s = Eio.Promise.is_resolved s.closed
 
 let enqueue' e last =
   let node = !last and new_last = new_node () in
@@ -152,7 +159,7 @@ let create_with_reference () =
   let close = t.close and closed = t.closed and last = t.last in
   (* The push function. It does not keep a reference to the stream. *)
   let push x =
-    if not (Lwt.is_sleeping closed) then raise Closed;
+    if Eio.Promise.is_resolved closed then raise Closed;
     (* Push the element at the end of the queue. *)
     enqueue' x last;
     (* Send a signal if at least one thread is waiting for a new
@@ -169,9 +176,8 @@ let create_with_reference () =
       in
       source.push_signal <- new_waiter;
       push_signal_resolver := new_push_signal_resolver;
-      Promise.resolve
-        (* Signal that a new value has been received. *)
-        old_push_signal_resolver ());
+      (* Signal that a new value has been received. *)
+      Promise.resolve_ok old_push_signal_resolver ());
     (* Do this at the end in case one of the function raise an
        exception. *)
     if x = None then Promise.resolve close ()
@@ -182,13 +188,13 @@ let return a =
   let stream, push, _ = create_with_reference () in
   push (Some a); push None; stream
 
-let return_lwt a =
+let return_promise a =
   let source, push, _ = create_with_reference () in
-  Lwt.dont_wait
-    (fun () ->
-       let x = a in
-       push (Some x); push None)
-    (fun _exc -> push None);
+  Eliom_lib.fork (fun () ->
+    try
+      let x = Eio.Promise.await a in
+      push (Some x); push None
+    with _exc -> push None);
   source
 
 let of_seq s =
@@ -202,17 +208,6 @@ let of_seq s =
   in
   from_direct get
 
-let of_lwt_seq s =
-  let s = ref s in
-  let get () =
-    match !s () with
-    | Lwt_seq.Nil -> None
-    | Lwt_seq.Cons (elt, s') ->
-        s := s';
-        Some elt
-  in
-  from get
-
 let create () =
   let source, push, _ = create_with_reference () in
   source, push
@@ -247,7 +242,7 @@ let notify_pusher info last =
   in
   info.pushb_push_waiter <- waiter;
   info.pushb_push_wakener <- wakener;
-  Promise.resolve old_wakener ()
+  Promise.resolve_ok old_wakener ()
 
 class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
   object
@@ -270,21 +265,14 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
       else if info.pushb_count >= info.pushb_size
       then (
         info.pushb_pending <- Some x;
-        try info.pushb_push_waiter
-        with exn -> (
-          match exn with
-          | Lwt.Canceled ->
-              info.pushb_pending <- None;
-              let waiter, wakener =
-                Promise.create
-                  (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-                  (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
-                  ()
-              in
-              info.pushb_push_waiter <- waiter;
-              info.pushb_push_wakener <- wakener;
-              Lwt.reraise exn
-          | _ -> Lwt.reraise exn))
+        try Eio.Promise.await_exn info.pushb_push_waiter with
+        | Cancelled ->
+            info.pushb_pending <- None;
+            let waiter, wakener = Eio.Promise.create () in
+            info.pushb_push_waiter <- waiter;
+            info.pushb_push_wakener <- wakener;
+            raise Cancelled
+        | exn -> raise exn)
       else (
         (* Push the element at the end of the queue. *)
         enqueue' (Some x) last;
@@ -303,9 +291,8 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
           in
           info.pushb_signal <- new_waiter;
           wakener_cell := new_wakener;
-          Promise.resolve
-            (* Signal that a new value has been received. *)
-            old_wakener ()))
+          (* Signal that a new value has been received. *)
+          Eio.Promise.resolve_ok old_wakener ()))
 
     method close =
       if not closed
@@ -318,7 +305,7 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
         if info.pushb_pending <> None
         then (
           info.pushb_pending <- None;
-          Lwt.wakeup_later_exn info.pushb_push_wakener Closed);
+          Eio.Promise.resolve_error info.pushb_push_wakener Closed);
         (* Send a signal if at least one thread is waiting for a new
          element. *)
         if info.pushb_waiting
@@ -326,8 +313,8 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
           info.pushb_waiting <- false;
           let old_wakener = !wakener_cell in
           (* Signal that a new value has been received. *)
-          Promise.resolve old_wakener ());
-        Promise.resolve close ())
+          Eio.Promise.resolve_ok old_wakener ());
+        Eio.Promise.resolve close ())
 
     method count = info.pushb_count
     method blocked = info.pushb_pending <> None
@@ -371,42 +358,34 @@ let feed s =
   match s.source with
   | From from ->
       (* There is already a thread started to create a new element,
-       wait for this one to terminate. *)
-      if Lwt.is_sleeping from.from_thread
-      then
-        Lwt.protected
-          (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-          (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-          from.from_thread
-      else
-        (* Otherwise request a new element. *)
-        let thread =
-         (* The function [from_create] can raise an exception (with
-           [raise], rather than returning a failed promise with
-           [Lwt.fail]). In this case, we have to catch the exception
-           and turn it into a safe failed promise. *)
-         fun () ->
-          from.from_create () >>= fun x ->
-          (* Push the element to the end of the queue. *)
-          enqueue x s;
-          if x = None then Lwt.wakeup s.close ();
-          Lwt.return_unit
-        in
-        (* Allow other threads to access this thread. *)
-        from.from_thread <- thread;
-        Lwt.protected thread
+         wait for this one to terminate. *)
+      if not (Eio.Promise.is_resolved from.from_promise)
+      then from.from_promise
+      else (* Otherwise request a new element. *)
+        let promise, wakener = Eio.Promise.create () in
+        Eliom_lib.fork (fun () ->
+          try
+            let x = from.from_create () in
+            (* Push the element to the end of the queue. *)
+            enqueue x s;
+            if x = None then Eio.Promise.resolve s.close ();
+            Eio.Promise.resolve_ok wakener ()
+          with exn -> Eio.Promise.resolve_error wakener exn);
+        (* Allow other threads to access this promise: *)
+        from.from_promise <- promise;
+        promise (*XXX protected *)
   | From_direct f ->
       let x = f () in
       (* Push the element to the end of the queue. *)
       enqueue x s;
-      if x = None then Lwt.wakeup s.close ();
-      Lwt.return_unit
+      if x = None then Eio.Promise.resolve s.close ();
+      Eio.Promise.create_resolved (Ok ())
   | Push push ->
       push.push_waiting <- true;
-      Lwt.protected push.push_signal
+      push.push_signal (*XXX protected *)
   | Push_bounded push ->
       push.pushb_waiting <- true;
-      Lwt.protected push.pushb_signal
+      push.pushb_signal (*XXX protected *)
 
 (* Remove [node] from the top of the queue, or do nothing if it was
    already consumed.
@@ -426,65 +405,72 @@ let consume s node =
 
 let rec peek_rec s node =
   if node == !(s.last)
-  then feed s >>= fun () -> peek_rec s node
-  else Lwt.return node.data
+  then (
+    Eio.Promise.await_exn (feed s);
+    peek_rec s node)
+  else node.data
 
 let peek s = peek_rec s s.node
 
 let rec npeek_rec node acc n s =
   if n <= 0
-  then Lwt.return (List.rev acc)
+  then List.rev acc
   else if node == !(s.last)
-  then feed s >>= fun () -> npeek_rec node acc n s
+  then (
+    Eio.Promise.await_exn (feed s);
+    npeek_rec node acc n s)
   else
     match node.data with
     | Some x -> npeek_rec node.next (x :: acc) (n - 1) s
-    | None -> Lwt.return (List.rev acc)
+    | None -> List.rev acc
 
 let npeek n s = npeek_rec s.node [] n s
 
 let rec get_rec s node =
   if node == !(s.last)
-  then feed s >>= fun () -> get_rec s node
+  then (
+    Eio.Promise.await_exn (feed s);
+    get_rec s node)
   else (
     if node.data <> None then consume s node;
-    Lwt.return node.data)
+    node.data)
 
 let get s = get_rec s s.node
 
 let rec get_exn_rec s node =
   if node == !(s.last)
   then
-    Lwt.try_bind
-      (fun () -> feed s)
-      (fun () -> get_exn_rec s node)
-      (fun exn -> Lwt.return (Some (Result.Error exn)))
+    match Eio.Promise.await_exn (feed s) with
+    | () -> get_exn_rec s node
+    | exception exn -> Some (Result.Error exn)
   else
     match node.data with
-    | Some value ->
-        consume s node;
-        Lwt.return (Some (Result.Ok value))
-    | None -> Lwt.return_none
+    | Some value -> consume s node; Some (Result.Ok value)
+    | None -> None
 
 let wrap_exn s = from (fun () -> get_exn_rec s s.node)
 
 let rec nget_rec node acc n s =
   if n <= 0
-  then Lwt.return (List.rev acc)
+  then List.rev acc
   else if node == !(s.last)
-  then feed s >>= fun () -> nget_rec node acc n s
+  then (
+    Eio.Promise.await_exn (feed s);
+    nget_rec node acc n s)
   else
     match s.node.data with
     | Some x ->
         consume s node;
         nget_rec node.next (x :: acc) (n - 1) s
-    | None -> Lwt.return (List.rev acc)
+    | None -> List.rev acc
 
 let nget n s = nget_rec s.node [] n s
 
 let rec get_while_rec node acc f s =
   if node == !(s.last)
-  then feed s >>= fun () -> get_while_rec node acc f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    get_while_rec node acc f s)
   else
     match node.data with
     | Some x ->
@@ -493,84 +479,63 @@ let rec get_while_rec node acc f s =
         then (
           consume s node;
           get_while_rec node.next (x :: acc) f s)
-        else Lwt.return (List.rev acc)
-    | None -> Lwt.return (List.rev acc)
+        else List.rev acc
+    | None -> List.rev acc
 
 let get_while f s = get_while_rec s.node [] f s
 
 let rec get_while_s_rec node acc f s =
   if node == !(s.last)
-  then feed s >>= fun () -> get_while_s_rec node acc f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    get_while_s_rec node acc f s)
   else
     match node.data with
-    | Some x -> (
-        f x >>= function
-        | true ->
-            consume s node;
-            get_while_s_rec node.next (x :: acc) f s
-        | false -> Lwt.return (List.rev acc))
-    | None -> Lwt.return (List.rev acc)
+    | Some x ->
+        if f x
+        then (
+          consume s node;
+          get_while_s_rec node.next (x :: acc) f s)
+        else List.rev acc
+    | None -> List.rev acc
 
 let get_while_s f s = get_while_s_rec s.node [] f s
 
 let rec next_rec s node =
   if node == !(s.last)
-  then feed s >>= fun () -> next_rec s node
-  else
-    match node.data with
-    | Some x -> consume s node; Lwt.return x
-    | None -> Lwt.fail Empty
+  then (
+    Eio.Promise.await_exn (feed s);
+    next_rec s node)
+  else match node.data with Some x -> consume s node; x | None -> raise Empty
 
 let next s = next_rec s s.node
 
-let rec last_new_rec node x s =
-  if node == !(s.last)
-  then
-    let thread = feed s in
-    match Lwt.state thread with
-    | Lwt.Return _ -> last_new_rec node x s
-    | Lwt.Fail exn -> Lwt.fail exn
-    | Lwt.Sleep -> Lwt.return x
-  else
-    match node.data with
-    | Some x -> consume s node; last_new_rec node.next x s
-    | None -> Lwt.return x
-
-let last_new s =
-  let node = s.node in
-  if node == !(s.last)
-  then
-    let thread = next s in
-    match Lwt.state thread with
-    | Lwt.Return x -> last_new_rec node x s
-    | Lwt.Fail _ | Lwt.Sleep -> thread
-  else
-    match node.data with
-    | Some x -> consume s node; last_new_rec node.next x s
-    | None -> Lwt.fail Empty
-
 let rec to_list_rec node acc s =
   if node == !(s.last)
-  then feed s >>= fun () -> to_list_rec node acc s
+  then (
+    Eio.Promise.await_exn (feed s);
+    to_list_rec node acc s)
   else
     match node.data with
     | Some x ->
         consume s node;
         to_list_rec node.next (x :: acc) s
-    | None -> Lwt.return (List.rev acc)
+    | None -> List.rev acc
 
 let to_list s = to_list_rec s.node [] s
 
 let rec to_string_rec node buf s =
   if node == !(s.last)
-  then feed s >>= fun () -> to_string_rec node buf s
+  then (
+    Eio.Promise.await_exn (feed s);
+    to_string_rec node buf s)
   else
     match node.data with
     | Some x ->
         consume s node;
         Buffer.add_char buf x;
         to_string_rec node.next buf s
-    | None -> Lwt.return (Buffer.contents buf)
+    | None -> Buffer.contents buf
 
 let to_string s = to_string_rec s.node (Buffer.create 128) s
 
@@ -578,30 +543,32 @@ let junk s =
   let node = s.node in
   if node == !(s.last)
   then (
-    feed s >>= fun () ->
-    if node.data <> None then consume s node;
-    Lwt.return_unit)
-  else (
-    if node.data <> None then consume s node;
-    Lwt.return_unit)
+    Eio.Promise.await_exn (feed s);
+    if node.data <> None then consume s node)
+  else if node.data <> None
+  then consume s node
 
 let rec njunk_rec node n s =
   if n <= 0
-  then Lwt.return_unit
+  then ()
   else if node == !(s.last)
-  then feed s >>= fun () -> njunk_rec node n s
+  then (
+    Eio.Promise.await_exn (feed s);
+    njunk_rec node n s)
   else
     match node.data with
     | Some _ ->
         consume s node;
         njunk_rec node.next (n - 1) s
-    | None -> Lwt.return_unit
+    | None -> ()
 
 let njunk n s = njunk_rec s.node n s
 
 let rec junk_while_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> junk_while_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    junk_while_rec node f s)
   else
     match node.data with
     | Some x ->
@@ -610,34 +577,35 @@ let rec junk_while_rec node f s =
         then (
           consume s node;
           junk_while_rec node.next f s)
-        else Lwt.return_unit
-    | None -> Lwt.return_unit
+        else ()
+    | None -> ()
 
 let junk_while f s = junk_while_rec s.node f s
 
 let rec junk_while_s_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> junk_while_s_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    junk_while_s_rec node f s)
   else
     match node.data with
-    | Some x -> (
-        f x >>= function
-        | true ->
-            consume s node;
-            junk_while_s_rec node.next f s
-        | false -> Lwt.return_unit)
-    | None -> Lwt.return_unit
+    | Some x ->
+        if f x
+        then (
+          consume s node;
+          junk_while_s_rec node.next f s)
+        else ()
+    | None -> ()
 
 let junk_while_s f s = junk_while_s_rec s.node f s
 
 let rec junk_available_rec node s =
   if node == !(s.last)
   then
-    let thread = feed s in
-    match Lwt.state thread with
-    | Lwt.Return _ -> junk_available_rec node s
-    | Lwt.Fail exn -> raise exn
-    | Lwt.Sleep -> ()
+    match Eio.Promise.peek (feed s) with
+    | Some (Ok _) -> junk_available_rec node s
+    | Some (Error exn) -> raise exn
+    | None -> ()
   else
     match node.data with
     | Some _ ->
@@ -646,16 +614,14 @@ let rec junk_available_rec node s =
     | None -> ()
 
 let junk_available s = junk_available_rec s.node s
-let junk_old s = Lwt.return (junk_available s)
 
 let rec get_available_rec node acc s =
   if node == !(s.last)
   then
-    let thread = feed s in
-    match Lwt.state thread with
-    | Lwt.Return _ -> get_available_rec node acc s
-    | Lwt.Fail exn -> raise exn
-    | Lwt.Sleep -> List.rev acc
+    match Eio.Promise.peek (feed s) with
+    | Some (Ok _) -> get_available_rec node acc s
+    | Some (Error exn) -> raise exn
+    | None -> List.rev acc
   else
     match node.data with
     | Some x ->
@@ -670,11 +636,10 @@ let rec get_available_up_to_rec node acc n s =
   then List.rev acc
   else if node == !(s.last)
   then
-    let thread = feed s in
-    match Lwt.state thread with
-    | Lwt.Return _ -> get_available_up_to_rec node acc n s
-    | Lwt.Fail exn -> raise exn
-    | Lwt.Sleep -> List.rev acc
+    match Eio.Promise.peek (feed s) with
+    | Some (Ok _) -> get_available_up_to_rec node acc n s
+    | Some (Error exn) -> raise exn
+    | None -> List.rev acc
   else
     match s.node.data with
     | Some x ->
@@ -686,60 +651,47 @@ let get_available_up_to n s = get_available_up_to_rec s.node [] n s
 
 let rec is_empty s =
   if s.node == !(s.last)
-  then feed s >>= fun () -> is_empty s
-  else Lwt.return (s.node.data = None)
+  then (
+    Eio.Promise.await_exn (feed s);
+    is_empty s)
+  else s.node.data = None
 
 let map f s =
   from (fun () ->
-    get s >|= function
+    match get s with
     | Some x ->
         let x = f x in
         Some x
     | None -> None)
 
 let map_s f s =
-  from (fun () ->
-    get s >>= function
-    | Some x -> f x >|= fun x -> Some x
-    | None -> Lwt.return_none)
+  from (fun () -> match get s with Some x -> Some (f x) | None -> None)
 
 let filter f s =
   let rec next () =
-    let t = get s in
-    t >>= function
-    | Some x ->
-        let test = f x in
-        if test then t else next ()
-    | None -> Lwt.return_none
+    match get s with Some x as t -> if f x then t else next () | None -> None
   in
   from next
 
 let filter_s f s =
   let rec next () =
-    let t = get s in
-    t >>= function
-    | Some x -> ( f x >>= function true -> t | false -> next ())
-    | None -> t
+    match get s with Some x as t -> if f x then t else next () | None -> None
   in
   from next
 
 let filter_map f s =
   let rec next () =
-    get s >>= function
-    | Some x -> (
-        let x = f x in
-        match x with Some _ -> Lwt.return x | None -> next ())
-    | None -> Lwt.return_none
+    match get s with
+    | Some x -> ( match f x with Some _ as t -> t | None -> next ())
+    | None -> None
   in
   from next
 
 let filter_map_s f s =
   let rec next () =
-    get s >>= function
-    | Some x -> (
-        let t = f x in
-        t >>= function Some _ -> t | None -> next ())
-    | None -> Lwt.return_none
+    match get s with
+    | Some x -> ( match f x with None -> next () | t -> t)
+    | None -> None
   in
   from next
 
@@ -748,15 +700,15 @@ let map_list f s =
   let rec next () =
     match !pendings with
     | [] -> (
-        get s >>= function
-        | Some x ->
-            let l = f x in
-            pendings := l;
-            next ()
-        | None -> Lwt.return_none)
+      match get s with
+      | Some x ->
+          let l = f x in
+          pendings := l;
+          next ()
+      | None -> None)
     | x :: l ->
         pendings := l;
-        Lwt.return (Some x)
+        Some x
   in
   from next
 
@@ -765,15 +717,14 @@ let map_list_s f s =
   let rec next () =
     match !pendings with
     | [] -> (
-        get s >>= function
-        | Some x ->
-            f x >>= fun l ->
-            pendings := l;
-            next ()
-        | None -> Lwt.return_none)
+      match get s with
+      | Some x ->
+          pendings := f x;
+          next ()
+      | None -> None)
     | x :: l ->
         pendings := l;
-        Lwt.return (Some x)
+        Some x
   in
   from next
 
@@ -781,163 +732,145 @@ let flatten s = map_list (fun l -> l) s
 
 let rec fold_rec node f s acc =
   if node == !(s.last)
-  then feed s >>= fun () -> fold_rec node f s acc
+  then (
+    Eio.Promise.await_exn (feed s);
+    fold_rec node f s acc)
   else
     match node.data with
     | Some x ->
         consume s node;
         let acc = f x acc in
         fold_rec node.next f s acc
-    | None -> Lwt.return acc
+    | None -> acc
 
 let fold f s acc = fold_rec s.node f s acc
 
 let rec fold_s_rec node f s acc =
   if node == !(s.last)
-  then feed s >>= fun () -> fold_s_rec node f s acc
+  then (
+    Eio.Promise.await_exn (feed s);
+    fold_s_rec node f s acc)
   else
     match node.data with
     | Some x ->
         consume s node;
-        f x acc >>= fun acc -> fold_s_rec node.next f s acc
-    | None -> Lwt.return acc
+        let acc = f x acc in
+        fold_s_rec node.next f s acc
+    | None -> acc
 
 let fold_s f s acc = fold_s_rec s.node f s acc
 
 let rec iter_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> iter_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    iter_rec node f s)
   else
     match node.data with
-    | Some x ->
-        consume s node;
-        let () = f x in
-        iter_rec node.next f s
-    | None -> Lwt.return_unit
+    | Some x -> consume s node; f x; iter_rec node.next f s
+    | None -> ()
 
 let iter f s = iter_rec s.node f s
 
 let rec iter_s_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> iter_s_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    iter_s_rec node f s)
   else
     match node.data with
-    | Some x ->
-        consume s node;
-        f x >>= fun () -> iter_s_rec node.next f s
-    | None -> Lwt.return_unit
+    | Some x -> consume s node; f x; iter_s_rec node.next f s
+    | None -> ()
 
 let iter_s f s = iter_s_rec s.node f s
 
 let rec iter_p_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> iter_p_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    iter_p_rec node f s)
   else
     match node.data with
     | Some x ->
         consume s node;
-        let res = f x in
-        let rest = iter_p_rec node.next f s in
-        res >>= fun () -> rest
-    | None -> Lwt.return_unit
+        Eio.Fiber.both (fun () -> f x) (fun () -> iter_p_rec node.next f s)
+    | None -> ()
 
 let iter_p f s = iter_p_rec s.node f s
 
-let iter_n ?(max_concurrency = 1) f stream =
-  (if max_concurrency <= 0
-   then
-     let message =
-       Printf.sprintf
-         "Eliom_stream.iter_n: max_concurrency must be > 0, %d given"
-         max_concurrency
-     in
-     invalid_arg message);
-  let rec loop running available =
-    (if available > 0
-     then Lwt.return (running, available)
-     else
-       Lwt.nchoose_split running >>= fun (complete, running) ->
-       Lwt.return (running, available + List.length complete))
-    >>= fun (running, available) ->
-    get stream >>= function
-    | None -> Lwt.join running
-    | Some elt -> loop (f elt :: running) (pred available)
-  in
-  loop [] max_concurrency
-
 let rec find_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> find_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    find_rec node f s)
   else
     match node.data with
     | Some x as opt ->
         consume s node;
         let test = f x in
-        if test then Lwt.return opt else find_rec node.next f s
-    | None -> Lwt.return_none
+        if test then opt else find_rec node.next f s
+    | None -> None
 
 let find f s = find_rec s.node f s
 
 let rec find_s_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> find_s_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    find_s_rec node f s)
   else
     match node.data with
-    | Some x as opt -> (
+    | Some x as opt ->
         consume s node;
-        f x >>= function
-        | true -> Lwt.return opt
-        | false -> find_s_rec node.next f s)
-    | None -> Lwt.return_none
+        if f x then opt else find_s_rec node.next f s
+    | None -> None
 
 let find_s f s = find_s_rec s.node f s
 
 let rec find_map_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> find_map_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    find_map_rec node f s)
   else
     match node.data with
     | Some x ->
         consume s node;
         let x = f x in
-        if x = None then find_map_rec node.next f s else Lwt.return x
-    | None -> Lwt.return_none
+        if x = None then find_map_rec node.next f s else x
+    | None -> None
 
 let find_map f s = find_map_rec s.node f s
 
 let rec find_map_s_rec node f s =
   if node == !(s.last)
-  then feed s >>= fun () -> find_map_s_rec node f s
+  then (
+    Eio.Promise.await_exn (feed s);
+    find_map_s_rec node f s)
   else
     match node.data with
     | Some x -> (
         consume s node;
-        let t = f x in
-        t >>= function None -> find_map_s_rec node.next f s | Some _ -> t)
-    | None -> Lwt.return_none
+        match f x with None -> find_map_s_rec node.next f s | t -> t)
+    | None -> None
 
 let find_map_s f s = find_map_s_rec s.node f s
 
 let combine s1 s2 =
   let next () =
-    let t1 = get s1 and t2 = get s2 in
-    t1 >>= fun n1 ->
-    t2 >>= fun n2 ->
-    match n1, n2 with
-    | Some x1, Some x2 -> Lwt.return (Some (x1, x2))
-    | _ -> Lwt.return_none
+    let n1 = get s1 and n2 = get s2 in
+    match n1, n2 with Some x1, Some x2 -> Some (x1, x2) | _ -> None
   in
   from next
 
 let append s1 s2 =
   let current_s = ref s1 in
   let rec next () =
-    let t = get !current_s in
-    t >>= function
-    | Some _ -> t
+    match get !current_s with
+    | Some _ as t -> t
     | None ->
         if !current_s == s2
-        then Lwt.return_none
+        then None
         else (
           current_s := s2;
           next ())
@@ -945,36 +878,16 @@ let append s1 s2 =
   from next
 
 let concat s_top =
-  let current_s = ref (from (fun () -> Lwt.return_none)) in
+  let current_s = ref (from (fun () -> None)) in
   let rec next () =
-    let t = get !current_s in
-    t >>= function
-    | Some _ -> t
+    match get !current_s with
     | None -> (
-        get s_top >>= function
-        | Some s ->
-            current_s := s;
-            next ()
-        | None -> Lwt.return_none)
-  in
-  from next
-
-let choose streams =
-  let source s = s, get s >|= fun x -> s, x in
-  let streams = ref (List.map source streams) in
-  let rec next () =
-    match !streams with
-    | [] -> Lwt.return_none
-    | l -> (
-        Lwt.choose (List.map snd l) >>= fun (s, x) ->
-        let l = List.remove_assq s l in
-        match x with
-        | Some _ ->
-            streams := source s :: l;
-            Lwt.return x
-        | None ->
-            streams := l;
-            next ())
+      match get s_top with
+      | Some s ->
+          current_s := s;
+          next ()
+      | None -> None)
+    | t -> t
   in
   from next
 
@@ -983,17 +896,16 @@ let parse s f =
   | Push_bounded _ -> invalid_arg "Eliom_stream.parse"
   | From _ | From_direct _ | Push _ -> ());
   let node = s.node in
-  Lwt.catch
-    (fun () -> f s)
-    (fun exn ->
-       s.node <- node;
-       Lwt.reraise exn)
+  try f s
+  with exn ->
+    s.node <- node;
+    raise exn
 
 let hexdump stream =
   let buf = Buffer.create 80 and num = ref 0 in
   from (fun _ ->
-    nget 16 stream >>= function
-    | [] -> Lwt.return_none
+    match nget 16 stream with
+    | [] -> None
     | l ->
         Buffer.clear buf;
         Printf.bprintf buf "%08x|  " !num;
@@ -1020,4 +932,4 @@ let hexdump stream =
                (if ch >= '\x20' && ch <= '\x7e' then ch else '.'))
           l;
         Buffer.add_char buf '|';
-        Lwt.return (Some (Buffer.contents buf)))
+        Some (Buffer.contents buf))
diff --git a/src/lib/eliom_stream.shared.mli b/src/lib/eliom_stream.shared.mli
index 2b918399e8..e15e79a580 100644
--- a/src/lib/eliom_stream.shared.mli
+++ b/src/lib/eliom_stream.shared.mli
@@ -1,7 +1,10 @@
 open Eio.Std
 
 (* This file is part of Lwt, released under the MIT license. See LICENSE.md for
-   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
+   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md.
+   
+   This is a partial translation to Eio of Lwt_stream.
+*)
 
 (** Data streams *)
 
@@ -29,9 +32,7 @@ val from : (unit -> 'a option) -> 'a t
 
 val from_direct : (unit -> 'a option) -> 'a t
 (** [from_direct f] does the same as {!from} but with a function
-    that does not return a thread. It is preferred that this
-    function be used rather than wrapping [f] into a function which
-    returns a thread.
+    that returns immediately.
 
     The behavior when [f] raises an exception is the same as for {!from},
     except that [f] does not produce a thread. *)
@@ -118,7 +119,7 @@ val return : 'a -> 'a t
 
     @since 5.5.0 *)
 
-val return_lwt : 'a Promise.t -> 'a t
+val return_promise : 'a Promise.t -> 'a t
 (** [return_lwt l] creates a stream returning the value that [l] resolves to.
     The value is pushed into the stream immediately after the promise becomes
     resolved and the stream is then immediately closed (in the sense of
@@ -135,12 +136,6 @@ val of_seq : 'a Seq.t -> 'a t
 
     @since 4.2.0 *)
 
-val of_lwt_seq : 'a Lwt_seq.t -> 'a t
-(** [of_lwt_seq s] creates a stream returning all elements of [s]. The elements
-    are evaluated from [s] and pushed onto the stream as the stream is consumed.
-
-    @since 5.5.0 *)
-
 val of_list : 'a list -> 'a t
 (** [of_list l] creates a stream returning all elements of [l]. The elements are
     pushed into the stream immediately, resulting in a closed stream (in the
@@ -167,9 +162,9 @@ val clone : 'a t -> 'a t
       val st1 : int Eliom_stream.t = <abstr>
       # let st2 = Eliom_stream.clone st1;;
       val st2 : int Eliom_stream.t = <abstr>
-      # lwt x = Eliom_stream.next st1;;
+      # let x = Eliom_stream.next st1;;
       val x : int = 1
-      # lwt y = Eliom_stream.next st2;;
+      # let y = Eliom_stream.next st2;;
       val y : int = 1
     ]}
 
@@ -217,12 +212,6 @@ val next : 'a t -> 'a
 (** [next st] removes and returns the next element of the stream or
     fails with {!Empty}, if the stream is empty. *)
 
-val last_new : 'a t -> 'a
-(** [last_new st] returns the last element that can be obtained
-    without sleeping, or wait for one if none is available.
-
-    It fails with {!Empty} if the stream has no more elements. *)
-
 val junk : 'a t -> unit
 (** [junk st] removes the first element of [st]. *)
 
@@ -260,17 +249,10 @@ val is_closed : 'a t -> bool
     @since 2.6.0 *)
 
 val closed : 'a t -> unit
-(** [closed st] returns a thread that will sleep until the stream has been
-    closed.
+(** [closed st] will block until the stream has been closed.
 
     @since 2.6.0 *)
 
-(** {3 Deprecated} *)
-
-val junk_old : 'a t -> unit
-[@@deprecated "Use junk_available instead"]
-(** @deprecated [junk_old st] is [Lwt.return (junk_available st)]. *)
-
 (** {2 Stream transversal} *)
 
 (** Note: all the following functions are destructive.
@@ -282,18 +264,13 @@ val junk_old : 'a t -> unit
       val st1 : int Eliom_stream.t = <abstr>
       # let st2 = Eliom_stream.map string_of_int st1;;
       val st2 : string Eliom_stream.t = <abstr>
-      # lwt x = Eliom_stream.next st1;;
+      # let x = Eliom_stream.next st1;;
       val x : int = 1
-      # lwt y = Eliom_stream.next st2;;
+      # let y = Eliom_stream.next st2;;
       val y : string = "2"
     ]}
 *)
 
-val choose : 'a t list -> 'a t
-(** [choose l] creates an stream from a list of streams. The
-    resulting stream will return elements returned by any stream of
-    [l] in an unspecified order. *)
-
 val map : ('a -> 'b) -> 'a t -> 'b t
 
 val map_s : ('a -> 'b) -> 'a t -> 'b t
@@ -326,18 +303,6 @@ val iter_p : ('a -> unit) -> 'a t -> unit
 val iter_s : ('a -> unit) -> 'a t -> unit
 (** [iter f s] iterates over all elements of the stream. *)
 
-val iter_n : ?max_concurrency:int -> ('a -> unit) -> 'a t -> unit
-(** [iter_n ?max_concurrency f s] iterates over all elements of the stream [s].
-    Iteration is performed concurrently with up to [max_threads] concurrent
-    instances of [f].
-
-    Iteration is {b not} guaranteed to be in order as this function will
-    attempt to always process [max_concurrency] elements from [s] at once.
-
-    @param max_concurrency defaults to [1].
-    @raise Invalid_argument if [max_concurrency < 1].
-    @since 3.3.0 *)
-
 val find : ('a -> bool) -> 'a t -> 'a option
 
 val find_s : ('a -> bool) -> 'a t -> 'a option
@@ -389,14 +354,4 @@ val parse : 'a t -> ('a t -> 'b) -> 'b
 val hexdump : char t -> string t
 (** [hexdump byte_stream] returns a stream which is the same as the
     output of [hexdump -C].
-
-    Basically, here is a simple implementation of [hexdump -C]:
-
-    {[
-      let () = Lwt_main.run begin
-          Lwt_io.write_lines
-            Lwt_io.stdout
-            (Eliom_stream.hexdump (Lwt_io.read_lines Lwt_io.stdin))
-        end
-    ]}
 *)

From 3c876166d855463cd5682492fb6be7f147bab79c Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Sat, 23 Aug 2025 00:08:57 +0200
Subject: [PATCH 14/21] Switch Lwt_react to Eio: manual changes

---
 src/lib/eio_react.shared.ml     | 312 +++++++++++++++-----------------
 src/lib/eio_react.shared.mli    |  59 +++---
 src/lib/eliom_comet.server.ml   |  14 +-
 src/lib/eliom_common.server.mli |   2 -
 4 files changed, 190 insertions(+), 197 deletions(-)

diff --git a/src/lib/eio_react.shared.ml b/src/lib/eio_react.shared.ml
index 1a6743de68..21d5686134 100644
--- a/src/lib/eio_react.shared.ml
+++ b/src/lib/eio_react.shared.ml
@@ -9,10 +9,6 @@ type 'a signal = 'a React.signal
 module E = struct
   include React.E
 
-  (* +---------------------------------------------------------------+
-     | Lwt-specific utilities                                        |
-     +---------------------------------------------------------------+ *)
-
   let finalise f _ = f ()
 
   let with_finaliser f event =
@@ -31,59 +27,50 @@ module E = struct
         (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
-    let ev = map (fun x -> Promise.resolve wakener x) (once ev) in
-    Lwt.on_cancel
+    let _ev = map (fun x -> Promise.resolve wakener x) (once ev) in
+    (* XXX restore this if promise can be cancelled
+      Lwt.on_cancel
       (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
       (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
       waiter (fun () -> stop ev);
+    *)
     waiter
 
   let limit f e =
-    (* Thread which prevents [e] from occurring while it is sleeping *)
-    let limiter = ref () in
+    let is_sleeping = ref false in
     (* The occurrence that is delayed until the limiter returns. *)
     let delayed = ref None in
     (* The resulting event. *)
     let event, push = create () in
+    let rec start_sleeping () =
+      f ();
+      match !delayed with
+      | None -> is_sleeping := false
+      | Some v ->
+          Eliom_lib.fork start_sleeping;
+          delayed := None;
+          push v
+    in
     let iter =
       fmap
         (fun x ->
-           if Lwt.is_sleeping !limiter
-           then (
-             (* The limiter is sleeping, we queue the event for later
-                delivering. *)
-             match !delayed with
-             | Some cell ->
-                 (* An occurrence is already queued, replace it. *)
-                 cell := x;
-                 None
-             | None ->
-                 let cell = ref x in
-                 delayed := Some cell;
-                 Lwt.on_success !limiter (fun () ->
-                   if Lwt.is_sleeping !limiter
-                   then delayed := None
-                   else
-                     let x = !cell in
-                     delayed := None;
-                     limiter := f ();
-                     push x);
-                 None)
+           if !is_sleeping
+           then delayed := Some x
            else (
-             (* Set the limiter for future events. *)
-             limiter := f ();
+             is_sleeping := true;
+             delayed := None;
+             Eliom_lib.fork start_sleeping;
              (* Send the occurrence now. *)
-             push x;
-             None))
+             push x);
+           None)
         e
     in
+    (* iter never happens, but we put it in the select to keep it alive
+    (effectful event) *)
     select [iter; event]
 
-  let cancel_thread t () =
-    Lwt.cancel
-      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-      t
+  let cancel_switch sw () =
+    Eio.Switch.fail sw (Failure "Eio_react.cancel_switch")
 
   let from f =
     let event, push = create () in
@@ -91,8 +78,9 @@ module E = struct
       let x = f () in
       push x; loop ()
     in
-    let t = loop (Fiber.yield ()) in
-    with_finaliser (cancel_thread t) event
+    Switch.run (fun sw ->
+      Eio.Fiber.fork ~sw (fun () -> Fiber.yield (); loop ());
+      with_finaliser (cancel_switch sw) event)
 
   let to_stream event =
     let stream, push, set_ref = Eliom_stream.create_with_reference () in
@@ -101,23 +89,21 @@ module E = struct
 
   let of_stream stream =
     let event, push = create () in
-    let t =
-      Fiber.yield ();
-      Eliom_stream.iter
-        (fun v ->
-           try push v
-           with exn when Lwt.Exception_filter.run exn ->
-             !Lwt.async_exception_hook exn)
-        stream
-    in
-    with_finaliser (cancel_thread t) event
-
-  let delay thread =
-    match Lwt.poll thread with
+    Switch.run (fun sw ->
+      Eio.Fiber.fork ~sw (fun () ->
+        Fiber.yield ();
+        (*XXX Check what happens if an exception is raised *)
+        Eliom_stream.iter push stream);
+      with_finaliser (cancel_switch sw) event)
+
+  let delay promise =
+    match Eio.Promise.peek promise with
     | Some e -> e
     | None ->
         let event, send = create () in
-        Lwt.on_success thread (fun e -> send e; stop event);
+        Eliom_lib.fork (fun () ->
+          let e = Eio.Promise.await promise in
+          send e; stop event);
         switch never event
 
   let keeped = ref []
@@ -131,8 +117,8 @@ module E = struct
     let event, push = create () in
     let iter =
       fmap
-        (fun t ->
-           Lwt.on_success t (fun v -> push v);
+        (fun p ->
+           Eliom_lib.fork (fun () -> push (Eio.Promise.await p));
            None)
         e
     in
@@ -143,10 +129,10 @@ module E = struct
     let mutex = Eio.Mutex.create () in
     let iter =
       fmap
-        (fun t ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> t))
-             (fun v -> push v);
+        (fun p ->
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               push (Eio.Promise.await p)));
            None)
         e
     in
@@ -157,7 +143,7 @@ module E = struct
     let iter =
       fmap
         (fun x ->
-           Lwt.on_success (f x) (fun v -> push v);
+           Eliom_lib.fork (fun () -> push (f x));
            None)
         e
     in
@@ -169,9 +155,8 @@ module E = struct
     let iter =
       fmap
         (fun x ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (fun v -> push v);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () -> push (f x)));
            None)
         e
     in
@@ -182,7 +167,7 @@ module E = struct
     let iter =
       fmap
         (fun (f, x) ->
-           Lwt.on_success (f x) (fun v -> push v);
+           Eliom_lib.fork (fun () -> push (f x));
            None)
         (app (map (fun f x -> f, x) ef) e)
     in
@@ -194,9 +179,8 @@ module E = struct
     let iter =
       fmap
         (fun (f, x) ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (fun v -> push v);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () -> push (f x)));
            None)
         (app (map (fun f x -> f, x) ef) e)
     in
@@ -207,7 +191,7 @@ module E = struct
     let iter =
       fmap
         (fun x ->
-           Lwt.on_success (f x) (function true -> push x | false -> ());
+           Eliom_lib.fork (fun () -> if f x then push x);
            None)
         e
     in
@@ -219,9 +203,9 @@ module E = struct
     let iter =
       fmap
         (fun x ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (function true -> push x | false -> ());
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               if f x then push x));
            None)
         e
     in
@@ -232,7 +216,8 @@ module E = struct
     let iter =
       fmap
         (fun x ->
-           Lwt.on_success (f x) (function Some x -> push x | None -> ());
+           Eliom_lib.fork (fun () ->
+             match f x with Some x -> push x | None -> ());
            None)
         e
     in
@@ -244,9 +229,9 @@ module E = struct
     let iter =
       fmap
         (fun x ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (function Some x -> push x | None -> ());
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               match f x with Some x -> push x | None -> ()));
            None)
         e
     in
@@ -265,9 +250,8 @@ module E = struct
                None
            | Some y ->
                previous := Some x;
-               Lwt.on_success
-                 (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x y))
-                 (fun v -> push v);
+               Eliom_lib.fork (fun () ->
+                 Eio.Mutex.use_rw ~protect:false mutex (fun () -> push (f x y)));
                None)
         e
     in
@@ -280,11 +264,11 @@ module E = struct
     let iter =
       fmap
         (fun f ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f !acc))
-             (fun x ->
-                acc := x;
-                push x);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               let x = f !acc in
+               acc := x;
+               push x));
            None)
         ef
     in
@@ -297,11 +281,11 @@ module E = struct
     let iter =
       fmap
         (fun x ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f !acc x))
-             (fun x ->
-                acc := x;
-                push x);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               let x = f !acc x in
+               acc := x;
+               push x));
            None)
         e
     in
@@ -319,9 +303,9 @@ module E = struct
     let iter =
       fmap
         (fun l ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> rev_fold f acc l))
-             (fun v -> push v);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               push (rev_fold f acc l)));
            None)
         (merge (fun acc x -> x :: acc) [] el)
     in
@@ -347,44 +331,37 @@ module S = struct
       signal
 
   let limit ?eq f s =
-    (* Thread which prevent [s] to changes while it is sleeping *)
-    let limiter = ref (f ()) in
+    let is_sleeping = ref true in
     (* The occurrence that is delayed until the limiter returns. *)
     let delayed = ref None in
     (* The resulting event. *)
     let event, push = E.create () in
+    let rec start_sleeping () =
+      f ();
+      match !delayed with
+      | None -> is_sleeping := false
+      | Some v ->
+          Eliom_lib.fork start_sleeping;
+          delayed := None;
+          push v
+    in
+    Eliom_lib.fork start_sleeping;
     let iter =
       E.fmap
         (fun x ->
-           if Lwt.is_sleeping !limiter
-           then (
-             (* The limiter is sleeping, we queue the event for later
-                delivering. *)
-             match !delayed with
-             | Some cell ->
-                 (* An occurrence is already queued, replace it. *)
-                 cell := x;
-                 None
-             | None ->
-                 let cell = ref x in
-                 delayed := Some cell;
-                 Lwt.on_success !limiter (fun () ->
-                   if Lwt.is_sleeping !limiter
-                   then delayed := None
-                   else
-                     let x = !cell in
-                     delayed := None;
-                     limiter := f ();
-                     push x);
-                 None)
+           if !is_sleeping
+           then delayed := Some x
            else (
-             (* Set the limiter for future events. *)
-             limiter := f ();
+             is_sleeping := true;
+             delayed := None;
+             Eliom_lib.fork start_sleeping;
              (* Send the occurrence now. *)
-             push x;
-             None))
+             push x);
+           None)
         (changes s)
     in
+    (* iter never happens, but we put it in the select to keep it alive
+    (effectful event) *)
     hold ?eq (value s) (E.select [iter; event])
 
   let keeped = ref []
@@ -399,15 +376,19 @@ module S = struct
     let mutex = Eio.Mutex.create () in
     let iter =
       E.fmap
-        (fun t ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> t))
-             (fun v -> push v);
+        (fun p ->
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               push (Eio.Promise.await p)));
            None)
         (changes s)
     in
-    let x = Eio.Mutex.use_rw ~protect:false mutex (fun () -> value s) in
-    hold ?eq x (E.select [iter; event])
+    Eliom_lib.fork_promise (fun () ->
+      let x =
+        Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+          Eio.Promise.await (value s))
+      in
+      hold ?eq x (E.select [iter; event]))
 
   let map_s ?eq f s =
     let event, push = E.create () in
@@ -415,14 +396,14 @@ module S = struct
     let iter =
       E.fmap
         (fun x ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (fun v -> push v);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () -> push (f x)));
            None)
         (changes s)
     in
-    let x = Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) in
-    hold ?eq x (E.select [iter; event])
+    Eliom_lib.fork_promise (fun () ->
+      let x = Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) in
+      hold ?eq x (E.select [iter; event]))
 
   let app_s ?eq sf s =
     let event, push = E.create () in
@@ -430,16 +411,16 @@ module S = struct
     let iter =
       E.fmap
         (fun (f, x) ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (fun v -> push v);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () -> push (f x)));
            None)
         (E.app (E.map (fun f x -> f, x) (changes sf)) (changes s))
     in
-    let x =
-      Eio.Mutex.use_rw ~protect:false mutex (fun () -> (value sf) (value s))
-    in
-    hold ?eq x (E.select [iter; event])
+    Eliom_lib.fork_promise (fun () ->
+      let x =
+        Eio.Mutex.use_rw ~protect:false mutex (fun () -> (value sf) (value s))
+      in
+      hold ?eq x (E.select [iter; event]))
 
   let filter_s ?eq f i s =
     let event, push = E.create () in
@@ -447,16 +428,17 @@ module S = struct
     let iter =
       E.fmap
         (fun x ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (function true -> push x | false -> ());
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               if f x then push x));
            None)
         (changes s)
     in
     let x = value s in
-    match Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x) with
-    | true -> hold ?eq x (E.select [iter; event])
-    | false -> hold ?eq i (E.select [iter; event])
+    Eliom_lib.fork_promise (fun () ->
+      match Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x) with
+      | true -> hold ?eq x (E.select [iter; event])
+      | false -> hold ?eq i (E.select [iter; event]))
 
   let fmap_s ?eq f i s =
     let event, push = E.create () in
@@ -464,15 +446,16 @@ module S = struct
     let iter =
       E.fmap
         (fun x ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (function Some x -> push x | None -> ());
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               match f x with Some x -> push x | None -> ()));
            None)
         (changes s)
     in
-    match Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) with
-    | Some x -> hold ?eq x (E.select [iter; event])
-    | None -> hold ?eq i (E.select [iter; event])
+    Eliom_lib.fork_promise (fun () ->
+      match Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) with
+      | Some x -> hold ?eq x (E.select [iter; event])
+      | None -> hold ?eq i (E.select [iter; event]))
 
   let diff_s f s =
     let previous = ref (value s) in
@@ -483,9 +466,8 @@ module S = struct
         (fun x ->
            let y = !previous in
            previous := x;
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x y))
-             (fun v -> push v);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () -> push (f x y)));
            None)
         (changes s)
     in
@@ -508,16 +490,18 @@ module S = struct
     let iter =
       E.fmap
         (fun l ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> rev_fold f acc l))
-             (fun v -> push v);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+               push (rev_fold f acc l)));
            None)
         (changes s)
     in
-    let x =
-      Eio.Mutex.use_rw ~protect:false mutex (fun () -> rev_fold f acc (value s))
-    in
-    hold ?eq x (E.select [iter; event])
+    Eliom_lib.fork_promise (fun () ->
+      let x =
+        Eio.Mutex.use_rw ~protect:false mutex (fun () ->
+          rev_fold f acc (value s))
+      in
+      hold ?eq x (E.select [iter; event]))
 
   let l1_s ?eq f s1 = map_s ?eq f s1
 
@@ -569,12 +553,12 @@ module S = struct
     let iter =
       E.fmap
         (fun x ->
-           Lwt.on_success
-             (Eio.Mutex.use_rw ~protect:false mutex (fun () -> f x))
-             (fun v -> push v);
+           Eliom_lib.fork (fun () ->
+             Eio.Mutex.use_rw ~protect:false mutex (fun () -> push (f x)));
            None)
         (changes s)
     in
-    let x = Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) in
-    switch ?eq (hold ~eq:( == ) x (E.select [iter; event]))
+    Eliom_lib.fork_promise (fun () ->
+      let x = Eio.Mutex.use_rw ~protect:false mutex (fun () -> f (value s)) in
+      switch ?eq (hold ~eq:( == ) x (E.select [iter; event])))
 end
diff --git a/src/lib/eio_react.shared.mli b/src/lib/eio_react.shared.mli
index f58d859471..64bfd944f8 100644
--- a/src/lib/eio_react.shared.mli
+++ b/src/lib/eio_react.shared.mli
@@ -1,16 +1,17 @@
 open Eio.Std
 
-(* This file is part of Lwt, released under the MIT license. See LICENSE.md for
-   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. *)
+(* This file is released under the MIT license. See LICENSE.md for
+   details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. 
+   
+   It is a partial translation of Lwt_react for Eio
+*)
 
 (** React utilities *)
 
 (** This module is an overlay for the [React] module. You can open it
     instead of the [React] module in order to get all of [React]'s functions
-    plus Lwt ones.
-
-    This module is provided by OPAM package [lwt_react]. Link with ocamlfind
-    package [lwt_react]. *)
+    plus Eio ones.
+ *)
 
 type 'a event = 'a React.event
 (** Type of events. *)
@@ -21,14 +22,14 @@ type 'a signal = 'a React.signal
 module E : sig
   include module type of React.E
 
-  (** {2 Lwt-specific utilities} *)
+  (** {2 Eio-specific utilities} *)
 
   val with_finaliser : (unit -> unit) -> 'a event -> 'a event
   (** [with_finaliser f e] returns an event [e'] which behave as
         [e], except that [f] is called when [e'] is garbage
         collected. *)
 
-  val next : 'a event -> 'a
+  val next : 'a event -> 'a Eio.Promise.t
   (** [next e] returns the next occurrence of [e].
 
       Avoid trying to create an “asynchronous loop” by calling [next e] again in
@@ -50,10 +51,11 @@ module E : sig
   (** [limit f e] limits the rate of [e] with [f].
 
         For example, to limit the rate of an event to 1 per second you
-        can use: [limit (fun () -> Lwt_unix.sleep 1.0) event]. *)
+        can use: [limit (fun () -> Eio_unix.sleep 1.0) event]. *)
 
   val from : (unit -> 'a) -> 'a event
-  (** [from f] creates an event which occurs each time [f ()]
+  (** [from f] launches f in a fork and
+        creates an event which occurs each time [f ()]
         returns a value. If [f] raises an exception, the event is just
         stopped. *)
 
@@ -126,7 +128,7 @@ module S : sig
      ?eq:('b -> 'b -> bool)
     -> 'a signal
     -> ('a -> 'b signal)
-    -> 'b signal
+    -> 'b signal Eio.Promise.or_exn
   (** Same as {!bind} except that [f] returns a promise. Calls to [f]
         are serialized. *)
 
@@ -159,23 +161,27 @@ module S : sig
      ?eq:('b -> 'b -> bool)
     -> ('a -> 'b) signal
     -> 'a signal
-    -> 'b signal
+    -> 'b signal Eio.Promise.or_exn
 
-  val map_s : ?eq:('b -> 'b -> bool) -> ('a -> 'b) -> 'a signal -> 'b signal
+  val map_s :
+     ?eq:('b -> 'b -> bool)
+    -> ('a -> 'b)
+    -> 'a signal
+    -> 'b signal Eio.Promise.or_exn
 
   val filter_s :
      ?eq:('a -> 'a -> bool)
     -> ('a -> bool)
     -> 'a
     -> 'a signal
-    -> 'a signal
+    -> 'a signal Eio.Promise.or_exn
 
   val fmap_s :
      ?eq:('b -> 'b -> bool)
     -> ('a -> 'b option)
     -> 'b
     -> 'a signal
-    -> 'b signal
+    -> 'b signal Eio.Promise.or_exn
 
   val diff_s : ('a -> 'a -> 'b) -> 'a signal -> 'b event
   val sample_s : ('b -> 'a -> 'c) -> 'b event -> 'a signal -> 'c event
@@ -193,16 +199,20 @@ module S : sig
     -> ('a -> 'b -> 'a)
     -> 'a
     -> 'b signal list
-    -> 'a signal
+    -> 'a signal Eio.Promise.or_exn
 
-  val l1_s : ?eq:('b -> 'b -> bool) -> ('a -> 'b) -> 'a signal -> 'b signal
+  val l1_s :
+     ?eq:('b -> 'b -> bool)
+    -> ('a -> 'b)
+    -> 'a signal
+    -> 'b signal Eio.Promise.or_exn
 
   val l2_s :
      ?eq:('c -> 'c -> bool)
     -> ('a -> 'b -> 'c)
     -> 'a signal
     -> 'b signal
-    -> 'c signal
+    -> 'c signal Eio.Promise.or_exn
 
   val l3_s :
      ?eq:('d -> 'd -> bool)
@@ -210,7 +220,7 @@ module S : sig
     -> 'a signal
     -> 'b signal
     -> 'c signal
-    -> 'd signal
+    -> 'd signal Eio.Promise.or_exn
 
   val l4_s :
      ?eq:('e -> 'e -> bool)
@@ -219,7 +229,7 @@ module S : sig
     -> 'b signal
     -> 'c signal
     -> 'd signal
-    -> 'e signal
+    -> 'e signal Eio.Promise.or_exn
 
   val l5_s :
      ?eq:('f -> 'f -> bool)
@@ -229,7 +239,7 @@ module S : sig
     -> 'c signal
     -> 'd signal
     -> 'e signal
-    -> 'f signal
+    -> 'f signal Eio.Promise.or_exn
 
   val l6_s :
      ?eq:('g -> 'g -> bool)
@@ -240,7 +250,10 @@ module S : sig
     -> 'd signal
     -> 'e signal
     -> 'f signal
-    -> 'g signal
+    -> 'g signal Eio.Promise.or_exn
 
-  val run_s : ?eq:('a -> 'a -> bool) -> 'a Promise.t signal -> 'a signal
+  val run_s :
+     ?eq:('a -> 'a -> bool)
+    -> 'a Promise.t signal
+    -> 'a signal Promise.or_exn
 end
diff --git a/src/lib/eliom_comet.server.ml b/src/lib/eliom_comet.server.ml
index 3b5bf76e91..73d0559538 100644
--- a/src/lib/eliom_comet.server.ml
+++ b/src/lib/eliom_comet.server.ml
@@ -147,10 +147,11 @@ end = struct
             (Dlist.add (msg, channel.ch_index) channel.ch_content : 'a option);
           wakeup_waiters channel
     in
-    ignore
-      (Fiber.without_binding Eliom_common.sp_key (fun () ->
-         Eliom_stream.iter_s f stream)
-       : unit Promise.t)
+    Fiber.fork
+      ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
+      (fun () ->
+         Fiber.without_binding Eliom_common.sp_key (fun () ->
+           Eliom_stream.iter_s f stream))
 
   let make_name name = "stateless:" ^ name
 
@@ -237,10 +238,7 @@ end = struct
     let rec make_list = function
       | [] -> []
       | Eliom_lib.Left (channel, _) :: q ->
-          Eio.Condition.await
-            (* TODO: ciao-lwt: A mutex must be passed *) channel.ch_wakeup
-            __mutex__
-          :: make_list q
+          Eio.Condition.await_no_mutex channel.ch_wakeup :: make_list q
       | Eliom_lib.Right _ :: _ -> assert false
       (* closed channels are considered to have data *)
     in
diff --git a/src/lib/eliom_common.server.mli b/src/lib/eliom_common.server.mli
index 2d6976da8b..ed8606e337 100644
--- a/src/lib/eliom_common.server.mli
+++ b/src/lib/eliom_common.server.mli
@@ -1,5 +1,3 @@
-open Eio.Std
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Module eliom_common.mli

From 48da6e3b068796919f6bca0bd4e11cb7e98103f4 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Sat, 20 Sep 2025 21:14:57 +0200
Subject: [PATCH 15/21] Switch to Eio: manual changes

---
 dune-project                         |   2 +-
 eliom.opam                           |   2 +-
 src/lib/eliom_bus.client.ml          |  75 ++++----
 src/lib/eliom_client.client.ml       | 164 +++++++++---------
 src/lib/eliom_client.client.mli      |   2 +-
 src/lib/eliom_client_core.client.ml  |   8 +-
 src/lib/eliom_comet.client.ml        |  45 +++--
 src/lib/eliom_comet.server.ml        |  55 +++---
 src/lib/eliom_common.server.ml       |   5 +-
 src/lib/eliom_common.server.mli      |   2 +-
 src/lib/eliom_cscache.eliom          |  39 +++--
 src/lib/eliom_cscache.eliomi         |   4 +-
 src/lib/eliom_form.eliom             |   1 -
 src/lib/eliom_react.client.ml        |   2 -
 src/lib/eliom_react.server.ml        |   8 +-
 src/lib/eliom_shared.client.mli      |   2 +-
 src/lib/eliom_shared.eliom           | 248 ++++++++++++++-------------
 src/lib/eliom_shared.server.mli      |   2 +-
 src/lib/eliom_shared_sigs.shared.mli |  18 +-
 19 files changed, 340 insertions(+), 344 deletions(-)

diff --git a/dune-project b/dune-project
index f09acf3010..63f9d0c5b8 100644
--- a/dune-project
+++ b/dune-project
@@ -1,7 +1,7 @@
 (lang dune 3.19)
 
 (name eliom)
-(version 11.1.1)
+(version 12.0.0~dev)
 (maintainers dev@ocsigen.org)
 (authors dev@ocsigen.org)
 (license "LGPL-2.1-only WITH OCaml-LGPL-linking-exception")
diff --git a/eliom.opam b/eliom.opam
index 4a09b952a0..8b646b8e04 100644
--- a/eliom.opam
+++ b/eliom.opam
@@ -1,6 +1,6 @@
 # This file is generated by dune, edit dune-project instead
 opam-version: "2.0"
-version: "11.1.1"
+version: "12.0.0~dev"
 synopsis: "Advanced client/server Web and mobile framework"
 description: """
 Eliom is a framework for implementing Web sites and client/server Web and mobile applications.
diff --git a/src/lib/eliom_bus.client.ml b/src/lib/eliom_bus.client.ml
index 65d56d3073..9403aa98ad 100644
--- a/src/lib/eliom_bus.client.ml
+++ b/src/lib/eliom_bus.client.ml
@@ -34,37 +34,37 @@ type ('a, 'b) t =
   ; mutable max_size : int
   ; write : 'a list -> unit
   ; mutable waiter : unit -> unit
-  ; mutable last_wait : unit Promise.t
+  ; mutable last_wait : Switch.t option
   ; mutable original_stream_available : bool
-  ; error_h : 'b option Promise.t * exn Lwt.u }
+  ; error_h : 'b option Promise.or_exn * (exn, exn) result Promise.u }
 
 (* clone streams such that each clone of the original stream raise the same exceptions *)
 let consume (t, u) s =
-  let t' =
-    try Eliom_stream.iter (fun _ -> ()) s
+  let p, w = Promise.create () in
+  Eliom_lib.fork (fun () ->
+    try Promise.resolve_ok w (Eliom_stream.iter (fun _ -> ()) s)
     with e ->
-      (match Promise.peek t with None -> Lwt.wakeup_exn u e | _ -> ());
-      raise e
-  in
-  Fiber.any
-    (List.map
-       (fun p () -> Promise.await p)
-       (* TODO: ciao-lwt: The list [[ Lwt.bind t (fun _ -> Lwt.return_unit); t' ]] is expected to be a list of promises. Use [Fiber.fork_promise] to make a promise. *)
-       [ (let _ = t in
-          ())
-       ; t' ])
+      (match Promise.peek t with None -> Promise.resolve_error u e | _ -> ());
+      Promise.resolve_error w e);
+  Eliom_lib.fork (fun () ->
+    try Promise.resolve_ok w (ignore (Promise.await_exn t))
+    with e -> Promise.resolve_error w e);
+  Promise.await_exn p
 
 let clone_exn (t, u) s =
   let s' = Eliom_stream.clone s in
   Eliom_stream.from (fun () ->
     try
-      Fiber.any
-        (List.map
-           (fun p () -> Promise.await p)
-           (* TODO: ciao-lwt: The list [[ Eliom_stream.get s'; t ]] is expected to be a list of promises. Use [Fiber.fork_promise] to make a promise. *)
-           [Eliom_stream.get s'; t])
+      let p, w = Promise.create () in
+      Eliom_lib.fork (fun () ->
+        try Promise.resolve_ok w (Eliom_stream.get s')
+        with e -> Promise.resolve_error w e);
+      Eliom_lib.fork (fun () ->
+        try Promise.resolve_ok w (Promise.await_exn t)
+        with e -> Promise.resolve_error w e);
+      Promise.await_exn p
     with e ->
-      (match Promise.peek t with None -> Lwt.wakeup_exn u e | _ -> ());
+      (match Promise.peek t with None -> Promise.resolve_error u e | _ -> ());
       raise e)
 
 type ('a, 'att, 'co, 'ext, 'reg) callable_bus_service =
@@ -93,15 +93,16 @@ let create service channel waiter =
     with Eliom_request.Failed_request 204 -> ()
   in
   let error_h =
-    let t, u =
+    let t, (u : (exn, exn) result Promise.u) =
       Promise.create
         (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
+    let tt, uu = Promise.create () in
     ( (try
-         let _ = t in
+         ignore (Promise.await t);
          assert false
-       with e -> raise e)
+       with e -> Promise.resolve_error uu e; tt)
     , u )
   in
   let stream =
@@ -118,7 +119,7 @@ let create service channel waiter =
     ; max_size = 20
     ; write
     ; waiter
-    ; last_wait = ()
+    ; last_wait = None
     ; original_stream_available = true
     ; error_h }
   in
@@ -152,23 +153,19 @@ let flush t =
   let l = List.rev (Queue.fold (fun l v -> v :: l) [] t.queue) in
   Queue.clear t.queue; t.write l
 
+exception Cancelled
+
 let try_flush t =
-  Lwt.cancel
-    (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-    (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-    t.last_wait;
+  Option.iter (fun o -> Switch.fail o Cancelled) t.last_wait;
   if Queue.length t.queue >= t.max_size
   then flush t
   else
-    let th =
-      Lwt.protected
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        (t.waiter ())
-    in
-    t.last_wait <- th;
-    let _ = th; flush t in
-    ()
+    Eliom_lib.fork (fun () ->
+      Switch.run_protected (fun sw ->
+        (*VVV ???*)
+        t.last_wait <- Some sw;
+        t.waiter ());
+      flush t)
 
 let write t v = Queue.add v t.queue; try_flush t
 let close {channel; _} = Eliom_comet.close channel
@@ -176,8 +173,6 @@ let set_queue_size b s = b.max_size <- s
 
 let set_time_before_flush b t =
   b.waiter <-
-    (if t <= 0.
-     then fun x1 -> Fiber.yield x1
-     else fun () -> Js_of_ocaml_eio.Eio_js.sleep t)
+    (if t <= 0. then Fiber.yield else fun () -> Js_of_ocaml_eio.Eio_js.sleep t)
 
 let force_link = ()
diff --git a/src/lib/eliom_client.client.ml b/src/lib/eliom_client.client.ml
index 4635bc4d0b..629a533a6b 100644
--- a/src/lib/eliom_client.client.ml
+++ b/src/lib/eliom_client.client.ml
@@ -76,13 +76,13 @@ let run_onunload_wrapper set_content cancel =
       run_callbacks (flush_onunload ());
       set_content ()
 
-let lwt_onload () =
+let onload_promise () =
   let t, u =
     Promise.create
       (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
       ()
   in
-  onload (fun x1 -> Promise.resolve u x1);
+  onload (fun () -> Promise.resolve u ());
   t
 
 (* == Initialize the client values sent with a request *)
@@ -432,11 +432,11 @@ let scroll_to_fragment ?offset fragment =
         let elem = Dom_html.document##(getElementById (Js.string fragment)) in
         Js.Opt.iter elem scroll_to_element)
 
-let with_progress_cursor : 'a Promise.t -> 'a =
- fun t ->
+let with_progress_cursor : (unit -> 'a) -> 'a =
+ fun f ->
   try
     Dom_html.document##.body##.style##.cursor := Js.string "progress";
-    let res = t in
+    let res = f () in
     Dom_html.document##.body##.style##.cursor := Js.string "auto";
     res
   with exn ->
@@ -698,7 +698,7 @@ let set_active_page p =
 
 (* This key serves as a hook to access the page the currently running code is
    generating. *)
-let this_page : page Lwt.key = Fiber.create_key ()
+let this_page : page Fiber.key = Fiber.create_key ()
 
 let get_this_page () =
   match Fiber.get this_page with
@@ -1442,23 +1442,24 @@ module Page_status = struct
     stop_event ?stop @@ React.E.map action @@ maybe_just_once ~once
     @@ Events.inactive ()
 
+  exception Cancelled
+
   let while_active ?now ?(stop = React.E.never) action =
-    let thread = ref () in
-    onactive ?now ~stop (fun () -> thread := action ());
-    oninactive ~stop (fun () ->
-      Lwt.cancel
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        !thread);
-    Dom_reference.retain_generic (get_this_page ())
-      ~keep:
-        (React.E.map
-           (fun () ->
-              Lwt.cancel
-                (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-                (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-                !thread)
-           stop)
+    let active_switch = ref None in
+    onactive ?now ~stop (fun () ->
+      Eio.Switch.run (fun sw ->
+        active_switch := Some sw;
+        Eio.Fiber.fork ~sw action);
+      oninactive ~stop (fun () ->
+        Option.iter (fun sw -> Eio.Switch.fail sw Cancelled) !active_switch);
+      Dom_reference.retain_generic (get_this_page ())
+        ~keep:
+          (React.E.map
+             (fun () ->
+                Option.iter
+                  (fun sw -> Eio.Switch.fail sw Cancelled)
+                  !active_switch)
+             stop))
 end
 
 let is_in_cache state_id =
@@ -1905,8 +1906,8 @@ and change_page :
       ~service ?hostname ?port ?fragment ?keep_nl_params ~nl_params
       ?keep_get_na_params get_params post_params
   else
-    with_progress_cursor
-      (match xhr with
+    with_progress_cursor (fun () ->
+      match xhr with
       | Some (Some tmpl as t)
         when t = Eliom_request_info.get_request_template () ->
           Logs.debug ~src:section_page (fun fmt ->
@@ -2042,29 +2043,28 @@ and reload_without_na_params ~replace ~uri ~fallback =
 (* Function used in "onclick" event handler of <a>.  *)
 let change_page_uri_a ?cookies_info ?tmpl ?(get_params = []) full_uri =
   Logs.debug ~src:section_page (fun fmt -> fmt "Change page uri");
-  with_progress_cursor
-    (let uri, fragment = Url.split_fragment full_uri in
-     if uri <> get_current_uri () || fragment = None
-     then (
-       if is_client_app ()
-       then failwith "Change_page_uri_a called on client app";
-       match tmpl with
-       | Some t when tmpl = Eliom_request_info.get_request_template () ->
-           let uri, content =
-             Eliom_request.http_get ?cookies_info uri
-               ((Eliom_request.nl_template_string, t) :: get_params)
-               Eliom_request.string_result
-           in
-           set_template_content ~replace:false ~uri ?fragment content
-       | _ ->
-           let uri, content =
-             Eliom_request.http_get ~expecting_process_page:true ?cookies_info
-               uri get_params Eliom_request.xml_result
-           in
-           set_content ~replace:false ~uri ?fragment content)
-     else (
-       change_url_string ~replace:true full_uri;
-       scroll_to_fragment fragment))
+  with_progress_cursor (fun () ->
+    let uri, fragment = Url.split_fragment full_uri in
+    if uri <> get_current_uri () || fragment = None
+    then (
+      if is_client_app () then failwith "Change_page_uri_a called on client app";
+      match tmpl with
+      | Some t when tmpl = Eliom_request_info.get_request_template () ->
+          let uri, content =
+            Eliom_request.http_get ?cookies_info uri
+              ((Eliom_request.nl_template_string, t) :: get_params)
+              Eliom_request.string_result
+          in
+          set_template_content ~replace:false ~uri ?fragment content
+      | _ ->
+          let uri, content =
+            Eliom_request.http_get ~expecting_process_page:true ?cookies_info
+              uri get_params Eliom_request.xml_result
+          in
+          set_content ~replace:false ~uri ?fragment content)
+    else (
+      change_url_string ~replace:true full_uri;
+      scroll_to_fragment fragment))
 
 let change_page_uri ?replace full_uri =
   Logs.debug ~src:section_page (fun fmt -> fmt "Change page uri");
@@ -2088,42 +2088,42 @@ let change_page_uri ?replace full_uri =
 (* Functions used in "onsubmit" event handler of <form>.  *)
 
 let change_page_get_form ?cookies_info ?tmpl form full_uri =
-  with_progress_cursor
-    (let form = Js.Unsafe.coerce form in
-     let uri, fragment = Url.split_fragment full_uri in
-     match tmpl with
-     | Some t when tmpl = Eliom_request_info.get_request_template () ->
-         let uri, content =
-           Eliom_request.send_get_form
-             ~get_args:[Eliom_request.nl_template_string, t]
-             ?cookies_info form uri Eliom_request.string_result
-         in
-         set_template_content ~replace:false ~uri ?fragment content
-     | _ ->
-         let uri, content =
-           Eliom_request.send_get_form ~expecting_process_page:true
-             ?cookies_info form uri Eliom_request.xml_result
-         in
-         set_content ~replace:false ~uri ?fragment content)
+  with_progress_cursor (fun () ->
+    let form = Js.Unsafe.coerce form in
+    let uri, fragment = Url.split_fragment full_uri in
+    match tmpl with
+    | Some t when tmpl = Eliom_request_info.get_request_template () ->
+        let uri, content =
+          Eliom_request.send_get_form
+            ~get_args:[Eliom_request.nl_template_string, t]
+            ?cookies_info form uri Eliom_request.string_result
+        in
+        set_template_content ~replace:false ~uri ?fragment content
+    | _ ->
+        let uri, content =
+          Eliom_request.send_get_form ~expecting_process_page:true ?cookies_info
+            form uri Eliom_request.xml_result
+        in
+        set_content ~replace:false ~uri ?fragment content)
 
 let change_page_post_form ?cookies_info ?tmpl form full_uri =
-  with_progress_cursor
-    (let form = Js.Unsafe.coerce form in
-     let uri, fragment = Url.split_fragment full_uri in
-     match tmpl with
-     | Some t when tmpl = Eliom_request_info.get_request_template () ->
-         let uri, content =
-           Eliom_request.send_post_form
-             ~get_args:[Eliom_request.nl_template_string, t]
-             ?cookies_info form uri Eliom_request.string_result
-         in
-         set_template_content ~replace:false ~uri ?fragment content
-     | _ ->
-         let uri, content =
-           Eliom_request.send_post_form ~expecting_process_page:true
-             ?cookies_info form uri Eliom_request.xml_result
-         in
-         set_content ~replace:false ~uri ?fragment content)
+  with_progress_cursor (fun () ->
+    let form = Js.Unsafe.coerce form in
+    let uri, fragment = Url.split_fragment full_uri in
+    match tmpl with
+    | Some t when tmpl = Eliom_request_info.get_request_template () ->
+        let uri, content =
+          Eliom_request.send_post_form
+            ~get_args:[Eliom_request.nl_template_string, t]
+            ?cookies_info form uri Eliom_request.string_result
+        in
+        set_template_content ~replace:false ~uri ?fragment content
+    | _ ->
+        let uri, content =
+          Eliom_request.send_post_form ~expecting_process_page:true
+            ?cookies_info form uri Eliom_request.xml_result
+        in
+        set_content ~replace:false ~uri ?fragment content)
 
 let _ =
   (Eliom_client_core.change_page_uri_ :=
@@ -2189,7 +2189,7 @@ let () =
       Js_of_ocaml_eio.Eio_js.start (fun () ->
         with_progress_cursor
         (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
-        @@
+        @@ fun () ->
         let uri, fragment = Url.split_fragment full_uri in
         if uri = get_current_uri ()
         then (
diff --git a/src/lib/eliom_client.client.mli b/src/lib/eliom_client.client.mli
index 2ee16b3a14..a4ec542187 100644
--- a/src/lib/eliom_client.client.mli
+++ b/src/lib/eliom_client.client.mli
@@ -272,7 +272,7 @@ val onload : (unit -> unit) -> unit
 
 *)
 
-val lwt_onload : unit -> unit
+val onload_promise : unit -> unit Eio.Promise.t
 (** Returns a Lwt thread that waits until the next page is loaded. *)
 
 type changepage_event =
diff --git a/src/lib/eliom_client_core.client.ml b/src/lib/eliom_client_core.client.ml
index 1cb9ff12d7..017df13c51 100644
--- a/src/lib/eliom_client_core.client.ml
+++ b/src/lib/eliom_client_core.client.ml
@@ -273,14 +273,10 @@ let in_onload, broadcast_load_end, wait_load_end, set_loading_phase =
   let in_onload () = !loading_phase in
   let broadcast_load_end () =
     loading_phase := false;
-    Lwt_condition.broadcast load_end ()
+    Eio.Condition.broadcast load_end
   in
   let wait_load_end () =
-    if !loading_phase
-    then
-      Eio.Condition.await (* TODO: ciao-lwt: A mutex must be passed *) load_end
-        __mutex__
-    else ()
+    if !loading_phase then Eio.Condition.await_no_mutex load_end else ()
   in
   in_onload, broadcast_load_end, wait_load_end, set
 
diff --git a/src/lib/eliom_comet.client.ml b/src/lib/eliom_comet.client.ml
index 3f3546dc75..3b264f2629 100644
--- a/src/lib/eliom_comet.client.ml
+++ b/src/lib/eliom_comet.client.ml
@@ -243,11 +243,11 @@ end = struct
     ; mutable focused : float option
       (** [focused] is None when the page is visible and Some [t]
             when the page became hidden at time [t] (in ms) *)
-    ; mutable active_waiter : unit Promise.t
+    ; mutable active_waiter : unit Promise.or_exn
       (** [active_waiter] terminates when the page get visible *)
-    ; mutable active_wakener : unit Lwt.u
-    ; mutable restart_waiter : Ecb.answer Promise.t
-    ; mutable restart_wakener : Ecb.answer Lwt.u
+    ; mutable active_wakener : (unit, exn) result Eio.Promise.u
+    ; mutable restart_waiter : Ecb.answer Promise.or_exn
+    ; mutable restart_wakener : (Ecb.answer, exn) result Eio.Promise.u
     ; mutable active_channels : Eliom_lib.String.Set.t }
 
   type stateful_state = int ref (* id of the next request *)
@@ -296,7 +296,7 @@ end = struct
           hd.hd_activity.active_waiter <- t;
           let wakener = hd.hd_activity.active_wakener in
           hd.hd_activity.active_wakener <- u;
-          Promise.resolve wakener ()
+          Promise.resolve_ok wakener ()
 
   let is_active hd = hd.hd_activity.active
 
@@ -370,7 +370,7 @@ end = struct
     act.restart_waiter <- t;
     let wakener = act.restart_wakener in
     act.restart_wakener <- u;
-    Lwt.wakeup_exn wakener Restart;
+    Eio.Promise.resolve_error wakener Restart;
     activate hd
 
   let max_retries = 10
@@ -482,7 +482,7 @@ end = struct
       Configuration.sleep_before_next_request
         (fun () -> hd_activity.focused)
         (fun () -> hd_activity.active = `Idle)
-        (fun () -> hd_activity.active_waiter)
+        (fun () -> Eio.Promise.await_exn hd_activity.active_waiter)
     in
     let request = make_request hd in
     let s =
@@ -517,17 +517,18 @@ end = struct
     let rec aux retries =
       if hd.hd_activity.active = `Inactive
       then
-        let () = hd.hd_activity.active_waiter in
+        let () = Eio.Promise.await_exn hd.hd_activity.active_waiter in
         aux 0
       else
         match
           Fiber.any
             [ (fun () -> call_service hd)
             ; (fun () ->
-                hd
-                (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
-                  .hd_activity
-                  .restart_waiter) ]
+                Eio.Promise.await_exn
+                  hd
+                  (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
+                    .hd_activity
+                    .restart_waiter) ]
         with
         | s -> (
           match s with
@@ -779,21 +780,15 @@ let register' hd position (_ : Ecb.comet_service) (chan_id : 'a Ecb.chan_id) =
         | _ -> None)
       (Eliom_stream.clone hd.hd_stream)
   in
-  let protect_and_close t =
-    let t' =
-      Lwt.protected
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        t
-    in
-    Lwt.on_cancel
-      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-      t' (fun () -> Service_handler.close hd.hd_service_handler chan_id);
-    t'
+  let protect_and_close f =
+    try Switch.run f
+    with Eio.Cancel.Cancelled _ as e ->
+      Service_handler.close hd.hd_service_handler chan_id;
+      raise e
   in
   (* protect the stream from cancels *)
-  Eliom_stream.from (fun () -> protect_and_close (Eliom_stream.get stream))
+  Eliom_stream.from (fun () ->
+    protect_and_close (fun _sw -> Eliom_stream.get stream))
 
 let register_stateful ?(wake = true) service chan_id =
   let hd = get_stateful_hd service in
diff --git a/src/lib/eliom_comet.server.ml b/src/lib/eliom_comet.server.ml
index 73d0559538..4a6b46bcbc 100644
--- a/src/lib/eliom_comet.server.ml
+++ b/src/lib/eliom_comet.server.ml
@@ -128,7 +128,7 @@ end = struct
       let dummy = {dummy_channel with ch_id} in
       try Some (Weak_channel_table.find channels dummy) with Not_found -> None
 
-  let wakeup_waiters channel = Lwt_condition.broadcast channel.ch_wakeup ()
+  let wakeup_waiters channel = Eio.Condition.broadcast channel.ch_wakeup
 
   (* fill the channel with messages from the stream *)
   let run_channel channel stream =
@@ -238,21 +238,20 @@ end = struct
     let rec make_list = function
       | [] -> []
       | Eliom_lib.Left (channel, _) :: q ->
-          Eio.Condition.await_no_mutex channel.ch_wakeup :: make_list q
+          (fun () -> Eio.Condition.await_no_mutex channel.ch_wakeup)
+          :: make_list q
       | Eliom_lib.Right _ :: _ -> assert false
       (* closed channels are considered to have data *)
     in
-    Fiber.any
-      ((* TODO: ciao-lwt: This expression is a ['a Lwt.t list] but a [(unit -> 'a) list] is expected. *)
-       make_list requests)
+    Fiber.any (make_list requests)
 
   let wait_data requests =
     if List.exists has_data requests
     then ()
     else
       Eio.Time.with_timeout_exn
-        (Stdlib.Option.get (Fiber.get Ocsigen_lib.env))#mono_clock (timeout ())
-        (fun () -> really_wait_data requests)
+        (Stdlib.Option.get (Fiber.get Ocsigen_lib.env))#clock (timeout ())
+        (*VVV How to use mono_clock? *) (fun () -> really_wait_data requests)
 
   let handle_request () (_, req) =
     match req with
@@ -326,7 +325,7 @@ end = struct
   type chan_id = string
   type comet_service = Eliom_comet_base.comet_service
   type internal_comet_service = Eliom_comet_base.internal_comet_service
-  type end_request_waiters = unit Lwt.u
+  type end_request_waiters = unit Eio.Promise.u
 
   type activity =
     | Active of end_request_waiters list
@@ -355,7 +354,8 @@ end = struct
       (** streams that are created on the server side, but client did not register *)
     ; mutable hd_registered_chan_id : chan_id list
       (** the fusion of all the streams from hd_active_channels *)
-    ; mutable hd_update_streams_w : [`Data | `Update] Lwt.u option
+    ; mutable hd_update_streams_w :
+        ([`Data | `Update], exn) result Eio.Promise.u option
       (** used to signal new data or new active streams. *)
     ; hd_service : internal_comet_service
     ; mutable hd_last : string * int
@@ -394,7 +394,7 @@ end = struct
               ()
           in
           let t =
-            let () = waiter in
+            let () = Eio.Promise.await waiter in
             let () = Eio_unix.sleep t in
             run ()
           in
@@ -421,7 +421,7 @@ end = struct
     | None -> ()
     | Some wakener ->
         handler.hd_update_streams_w <- None;
-        Lwt.wakeup_exn wakener New_connection
+        Eio.Promise.resolve_error wakener New_connection
 
   (** called when a new channel is made active. It restarts the thread
       wainting for inputs ( wait_data ) such that it can receive the messages from
@@ -431,15 +431,13 @@ end = struct
     | None -> ()
     | Some wakener ->
         handler.hd_update_streams_w <- None;
-        Promise.resolve wakener event
+        Promise.resolve_ok wakener event
 
   let stream_waiter s =
     Fiber.without_binding Eliom_common.sp_key (fun () ->
-      Lwt.no_cancel
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        (let _ = Eliom_stream.peek s in
-         `Data))
+      Eio.Switch.run (fun _sw ->
+        let _ = Eliom_stream.peek s in
+        Eio.Promise.create_resolved `Data))
 
   (** read up to [n] messages in the list of streams [streams] without blocking. *)
   let read_channels n handler =
@@ -483,11 +481,20 @@ end = struct
           ()
       in
       handler.hd_update_streams_w <- Some hd_update_streams_w;
-      Fiber.any
-        (List.map
-           (fun p () -> Promise.await p)
-           (* TODO: ciao-lwt: The list [wait_closed_connection :: hd_update_streams :: wait_channels handler] is expected to be a list of promises. Use [Fiber.fork_promise] to make a promise. *)
-           (wait_closed_connection :: hd_update_streams :: wait_channels handler))
+      let p, w = Eio.Promise.create () in
+      Eliom_lib.fork (fun () ->
+        ignore
+        @@ Eio.Fiber.List.map
+             (fun f ->
+                match f () with
+                | v -> Eio.Promise.resolve_ok w v
+                | exception e -> Eio.Promise.resolve_error w e)
+             (wait_closed_connection
+             :: (fun () -> Eio.Promise.await_exn hd_update_streams)
+             :: List.map
+                  (fun p () -> Eio.Promise.await p)
+                  (wait_channels handler)));
+      Eio.Promise.await_exn p
     with
     | `Data -> handler.hd_update_streams_w <- None
     | `Update -> wait_data wait_closed_connection handler
@@ -542,8 +549,8 @@ end = struct
           else
             try
               Eio.Time.with_timeout_exn
-                (Stdlib.Option.get (Fiber.get Ocsigen_lib.env))#mono_clock
-                (timeout ()) (fun () ->
+                (Stdlib.Option.get (Fiber.get Ocsigen_lib.env))#clock
+                (*VVV How to use mono_clock? *) (timeout ()) (fun () ->
                 let messages =
                   let messages = read_channels 100 handler in
                   if messages <> [] || idle
diff --git a/src/lib/eliom_common.server.ml b/src/lib/eliom_common.server.ml
index 4b79f16a7c..8ce4833b44 100644
--- a/src/lib/eliom_common.server.ml
+++ b/src/lib/eliom_common.server.ml
@@ -299,8 +299,7 @@ let network_of_ip k mask4 mask6 =
 
 let network_of_request r ~mask4 ~mask6 =
   match Ocsigen_request.client_conn r with
-  | `Inet (ip, _) ->
-      network_of_ip (Ipaddr.of_string_exn (ip :> string)) mask4 mask6
+  | `Inet (ip, _) -> network_of_ip ip mask4 mask6
   | _ -> Ipaddr.(V6 V6.localhost)
 
 module Net_addr_Hashtbl : sig
@@ -831,7 +830,7 @@ let empty_tables max forsession =
                      Ocsigen_request.client_conn
                        sp.sp_request.Ocsigen_extensions.request_info
                    with
-                   | `Inet (ip, _) -> Ipaddr.of_string_exn (ip :> string)
+                   | `Inet (ip, _) -> ip
                    | _ -> default_ip_table_key
                  in
                  ( ip
diff --git a/src/lib/eliom_common.server.mli b/src/lib/eliom_common.server.mli
index ed8606e337..cb41cf16b3 100644
--- a/src/lib/eliom_common.server.mli
+++ b/src/lib/eliom_common.server.mli
@@ -693,7 +693,7 @@ val tab_cookie_action_info_key :
   * string Ocsigen_cookie_map.Map_inner.t)
     Polytables.key
 
-val sp_key : server_params Lwt.key
+val sp_key : server_params Eio.Fiber.key
 val get_sp_option : unit -> server_params option
 val get_sp : unit -> server_params
 val sp_of_option : server_params option -> server_params
diff --git a/src/lib/eliom_cscache.eliom b/src/lib/eliom_cscache.eliom
index 2ddcef7a0d..c916f2a47d 100644
--- a/src/lib/eliom_cscache.eliom
+++ b/src/lib/eliom_cscache.eliom
@@ -5,7 +5,7 @@ open%server Eio.Std
 [%%shared.start]
 
 type ('a, 'b) t =
-  (unit -> ('a, 'b Promise.or_exn) Hashtbl.t) Eliom_shared.Value.t
+  (unit -> ('a, 'b Eio.Promise.or_exn) Hashtbl.t) Eliom_shared.Value.t
 
 let%client create_ () =
   let c = Hashtbl.create 100 in
@@ -25,9 +25,12 @@ let do_cache_raw cache id data =
   let c = Eliom_shared.Value.local cache () in
   Hashtbl.replace c id data;
   (* Do not cache exceptions *)
-  ignore (try data with e -> Hashtbl.remove c id; raise e)
+  Eliom_lib.fork (fun () ->
+    try ignore (Eio.Promise.await_exn data)
+    with e -> Hashtbl.remove c id; raise e)
 
-let do_cache cache id data = do_cache_raw cache id data
+let do_cache cache id data =
+  do_cache_raw cache id (Eio.Promise.create_resolved (Ok data))
 
 let%server do_cache cache id v =
   do_cache cache id v;
@@ -36,36 +39,36 @@ let%server do_cache cache id v =
 let%server find cache get_data id =
   try Promise.await_exn (Hashtbl.find ((Eliom_shared.Value.local cache) ()) id)
   with Not_found ->
-    let th =
-      Fiber.fork_promise
-        ~sw:(Stdlib.Option.get (Fiber.get Ocsigen_lib.current_switch))
-        (fun () ->
-           let v = get_data id in
-           ignore [%client.unsafe (do_cache ~%cache ~%id ~%v : unit)];
-           v)
+    let p =
+      Eliom_lib.fork_promise (fun () ->
+        let v = get_data id in
+        ignore [%client.unsafe (do_cache ~%cache ~%id ~%v : unit)];
+        v)
     in
     (* On server side, we put immediately in table the thread that is fetching
        the data. in order to avoid fetching it several times. *)
-    do_cache_raw cache id th; Promise.await_exn th
+    do_cache_raw cache id p; Promise.await_exn p
 
 let%client load cache get_data id =
-  let th = get_data id in
+  let p = Eliom_lib.fork_promise (fun () -> get_data id) in
   (* On client side, we put immediately in table the thread that is
      fetching the data.  Thus, [get_data_from_cache] returns
      immediately (in order to display a spinner). *)
-  do_cache_raw cache id th; Promise.await_exn th
+  do_cache_raw cache id p; Eio.Promise.await_exn p
 
 let%client find cache get_data id =
-  try Hashtbl.find ((Eliom_shared.Value.local cache) ()) id
-  with Not_found -> load cache get_data id
+  match Hashtbl.find ((Eliom_shared.Value.local cache) ()) id with
+  | p -> Eio.Promise.await_exn p
+  | exception Not_found -> load cache get_data id
 
 exception Not_ready
 
-let local_find cache id = Hashtbl.find ((Eliom_shared.Value.local cache) ()) id
+let local_find cache id =
+  Eio.Promise.await_exn (Hashtbl.find ((Eliom_shared.Value.local cache) ()) id)
 
 let find_if_ready cache id =
-  let v = local_find cache id in
-  match Promise.peek v with
+  let p = Hashtbl.find ((Eliom_shared.Value.local cache) ()) id in
+  match Eio.Promise.peek p with
   | Some (Ok v) -> v
   | Some (Error e) -> raise e
   | _ -> raise Not_ready
diff --git a/src/lib/eliom_cscache.eliomi b/src/lib/eliom_cscache.eliomi
index 06a7be3008..5d0db53b68 100644
--- a/src/lib/eliom_cscache.eliomi
+++ b/src/lib/eliom_cscache.eliomi
@@ -40,14 +40,14 @@ val find : ('a, 'b) t -> ('a -> 'b) -> 'a -> 'b
     result in a single call to [get_from_db]. Exceptions are not
     cached.  *)
 
-val do_cache : ('a, 'b) t -> 'a -> 'b Eio.Promise.or_exn -> unit
+val do_cache : ('a, 'b) t -> 'a -> 'b -> unit
 (** [do_cache cache key value] adds the association from [key] to
     [value] in [cache], or replaces it if not already present.  Called
     from client side, it affects only client side cache.  Called from
     server side, it will have effect both on the server cache (scope:
     request) and the client side cache.  *)
 
-val local_find : ('a, 'b) t -> 'a -> 'b Eio.Promise.or_exn
+val local_find : ('a, 'b) t -> 'a -> 'b
 (** Find a piece of data in local cache, without trying to fetch it
     from server. Raises [Not_found] instead.  If the value is currently
     being retrieved, it waits for it to be ready before returning.  *)
diff --git a/src/lib/eliom_form.eliom b/src/lib/eliom_form.eliom
index 6438dc2d09..0deba8d853 100644
--- a/src/lib/eliom_form.eliom
+++ b/src/lib/eliom_form.eliom
@@ -146,7 +146,6 @@ module Make_links (Html : Html) = struct
         let f =
           [%client.unsafe
             fun ev ->
-              let open Eio.Std in
               if not (Eliom_client.middleClick ev)
               then (
                 Dom.preventDefault ev;
diff --git a/src/lib/eliom_react.client.ml b/src/lib/eliom_react.client.ml
index c03e7390b1..a7903711df 100644
--- a/src/lib/eliom_react.client.ml
+++ b/src/lib/eliom_react.client.ml
@@ -1,5 +1,3 @@
-open Eio.Std
-
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2010-2011
diff --git a/src/lib/eliom_react.server.ml b/src/lib/eliom_react.server.ml
index aaad25674d..cbf04a0cc8 100644
--- a/src/lib/eliom_react.server.ml
+++ b/src/lib/eliom_react.server.ml
@@ -169,7 +169,7 @@ module S = struct
              (fun v ->
                 store.read <- false;
                 store.value <- v;
-                Lwt_condition.broadcast store.condition ();
+                Eio.Condition.broadcast store.condition;
                 ())
              signal)
       in
@@ -180,11 +180,7 @@ module S = struct
       let rec aux () =
         if store.read
         then
-          let () =
-            Eio.Condition.await
-              (* TODO: ciao-lwt: A mutex must be passed *) store.condition
-              __mutex__
-          in
+          let () = Eio.Condition.await_no_mutex store.condition in
           aux ()
         else (
           store.read <- true;
diff --git a/src/lib/eliom_shared.client.mli b/src/lib/eliom_shared.client.mli
index 71dd50a3a7..6917393638 100644
--- a/src/lib/eliom_shared.client.mli
+++ b/src/lib/eliom_shared.client.mli
@@ -32,7 +32,7 @@ open Eio.Std
 val to_signal :
    init:'a
   -> ?eq:('a -> 'a -> bool)
-  -> 'a React.S.t Promise.t
+  -> 'a React.S.t Promise.or_exn
   -> 'a React.S.t
 (** [to_signal ~init s] converts the Lwt-wrapped signal [s] into a
     regular signal with initial value [init]. *)
diff --git a/src/lib/eliom_shared.eliom b/src/lib/eliom_shared.eliom
index a7e194411d..3aee69185e 100644
--- a/src/lib/eliom_shared.eliom
+++ b/src/lib/eliom_shared.eliom
@@ -1,4 +1,4 @@
-open Eio.Std
+open%client Eio.Std
 
 (* Ocsigen
  * http://www.ocsigen.org
@@ -20,27 +20,26 @@ open Eio.Std
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *)
 
-[%%shared
-(* put this in Eio_react? Find a better name? *)
-let to_signal ~init ?eq (th : 'a React.S.t Promise.t) : 'a React.S.t =
+(* put this in Lwt_react? Find a better name? *)
+let%shared to_signal ~init ?eq (th : 'a React.S.t Eio.Promise.or_exn) :
+  'a React.S.t
+  =
   let s, set = React.S.create ?eq init in
   Eliom_lib.fork (fun () ->
-    let ss = Promise.await th in
+    let ss = Eio.Promise.await_exn th in
     let effectful_signal = React.S.map (fun v -> set v) ss in
     ignore (React.S.retain s (fun () -> ignore effectful_signal)));
-  s]
+  s
 
-[%%client
-module Value = struct
+module%client Value = struct
   type 'a t = 'a
 
   let create _ x = x
   let client x = x
   let local x = x
-end]
+end
 
-[%%server
-module Value = struct
+module%server Value = struct
   type +'a t =
     { sh_server : 'a
     ; sh_client : 'a Eliom_client_value.t
@@ -57,10 +56,9 @@ module Value = struct
 
   let client {sh_client; _} = sh_client
   let local {sh_server; _} = sh_server
-end]
+end
 
-[%%client
-module React = struct
+module%client React = struct
   type step = React.step
 
   module S = struct
@@ -126,12 +124,12 @@ module React = struct
   module E = React.E
 end
 
-module ReactiveData = struct
+module%client ReactiveData = struct
   module RList = struct
     include ReactiveData.RList
 
     module Lwt = struct
-      let map_data_p_lwt = Fiber.List.map
+      let map_data_p_lwt = Eio.Fiber.List.map
 
       let map_patch_p_lwt f = function
         | I (i, x) ->
@@ -143,7 +141,7 @@ module ReactiveData = struct
             let p = f x in
             U (i, p)
 
-      let map_patch_p_lwt f = Fiber.List.map (map_patch_p_lwt f)
+      let map_patch_p_lwt f = Eio.Fiber.List.map (map_patch_p_lwt f)
 
       let map_msg_p_lwt f = function
         | Set l ->
@@ -176,7 +174,7 @@ module ReactiveData = struct
                waiter := new_waiter;
                let new_msg = map_msg_p_lwt f msg in
                let _, rhandle = r_th in
-               let () = fst waiter1 in
+               let () = Eio.Promise.await (fst waiter1) in
                (match new_msg with
                | ReactiveData.RList.Set s -> ReactiveData.RList.set rhandle s
                | ReactiveData.RList.Patch p ->
@@ -207,7 +205,7 @@ module ReactiveData = struct
       let map_p (f : 'a -> 'b) (l : 'a t) : 'b t =
         (* First we build the initial value of the result list *)
         let r_th =
-          let r = Fiber.List.map f (ReactiveData.RList.value l) in
+          let r = Eio.Fiber.List.map f (ReactiveData.RList.value l) in
           ReactiveData.RList.create r
         in
         let effectul_event = map_p_aux r_th f l in
@@ -239,11 +237,10 @@ module ReactiveData = struct
   end
 end
 
-module FakeReact = React
-module FakeReactiveData = ReactiveData]
+module%client FakeReact = React
+module%client FakeReactiveData = ReactiveData
 
-[%%server
-module FakeReact = struct
+module%server FakeReact = struct
   module S : sig
     type 'a t
 
@@ -315,7 +312,7 @@ module FakeReact = struct
   end
 end
 
-module FakeReactiveData = struct
+module%server FakeReactiveData = struct
   module RList : sig
     type 'a t
     type 'a handle
@@ -341,10 +338,9 @@ module FakeReactiveData = struct
     let map f (l, b) = List.map f l, b
     let from_signal ?eq:_ s = FakeReact.S.(value s, synced s)
   end
-end]
+end
 
-[%%server
-module React = struct
+module%server React = struct
   module S = struct
     type 'a t = 'a FakeReact.S.t Value.t
 
@@ -504,55 +500,59 @@ module React = struct
 
     module Lwt = struct
       let map_s ?eq (f : ('a -> 'b) Value.t) (s : 'a FakeReact.S.t Value.t) :
-        'b t
+        'b t Eio.Promise.or_exn
         =
         let s' = Value.local s in
-        let server_result = (Value.local f) (FakeReact.S.value s') in
-        let synced = FakeReact.S.synced s' in
-        Value.create
-          (fst (FakeReact.S.create ~synced server_result))
-          [%client.unsafe
-            (React.S.Lwt.map_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s
-             : 'b FakeReact.S.t)]
+        Eliom_lib.fork_promise (fun () ->
+          let server_result = (Value.local f) (FakeReact.S.value s') in
+          let synced = FakeReact.S.synced s' in
+          Value.create
+            (fst (FakeReact.S.create ~synced server_result))
+            [%client.unsafe
+              (React.S.Lwt.map_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s
+               : 'b FakeReact.S.t)])
 
       let l2_s
             ?eq
             (f : ('a -> 'b -> 'c) Value.t)
             (s1 : 'a FakeReact.S.t Value.t)
-            (s2 : 'b FakeReact.S.t Value.t) : 'c t
+            (s2 : 'b FakeReact.S.t Value.t) : 'c t Eio.Promise.or_exn
         =
         let s1' = Value.local s1 and s2' = Value.local s2 in
-        let server_result =
-          (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
-        in
-        let synced = FakeReact.S.(synced s1' && synced s2') in
-        Value.create
-          (fst (FakeReact.S.create ~synced server_result))
-          [%client.unsafe
-            (React.S.Lwt.l2_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s1 ~%s2
-             : 'c FakeReact.S.t)]
+        Eliom_lib.fork_promise (fun () ->
+          let server_result =
+            (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
+          in
+          let synced = FakeReact.S.(synced s1' && synced s2') in
+          Value.create
+            (fst (FakeReact.S.create ~synced server_result))
+            [%client.unsafe
+              (React.S.Lwt.l2_s_init ~init:~%server_result ?eq:~%eq ~%f ~%s1
+                 ~%s2
+               : 'c FakeReact.S.t)])
 
       let l3_s
             ?eq
             (f : ('a -> 'b -> 'c -> 'd) Value.t)
             (s1 : 'a FakeReact.S.t Value.t)
             (s2 : 'b FakeReact.S.t Value.t)
-            (s3 : 'c FakeReact.S.t Value.t) : 'd t
+            (s3 : 'c FakeReact.S.t Value.t) : 'd t Eio.Promise.or_exn
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
         and s3' = Value.local s3 in
-        let server_result =
-          (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
-            (FakeReact.S.value s3')
-        in
-        let synced = FakeReact.S.(synced s1' && synced s2' && synced s3') in
-        Value.create
-          (fst (FakeReact.S.create ~synced server_result))
-          [%client.unsafe
-            (React.S.Lwt.l3_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1 ~%s2
-               ~%s3
-             : 'd FakeReact.S.t)]
+        Eliom_lib.fork_promise (fun () ->
+          let server_result =
+            (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
+              (FakeReact.S.value s3')
+          in
+          let synced = FakeReact.S.(synced s1' && synced s2' && synced s3') in
+          Value.create
+            (fst (FakeReact.S.create ~synced server_result))
+            [%client.unsafe
+              (React.S.Lwt.l3_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1
+                 ~%s2 ~%s3
+               : 'd FakeReact.S.t)])
 
       let l4_s
             ?eq
@@ -560,25 +560,26 @@ module React = struct
             (s1 : 'a FakeReact.S.t Value.t)
             (s2 : 'b FakeReact.S.t Value.t)
             (s3 : 'c FakeReact.S.t Value.t)
-            (s4 : 'd FakeReact.S.t Value.t) : 'e t
+            (s4 : 'd FakeReact.S.t Value.t) : 'e t Eio.Promise.or_exn
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
         and s3' = Value.local s3
         and s4' = Value.local s4 in
-        let server_result =
-          (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
-            (FakeReact.S.value s3') (FakeReact.S.value s4')
-        in
-        let synced =
-          FakeReact.S.(synced s1' && synced s2' && synced s3' && synced s4')
-        in
-        Value.create
-          (fst (FakeReact.S.create ~synced server_result))
-          [%client.unsafe
-            (React.S.Lwt.l4_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1 ~%s2
-               ~%s3 ~%s4
-             : 'e FakeReact.S.t)]
+        Eliom_lib.fork_promise (fun () ->
+          let server_result =
+            (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
+              (FakeReact.S.value s3') (FakeReact.S.value s4')
+          in
+          let synced =
+            FakeReact.S.(synced s1' && synced s2' && synced s3' && synced s4')
+          in
+          Value.create
+            (fst (FakeReact.S.create ~synced server_result))
+            [%client.unsafe
+              (React.S.Lwt.l4_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1
+                 ~%s2 ~%s3 ~%s4
+               : 'e FakeReact.S.t)])
 
       let l5_s
             ?eq
@@ -587,28 +588,29 @@ module React = struct
             (s2 : 'b FakeReact.S.t Value.t)
             (s3 : 'c FakeReact.S.t Value.t)
             (s4 : 'd FakeReact.S.t Value.t)
-            (s5 : 'e FakeReact.S.t Value.t) : 'f t
+            (s5 : 'e FakeReact.S.t Value.t) : 'f t Eio.Promise.or_exn
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
         and s3' = Value.local s3
         and s4' = Value.local s4
         and s5' = Value.local s5 in
-        let server_result =
-          (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
-            (FakeReact.S.value s3') (FakeReact.S.value s4')
-            (FakeReact.S.value s5')
-        in
-        let synced =
-          FakeReact.S.(
-            synced s1' && synced s2' && synced s3' && synced s4' && synced s5')
-        in
-        Value.create
-          (fst (FakeReact.S.create ~synced server_result))
-          [%client.unsafe
-            (React.S.Lwt.l5_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1 ~%s2
-               ~%s3 ~%s4 ~%s5
-             : 'f FakeReact.S.t)]
+        Eliom_lib.fork_promise (fun () ->
+          let server_result =
+            (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
+              (FakeReact.S.value s3') (FakeReact.S.value s4')
+              (FakeReact.S.value s5')
+          in
+          let synced =
+            FakeReact.S.(
+              synced s1' && synced s2' && synced s3' && synced s4' && synced s5')
+          in
+          Value.create
+            (fst (FakeReact.S.create ~synced server_result))
+            [%client.unsafe
+              (React.S.Lwt.l5_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1
+                 ~%s2 ~%s3 ~%s4 ~%s5
+               : 'f FakeReact.S.t)])
 
       let l6_s
             ?eq
@@ -618,7 +620,7 @@ module React = struct
             (s3 : 'c FakeReact.S.t Value.t)
             (s4 : 'd FakeReact.S.t Value.t)
             (s5 : 'e FakeReact.S.t Value.t)
-            (s6 : 'f FakeReact.S.t Value.t) : 'g t
+            (s6 : 'f FakeReact.S.t Value.t) : 'g t Eio.Promise.or_exn
         =
         let s1' = Value.local s1
         and s2' = Value.local s2
@@ -626,49 +628,51 @@ module React = struct
         and s4' = Value.local s4
         and s5' = Value.local s5
         and s6' = Value.local s6 in
-        let server_result =
-          (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
-            (FakeReact.S.value s3') (FakeReact.S.value s4')
-            (FakeReact.S.value s5') (FakeReact.S.value s6')
-        in
-        let synced =
-          FakeReact.S.(
-            synced s1' && synced s2' && synced s3' && synced s4' && synced s5'
-            && synced s6')
-        in
-        Value.create
-          (fst (FakeReact.S.create ~synced server_result))
-          [%client.unsafe
-            (React.S.Lwt.l6_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1 ~%s2
-               ~%s3 ~%s4 ~%s5 ~%s6
-             : 'g FakeReact.S.t)]
+        Eliom_lib.fork_promise (fun () ->
+          let server_result =
+            (Value.local f) (FakeReact.S.value s1') (FakeReact.S.value s2')
+              (FakeReact.S.value s3') (FakeReact.S.value s4')
+              (FakeReact.S.value s5') (FakeReact.S.value s6')
+          in
+          let synced =
+            FakeReact.S.(
+              synced s1' && synced s2' && synced s3' && synced s4' && synced s5'
+              && synced s6')
+          in
+          Value.create
+            (fst (FakeReact.S.create ~synced server_result))
+            [%client.unsafe
+              (React.S.Lwt.l6_s_init ?eq:~%eq ~init:~%server_result ~%f ~%s1
+                 ~%s2 ~%s3 ~%s4 ~%s5 ~%s6
+               : 'g FakeReact.S.t)])
 
       let merge_s
             ?eq
             (f : ('a -> 'b -> 'a) Value.t)
             (acc : 'a)
-            (l : 'b FakeReact.S.t Value.t list) : 'a t
+            (l : 'b FakeReact.S.t Value.t list) : 'a t Eio.Promise.or_exn
         =
-        let server_result, synced =
-          let f (acc, _acc_b) v =
-            let v = Value.local v and f = Value.local f in
-            let acc = f acc (FakeReact.S.value v) in
-            let acc_b = FakeReact.S.synced v in
-            acc, acc_b
+        Eliom_lib.fork_promise (fun () ->
+          let server_result, synced =
+            let f (acc, _acc_b) v =
+              let v = Value.local v and f = Value.local f in
+              let acc = f acc (FakeReact.S.value v) in
+              let acc_b = FakeReact.S.synced v in
+              acc, acc_b
+            in
+            List.fold_left f (acc, true) l
           in
-          List.fold_left f (acc, true) l
-        in
-        Value.create
-          (fst (FakeReact.S.create ~synced server_result))
-          [%client.unsafe
-            (React.S.Lwt.merge_s_init ~init:~%server_result ?eq:~%eq ~%f ~%acc
-               ~%l
-             : 'a FakeReact.S.t)]
+          Value.create
+            (fst (FakeReact.S.create ~synced server_result))
+            [%client.unsafe
+              (React.S.Lwt.merge_s_init ~init:~%server_result ?eq:~%eq ~%f ~%acc
+                 ~%l
+               : 'a FakeReact.S.t)])
     end
   end
 end
 
-module ReactiveData = struct
+module%server ReactiveData = struct
   module RList = struct
     type 'a t = 'a FakeReactiveData.RList.t Value.t
     type 'a handle = 'a FakeReactiveData.RList.handle Value.t
@@ -766,7 +770,7 @@ module ReactiveData = struct
         =
         let l' = Value.local l in
         let server_result =
-          Fiber.List.map (Value.local f) (FakeReactiveData.RList.value l')
+          Eio.Fiber.List.map (Value.local f) (FakeReactiveData.RList.value l')
         in
         let synced = FakeReactiveData.RList.synced l' in
         Value.create
@@ -775,4 +779,4 @@ module ReactiveData = struct
             ReactiveData.RList.Lwt.map_p_init ~init:~%server_result ~%f ~%l]
     end
   end
-end]
+end
diff --git a/src/lib/eliom_shared.server.mli b/src/lib/eliom_shared.server.mli
index 7f28dfe65e..003c713505 100644
--- a/src/lib/eliom_shared.server.mli
+++ b/src/lib/eliom_shared.server.mli
@@ -34,7 +34,7 @@ open Eio.Std
 val to_signal :
    init:'a
   -> ?eq:('a -> 'a -> bool)
-  -> 'a React.S.t Promise.t
+  -> 'a React.S.t Promise.or_exn
   -> 'a React.S.t
 (** [to_signal ~init s] converts the Lwt-wrapped signal [s] into a
     regular signal with initial value [init]. *)
diff --git a/src/lib/eliom_shared_sigs.shared.mli b/src/lib/eliom_shared_sigs.shared.mli
index 8f73f1718c..ab7affb340 100644
--- a/src/lib/eliom_shared_sigs.shared.mli
+++ b/src/lib/eliom_shared_sigs.shared.mli
@@ -111,14 +111,18 @@ module type S = sig
 
   (** Cooperative versions of the React operators *)
   module Lwt : sig
-    val map_s : ?eq:('b -> 'b -> bool) sv -> ('a -> 'b) sv -> 'a t -> 'b t
+    val map_s :
+       ?eq:('b -> 'b -> bool) sv
+      -> ('a -> 'b) sv
+      -> 'a t
+      -> 'b t Eio.Promise.or_exn
 
     val l2_s :
        ?eq:('c -> 'c -> bool) sv
       -> ('a -> 'b -> 'c) sv
       -> 'a t
       -> 'b t
-      -> 'c t
+      -> 'c t Eio.Promise.or_exn
 
     val l3_s :
        ?eq:('d -> 'd -> bool) sv
@@ -126,7 +130,7 @@ module type S = sig
       -> 'a t
       -> 'b t
       -> 'c t
-      -> 'd t
+      -> 'd t Eio.Promise.or_exn
 
     val l4_s :
        ?eq:('e -> 'e -> bool) sv
@@ -135,7 +139,7 @@ module type S = sig
       -> 'b t
       -> 'c t
       -> 'd t
-      -> 'e t
+      -> 'e t Eio.Promise.or_exn
 
     val l5_s :
        ?eq:('f -> 'f -> bool) sv
@@ -145,7 +149,7 @@ module type S = sig
       -> 'c t
       -> 'd t
       -> 'e t
-      -> 'f t
+      -> 'f t Eio.Promise.or_exn
 
     val l6_s :
        ?eq:('g -> 'g -> bool) sv
@@ -156,14 +160,14 @@ module type S = sig
       -> 'd t
       -> 'e t
       -> 'f t
-      -> 'g t
+      -> 'g t Eio.Promise.or_exn
 
     val merge_s :
        ?eq:('a -> 'a -> bool) sv
       -> ('a -> 'b -> 'a) sv
       -> 'a
       -> 'b t list
-      -> 'a t
+      -> 'a t Eio.Promise.or_exn
   end
 end
 

From f2a2c64ceeb43fedf0643736fae206cf4a50ae58 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Mon, 29 Sep 2025 17:14:39 +0200
Subject: [PATCH 16/21] Remove dependencies to some lwt related modules

---
 .ocp-indent         | 2 +-
 dune-project        | 1 -
 eliom.opam          | 1 -
 src/lib/client/dune | 3 +--
 src/lib/server/dune | 2 +-
 5 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/.ocp-indent b/.ocp-indent
index e98972dec4..e42012c136 100644
--- a/.ocp-indent
+++ b/.ocp-indent
@@ -1,4 +1,4 @@
 normal
 with=0
-syntax=lwt mll
+syntax=mll
 max_indent=2
diff --git a/dune-project b/dune-project
index 63f9d0c5b8..7799eb20ad 100644
--- a/dune-project
+++ b/dune-project
@@ -28,7 +28,6 @@ The client-side code is compiled to JS using Ocsigen Js_of_ocaml or to Wasm usin
   (ppxlib (>= 0.15))
   (js_of_ocaml-compiler (>= 6.0))
   (js_of_ocaml (>= 6.0))
-  (js_of_ocaml-lwt (>= 6.0))
   (js_of_ocaml-ocamlbuild :build)
   (js_of_ocaml-ppx (>= 6.0))
   (js_of_ocaml-ppx_deriving_json (>= 6.0))
diff --git a/eliom.opam b/eliom.opam
index 8b646b8e04..d39dbb5840 100644
--- a/eliom.opam
+++ b/eliom.opam
@@ -24,7 +24,6 @@ depends: [
   "ppxlib" {>= "0.15"}
   "js_of_ocaml-compiler" {>= "6.0"}
   "js_of_ocaml" {>= "6.0"}
-  "js_of_ocaml-lwt" {>= "6.0"}
   "js_of_ocaml-ocamlbuild" {build}
   "js_of_ocaml-ppx" {>= "6.0"}
   "js_of_ocaml-ppx_deriving_json" {>= "6.0"}
diff --git a/src/lib/client/dune b/src/lib/client/dune
index f7866e3921..4ff37218e2 100644
--- a/src/lib/client/dune
+++ b/src/lib/client/dune
@@ -21,8 +21,7 @@
   ocsigenserver.polytables
   js_of_ocaml
   js_of_ocaml-tyxml
-  js_of_ocaml-lwt
-  lwt_react
+  react
   ocsigenserver.baselib.base
   logs
   logs.browser
diff --git a/src/lib/server/dune b/src/lib/server/dune
index 59567d6639..0adf476c34 100644
--- a/src/lib/server/dune
+++ b/src/lib/server/dune
@@ -17,7 +17,7 @@
    (:include type_includes)))
  (library_flags
   (:standard -linkall))
- (libraries lwt_react ocsigenserver logs ocsipersist tyxml eio eio.unix))
+ (libraries react ocsigenserver logs ocsipersist tyxml eio eio.unix))
 
 (include dune.server)
 

From ca7df842925c4101cad3ed35c5125dfac449fb4b Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Mon, 29 Sep 2025 17:27:22 +0200
Subject: [PATCH 17/21] Ocsigenserver is now using Eio ipaddr

---
 src/lib/eliom_common.server.ml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/lib/eliom_common.server.ml b/src/lib/eliom_common.server.ml
index 8ce4833b44..03e38bb4c1 100644
--- a/src/lib/eliom_common.server.ml
+++ b/src/lib/eliom_common.server.ml
@@ -299,7 +299,8 @@ let network_of_ip k mask4 mask6 =
 
 let network_of_request r ~mask4 ~mask6 =
   match Ocsigen_request.client_conn r with
-  | `Inet (ip, _) -> network_of_ip ip mask4 mask6
+  | `Inet (eio_ip, _) ->
+      network_of_ip (Ipaddr.of_octets_exn (eio_ip :> string)) mask4 mask6
   | _ -> Ipaddr.(V6 V6.localhost)
 
 module Net_addr_Hashtbl : sig
@@ -830,7 +831,8 @@ let empty_tables max forsession =
                      Ocsigen_request.client_conn
                        sp.sp_request.Ocsigen_extensions.request_info
                    with
-                   | `Inet (ip, _) -> ip
+                   | `Inet (eio_ip, _) ->
+                       Ipaddr.of_octets_exn (eio_ip :> string)
                    | _ -> default_ip_table_key
                  in
                  ( ip

From f7dc1185bcd812f18c1756d105a1fbaee079b2c9 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Wed, 12 Nov 2025 17:32:12 +0100
Subject: [PATCH 18/21] Fix wrong translation of Lwt exceptions

---
 src/lib/eliom_route.server.ml      | 28 ++++++++++++++++------------
 src/lib/eliom_route_base.shared.ml | 25 +++++++++++++------------
 2 files changed, 29 insertions(+), 24 deletions(-)

diff --git a/src/lib/eliom_route.server.ml b/src/lib/eliom_route.server.ml
index 016e18c24e..5a1a17f6a9 100644
--- a/src/lib/eliom_route.server.ml
+++ b/src/lib/eliom_route.server.ml
@@ -104,19 +104,23 @@ let get_page
       sitedata : Ocsigen_response.t
   =
   let tables = session_tables info in
+  let rec try_page e f = function
+    | tables :: others -> (
+      try f tables
+      with
+      | (Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter) as e ->
+        try_page e f others)
+    | [] -> raise e
+  in
   try
-    List.fold_left
-      (fun beg (table, table_name) ->
-         try beg with
-         | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter ->
-             Logs.info ~src:section (fun fmt ->
-               fmt "Looking for %s in the %s:"
-                 (Url.string_of_url_path ~encode:true
-                    (Ocsigen_request.sub_path ri.request_info))
-                 table_name);
-             find_aux now sitedata info Eliom_common.Eliom_404 table
-         | e -> raise e)
-      (raise Eliom_common.Eliom_404)
+    try_page Eliom_common.Eliom_404
+      (fun (table, table_name) ->
+         Logs.info ~src:section (fun fmt ->
+           fmt "Looking for %s in the %s:"
+             (Url.string_of_url_path ~encode:true
+                (Ocsigen_request.sub_path ri.request_info))
+             table_name);
+         find_aux now sitedata info Eliom_common.Eliom_404 table)
       tables
   with
   | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter -> (
diff --git a/src/lib/eliom_route_base.shared.ml b/src/lib/eliom_route_base.shared.ml
index 96eb4b735f..1bffe58c4b 100644
--- a/src/lib/eliom_route_base.shared.ml
+++ b/src/lib/eliom_route_base.shared.ml
@@ -422,21 +422,22 @@ module Make (P : PARAM) = struct
            because of optional suffixes *)
       | a :: l -> aux (Some a) l
     in
-    let search_by_priority_generation tables path =
-      (* New in 1.91: There is now one table for each pair
-         (generation, priority) *)
-      List.fold_left
-        (fun prev (_prio, _gen, table) ->
-           try prev with
-           | Exn1 | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter
-             ->
-               search_page_table !table path
-           | e -> raise e)
-        (raise Exn1) tables
+    let rec search_by_priority_generation path e = function
+      | (_prio, _gen, table) :: others -> (
+        (* New in 1.91: There is now one table for each pair
+          (generation, priority) *)
+        try search_page_table !table path
+        with
+        | (Exn1 | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter)
+          as e
+        ->
+          search_by_priority_generation path e others)
+      | [] -> raise e
     in
     try
-      search_by_priority_generation (P.Container.get tables)
+      search_by_priority_generation
         (Url.change_empty_list (P.subpath_of_info info))
+        Exn1 (P.Container.get tables)
     with
     | Exn1 -> raise Eliom_common.Eliom_404
     | e -> raise e

From 3e822394f43547dc9b63051dcbf9cf0660475819 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Fri, 16 Jan 2026 15:05:20 +0100
Subject: [PATCH 19/21] Update distillery templates

---
 .ocamlformat                                  |  3 +-
 .../templates/app.exe/PROJECT_NAME.eliom      | 36 +++++++++----------
 pkg/distillery/templates/app.exe/dune         |  4 ++-
 .../templates/app.lib/PROJECT_NAME.eliom      | 33 +++++++++--------
 pkg/distillery/templates/app.lib/dune         |  4 ++-
 .../templates/basic.ppx/PROJECT_NAME.eliom    | 13 ++++---
 6 files changed, 48 insertions(+), 45 deletions(-)

diff --git a/.ocamlformat b/.ocamlformat
index a7668bf8f9..a84459a472 100644
--- a/.ocamlformat
+++ b/.ocamlformat
@@ -1,5 +1,6 @@
-version=0.27.0
+version=0.28.1
 parse-docstrings = false
+wrap-comments = false
 break-cases = fit
 break-collection-expressions = fit-or-vertical
 break-fun-decl = wrap
diff --git a/pkg/distillery/templates/app.exe/PROJECT_NAME.eliom b/pkg/distillery/templates/app.exe/PROJECT_NAME.eliom
index 2f69b13869..fc32e2f7fd 100644
--- a/pkg/distillery/templates/app.exe/PROJECT_NAME.eliom
+++ b/pkg/distillery/templates/app.exe/PROJECT_NAME.eliom
@@ -1,11 +1,12 @@
-(* This file was generated by Eliom-distillery.
-   Feel free to use it, modify it, and redistribute it as you wish. *)
+(* This file was generated by Eliom-distillery. Feel free to use it, modify it,
+   and redistribute it as you wish. *)
 
 let%server application_name = "%%%PROJECT_NAME%%%"
 let%client application_name = Eliom_client.get_application_name ()
 
 let%server () =
-    Ocsipersist_settings.set_db_file "local/var/data/%%%PROJECT_NAME%%%/%%%PROJECT_NAME%%%_db";
+  Ocsipersist_settings.set_db_file
+    "local/var/data/%%%PROJECT_NAME%%%/%%%PROJECT_NAME%%%_db"
 
 (* Create a module for the application. See
    https://ocsigen.org/eliom/manual/clientserver-applications for more
@@ -15,9 +16,9 @@ module%shared App = Eliom_registration.App (struct
     let global_data_path = Some ["__global_data__"]
   end)
 
-(* As the headers (stylesheets, etc) won't change, we ask Eliom not to
-   update the <head> of the page when changing page. (This also avoids
-   blinking when changing page in iOS). *)
+(* As the headers (stylesheets, etc) won't change, we ask Eliom not to update
+   the <head> of the page when changing page. (This also avoids blinking when
+   changing page in iOS). *)
 let%client _ = Eliom_client.persist_document_head ()
 
 let%server main_service =
@@ -28,15 +29,14 @@ let%client main_service = ~%main_service
 
 let%shared () =
   App.register ~service:main_service (fun () () ->
-    Lwt.return
-      Eliom_content.Html.F.(
-        html
-          (head
-             (title (txt "%%%PROJECT_NAME%%%"))
-             [ css_link
-                 ~uri:
-                   (make_uri
-                      ~service:(Eliom_service.static_dir ())
-                      ["css"; "%%%PROJECT_NAME%%%.css"])
-                 () ])
-          (body [h1 [txt "Welcome to Eliom!"]])))
+    Eliom_content.Html.F.(
+      html
+        (head
+           (title (txt "%%%PROJECT_NAME%%%"))
+           [ css_link
+               ~uri:
+                 (make_uri
+                    ~service:(Eliom_service.static_dir ())
+                    ["css"; "%%%PROJECT_NAME%%%.css"])
+               () ])
+        (body [h1 [txt "Welcome to Eliom!"]])))
diff --git a/pkg/distillery/templates/app.exe/dune b/pkg/distillery/templates/app.exe/dune
index 79f6fd711e..48669291a3 100644
--- a/pkg/distillery/templates/app.exe/dune
+++ b/pkg/distillery/templates/app.exe/dune
@@ -100,10 +100,12 @@
     ;    %%%MODULE_NAME%%%_i18n
     ))
   (js_of_ocaml
-   (build_runtime_flags :standard --enable use-js-string)
+   (build_runtime_flags :standard --enable use-js-string --enable effects)
    (flags
     :standard
     --enable
+    effects
+    --enable
     with-js-error
     --enable
     use-js-string
diff --git a/pkg/distillery/templates/app.lib/PROJECT_NAME.eliom b/pkg/distillery/templates/app.lib/PROJECT_NAME.eliom
index 6fe38deee0..a40f41f941 100644
--- a/pkg/distillery/templates/app.lib/PROJECT_NAME.eliom
+++ b/pkg/distillery/templates/app.lib/PROJECT_NAME.eliom
@@ -1,5 +1,5 @@
-(* This file was generated by Eliom-distillery.
-   Feel free to use it, modify it, and redistribute it as you wish. *)
+(* This file was generated by Eliom-distillery. Feel free to use it, modify it,
+   and redistribute it as you wish. *)
 
 let%server application_name = "%%%PROJECT_NAME%%%"
 let%client application_name = Eliom_client.get_application_name ()
@@ -12,9 +12,9 @@ module%shared App = Eliom_registration.App (struct
     let global_data_path = Some ["__global_data__"]
   end)
 
-(* As the headers (stylesheets, etc) won't change, we ask Eliom not to
-   update the <head> of the page when changing page. (This also avoids
-   blinking when changing page in iOS). *)
+(* As the headers (stylesheets, etc) won't change, we ask Eliom not to update
+   the <head> of the page when changing page. (This also avoids blinking when
+   changing page in iOS). *)
 let%client _ = Eliom_client.persist_document_head ()
 
 let%server main_service =
@@ -25,15 +25,14 @@ let%client main_service = ~%main_service
 
 let%shared () =
   App.register ~service:main_service (fun () () ->
-    Lwt.return
-      Eliom_content.Html.F.(
-        html
-          (head
-             (title (txt "%%%PROJECT_NAME%%%"))
-             [ css_link
-                 ~uri:
-                   (make_uri
-                      ~service:(Eliom_service.static_dir ())
-                      ["css"; "%%%PROJECT_NAME%%%.css"])
-                 () ])
-          (body [h1 [txt "Welcome to Eliom!"]])))
+    Eliom_content.Html.F.(
+      html
+        (head
+           (title (txt "%%%PROJECT_NAME%%%"))
+           [ css_link
+               ~uri:
+                 (make_uri
+                    ~service:(Eliom_service.static_dir ())
+                    ["css"; "%%%PROJECT_NAME%%%.css"])
+               () ])
+        (body [h1 [txt "Welcome to Eliom!"]])))
diff --git a/pkg/distillery/templates/app.lib/dune b/pkg/distillery/templates/app.lib/dune
index 3e04eda1d4..85ab8caf0a 100644
--- a/pkg/distillery/templates/app.lib/dune
+++ b/pkg/distillery/templates/app.lib/dune
@@ -71,10 +71,12 @@
     ;    %%%MODULE_NAME%%%_i18n
     ))
   (js_of_ocaml
-   (build_runtime_flags :standard --enable use-js-string)
+   (build_runtime_flags :standard --enable use-js-string --enable effects)
    (flags
     :standard
     --enable
+    effects
+    --enable
     with-js-error
     --enable
     use-js-string
diff --git a/pkg/distillery/templates/basic.ppx/PROJECT_NAME.eliom b/pkg/distillery/templates/basic.ppx/PROJECT_NAME.eliom
index c04a600377..dd5a1b5629 100644
--- a/pkg/distillery/templates/basic.ppx/PROJECT_NAME.eliom
+++ b/pkg/distillery/templates/basic.ppx/PROJECT_NAME.eliom
@@ -21,10 +21,9 @@ let () =
   %%%MODULE_NAME%%%_app.register
     ~service:main_service
     (fun () () ->
-       Lwt.return
-         (Eliom_tools.F.html
-            ~title:"%%%PROJECT_NAME%%%"
-            ~css:[["css";"%%%PROJECT_NAME%%%.css"]]
-            Html.F.(body [
-              h1 [txt "Welcome from Eliom's distillery!"];
-            ])))
+       (Eliom_tools.F.html
+          ~title:"%%%PROJECT_NAME%%%"
+          ~css:[["css";"%%%PROJECT_NAME%%%.css"]]
+          Html.F.(body [
+            h1 [txt "Welcome from Eliom's distillery!"];
+          ])))

From 18dca0eda7ab4118a7038b952ad8646bb2935d8a Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Mon, 19 Jan 2026 15:46:03 +0100
Subject: [PATCH 20/21] Code cleaning: removing ciao-lwt comments

---
 src/lib/client/eliommod_dom.ml       | 1 -
 src/lib/eio_react.shared.ml          | 4 ----
 src/lib/eliom_bus.client.ml          | 1 -
 src/lib/eliom_client.client.ml       | 5 -----
 src/lib/eliom_client_core.client.ml  | 1 -
 src/lib/eliom_comet.client.ml        | 7 -------
 src/lib/eliom_comet.server.ml        | 4 ----
 src/lib/eliom_registration.client.ml | 2 --
 src/lib/eliom_request.client.ml      | 1 -
 src/lib/eliom_shared.eliom           | 2 --
 src/lib/eliom_stream.shared.ml       | 9 ---------
 11 files changed, 37 deletions(-)

diff --git a/src/lib/client/eliommod_dom.ml b/src/lib/client/eliommod_dom.ml
index 14871c251e..72df496ef9 100644
--- a/src/lib/client/eliommod_dom.ml
+++ b/src/lib/client/eliommod_dom.ml
@@ -610,7 +610,6 @@ and rewrite_css_import ?(charset = "") ~max ~prefix ~media css pos =
             (fun () -> rewrite_css_import ~charset ~max ~prefix ~media css i)
             (fun () ->
                if
-                 (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
                  max = 0
                then
                  (* Maximum imbrication of @import reached, rewrite url. *)
diff --git a/src/lib/eio_react.shared.ml b/src/lib/eio_react.shared.ml
index 21d5686134..5edbb6cc40 100644
--- a/src/lib/eio_react.shared.ml
+++ b/src/lib/eio_react.shared.ml
@@ -23,15 +23,11 @@ module E = struct
   let next ev =
     let waiter, wakener =
       Promise.create
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     let _ev = map (fun x -> Promise.resolve wakener x) (once ev) in
     (* XXX restore this if promise can be cancelled
       Lwt.on_cancel
-      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
       waiter (fun () -> stop ev);
     *)
     waiter
diff --git a/src/lib/eliom_bus.client.ml b/src/lib/eliom_bus.client.ml
index 9403aa98ad..edcff31f56 100644
--- a/src/lib/eliom_bus.client.ml
+++ b/src/lib/eliom_bus.client.ml
@@ -95,7 +95,6 @@ let create service channel waiter =
   let error_h =
     let t, (u : (exn, exn) result Promise.u) =
       Promise.create
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     let tt, uu = Promise.create () in
diff --git a/src/lib/eliom_client.client.ml b/src/lib/eliom_client.client.ml
index 629a533a6b..b139b606e5 100644
--- a/src/lib/eliom_client.client.ml
+++ b/src/lib/eliom_client.client.ml
@@ -79,7 +79,6 @@ let run_onunload_wrapper set_content cancel =
 let onload_promise () =
   let t, u =
     Promise.create
-      (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
       ()
   in
   onload (fun () -> Promise.resolve u ());
@@ -2188,7 +2187,6 @@ let () =
       let tmpl = state.template in
       Js_of_ocaml_eio.Eio_js.start (fun () ->
         with_progress_cursor
-        (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
         @@ fun () ->
         let uri, fragment = Url.split_fragment full_uri in
         if uri = get_current_uri ()
@@ -2303,7 +2301,6 @@ let () =
     in
     Js_of_ocaml_eio.Eio_js.start (fun () ->
       let
-          (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
             ()
         =
         wait_load_end ()
@@ -2340,7 +2337,6 @@ let () =
     let read_fragment () = Js.to_string Dom_html.window##.location##.hash in
     let auto_change_page fragment =
       Js_of_ocaml_eio.Eio_js.start (fun () ->
-        (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
         let l = String.length fragment in
         if l = 0 || (l > 1 && fragment.[1] = '!')
         then
@@ -2365,7 +2361,6 @@ let () =
     then
       Js_of_ocaml_eio.Eio_js.start (fun () ->
         let
-            (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
               ()
           =
           wait_load_end ()
diff --git a/src/lib/eliom_client_core.client.ml b/src/lib/eliom_client_core.client.ml
index 017df13c51..d47d3d1605 100644
--- a/src/lib/eliom_client_core.client.ml
+++ b/src/lib/eliom_client_core.client.ml
@@ -568,7 +568,6 @@ let rec rebuild_rattrib node ra =
 let delay f =
   Js_of_ocaml_eio.Eio_js.start (fun () ->
     Fiber.yield
-      (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
       ();
     f ())
 
diff --git a/src/lib/eliom_comet.client.ml b/src/lib/eliom_comet.client.ml
index 3b264f2629..c99958f7c1 100644
--- a/src/lib/eliom_comet.client.ml
+++ b/src/lib/eliom_comet.client.ml
@@ -86,7 +86,6 @@ module Configuration = struct
   let update_configuration_waiter, update_configuration_waker =
     let t, u =
       Promise.create
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     ref t, ref u
@@ -95,7 +94,6 @@ module Configuration = struct
     global_configuration := get_configuration ();
     let t, u =
       Promise.create
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     update_configuration_waiter := t;
@@ -290,7 +288,6 @@ end = struct
           hd.hd_activity.active <- v;
           let t, u =
             Promise.create
-              (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
               ()
           in
           hd.hd_activity.active_waiter <- t;
@@ -364,7 +361,6 @@ end = struct
     let act = hd.hd_activity in
     let t, u =
       Promise.create
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     act.restart_waiter <- t;
@@ -526,7 +522,6 @@ end = struct
             ; (fun () ->
                 Eio.Promise.await_exn
                   hd
-                  (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
                     .hd_activity
                     .restart_waiter) ]
         with
@@ -633,12 +628,10 @@ end = struct
   let init_activity () =
     let active_waiter, active_wakener =
       Promise.create
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     let restart_waiter, restart_wakener =
       Promise.create
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     { active = `Inactive
diff --git a/src/lib/eliom_comet.server.ml b/src/lib/eliom_comet.server.ml
index 4a6b46bcbc..374a5d29a2 100644
--- a/src/lib/eliom_comet.server.ml
+++ b/src/lib/eliom_comet.server.ml
@@ -389,8 +389,6 @@ end = struct
       | Active l ->
           let waiter, waker =
             Promise.create
-              (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-              (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
               ()
           in
           let t =
@@ -476,8 +474,6 @@ end = struct
     match
       let hd_update_streams, hd_update_streams_w =
         Promise.create
-          (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-          (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
           ()
       in
       handler.hd_update_streams_w <- Some hd_update_streams_w;
diff --git a/src/lib/eliom_registration.client.ml b/src/lib/eliom_registration.client.ml
index 2eab3ab059..dd85759692 100644
--- a/src/lib/eliom_registration.client.ml
+++ b/src/lib/eliom_registration.client.ml
@@ -60,7 +60,6 @@ let typed_apply ~service f gp pp l l' suffix =
       Fiber.pair
         (fun () ->
            let
-               (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
                  l'
              =
              Some l'
@@ -68,7 +67,6 @@ let typed_apply ~service f gp pp l l' suffix =
            Eliom_parameter.reconstruct_params ~sp:() pp l' None true suffix)
         (fun () ->
            let
-               (* TODO: ciao-lwt: This computation might not be suspended correctly. *)
                  l
              =
              Some l
diff --git a/src/lib/eliom_request.client.ml b/src/lib/eliom_request.client.ml
index a2e8dd5279..7f98c85638 100644
--- a/src/lib/eliom_request.client.ml
+++ b/src/lib/eliom_request.client.ml
@@ -271,7 +271,6 @@ let send
       in
       let wait_for_unlock, unlock =
         Promise.create
-          (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
           ()
       in
       (if not @@ React.S.value locked
diff --git a/src/lib/eliom_shared.eliom b/src/lib/eliom_shared.eliom
index 3aee69185e..aa0fc39cc3 100644
--- a/src/lib/eliom_shared.eliom
+++ b/src/lib/eliom_shared.eliom
@@ -158,7 +158,6 @@ module%client ReactiveData = struct
         let waiter =
           ref
             (Promise.create
-               (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
                ())
         in
         Promise.resolve (snd !waiter) ();
@@ -168,7 +167,6 @@ module%client ReactiveData = struct
                let waiter1 = !waiter in
                let new_waiter =
                  Promise.create
-                   (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
                    ()
                in
                waiter := new_waiter;
diff --git a/src/lib/eliom_stream.shared.ml b/src/lib/eliom_stream.shared.ml
index ac43452af6..8ba38b25c4 100644
--- a/src/lib/eliom_stream.shared.ml
+++ b/src/lib/eliom_stream.shared.ml
@@ -120,7 +120,6 @@ let from_source source =
   let node = new_node () in
   let closed, close =
     Promise.create
-      (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
       ()
   in
   {source; close; closed; node; last = ref node}
@@ -146,7 +145,6 @@ let create_with_reference () =
   let source, push_signal_resolver =
     let push_signal, push_signal_resolver =
       Promise.create
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     ( {push_signal; push_waiting = false; push_external = Obj.repr ()}
@@ -171,7 +169,6 @@ let create_with_reference () =
       let old_push_signal_resolver = !push_signal_resolver in
       let new_waiter, new_push_signal_resolver =
         Promise.create
-          (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
           ()
       in
       source.push_signal <- new_waiter;
@@ -236,8 +233,6 @@ let notify_pusher info last =
   let old_wakener = info.pushb_push_wakener in
   let waiter, wakener =
     Promise.create
-      (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-      (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
       ()
   in
   info.pushb_push_waiter <- waiter;
@@ -286,7 +281,6 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
           let old_wakener = !wakener_cell in
           let new_waiter, new_wakener =
             Promise.create
-              (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
               ()
           in
           info.pushb_signal <- new_waiter;
@@ -330,13 +324,10 @@ let create_bounded size =
   let info, wakener_cell =
     let waiter, wakener =
       Promise.create
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     let push_waiter, push_wakener =
       Promise.create
-        (* TODO: ciao-lwt: Use [Switch] or [Cancel] for defining a cancellable context. *)
-        (* TODO: ciao-lwt: Translation is incomplete, [Promise.await] must be called on the promise when it's part of control-flow. *)
         ()
     in
     ( { pushb_signal = waiter

From 2ba98eba7f1ca69173750aa508d17f0ec922eee7 Mon Sep 17 00:00:00 2001
From: Vincent Balat <vincent.balat@vblt.org>
Date: Fri, 16 Jan 2026 18:29:17 +0100
Subject: [PATCH 21/21] Switch to Eio: Manual changes, step 2

---
 src/lib/eio_react.shared.ml          |  2 +-
 src/lib/eliom_bus.client.ml          | 66 ++++++++++++++-----------
 src/lib/eliom_client.client.ml       | 74 ++++++++++++++--------------
 src/lib/eliom_client_core.client.ml  | 41 +++++++++------
 src/lib/eliom_comet.client.ml        | 59 ++++++++++++----------
 src/lib/eliom_comet.server.ml        |  9 +++-
 src/lib/eliom_lib.client.ml          |  8 ++-
 src/lib/eliom_mkreg.server.ml        |  3 +-
 src/lib/eliom_react.client.ml        | 34 +++++++++----
 src/lib/eliom_registration.server.ml | 12 +++--
 src/lib/eliom_request.client.ml      |  5 +-
 src/lib/eliom_route.server.ml        | 43 ++++++++--------
 src/lib/eliom_shared.eliom           |  4 +-
 src/lib/eliom_stream.shared.ml       | 23 ++++-----
 src/lib/eliom_unwrap.client.ml       | 24 +++++++--
 src/lib/server/eliommod_pagegen.ml   |  3 +-
 16 files changed, 245 insertions(+), 165 deletions(-)

diff --git a/src/lib/eio_react.shared.ml b/src/lib/eio_react.shared.ml
index 5edbb6cc40..77d495cb07 100644
--- a/src/lib/eio_react.shared.ml
+++ b/src/lib/eio_react.shared.ml
@@ -25,7 +25,7 @@ module E = struct
       Promise.create
         ()
     in
-    let _ev = map (fun x -> Promise.resolve wakener x) (once ev) in
+    let _ev = map (fun x -> ignore (Eio.Promise.try_resolve wakener x)) (once ev) in
     (* XXX restore this if promise can be cancelled
       Lwt.on_cancel
       waiter (fun () -> stop ev);
diff --git a/src/lib/eliom_bus.client.ml b/src/lib/eliom_bus.client.ml
index edcff31f56..1754af15d7 100644
--- a/src/lib/eliom_bus.client.ml
+++ b/src/lib/eliom_bus.client.ml
@@ -1,5 +1,6 @@
 open Eio.Std
 
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2010-2011
@@ -36,19 +37,23 @@ type ('a, 'b) t =
   ; mutable waiter : unit -> unit
   ; mutable last_wait : Switch.t option
   ; mutable original_stream_available : bool
-  ; error_h : 'b option Promise.or_exn * (exn, exn) result Promise.u }
+  ; error_h : ('b option Promise.or_exn * (exn, exn) result Promise.u) Lazy.t }
 
 (* clone streams such that each clone of the original stream raise the same exceptions *)
 let consume (t, u) s =
   let p, w = Promise.create () in
   Eliom_lib.fork (fun () ->
-    try Promise.resolve_ok w (Eliom_stream.iter (fun _ -> ()) s)
+    try
+      let v = Eliom_stream.iter (fun _ -> ()) s in
+      ignore (Eio.Promise.try_resolve w (Ok v))
     with e ->
-      (match Promise.peek t with None -> Promise.resolve_error u e | _ -> ());
-      Promise.resolve_error w e);
+      (match Promise.peek t with None -> ignore (Eio.Promise.try_resolve u (Error e)) | _ -> ());
+      ignore (Eio.Promise.try_resolve w (Error e)));
   Eliom_lib.fork (fun () ->
-    try Promise.resolve_ok w (ignore (Promise.await_exn t))
-    with e -> Promise.resolve_error w e);
+    try
+      ignore (Promise.await_exn t);
+      ignore (Eio.Promise.try_resolve w (Ok ()))
+    with e -> ignore (Eio.Promise.try_resolve w (Error e)));
   Promise.await_exn p
 
 let clone_exn (t, u) s =
@@ -57,14 +62,14 @@ let clone_exn (t, u) s =
     try
       let p, w = Promise.create () in
       Eliom_lib.fork (fun () ->
-        try Promise.resolve_ok w (Eliom_stream.get s')
-        with e -> Promise.resolve_error w e);
+        try ignore (Eio.Promise.try_resolve w (Ok (Eliom_stream.get s')))
+        with e -> ignore (Eio.Promise.try_resolve w (Error e)));
       Eliom_lib.fork (fun () ->
-        try Promise.resolve_ok w (Promise.await_exn t)
-        with e -> Promise.resolve_error w e);
+        try ignore (Eio.Promise.try_resolve w (Ok (Promise.await_exn t)))
+        with e -> ignore (Eio.Promise.try_resolve w (Error e)));
       Promise.await_exn p
     with e ->
-      (match Promise.peek t with None -> Promise.resolve_error u e | _ -> ());
+      (match Promise.peek t with None -> ignore (Eio.Promise.try_resolve u (Error e)) | _ -> ());
       raise e)
 
 type ('a, 'att, 'co, 'ext, 'reg) callable_bus_service =
@@ -81,6 +86,18 @@ type ('a, 'att, 'co, 'ext, 'reg) callable_bus_service =
     , Eliom_registration.Action.return )
     Eliom_service.t
 
+let create_error_h () =
+  let t, (u : (exn, exn) result Promise.u) =
+    Promise.create
+      ()
+  in
+  let tt, uu = Promise.create () in
+  ( (try
+       ignore (Promise.await t);
+       assert false
+     with e -> ignore (Eio.Promise.try_resolve uu (Error e)); tt)
+  , u )
+
 let create service channel waiter =
   let write x =
     try
@@ -92,23 +109,13 @@ let create service channel waiter =
       ()
     with Eliom_request.Failed_request 204 -> ()
   in
-  let error_h =
-    let t, (u : (exn, exn) result Promise.u) =
-      Promise.create
-        ()
-    in
-    let tt, uu = Promise.create () in
-    ( (try
-         ignore (Promise.await t);
-         assert false
-       with e -> Promise.resolve_error uu e; tt)
-    , u )
-  in
+  (* error_h is lazy to avoid Promise.create/await outside Eio context *)
+  let error_h = lazy (create_error_h ()) in
   let stream =
     lazy
       (let stream = Eliom_comet.register channel in
        (* iterate on the stream to consume messages: avoid memory leak *)
-       let _ = consume error_h stream in
+       let _ = consume (Lazy.force error_h) stream in
        stream)
   in
   let t =
@@ -124,10 +131,13 @@ let create service channel waiter =
   in
   (* the comet channel start receiving after the load phase, so the
      original channel (i.e. without message lost) is only available in
-     the first loading phase. *)
+     the first loading phase.
+     Note: we use fork to avoid calling wait_load_end during unmarshalling,
+     which happens outside an Eio context. *)
   let _ =
-    let () = Eliom_client.wait_load_end () in
-    t.original_stream_available <- false
+    Eliom_lib.fork (fun () ->
+      Eliom_client.wait_load_end ();
+      t.original_stream_available <- false)
   in
   t
 
@@ -139,7 +149,7 @@ let internal_unwrap ((wrapped_bus : ('a, 'b) Ecb.wrapped_bus), _unwrapper) =
 let () =
   Eliom_unwrap.register_unwrapper Eliom_common.bus_unwrap_id internal_unwrap
 
-let stream t = clone_exn t.error_h (Lazy.force t.stream)
+let stream t = clone_exn (Lazy.force t.error_h) (Lazy.force t.stream)
 
 let original_stream t =
   if Eliom_client_core.in_onload () && t.original_stream_available
diff --git a/src/lib/eliom_client.client.ml b/src/lib/eliom_client.client.ml
index b139b606e5..7760048f3d 100644
--- a/src/lib/eliom_client.client.ml
+++ b/src/lib/eliom_client.client.ml
@@ -19,7 +19,7 @@ open Eio.Std
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-*)
+ *)
 
 let section = Eliom_client_core.section
 
@@ -77,11 +77,9 @@ let run_onunload_wrapper set_content cancel =
       set_content ()
 
 let onload_promise () =
-  let t, u =
-    Promise.create
-      ()
-  in
-  onload (fun () -> Promise.resolve u ());
+  let t, u = Promise.create () in
+  onload (fun () ->
+    ignore (Eio.Promise.try_resolve u ()));
   t
 
 (* == Initialize the client values sent with a request *)
@@ -935,6 +933,11 @@ let set_base_url () =
 
 let dom_history_ready = ref false
 
+(* Queue of callbacks to execute after onload completes *)
+let post_onload_callbacks = ref []
+let register_post_onload_callback f =
+  post_onload_callbacks := f :: !post_onload_callbacks
+
 (* Function called (in Eliom_client_main), once when starting the app.
    Either when sent by a server or initiated on client side.
 
@@ -1049,8 +1052,11 @@ let init () =
         flush_onload ()
         @ [onload_closure_nodes; Eliom_client_core.broadcast_load_end]
       in
-      Eio.Mutex.unlock Eliom_client_core.load_mutex;
+      Eliom_client_core.unlock_load_mutex ();
       run_callbacks load_callbacks;
+      (* Execute post-onload callbacks *)
+      List.iter (fun f -> f ()) (List.rev !post_onload_callbacks);
+      post_onload_callbacks := [];
       if !Eliom_config.debug_timings
       then Console.console##(timeEnd (Js.string "onload")));
     Js._false
@@ -1060,8 +1066,7 @@ let init () =
   then
     Js_of_ocaml_eio.Eio_js.start (fun () ->
       let () = Js_of_ocaml_eio.Eio_js_events.request_animation_frame () in
-      let _ = onload () in
-      ())
+      ignore (onload ()))
   else
     onload_handler :=
       Some
@@ -1317,13 +1322,13 @@ let call_ocaml_service
       ?fragment ?keep_nl_params ?nl_params ?keep_get_na_params ?progress
       ?upload_progress ?override_mime_type get_params post_params
   in
-  let () = Eio.Mutex.lock Eliom_client_core.load_mutex in
+  let () = Eliom_client_core.lock_load_mutex () in
   Eliom_client_core.set_loading_phase ();
   let content, request_data = unwrap_caml_content content in
   do_request_data request_data;
   Eliom_client_core.reset_request_nodes ();
-  let load_callbacks = [Eliom_client_core.broadcast_load_end] in
-  Eio.Mutex.unlock Eliom_client_core.load_mutex;
+  let load_callbacks = flush_onload () @ [Eliom_client_core.broadcast_load_end] in
+  Eliom_client_core.unlock_load_mutex ();
   run_callbacks load_callbacks;
   match content with
   | `Success result -> result
@@ -1446,9 +1451,13 @@ module Page_status = struct
   let while_active ?now ?(stop = React.E.never) action =
     let active_switch = ref None in
     onactive ?now ~stop (fun () ->
-      Eio.Switch.run (fun sw ->
-        active_switch := Some sw;
-        Eio.Fiber.fork ~sw action);
+      (* Fork the switch.run to avoid blocking - the action runs in background *)
+      Eliom_lib.fork (fun () ->
+        try
+          Eio.Switch.run (fun sw ->
+            active_switch := Some sw;
+            Eio.Fiber.fork ~sw action)
+        with Cancelled -> (* Expected: page became inactive *) ());
       oninactive ~stop (fun () ->
         Option.iter (fun sw -> Eio.Switch.fail sw Cancelled) !active_switch);
       Dom_reference.retain_generic (get_this_page ())
@@ -1550,12 +1559,12 @@ let set_template_content ~replace ~uri ?fragment =
     (match fragment with
     | None -> change_url_string ~replace uri
     | Some fragment -> change_url_string ~replace (uri ^ "#" ^ fragment));
-    let () = Eio.Mutex.lock Eliom_client_core.load_mutex in
+    let () = Eliom_client_core.lock_load_mutex () in
     let (), request_data = unwrap_caml_content content in
     do_request_data request_data;
     Eliom_client_core.reset_request_nodes ();
     let load_callbacks = flush_onload () in
-    Eio.Mutex.unlock Eliom_client_core.load_mutex;
+    Eliom_client_core.unlock_load_mutex ();
     run_callbacks load_callbacks
   and cancel () = () in
   function
@@ -1593,7 +1602,7 @@ let set_content_local ?offset ?fragment new_page =
   Logs.debug ~src:section_page (fun fmt -> fmt "Set content local");
   let locked = ref true in
   let recover () =
-    if !locked then Eio.Mutex.unlock Eliom_client_core.load_mutex;
+    if !locked then Eliom_client_core.unlock_load_mutex ();
     if !Eliom_config.debug_timings
     then Console.console##(timeEnd (Js.string "set_content_local"))
   and really_set () =
@@ -1613,7 +1622,7 @@ let set_content_local ?offset ?fragment new_page =
       flush_onload () @ [Eliom_client_core.broadcast_load_end]
     in
     locked := false;
-    Eio.Mutex.unlock Eliom_client_core.load_mutex;
+    Eliom_client_core.unlock_load_mutex ();
     (* run callbacks upon page activation (or now), but just once *)
     Page_status.onactive ~once:true (fun () -> run_callbacks load_callbacks);
     scroll_to_fragment ?offset fragment;
@@ -1623,7 +1632,7 @@ let set_content_local ?offset ?fragment new_page =
   in
   let cancel () = recover () in
   try
-    let () = Eio.Mutex.lock Eliom_client_core.load_mutex in
+    let () = Eliom_client_core.lock_load_mutex () in
     Eliom_client_core.set_loading_phase ();
     if !Eliom_config.debug_timings
     then Console.console##(time (Js.string "set_content_local"));
@@ -1724,19 +1733,19 @@ let set_content ~replace ~uri ?offset ?fragment content =
           flush_onload ()
           @ [onload_closure_nodes; Eliom_client_core.broadcast_load_end]
         in
-        Eio.Mutex.unlock Eliom_client_core.load_mutex;
+        Eliom_client_core.unlock_load_mutex ();
         run_callbacks load_callbacks;
         scroll_to_fragment ?offset fragment;
         advance_page ();
         if !Eliom_config.debug_timings
         then Console.console##(timeEnd (Js.string "set_content"))
       and recover () =
-        if !locked then Eio.Mutex.unlock Eliom_client_core.load_mutex;
+        if !locked then Eliom_client_core.unlock_load_mutex ();
         if !Eliom_config.debug_timings
         then Console.console##(timeEnd (Js.string "set_content"))
       in
       try
-        let () = Eio.Mutex.lock Eliom_client_core.load_mutex in
+        let () = Eliom_client_core.lock_load_mutex () in
         Eliom_client_core.set_loading_phase ();
         if !Eliom_config.debug_timings
         then Console.console##(time (Js.string "set_content"));
@@ -2186,8 +2195,7 @@ let () =
       in
       let tmpl = state.template in
       Js_of_ocaml_eio.Eio_js.start (fun () ->
-        with_progress_cursor
-        @@ fun () ->
+        with_progress_cursor @@ fun () ->
         let uri, fragment = Url.split_fragment full_uri in
         if uri = get_current_uri ()
         then (
@@ -2299,12 +2307,8 @@ let () =
       and cancel () = () in
       run_onunload_wrapper f cancel
     in
-    Js_of_ocaml_eio.Eio_js.start (fun () ->
-      let
-            ()
-        =
-        wait_load_end ()
-      in
+    (* Register callback to set initial history state after onload *)
+    register_post_onload_callback (fun () ->
       Logs.debug ~src:section_page (fun fmt ->
         fmt "revisit_wrapper: replaceState");
       Dom_html.window##.history##(replaceState
@@ -2359,12 +2363,8 @@ let () =
     let first_fragment = read_fragment () in
     if first_fragment <> !current_pseudo_fragment
     then
-      Js_of_ocaml_eio.Eio_js.start (fun () ->
-        let
-              ()
-          =
-          wait_load_end ()
-        in
+      (* Register callback to handle initial fragment after onload *)
+      register_post_onload_callback (fun () ->
         auto_change_page first_fragment)
 
 let () =
diff --git a/src/lib/eliom_client_core.client.ml b/src/lib/eliom_client_core.client.ml
index d47d3d1605..f010230430 100644
--- a/src/lib/eliom_client_core.client.ml
+++ b/src/lib/eliom_client_core.client.ml
@@ -263,22 +263,31 @@ let register_request_node, find_request_node, reset_request_nodes =
    *and* to the change_page phase
    *and* to the loading phase after caml services (added 2016-03 --V). *)
 
-let load_mutex = Eio.Mutex.create ()
-let _ = ignore (Eio.Mutex.lock load_mutex)
-
-let in_onload, broadcast_load_end, wait_load_end, set_loading_phase =
-  let loading_phase = ref true in
-  let load_end = Eio.Condition.create () in
-  let set () = loading_phase := true in
-  let in_onload () = !loading_phase in
-  let broadcast_load_end () =
-    loading_phase := false;
-    Eio.Condition.broadcast load_end
-  in
-  let wait_load_end () =
-    if !loading_phase then Eio.Condition.await_no_mutex load_end else ()
-  in
-  in_onload, broadcast_load_end, wait_load_end, set
+(* For synchronization during page loading.
+   We use a simple boolean flag instead of Eio.Mutex because:
+   1. Eio.Mutex operations require being inside an Eio fiber
+   2. The original Lwt code used a mutex that was locked at module init time
+   3. We only need to track "loading in progress" state, not actual mutual exclusion *)
+let load_mutex_locked = ref true  (* Start locked, like the Lwt version *)
+
+let loading_phase = ref true
+let load_end = lazy (Eio.Condition.create ())
+
+let in_onload () = !loading_phase
+
+let set_loading_phase () = loading_phase := true
+
+let broadcast_load_end () =
+  loading_phase := false;
+  if Lazy.is_val load_end then Eio.Condition.broadcast (Lazy.force load_end)
+
+let wait_load_end () =
+  if !loading_phase then Eio.Condition.await_no_mutex (Lazy.force load_end) else ()
+
+(* Expose the lock state for eliom_client.client.ml *)
+let lock_load_mutex () = load_mutex_locked := true
+let unlock_load_mutex () = load_mutex_locked := false
+let is_load_mutex_locked () = !load_mutex_locked
 
 (* == Helper's functions for Eliom's event handler.
 
diff --git a/src/lib/eliom_comet.client.ml b/src/lib/eliom_comet.client.ml
index c99958f7c1..e69bd95645 100644
--- a/src/lib/eliom_comet.client.ml
+++ b/src/lib/eliom_comet.client.ml
@@ -1,5 +1,6 @@
 open Eio.Std
 
+
 (* Ocsigen
  * http://www.ocsigen.org
  * Copyright (C) 2010-2011
@@ -83,23 +84,27 @@ module Configuration = struct
         configuration_table
         (first_conf configuration_table)
 
-  let update_configuration_waiter, update_configuration_waker =
-    let t, u =
-      Promise.create
-        ()
-    in
-    ref t, ref u
+  (* Initialized lazily to avoid calling Promise.create at toplevel *)
+  let update_configuration_waiter = ref None
+  let update_configuration_waker = ref None
+
+  let get_configuration_waiter () =
+    match !update_configuration_waiter, !update_configuration_waker with
+    | Some t, Some u -> t, u
+    | _ ->
+        let t, u = Promise.create () in
+        update_configuration_waiter := Some t;
+        update_configuration_waker := Some u;
+        t, u
 
   let update_configuration () =
     global_configuration := get_configuration ();
-    let t, u =
-      Promise.create
-        ()
-    in
-    update_configuration_waiter := t;
-    let wakener = !update_configuration_waker in
-    update_configuration_waker := u;
-    Promise.resolve wakener ()
+    (* Get the old waker BEFORE creating the new promise *)
+    let _old_waiter, old_waker = get_configuration_waiter () in
+    let t, u = Promise.create () in
+    update_configuration_waiter := Some t;
+    update_configuration_waker := Some u;
+    ignore (Eio.Promise.try_resolve old_waker ())
 
   let get () = !global_configuration
 
@@ -168,7 +173,7 @@ module Configuration = struct
       let () =
         Fiber.any
           [ (fun () -> Js_of_ocaml_eio.Eio_js.sleep t)
-          ; (fun () -> Promise.await !update_configuration_waiter)
+          ; (fun () -> Promise.await (fst (get_configuration_waiter ())))
           ; active_waiter ]
       in
       let remaining_time = sleep_duration () -. (Sys.time () -. time) in
@@ -293,7 +298,7 @@ end = struct
           hd.hd_activity.active_waiter <- t;
           let wakener = hd.hd_activity.active_wakener in
           hd.hd_activity.active_wakener <- u;
-          Promise.resolve_ok wakener ()
+          ignore (Eio.Promise.try_resolve wakener (Ok ()))
 
   let is_active hd = hd.hd_activity.active
 
@@ -366,7 +371,7 @@ end = struct
     act.restart_waiter <- t;
     let wakener = act.restart_wakener in
     act.restart_wakener <- u;
-    Eio.Promise.resolve_error wakener Restart;
+    ignore (Eio.Promise.try_resolve wakener (Error Restart));
     activate hd
 
   let max_retries = 10
@@ -562,14 +567,18 @@ end = struct
     update_activity hd; aux 0
 
   let call_commands {hd_service = Ecb.Comet_service (srv, queue); _} command =
-    ignore
-      (try
-         call_service_after_load_end srv queue
-           (false, Ecb.Stateful (Ecb.Commands command))
-       with exn ->
-         Logs.app ~src:section (fun fmt ->
-           fmt ("request failed" ^^ "@\n%s") (Printexc.to_string exn));
-         "")
+    (* Use fork to run the HTTP request in an Eio context.
+       This is necessary because call_commands may be called during
+       unwrapping which happens outside of an Eio fiber. *)
+    Eliom_lib.fork (fun () ->
+      ignore
+        (try
+           call_service_after_load_end srv queue
+             (false, Ecb.Stateful (Ecb.Commands command))
+         with exn ->
+           Logs.app ~src:section (fun fmt ->
+             fmt ("request failed" ^^ "@\n%s") (Printexc.to_string exn));
+           ""))
 
   let close hd chan_id =
     match hd.hd_state with
diff --git a/src/lib/eliom_comet.server.ml b/src/lib/eliom_comet.server.ml
index 374a5d29a2..4fa062262b 100644
--- a/src/lib/eliom_comet.server.ml
+++ b/src/lib/eliom_comet.server.ml
@@ -196,7 +196,10 @@ end = struct
     with Finished l -> l
 
   let get_available_data = function
-    | Eliom_lib.Right ch_id -> [ch_id, Eliom_comet_base.Closed]
+    | Eliom_lib.Right ch_id ->
+        Logs.warn ~src:section (fun fmt ->
+          fmt "Stateless channel not found, sending Closed: %s" ch_id);
+        [ch_id, Eliom_comet_base.Closed]
     | Eliom_lib.Left (channel, position) -> (
       match position with
       (* the first request of the client should be with i = 1 *)
@@ -552,7 +555,7 @@ end = struct
                   if messages <> [] || idle
                   then messages
                   else
-                    let () = wait_data (wait_closed_connection ()) handler in
+                    let () = wait_data wait_closed_connection handler in
                     read_channels 100 handler
                 in
                 let message = encode_downgoing messages in
@@ -642,6 +645,8 @@ end = struct
           ; hd_activity = Inactive (Unix.gettimeofday ()) }
         in
         Eliom_reference.Volatile.set eref (Some handler);
+        Logs.info ~src:section (fun fmt ->
+          fmt "Creating new comet handler and registering service for scope");
         run_handler handler;
         handler
 
diff --git a/src/lib/eliom_lib.client.ml b/src/lib/eliom_lib.client.ml
index 3afa0cbaa4..f343fd293b 100644
--- a/src/lib/eliom_lib.client.ml
+++ b/src/lib/eliom_lib.client.ml
@@ -204,11 +204,15 @@ end
 
 let fork = Js_of_ocaml_eio.Eio_js.start
 
+(* fork_promise launches f in a new Eio fiber and returns a promise for its result.
+   The promise is created before entering the Eio context so it can be returned
+   immediately. Eio.Promise.create() does NOT use Get_context effect - it only
+   uses Trace.mint_id and Broadcast.create which are pure operations. *)
 let fork_promise f =
   let p, u = Eio.Promise.create () in
   Js_of_ocaml_eio.Eio_js.start (fun () ->
     try
       let v = f () in
-      Eio.Promise.resolve_ok u v
-    with e -> Eio.Promise.resolve_error u e);
+      ignore (Eio.Promise.try_resolve u (Ok v))
+    with e -> ignore (Eio.Promise.try_resolve u (Error e)));
   p
diff --git a/src/lib/eliom_mkreg.server.ml b/src/lib/eliom_mkreg.server.ml
index c3c2700bf9..49ab77db72 100644
--- a/src/lib/eliom_mkreg.server.ml
+++ b/src/lib/eliom_mkreg.server.ml
@@ -145,7 +145,8 @@ let send_with_cookies
         (Eliommod_cookies.cookieset_to_json tab_cookies)
     in
     {response with Cohttp.Response.headers}
-  and cookies =
+  in
+  let cookies =
     Ocsigen_cookie_map.add_multi
       (Eliom_request_info.get_user_cookies ())
       (Ocsigen_response.cookies result)
diff --git a/src/lib/eliom_react.client.ml b/src/lib/eliom_react.client.ml
index a7903711df..e2da309a8f 100644
--- a/src/lib/eliom_react.client.ml
+++ b/src/lib/eliom_react.client.ml
@@ -47,15 +47,24 @@ module Down = struct
        in Eliom_comet. For example Channel_full. *)
     (* We transform the stream into a stream with exception: *)
     let stream = Eliom_stream.wrap_exn channel in
+    (* Create the event outside of Eio context *)
+    let event, push = React.E.create () in
+    (* Start the fiber that will push events - this must be inside Eio_js.start *)
     Js_of_ocaml_eio.Eio_js.start (fun () ->
-      Eliom_stream.iter_s
-        (function
-          | Error exn ->
-              let () = handle_react_exn ~exn () in
-              raise exn
-          | Ok () -> ())
-        stream);
-    E.of_stream channel
+      try
+        Eliom_stream.iter_s
+          (function
+            | Error exn ->
+                let () = handle_react_exn ~exn () in
+                raise exn
+            | Ok () -> ())
+          stream
+      with Eliom_comet.Channel_closed -> ());
+    (* Start another fiber to read from the channel and push to the event *)
+    Js_of_ocaml_eio.Eio_js.start (fun () ->
+      try Eliom_stream.iter push channel
+      with Eliom_comet.Channel_closed -> ());
+    event
 
   let () =
     Eliom_unwrap.register_unwrapper Eliom_common.react_down_unwrap_id
@@ -79,8 +88,13 @@ module S = struct
     type 'a t = 'a React.S.t
 
     let internal_unwrap (channel, value, _unwrapper) =
-      let e = E.of_stream channel in
-      S.hold ~eq:(fun _ _ -> false) value e
+      (* Create the event outside of Eio context *)
+      let event, push = React.E.create () in
+      (* Start the fiber to read from the channel - inside Eio_js.start *)
+      Js_of_ocaml_eio.Eio_js.start (fun () ->
+        try Eliom_stream.iter push channel
+        with Eliom_comet.Channel_closed -> ());
+      S.hold ~eq:(fun _ _ -> false) value event
 
     let () =
       Eliom_unwrap.register_unwrapper Eliom_common.signal_down_unwrap_id
diff --git a/src/lib/eliom_registration.server.ml b/src/lib/eliom_registration.server.ml
index 15e55cbd54..8a9dac33a4 100644
--- a/src/lib/eliom_registration.server.ml
+++ b/src/lib/eliom_registration.server.ml
@@ -55,7 +55,12 @@ let result_of_content ?charset ?content_type ?headers ?status body =
       (Ocsigen_header.of_option headers)
       "cache-control" "no-cache"
   in
-  let response = Cohttp.Response.make ?status ~headers () in
+  (* Pass the body's encoding to Response.make to ensure headers match the actual
+     body encoding. Without this, Response.make defaults to Chunked when encoding
+     is Unknown, but the body may have Fixed encoding, causing the chunk terminator
+     to not be sent. *)
+  let encoding = Ocsigen_response.Body.transfer_encoding body in
+  let response = Cohttp.Response.make ?status ~encoding ~headers () in
   Ocsigen_response.make ~body response
 
 module Result_types : sig
@@ -1151,8 +1156,9 @@ module App_base (App_param : Eliom_registration_sigs.APP_PARAM) = struct
         Cohttp.Header.replace h Eliom_common_base.response_url_header
           (Polytables.get ~table ~key:Eliom_mkreg.suffix_redir_uri_key)
       with Not_found -> h
-    and status = Eliom_lib.Option.map Cohttp.Code.status_of_code code
-    and content_type = content_type_html content_type in
+    in
+    let status = Eliom_lib.Option.map Cohttp.Code.status_of_code code in
+    let content_type = content_type_html content_type in
     result_of_content ?charset ?status ~content_type ~headers body
 end
 
diff --git a/src/lib/eliom_request.client.ml b/src/lib/eliom_request.client.ml
index 7f98c85638..52310fdd1f 100644
--- a/src/lib/eliom_request.client.ml
+++ b/src/lib/eliom_request.client.ml
@@ -274,11 +274,12 @@ let send
           ()
       in
       (if not @@ React.S.value locked
-       then Promise.resolve unlock ()
+       then ignore (Eio.Promise.try_resolve unlock ())
        else
          let unlock_event = React.E.once @@ React.S.changes locked in
          Dom_reference.retain_generic wait_for_unlock
-           ~keep:(React.E.map (fun _ -> Promise.resolve unlock ()) unlock_event));
+           ~keep:(React.E.map (fun _ ->
+             ignore (Eio.Promise.try_resolve unlock ())) unlock_event));
       let () = Promise.await wait_for_unlock in
       (if Js.Optdef.test Js.Unsafe.global##.___eliom_use_cookie_substitutes_
        then
diff --git a/src/lib/eliom_route.server.ml b/src/lib/eliom_route.server.ml
index 5a1a17f6a9..ecc02d2843 100644
--- a/src/lib/eliom_route.server.ml
+++ b/src/lib/eliom_route.server.ml
@@ -67,21 +67,29 @@ include Eliom_route_base.Make (struct
     let get_number_of_reloads () = Ocsigen_extensions.get_numberofreloads ()
   end)
 
+(* Use Option to avoid immediate evaluation of raise as initial value.
+   In direct-style (Eio), (raise X) as a function argument is evaluated immediately,
+   unlike Lwt where Lwt.fail X returns a value. *)
 let find_aux now sitedata info _ sci : Ocsigen_response.t =
-  Eliom_common.Full_state_name_table.fold
-    (fun fullsessname (_, r) beg ->
-       try beg with
-       | Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter -> (
-         match !r with
-         | Eliom_common.SCData_session_expired
-         | Eliom_common.SCNo_data (* cookie removed *) ->
-             beg
-         | Eliom_common.SC c ->
-             find_service now !(c.Eliom_common.sc_table) (Some fullsessname)
-               sitedata info)
-       | e -> raise e)
-    sci
-    (raise Eliom_common.Eliom_404)
+  let result =
+    Eliom_common.Full_state_name_table.fold
+      (fun fullsessname (_, r) acc ->
+         match acc with
+         | Some _ -> acc
+         | None ->
+             match !r with
+             | Eliom_common.SCData_session_expired
+             | Eliom_common.SCNo_data ->
+                 None
+             | Eliom_common.SC c ->
+                 (try Some (find_service now !(c.Eliom_common.sc_table) (Some fullsessname) sitedata info)
+                  with Eliom_common.Eliom_404 | Eliom_common.Eliom_Wrong_parameter -> None))
+      sci
+      None
+  in
+  match result with
+  | Some response -> response
+  | None -> raise Eliom_common.Eliom_404
 
 let session_tables {Eliom_common.all_cookie_info; tab_cookie_info; _} =
   let (service_cookies_info, _, _), (secure_service_cookies_info, _, _) =
@@ -114,12 +122,7 @@ let get_page
   in
   try
     try_page Eliom_common.Eliom_404
-      (fun (table, table_name) ->
-         Logs.info ~src:section (fun fmt ->
-           fmt "Looking for %s in the %s:"
-             (Url.string_of_url_path ~encode:true
-                (Ocsigen_request.sub_path ri.request_info))
-             table_name);
+      (fun (table, _table_name) ->
          find_aux now sitedata info Eliom_common.Eliom_404 table)
       tables
   with
diff --git a/src/lib/eliom_shared.eliom b/src/lib/eliom_shared.eliom
index aa0fc39cc3..054f7650cb 100644
--- a/src/lib/eliom_shared.eliom
+++ b/src/lib/eliom_shared.eliom
@@ -160,7 +160,7 @@ module%client ReactiveData = struct
             (Promise.create
                ())
         in
-        Promise.resolve (snd !waiter) ();
+        ignore (Eio.Promise.try_resolve (snd !waiter) ());
         React.E.map
           (fun msg ->
              Eliom_lib.fork (fun () ->
@@ -177,7 +177,7 @@ module%client ReactiveData = struct
                | ReactiveData.RList.Set s -> ReactiveData.RList.set rhandle s
                | ReactiveData.RList.Patch p ->
                    ReactiveData.RList.patch rhandle p);
-               Promise.resolve (snd new_waiter) ()))
+               ignore (Eio.Promise.try_resolve (snd new_waiter) ())))
           event
 
       (** Same as map_p but we do not compute the initial list.
diff --git a/src/lib/eliom_stream.shared.ml b/src/lib/eliom_stream.shared.ml
index 8ba38b25c4..1be0a31c9f 100644
--- a/src/lib/eliom_stream.shared.ml
+++ b/src/lib/eliom_stream.shared.ml
@@ -174,10 +174,10 @@ let create_with_reference () =
       source.push_signal <- new_waiter;
       push_signal_resolver := new_push_signal_resolver;
       (* Signal that a new value has been received. *)
-      Promise.resolve_ok old_push_signal_resolver ());
+      ignore (Eio.Promise.try_resolve old_push_signal_resolver (Ok ())));
     (* Do this at the end in case one of the function raise an
        exception. *)
-    if x = None then Promise.resolve close ()
+    if x = None then ignore (Eio.Promise.try_resolve close ())
   in
   t, push, fun x -> source.push_external <- Obj.repr x
 
@@ -237,7 +237,7 @@ let notify_pusher info last =
   in
   info.pushb_push_waiter <- waiter;
   info.pushb_push_wakener <- wakener;
-  Promise.resolve_ok old_wakener ()
+  ignore (Eio.Promise.try_resolve old_wakener (Ok ()))
 
 class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
   object
@@ -286,7 +286,7 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
           info.pushb_signal <- new_waiter;
           wakener_cell := new_wakener;
           (* Signal that a new value has been received. *)
-          Eio.Promise.resolve_ok old_wakener ()))
+          ignore (Eio.Promise.try_resolve old_wakener (Ok ()))))
 
     method close =
       if not closed
@@ -299,7 +299,7 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
         if info.pushb_pending <> None
         then (
           info.pushb_pending <- None;
-          Eio.Promise.resolve_error info.pushb_push_wakener Closed);
+          ignore (Eio.Promise.try_resolve info.pushb_push_wakener (Error Closed)));
         (* Send a signal if at least one thread is waiting for a new
          element. *)
         if info.pushb_waiting
@@ -307,8 +307,9 @@ class ['a] bounded_push_impl (info : 'a push_bounded) wakener_cell last close =
           info.pushb_waiting <- false;
           let old_wakener = !wakener_cell in
           (* Signal that a new value has been received. *)
-          Eio.Promise.resolve_ok old_wakener ());
-        Eio.Promise.resolve close ())
+          ignore (Eio.Promise.try_resolve old_wakener (Ok ())));
+        (* close is only resolved here and closed boolean prevents double call *)
+        ignore (Eio.Promise.try_resolve close ()))
 
     method count = info.pushb_count
     method blocked = info.pushb_pending <> None
@@ -359,9 +360,9 @@ let feed s =
             let x = from.from_create () in
             (* Push the element to the end of the queue. *)
             enqueue x s;
-            if x = None then Eio.Promise.resolve s.close ();
-            Eio.Promise.resolve_ok wakener ()
-          with exn -> Eio.Promise.resolve_error wakener exn);
+            if x = None then ignore (Eio.Promise.try_resolve s.close ());
+            ignore (Eio.Promise.try_resolve wakener (Ok ()))
+          with exn -> ignore (Eio.Promise.try_resolve wakener (Error exn)));
         (* Allow other threads to access this promise: *)
         from.from_promise <- promise;
         promise (*XXX protected *)
@@ -369,7 +370,7 @@ let feed s =
       let x = f () in
       (* Push the element to the end of the queue. *)
       enqueue x s;
-      if x = None then Eio.Promise.resolve s.close ();
+      if x = None then ignore (Eio.Promise.try_resolve s.close ());
       Eio.Promise.create_resolved (Ok ())
   | Push push ->
       push.push_waiting <- true;
diff --git a/src/lib/eliom_unwrap.client.ml b/src/lib/eliom_unwrap.client.ml
index efa21eb347..0b0848ceb4 100644
--- a/src/lib/eliom_unwrap.client.ml
+++ b/src/lib/eliom_unwrap.client.ml
@@ -71,10 +71,26 @@ let apply_unwrapper unwrapper v =
 
 let late_unwrap_value old_value new_value =
   let old_value = Obj.repr old_value in
-  List.iter
-    (fun {parent; field} ->
-       Obj.set_field parent (field - 1) (Obj.repr new_value))
-    (Obj.obj (Obj.field (Obj.field old_value (Obj.size old_value - 1)) 2))
+  (* Only process if the value is a block with the late-unwrap marker structure.
+     The late-unwrap marker is stored in the last field and should be
+     a block with at least 3 fields (tag, unwrapper_id, mark, occurrences).
+     If the value doesn't have this structure, there are no occurrences
+     to update, so we can skip. *)
+  if Obj.is_block old_value then begin
+    let size = Obj.size old_value in
+    if size >= 1 then begin
+      let last_field = Obj.field old_value (size - 1) in
+      (* Check that last_field is defined (not undefined in JS) before proceeding *)
+      if not (Js.Optdef.test (Obj.magic last_field)) then ()
+      else if Obj.is_block last_field && Obj.size last_field >= 3 then
+        (* This looks like a late-unwrap marker, process the occurrences *)
+        List.iter
+          (fun {parent; field} ->
+             Obj.set_field parent (field - 1) (Obj.repr new_value))
+          (Obj.obj (Obj.field last_field 2))
+      (* else: no late-unwrap marker, nothing to update *)
+    end
+  end
 
 external raw_unmarshal_and_unwrap :
    (unwrapper -> _ -> _ option)
diff --git a/src/lib/server/eliommod_pagegen.ml b/src/lib/server/eliommod_pagegen.ml
index 5929bc2d61..5ff98120ec 100644
--- a/src/lib/server/eliommod_pagegen.ml
+++ b/src/lib/server/eliommod_pagegen.ml
@@ -317,7 +317,8 @@ let gen_req_not_found ~is_eliom_extension ~sitedata ~previous_extension_err ~req
               Do not try the following extensions.
           *)
           Ocsigen_extensions.Ext_found_stop (fun () -> res)
-        with Not_found -> Ocsigen_extensions.Ext_found (fun () -> res)
+        with Not_found ->
+          Ocsigen_extensions.Ext_found (fun () -> res)
       with
       (* FIXME COHTTP transition ; restore all that *)
       | Eliom_common.Eliom_Typing_Error l ->