diff --git a/.github/workflows/ci-interpreter.yml b/.github/workflows/ci-interpreter.yml
index 91a5fc42..63afd8c8 100644
--- a/.github/workflows/ci-interpreter.yml
+++ b/.github/workflows/ci-interpreter.yml
@@ -33,4 +33,4 @@ jobs:
       - name: Run tests
         # TODO: reactiate node once it supports all of Wasm 3.0
         # run: cd interpreter && opam exec make JS=node ci
-        run: cd interpreter && opam exec make ci
+        run: cd interpreter && opam exec make test
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 84118817..f8898a87 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -180,6 +180,7 @@ let heap_type s =
     (fun s -> VarHT (var_type s33 s));
     (fun s ->
       match s7 s with
+      | -0x0b -> NoContHT
       | -0x0c -> NoExnHT
       | -0x0d -> NoFuncHT
       | -0x0e -> NoExternHT
@@ -192,6 +193,7 @@ let heap_type s =
       | -0x15 -> StructHT
       | -0x16 -> ArrayHT
       | -0x17 -> ExnHT
+      | -0x18 -> ContHT
       | _ -> error s pos "malformed heap type"
     )
   ] s
@@ -199,6 +201,7 @@ let heap_type s =
 let ref_type s =
   let pos = pos s in
   match s7 s with
+  | -0x0b -> (Null, NoContHT)
   | -0x0c -> (Null, NoExnHT)
   | -0x0d -> (Null, NoFuncHT)
   | -0x0e -> (Null, NoExternHT)
@@ -211,6 +214,7 @@ let ref_type s =
   | -0x15 -> (Null, StructHT)
   | -0x16 -> (Null, ArrayHT)
   | -0x17 -> (Null, ExnHT)
+  | -0x18 -> (Null, ContHT)
   | -0x1c -> (NoNull, heap_type s)
   | -0x1d -> (Null, heap_type s)
   | _ -> error s pos "malformed reference type"
@@ -253,11 +257,15 @@ let func_type s =
   let ts2 = result_type s in
   FuncT (ts1, ts2)
 
+let cont_type s =
+  ContT (heap_type s)
+
 let str_type s =
   match s7 s with
   | -0x20 -> DefFuncT (func_type s)
   | -0x21 -> DefStructT (struct_type s)
   | -0x22 -> DefArrayT (array_type s)
+  | -0x23 -> DefContT (cont_type s) (* TODO(dhil): See comment in encode.ml *)
   | _ -> error s (pos s - 1) "malformed definition type"
 
 let sub_type s =
@@ -293,14 +301,15 @@ let memory_type s =
   let lim = limits u32 s in
   MemoryT lim
 
+let tag_type s =
+  zero s;
+  at var s
+
 let global_type s =
   let t = val_type s in
   let mut = mutability s in
   GlobalT (mut, t)
 
-let tag_type s =
-  zero s; at var s
-
 
 (* Instructions *)
 
@@ -340,6 +349,16 @@ let locals s =
     s pos "too many locals";
   List.flatten (List.map (Lib.Fun.uncurry Lib.List32.make) nts)
 
+let on_clause s =
+  match byte s with
+  | 0x00 ->
+    let x = at var s in
+    let y = at var s in
+    (x, OnLabel y)
+  | 0x01 ->
+    let x = at var s in
+    (x, OnSwitch)
+  | _ -> error s (pos s) "ON opcode expected"
 
 let rec instr s =
   let pos = pos s in
@@ -399,7 +418,10 @@ let rec instr s =
   | 0x14 -> call_ref (at var s)
   | 0x15 -> return_call_ref (at var s)
 
-  | 0x16 | 0x17 | 0x18 | 0x19 as b -> illegal s pos b
+  | (0x16 | 0x17) as b -> illegal s pos b
+
+  | 0x18 -> error s pos "misplaced DELEGATE opcode"
+  | 0x19 -> error s pos "misplaced CATCH_ALL opcode"
 
   | 0x1a -> drop
   | 0x1b -> select None
@@ -607,6 +629,26 @@ let rec instr s =
   | 0xd5 -> br_on_null (at var s)
   | 0xd6 -> br_on_non_null (at var s)
 
+  | 0xe0 -> cont_new (at var s)
+  | 0xe1 ->
+    let x = at var s in
+    let y = at var s in
+    cont_bind x y
+  | 0xe2 -> suspend (at var s)
+  | 0xe3 ->
+    let x = at var s in
+    let xls = vec on_clause s in
+    resume x xls
+  | 0xe4 ->
+    let x   = at var s in
+    let tag = at var s in
+    let xls = vec on_clause s in
+    resume_throw x tag xls
+  | 0xe5 ->
+    let x = at var s in
+    let y = at var s in
+    switch x y
+
   | 0xfb as b ->
     (match u32 s with
     | 0x00l -> struct_new (at var s)
@@ -971,11 +1013,11 @@ let rec instr s =
 and instr_block s = List.rev (instr_block' s [])
 and instr_block' s es =
   match peek s with
-  | None | Some (0x05 | 0x0b) -> es
+  | None | Some (0x05 | 0x07 | 0x0b | 0x19) -> es
   | _ ->
     let pos = pos s in
     let e' = instr s in
-    instr_block' s ((e' @@ region s pos pos) :: es)
+    instr_block' s (Source.(e' @@ region s pos pos) :: es)
 
 and catch s =
   match byte s with
@@ -1045,7 +1087,7 @@ let import_desc s =
   | 0x01 -> TableImport (table_type s)
   | 0x02 -> MemoryImport (memory_type s)
   | 0x03 -> GlobalImport (global_type s)
-  | 0x04 -> TagImport (tag_type s)
+  | 0x04 -> TagImport (at var s)
   | _ -> error s (pos s - 1) "malformed import kind"
 
 let import s =
@@ -1106,6 +1148,7 @@ let tag_section s =
   section Custom.Tag (vec (at tag)) [] s
 
 
+
 (* Global section *)
 
 let global s =
@@ -1336,7 +1379,6 @@ let module_ s =
     imports; exports; elems; datas; start },
   customs
 
-
 let decode_custom m bs custom =
   let open Source in
   let Custom.{name; content; place} = custom.it in
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 072c3512..31e6340a 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -130,6 +130,8 @@ struct
     | NoExnHT -> s7 (-0x0c)
     | ExternHT -> s7 (-0x11)
     | NoExternHT -> s7 (-0x0e)
+    | ContHT -> s7 (-0x18)
+    | NoContHT -> s7 (-0x0b)
     | VarHT x -> var_type s33 x
     | DefHT _ | BotHT -> assert false
 
@@ -150,6 +152,8 @@ struct
     | (Null, NoExnHT) -> s7 (-0x0c)
     | (Null, ExternHT) -> s7 (-0x11)
     | (Null, NoExternHT) -> s7 (-0x0e)
+    | (Null, ContHT) -> s7 (-0x18)
+    | (Null, NoContHT) -> s7 (-0x0b)
     | (Null, t) -> s7 (-0x1d); heap_type t
     | (NoNull, t) -> s7 (-0x1c); heap_type t
 
@@ -180,10 +184,17 @@ struct
   let func_type = function
     | FuncT (ts1, ts2) -> vec val_type ts1; vec val_type ts2
 
+  let cont_type = function
+    | ContT ht -> heap_type ht
+
   let str_type = function
     | DefStructT st -> s7 (-0x21); struct_type st
     | DefArrayT at -> s7 (-0x22); array_type at
     | DefFuncT ft -> s7 (-0x20); func_type ft
+    | DefContT ct -> s7 (-0x23); cont_type ct
+    (* TODO(dhil): This might need to change again in the future as a
+       different proposal might claim this opcode! GC proposal claimed
+       the previous opcode we were using. *)
 
   let sub_type = function
     | SubT (Final, [], st) -> str_type st
@@ -206,9 +217,7 @@ struct
   let global_type = function
     | GlobalT (mut, t) -> val_type t; mutability mut
 
-  let tag_type x =
-    u32 0x00l; var x
-
+  let tag_type x = u32 0x00l; var x
 
   (* Expressions *)
 
@@ -245,6 +254,16 @@ struct
       | nlocs -> (1, loc) :: nlocs
     in vec local (List.fold_right combine locs [])
 
+  let on_clause (x, y) =
+    match y with
+    | OnSwitch ->
+       byte 0x01; var x
+    | OnLabel y ->
+       byte 0x00; var x; var y
+
+  let resumetable xls =
+    vec on_clause xls
+
   let rec instr e =
     match e.it with
     | Unreachable -> op 0x00
@@ -278,6 +297,13 @@ struct
     | ReturnCallRef x -> op 0x15; var x
     | ReturnCallIndirect (x, y) -> op 0x13; var y; var x
 
+    | ContNew x -> op 0xe0; var x
+    | ContBind (x, y) -> op 0xe1; var x; var y
+    | Suspend x -> op 0xe2; var x
+    | Resume (x, xls) -> op 0xe3; var x; resumetable xls
+    | ResumeThrow (x, y, xls) -> op 0xe4; var x; var y; resumetable xls
+    | Switch (x, y) -> op 0xe5; var x; var y
+
     | Throw x -> op 0x08; var x
     | ThrowRef -> op 0x0a
 
@@ -925,7 +951,7 @@ struct
     | TableImport t -> byte 0x01; table_type t
     | MemoryImport t -> byte 0x02; memory_type t
     | GlobalImport t -> byte 0x03; global_type t
-    | TagImport t -> byte 0x04; tag_type t
+    | TagImport t -> byte 0x04; var t
 
   let import im =
     let {module_name; item_name; idesc} = im.it in
@@ -966,14 +992,6 @@ struct
     section 5 (vec memory) mems (mems <> [])
 
 
-  (* Tag section *)
-
-  let tag (t : tag) = byte 0x00; var t.it.tgtype
-
-  let tag_section ts =
-    section 13 (vec tag) ts (ts <> [])
-
-
   (* Global section *)
 
   let global g =
@@ -983,6 +1001,12 @@ struct
   let global_section gs =
     section 6 (vec global) gs (gs <> [])
 
+  (* Tag section *)
+  let tag tag =
+    tag_type tag.it.tgtype
+
+  let tag_section ts =
+    section 13 (vec tag) ts (ts <> [])
 
   (* Export section *)
 
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index b04cb5db..8bac5a31 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -9,16 +9,18 @@ open Instance
 (* Errors *)
 
 module Link = Error.Make ()
-module Exception = Error.Make ()
 module Trap = Error.Make ()
-module Crash = Error.Make ()
+module Exception = Error.Make ()
+module Suspension = Error.Make ()
 module Exhaustion = Error.Make ()
+module Crash = Error.Make ()
 
 exception Link = Link.Error
-exception Exception = Exception.Error
 exception Trap = Trap.Error
-exception Crash = Crash.Error (* failure that cannot happen in valid code *)
+exception Exception = Exception.Error
+exception Suspension = Suspension.Error
 exception Exhaustion = Exhaustion.Error
+exception Crash = Crash.Error (* failure that cannot happen in valid code *)
 
 let table_error at = function
   | Table.Bounds -> "out of bounds table access"
@@ -45,7 +47,7 @@ let numeric_error at = function
   | exn -> raise exn
 
 
-(* Administrative Expressions & Configurations *)
+(* Administrative Expressions & Continuations *)
 
 type 'a stack = 'a list
 
@@ -70,6 +72,40 @@ and admin_instr' =
   | Label of int * instr list * code
   | Frame of int * frame * code
   | Handler of int * catch list * code
+  | Handle of handle_table * code
+  | Suspending of tag_inst * value stack * ref_ option * ctxt
+
+and ctxt = code -> code
+and handle_table = (tag_inst * idx) list * tag_inst list
+
+type cont = int32 * ctxt  (* TODO: represent type properly *)
+type ref_ += ContRef of cont option ref
+
+let () =
+  let type_of_ref' = !Value.type_of_ref' in
+  Value.type_of_ref' := function
+    | ContRef _ -> ContHT
+    | r -> type_of_ref' r
+
+let () =
+  let string_of_ref' = !Value.string_of_ref' in
+  Value.string_of_ref' := function
+    | ContRef _ -> "cont"
+    | r -> string_of_ref' r
+
+let plain e = Plain e.it @@ e.at
+
+let is_jumping e =
+  match e.it with
+  | Returning _ | ReturningInvoke _ | Breaking _
+  | Throwing _ | Trapping _ | Suspending _ -> true
+  | _ -> false
+
+
+let compose (vs1, es1) (vs2, es2) = vs1 @ vs2, es1 @ es2
+
+
+(* Configurations *)
 
 type config =
 {
@@ -82,20 +118,12 @@ let frame inst locals = {inst; locals}
 let config inst vs es =
   {frame = frame inst []; code = vs, es; budget = !Flags.budget}
 
-let plain e = Plain e.it @@ e.at
-
 let admin_instr_of_value (v : value) at : admin_instr' =
   match v with
   | Num n -> Plain (Const (n @@ at))
   | Vec v -> Plain (VecConst (v @@ at))
   | Ref r -> Refer r
 
-let is_jumping e =
-  match e.it with
-  | Returning _ | ReturningInvoke _ | Breaking _
-  | Throwing _ | Trapping _ -> true
-  | _ -> false
-
 let lookup category list x =
   try Lib.List32.nth list x.it with Failure _ ->
     Crash.error x.at ("undefined " ^ category ^ " " ^ Int32.to_string x.it)
@@ -104,8 +132,8 @@ let type_ (inst : module_inst) x = lookup "type" inst.types x
 let func (inst : module_inst) x = lookup "function" inst.funcs x
 let table (inst : module_inst) x = lookup "table" inst.tables x
 let memory (inst : module_inst) x = lookup "memory" inst.memories x
-let tag (inst : module_inst) x = lookup "tag" inst.tags x
 let global (inst : module_inst) x = lookup "global" inst.globals x
+let tag (inst : module_inst) x = lookup "tag" inst.tags x
 let elem (inst : module_inst) x = lookup "element segment" inst.elems x
 let data (inst : module_inst) x = lookup "data segment" inst.datas x
 let local (frame : frame) x = lookup "local" frame.locals x
@@ -114,6 +142,7 @@ let str_type (inst : module_inst) x = expand_def_type (type_ inst x)
 let func_type (inst : module_inst) x = as_func_str_type (str_type inst x)
 let struct_type (inst : module_inst) x = as_struct_str_type  (str_type inst x)
 let array_type (inst : module_inst) x = as_array_str_type (str_type inst x)
+let cont_type (inst : module_inst) x = as_cont_str_type (str_type inst x)
 
 let subst_of (inst : module_inst) = function
   | StatX x when x < Lib.List32.length inst.types ->
@@ -145,6 +174,24 @@ let drop n (vs : 'a stack) at =
 
 let split n (vs : 'a stack) at = take n vs at, drop n vs at
 
+let i32_split n (vs : 'a stack) at =
+  try
+    Lib.List32.take n vs, Lib.List32.drop n vs
+  with
+    Failure _ -> Crash.error at "stack underflow"
+
+let str_type_of_heap_type (inst : module_inst) ht : str_type =
+  match ht with
+  | VarHT (StatX x) -> str_type inst (x @@ Source.no_region)
+  | DefHT dt -> expand_def_type dt
+  | _ -> assert false
+
+let func_type_of_cont_type (inst : module_inst) (ContT ht) : func_type =
+  as_func_str_type (str_type_of_heap_type inst ht)
+
+let func_type_of_tag_type (_inst : module_inst) (TagT dt) : func_type =
+  as_func_str_type (expand_def_type dt)
+
 
 (* Evaluation *)
 
@@ -177,6 +224,24 @@ let array_oob a i n =
   I64.gt_u (I64.add (I64_convert.extend_i32_u i) (I64_convert.extend_i32_u n))
     (I64_convert.extend_i32_u (Aggr.array_length a))
 
+let handle_table (c : config) xls : handle_table =
+  let suspend =
+    List.filter_map
+      (fun (x, hdl) ->
+        match hdl with
+        | OnLabel l -> Some (tag c.frame.inst x, l)
+        | _ -> None)
+      xls
+  in
+  let switch =
+    List.filter_map
+      (fun (x, hdl) ->
+        match hdl with
+        | OnSwitch -> Some (tag c.frame.inst x)
+        | _ -> None)
+      xls
+  in
+  (suspend, switch)
 
 let rec step (c : config) : config =
   let vs, es = c.code in
@@ -185,7 +250,7 @@ let rec step (c : config) : config =
     match e.it, vs with
     | Plain e', vs ->
       (match e', vs with
-      | Unreachable, vs ->
+       | Unreachable, vs ->
         vs, [Trapping "unreachable executed" @@ e.at]
 
       | Nop, vs ->
@@ -272,12 +337,6 @@ let rec step (c : config) : config =
             string_of_def_type (type_ c.frame.inst y) ^ " but got " ^
             string_of_def_type (Func.type_of f)) @@ e.at]
 
-      | ReturnCall x, vs ->
-        (match (step {c with code = (vs, [Plain (Call x) @@ e.at])}).code with
-        | vs', [{it = Invoke a; at}] -> vs', [ReturningInvoke (vs', a) @@ at]
-        | _ -> assert false
-        )
-
       | ReturnCallRef _x, Ref (NullRef _) :: vs ->
         vs, [Trapping "null function reference" @@ e.at]
 
@@ -288,6 +347,81 @@ let rec step (c : config) : config =
         | _ -> assert false
         )
 
+      | ContNew x, Ref (NullRef _) :: vs ->
+        vs, [Trapping "null function reference" @@ e.at]
+
+      | ContNew x, Ref (FuncRef f) :: vs ->
+        let FuncT (ts, _) = as_func_str_type (expand_def_type (Func.type_of f)) in
+        let ctxt code = compose code ([], [Invoke f @@ e.at]) in
+        Ref (ContRef (ref (Some (Lib.List32.length ts, ctxt)))) :: vs, []
+
+      | ContBind (x, y), Ref (NullRef _) :: vs ->
+        vs, [Trapping "null continuation reference" @@ e.at]
+
+      | ContBind (x, y), Ref (ContRef {contents = None}) :: vs ->
+        vs, [Trapping "continuation already consumed" @@ e.at]
+
+      | ContBind (x, y), Ref (ContRef ({contents = Some (n, ctxt)} as cont)) :: vs ->
+        let ct = cont_type c.frame.inst y in
+        let ct = subst_cont_type (subst_of c.frame.inst) ct in
+        let FuncT (ts', _) = func_type_of_cont_type c.frame.inst ct in
+        let args, vs' =
+          try i32_split (I32.sub n (Lib.List32.length ts')) vs e.at
+          with Failure _ -> Crash.error e.at "type mismatch at continuation bind"
+        in
+        cont := None;
+        let ctxt' code = ctxt (compose code (args, [])) in
+        Ref (ContRef (ref (Some (I32.sub n (Lib.List32.length args), ctxt')))) :: vs', []
+
+      | Suspend x, vs ->
+        let tagt = tag c.frame.inst x in
+        let FuncT (ts, _) = func_type_of_tag_type c.frame.inst (Tag.type_of tagt) in
+        let args, vs' = i32_split (Lib.List32.length ts) vs e.at in
+        vs', [Suspending (tagt, args, None, fun code -> code) @@ e.at]
+
+      | Resume (x, xls), Ref (NullRef _) :: vs ->
+        vs, [Trapping "null continuation reference" @@ e.at]
+
+      | Resume (x, xls), Ref (ContRef {contents = None}) :: vs ->
+        vs, [Trapping "continuation already consumed" @@ e.at]
+
+      | Resume (x, xls), Ref (ContRef ({contents = Some (n, ctxt)} as cont)) :: vs ->
+        let hs = handle_table c xls in
+        let args, vs' = i32_split n vs e.at in
+        cont := None;
+        vs', [Handle (hs, ctxt (args, [])) @@ e.at]
+
+      | ResumeThrow (x, y, xls), Ref (NullRef _) :: vs ->
+        vs, [Trapping "null continuation reference" @@ e.at]
+
+      | ResumeThrow (x, y, xls), Ref (ContRef {contents = None}) :: vs ->
+        vs, [Trapping "continuation already consumed" @@ e.at]
+
+      | ResumeThrow (x, y, xls), Ref (ContRef ({contents = Some (n, ctxt)} as cont)) :: vs ->
+        let tagt = tag c.frame.inst y in
+        let FuncT (ts, _) = func_type_of_tag_type c.frame.inst (Tag.type_of tagt) in
+        let hs = handle_table c xls in
+        let args, vs' = i32_split (Lib.List32.length ts) vs e.at in
+        cont := None;
+        vs', [Handle (hs, ctxt ([], [Throwing (tagt, args) @@ e.at])) @@ e.at]
+
+      | Switch (x, y), Ref (NullRef _) :: vs ->
+         vs, [Trapping "null continuation reference" @@ e.at]
+
+      | Switch (x, y), Ref (ContRef {contents = None}) :: vs ->
+         vs, [Trapping "continuation already consumed" @@ e.at]
+
+      | Switch (x, y), Ref (ContRef {contents = Some (n, ctxt)} as cont) :: vs ->
+         let tagt = tag c.frame.inst y in
+         let args, vs' = i32_split (Int32.sub n 1l) vs e.at in
+         vs', [Suspending (tagt, args, Some cont, fun code -> code) @@ e.at]
+
+      | ReturnCall x, vs ->
+        (match (step {c with code = (vs, [Plain (Call x) @@ e.at])}).code with
+        | vs', [{it = Invoke a; at}] -> vs', [ReturningInvoke (vs', a) @@ at]
+        | _ -> assert false
+        )
+
       | ReturnCallIndirect (x, y), vs ->
         (match
           (step {c with code = (vs, [Plain (CallIndirect (x, y)) @@ e.at])}).code
@@ -299,8 +433,7 @@ let rec step (c : config) : config =
 
       | Throw x, vs ->
         let t = tag c.frame.inst x in
-        let TagT dt = Tag.type_of t in
-        let FuncT (ts, _) = as_func_str_type (expand_def_type dt) in
+        let FuncT (ts, _) = func_type_of_tag_type c.frame.inst (Tag.type_of t) in
         let n = List.length ts in
         let args, vs' = split n vs e.at in
         vs', [Throwing (t, args) @@ e.at]
@@ -653,7 +786,7 @@ let rec step (c : config) : config =
         let args, vs'' =
           match initop with
           | Explicit ->
-            let args, vs'' = split (List.length fts) vs' e.at in
+            let args, vs'' = i32_split (Lib.List32.length fts) vs' e.at in
             List.rev args, vs''
           | Implicit ->
             let ts = List.map unpacked_field_type fts in
@@ -702,7 +835,7 @@ let rec step (c : config) : config =
         in Ref (Aggr.ArrayRef array) :: vs'', []
 
       | ArrayNewFixed (x, n), vs' ->
-        let args, vs'' = split (I32.to_int_u n) vs' e.at in
+        let args, vs'' = i32_split n vs' e.at in
         let array =
           try Aggr.alloc_array (type_ c.frame.inst x) (List.rev args)
           with Failure _ -> Crash.error e.at "type mismatch packing value"
@@ -1014,6 +1147,13 @@ let rec step (c : config) : config =
     | Label (n, es0, (vs', [])), vs ->
       vs' @ vs, []
 
+    | Label (n, es0, (vs', {it = Suspending (tagt, vs1, contref, ctxt); at} :: es')), vs ->
+      let ctxt' code = [], [Label (n, es0, compose (ctxt code) (vs', es')) @@ e.at] in
+      vs, [Suspending (tagt, vs1, contref, ctxt') @@ at]
+
+    | Label (n, es0, (vs', {it = ReturningInvoke (vs0, f); at} :: es')), vs ->
+      vs, [ReturningInvoke (vs0, f) @@ at]
+
     | Label (n, es0, (vs', {it = Breaking (0l, vs0); at} :: es')), vs ->
       take n vs0 e.at @ vs, List.map plain es0
 
@@ -1030,6 +1170,16 @@ let rec step (c : config) : config =
     | Frame (n, frame', (vs', [])), vs ->
       vs' @ vs, []
 
+    | Frame (n, frame', (vs', {it = Trapping msg; at} :: es')), vs ->
+      vs, [Trapping msg @@ at]
+
+    | Frame (n, frame', (vs', {it = Throwing (a, vs0); at} :: es')), vs ->
+      vs, [Throwing (a, vs0) @@ at]
+
+    | Frame (n, frame', (vs', {it = Suspending (tagt, vs1, contref, ctxt); at} :: es')), vs ->
+      let ctxt' code = [], [Frame (n, frame', compose (ctxt code) (vs', es')) @@ e.at] in
+      vs, [Suspending (tagt, vs1, contref, ctxt') @@ at]
+
     | Frame (n, frame', (vs', {it = Returning vs0; at} :: es')), vs ->
       take n vs0 e.at @ vs, []
 
@@ -1068,6 +1218,10 @@ let rec step (c : config) : config =
     | Handler (n, [], (vs', {it = Throwing (a, vs0); at} :: es')), vs ->
       vs, [Throwing (a, vs0) @@ at]
 
+    | Handler (n, cs, (vs', {it = Suspending (tagt, vs1, contref, ctxt); at} :: es')), vs ->
+      let ctxt' code = [], [Handler (n, cs, compose (ctxt code) (vs', es')) @@ e.at] in
+      vs, [Suspending (tagt, vs1, contref, ctxt') @@ at]
+
     | Handler (n, cs, (vs', e' :: es')), vs when is_jumping e' ->
       vs, [e']
 
@@ -1083,7 +1237,7 @@ let rec step (c : config) : config =
       let n1, n2 = List.length ts1, List.length ts2 in
       let args, vs' = split n1 vs e.at in
       (match f with
-      | Func.AstFunc (_, inst', func) ->
+       | Func.AstFunc (_, inst', func) ->
         let {locals; body; _} = func.it in
         let m = Lib.Promise.value inst' in
         let s = subst_of m in
@@ -1097,6 +1251,39 @@ let rec step (c : config) : config =
         (try List.rev (f (List.rev args)) @ vs', []
         with Crash (_, msg) -> Crash.error e.at msg)
       )
+
+    | Handle (hso, (vs', [])), vs ->
+      vs' @ vs, []
+
+    | Handle ((hs, _), (vs', {it = Suspending (tagt, vs1, None, ctxt); at} :: es')), vs
+      when List.mem_assq tagt hs ->
+      let FuncT (_, ts) = func_type_of_tag_type c.frame.inst (Tag.type_of tagt) in
+      let ctxt' code = compose (ctxt code) (vs', es') in
+      [Ref (ContRef (ref (Some (Lib.List32.length ts, ctxt'))))] @ vs1 @ vs,
+      [Plain (Br (List.assq tagt hs)) @@ e.at]
+
+    | Handle ((_, hs) as hso, (vs', {it = Suspending (tagt, vs1, Some (ContRef ({contents = Some (_, ctxt)} as cont)), ctxt'); at} :: es')), vs
+       when List.memq tagt hs ->
+       let FuncT (_, ts) = func_type_of_tag_type c.frame.inst (Tag.type_of tagt) in
+       let ctxt'' code = compose (ctxt' code) (vs', es') in
+       let cont' = Ref (ContRef (ref (Some (Int32.add (Lib.List32.length ts) 1l, ctxt'')))) in
+       let args = cont' :: vs1 in
+       cont := None;
+       vs' @ vs, [Handle (hso, ctxt (args, [])) @@ e.at]
+
+    | Handle (hso, (vs', {it = Suspending (tagt, vs1, contref, ctxt); at} :: es')), vs ->
+      let ctxt' code = [], [Handle (hso, compose (ctxt code) (vs', es')) @@ e.at] in
+      vs, [Suspending (tagt, vs1, contref, ctxt') @@ at]
+
+    | Handle (hso, (vs', e' :: es')), vs when is_jumping e' ->
+      vs, [e']
+
+    | Handle (hso, code'), vs ->
+      let c' = step {c with code = code'} in
+      vs, [Handle (hso, c'.code) @@ e.at]
+
+    | Suspending (_, _, _, _), _ -> assert false
+
   in {c with code = vs', es' @ List.tl es}
 
 
@@ -1105,8 +1292,15 @@ let rec eval (c : config) : value stack =
   | vs, [] ->
     vs
 
-  | vs, {it = Trapping msg; at} :: _ ->
-    Trap.error at msg
+  | vs, e::_ when is_jumping e ->
+    (match e.it with
+    | Trapping msg ->  Trap.error e.at msg
+    | Throwing _ -> Exception.error e.at "unhandled exception"
+    | Suspending _ -> Suspension.error e.at "unhandled tag"
+    | Returning _ | ReturningInvoke _ -> Crash.error e.at "undefined frame"
+    | Breaking _ -> Crash.error e.at "undefined label"
+    | _ -> assert false
+    )
 
   | vs, {it = Throwing (a, args); at} :: _ ->
     let msg = "uncaught exception with args (" ^ string_of_values args ^ ")" in
@@ -1176,10 +1370,6 @@ let init_func (inst : module_inst) (f : func) : module_inst =
   let func = Func.alloc (type_ inst f.it.ftype) (Lib.Promise.make ()) f in
   {inst with funcs = inst.funcs @ [func]}
 
-let init_tag (inst : module_inst) (t : tag) : module_inst =
-  let tag = Tag.alloc (TagT (type_ inst t.it.tgtype)) in
-  {inst with tags = inst.tags @ [tag]}
-
 let init_global (inst : module_inst) (glob : global) : module_inst =
   let {gtype; ginit} = glob.it in
   let gt = subst_global_type (subst_of inst) gtype in
@@ -1209,6 +1399,10 @@ let init_elem (inst : module_inst) (seg : elem_segment) : module_inst =
   let elem = Elem.alloc (List.map (fun c -> as_ref (eval_const inst c)) einit) in
   {inst with elems = inst.elems @ [elem]}
 
+let init_tag (inst : module_inst) (t : tag) : module_inst =
+  let tag = Tag.alloc (TagT (type_ inst t.it.tgtype)) in
+  {inst with tags = inst.tags @ [tag]}
+
 let init_data (inst : module_inst) (seg : data_segment) : module_inst =
   let {dinit; _} = seg.it in
   let data = Data.alloc dinit in
@@ -1226,7 +1420,6 @@ let init_export (inst : module_inst) (ex : export) : module_inst =
   in
   {inst with exports = inst.exports @ [(name, ext)]}
 
-
 let init_func_inst (inst : module_inst) (func : func_inst) =
   match func with
   | Func.AstFunc (_, prom, _) when Lib.Promise.value_opt prom = None ->
@@ -1281,6 +1474,7 @@ let init (m : module_) (exts : extern list) : module_inst =
     |> init_list2 init_import exts m.it.imports
     |> init_list init_func m.it.funcs
     |> init_list init_global m.it.globals
+    |> init_list init_tag m.it.tags
     |> init_list init_table m.it.tables
     |> init_list init_memory m.it.memories
     |> init_list init_tag m.it.tags
diff --git a/interpreter/exec/eval.mli b/interpreter/exec/eval.mli
index 196f8997..089aaeca 100644
--- a/interpreter/exec/eval.mli
+++ b/interpreter/exec/eval.mli
@@ -4,8 +4,9 @@ open Instance
 exception Link of Source.region * string
 exception Trap of Source.region * string
 exception Exception of Source.region * string
-exception Crash of Source.region * string
+exception Suspension of Source.region * string
 exception Exhaustion of Source.region * string
+exception Crash of Source.region * string
 
 val init : Ast.module_ -> extern list -> module_inst (* raises Link, Trap *)
 val invoke : func_inst -> value list -> value list (* raises Trap *)
diff --git a/interpreter/runtime/global.ml b/interpreter/runtime/global.ml
index 3640cf40..cf69d2ac 100644
--- a/interpreter/runtime/global.ml
+++ b/interpreter/runtime/global.ml
@@ -21,5 +21,4 @@ let load glob =
 let store glob v =
   let GlobalT (mut, t) = glob.ty in
   if mut <> Var then raise NotMutable;
-  if not (Match.match_val_type [] (type_of_value v) t) then raise Type;
   glob.content <- v
diff --git a/interpreter/runtime/table.ml b/interpreter/runtime/table.ml
index 7284af0c..4547824e 100644
--- a/interpreter/runtime/table.ml
+++ b/interpreter/runtime/table.ml
@@ -53,7 +53,6 @@ let load tab i =
 
 let store tab i r =
   let TableT (lim, t) = tab.ty in
-  if not (Match.match_ref_type [] (type_of_ref r) t) then raise Type;
   if i < 0l || i >= Lib.Array32.length tab.content then raise Bounds;
   Lib.Array32.set tab.content i r
 
diff --git a/interpreter/runtime/tag.ml b/interpreter/runtime/tag.ml
index 3e0b9e49..cd6c9307 100644
--- a/interpreter/runtime/tag.ml
+++ b/interpreter/runtime/tag.ml
@@ -4,7 +4,7 @@ type tag = {ty : tag_type}
 type t = tag
 
 let alloc ty =
-   {ty}
+  {ty}
 
-let type_of tg =
-  tg.ty
+let type_of tag =
+  tag.ty
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 7bacb518..a4ad7b3c 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -137,6 +137,14 @@ function assert_exception(action) {
   throw new Error("exception expected");
 }
 
+function assert_suspension(action) {
+  try { action() } catch (e) {
+    /* TODO: Not clear how to observe form JS */
+    return;
+  }
+  throw new Error("Wasm exception expected");
+}
+
 let StackOverflow;
 try { (function f() { 1 + f() })() } catch (e) { StackOverflow = e.constructor }
 
@@ -666,6 +674,8 @@ let of_assertion env ass =
     of_assertion' env act "assert_exhaustion" [] None
   | AssertException act ->
     of_assertion' env act "assert_exception" [] None
+  | AssertSuspension (act, _) ->
+    of_assertion' env act "assert_suspension" [] None
 
 let of_command env cmd =
   "\n// " ^ Filename.basename cmd.at.left.file ^
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index 81496b63..8a17b421 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -116,6 +116,7 @@ let input_from get_script run =
   | Eval.Exhaustion (at, msg) -> error at "resource exhaustion" msg
   | Eval.Crash (at, msg) -> error at "runtime crash" msg
   | Eval.Exception (at, msg) -> error at "uncaught exception" msg
+  | Eval.Suspension (at, msg) -> error at "suspension error" msg
   | Encode.Code (at, msg) -> error at "encoding error" msg
   | Script.Error (at, msg) -> error at "script error" msg
   | IO (at, msg) -> error at "i/o error" msg
@@ -520,6 +521,13 @@ let run_assertion ass =
     | _ -> Assert.error ass.at "expected runtime error"
     )
 
+  | AssertSuspension (act, re) ->
+    trace ("Asserting suspension...");
+    (match run_action act with
+    | exception Eval.Suspension (_, msg) -> assert_message ass.at "runtime" msg re
+    | _ -> Assert.error ass.at "expected suspension"
+    )
+
   | AssertExhaustion (act, re) ->
     trace ("Asserting exhaustion...");
     (match run_action act with
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index 315905e3..85d8d2ae 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -47,8 +47,9 @@ and assertion' =
   | AssertUnlinkable of var option * string
   | AssertUninstantiable of var option * string
   | AssertReturn of action * result list
-  | AssertException of action
   | AssertTrap of action * string
+  | AssertException of action
+  | AssertSuspension of action * string
   | AssertExhaustion of action * string
 
 type command = command' Source.phrase
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 5d5ac6dc..861efd00 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -139,6 +139,7 @@ type vec = Value.vec Source.phrase
 type name = Utf8.unicode
 
 type block_type = VarBlockType of idx | ValBlockType of val_type option
+type hdl = OnLabel of idx | OnSwitch
 
 type instr = instr' Source.phrase
 and instr' =
@@ -163,6 +164,12 @@ and instr' =
   | ReturnCall of idx                 (* tail-call function *)
   | ReturnCallRef of idx              (* tail call through reference *)
   | ReturnCallIndirect of idx * idx   (* tail-call function through table *)
+  | ContNew of idx                    (* create continuation *)
+  | ContBind of idx * idx             (* bind continuation arguments *)
+  | Suspend of idx                    (* suspend continuation *)
+  | Resume of idx * (idx * hdl) list  (* resume continuation *)
+  | ResumeThrow of idx * idx * (idx * hdl) list (* abort continuation *)
+  | Switch of idx * idx               (* direct switch continuation *)
   | Throw of idx                      (* throw exception *)
   | ThrowRef                          (* rethrow exception *)
   | TryTable of block_type * catch list * instr list  (* handle exceptions *)
@@ -271,6 +278,15 @@ and func' =
 }
 
 
+(* Tags *)
+
+type tag = tag' Source.phrase
+and tag' =
+{
+  tgtype : idx;
+}
+
+
 (* Tables & Memories *)
 
 type table = table' Source.phrase
@@ -286,13 +302,6 @@ and memory' =
   mtype : memory_type;
 }
 
-type tag = tag' Source.phrase
-and tag' =
-{
-  tgtype : idx;
-}
-
-
 type segment_mode = segment_mode' Source.phrase
 and segment_mode' =
   | Passive
@@ -399,6 +408,9 @@ let def_types_of (m : module_) : def_type list =
     dts @ List.map (subst_def_type (subst_of dts)) (roll_def_types x rt)
   ) [] rts
 
+let ht (m : module_) (x : idx) : heap_type =
+  VarHT (StatX x.it)
+
 let import_type_of (m : module_) (im : import) : import_type =
   let {idesc; module_name; item_name} = im.it in
   let dts = def_types_of m in
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 082c9d39..e62c3e14 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -81,6 +81,7 @@ let heap_type = function
   | FuncHT | NoFuncHT -> empty
   | ExnHT | NoExnHT -> empty
   | ExternHT | NoExternHT -> empty
+  | ContHT | NoContHT -> empty
   | VarHT x -> var_type x
   | DefHT _ct -> empty  (* assume closed *)
   | BotHT -> empty
@@ -94,6 +95,9 @@ let val_type = function
   | RefT t -> ref_type t
   | BotT -> empty
 
+(* let func_type (FuncT (ins, out)) = list val_type ins ++ list val_type out *)
+let cont_type (ContT ht) = heap_type ht
+
 let pack_type t = empty
 
 let storage_type = function
@@ -110,6 +114,7 @@ let str_type = function
   | DefStructT st -> struct_type st
   | DefArrayT at -> array_type at
   | DefFuncT ft -> func_type ft
+  | DefContT ct -> cont_type ct
 
 let sub_type = function
   | SubT (_fin, hts, st) -> list heap_type hts ++ str_type st
@@ -130,12 +135,16 @@ let extern_type = function
   | ExternTableT tt -> table_type tt
   | ExternMemoryT mt -> memory_type mt
   | ExternGlobalT gt -> global_type gt
-  | ExternTagT tt -> tag_type tt
+  | ExternTagT et -> tag_type et
 
 let block_type = function
   | VarBlockType x -> types (idx x)
   | ValBlockType t -> opt val_type t
 
+let hdl = function
+  | OnLabel x -> labels (idx x)
+  | OnSwitch -> empty
+
 let rec instr (e : instr) =
   match e.it with
   | Unreachable | Nop | Drop -> empty
@@ -168,7 +177,13 @@ let rec instr (e : instr) =
   | Call x | ReturnCall x -> funcs (idx x)
   | CallRef x | ReturnCallRef x -> types (idx x)
   | CallIndirect (x, y) | ReturnCallIndirect (x, y) ->
-    tables (idx x) ++ types (idx y)
+     tables (idx x) ++ types (idx y)
+  | ContNew x -> types (idx x)
+  | ContBind (x, y) -> types (idx x) ++ types (idx y)
+  | ResumeThrow (x, y, xys) -> types (idx x) ++ tags (idx y) ++ list (fun (x, y) -> tags (idx x) ++ hdl y) xys
+  | Resume (x, xys) -> types (idx x) ++ list (fun (x, y) -> tags (idx x) ++ hdl y) xys
+  | Suspend x -> tags (idx x)
+  | Switch (x, z) -> types (idx x) ++ tags (idx z)
   | Throw x -> tags (idx x)
   | ThrowRef -> empty
   | TryTable (bt, cs, es) ->
@@ -208,7 +223,7 @@ let func (f : func) =
   {(types (idx f.it.ftype) ++ block f.it.body) with locals = Set.empty}
 let table (t : table) = table_type t.it.ttype ++ const t.it.tinit
 let memory (m : memory) = memory_type m.it.mtype
-let tag (t : tag) = empty
+let tag (e : tag) = empty
 
 let segment_mode f (m : segment_mode) =
   match m.it with
@@ -237,7 +252,7 @@ let import_desc (d : import_desc) =
   | TableImport tt -> table_type tt
   | MemoryImport mt -> memory_type mt
   | GlobalImport gt -> global_type gt
-  | TagImport x -> types (idx x)
+  | TagImport et -> types (idx et)
 
 let export (e : export) = export_desc e.it.edesc
 let import (i : import) = import_desc i.it.idesc
@@ -249,6 +264,7 @@ let module_ (m : module_) =
   list global m.it.globals ++
   list table m.it.tables ++
   list memory m.it.memories ++
+  list tag m.it.tags ++
   list func m.it.funcs ++
   opt start m.it.start ++
   list elem m.it.elems ++
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index 9a467b1c..a5239058 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -45,6 +45,12 @@ let return_call x = ReturnCall x
 let return_call_ref x = ReturnCallRef x
 let return_call_indirect x y = ReturnCallIndirect (x, y)
 
+let cont_new x = ContNew x
+let cont_bind x y = ContBind (x, y)
+let suspend x = Suspend x
+let resume x xys = Resume (x, xys)
+let resume_throw x y xys = ResumeThrow (x, y, xys)
+let switch x y = Switch (x, y)
 let throw x = Throw x
 let throw_ref = ThrowRef
 let try_table bt cs es = TryTable (bt, cs, es)
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index dd233c9f..115e61d8 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -19,6 +19,7 @@ type heap_type =
   | FuncHT | NoFuncHT
   | ExnHT | NoExnHT
   | ExternHT | NoExternHT
+  | ContHT | NoContHT
   | VarHT of var
   | DefHT of def_type
   | BotHT
@@ -34,11 +35,13 @@ and field_type = FieldT of mut * storage_type
 and struct_type = StructT of field_type list
 and array_type = ArrayT of field_type
 and func_type = FuncT of result_type * result_type
+and cont_type = ContT of heap_type
 
 and str_type =
   | DefStructT of struct_type
   | DefArrayT of array_type
   | DefFuncT of func_type
+  | DefContT of cont_type
 
 and sub_type = SubT of final * heap_type list * str_type
 and rec_type = RecT of sub_type list
@@ -47,8 +50,8 @@ and def_type = DefT of rec_type * int32
 type table_type = TableT of Int32.t limits * ref_type
 type memory_type = MemoryT of Int32.t limits
 type global_type = GlobalT of mut * val_type
-type tag_type = TagT of def_type
 type local_type = LocalT of init * val_type
+type tag_type = TagT of def_type
 type extern_type =
   | ExternFuncT of def_type
   | ExternTableT of table_type
@@ -110,34 +113,6 @@ let defaultable = function
   | BotT -> assert false
 
 
-(* Projections *)
-
-let unpacked_storage_type = function
-  | ValStorageT t -> t
-  | PackStorageT _ -> NumT I32T
-
-let unpacked_field_type (FieldT (_mut, t)) = unpacked_storage_type t
-
-
-let as_func_str_type (st : str_type) : func_type =
-  match st with
-  | DefFuncT ft -> ft
-  | _ -> assert false
-
-let as_struct_str_type (st : str_type) : struct_type =
-  match st with
-  | DefStructT st -> st
-  | _ -> assert false
-
-let as_array_str_type (st : str_type) : array_type =
-  match st with
-  | DefArrayT at -> at
-  | _ -> assert false
-
-let extern_type_of_import_type (ImportT (et, _, _)) = et
-let extern_type_of_export_type (ExportT (et, _)) = et
-
-
 (* Filters *)
 
 let funcs = List.filter_map (function ExternFuncT ft -> Some ft | _ -> None)
@@ -173,6 +148,8 @@ let subst_heap_type s = function
   | NoExnHT -> NoExnHT
   | ExternHT -> ExternHT
   | NoExternHT -> NoExternHT
+  | ContHT -> ContHT
+  | NoContHT -> NoContHT
   | VarHT x -> s x
   | DefHT dt -> DefHT dt  (* assume closed *)
   | BotHT -> BotHT
@@ -206,10 +183,14 @@ let subst_array_type s = function
 let subst_func_type s = function
   | FuncT (ts1, ts2) -> FuncT (subst_result_type s ts1, subst_result_type s ts2)
 
+let subst_cont_type s = function
+  | ContT ht -> ContT (subst_heap_type s ht)
+
 let subst_str_type s = function
   | DefStructT st -> DefStructT (subst_struct_type s st)
   | DefArrayT at -> DefArrayT (subst_array_type s at)
   | DefFuncT ft -> DefFuncT (subst_func_type s ft)
+  | DefContT ct -> DefContT (subst_cont_type s ct)
 
 let subst_sub_type s = function
   | SubT (fin, hts, st) ->
@@ -239,8 +220,7 @@ let subst_extern_type s = function
   | ExternTableT tt -> ExternTableT (subst_table_type s tt)
   | ExternMemoryT mt -> ExternMemoryT (subst_memory_type s mt)
   | ExternGlobalT gt -> ExternGlobalT (subst_global_type s gt)
-  | ExternTagT tt -> ExternTagT (subst_tag_type s tt)
-
+  | ExternTagT et -> ExternTagT (subst_tag_type s et)
 
 let subst_export_type s = function
   | ExportT (et, name) -> ExportT (subst_extern_type s et, name)
@@ -289,6 +269,37 @@ let expand_def_type (dt : def_type) : str_type =
   let SubT (_, _, st) = unroll_def_type dt in
   st
 
+(* Projections *)
+
+let unpacked_storage_type = function
+  | ValStorageT t -> t
+  | PackStorageT _ -> NumT I32T
+
+let unpacked_field_type (FieldT (_mut, t)) = unpacked_storage_type t
+
+let as_func_str_type (st : str_type) : func_type =
+  match st with
+  | DefFuncT ft -> ft
+  | _ -> assert false
+
+let as_cont_str_type (dt : str_type) : cont_type =
+  match dt with
+  | DefContT ct -> ct
+  | _ -> assert false
+
+let as_struct_str_type (st : str_type) : struct_type =
+  match st with
+  | DefStructT st -> st
+  | _ -> assert false
+
+let as_array_str_type (st : str_type) : array_type =
+  match st with
+  | DefArrayT at -> at
+  | _ -> assert false
+
+let extern_type_of_import_type (ImportT (et, _, _)) = et
+let extern_type_of_export_type (ExportT (et, _)) = et
+
 
 (* String conversion *)
 
@@ -348,6 +359,8 @@ let rec string_of_heap_type = function
   | NoExnHT -> "noexn"
   | ExternHT -> "extern"
   | NoExternHT -> "noextern"
+  | ContHT -> "cont"
+  | NoContHT -> "nocont"
   | VarHT x -> string_of_var x
   | DefHT dt -> "(" ^ string_of_def_type dt ^ ")"
   | BotHT -> "something"
@@ -384,10 +397,18 @@ and string_of_func_type = function
   | FuncT (ts1, ts2) ->
     string_of_result_type ts1 ^ " -> " ^ string_of_result_type ts2
 
+and string_of_cont_type = function
+  | ContT ht -> string_of_heap_type ht
+
 and string_of_str_type = function
   | DefStructT st -> "struct " ^ string_of_struct_type st
   | DefArrayT at -> "array " ^ string_of_array_type at
   | DefFuncT ft -> "func " ^ string_of_func_type ft
+  | DefContT ct -> "cont " ^ string_of_cont_type ct
+
+
+and string_of_tag_type = function
+  | TagT dt -> string_of_def_type dt
 
 and string_of_sub_type = function
   | SubT (Final, [], st) -> string_of_str_type st
@@ -421,9 +442,6 @@ let string_of_table_type = function
 let string_of_global_type = function
   | GlobalT (mut, t) -> string_of_mut (string_of_val_type t) mut
 
-let string_of_tag_type = function
-  | TagT dt -> string_of_def_type dt
-
 let string_of_local_type = function
   | LocalT (Set, t) -> string_of_val_type t
   | LocalT (Unset, t) -> "(unset " ^ string_of_val_type t ^ ")"
@@ -433,8 +451,7 @@ let string_of_extern_type = function
   | ExternTableT tt -> "table " ^ string_of_table_type tt
   | ExternMemoryT mt -> "memory " ^ string_of_memory_type mt
   | ExternGlobalT gt -> "global " ^ string_of_global_type gt
-  | ExternTagT tt -> "tag " ^ string_of_tag_type tt
-
+  | ExternTagT t -> "tag " ^ string_of_tag_type t
 
 let string_of_export_type = function
   | ExportT (et, name) ->
@@ -450,4 +467,4 @@ let string_of_module_type = function
     String.concat "" (
       List.map (fun it -> "import " ^ string_of_import_type it ^ "\n") its @
       List.map (fun et -> "export " ^ string_of_export_type et ^ "\n") ets
-    )
+      )
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index fa5416f1..5ed9687f 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -99,11 +99,15 @@ let array_type (ArrayT ft) =
 let func_type (FuncT (ts1, ts2)) =
   Node ("func", decls "param" ts1 @ decls "result" ts2)
 
+let cont_type (ContT ct) =
+  Node ("cont", [atom heap_type ct])
+
 let str_type st =
   match st with
   | DefStructT st -> struct_type st
   | DefArrayT at -> array_type at
   | DefFuncT ft -> func_type ft
+  | DefContT ct -> cont_type ct
 
 let sub_type = function
   | SubT (Final, [], st) -> str_type st
@@ -486,6 +490,15 @@ let block_type = function
   | VarBlockType x -> [Node ("type " ^ var x, [])]
   | ValBlockType ts -> decls "result" (list_of_opt ts)
 
+let hdl = function
+  | OnLabel x -> var x
+  | OnSwitch -> "switch"
+
+let resumetable xys =
+  List.map
+    (fun (x, y) -> Node ("on " ^ var x ^ " " ^ hdl y, []))
+    xys
+
 let rec instr e =
   let head, inner =
     match e.it with
@@ -519,6 +532,15 @@ let rec instr e =
     | ReturnCallRef x -> "return_call_ref " ^ var x, []
     | ReturnCallIndirect (x, y) ->
       "return_call_indirect " ^ var x, [Node ("type " ^ var y, [])]
+    | ContNew x -> "cont.new " ^ var x, []
+    | ContBind (x, y) -> "cont.bind " ^ var x ^ " " ^ var y, []
+    | Suspend x -> "suspend " ^ var x, []
+    | Resume (x, xys) ->
+      "resume " ^ var x, resumetable xys
+    | ResumeThrow (x, y, xys) ->
+      "resume_throw " ^ var x ^ " " ^ var y, resumetable xys
+    | Switch (x, z) ->
+      "switch " ^ var x ^ " " ^ var z, []
     | Throw x -> "throw " ^ var x, []
     | ThrowRef -> "throw_ref", []
     | TryTable (bt, cs, es) ->
@@ -717,8 +739,8 @@ let export_desc d =
   | FuncExport x -> Node ("func", [atom var x])
   | TableExport x -> Node ("table", [atom var x])
   | MemoryExport x -> Node ("memory", [atom var x])
-  | TagExport x -> Node ("tag", [atom var x])
   | GlobalExport x -> Node ("global", [atom var x])
+  | TagExport x -> Node ("tag", [atom var x])
 
 let export ex =
   let {name = n; edesc} = ex.it in
@@ -902,10 +924,12 @@ let assertion mode ass =
     [Node ("assert_trap", [instance (None, x_opt); Atom (string re)])]
   | AssertReturn (act, results) ->
     [Node ("assert_return", action mode act :: List.map (result mode) results)]
-  | AssertTrap (act, re) ->
-    [Node ("assert_trap", [action mode act; Atom (string re)])]
   | AssertException act ->
     [Node ("assert_exception", [action mode act])]
+  | AssertTrap (act, re) ->
+    [Node ("assert_trap", [action mode act; Atom (string re)])]
+  | AssertSuspension (act, re) ->
+    [Node ("assert_suspension", [action mode act; Atom (string re)])]
   | AssertExhaustion (act, re) ->
     [Node ("assert_exhaustion", [action mode act; Atom (string re)])]
 
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 5b95a124..c0bad0d6 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -177,6 +177,9 @@ rule token = parse
       | "noextern" -> NOEXTERN
       | "externref" -> EXTERNREF
       | "nullexternref" -> NULLEXTERNREF
+      | "nocont" -> NOCONT
+      | "contref" -> CONTREF
+      | "nullcontref" -> NULLCONTREF
       | "ref" -> REF
       | "null" -> NULL
 
@@ -184,6 +187,7 @@ rule token = parse
       | "struct" -> STRUCT
       | "field" -> FIELD
       | "mut" -> MUT
+      | "cont" -> CONT
       | "sub" -> SUB
       | "final" -> FINAL
       | "rec" -> REC
@@ -220,6 +224,15 @@ rule token = parse
       | "catch_all" -> CATCH_ALL
       | "catch_all_ref" -> CATCH_ALL_REF
 
+
+      | "cont.new" -> CONT_NEW
+      | "cont.bind" -> CONT_BIND
+      | "suspend" -> SUSPEND
+      | "resume" -> RESUME
+      | "resume_throw" -> RESUME_THROW
+      | "switch" -> SWITCH
+
+
       | "local.get" -> LOCAL_GET
       | "local.set" -> LOCAL_SET
       | "local.tee" -> LOCAL_TEE
@@ -756,6 +769,7 @@ rule token = parse
       | "data" -> DATA
       | "declare" -> DECLARE
       | "offset" -> OFFSET
+      | "on" -> ON
       | "item" -> ITEM
       | "import" -> IMPORT
       | "export" -> EXPORT
@@ -779,6 +793,7 @@ rule token = parse
       | "assert_trap" -> ASSERT_TRAP
       | "assert_exception" -> ASSERT_EXCEPTION
       | "assert_exhaustion" -> ASSERT_EXHAUSTION
+      | "assert_suspension" -> ASSERT_SUSPENSION
       | "nan:canonical" -> NAN Script.CanonicalNan
       | "nan:arithmetic" -> NAN Script.ArithmeticNan
       | "input" -> INPUT
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 2eebddd0..f1d0a1c5 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -186,7 +186,6 @@ let func_type (c : context) x =
   | _ -> error x.at ("non-function type " ^ Int32.to_string x.it)
   | exception Failure _ -> error x.at ("unknown type " ^ Int32.to_string x.it)
 
-
 let bind_abs category space x =
   if VarMap.mem x.it space.map then
     error x.at ("duplicate " ^ category ^ " " ^ print x);
@@ -236,9 +235,8 @@ let anon_label (c : context) loc = bind "label" c.labels 1l (at loc)
 let anon_fields (c : context) x n loc =
   bind "field" (Lib.List32.nth c.types.fields x) n (at loc)
 
-
-let inline_func_type (c : context) ft loc =
-  let st = SubT (Final, [], DefFuncT ft) in
+let find_type_index (c : context) dt loc =
+  let st = SubT (Final, [], dt) in
   match
     Lib.List.index_where (function
       | DefT (RecT [st'], 0l) -> st = st'
@@ -252,6 +250,10 @@ let inline_func_type (c : context) ft loc =
     define_def_type c (DefT (RecT [st], 0l));
     i @@ loc
 
+let inline_func_type (c : context) ft loc =
+  let dt = DefFuncT ft in
+  find_type_index c dt loc
+
 let inline_func_type_explicit (c : context) x ft loc =
   if ft = FuncT ([], []) then
     (* Deferring ensures that type lookup is only triggered when
@@ -264,7 +266,6 @@ let inline_func_type_explicit (c : context) x ft loc =
     error (at loc) "inline function type does not match explicit type";
   x
 
-
 (* Custom annotations *)
 
 let parse_annots (m : module_) : Custom.section list =
@@ -298,11 +299,13 @@ let parse_annots (m : module_) : Custom.section list =
 %token<V128.shape> VEC_SHAPE
 %token ANYREF NULLREF EQREF I31REF STRUCTREF ARRAYREF
 %token FUNCREF NULLFUNCREF EXNREF NULLEXNREF EXTERNREF NULLEXTERNREF
+%token NOCONT CONTREF NULLCONTREF
 %token ANY NONE EQ I31 REF NOFUNC EXN NOEXN EXTERN NOEXTERN NULL
 %token MUT FIELD STRUCT ARRAY SUB FINAL REC
 %token UNREACHABLE NOP DROP SELECT
 %token BLOCK END IF THEN ELSE LOOP
-%token BR BR_IF BR_TABLE
+%token CONT_NEW CONT_BIND SUSPEND RESUME RESUME_THROW SWITCH
+%token BR BR_IF BR_TABLE BR_ON_NON_NULL
 %token<Ast.idx -> Ast.instr'> BR_ON_NULL
 %token<Ast.idx -> Types.ref_type -> Types.ref_type -> Ast.instr'> BR_ON_CAST
 %token CALL CALL_REF CALL_INDIRECT
@@ -333,12 +336,12 @@ let parse_annots (m : module_) : Custom.section list =
 %token<Ast.instr'> VEC_SHIFT VEC_BITMASK VEC_SPLAT
 %token VEC_SHUFFLE
 %token<int -> Ast.instr'> VEC_EXTRACT VEC_REPLACE
-%token FUNC START TYPE PARAM RESULT LOCAL GLOBAL
-%token TABLE ELEM MEMORY TAG DATA DECLARE OFFSET ITEM IMPORT EXPORT
+%token FUNC START TYPE PARAM RESULT LOCAL GLOBAL CONT
+%token TABLE ELEM MEMORY ON TAG DATA DECLARE OFFSET ITEM IMPORT EXPORT
 %token MODULE BIN QUOTE DEFINITION INSTANCE
 %token SCRIPT REGISTER INVOKE GET
 %token ASSERT_MALFORMED ASSERT_INVALID ASSERT_UNLINKABLE
-%token ASSERT_RETURN ASSERT_TRAP ASSERT_EXCEPTION ASSERT_EXHAUSTION
+%token ASSERT_RETURN ASSERT_TRAP ASSERT_EXCEPTION ASSERT_EXHAUSTION ASSERT_SUSPENSION
 %token ASSERT_MALFORMED_CUSTOM ASSERT_INVALID_CUSTOM
 %token<Script.nan> NAN
 %token INPUT OUTPUT
@@ -380,6 +383,8 @@ heap_type :
   | NOEXN { fun c -> NoExnHT }
   | EXTERN { fun c -> ExternHT }
   | NOEXTERN { fun c -> NoExternHT }
+  | CONT { fun c -> ContHT }
+  | NOCONT { fun c -> NoContHT }
   | var { fun c -> VarHT (StatX ($1 c type_).it) }
 
 ref_type :
@@ -396,6 +401,8 @@ ref_type :
   | NULLEXNREF { fun c -> (Null, NoExnHT) }  /* Sugar */
   | EXTERNREF { fun c -> (Null, ExternHT) }  /* Sugar */
   | NULLEXTERNREF { fun c -> (Null, NoExternHT) }  /* Sugar */
+  | CONTREF { fun c -> (Null, ContHT) } /* Sugar */
+  | NULLCONTREF { fun c -> (Null, NoContHT) } /* Sugar */
 
 val_type :
   | NUM_TYPE { fun c -> NumT $1 }
@@ -410,6 +417,34 @@ global_type :
   | val_type { fun c -> GlobalT (Cons, $1 c) }
   | LPAR MUT val_type RPAR { fun c -> GlobalT (Var, $3 c) }
 
+cont_type :
+  | type_use cont_type_params
+    { let at1 = $loc($1) in
+      fun c ->
+      match $2 c with
+      | FuncT ([], []) -> ContT (VarHT (StatX ($1 c).it))
+      | ft ->
+         let x = inline_func_type_explicit c ($1 c) ft at1 in
+         ContT (VarHT (StatX x.it)) }
+  | cont_type_params
+    /* TODO: the inline type is broken for now */
+    { let at = $sloc in fun c -> ContT (VarHT (StatX (inline_func_type c ($1 c) at).it)) }
+  | var  /* Sugar */
+    { fun c -> ContT (VarHT (StatX ($1 c type_).it)) }
+
+cont_type_params :
+  | LPAR PARAM val_type_list RPAR cont_type_params
+    { fun c -> let FuncT (ts1, ts2) = $5 c in
+      FuncT (snd $3 c @ ts1, ts2) }
+  | cont_type_results
+    { fun c -> FuncT ([], $1 c) }
+
+cont_type_results :
+  | LPAR RESULT val_type_list RPAR cont_type_results
+    { fun c -> snd $3 c @ $5 c }
+  | /* empty */
+    { fun c -> [] }
+
 storage_type :
   | val_type { fun c -> ValStorageT ($1 c) }
   | PACK_TYPE { fun c -> PackStorageT $1 }
@@ -456,6 +491,7 @@ str_type :
   | LPAR STRUCT struct_type RPAR { fun c x -> DefStructT ($3 c x) }
   | LPAR ARRAY array_type RPAR { fun c x -> DefArrayT ($3 c) }
   | LPAR FUNC func_type RPAR { fun c x -> DefFuncT ($3 c) }
+  | LPAR CONT cont_type RPAR { fun c x -> DefContT ($3 c) }
 
 sub_type :
   | str_type { fun c x -> SubT (Final, [], $1 c x) }
@@ -554,6 +590,7 @@ instr_list :
   | instr1 instr_list { fun c -> $1 c @ $2 c }
   | select_instr_instr_list { $1 }
   | call_instr_instr_list { $1 }
+  | resume_instr_instr { fun c -> let e, es = $1 c in e :: es }
 
 instr1 :
   | plain_instr { fun c -> [$1 c @@ $sloc] }
@@ -570,12 +607,16 @@ plain_instr :
     { fun c -> let xs, x = Lib.List.split_last ($2 c label :: $3 c label) in
       br_table xs x }
   | BR_ON_NULL var { fun c -> $1 ($2 c label) }
+  | BR_ON_NON_NULL var { fun c -> br_on_non_null ($2 c label) }
   | BR_ON_CAST var ref_type ref_type { fun c -> $1 ($2 c label) ($3 c) ($4 c) }
   | RETURN { fun c -> return }
   | CALL var { fun c -> call ($2 c func) }
   | CALL_REF var { fun c -> call_ref ($2 c type_) }
   | RETURN_CALL var { fun c -> return_call ($2 c func) }
   | RETURN_CALL_REF var { fun c -> return_call_ref ($2 c type_) }
+  | CONT_NEW var { fun c -> cont_new ($2 c type_) }
+  | CONT_BIND var var { fun c -> cont_bind ($2 c type_) ($3 c type_) }
+  | SUSPEND var { fun c -> suspend ($2 c tag) }
   | THROW var { fun c -> throw ($2 c tag) }
   | THROW_REF { fun c -> throw_ref }
   | LOCAL_GET var { fun c -> local_get ($2 c local) }
@@ -627,6 +668,7 @@ plain_instr :
   | STRUCT_NEW var { fun c -> $1 ($2 c type_) }
   | STRUCT_GET var var { fun c -> let x = $2 c type_ in $1 x ($3 c (field x.it)) }
   | STRUCT_SET var var { fun c -> let x = $2 c type_ in struct_set x ($3 c (field x.it)) }
+  | SWITCH var var { fun c -> let x = $2 c type_ in let tag = $3 c tag in switch x tag }
   | ARRAY_NEW var { fun c -> $1 ($2 c type_) }
   | ARRAY_NEW_FIXED var nat32 { fun c -> array_new_fixed ($2 c type_) $3 }
   | ARRAY_NEW_ELEM var var { fun c -> array_new_elem ($2 c type_) ($3 c elem) }
@@ -726,6 +768,26 @@ call_instr_results_instr_list :
   | instr_list
     { fun c -> [], $1 c }
 
+resume_instr_instr :
+  | RESUME var resume_instr_handler_instr
+    { let loc1 = $loc($1) in
+      fun c ->
+      let x = $2 c type_ in
+      let hs, es = $3 c in resume x hs @@ loc1, es }
+  | RESUME_THROW var var resume_instr_handler_instr
+    { let loc1 = $loc($1) in
+      fun c ->
+      let x  = $2 c type_ in
+      let tag = $3 c tag in
+      let hs, es = $4 c in resume_throw x tag hs @@ loc1, es }
+
+resume_instr_handler_instr :
+  | LPAR ON var var RPAR resume_instr_handler_instr
+    { fun c -> let hs, es = $6 c in ($3 c tag, OnLabel ($4 c label)) :: hs, es }
+  | LPAR ON var SWITCH RPAR resume_instr_handler_instr
+    { fun c -> let hs, es = $6 c in ($3 c tag, OnSwitch) :: hs, es }
+  | instr1
+    { fun c -> [], $1 c }
 
 block_instr :
   | BLOCK labeling_opt block END labeling_end_opt
@@ -826,6 +888,16 @@ expr1 :  /* Sugar */
     { fun c -> let x, es = $3 c in es, return_call_indirect ($2 c table) x }
   | RETURN_CALL_INDIRECT call_expr_type  /* Sugar */
     { fun c -> let x, es = $2 c in es, return_call_indirect (0l @@ $loc($1)) x }
+  | RESUME var resume_expr_handler
+    { fun c ->
+      let x = $2 c type_ in
+      let hs, es = $3 c in es, resume x hs }
+  | RESUME_THROW var var resume_expr_handler
+    { fun c ->
+      let x = $2 c type_ in
+      let tag = $3 c tag in
+      let hs, es = $4 c in
+      es, resume_throw x tag hs }
   | BLOCK labeling_opt block
     { fun c -> let c' = $2 c [] in let bt, es = $3 c' in [], block bt es }
   | LOOP labeling_opt block
@@ -865,6 +937,13 @@ call_expr_results :
   | expr_list
     { fun c -> [], $1 c }
 
+resume_expr_handler :
+  | LPAR ON var var RPAR resume_expr_handler
+    { fun c -> let hs, es = $6 c in ($3 c tag, OnLabel ($4 c label)) :: hs, es }
+  | LPAR ON var SWITCH RPAR resume_expr_handler
+    { fun c -> let hs, es = $6 c in ($3 c tag, OnSwitch) :: hs, es }
+  | expr_list
+    { fun c -> [], $1 c }
 
 if_block :
   | type_use if_block_param_body
@@ -874,7 +953,7 @@ if_block :
   | if_block_param_body  /* Sugar */
     { fun c c' -> let ft, es = $1 c c' in
       let bt =
-        match ft with
+        match fst ($1 c c') with
         | FuncT ([], []) -> ValBlockType None
         | FuncT ([], [t]) -> ValBlockType (Some t)
         | ft ->  VarBlockType (inline_func_type c ft $sloc)
@@ -901,7 +980,6 @@ if_ :
   | LPAR THEN instr_list RPAR  /* Sugar */
     { fun c c' -> [], $3 c', [] }
 
-
 try_block :
   | type_use try_block_param_body
     { fun c c' ->
@@ -1037,11 +1115,11 @@ local_type :
   | val_type { fun c -> {ltype = $1 c} @@ $sloc }
 
 local_type_list :
-  | list(local_type)
-    { Lib.List32.length $1, fun c -> List.map (fun f -> f c) $1 }
+  | /* empty */ { 0l, fun c -> [] }
+  | local_type local_type_list { I32.add (fst $2) 1l, fun c -> $1 c :: snd $2 c }
 
 
-/* Tables, Memories & Globals */
+/* Tables, Memories, Globals, Tags */
 
 table_use :
   | LPAR TABLE var RPAR { fun c -> $3 c }
@@ -1227,7 +1305,6 @@ global_fields :
     { fun c x loc -> let globs, ims, exs = $2 c x loc in
       globs, ims, $1 (GlobalExport x) c :: exs }
 
-
 /* Imports & Exports */
 
 import_desc :
@@ -1265,8 +1342,8 @@ export_desc :
   | LPAR FUNC var RPAR { fun c -> FuncExport ($3 c func) }
   | LPAR TABLE var RPAR { fun c -> TableExport ($3 c table) }
   | LPAR MEMORY var RPAR { fun c -> MemoryExport ($3 c memory) }
-  | LPAR TAG var RPAR { fun c -> TagExport ($3 c tag) }
   | LPAR GLOBAL var RPAR { fun c -> GlobalExport ($3 c global) }
+  | LPAR TAG var RPAR { fun c -> TagExport ($3 c tag) }
 
 export :
   | LPAR EXPORT name export_desc RPAR
@@ -1456,6 +1533,7 @@ action :
   | LPAR GET option(instance_var) name RPAR
     { Get ($3, $4) @@ $sloc }
 
+
 assertion :
   | LPAR ASSERT_MALFORMED script_module STRING RPAR
     { [], AssertMalformed (thd $3, $4) @@ $sloc }
@@ -1477,6 +1555,8 @@ assertion :
     { [], AssertTrap ($3, $4) @@ $sloc }
   | LPAR ASSERT_EXHAUSTION action STRING RPAR
     { [], AssertExhaustion ($3, $4) @@ $sloc }
+  | LPAR ASSERT_SUSPENSION action STRING RPAR
+    { [], AssertSuspension ($3, $4) @@ $sloc }
 
 cmd :
   | action { [Action $1 @@ $sloc] }
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 0f1c3121..5ae35e36 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -80,6 +80,11 @@ struct
     | n, y::ys' when n > 0 -> split' (n - 1) (y::xs) ys'
     | _ -> failwith "split"
 
+  let rec last_opt = function
+    | x::[] -> Some x
+    | _::xs -> last_opt xs
+    | [] -> None
+
   let rec lead = function
     | x::[] -> []
     | x::xs -> x :: lead xs
@@ -108,6 +113,13 @@ struct
     | [] -> []
     | x1::x2::xs -> f x1 x2 :: pairwise f xs
     | _ -> failwith "pairwise"
+
+  let rec map_filter f = function
+    | [] -> []
+    | x::xs ->
+      match f x with
+      | None -> map_filter f xs
+      | Some y -> y :: map_filter f xs
 end
 
 module List32 =
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index c11767ea..39ce9fe1 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -19,6 +19,7 @@ sig
   val drop : int -> 'a list -> 'a list (* raises Failure *)
   val split : int -> 'a list -> 'a list * 'a list (* raises Failure *)
 
+  val last_opt : 'a list -> 'a option
   val lead : 'a list -> 'a list (* raises Failure *)
   val last : 'a list -> 'a (* raises Failure *)
   val split_last : 'a list -> 'a list * 'a (* raises Failure *)
@@ -26,6 +27,7 @@ sig
   val index_of : 'a -> 'a list -> int option
   val index_where : ('a -> bool) -> 'a list -> int option
   val pairwise : ('a -> 'a -> 'b) -> 'a list -> 'b list
+  val map_filter : ('a -> 'b option) -> 'a list -> 'b list
 end
 
 module List32 :
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index 70f8136c..5ec7069a 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -13,6 +13,7 @@ let lookup c x = Lib.List32.nth c x
 let abs_of_str_type _c = function
   | DefStructT _ | DefArrayT _ -> StructHT
   | DefFuncT _ -> FuncHT
+  | DefContT _ -> ContHT
 
 let rec top_of_str_type c st =
   top_of_heap_type c (abs_of_str_type c st)
@@ -22,6 +23,7 @@ and top_of_heap_type c = function
   | FuncHT | NoFuncHT -> FuncHT
   | ExnHT | NoExnHT -> ExnHT
   | ExternHT | NoExternHT -> ExternHT
+  | ContHT | NoContHT -> ContHT
   | DefHT dt -> top_of_str_type c (expand_def_type dt)
   | VarHT (StatX x) -> top_of_str_type c (expand_def_type (lookup c x))
   | VarHT (RecX _) | BotHT -> assert false
@@ -34,6 +36,7 @@ and bot_of_heap_type c = function
   | FuncHT | NoFuncHT -> NoFuncHT
   | ExnHT | NoExnHT -> NoExnHT
   | ExternHT | NoExternHT -> NoExternHT
+  | ContHT | NoContHT -> NoContHT
   | DefHT dt -> bot_of_str_type c (expand_def_type dt)
   | VarHT (StatX x) -> bot_of_str_type c (expand_def_type (lookup c x))
   | VarHT (RecX _) | BotHT -> assert false
@@ -73,6 +76,7 @@ let rec match_heap_type c t1 t2 =
   | NoFuncHT, t -> match_heap_type c t FuncHT
   | NoExnHT, t -> match_heap_type c t ExnHT
   | NoExternHT, t -> match_heap_type c t ExternHT
+  | NoContHT, t -> match_heap_type c t ContHT
   | VarHT (StatX x1), _ -> match_heap_type c (DefHT (lookup c x1)) t2
   | _, VarHT (StatX x2) -> match_heap_type c t1 (DefHT (lookup c x2))
   | DefHT dt1, DefHT dt2 -> match_def_type c dt1 dt2
@@ -85,6 +89,7 @@ let rec match_heap_type c t1 t2 =
     | DefArrayT _, EqHT -> true
     | DefArrayT _, ArrayHT -> true
     | DefFuncT _, FuncHT -> true
+    | DefContT _, ContHT -> true
     | _ -> false
     )
   | BotHT, _ -> true
@@ -107,7 +112,6 @@ and match_result_type c ts1 ts2 =
   List.length ts1 = List.length ts2 &&
   List.for_all2 (match_val_type c) ts1 ts2
 
-
 and match_pack_type _c t1 t2 =
   t1 = t2
 
@@ -134,12 +138,15 @@ and match_array_type c (ArrayT ft1) (ArrayT ft2) =
 and match_func_type c (FuncT (ts11, ts12)) (FuncT (ts21, ts22)) =
   match_result_type c ts21 ts11 && match_result_type c ts12 ts22
 
+and match_cont_type c (ContT ht1) (ContT ht2) =
+  match_heap_type c ht1 ht2
 
 and match_str_type c dt1 dt2 =
   match dt1, dt2 with
   | DefStructT st1, DefStructT st2 -> match_struct_type c st1 st2
   | DefArrayT at1, DefArrayT at2 -> match_array_type c at1 at2
   | DefFuncT ft1, DefFuncT ft2 -> match_func_type c ft1 ft2
+  | DefContT ct1, DefContT ct2 -> match_cont_type c ct1 ct2
   | _, _ -> false
 
 and match_def_type c dt1 dt2 =
@@ -155,16 +162,15 @@ let match_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
   | Cons -> true
   | Var -> match_val_type c t2 t1
 
+let match_tag_type c (TagT dt1) (TagT dt2) =
+  match_def_type c dt1 dt2
+
 let match_table_type c (TableT (lim1, t1)) (TableT (lim2, t2)) =
   match_limits c lim1 lim2 && match_ref_type c t1 t2 && match_ref_type c t2 t1
 
 let match_memory_type c (MemoryT lim1) (MemoryT lim2) =
   match_limits c lim1 lim2
 
-let match_tag_type c (TagT dt1) (TagT dt2) =
-  match_def_type c dt1 dt2 && match_def_type c dt2 dt1
-
-
 let match_extern_type c et1 et2 =
   match et1, et2 with
   | ExternFuncT dt1, ExternFuncT dt2 -> match_def_type c dt1 dt2
diff --git a/interpreter/valid/match.mli b/interpreter/valid/match.mli
index 5f0c9639..e60aea37 100644
--- a/interpreter/valid/match.mli
+++ b/interpreter/valid/match.mli
@@ -28,6 +28,7 @@ val match_str_type : context -> str_type -> str_type -> bool
 val match_def_type : context -> def_type -> def_type -> bool
 
 val match_func_type : context -> func_type -> func_type -> bool
+val match_cont_type : context -> cont_type -> cont_type -> bool
 
 val match_table_type : context -> table_type -> table_type -> bool
 val match_memory_type : context -> memory_type -> memory_type -> bool
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index fa9df084..15b18ae7 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -46,8 +46,8 @@ let type_ (c : context) x = lookup "type" c.types x
 let func (c : context) x = lookup "function" c.funcs x
 let table (c : context) x = lookup "table" c.tables x
 let memory (c : context) x = lookup "memory" c.memories x
-let tag (c : context) x = lookup "tag" c.tags x
 let global (c : context) x = lookup "global" c.globals x
+let tag (c : context) x = lookup "tag" c.tags x
 let elem (c : context) x = lookup "elem segment" c.elems x
 let data (c : context) x = lookup "data segment" c.datas x
 let local (c : context) x = lookup "local" c.locals x
@@ -67,7 +67,12 @@ let init_locals (c : context) xs =
 let func_type (c : context) x =
   match expand_def_type (type_ c x) with
   | DefFuncT ft -> ft
-  | _ -> error x.at ("non-function type " ^ I32.to_string_u x.it)
+  | _ -> error x.at ("non-function type " ^ Int32.to_string x.it)
+
+let cont_type (c : context) x =
+  match expand_def_type (type_ c x) with
+  | DefContT ct -> ct
+  | _ -> error x.at ("non-continuation type " ^ Int32.to_string x.it)
 
 let struct_type (c : context) x =
   match expand_def_type (type_ c x) with
@@ -87,6 +92,28 @@ let refer category (s : Free.Set.t) x =
 let refer_func (c : context) x = refer "function" c.refs.Free.funcs x
 
 
+(* Conversions *)
+
+let cont_type_of_heap_type (c : context) (ht : heap_type) at : cont_type =
+  match ht with
+  | DefHT dt -> as_cont_str_type (expand_def_type dt)
+  | VarHT (StatX x) -> cont_type c (x @@ at)
+  | _ -> assert false
+
+let func_type_of_heap_type (c : context) (ht : heap_type) at : func_type =
+  match ht with
+  | DefHT dt -> as_func_str_type (expand_def_type dt)
+  | VarHT (StatX x) -> func_type c (x @@ at)
+  | _ -> assert false
+
+let func_type_of_cont_type (c : context) (ContT ht) at : func_type =
+  func_type_of_heap_type c ht at
+
+let func_type_of_tag_type (c : context) (TagT dt) at : func_type =
+  match expand_def_type dt with
+  | DefFuncT ft -> ft
+  | _ -> error at "non-function type"
+
 (* Types *)
 
 let check_limits {min; max} range at msg =
@@ -108,6 +135,7 @@ let check_heap_type (c : context) (t : heap_type) at =
   match t with
   | AnyHT | NoneHT | EqHT | I31HT | StructHT | ArrayHT
   | FuncHT | NoFuncHT
+  | ContHT | NoContHT
   | ExnHT | NoExnHT
   | ExternHT | NoExternHT -> ()
   | VarHT (StatX x) -> let _dt = type_ c (x @@ at) in ()
@@ -150,6 +178,12 @@ let check_func_type (c : context) (ft : func_type) at =
   check_result_type c ts1 at;
   check_result_type c ts2 at
 
+let check_cont_type (c : context) (ct : cont_type) at =
+  match ct with
+  | ContT (VarHT (StatX x)) ->
+    let _dt = func_type c (x @@ at) in ()
+  | _ -> assert false
+
 let check_table_type (c : context) (tt : table_type) at =
   let TableT (lim, t) = tt in
   check_limits lim 0xffff_ffffl at "table size must be at most 2^32-1";
@@ -160,16 +194,20 @@ let check_memory_type (c : context) (mt : memory_type) at =
   check_limits lim 0x1_0000l at
     "memory size must be at most 65536 pages (4GiB)"
 
+let check_tag_type (c : context) (et : tag_type) at =
+  match et with
+  | TagT dt -> check_func_type c (as_func_str_type (expand_def_type dt)) at
+
 let check_global_type (c : context) (gt : global_type) at =
   let GlobalT (_mut, t) = gt in
   check_val_type c t at
 
-
 let check_str_type (c : context) (st : str_type) at =
   match st with
   | DefStructT st -> check_struct_type c st at
   | DefArrayT rt -> check_array_type c rt at
   | DefFuncT ft -> check_func_type c ft at
+  | DefContT ct -> check_cont_type c ct at
 
 let check_sub_type (c : context) (sut : sub_type) at =
   let SubT (_fin, hts, st) = sut in
@@ -383,6 +421,29 @@ let check_memop (c : context) (memop : ('t, 's) memop) ty_size get_sz at =
  * declarative typing rules.
  *)
 
+let check_resume_table (c : context) ts2 (xys : (idx * hdl) list) at =
+  List.iter (fun (x1, x2) ->
+      match x2 with
+      | OnLabel x2 ->
+        let FuncT (ts3, ts4) = func_type_of_tag_type c (tag c x1) x1.at in
+        let ts' = label c x2 in
+        (match Lib.List.last_opt ts' with
+        | Some (RefT (nul', ht)) ->
+          let ct = cont_type_of_heap_type c ht x2.at in
+          let ft' = func_type_of_cont_type c ct x2.at in
+          require (match_func_type c.types (FuncT (ts4, ts2)) ft') x2.at
+            "type mismatch in continuation type";
+          match_stack c (ts3 @ [RefT (nul', ht)]) ts' x2.at
+        | _ ->
+           error at
+             ("type mismatch: instruction requires continuation reference type" ^
+                " but label has " ^ string_of_result_type ts'))
+      | OnSwitch ->
+        let FuncT (ts3, ts4) = func_type_of_tag_type c (tag c x1) x1.at in
+        require (match_result_type c.types ts3 []) x1.at
+          "type mismatch tag type"
+    ) xys
+
 let check_block_type (c : context) (bt : block_type) at : instr_type =
   match bt with
   | ValBlockType None -> InstrT ([], [], [])
@@ -431,10 +492,12 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     (ts1 @ [NumT I32T]) --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | Br x ->
-    label c x -->... [], []
+    let ts = label c x in
+    ts -->... [], []
 
   | BrIf x ->
-    (label c x @ [NumT I32T]) --> label c x, []
+    let ts = label c x in
+    (ts @ [NumT I32T]) --> ts, []
 
   | BrTable (xs, x) ->
     let n = List.length (label c x) in
@@ -445,18 +508,20 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
 
   | BrOnNull x ->
     let (_nul, ht) = peek_ref 0 s e.at in
-    (label c x @ [RefT (Null, ht)]) --> (label c x @ [RefT (NoNull, ht)]), []
+    let ts = label c x in
+    (ts @ [RefT (Null, ht)]) --> (ts @ [RefT (NoNull, ht)]), []
 
   | BrOnNonNull x ->
     let (_nul, ht) = peek_ref 0 s e.at in
     let t' = RefT (NoNull, ht) in
-    require (label c x <> []) e.at
+    let ts = label c x in
+    require (ts <> []) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
        " but label has " ^ string_of_result_type (label c x));
     let ts0, t1 = Lib.List.split_last (label c x) in
     require (match_val_type c.types t' t1) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
-       " but label has " ^ string_of_result_type (label c x));
+       " but label has " ^ string_of_result_type ts);
     (ts0 @ [RefT (Null, ht)]) --> ts0, []
 
   | BrOnCast (x, rt1, rt2) ->
@@ -536,9 +601,67 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
        " but callee returns " ^ string_of_result_type ts2);
     (ts1 @ [NumT I32T]) -->... [], []
 
+  | ContNew x ->
+    let ContT ht = cont_type c x in
+    [RefT (Null, ht)] -->
+    [RefT (NoNull, VarHT (StatX x.it))], []
+
+  | ContBind (x, y) ->
+    let ct = cont_type c x in
+    let FuncT (ts1, ts2) = func_type_of_cont_type c ct x.at in
+    let ct' = cont_type c y in
+    let FuncT (ts1', _) as ft' = func_type_of_cont_type c ct' y.at in
+    require (List.length ts1 >= List.length ts1') x.at
+      "type mismatch in continuation arguments";
+    let ts11, ts12 = Lib.List.split (List.length ts1 - List.length ts1') ts1 in
+    require (match_func_type c.types (FuncT (ts12, ts2)) ft') e.at
+      "type mismatch in continuation types";
+    (ts11 @ [RefT (Null, VarHT (StatX x.it))]) -->
+      [RefT (NoNull, VarHT (StatX y.it))], []
+
+  | Suspend x ->
+    let tag = tag c x in
+    let FuncT (ts1, ts2) = func_type_of_tag_type c tag x.at in
+    ts1 --> ts2, []
+
+  | Resume (x, xys) ->
+    let ct = cont_type c x in
+    let FuncT (ts1, ts2) = func_type_of_cont_type c ct x.at in
+    check_resume_table c ts2 xys e.at;
+    (ts1 @ [RefT (Null, VarHT (StatX x.it))]) --> ts2, []
+
+  | ResumeThrow (x, y, xys) ->
+    let ct = cont_type c x in
+    let FuncT (ts1, ts2) = func_type_of_cont_type c ct x.at in
+    let tag = tag c y in
+    let FuncT (ts0, _) = func_type_of_tag_type c tag y.at in
+    check_resume_table c ts2 xys e.at;
+    (ts0 @ [RefT (Null, VarHT (StatX x.it))]) --> ts2, []
+
+  | Switch (x, y) ->
+     let ct1 = cont_type c x in
+     let FuncT (ts11, ts12) = func_type_of_cont_type c ct1 x.at in
+     let FuncT (ts21, ts22) =
+       match Lib.List.last_opt ts11 with
+       | Some (RefT (nul', ht)) ->
+         func_type_of_cont_type c (cont_type_of_heap_type c ht x.at) x.at
+       | _ ->
+         error x.at
+           ("type mismatch: instruction requires continuation reference type" ^
+              " but the type annotation has " ^ string_of_result_type ts11)
+     in
+     let et = tag c y in
+     let FuncT (_, t) as ft = func_type_of_tag_type c et y.at in
+     require (match_func_type c.types (FuncT ([], t)) ft) y.at
+       "type mismatch in switch tag";
+     require (match_result_type c.types ts12 t) y.at
+       "type mismatch in continuation types";
+     require (match_result_type c.types t ts22) y.at
+       "type mismatch in continuation types";
+     ts11 --> ts21, []
+
   | Throw x ->
-    let TagT dt = tag c x in
-    let FuncT (ts1, ts2) = as_func_str_type (expand_def_type dt) in
+    let FuncT (ts1, ts2) = func_type_of_tag_type c (tag c x) x.at in
     ts1 -->... [], []
 
   | ThrowRef ->
@@ -933,8 +1056,7 @@ and check_catch (c : context) (cc : catch) (ts : val_type list) at =
   let match_target = match_resulttype "label" "catch handler" in
   match cc.it with
   | Catch (x1, x2) ->
-    let TagT dt = tag c x1 in
-    let FuncT (ts1, ts2) = as_func_str_type (expand_def_type dt) in
+    let FuncT (ts1, ts2) = func_type_of_tag_type c (tag c x1) x1.at in
     match_target c ts1 (label c x2) cc.at
   | CatchRef (x1, x2) ->
     let TagT dt = tag c x1 in
@@ -1019,11 +1141,6 @@ let check_memory (c : context) (mem : memory) : context =
   check_memory_type c mtype mem.at;
   {c with memories = c.memories @ [mtype]}
 
-let check_tag (c : context) (t : tag) : context =
-  let FuncT (_, ts2) = func_type c t.it.tgtype in
-  require (ts2 = []) t.it.tgtype.at "non-empty tag result type";
-  {c with tags = c.tags @ [TagT (type_ c t.it.tgtype)]}
-
 let check_elem_mode (c : context) (t : ref_type) (mode : segment_mode) =
   match mode.it with
   | Passive -> ()
@@ -1055,6 +1172,11 @@ let check_data (c : context) (seg : data_segment) : context =
   check_data_mode c dmode;
   {c with datas = c.datas @ [()]}
 
+let check_tag (c : context) (tag : tag) : context =
+  check_tag_type c (TagT (type_ c tag.it.tgtype)) tag.at;
+  {c with tags = c.tags @ [TagT (type_ c tag.it.tgtype)]}
+
+
 
 (* Modules *)
 
@@ -1108,6 +1230,7 @@ let check_module (m : module_) =
     |> check_list check_type m.it.types
     |> check_list check_import m.it.imports
     |> check_list check_func m.it.funcs
+    |> check_list check_tag m.it.tags
     |> check_list check_table m.it.tables
     |> check_list check_memory m.it.memories
     |> check_list check_global m.it.globals
diff --git a/proposals/continuations/Explainer.md b/proposals/continuations/Explainer.md
index 72f00df7..b0db8a45 100644
--- a/proposals/continuations/Explainer.md
+++ b/proposals/continuations/Explainer.md
@@ -216,7 +216,7 @@ a *handler*, which handles subsequent control suspensions within the
 continuation.
 
 ```wast
-  resume $ct (tag $e $l)* : [tp* (ref $ct)] -> [tr*]
+  resume $ct (on $e $l)* : [tp* (ref $ct)] -> [tr*]
   where:
   - $ct = cont [tp*] -> [tr*]
 ```
@@ -440,7 +440,7 @@ We assume a suitable interface to a queue of active threads
 represented as continuations. The scheduler is a loop which repeatedly
 runs the continuation (thread) at the head of the queue. It does so by
 resuming the continuation with a handler for the `$yield` tag. The
-handler `(tag $yield $on_yield)` specifies that the `$yield` tag
+handler `(on $yield $on_yield)` specifies that the `$yield` tag
 is handled by running the code immediately following the block
 labelled with `$on_yield`, the `$on_yield` clause. The result of the
 block `(result (ref $cont))` declares that there will be a
@@ -1439,7 +1439,7 @@ executing a variant of the `resume` instruction and is passed to the
 continuation:
 
 ```wast
-  resume_with $ht $ct (tag $e $l)* : [ t1* (ref $ht) (ref $ct) ] -> [ t2* ]
+  resume_with $ht $ct (on $e $l)* : [ t1* (ref $ht) (ref $ct) ] -> [ t2* ]
   where:
   - $ht = handler t2*
   - $ct = cont ([ (ref $ht) t1* ] -> [ t2* ])
@@ -1491,7 +1491,7 @@ instruction for switching directly to another continuation:
 This behaves as if there was a built-in tag
 
 ```wast
-  (tag $Switch (param t1* (ref $ct1)) (result t3*))
+  (on $Switch (param t1* (ref $ct1)) (result t3*))
 ```
 
 with which the computation suspends to the handler, and the handler
diff --git a/proposals/continuations/Overview.md b/proposals/continuations/Overview.md
index 7b4e5fc0..04a9a8e3 100644
--- a/proposals/continuations/Overview.md
+++ b/proposals/continuations/Overview.md
@@ -31,27 +31,27 @@ Based on [typed reference proposal](https://github.com/WebAssembly/function-refe
   - `suspend $t : [t1*] -> [t2*]`
     - iff `tag $t : [t1*] -> [t2*]`
 
-* `resume <typeidx> (tag <tagidx> <labelidx>)*` resumes a continuation
-  - `resume $ct (tag $t $l)* : [t1* (ref null? $ct)] -> [t2*]`
+* `resume <typeidx> (on <tagidx> <labelidx>)*` resumes a continuation
+  - `resume $ct (on $t $l)* : [t1* (ref null? $ct)] -> [t2*]`
     - iff `$ct = cont $ft`
     - and `$ft = [t1*] -> [t2*]`
-    - and `(tag $t : [te1*] -> [te2*])*`
+    - and `(on $t : [te1*] -> [te2*])*`
     - and `(label $l : [te1'* (ref null? $ct')])*`
     - and `([te1*] <: [te1'*])*`
     - and `($ct' = cont $ft')*`
-    - and `$ft' = [t1'*] -> [t2'*]`
+    - and `($ft' = [t1'*] -> [t2'*])*`
     - and `([te2*] -> [t2*] <: [t1'*] -> [t2'*])*`
 
-* `resume_throw <typeidx> <tagidx> (tag <tagidx> <labelidx>)` aborts a continuation
-  - `resume_throw $ct $e (tag $t $l): [te* (ref null? $ct)] -> [t2*]`
+* `resume_throw <typeidx> <tagidx> (on <tagidx> <labelidx>)*` aborts a continuation
+  - `resume_throw $ct $e (on $t $l)* : [te* (ref null? $ct)] -> [t2*]`
     - iff `(tag $e : [te*] -> [])`
     - and `$ct = cont $ft`
     - and `$ft = [t1*] -> [t2*]`
-    - and `(tag $t : [te1*] -> [te2*])*`
+    - and `(on $t : [te1*] -> [te2*])*`
     - and `(label $l : [te1'* (ref null? $ct')])*`
     - and `([te1*] <: [te1'*])*`
     - and `($ct' = cont $ft')*`
-    - and `$ft' = [t1'*] -> [t2'*]`
+    - and `($ft' = [t1'*] -> [t2'*])*`
     - and `([te2*] -> [t2*] <: [t1'*] -> [t2'*])*`
 
 * `barrier <blocktype> <instr>* end` blocks suspension
@@ -131,22 +131,22 @@ H^ea ::=
   - and `S' = S with conts[ca] = epsilon with conts += (E : |t1'*|)`
   - and `E = E'[v^n _]`
 
-* `S; F; (ref.null t) (resume $ct (tag $e $l)*)  -->  S; F; trap`
+* `S; F; (ref.null t) (resume $ct (on $e $l)*)  -->  S; F; trap`
 
-* `S; F; (ref.cont ca) (resume $ct (tag $e $l)*)  -->  S; F; trap`
+* `S; F; (ref.cont ca) (resume $ct (on $e $l)*)  -->  S; F; trap`
   - iff `S.conts[ca] = epsilon`
 
-* `S; F; v^n (ref.cont ca) (resume $ct (tag $t $l)*)  -->  S'; F; handle{(ea $l)*} E[v^n] end`
+* `S; F; v^n (ref.cont ca) (resume $ct (on $t $l)*)  -->  S'; F; handle{(ea $l)*} E[v^n] end`
   - iff `S.conts[ca] = (E : n)`
   - and `(ea = F.tags[$t])*`
   - and `S' = S with conts[ca] = epsilon`
 
-* `S; F; (ref.null t) (resume_throw $ct $e (tag $t $l)*)  -->  S; F; trap`
+* `S; F; (ref.null t) (resume_throw $ct $e (on $t $l)*)  -->  S; F; trap`
 
-* `S; F; (ref.cont ca) (resume_throw $ct $e (tag $t $l)*)  -->  S; F; trap`
+* `S; F; (ref.cont ca) (resume_throw $ct $e (on $t $l)*)  -->  S; F; trap`
   - iff `S.conts[ca] = epsilon`
 
-* `S; F; v^m (ref.cont ca) (resume_throw $ct $e (tag $t $l)*)  -->  S'; F; handle{(ea $l)*} E[v^m (throw $e)] end`
+* `S; F; v^m (ref.cont ca) (resume_throw $ct $e (on $t $l)*)  -->  S'; F; handle{(ea $l)*} E[v^m (throw $e)] end`
   - iff `S.conts[ca] = (E : n)`
   - and `(ea = F.tags[$t])*`
   - and `S.tags[F.tags[$e]].type = [t1^m] -> [t2*]`
diff --git a/proposals/continuations/examples/actor-lwt.wast b/proposals/continuations/examples/actor-lwt.wast
index 60d87959..4fc7dcb6 100644
--- a/proposals/continuations/examples/actor-lwt.wast
+++ b/proposals/continuations/examples/actor-lwt.wast
@@ -62,228 +62,6 @@
 )
 (register "chain")
 
-;; queues of threads and mailboxes
-(module $queue
-  (type $func (func))       ;; [] -> []
-  (type $cont (cont $func)) ;; cont ([] -> [])
-
-  (func $log (import "spectest" "print_i32") (param i32))
-
-  ;; table (threads) and memory (mailboxes) as simple queues
-  (table $queue 0 (ref null $cont))
-  (memory 1)
-
-  (tag $too-many-mailboxes)
-
-  (global $qdelta i32 (i32.const 10))
-
-  (global $qback-k (mut i32) (i32.const 0))
-  (global $qfront-k (mut i32) (i32.const 0))
-
-  (func $queue-empty-k (export "queue-empty") (result i32)
-    (i32.eq (global.get $qfront-k) (global.get $qback-k))
-  )
-
-  (func $dequeue-k (export "dequeue-k") (result (ref null $cont))
-    (local $i i32)
-    (if (call $queue-empty-k)
-      (then (return (ref.null $cont)))
-    )
-    (local.set $i (global.get $qfront-k))
-    (global.set $qfront-k (i32.add (local.get $i) (i32.const 1)))
-    (table.get $queue (local.get $i))
-  )
-
-  (func $enqueue-k (export "enqueue-k") (param $k (ref $cont))
-    ;; Check if queue is full
-    (if (i32.eq (global.get $qback-k) (table.size $queue))
-      (then
-        ;; Check if there is enough space in the front to compact
-        (if (i32.lt_u (global.get $qfront-k) (global.get $qdelta))
-          (then
-            ;; Space is below threshold, grow table instead
-            (drop (table.grow $queue (ref.null $cont) (global.get $qdelta)))
-          )
-          (else
-            ;; Enough space, move entries up to head of table
-            (global.set $qback-k (i32.sub (global.get $qback-k) (global.get $qfront-k)))
-            (table.copy $queue $queue
-              (i32.const 0)         ;; dest = new front = 0
-              (global.get $qfront-k)  ;; src = old front
-              (global.get $qback-k)   ;; len = new back = old back - old front
-            )
-            (table.fill $queue      ;; null out old entries to avoid leaks
-              (global.get $qback-k)   ;; start = new back
-              (ref.null $cont)      ;; init value
-              (global.get $qfront-k)  ;; len = old front = old front - new front
-            )
-            (global.set $qfront-k (i32.const 0))
-          )
-        )
-      )
-    )
-    (table.set $queue (global.get $qback-k) (local.get $k))
-    (global.set $qback-k (i32.add (global.get $qback-k) (i32.const 1)))
-  )
-
-  (global $qback-mb (mut i32) (i32.const 0))
-  (global $qfront-mb (mut i32) (i32.const 0))
-
-  (func $queue-empty-mb (export "queue-empty-mb") (result i32)
-    (i32.eq (global.get $qfront-mb) (global.get $qback-mb))
-  )
-
-  (func $dequeue-mb (export "dequeue-mb") (result i32)
-    (local $i i32)
-    (local $mb i32)
-    (if (call $queue-empty-mb)
-      (then (return (i32.const -1)))
-    )
-    (local.set $i (global.get $qfront-mb))
-    (global.set $qfront-mb (i32.add (local.get $i) (i32.const 1)))
-    (local.set $mb (i32.load (i32.mul (local.get $i) (i32.const 4))))
-    (return (local.get $mb))
-  )
-
-  (func $enqueue-mb (export "enqueue-mb") (param $mb i32)
-    ;; Check if queue is full
-    (if (i32.eq (global.get $qback-mb) (i32.const 16383))
-      (then
-        ;; Check if there is enough space in the front to compact
-        (if (i32.lt_u (global.get $qfront-mb) (global.get $qdelta))
-          (then
-            ;; Space is below threshold, throw exception
-            (throw $too-many-mailboxes)
-          )
-          (else
-            ;; Enough space, move entries up to head of table
-            (global.set $qback-mb (i32.sub (global.get $qback-mb) (global.get $qfront-mb)))
-            (memory.copy
-              (i32.const 0)                                    ;; dest = new front = 0
-              (i32.mul (global.get $qfront-mb) (i32.const 4))  ;; src = old front
-              (i32.mul (global.get $qback-mb) (i32.const 4))   ;; len = new back = old back - old front
-            )
-            (memory.fill                                       ;; null out old entries to avoid leaks
-              (i32.mul (global.get $qback-mb) (i32.const 4))   ;; start = new back
-              (i32.const -1)                                   ;; init value
-              (i32.mul (global.get $qfront-mb) (i32.const 4))  ;; len = old front = old front - new front
-            )
-            (global.set $qfront-mb (i32.const 0))
-          )
-        )
-      )
-    )
-    (i32.store (i32.mul (global.get $qback-mb) (i32.const 4)) (local.get $mb))
-    (global.set $qback-mb (i32.add (global.get $qback-mb) (i32.const 1)))
-  )
-)
-(register "queue")
-
-(module $mailboxes
-  ;; Stupid implementation of mailboxes that raises an exception if
-  ;; there are too many mailboxes or if more than one message is sent
-  ;; to any given mailbox.
-  ;;
-  ;; Sufficient for the simple chain example.
-
-  ;; -1 means empty
-
-  (func $log (import "spectest" "print_i32") (param i32))
-
-  (tag $too-many-mailboxes)
-  (tag $too-many-messages)
-
-  (memory 1)
-
-  (global $msize (mut i32) (i32.const 0)) ;; current number of mailboxes
-  (global $mmax i32 (i32.const 1024))     ;; maximum number of mailboxes
-
-  (func $init (export "init")
-     (global.set $msize (i32.const 0))
-     (memory.fill (i32.const 0) (i32.const -1) (i32.mul (global.get $mmax) (i32.const 4)))
-  )
-
-  (func $empty-mb (export "empty-mb") (param $mb i32) (result i32)
-    (local $offset i32)
-    (local.set $offset (i32.mul (local.get $mb) (i32.const 4)))
-    (i32.eq (i32.load (local.get $offset)) (i32.const -1))
-  )
-
-  (func $new-mb (export "new-mb") (result i32)
-     (local $mb i32)
-
-     (if (i32.ge_u (global.get $msize) (global.get $mmax))
-         (then (throw $too-many-mailboxes))
-     )
-
-     (local.set $mb (global.get $msize))
-     (global.set $msize (i32.add (global.get $msize) (i32.const 1)))
-     (return (local.get $mb))
-  )
-
-  (func $send-to-mb (export "send-to-mb") (param $v i32) (param $mb i32)
-    (local $offset i32)
-    (local.set $offset (i32.mul (local.get $mb) (i32.const 4)))
-    (if (call $empty-mb (local.get $mb))
-      (then (i32.store (local.get $offset) (local.get $v)))
-      (else (throw $too-many-messages))
-    )
-  )
-
-  (func $recv-from-mb (export "recv-from-mb") (param $mb i32) (result i32)
-    (local $v i32)
-    (local $offset i32)
-    (local.set $offset (i32.mul (local.get $mb) (i32.const 4)))
-    (local.set $v (i32.load (local.get $offset)))
-    (i32.store (local.get $offset) (i32.const -1))
-    (local.get $v)
-  )
-)
-(register "mailboxes")
-
-
-;; a simple example - pass a message through a chain of actors
-(module $chain
-  (type $func (func))
-  (type $cont (cont $func))
-
-  (type $i-func (func (param i32)))
-  (type $i-cont (cont $i-func))
-
-  (tag $self (import "actor" "self") (result i32))
-  (tag $spawn (import "actor" "spawn") (param (ref $cont)) (result i32))
-  (tag $send (import "actor" "send") (param i32 i32))
-  (tag $recv (import "actor" "recv") (result i32))
-
-  (elem declare func $next)
-
-  (func $log (import "spectest" "print_i32") (param i32))
-
-  (func $next (param $p i32)
-    (local $s i32)
-    (local.set $s (suspend $recv))
-    (call $log (i32.const -1))
-    (suspend $send (local.get $s) (local.get $p))
-  )
-
-  ;; send the message 42 through a chain of n actors
-  (func $chain (export "chain") (param $n i32)
-    (local $p i32)
-    (local.set $p (suspend $self))
-
-    (loop $l
-      (if (i32.eqz (local.get $n))
-        (then (suspend $send (i32.const 42) (local.get $p)))
-        (else (local.set $p (suspend $spawn (cont.bind $i-cont $cont (local.get $p) (cont.new $i-cont (ref.func $next)))))
-              (local.set $n (i32.sub (local.get $n) (i32.const 1)))
-              (br $l))
-      )
-    )
-    (call $log (suspend $recv))
-  )
-)
-(register "chain")
-
 ;; interface to lightweight threads
 (module $lwt
   (type $func (func))
@@ -371,7 +149,7 @@
       (if (call $queue-empty) (then (return)))
       (block $on_yield (result (ref $cont))
         (block $on_fork (result (ref $cont) (ref $cont))
-          (resume $cont (tag $yield $on_yield) (tag $fork $on_fork)
+          (resume $cont (on $yield $on_yield) (on $fork $on_fork)
             (call $dequeue)
           )
           (br $l)  ;; thread terminated
@@ -498,10 +276,10 @@
         (block $on_spawn (result (ref $cont) (ref $i-cont))
           (block $on_send (result i32 i32 (ref $cont))
             (block $on_recv (result (ref $i-cont))
-               (resume $cont (tag $self $on_self)
-                             (tag $spawn $on_spawn)
-                             (tag $send $on_send)
-                             (tag $recv $on_recv)
+               (resume $cont (on $self $on_self)
+                             (on $spawn $on_spawn)
+                             (on $send $on_send)
+                             (on $recv $on_recv)
                              (local.get $nextk)
                )
                (return)
diff --git a/proposals/continuations/examples/actor.wast b/proposals/continuations/examples/actor.wast
index 151c08d5..61caced2 100644
--- a/proposals/continuations/examples/actor.wast
+++ b/proposals/continuations/examples/actor.wast
@@ -329,10 +329,10 @@
         (block $on_spawn (result (ref $cont) (ref $i-cont))
           (block $on_send (result i32 i32 (ref $cont))
             (block $on_recv (result (ref $i-cont))
-               (resume $cont (tag $self $on_self)
-                             (tag $spawn $on_spawn)
-                             (tag $send $on_send)
-                             (tag $recv $on_recv)
+               (resume $cont (on $self $on_self)
+                             (on $spawn $on_spawn)
+                             (on $send $on_send)
+                             (on $recv $on_recv)
                              (local.get $nextk)
                )
                (local.set $mine (call $dequeue-mb))
diff --git a/proposals/continuations/examples/async-await.wast b/proposals/continuations/examples/async-await.wast
index 53570c3b..da6a0683 100644
--- a/proposals/continuations/examples/async-await.wast
+++ b/proposals/continuations/examples/async-await.wast
@@ -265,10 +265,10 @@
         (block $on_fulfill (result i32 i32 (ref $cont))
           (block $on_async (result (ref $i-cont) (ref $i-cont))
             (block $on_await (result i32 (ref $i-cont))
-              (resume $cont (tag $yield $on_yield)
-                            (tag $fulfill $on_fulfill)
-                            (tag $async $on_async)
-                            (tag $await $on_await)
+              (resume $cont (on $yield $on_yield)
+                            (on $fulfill $on_fulfill)
+                            (on $async $on_async)
+                            (on $await $on_await)
                             (local.get $nextk)
               )
               (local.set $nextk (call $dequeue))
diff --git a/proposals/continuations/examples/control-lwt.wast b/proposals/continuations/examples/control-lwt.wast
index d7c00cb3..cfd2357d 100644
--- a/proposals/continuations/examples/control-lwt.wast
+++ b/proposals/continuations/examples/control-lwt.wast
@@ -29,7 +29,7 @@
     (local $h (ref $cont-cont))
     (local $k (ref $cont))
     (block $on_control (result (ref $cont-cont) (ref $cont))
-       (resume $cont (tag $control $on_control)
+       (resume $cont (on $control $on_control)
                      (local.get $nextk))
        (return)
     ) ;;   $on_control (param (ref $cont-func) (ref $cont))
diff --git a/proposals/continuations/examples/fun-actor-lwt.wast b/proposals/continuations/examples/fun-actor-lwt.wast
index a9cfff91..88fe6043 100644
--- a/proposals/continuations/examples/fun-actor-lwt.wast
+++ b/proposals/continuations/examples/fun-actor-lwt.wast
@@ -143,7 +143,7 @@
       (if (call $queue-empty) (then (return)))
       (block $on_yield (result (ref $cont))
         (block $on_fork (result (ref $cont) (ref $cont))
-          (resume $cont (tag $yield $on_yield) (tag $fork $on_fork)
+          (resume $cont (on $yield $on_yield) (on $fork $on_fork)
             (call $dequeue)
           )
           (br $l)  ;; thread terminated
@@ -262,10 +262,10 @@
           (block $on_recv (result (ref $i-cont))
              ;; this should really be a tail call to the continuation
              ;; do we need a 'return_resume' operator?
-             (resume $i-cont (tag $self $on_self)
-                             (tag $spawn $on_spawn)
-                             (tag $send $on_send)
-                             (tag $recv $on_recv)
+             (resume $i-cont (on $self $on_self)
+                             (on $spawn $on_spawn)
+                             (on $send $on_send)
+                             (on $recv $on_recv)
                              (local.get $res) (local.get $ik)
              )
              (return)
@@ -312,10 +312,10 @@
           (block $on_recv (result (ref $i-cont))
              ;; this should really be a tail call to the continuation
              ;; do we need a 'return_resume' operator?
-             (resume $cont (tag $self $on_self)
-                           (tag $spawn $on_spawn)
-                           (tag $send $on_send)
-                           (tag $recv $on_recv)
+             (resume $cont (on $self $on_self)
+                           (on $spawn $on_spawn)
+                           (on $send $on_send)
+                           (on $recv $on_recv)
                            (local.get $k)
              )
              (return)
diff --git a/proposals/continuations/examples/fun-lwt.wast b/proposals/continuations/examples/fun-lwt.wast
index 2b57b53d..4d7b2e6e 100644
--- a/proposals/continuations/examples/fun-lwt.wast
+++ b/proposals/continuations/examples/fun-lwt.wast
@@ -133,8 +133,8 @@
     (block $on_yield (result (ref $cont))
       (block $on_fork (result (ref $cont) (ref $cont))
         (resume $cont
-          (tag $yield $on_yield)
-          (tag $fork $on_fork)
+          (on $yield $on_yield)
+          (on $fork $on_fork)
           (local.get $nextk)
         )
         (return_call $sync (call $dequeue))
@@ -160,8 +160,8 @@
     (block $on_yield (result (ref $cont))
       (block $on_fork (result (ref $cont) (ref $cont))
         (resume $cont
-          (tag $yield $on_yield)
-          (tag $fork $on_fork)
+          (on $yield $on_yield)
+          (on $fork $on_fork)
           (local.get $nextk)
         )
         (return_call $tk (call $dequeue))
@@ -180,8 +180,8 @@
     (block $on_yield (result (ref $cont))
       (block $on_fork (result (ref $cont) (ref $cont))
         (resume $cont
-          (tag $yield $on_yield)
-          (tag $fork $on_fork)
+          (on $yield $on_yield)
+          (on $fork $on_fork)
           (local.get $nextk))
         (return_call $kt (call $dequeue))
       ) ;;   $on_fork (result (ref $cont) (ref $cont))
@@ -197,8 +197,8 @@
     (block $on_yield (result (ref $cont))
       (block $on_fork (result (ref $cont) (ref $cont))
         (resume $cont
-          (tag $yield $on_yield)
-          (tag $fork $on_fork)
+          (on $yield $on_yield)
+          (on $fork $on_fork)
           (local.get $nextk)
         )
         (return_call $ykt (call $dequeue))
@@ -217,7 +217,7 @@
     (if (ref.is_null (local.get $nextk)) (then (return)))
     (block $on_yield (result (ref $cont))
       (block $on_fork (result (ref $cont) (ref $cont))
-        (resume $cont (tag $yield $on_yield) (tag $fork $on_fork) (local.get $nextk))
+        (resume $cont (on $yield $on_yield) (on $fork $on_fork) (local.get $nextk))
         (return_call $ytk (call $dequeue))
       ) ;;   $on_fork (result (ref $cont) (ref $cont))
       (local.set $k)
diff --git a/proposals/continuations/examples/fun-pipes.wast b/proposals/continuations/examples/fun-pipes.wast
index 4c4008de..85ca0185 100644
--- a/proposals/continuations/examples/fun-pipes.wast
+++ b/proposals/continuations/examples/fun-pipes.wast
@@ -10,7 +10,7 @@
 
   (func $piper (param $n i32) (param $p (ref $producer)) (param $c (ref $consumer))
      (block $on-receive (result (ref $consumer))
-        (resume $consumer (tag $receive $on-receive) (local.get $n) (local.get $c))
+        (resume $consumer (on $receive $on-receive) (local.get $n) (local.get $c))
         (return)
      ) ;; receive
      (local.set $c)
@@ -20,7 +20,7 @@
   (func $copiper (param $c (ref $consumer)) (param $p (ref $producer))
      (local $n i32)
      (block $on-send (result i32 (ref $producer))
-        (resume $producer (tag $send $on-send) (local.get $p))
+        (resume $producer (on $send $on-send) (local.get $p))
         (return)
      ) ;; send
      (local.set $p)
diff --git a/proposals/continuations/examples/fun-state.wast b/proposals/continuations/examples/fun-state.wast
index 440aaedf..8ffde96b 100644
--- a/proposals/continuations/examples/fun-state.wast
+++ b/proposals/continuations/examples/fun-state.wast
@@ -12,7 +12,7 @@
   (func $getting (param $k (ref $gk)) (param $s i32) (result i32)
      (block $on_get (result (ref $gk))
        (block $on_set (result i32 (ref $sk))
-          (resume $gk (tag $get $on_get) (tag $set $on_set)
+          (resume $gk (on $get $on_get) (on $set $on_set)
             (local.get $s) (local.get $k)
           )
           (return)
@@ -26,7 +26,7 @@
   (func $setting (param $s i32) (param $k (ref $sk)) (result i32)
      (block $on_get (result (ref $gk))
        (block $on_set (result i32 (ref $sk))
-          (resume $sk (tag $get $on_get) (tag $set $on_set)
+          (resume $sk (on $get $on_get) (on $set $on_set)
             (local.get $k)
           )
           (return)
diff --git a/proposals/continuations/examples/generators.wast b/proposals/continuations/examples/generators.wast
index a7ce4e05..b4bc8727 100644
--- a/proposals/continuations/examples/generators.wast
+++ b/proposals/continuations/examples/generators.wast
@@ -50,7 +50,7 @@
     (loop $l
       (block $on_yield (result i32 (ref $cont))
         (if (local.get $n)
-          (then (resume $cont (tag $yield $on_yield) (local.get $k)))
+          (then (resume $cont (on $yield $on_yield) (local.get $k)))
         )
         (return)
       ) ;;   $on_yield (result i32 (ref $cont))
@@ -67,7 +67,7 @@
     (loop $l
       (block $on_yield (result i32 (ref $cont))
         (if (local.get $n)
-          (then (resume $cont (tag $yield $on_yield) (local.get $k)))
+          (then (resume $cont (on $yield $on_yield) (local.get $k)))
         )
         (return (local.get $sum))
       ) ;;   $on_yield (result i32 (ref $cont))
@@ -99,7 +99,7 @@
     (local $next_k (ref $cont))
     (local $next_v i32)
     (block $on_yield (result i32 (ref $cont))
-      (resume $cont (tag $yield $on_yield)
+      (resume $cont (on $yield $on_yield)
                     (table.get $active (local.get $g))
       )
       (return (i32.const -1))
diff --git a/proposals/continuations/examples/lwt.wast b/proposals/continuations/examples/lwt.wast
index 65232d5b..20b2369b 100644
--- a/proposals/continuations/examples/lwt.wast
+++ b/proposals/continuations/examples/lwt.wast
@@ -135,8 +135,8 @@
       (block $on_yield (result (ref $cont))
         (block $on_fork (result (ref $cont) (ref $cont))
           (resume $cont
-            (tag $yield $on_yield)
-            (tag $fork $on_fork)
+            (on $yield $on_yield)
+            (on $fork $on_fork)
             (local.get $nextk)
           )
           (local.set $nextk (call $dequeue))
@@ -166,8 +166,8 @@
       (block $on_yield (result (ref $cont))
         (block $on_fork (result (ref $cont) (ref $cont))
           (resume $cont
-            (tag $yield $on_yield)
-            (tag $fork $on_fork)
+            (on $yield $on_yield)
+            (on $fork $on_fork)
             (local.get $nextk)
           )
           (local.set $nextk (call $dequeue))
@@ -190,8 +190,8 @@
       (block $on_yield (result (ref $cont))
         (block $on_fork (result (ref $cont) (ref $cont))
           (resume $cont
-            (tag $yield $on_yield)
-            (tag $fork $on_fork)
+            (on $yield $on_yield)
+            (on $fork $on_fork)
             (local.get $nextk)
           )
           (local.set $nextk (call $dequeue))
@@ -214,8 +214,8 @@
       (block $on_yield (result (ref $cont))
         (block $on_fork (result (ref $cont) (ref $cont))
           (resume $cont
-            (tag $yield $on_yield)
-            (tag $fork $on_fork)
+            (on $yield $on_yield)
+            (on $fork $on_fork)
             (local.get $nextk)
           )
           (local.set $nextk (call $dequeue))
@@ -239,8 +239,8 @@
       (block $on_yield (result (ref $cont))
         (block $on_fork (result (ref $cont) (ref $cont))
           (resume $cont
-            (tag $yield $on_yield)
-            (tag $fork $on_fork)
+            (on $yield $on_yield)
+            (on $fork $on_fork)
             (local.get $nextk)
           )
           (local.set $nextk (call $dequeue))
diff --git a/proposals/continuations/examples/pipes.wast b/proposals/continuations/examples/pipes.wast
index e3581785..39324894 100644
--- a/proposals/continuations/examples/pipes.wast
+++ b/proposals/continuations/examples/pipes.wast
@@ -19,7 +19,7 @@
       (if (local.get $consuming)
         (then
            (block $on-receive (result (ref $consumer))
-             (resume $consumer (tag $receive $on-receive) (local.get $n) (local.get $c))
+             (resume $consumer (on $receive $on-receive) (local.get $n) (local.get $c))
              (return)
            ) ;; receive
            (local.set $c)
@@ -28,7 +28,7 @@
         )
       ) ;; else producing
            (block $on-send (result i32 (ref $producer))
-             (resume $producer (tag $send $on-send) (local.get $p))
+             (resume $producer (on $send $on-send) (local.get $p))
              (return)
            ) ;; send
            (local.set $p)
diff --git a/proposals/continuations/examples/static-lwt.wast b/proposals/continuations/examples/static-lwt.wast
index 22bd0f34..ee725236 100644
--- a/proposals/continuations/examples/static-lwt.wast
+++ b/proposals/continuations/examples/static-lwt.wast
@@ -110,7 +110,7 @@
     (loop $l
       (if (call $queue-empty) (then (return)))
       (block $on_yield (result (ref $cont))
-        (resume $cont (tag $yield $on_yield)
+        (resume $cont (on $yield $on_yield)
                       (call $dequeue)
         )
         (br $l)  ;; thread terminated
diff --git a/test/core/stack-switching/cont.wast b/test/core/stack-switching/cont.wast
new file mode 100644
index 00000000..cc84061f
--- /dev/null
+++ b/test/core/stack-switching/cont.wast
@@ -0,0 +1,928 @@
+;; Unhandled tags & guards
+
+(module
+  (tag $exn)
+  (tag $e1)
+  (tag $e2)
+
+  (type $f1 (func))
+  (type $k1 (cont $f1))
+
+  (func $f1 (export "unhandled-1")
+    (suspend $e1)
+  )
+
+  (func (export "unhandled-2")
+    (resume $k1 (cont.new $k1 (ref.func $f1)))
+  )
+
+  (func (export "unhandled-3")
+    (block $h (result (ref $k1))
+      (resume $k1 (on $e2 $h) (cont.new $k1 (ref.func $f1)))
+      (unreachable)
+    )
+    (drop)
+  )
+
+  (func (export "handled")
+    (block $h (result (ref $k1))
+      (resume $k1 (on $e1 $h) (cont.new $k1 (ref.func $f1)))
+      (unreachable)
+    )
+    (drop)
+  )
+
+  (elem declare func $f2)
+  (func $f2
+    (throw $exn)
+  )
+
+  (func (export "uncaught-1")
+    (block $h (result (ref $k1))
+      (resume $k1 (on $e1 $h) (cont.new $k1 (ref.func $f2)))
+      (unreachable)
+    )
+    (drop)
+  )
+
+  (func (export "uncaught-2")
+    (block $h (result (ref $k1))
+      (resume $k1 (on $e1 $h) (cont.new $k1 (ref.func $f1)))
+      (unreachable)
+    )
+    (resume_throw $k1 $exn)
+  )
+
+  (elem declare func $f3)
+  (func $f3
+    (call $f4)
+  )
+  (func $f4
+    (suspend $e1)
+  )
+
+  (func (export "uncaught-3")
+    (block $h (result (ref $k1))
+      (resume $k1 (on $e1 $h) (cont.new $k1 (ref.func $f3)))
+      (unreachable)
+    )
+    (resume_throw $k1 $exn)
+  )
+
+  (elem declare func $r0 $r1)
+  (func $r0)
+  (func $r1 (suspend $e1) (suspend $e1))
+
+  (func $nl1 (param $k (ref $k1))
+    (resume $k1 (local.get $k))
+    (resume $k1 (local.get $k))
+  )
+  (func $nl2 (param $k (ref $k1))
+    (block $h (result (ref $k1))
+      (resume $k1 (on $e1 $h) (local.get $k))
+      (unreachable)
+    )
+    (resume $k1 (local.get $k))
+    (unreachable)
+  )
+  (func $nl3 (param $k (ref $k1))
+    (local $k' (ref null $k1))
+    (block $h1 (result (ref $k1))
+      (resume $k1 (on $e1 $h1) (local.get $k))
+      (unreachable)
+    )
+    (local.set $k')
+    (block $h2 (result (ref $k1))
+      (resume $k1 (on $e1 $h2) (local.get $k'))
+      (unreachable)
+    )
+    (resume $k1 (local.get $k'))
+    (unreachable)
+  )
+  (func $nl4 (param $k (ref $k1))
+    (drop (cont.bind $k1 $k1 (local.get $k)))
+    (resume $k1 (local.get $k))
+  )
+
+  (func (export "non-linear-1")
+    (call $nl1 (cont.new $k1 (ref.func $r0)))
+  )
+  (func (export "non-linear-2")
+    (call $nl2 (cont.new $k1 (ref.func $r1)))
+  )
+  (func (export "non-linear-3")
+    (call $nl3 (cont.new $k1 (ref.func $r1)))
+  )
+  (func (export "non-linear-4")
+    (call $nl4 (cont.new $k1 (ref.func $r1)))
+  )
+)
+
+(assert_suspension (invoke "unhandled-1") "unhandled")
+(assert_suspension (invoke "unhandled-2") "unhandled")
+(assert_suspension (invoke "unhandled-3") "unhandled")
+(assert_return (invoke "handled"))
+
+(assert_exception (invoke "uncaught-1"))
+(assert_exception (invoke "uncaught-2"))
+(assert_exception (invoke "uncaught-3"))
+
+(assert_trap (invoke "non-linear-1") "continuation already consumed")
+(assert_trap (invoke "non-linear-2") "continuation already consumed")
+(assert_trap (invoke "non-linear-3") "continuation already consumed")
+(assert_trap (invoke "non-linear-4") "continuation already consumed")
+
+(assert_invalid
+  (module
+    (type $ft (func))
+    (func
+      (cont.new $ft (ref.null $ft))
+      (drop)))
+  "non-continuation type 0")
+
+(assert_invalid
+  (module
+    (type $ft (func))
+    (type $ct (cont $ft))
+    (func
+      (resume $ft (ref.null $ct))
+      (unreachable)))
+  "non-continuation type 0")
+
+(assert_invalid
+  (module
+    (type $ft (func))
+    (type $ct (cont $ft))
+    (tag $exn)
+    (func
+      (resume_throw $ft $exn (ref.null $ct))
+      (unreachable)))
+  "non-continuation type 0")
+
+(assert_invalid
+  (module
+    (type $ft (func))
+    (type $ct (cont $ft))
+    (func
+      (cont.bind $ft $ct (ref.null $ct))
+      (unreachable)))
+  "non-continuation type 0")
+
+(assert_invalid
+  (module
+    (type $ft (func))
+    (type $ct (cont $ft))
+    (func
+      (cont.bind $ct $ft (ref.null $ct))
+      (unreachable)))
+  "non-continuation type 0")
+
+(assert_invalid
+  (module
+    (type $ft (func))
+    (type $ct (cont $ft))
+    (tag $foo)
+    (func
+      (block $on_foo (result (ref $ft))
+        (resume $ct (on $foo $on_foo) (ref.null $ct))
+        (unreachable)
+      )
+      (drop)))
+  "non-continuation type 0")
+
+(assert_invalid
+  (module
+    (type $ft (func))
+    (type $ct (cont $ft))
+    (tag $foo)
+    (func
+      (block $on_foo (result (ref $ct) (ref $ft))
+        (resume $ct (on $foo $on_foo) (ref.null $ct))
+        (unreachable)
+      )
+      (drop)
+      (drop)))
+  "non-continuation type 0")
+
+(assert_invalid
+  (module
+    (type $ct (cont $ct)))
+  "non-function type 0")
+
+(assert_invalid
+  (module
+    (rec
+      (type $s0 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
+      (type $s1 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
+    )
+    (type $ct (cont $s0)))
+  "non-function type 0")
+
+(module
+  (rec
+    (type $f1 (func (param (ref $f2))))
+    (type $f2 (func (param (ref $f1))))
+  )
+  (type $c1 (cont $f1))
+  (type $c2 (cont $f2))
+)
+
+;; Simple state example
+
+(module $state
+  (tag $get (result i32))
+  (tag $set (param i32) (result i32))
+
+  (type $f (func (param i32) (result i32)))
+  (type $k (cont $f))
+
+  (func $runner (param $s i32) (param $k (ref $k)) (result i32)
+    (loop $loop
+      (block $on_get (result (ref $k))
+        (block $on_set (result i32 (ref $k))
+          (resume $k (on $get $on_get) (on $set $on_set)
+            (local.get $s) (local.get $k)
+          )
+          (return)
+        )
+        ;; on set
+        (local.set $k)
+        (local.set $s)
+        (br $loop)
+      )
+      ;; on get
+      (local.set $k)
+      (br $loop)
+    )
+    (unreachable)
+  )
+
+  (func $f (param i32) (result i32)
+    (drop (suspend $set (i32.const 7)))
+    (i32.add
+      (suspend $get)
+      (i32.mul
+        (i32.const 2)
+        (i32.add
+          (suspend $set (i32.const 3))
+          (suspend $get)
+        )
+      )
+    )
+  )
+
+  (elem declare func $f)
+  (func (export "run") (result i32)
+    (call $runner (i32.const 0) (cont.new $k (ref.func $f)))
+  )
+)
+
+(assert_return (invoke "run") (i32.const 19))
+
+
+;; Simple generator example
+
+(module $generator
+  (type $gen (func (param i64)))
+  (type $geny (func (param i32)))
+  (type $cont0 (cont $gen))
+  (type $cont (cont $geny))
+
+  (tag $yield (param i64) (result i32))
+
+  ;; Hook for logging purposes
+  (global $hook (export "hook") (mut (ref $gen)) (ref.func $dummy))
+  (func $dummy (param i64))
+
+  (func $gen (export "start") (param $i i64)
+    (loop $l
+      (br_if 1 (suspend $yield (local.get $i)))
+      (call_ref $gen (local.get $i) (global.get $hook))
+      (local.set $i (i64.add (local.get $i) (i64.const 1)))
+      (br $l)
+    )
+  )
+
+  (elem declare func $gen)
+
+  (func (export "sum") (param $i i64) (param $j i64) (result i64)
+    (local $sum i64)
+    (local $n i64)
+    (local $k (ref null $cont))
+    (local.get $i)
+    (cont.new $cont0 (ref.func $gen))
+    (block $on_first_yield (param i64 (ref $cont0)) (result i64 (ref $cont))
+      (resume $cont0 (on $yield $on_first_yield))
+      (unreachable)
+    )
+    (loop $on_yield (param i64) (param (ref $cont))
+      (local.set $k)
+      (local.set $n)
+      (local.set $sum (i64.add (local.get $sum) (local.get $n)))
+      (i64.eq (local.get $n) (local.get $j))
+      (local.get $k)
+      (resume $cont (on $yield $on_yield))
+    )
+    (return (local.get $sum))
+  )
+)
+
+(register "generator")
+
+(assert_return (invoke "sum" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "sum" (i64.const 2) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "sum" (i64.const 0) (i64.const 3)) (i64.const 6))
+(assert_return (invoke "sum" (i64.const 1) (i64.const 10)) (i64.const 55))
+(assert_return (invoke "sum" (i64.const 100) (i64.const 2000)) (i64.const 1_996_050))
+
+
+;; Simple scheduler example
+
+(module $scheduler
+  (type $proc (func))
+  (type $cont (cont $proc))
+
+  (tag $yield (export "yield"))
+  (tag $spawn (export "spawn") (param (ref $cont)))
+
+  ;; Table as simple queue (keeping it simple, no ring buffer)
+  (table $queue 0 (ref null $cont))
+  (global $qdelta i32 (i32.const 10))
+  (global $qback (mut i32) (i32.const 0))
+  (global $qfront (mut i32) (i32.const 0))
+
+  (func $queue-empty (result i32)
+    (i32.eq (global.get $qfront) (global.get $qback))
+  )
+
+  (func $dequeue (result (ref null $cont))
+    (local $i i32)
+    (if (call $queue-empty)
+      (then (return (ref.null $cont)))
+    )
+    (local.set $i (global.get $qfront))
+    (global.set $qfront (i32.add (local.get $i) (i32.const 1)))
+    (table.get $queue (local.get $i))
+  )
+
+  (func $enqueue (param $k (ref $cont))
+    ;; Check if queue is full
+    (if (i32.eq (global.get $qback) (table.size $queue))
+      (then
+        ;; Check if there is enough space in the front to compact
+        (if (i32.lt_u (global.get $qfront) (global.get $qdelta))
+          (then
+            ;; Space is below threshold, grow table instead
+            (drop (table.grow $queue (ref.null $cont) (global.get $qdelta)))
+          )
+          (else
+            ;; Enough space, move entries up to head of table
+            (global.set $qback (i32.sub (global.get $qback) (global.get $qfront)))
+            (table.copy $queue $queue
+              (i32.const 0)         ;; dest = new front = 0
+              (global.get $qfront)  ;; src = old front
+              (global.get $qback)   ;; len = new back = old back - old front
+            )
+            (table.fill $queue      ;; null out old entries to avoid leaks
+              (global.get $qback)   ;; start = new back
+              (ref.null $cont)      ;; init value
+              (global.get $qfront)  ;; len = old front = old front - new front
+            )
+            (global.set $qfront (i32.const 0))
+          )
+        )
+      )
+    )
+    (table.set $queue (global.get $qback) (local.get $k))
+    (global.set $qback (i32.add (global.get $qback) (i32.const 1)))
+  )
+
+  (func $scheduler (export "scheduler") (param $main (ref $cont))
+    (call $enqueue (local.get $main))
+    (loop $l
+      (if (call $queue-empty) (then (return)))
+      (block $on_yield (result (ref $cont))
+        (block $on_spawn (result (ref $cont) (ref $cont))
+          (resume $cont (on $yield $on_yield) (on $spawn $on_spawn)
+            (call $dequeue)
+          )
+          (br $l)  ;; thread terminated
+        )
+        ;; on $spawn, proc and cont on stack
+        (call $enqueue)             ;; continuation of old thread
+        (call $enqueue)             ;; new thread
+        (br $l)
+      )
+      ;; on $yield, cont on stack
+      (call $enqueue)
+      (br $l)
+    )
+  )
+)
+
+(register "scheduler")
+
+(module
+  (type $proc (func))
+  (type $pproc (func (param i32))) ;; parameterised proc
+  (type $cont (cont $proc))
+  (type $pcont (cont $pproc)) ;; parameterised continuation proc
+  (tag $yield (import "scheduler" "yield"))
+  (tag $spawn (import "scheduler" "spawn") (param (ref $cont)))
+  (func $scheduler (import "scheduler" "scheduler") (param $main (ref $cont)))
+
+  (func $log (import "spectest" "print_i32") (param i32))
+
+  (global $width (mut i32) (i32.const 0))
+  (global $depth (mut i32) (i32.const 0))
+
+  (elem declare func $main $thread1 $thread2 $thread3)
+
+  (func $main
+    (call $log (i32.const 0))
+    (suspend $spawn (cont.new $cont (ref.func $thread1)))
+    (call $log (i32.const 1))
+    (suspend $spawn (cont.bind $pcont $cont (global.get $depth) (cont.new $pcont (ref.func $thread2))))
+    (call $log (i32.const 2))
+    (suspend $spawn (cont.new $cont (ref.func $thread3)))
+    (call $log (i32.const 3))
+  )
+
+  (func $thread1
+    (call $log (i32.const 10))
+    (suspend $yield)
+    (call $log (i32.const 11))
+    (suspend $yield)
+    (call $log (i32.const 12))
+    (suspend $yield)
+    (call $log (i32.const 13))
+  )
+
+  (func $thread2 (param $d i32)
+    (local $w i32)
+    (local.set $w (global.get $width))
+    (call $log (i32.const 20))
+    (br_if 0 (i32.eqz (local.get $d)))
+    (call $log (i32.const 21))
+    (loop $l
+      (if (local.get $w)
+        (then
+          (call $log (i32.const 22))
+          (suspend $yield)
+          (call $log (i32.const 23))
+          (suspend $spawn
+            (cont.bind $pcont $cont
+              (i32.sub (local.get $d) (i32.const 1))
+              (cont.new $pcont (ref.func $thread2))
+            )
+          )
+          (call $log (i32.const 24))
+          (local.set $w (i32.sub (local.get $w) (i32.const 1)))
+          (br $l)
+        )
+      )
+    )
+    (call $log (i32.const 25))
+  )
+
+  (func $thread3
+    (call $log (i32.const 30))
+    (suspend $yield)
+    (call $log (i32.const 31))
+    (suspend $yield)
+    (call $log (i32.const 32))
+  )
+
+  (func (export "run") (param $width i32) (param $depth i32)
+    (global.set $depth (local.get $depth))
+    (global.set $width (local.get $width))
+    (call $log (i32.const -1))
+    (call $scheduler (cont.new $cont (ref.func $main)))
+    (call $log (i32.const -2))
+  )
+)
+
+(assert_return (invoke "run" (i32.const 0) (i32.const 0)))
+(assert_return (invoke "run" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "run" (i32.const 1) (i32.const 0)))
+(assert_return (invoke "run" (i32.const 1) (i32.const 1)))
+(assert_return (invoke "run" (i32.const 3) (i32.const 4)))
+
+
+;; Nested example: generator in a thread
+
+(module $concurrent-generator
+  (func $log (import "spectest" "print_i64") (param i64))
+
+  (tag $syield (import "scheduler" "yield"))
+  (tag $spawn (import "scheduler" "spawn") (param (ref $cont)))
+  (func $scheduler (import "scheduler" "scheduler") (param $main (ref $cont)))
+
+  (type $ghook (func (param i64)))
+  (func $gsum (import "generator" "sum") (param i64 i64) (result i64))
+  (global $ghook (import "generator" "hook") (mut (ref $ghook)))
+
+  (global $result (mut i64) (i64.const 0))
+  (global $done (mut i32) (i32.const 0))
+
+  (elem declare func $main $bg-thread $syield)
+
+  (func $syield (param $i i64)
+    (call $log (local.get $i))
+    (suspend $syield)
+  )
+
+  (func $bg-thread
+    (call $log (i64.const -10))
+    (loop $l
+      (call $log (i64.const -11))
+      (suspend $syield)
+      (br_if $l (i32.eqz (global.get $done)))
+    )
+    (call $log (i64.const -12))
+  )
+
+  (func $main (param $i i64) (param $j i64)
+    (suspend $spawn (cont.new $cont (ref.func $bg-thread)))
+    (global.set $ghook (ref.func $syield))
+    (global.set $result (call $gsum (local.get $i) (local.get $j)))
+    (global.set $done (i32.const 1))
+  )
+
+  (type $proc (func))
+  (type $pproc (func (param i64 i64)))
+  (type $cont (cont $proc))
+  (type $pcont (cont $pproc))
+  (func (export "sum") (param $i i64) (param $j i64) (result i64)
+    (call $log (i64.const -1))
+    (call $scheduler
+      (cont.bind $pcont $cont (local.get $i) (local.get $j) (cont.new $pcont (ref.func $main)))
+    )
+    (call $log (i64.const -2))
+    (global.get $result)
+  )
+)
+
+(assert_return (invoke "sum" (i64.const 10) (i64.const 20)) (i64.const 165))
+
+
+;; cont.bind
+
+(module
+  (type $f2 (func (param i32 i32) (result i32 i32 i32 i32 i32 i32)))
+  (type $f4 (func (param i32 i32 i32 i32) (result i32 i32 i32 i32 i32 i32)))
+  (type $f6 (func (param i32 i32 i32 i32 i32 i32) (result i32 i32 i32 i32 i32 i32)))
+
+  (type $k2 (cont $f2))
+  (type $k4 (cont $f4))
+  (type $k6 (cont $f6))
+
+  (elem declare func $f)
+  (func $f (param i32 i32 i32 i32 i32 i32) (result i32 i32 i32 i32 i32 i32)
+    (local.get 0) (local.get 1) (local.get 2)
+    (local.get 3) (local.get 4) (local.get 5)
+  )
+
+  (func (export "run") (result i32 i32 i32 i32 i32 i32)
+    (local $k6 (ref null $k6))
+    (local $k4 (ref null $k4))
+    (local $k2 (ref null $k2))
+    (local.set $k6 (cont.new $k6 (ref.func $f)))
+    (local.set $k4 (cont.bind $k6 $k4 (i32.const 1) (i32.const 2) (local.get $k6)))
+    (local.set $k2 (cont.bind $k4 $k2 (i32.const 3) (i32.const 4) (local.get $k4)))
+    (resume $k2 (i32.const 5) (i32.const 6) (local.get $k2))
+  )
+)
+
+(assert_return (invoke "run")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+  (i32.const 4) (i32.const 5) (i32.const 6)
+)
+
+
+(module
+  (tag $e (result i32 i32 i32 i32 i32 i32))
+
+  (type $f0 (func (result i32 i32 i32 i32 i32 i32 i32)))
+  (type $f2 (func (param i32 i32) (result i32 i32 i32 i32 i32 i32 i32)))
+  (type $f4 (func (param i32 i32 i32 i32) (result i32 i32 i32 i32 i32 i32 i32)))
+  (type $f6 (func (param i32 i32 i32 i32 i32 i32) (result i32 i32 i32 i32 i32 i32 i32)))
+
+  (type $k0 (cont $f0))
+  (type $k2 (cont $f2))
+  (type $k4 (cont $f4))
+  (type $k6 (cont $f6))
+
+  (elem declare func $f)
+  (func $f (result i32 i32 i32 i32 i32 i32 i32)
+    (i32.const 0) (suspend $e)
+  )
+
+  (func (export "run") (result i32 i32 i32 i32 i32 i32 i32)
+    (local $k6 (ref null $k6))
+    (local $k4 (ref null $k4))
+    (local $k2 (ref null $k2))
+    (block $l (result (ref $k6))
+      (resume $k0 (on $e $l) (cont.new $k0 (ref.func $f)))
+      (unreachable)
+    )
+    (local.set $k6)
+    (local.set $k4 (cont.bind $k6 $k4 (i32.const 1) (i32.const 2) (local.get $k6)))
+    (local.set $k2 (cont.bind $k4 $k2 (i32.const 3) (i32.const 4) (local.get $k4)))
+    (resume $k2 (i32.const 5) (i32.const 6) (local.get $k2))
+  )
+)
+
+(assert_return (invoke "run")
+  (i32.const 0) (i32.const 1) (i32.const 2) (i32.const 3)
+  (i32.const 4) (i32.const 5) (i32.const 6)
+)
+
+;; Subtyping
+(module
+  (type $ft1 (func (param i32)))
+  (type $ct1 (sub (cont $ft1)))
+
+  (type $ft0 (func))
+  (type $ct0 (sub (cont $ft0)))
+
+  (func $test (param $x (ref $ct1))
+    (i32.const 123)
+    (local.get $x)
+    (cont.bind $ct1 $ct0)
+    (drop)
+  )
+)
+
+(module
+    (type $f1 (sub (func (result anyref))))
+    (type $f2 (sub $f1 (func (result eqref))))
+    (type $c1 (sub (cont $f1)))
+    (type $c2 (sub $c1 (cont $f2)))
+)
+
+;; Globals
+(module
+  (type $ft (func))
+  (type $ct (cont $ft))
+
+  (global $k (mut (ref null $ct)) (ref.null $ct))
+  (global $g (ref null $ct) (ref.null $ct))
+
+  (func $f)
+  (elem declare func $f)
+
+  (func (export "set-global")
+    (global.set $k (cont.new $ct (ref.func $f))))
+)
+(assert_return (invoke "set-global"))
+
+;; Switch
+(module
+  (rec
+    (type $ft (func (param (ref null $ct))))
+    (type $ct (cont $ft)))
+
+  (func $print-i32 (import "spectest" "print_i32") (param i32))
+
+  (global $fi (mut i32) (i32.const 0))
+  (global $gi (mut i32) (i32.const 1))
+
+  (tag $swap)
+
+  (func $init (export "init") (result i32)
+    (resume $ct (on $swap switch)
+      (cont.new $ct (ref.func $g))
+      (cont.new $ct (ref.func $f)))
+    (return (i32.const 42)))
+  (func $f (type $ft)
+    (local $nextk (ref null $ct))
+    (local.set $nextk (local.get 0))
+    (call $print-i32 (global.get $fi))
+    (switch $ct $swap (local.get $nextk))
+    (local.set $nextk)
+    (call $print-i32 (global.get $fi))
+    (switch $ct $swap (local.get $nextk))
+    (drop))
+  (func $g (type $ft)
+    (local $nextk (ref null $ct))
+    (local.set $nextk (local.get 0))
+    (call $print-i32 (global.get $gi))
+    (switch $ct $swap (local.get $nextk))
+    (local.set $nextk)
+    (call $print-i32 (global.get $gi)))
+  (elem declare func $f $g)
+)
+(assert_return (invoke "init") (i32.const 42))
+
+(module
+  (rec
+    (type $ft (func (param i32) (param (ref null $ct)) (result i32)))
+    (type $ct (cont $ft)))
+
+  (func $print-i32 (import "spectest" "print_i32") (param i32))
+
+  (tag $swap (result i32))
+
+  (func $init (export "init") (result i32)
+    (resume $ct (on $swap switch)
+      (i32.const 1)
+      (cont.new $ct (ref.func $g))
+      (cont.new $ct (ref.func $f))))
+  (func $f (type $ft)
+    (local $i i32)
+    (local $nextk (ref null $ct))
+    (local.set $i (local.get 0))
+    (local.set $nextk (local.get 1))
+    (call $print-i32 (local.get $i))
+    (switch $ct $swap (i32.add (i32.const 1) (local.get $i)) (local.get $nextk))
+    (local.set $nextk)
+    (local.set $i)
+    (call $print-i32 (local.get $i))
+    (switch $ct $swap (i32.add (i32.const 1) (local.get $i)) (local.get $nextk))
+    (unreachable))
+  (func $g (type $ft)
+    (local $i i32)
+    (local $nextk (ref null $ct))
+    (local.set $i (local.get 0))
+    (local.set $nextk (local.get 1))
+    (call $print-i32 (local.get $i))
+    (switch $ct $swap (i32.add (i32.const 1) (local.get $i)) (local.get $nextk))
+    (local.set $nextk)
+    (local.set $i)
+    (call $print-i32 (local.get $i))
+    (return (local.get $i)))
+  (elem declare func $f $g)
+)
+(assert_return (invoke "init") (i32.const 4))
+
+
+(assert_invalid
+  (module
+    (rec
+      (type $ft (func (param (ref null $ct))))
+      (type $ct (cont $ft)))
+    (type $ft2 (func))
+    (type $ct2 (cont $ft2))
+
+    (tag $swap)
+    (func $f (type $ft)
+      (switch $ct $swap (cont.new $ct2 (ref.null $ft2)))
+      (drop)))
+   "type mismatch")
+
+(assert_invalid
+  (module
+    (rec
+      (type $ft (func (param i32) (param (ref null $ct))))
+      (type $ct (cont $ft)))
+
+    (tag $swap)
+    (func $f (type $ft)
+      (switch $ct $swap (i64.const 0) (local.get 1))
+      (drop)
+      (drop)))
+   "type mismatch")
+
+(module
+  (type $ft1 (func))
+  (type $ct1 (cont $ft1))
+  (rec
+    (type $ft2 (func (param (ref null $ct2))))
+    (type $ct2 (cont $ft2)))
+
+  (tag $t)
+
+  (func $suspend (type $ft2)
+    (suspend $t))
+
+  (func $switch (type $ft2)
+    (switch $ct2 $t (local.get 0))
+    (drop))
+
+  (func (export "unhandled-suspend-t")
+    (resume $ct2 (on $t switch)
+      (cont.new $ct2 (ref.func $suspend))
+      (cont.new $ct2 (ref.func $suspend))))
+  (func (export "unhandled-switch-t")
+    (block $l (result (ref $ct1))
+      (resume $ct2 (on $t $l)
+        (cont.new $ct2 (ref.func $switch))
+        (cont.new $ct2 (ref.func $switch)))
+      (unreachable)
+    )
+    (unreachable))
+
+  (elem declare func $suspend $switch)
+)
+(assert_suspension (invoke "unhandled-suspend-t") "unhandled tag")
+(assert_suspension (invoke "unhandled-switch-t") "unhandled tag")
+
+(module
+  (rec
+    (type $ft (func (param (ref null $ct))))
+    (type $ct (cont $ft)))
+
+  (tag $t)
+
+  (func
+    (cont.new $ct (ref.null $ft))
+    (unreachable))
+  (func
+    (cont.bind $ct $ct (ref.null $ct))
+    (unreachable))
+  (func
+    (resume $ct (ref.null $ct) (ref.null $ct))
+    (unreachable))
+  (func
+    (resume_throw $ct $t (ref.null $ct))
+    (unreachable))
+  (func
+    (switch $ct $t (ref.null $ct))
+    (unreachable))
+)
+
+(module $co2
+  (type $task (func (result i32))) ;; type alias task = [] -> []
+  (type $ct   (cont $task)) ;; type alias   ct = $task
+  (tag $pause (export "pause"))   ;; pause : [] -> []
+  (tag $cancel (export "cancel"))   ;; cancel : [] -> []
+  ;; run : [(ref $task) (ref $task)] -> []
+  ;; implements a 'seesaw' (c.f. Ganz et al. (ICFP@99))
+  (func $run (export "seesaw") (param $up (ref $ct)) (param $down (ref $ct)) (result i32)
+    (local $result i32)
+    ;; run $up
+    (loop $run_next (result i32)
+      (block $on_pause (result (ref $ct))
+        (resume $ct (on $pause $on_pause)
+                    (local.get $up))
+        ;; $up finished, store its result
+        (local.set $result)
+        ;; next cancel $down
+        (block $on_cancel
+          (try_table (catch $cancel $on_cancel)
+            ;; inject the cancel exception into $down
+            (resume_throw $ct $cancel (local.get $down))
+            (drop) ;; drop the return value if it handled $cancel
+                   ;; itself and returned normally...
+          )
+        ) ;; ... otherwise catch $cancel and return $up's result.
+        (return (local.get $result))
+      ) ;; on_pause clause, stack type: [(cont $ct)]
+      (local.set $up)
+      ;; swap $up and $down
+      (local.get $down)
+      (local.set $down (local.get $up))
+      (local.set $up)
+      (br $run_next)
+    )
+  )
+)
+(register "co2")
+
+(module $client
+  (type $task-0 (func (param i32) (result i32)))
+  (type $ct-0 (cont $task-0))
+  (type $task (func (result i32)))
+  (type $ct (cont $task))
+
+  (func $seesaw (import "co2" "seesaw") (param (ref $ct)) (param (ref $ct)) (result i32))
+  (func $print-i32 (import "spectest" "print_i32") (param i32))
+  (tag $pause (import "co2" "pause"))
+
+  (func $even (param $niter i32) (result i32)
+     (local $next i32) ;; zero initialised.
+     (local $i i32)
+     (loop $print-next
+       (call $print-i32 (local.get $next))
+       (suspend $pause)
+       (local.set $next (i32.add (local.get $next) (i32.const 2)))
+       (local.set $i (i32.add (local.get $i) (i32.const 1)))
+       (br_if $print-next (i32.lt_u (local.get $i) (local.get $niter)))
+     )
+     (local.get $next)
+  )
+  (func $odd (param $niter i32) (result i32)
+     (local $next i32) ;; zero initialised.
+     (local $i i32)
+     (local.set $next (i32.const 1))
+     (loop $print-next
+       (call $print-i32 (local.get $next))
+       (suspend $pause)
+       (local.set $next (i32.add (local.get $next) (i32.const 2)))
+       (local.set $i (i32.add (local.get $i) (i32.const 1)))
+       (br_if $print-next (i32.lt_u (local.get $i) (local.get $niter)))
+     )
+     (local.get $next)
+  )
+
+  (func (export "main") (result i32)
+    (call $seesaw
+       (cont.bind $ct-0 $ct
+         (i32.const 5) (cont.new $ct-0 (ref.func $even)))
+       (cont.bind $ct-0 $ct
+         (i32.const 5) (cont.new $ct-0 (ref.func $odd)))))
+
+  (elem declare func $even $odd)
+)
+(assert_return (invoke "main") (i32.const 10))
\ No newline at end of file
diff --git a/test/core/stack-switching/validation.wast b/test/core/stack-switching/validation.wast
new file mode 100644
index 00000000..5a1ed682
--- /dev/null
+++ b/test/core/stack-switching/validation.wast
@@ -0,0 +1,798 @@
+;; This file tests validation only, without GC types and subtyping.
+
+
+;;;;
+;;;; WasmFX types
+;;;;
+
+(module
+  (type $ft1 (func))
+  (type $ct1 (cont $ft1))
+
+  (type $ft2 (func (param i32) (result i32)))
+  (type $ct2 (cont $ft2))
+
+  (func $test
+    (param $p1 (ref cont))
+    (param $p2 (ref nocont))
+    (param $p3 (ref $ct1))
+
+    (local $x1 (ref cont))
+    (local $x2 (ref nocont))
+    (local $x3 (ref $ct1))
+    (local $x4 (ref $ct2))
+    (local $x5 (ref null $ct1))
+
+    ;; nocont <: cont
+    (local.set $x1 (local.get $p2))
+
+    ;; nocont <: $ct1
+    (local.set $x3 (local.get $p2))
+
+    ;; $ct1 <: $cont
+    (local.set $x3 (local.get $p3))
+
+    ;; (ref $ct1) <: (ref null $cont)
+    (local.set $x5 (local.get $p3))
+   )
+)
+
+(assert_invalid
+  (module
+    (type $ft1 (func))
+    (type $ct1 (cont $ft1))
+
+    (type $ft2 (func (param i32) (result i32)))
+    (type $ct2 (cont $ft2))
+
+    (func $test
+      (param $p1 (ref cont))
+      (param $p2 (ref nocont))
+      (param $p3 (ref $ct1))
+
+      (local $x1 (ref cont))
+      (local $x2 (ref nocont))
+      (local $x3 (ref $ct1))
+      (local $x4 (ref $ct2))
+      (local $x5 (ref null $ct1))
+
+      ;; cont </: nocont
+      (local.set $p2 (local.get $p1))
+     )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft1 (func))
+    (type $ct1 (cont $ft1))
+
+    (type $ft2 (func (param i32) (result i32)))
+    (type $ct2 (cont $ft2))
+
+    (func $test
+      (param $p1 (ref cont))
+      (param $p2 (ref nocont))
+      (param $p3 (ref $ct1))
+
+      (local $x1 (ref cont))
+      (local $x2 (ref nocont))
+      (local $x3 (ref $ct1))
+      (local $x4 (ref $ct2))
+      (local $x5 (ref null $ct1))
+
+      ;; $ct1 </: nocont
+      (local.set $p2 (local.get $p3))
+     )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft1 (func))
+    (type $ct1 (cont $ft1))
+
+    (type $ft2 (func (param i32) (result i32)))
+    (type $ct2 (cont $ft2))
+
+    (func $test
+      (param $p1 (ref cont))
+      (param $p2 (ref nocont))
+      (param $p3 (ref $ct1))
+
+      (local $x1 (ref cont))
+      (local $x2 (ref nocont))
+      (local $x3 (ref $ct1))
+      (local $x4 (ref $ct2))
+      (local $x5 (ref null $ct1))
+
+      ;; $cont </: $ct1
+      (local.set $p3 (local.get $p1))
+     )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft1 (func))
+    (type $ct1 (cont $ft1))
+
+    (type $ft2 (func (param i32) (result i32)))
+    (type $ct2 (cont $ft2))
+
+    (func $test
+      (param $p1 (ref cont))
+      (param $p2 (ref nocont))
+      (param $p3 (ref $ct1))
+      (param $p4 (ref $ct2))
+      (param $p5 (ref null $ct1))
+
+
+      (local $x1 (ref cont))
+      (local $x2 (ref nocont))
+      (local $x3 (ref $ct1))
+      (local $x4 (ref $ct2))
+      (local $x5 (ref null $ct1))
+
+      ;; (ref null $ct1) </: (ref $cont)
+      (local.set $x3 (local.get $p5))
+     )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft1 (func))
+    (type $ct1 (cont $ft1))
+
+    (type $ft2 (func (param i32) (result i32)))
+    (type $ct2 (cont $ft2))
+
+    (func $test
+      (param $p1 (ref cont))
+      (param $p2 (ref nocont))
+      (param $p3 (ref $ct1))
+      (param $p4 (ref $ct2))
+      (param $p5 (ref null $ct1))
+
+
+      (local $x1 (ref cont))
+      (local $x2 (ref nocont))
+      (local $x3 (ref $ct1))
+      (local $x4 (ref $ct2))
+      (local $x5 (ref null $ct1))
+
+      ;; (ref $ct1) </: (ref $ct2)
+      (local.set $p4 (local.get $p3))
+     )
+  )
+  "type mismatch"
+)
+
+;;;;
+;;;; cont_bind instructions
+;;;;
+
+(module
+  (type $ft0 (func (result i32)))
+  (type $ct0 (cont $ft0))
+
+  (type $ft1 (func (param i32) (result i32)))
+  (type $ct1 (cont $ft1))
+
+  (type $ft2 (func (param i64 i32) (result i32)))
+  (type $ct2 (cont $ft2))
+
+
+  (func $test1
+    (param $p_ct1 (ref null $ct1))
+    (result (ref $ct0))
+
+    ;; cont.bind takes nullable ref, returns non-nullable one
+    (i32.const 123)
+    (local.get $p_ct1)
+    (cont.bind $ct1 $ct0)
+  )
+
+  (func $test2
+    (param $p_ct2 (ref $ct2))
+    (result (ref $ct1))
+
+    ;; cont.bind does not have to apply continuation fully
+    (i64.const 123)
+    (local.get $p_ct2)
+    (cont.bind $ct2 $ct1)
+  )
+
+  (func $test3
+    (param $p_ct1 (ref $ct1))
+    (result (ref $ct1))
+
+    ;; cont.bind can take same type twice, not actually apply anything
+    (local.get $p_ct1)
+    (cont.bind $ct1 $ct1)
+  )
+
+
+ )
+
+(assert_invalid
+
+  (module
+    (type $ft0 (func (result i32)))
+    (type $ct0 (cont $ft0))
+
+    (func $error
+      (param $p_ft0 (ref $ft0))
+      ;; error: non-continuation type on cont.bind
+      (local.get $p_ft0)
+      (cont.bind $ft0 $ft0)
+      (drop)
+    )
+  )
+  "non-continuation type"
+)
+
+  ;; cont.new type mismatch: passing a continuation reference to cont.new instead of function reference
+  ;; This is actually just checking type-matching, not cont.new specific:
+  ;; (ref null $ct1) is not a subtype of (ref null $ft1)
+
+(assert_invalid
+
+  (module
+    (type $ft0 (func (result i32)))
+    (type $ct0 (cont $ft0))
+
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+    (func $error
+      (param $p_ct1 (ref $ct1))
+      ;; cont.bind type mismatch: passing wrong kind of continuation.
+      ;; This is actually just checking type-matching, not cont.bind specific.
+      (local.get $p_ct1)
+      (cont.bind $ct0 $ct0)
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+
+  (module
+    (type $ft0 (func (result i32)))
+    (type $ct0 (cont $ft0))
+
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+    (type $ft2 (func (param i64 i32) (result i32)))
+    (type $ct2 (cont $ft2))
+
+
+    (type $ft1_alt (func (param i64) (result i32)))
+    (type $ct1_alt (cont $ft1_alt))
+
+    (func $error
+      (param $p_ct2 (ref $ct2))
+      ;; error: two continuation types not agreeing on arg types
+      (i64.const 123)
+      (local.get $p_ct2)
+      (cont.bind $ct2 $ct1_alt)
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+
+  (module
+    (type $ft0 (func (result i32)))
+    (type $ct0 (cont $ft0))
+
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+    (type $ft2 (func (param i64 i32) (result i32)))
+    (type $ct2 (cont $ft2))
+
+
+    (type $ft1_alt (func (param i32) (result i64)))
+    (type $ct1_alt (cont $ft1_alt))
+
+    (func $error
+      (param $p_ct2 (ref $ct2))
+      ;; error: two continuation types not agreeing on return types
+      (i64.const 123)
+      (local.get $p_ct2)
+      (cont.bind $ct2 $ct1_alt)
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+
+  (module
+    (type $ft0 (func (result i32)))
+    (type $ct0 (cont $ft0))
+
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+    (func $error
+      (param $p_ct0 (ref $ct0))
+      ;; error: trying to go from 0 to 1 args
+      (local.get $p_ct0)
+      (cont.bind $ct0 $ct1)
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+
+  (module
+    (type $ft0 (func (result i32)))
+    (type $ct0 (cont $ft0))
+
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+
+    (func $error
+      (param $p_ct1 (ref $ct1))
+      ;; error: Insufficient arguments::
+      ;; This is really testing the general application of arguments to instructions,
+      ;; but trying to trick parsers of the folded form
+      (cont.bind $ct1 $ct0 (local.get $p_ct1))
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+
+  (module
+    (type $ft0 (func (result i32)))
+    (type $ct0 (cont $ft0))
+
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+    (func $error
+      (param $p_ct1 (ref $ct1))
+      ;; error: Too many arguments::
+      ;; This is really testing the general application of arguments to instructions,
+      ;; but trying to trick parsers of the folded form
+      (cont.bind $ct1 $ct0 (i32.const 123) (i32.const 123) (local.get $p_ct1))
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+
+;;;;
+;;;; cont_new instructions
+;;;;
+
+(module
+  (type $ft1 (func (param i32) (result i32)))
+  (type $ct1 (cont $ft1))
+
+  (type $ft2 (func (param i32 i32) (result i32)))
+  (type $ct2 (cont $ft2))
+
+  (func $f1 (export "f1") (param i32) (result i32)
+    (i32.const 123)
+  )
+
+  (func $drop_ct1 (param $c (ref $ct1)))
+
+  ;; simple smoke test
+  (func $test_good1 (param $x (ref $ft1)) (result (ref $ct1))
+    (local.get $x)
+    (cont.new $ct1)
+  )
+
+  ;; cont.new takes a nullable function
+  (func $test_good2 (param $x (ref null $ft1)) (result (ref $ct1))
+    (local.get $x)
+    (cont.new $ct1)
+  )
+
+
+)
+
+(assert_invalid
+  (module
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+    (func $bad (param $x (ref null $ct1)) (result (ref $ct1))
+      (local.get $x)
+      (cont.new $ct1)
+    )
+  )
+  ;; cont.new type mismatch: passing a continuation reference to cont.new instead of function reference
+  ;; This is actually just checking type-matching, not cont.new specific:
+  ;; (ref null $ct1) is not a subtype of (ref null $ft1)
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+    (type $ft2 (func (param i32 i32) (result i32)))
+    (type $ct2 (cont $ft2))
+
+    (func $drop_ct1 (param $c (ref $ct1)))
+
+    (func $bad (param $x (ref null $ft2)) (result (ref $ct1))
+      (local.get $x)
+      (cont.new $ct1)
+    )
+  )
+  ;; cont.new type mismatch: passing function of wrong type to cont.new
+  ;; This is actually just checking type-matching, not cont.new specific:
+  ;; (ref null $ft2) is not a subtype of (ref null $ft1)
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft1 (func (param i32) (result i32)))
+    (type $ct1 (cont $ft1))
+
+    (func $bad (param $x (ref null $ct1))
+      (local.get $x)
+      (cont.new $ft1)
+      (drop)
+    )
+  )
+  ;; non-continuation type on cont.new
+  "non-continuation type 0"
+)
+
+;;;;
+;;;; resume instructions
+;;;;
+
+
+(module
+  (type $ft0 (func))
+  (type $ct0 (cont $ft0))
+
+  (type $ft1 (func (param f32) (result f64)))
+  (type $ct1 (cont $ft1))
+
+  (type $ft2 (func (param i64) (result f64)))
+  (type $ct2 (cont $ft2))
+
+  (type $ft3 (func (param i32) (result f64)))
+  (type $ct3 (cont $ft3))
+
+  (tag $t0)
+  (tag $t1)
+  (tag $t2 (param i32) (result i64))
+  (tag $t3 (param i64) (result i32))
+
+  ;; Multiple tags, all types handled correctly
+  (func $test0 (param $x (ref $ct1)) (result f64)
+    (block $handler0 (result i32 (ref $ct2))
+      (block $handler1 (result i64 (ref $ct3))
+        (f32.const 1.23)
+        (local.get $x)
+        (resume $ct1 (on $t2 $handler0) (on $t3 $handler1))
+        (return)
+      )
+      (unreachable)
+    )
+    (unreachable)
+  )
+
+  ;; Same as $test0, but we provide two handlers for the same tag
+  (func $test1 (param $x (ref $ct1)) (result f64)
+    (block $handler0 (result i32 (ref $ct2))
+      (block $handler1 (result i32 (ref $ct2))
+        (f32.const 1.23)
+        (local.get $x)
+        (resume $ct1 (on $t2 $handler0) (on $t2 $handler1))
+        (return)
+      )
+      (unreachable)
+    )
+    (unreachable)
+  )
+
+  ;; resume takes a nullable reference
+  (func $test2 (param $x (ref null $ct0))
+    (local.get $x)
+    (resume $ct0)
+  )
+
+  ;; handler blocks take the continuation as nullable ref
+  (func $test3 (param $x (ref $ct0))
+    (block $handler (result (ref null $ct0))
+      (local.get $x)
+      (resume $ct0 (on $t0 $handler))
+      (return)
+    )
+    (unreachable)
+  )
+
+  ;; Nothing wrong with using the same handler block for multiple tags
+  (func $test4 (param $x (ref $ct0))
+    (block $handler (result (ref null $ct0))
+      (local.get $x)
+      (resume $ct0 (on $t0 $handler) (on $t1 $handler))
+      (return)
+    )
+    (unreachable)
+  )
+
+  ;; handler block can have params
+  (func $test5 (param $x (ref $ct0))
+    (local.get $x)
+    (block $handler (param (ref $ct0)) (result (ref $ct0))
+      (resume $ct0 (on $t0 $handler))
+      (return)
+    )
+    (unreachable)
+  )
+)
+
+;; tag does not exist
+(assert_invalid
+  (module
+    (type $ft0 (func))
+    (type $ct0 (cont $ft0))
+    ;;(tag $t0)
+    (func $error (param $x (ref $ct0))
+      (block $handler (result (ref null $ct0))
+        (local.get $x)
+        (resume $ct0 (on 0 $handler))
+        (return)
+      )
+      (unreachable)
+    )
+
+  )
+  "unknown tag"
+)
+
+;; non-continuation type on resume
+(assert_invalid
+  (module
+    (type $ft0 (func))
+    (type $ct0 (cont $ft0))
+    (func $error (param $x (ref $ct0))
+      (local.get $x)
+      (resume $ft0)
+    )
+
+  )
+  "non-continuation type"
+)
+
+;; non-continuation type on handler
+(assert_invalid
+  (module
+    (type $ft0 (func))
+    (type $ct0 (cont $ft0))
+    (tag $t0)
+    (func $test1 (param $x (ref $ct0))
+      (block $handler (result (ref $ft0))
+        (local.get $x)
+        (resume $ct0 (on $t0 $handler))
+        (return)
+      )
+      (unreachable)
+    )
+
+  )
+  "non-continuation type"
+)
+
+(assert_invalid
+  (module
+    (type $ft (func (param i32)))
+    (type $ct (cont $ft))
+
+    (func $error
+      (param $p (ref $ct))
+      ;; error: Too many arguments::
+      ;; This is really testing the general application of arguments to instructions,
+      ;; but trying to trick parsers of the folded form
+      (resume $ct (i32.const 123) (i32.const 123) (local.get $p))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft (func (param i32)))
+    (type $ct (cont $ft))
+
+    (func $error
+      (param $p (ref $ct))
+      ;; error: Too few arguments::
+      ;; This is really testing the general application of arguments to instructions,
+      ;; but trying to trick parsers of the folded form
+      (resume $ct (local.get $p))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft0 (func (param i32)))
+    (type $ct0 (cont $ft0))
+
+    (type $ft1 (func (param i64)))
+    (type $ct1 (cont $ft1))
+
+    (func $error
+      (param $p (ref $ct1))
+      ;; error: Mismatch between annotation on resume and actual argument
+      ;; This is really testing the general application of arguments to instructions.
+      (resume $ct0 (i32.const 123) (local.get $p))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft0 (func))
+    (type $ct0 (cont $ft0))
+
+    (tag $t (param i32))
+
+    (func $error
+      (param $p (ref $ct0))
+      (block $handler (result (ref $ct0))
+        ;; error: handler block has insufficient number of results
+        (local.get $p)
+        (resume $ct0 (on $t $handler))
+        (return)
+      )
+      (unreachable)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft0 (func))
+    (type $ct0 (cont $ft0))
+
+    (tag $t (param i32))
+
+    (func $error
+      (param $p (ref $ct0))
+      (block $handler (result i32 i32 (ref $ct0))
+        ;; error: handler block has too many results
+        (local.get $p)
+        (resume $ct0 (on $t $handler))
+        (return)
+      )
+      (unreachable)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft0 (func))
+    (type $ct0 (cont $ft0))
+
+    (tag $t (param i32))
+
+    (func $error
+      (param $p (ref $ct0))
+      (block $handler (result i64 (ref $ct0))
+        ;; error: type mismatch in non-continuation handler result type
+        (local.get $p)
+        (resume $ct0 (on $t $handler))
+        (return)
+      )
+      (unreachable)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ft0 (func))
+    (type $ct0 (cont $ft0))
+
+    (type $ft1 (func (param i32)))
+    (type $ct1 (cont $ft1))
+
+    (tag $t (param i32))
+
+    (func $error
+      (param $p (ref $ct0))
+      (block $handler (result i32 (ref $ct1))
+        ;; error: type mismatch in continuation handler result type
+        (local.get $p)
+        (resume $ct0 (on $t $handler))
+        (return)
+      )
+      (unreachable)
+    )
+  )
+  "type mismatch"
+)
+
+;;;;
+;;;; suspend instructions
+;;;;
+
+(module
+  (tag $t (param i64 i32) (result i32 i64))
+
+  (func $test (result i32 i64)
+    (i64.const 123)
+    (i32.const 123)
+    (suspend $t)
+  )
+)
+
+
+(assert_invalid
+  (module
+    (tag $t (param i64 i32) (result i32 i64))
+
+    (func $test (result i32 i64)
+      ;; error: Insufficient arguments::
+      ;; This is really testing the general application of arguments to instructions,
+      ;; but trying to trick parsers of the folded form
+
+      (suspend $t (i64.const 123))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (tag $t (param i32) (result i32 i64))
+
+    (func $test (result i32 i64)
+      ;; error: Too many arguments:
+      ;; This is really testing the general application of arguments to instructions,
+      ;; but trying to trick parsers of the folded form
+
+      (suspend $t (i64.const 123) (i32.const 123))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $test
+      ;; error: Tag does not exist
+      (suspend 0)
+    )
+  )
+  "unknown tag"
+)
diff --git a/test/core/stack-switching/validation_gc.wast b/test/core/stack-switching/validation_gc.wast
new file mode 100644
index 00000000..f6691e0c
--- /dev/null
+++ b/test/core/stack-switching/validation_gc.wast
@@ -0,0 +1,320 @@
+;; This file tests validation only, focusing on GC types and subtyping.
+
+;;;;
+;;;;; WasmFX types
+;;;;
+
+
+(module
+  (type $f (func))
+
+  (type $ft1 (sub (func (param (ref $f)) (result (ref func)))))
+  (type $ct1 (sub (cont $ft1)))
+
+  (type $ft2 (func (param (ref any)) (result (ref func))))
+  (type $ct2 (cont $ft2))
+
+  (type $ft3 (sub $ft1 (func (param (ref func)) (result (ref $f)))))
+  (type $ct3 (cont $ft3))
+
+  ;; Okay: Continuation types are covariant, have declared $ft3 <: $ft1
+  (type $ct_sub (sub $ct1 (cont $ft3)))
+
+  (func $test
+    (param $p1 (ref $ct1))
+    (param $p2 (ref $ct_sub))
+
+    ;; Okay: (ref $ct_sub) <: (ref $ct1)
+    (local.set $p1 (local.get $p2))
+
+  )
+
+)
+
+(assert_invalid
+  (module
+    (type $f (func))
+
+    (type $ft1 (sub (func (param (ref $f)) (result (ref func)))))
+    (type $ct1 (sub (cont $ft1)))
+
+    (type $ft2 (func (param (ref func)) (result (ref $f))))
+
+    ;; Error: $ft2 and ft1 have compatible types, but have not declared $ft2 <: ft1
+    (type $error (sub $ct1 (cont $ft2)))
+
+  )
+  "sub type 4 does not match super type 2"
+)
+
+(assert_invalid
+  (module
+    (type $f (func))
+
+    (type $ft1 (sub (func (param (ref $f)) (result (ref func)))))
+    (type $ct1 (sub (cont $ft1)))
+
+    (type $ft2 (func (param (ref func)) (result (ref $f))))
+    (type $ct2 (cont $ft2))
+
+   (func $test
+    (param $p1 (ref $ct1))
+    (param $p2 (ref $ct2))
+
+    ;; Error $ct2 and $ct1 have generally compatible types,
+    ;; but have not declared $ft2 <: ft1 or $ct2 <: $ct1
+    ;; Thus, $ct2 </: $ct1.
+    (local.set $p1 (local.get $p2))
+
+  )
+
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $f (func))
+
+    (type $ft1 (sub (func (param (ref $f)) (result (ref func)))))
+    (type $ct1 (sub (cont $ft1)))
+    (type $ft3 (sub $ft1 (func (param (ref func)) (result (ref $f)))))
+    (type $ct3 (cont $ft3))
+
+   (func $error
+    (param $p1 (ref $ct1))
+    ;;(param $p2 (ref $ct2))
+    (param $p3 (ref $ct3))
+
+    ;; Error $ct3 and $ct1 have generally compatible types,
+    ;; (in particular: declared $ft3 <: ft1,
+    ;; but have not declared $ct3 <: $ct1
+    ;; $ct3 </: $ct1
+    (local.set $p1 (local.get $p3))
+
+  )
+
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+
+    (func $error
+      (param $p_any (ref any))
+      (param $p_cont (ref cont))
+
+      ;; Error: cont </: any
+      (local.set $p_any (local.get $p_cont))
+    )
+  )
+
+  "type mismatch"
+)
+
+;;;;
+;;;; cont_bind instructions
+;;;;
+
+(module $non_final
+
+  (type $ft1 (func (param i32) (result (ref func))))
+  (type $ct1 (sub (cont $ft1)))
+
+  (type $ft0 (func (result (ref func))))
+  (type $ct0 (sub (cont $ft0)))
+
+  (func $test1 (param $x (ref $ct1))
+    (i32.const 123)
+    (local.get $x)
+    ;; Smoke test: using non-final types here
+    (cont.bind $ct1 $ct0)
+    (drop)
+  )
+)
+
+
+(module $subtyping0
+
+  (type $f (func))
+
+  (type $ft0_sup (func (result (ref func))))
+  (type $ct0_sup (cont $ft0_sup))
+
+  (type $ft1 (func (param i32) (result (ref $f))))
+  (type $ct1 (cont $ft1))
+
+  (type $ft0 (func (result (ref $f))))
+  (type $ct0 (cont $ft0))
+
+
+  (func $test2 (param $x (ref $ct1))
+    (i32.const 123)
+    (local.get $x)
+    ;; Okay: The most natural second continuation type would be $ct0.
+    ;; But we have (func (result (ref $f))) <: (func (result (ref $func)))
+    ;; This holds without us needing to declare any subtyping relations at all.
+    (cont.bind $ct1 $ct0_sup)
+    (drop)
+  )
+
+)
+
+(module $recursive
+
+  (rec
+    (type $ft0 (func             (result (ref $ct_rec))))
+    (type $ft1 (func (param i32) (result (ref $ct_rec))))
+    (type $ct_rec (cont $ft1))
+  )
+  (type $ct0 (cont $ft0))
+
+  (rec
+    (type $ft0' (func             (result (ref $ct_rec'))))
+    (type $ft1' (func (param i32) (result (ref $ct_rec'))))
+    (type $ct_rec' (cont $ft1'))
+  )
+  (type $ct1 (cont $ft1'))
+
+
+  ;; Okay: Some simple test where the types involved in cont.bind
+  ;; are part of a recursion group
+  ;; (more concretely: two equivalent recursion groups)
+  (func $test (param $x (ref $ct1))
+    (i32.const 123)
+    (local.get $x)
+    (cont.bind $ct1 $ct0)
+    (drop)
+  )
+
+)
+
+(module $recursive_subtyping
+
+  ;; We define types such that $ft0 <: $ft0_sup and $ct_rec <: $ct_rec_sup
+  (rec
+    (type $ft0_sup (sub          (func             (result (ref $ct_rec_sup)))))
+    (type $ft0     (sub $ft0_sup (func             (result (ref $ct_rec)))))
+    (type $ft1     (sub          (func (param i32) (result (ref $ct_rec)))))
+
+    (type $ct_rec_sup (sub (cont $ft0_sup)))
+    (type $ct_rec     (sub $ct_rec_sup (cont $ft0)))
+  )
+
+  (type $ct0_sup (cont $ft0_sup))
+  (type $ct0     (cont $ft0))
+  (type $ct1     (cont $ft1))
+
+
+  (func $test (param $x (ref $ct1))
+    (i32.const 123)
+    (local.get $x)
+    (cont.bind $ct1 $ct0)
+    (drop)
+
+    (i32.const 123)
+    (local.get $x)
+    ;; Okay: We have (func (result (ref $ct_rec))) <: (func (result (ref
+    ;; $ct_rec_sup)))
+    (cont.bind $ct1 $ct0_sup)
+    (drop)
+  )
+
+)
+
+;;;;
+;;;; resume instructions
+;;;;
+
+
+(module $subtyping-resume0
+
+  (type $ft0 (func))
+  (type $ct0 (cont $ft0))
+
+  (type $ft_sup (func (param (ref $ft0))))
+  (type $ct_sup (cont $ft_sup))
+
+  (type $ft_sub (func (param (ref func))))
+  (type $ct_sub (cont $ft_sub)) ;; unused
+
+  (tag $t (result (ref func)))
+
+  (func $test0
+    (param $p (ref $ct0))
+
+    ;; Here we test subtyping with respect to the continuations received by handlers.
+    ;;
+    ;; The most "straightforward" type of the continuation in $handler would be (ref
+    ;; $ct_sub). Instead, we use $ct_sup. According to the spec, we neither need
+    ;; to declare $ft_sub <: $ft_sup or $ct_sub <: $ct_sup for this to work. We
+    ;; have (func (param (ref func))) <: (func (param (ref $ft0))), which is
+    ;; sufficient
+    (block $handler (result (ref $ct_sup))
+      (local.get $p)
+      (resume $ct0 (on $t $handler))
+      (return)
+    )
+    (unreachable)
+  )
+)
+
+(module $subtyping-resume1
+
+  (type $ft0 (func))
+  (type $ct0 (cont $ft0))
+
+  (tag $t (param (ref $ft0)))
+
+  (func $test0
+    (param $p (ref $ct0))
+
+    ;; Here we test subtyping with respect to the payloads received by handlers.
+    ;; Instead of just (ref $ft0), then handler takes func.
+    (block $handler (result (ref func) (ref $ct0))
+      (local.get $p)
+      (resume $ct0 (on $t $handler))
+      (return)
+    )
+    (unreachable)
+  )
+
+)
+
+(assert_invalid
+  (module
+
+    (type $ft0 (func))
+    (type $ct0 (cont $ft0))
+
+    (type $ft_sup (sub (func (param (ref $ft0)))))
+    (type $ct_sup (sub (cont $ft_sup)))
+
+    (type $ft_sub (sub $ft_sup (func (param (ref func)))))
+    (type $ct_sub (cont $ft_sub))
+
+    (tag $t (param (ref $ct_sub)))
+
+    (func $test0
+      (param $p (ref $ct0))
+
+      ;; This is similar to $subtyping1, but this time we use a continuation as payload.
+      ;; But we did not actually declare $ct_sub <: $ct_sub.
+      ;;
+      ;; This is mostly just to check the following:
+      ;; For the continuation received by every handler, we see through the
+      ;; continuation type and do structural subtyping on the underlying
+      ;; function type.
+      ;; However, for continuations that are just payloads ($ct_sup here), we do
+      ;; ordinary nominal subtyping.
+      (block $handler (result (ref $ct_sup) (ref $ct0))
+        (local.get $p)
+        (resume $ct0 (on $t $handler))
+        (return)
+      )
+      (unreachable)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/table.wast b/test/core/table.wast
index a11dce56..91801624 100644
--- a/test/core/table.wast
+++ b/test/core/table.wast
@@ -135,6 +135,31 @@
 )
 
 
+(assert_invalid
+  (module
+    (type $f (func))
+    (table 10 (ref $f))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $f (func))
+    (table 0 (ref $f))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $f (func))
+    (table 0 0 (ref $f))
+  )
+  "type mismatch"
+)
+
+
 ;; Duplicate table identifiers
 
 (assert_malformed
diff --git a/test/core/tag.wast b/test/core/tag.wast
index 3ea8b558..e970c1f4 100644
--- a/test/core/tag.wast
+++ b/test/core/tag.wast
@@ -15,10 +15,11 @@
   (import "test" "t3" (tag $t1 (param i32 f32)))
 )
 
-(assert_invalid
-  (module (tag (result i32)))
-  "non-empty tag result type"
-)
+;; NOTE(dhil): This test is invalid as our proposal allows non-empty
+;; (assert_invalid
+;;   (module (tag (result i32)))
+;;   "non-empty tag result type"
+;; )
 
 
 ;; Link-time typing