diff --git a/ml-proto/README.md b/ml-proto/README.md
index ee0a63e980..f4c294a28d 100644
--- a/ml-proto/README.md
+++ b/ml-proto/README.md
@@ -61,6 +61,8 @@ Either way, in order to run the test suite you'll need to have Python installed.
 
 ## Synopsis
 
+#### Running Modules or Scripts
+
 You can call the executable with
 
 ```
@@ -73,6 +75,8 @@ By default, the interpreter validates all modules.
 The `-u` option selects "unchecked mode", which skips validation and runs code as is.
 Runtime type errors will be captured and reported appropriately.
 
+#### Converting Modules or Scripts
+
 A file prefixed by `-o` is taken to be an output file. Depending on its extension, this will write out the preceding module definition in either S-expression or binary format. This option can be used to convert between the two in both directions, e.g.:
 
 ```
@@ -84,12 +88,28 @@ In the second case, the produced script contains exactly one module definition.
 The `-d` option selects "dry mode" and ensures that the input module is not run, even if it has a start section.
 In addition, the `-u` option for "unchecked mode" can be used to convert even modules that do not validate.
 
+The interpreter can also convert entire test scripts:
+
+```
+wasm -d script.wast -o script.bin.wast
+wasm -d script.wast -o script2.wast
+wasm -d script.wast -o script.js
+```
+
+The first creates a new test scripts where all embedded modules are converted to binary, the second one where all are converted to textual.
+
+The last invocation produces an equivalent, self-contained JavaScript test file.
+
+#### Command Line Expressions
+
 Finally, the option `-e` allows to provide arbitrary script commands directly on the command line. For example:
 
 ```
 wasm module.wasm -e '(invoke "foo")'
 ```
 
+#### Interactive Mode
+
 If neither a file nor any of the previous options is given, you'll land in the REPL and can enter script commands interactively. You can also get into the REPL by explicitly passing `-` as a file name. You can do that in combination to giving a module file, so that you can then invoke its exports interactively, e.g.:
 
 ```
@@ -240,31 +260,40 @@ script: <cmd>*
 
 cmd:
   <module>                                  ;; define, validate, and initialize module
-  <action>                                  ;; perform action and print results
   ( register <string> <name>? )             ;; register module for imports
+module with given failure string
+  <action>                                  ;; perform action and print results
+  <assertion>                               ;; assert result of an action
+  <meta>                                    ;; meta command
+
+action:
+  ( invoke <name>? <string> <expr>* )       ;; invoke function export
+  ( get <name>? <string> )                  ;; get global export
+
+assertion:
   ( assert_return <action> <expr>* )        ;; assert action has expected results
   ( assert_return_nan <action> )            ;; assert action results in NaN
   ( assert_trap <action> <failure> )        ;; assert action traps with given failure string
+  ( assert_malformed <module> <failure> )   ;; assert module cannot be decoded with given failure string
   ( assert_invalid <module> <failure> )     ;; assert module is invalid with given failure string
-  ( assert_unlinkable <module> <failure> )  ;; assert module fails to link module with given failure string
-  ( input <string> )                        ;; read script or module from file
-  ( output <name>? <string>? )              ;; output module to stout or file
+  ( assert_unlinkable <module> <failure> )  ;; assert module fails to link
 
-action:
-  ( invoke <name>? <string> <expr>* )       ;; invoke function export
-  ( get <name>? <string> )                  ;; get global export
+meta:
+  ( script <name>? <script> )               ;; name a subscript
+  ( input <name>? <string> )                ;; read script or module from file
+  ( output <name>? <string>? )              ;; output module to stout or file
 ```
-
 Commands are executed in sequence. Commands taking an optional module name refer to the most recently defined module if no name is given. They are only possible after a module has been defined.
 
 After a module is _registered_ under a string name it is available for importing in other modules.
 
-The input and output commands determine the requested file format from the file name extension. They can handle both `.wast` and `.wasm` files. In the case of input, a `.wast` script will be recursively executed.
-
-Again, this is only a meta-level for testing, and not a part of the language proper.
+There are also a number of meta commands.
+The `script` command is a simple mechanism to name sub-scripts themselves. This is mainly useful for converting scripts with the `output` command. Commands inside a `script` will be executed normally, but nested meta are expanded in place (`input`, recursively) or elided (`output`) in the named script.
 
-The interpreter also supports a "dry" mode (flag `-d`), in which modules are only validated. In this mode, `invoke` commands are ignored (and not needed).
+The `input` and `output` meta commands determine the requested file format from the file name extension. They can handle both `.wast` and `.wasm` files. In the case of input, a `.wast` script will be recursively executed. Output additionally handles `.js` as a target, which will convert the referenced script to an equivalent, self-contained JavaScript runner. It also recognises `.bin.wast` specially, which creates a script where module definitions are in binary.
 
+The interpreter supports a "dry" mode (flag `-d`), in which modules are only validated. In this mode, all actions and assertions are ignored.
+It also supports an "unchecked" mode (flag `-u`), in which module definitions are not validated before use.
 
 ## Abstract Syntax
 
diff --git a/ml-proto/host/arrange.ml b/ml-proto/host/arrange.ml
index 63cbf0234d..2758175511 100644
--- a/ml-proto/host/arrange.ml
+++ b/ml-proto/host/arrange.ml
@@ -1,5 +1,6 @@
 open Source
 open Ast
+open Script
 open Values
 open Types
 open Sexpr
@@ -11,21 +12,25 @@ let int = string_of_int
 let int32 = Int32.to_string
 let int64 = Int64.to_string
 
-let string s =
-  let buf = Buffer.create (String.length s + 2) in
+let add_hex_char buf c = Printf.bprintf buf "\\%02x" (Char.code c)
+let add_char buf c =
+  if c < '\x20' || c >= '\x7f' then
+    add_hex_char buf c
+  else begin
+    if c = '\"' || c = '\\' then Buffer.add_char buf '\\';
+    Buffer.add_char buf c
+  end
+
+let string_with add_char s =
+  let buf = Buffer.create (3 * String.length s + 2) in
   Buffer.add_char buf '\"';
-  for i = 0 to String.length s - 1 do
-    let c = s.[i] in
-    if c = '\"' then
-      Buffer.add_string buf "\\\""
-    else if '\x20' <= c && c < '\x7f' then
-      Buffer.add_char buf c
-    else
-      Buffer.add_string buf (Printf.sprintf "\\%02x" (Char.code c));
-  done;
+  String.iter (add_char buf) s;
   Buffer.add_char buf '\"';
   Buffer.contents buf
 
+let bytes = string_with add_hex_char
+let string = string_with add_char
+
 let list_of_opt = function None -> [] | Some x -> [x]
 
 let list f xs = List.map f xs
@@ -35,9 +40,9 @@ let opt f xo = list f (list_of_opt xo)
 let tab head f xs = if xs = [] then [] else [Node (head, list f xs)]
 let atom f x = Atom (f x)
 
-let break_string s =
-  let ss = Lib.String.breakup s (!Flags.width / 2) in
-  list (atom string) ss
+let break_bytes s =
+  let ss = Lib.String.breakup s (!Flags.width / 3 - 4) in
+  list (atom bytes) ss
 
 
 (* Types *)
@@ -277,7 +282,7 @@ let elems seg =
   segment "elem" (list (atom var)) seg
 
 let data seg =
-  segment "data" break_string seg
+  segment "data" break_bytes seg
 
 
 (* Modules *)
@@ -319,6 +324,10 @@ let global off i g =
 
 (* Modules *)
 
+let var_opt = function
+  | None -> ""
+  | Some x -> " " ^ x.it
+
 let is_func_import im =
   match im.it.ikind.it with FuncImport _ -> true | _ -> false
 let is_table_import im =
@@ -328,12 +337,12 @@ let is_memory_import im =
 let is_global_import im =
   match im.it.ikind.it with GlobalImport _ -> true | _ -> false
 
-let module_ m =
+let module_with_var_opt x_opt m =
   let func_imports = List.filter is_func_import m.it.imports in
   let table_imports = List.filter is_table_import m.it.imports in
   let memory_imports = List.filter is_memory_import m.it.imports in
   let global_imports = List.filter is_global_import m.it.imports in
-  Node ("module",
+  Node ("module" ^ var_opt x_opt,
     listi typedef m.it.types @
     listi import table_imports @
     listi import memory_imports @
@@ -349,3 +358,69 @@ let module_ m =
     list data m.it.data
   )
 
+let binary_module_with_var_opt x_opt bs =
+  Node ("module" ^ var_opt x_opt, break_bytes bs)
+
+let module_ = module_with_var_opt None
+let binary_module = binary_module_with_var_opt None
+
+
+(* Scripts *)
+
+let literal lit =
+  match lit.it with
+  | Values.I32 i -> Node ("i32.const " ^ I32.to_string i, [])
+  | Values.I64 i -> Node ("i64.const " ^ I64.to_string i, [])
+  | Values.F32 z -> Node ("f32.const " ^ F32.to_string z, [])
+  | Values.F64 z -> Node ("f64.const " ^ F64.to_string z, [])
+
+let definition mode x_opt def =
+  match mode, def.it with
+  | `Textual, _ | `Original, Textual _ ->
+    let m =
+      match def.it with
+      | Textual m -> m
+      | Binary (_, bs) -> Decode.decode "" bs
+    in module_with_var_opt x_opt m
+  | `Binary, _ | `Original, Binary _ ->
+    let bs =
+      match def.it with
+      | Textual m -> Encode.encode m
+      | Binary (_, bs) -> bs
+    in binary_module_with_var_opt x_opt bs
+
+let access x_opt name =
+  String.concat " " [var_opt x_opt; string name]
+
+let action act =
+  match act.it with
+  | Invoke (x_opt, name, lits) ->
+    Node ("invoke" ^ access x_opt name, List.map literal lits)
+  | Get (x_opt, name) ->
+    Node ("get" ^ access x_opt name, [])
+
+let assertion mode ass =
+  match ass.it with
+  | AssertMalformed (def, re) ->
+    Node ("assert_malformed", [definition `Original None def; Atom (string re)])
+  | AssertInvalid (def, re) ->
+    Node ("assert_invalid", [definition mode None def; Atom (string re)])
+  | AssertUnlinkable (def, re) ->
+    Node ("assert_unlinkable", [definition mode None def; Atom (string re)])
+  | AssertReturn (act, lits) ->
+    Node ("assert_return", action act :: List.map literal lits)
+  | AssertReturnNaN act ->
+    Node ("assert_return_nan", [action act])
+  | AssertTrap (act, re) ->
+    Node ("assert_trap", [action act; Atom (string re)])
+
+let command mode cmd =
+  match cmd.it with
+  | Module (x_opt, def) -> definition mode x_opt def
+  | Register (name, x_opt) ->
+    Node ("register " ^ string name ^ var_opt x_opt, [])
+  | Action act -> action act
+  | Assertion ass -> assertion mode ass
+  | Meta _ -> assert false
+
+let script mode scr = List.map (command mode) scr
diff --git a/ml-proto/host/arrange.mli b/ml-proto/host/arrange.mli
index f9b2268704..a77dedbab8 100644
--- a/ml-proto/host/arrange.mli
+++ b/ml-proto/host/arrange.mli
@@ -4,4 +4,4 @@ val func_type : Types.func_type -> sexpr
 
 val instr : Ast.instr -> sexpr
 val module_ : Ast.module_ -> sexpr
-
+val script : [`Textual | `Binary] -> Script.script -> sexpr list
diff --git a/ml-proto/host/flags.ml b/ml-proto/host/flags.ml
index 13348dab67..2554fba0f9 100644
--- a/ml-proto/host/flags.ml
+++ b/ml-proto/host/flags.ml
@@ -1,6 +1,3 @@
-let name = "wasm"
-let version = "0.2"
-
 let interactive = ref false
 let trace = ref false
 let unchecked = ref false
diff --git a/ml-proto/host/js.ml b/ml-proto/host/js.ml
new file mode 100644
index 0000000000..f66997d596
--- /dev/null
+++ b/ml-proto/host/js.ml
@@ -0,0 +1,157 @@
+open Script
+open Source
+
+
+(* Harness *)
+
+let prefix =
+  "'use strict';\n" ^
+  "\n" ^
+  "let spectest = {\n" ^
+  "  print: print || ((...xs) => console.log(...xs)),\n" ^
+  "  global: 666,\n" ^
+  "};\n" ^  (* TODO: table, memory *)
+  "\n" ^
+  "let registry = {spectest: spectest};\n" ^
+  "let $$;\n" ^
+  "\n" ^
+  "function register(name, instance) {\n" ^
+  "  registry[name] = instance.exports;\n" ^
+  "}\n" ^
+  "\n" ^
+  "function module(bytes) {\n" ^
+  "  let buffer = new ArrayBuffer(bytes.length);\n" ^
+  "  let view = new Uint8Array(buffer);\n" ^
+  "  for (let i = 0; i < bytes.length; ++i) {\n" ^
+  "    view[i] = bytes.charCodeAt(i);\n" ^
+  "  }\n" ^
+  "  return new WebAssembly.Module(buffer);\n" ^
+  "}\n" ^
+  "\n" ^
+  "function instance(bytes) {\n" ^
+  "  return new WebAssembly.Instance(module(bytes), registry);\n" ^
+  "}\n" ^
+  "\n" ^
+  "function assert_malformed(bytes) {\n" ^
+  "  try { module(bytes) } catch (e) { return }\n" ^
+  "  throw new Error(\"Wasm decoding failure expected\");\n" ^
+  "}\n" ^
+  "\n" ^
+  "function assert_invalid(bytes) {\n" ^
+  "  try { module(bytes) } catch (e) { return }\n" ^
+  "  throw new Error(\"Wasm validation failure expected\");\n" ^
+  "}\n" ^
+  "\n" ^
+  "function assert_unlinkable(bytes) {\n" ^
+  "  let mod = module(bytes);\n" ^
+  "  try { new WebAssembly.Instance(mod, registry) } catch (e) { return }\n" ^
+  "  throw new Error(\"Wasm linking failure expected\");\n" ^
+  "}\n" ^
+  "\n" ^
+  "function assert_trap(action) {\n" ^
+  "  try { action() } catch (e) { return }\n" ^
+  "  throw new Error(\"Wasm trap expected\");\n" ^
+  "}\n" ^
+  "\n" ^
+  "function assert_return(action, expected) {\n" ^
+  "  let actual = action();\n" ^
+  "  if (actual !== expected) {\n" ^
+  "    throw new Error(\"Wasm return value \" + expected + \" expected, got \" + actual);\n" ^
+  "  };\n" ^
+  "}\n" ^
+  "\n" ^
+  "function assert_return_nan(action) {\n" ^
+  "  let actual = action();\n" ^
+  "  if (!Number.isNaN(actual)) {\n" ^
+  "    throw new Error(\"Wasm return value NaN expected, got \" + actual);\n" ^
+  "  };\n" ^
+  "}\n" ^
+  "\n"
+
+
+(* Script conversion *)
+
+let add_hex_char buf c = Printf.bprintf buf "\\x%02x" (Char.code c)
+let add_char buf c =
+  if c < '\x20' || c >= '\x7f' then
+    add_hex_char buf c
+  else begin
+    if c = '\"' || c = '\\' then Buffer.add_char buf '\\';
+    Buffer.add_char buf c
+  end
+
+let of_string_with add_char s =
+  let buf = Buffer.create (4 * String.length s + 2) in
+  Buffer.add_char buf '\"';
+  String.iter (add_char buf) s;
+  Buffer.add_char buf '\"';
+  Buffer.contents buf
+
+let of_bytes = of_string_with add_hex_char
+let of_string = of_string_with add_char
+
+let of_float z =
+  match string_of_float z with
+  | "nan" -> "NaN"
+  | "-nan" -> "-NaN"
+  | "inf" -> "Infinity"
+  | "-inf" -> "-Infinity"
+  | s -> s
+
+let of_literal lit =
+  match lit.it with
+  | Values.I32 i -> I32.to_string i
+  | Values.I64 i -> "int64(\"" ^ I64.to_string i ^ "\")"
+  | Values.F32 z -> of_float (F32.to_float z)
+  | Values.F64 z -> of_float (F64.to_float z)
+
+let of_var_opt = function
+  | None -> "$$"
+  | Some x -> x.it
+
+let of_definition def =
+  let bs =
+    match def.it with
+    | Textual m -> Encode.encode m
+    | Binary (_, bs) -> bs
+  in of_bytes bs
+
+let of_action act =
+  match act.it with
+  | Invoke (x_opt, name, lits) ->
+    of_var_opt x_opt ^ ".exports[" ^ of_string name ^ "]" ^
+      "(" ^ String.concat ", " (List.map of_literal lits) ^ ")"
+  | Get (x_opt, name) ->
+    of_var_opt x_opt ^ ".exports[" ^ of_string name ^ "]"
+
+let of_assertion ass =
+  match ass.it with
+  | AssertMalformed (def, _) ->
+    "assert_malformed(" ^ of_definition def ^ ")"
+  | AssertInvalid (def, _) ->
+    "assert_invalid(" ^ of_definition def ^ ")"
+  | AssertUnlinkable (def, _) ->
+    "assert_unlinkable(" ^ of_definition def ^ ")"
+  | AssertReturn (act, lits) ->
+    "assert_return(() => " ^ of_action act ^ ", " ^
+      String.concat ", " (List.map of_literal lits) ^ ")"
+  | AssertReturnNaN act ->
+    "assert_return_nan(() => " ^ of_action act ^ ")"
+  | AssertTrap (act, _) ->
+    "assert_trap(() => " ^ of_action act ^ ")"
+
+let of_command cmd =
+  match cmd.it with
+  | Module (x_opt, def) ->
+    (if x_opt = None then "" else "let " ^ of_var_opt x_opt ^ " = ") ^
+    "$$ = instance(" ^ of_definition def ^ ");\n"
+  | Register (name, x_opt) ->
+    "register(" ^ of_string name ^ ", " ^ of_var_opt x_opt ^ ")\n"
+  | Action act ->
+    of_action act ^ ";\n"
+  | Assertion ass ->
+    of_assertion ass ^ ";\n"
+  | Meta _ -> assert false
+
+let of_script scr =
+  prefix ^ String.concat "" (List.map of_command scr)
diff --git a/ml-proto/host/js.mli b/ml-proto/host/js.mli
new file mode 100644
index 0000000000..c60d3c501b
--- /dev/null
+++ b/ml-proto/host/js.mli
@@ -0,0 +1 @@
+val of_script : Script.script -> string
diff --git a/ml-proto/host/lexer.mll b/ml-proto/host/lexer.mll
index 73846fec3b..2ece85a435 100644
--- a/ml-proto/host/lexer.mll
+++ b/ml-proto/host/lexer.mll
@@ -300,9 +300,11 @@ rule token = parse
   | "import" { IMPORT }
   | "export" { EXPORT }
 
+  | "script" { SCRIPT }
   | "register" { REGISTER }
   | "invoke" { INVOKE }
   | "get" { GET }
+  | "assert_malformed" { ASSERT_MALFORMED }
   | "assert_invalid" { ASSERT_INVALID }
   | "assert_unlinkable" { ASSERT_UNLINKABLE }
   | "assert_return" { ASSERT_RETURN }
diff --git a/ml-proto/host/parser.mly b/ml-proto/host/parser.mly
index 5c9d1a6e63..2d0372c4d2 100644
--- a/ml-proto/host/parser.mly
+++ b/ml-proto/host/parser.mly
@@ -163,8 +163,8 @@ let inline_type c t at =
 %token UNREACHABLE CURRENT_MEMORY GROW_MEMORY
 %token FUNC START TYPE PARAM RESULT LOCAL GLOBAL
 %token MODULE TABLE ELEM MEMORY DATA OFFSET IMPORT EXPORT TABLE
-%token REGISTER INVOKE GET
-%token ASSERT_INVALID ASSERT_UNLINKABLE
+%token SCRIPT REGISTER INVOKE GET
+%token ASSERT_MALFORMED ASSERT_INVALID ASSERT_UNLINKABLE
 %token ASSERT_RETURN ASSERT_RETURN_NAN ASSERT_TRAP
 %token INPUT OUTPUT
 %token EOF
@@ -668,29 +668,29 @@ module_fields :
       {m with exports = $1 c :: m.exports} }
 ;
 module_ :
-  | LPAR MODULE module_var_opt module_fields RPAR
+  | LPAR MODULE script_var_opt module_fields RPAR
     { $3, Textual ($4 (empty_context ()) @@ at ()) @@ at () }
-  | LPAR MODULE module_var_opt TEXT text_list RPAR
-    { $3, Binary ($4 ^ $5) @@ at() }
+  | LPAR MODULE script_var_opt TEXT text_list RPAR
+    { $3, Binary ("binary", $4 ^ $5) @@ at() }
 ;
 
 
 /* Scripts */
 
-module_var_opt :
+script_var_opt :
   | /* empty */ { None }
   | VAR { Some ($1 @@ at ()) }  /* Sugar */
 ;
+
 action :
-  | LPAR INVOKE module_var_opt TEXT const_list RPAR
+  | LPAR INVOKE script_var_opt TEXT const_list RPAR
     { Invoke ($3, $4, $5) @@ at () }
-  | LPAR GET module_var_opt TEXT RPAR
+  | LPAR GET script_var_opt TEXT RPAR
     { Get ($3, $4) @@ at() }
 ;
-cmd :
-  | module_ { Define (fst $1, snd $1) @@ at () }
-  | action { Action $1 @@ at () }
-  | LPAR REGISTER TEXT module_var_opt RPAR { Register ($3, $4) @@ at () }
+assertion :
+  | LPAR ASSERT_MALFORMED module_ TEXT RPAR
+    { AssertMalformed (snd $3, $4) @@ at () }
   | LPAR ASSERT_INVALID module_ TEXT RPAR
     { AssertInvalid (snd $3, $4) @@ at () }
   | LPAR ASSERT_UNLINKABLE module_ TEXT RPAR
@@ -698,15 +698,27 @@ cmd :
   | LPAR ASSERT_RETURN action const_list RPAR { AssertReturn ($3, $4) @@ at () }
   | LPAR ASSERT_RETURN_NAN action RPAR { AssertReturnNaN $3 @@ at () }
   | LPAR ASSERT_TRAP action TEXT RPAR { AssertTrap ($3, $4) @@ at () }
-  | LPAR INPUT TEXT RPAR { Input $3 @@ at () }
-  | LPAR OUTPUT module_var_opt TEXT RPAR { Output ($3, Some $4) @@ at () }
-  | LPAR OUTPUT module_var_opt RPAR { Output ($3, None) @@ at () }
+;
+
+cmd :
+  | action { Action $1 @@ at () }
+  | assertion { Assertion $1 @@ at () }
+  | module_ { Module (fst $1, snd $1) @@ at () }
+  | LPAR REGISTER TEXT script_var_opt RPAR { Register ($3, $4) @@ at () }
+  | meta { Meta $1 @@ at () }
 ;
 cmd_list :
   | /* empty */ { [] }
   | cmd cmd_list { $1 :: $2 }
 ;
 
+meta :
+  | LPAR SCRIPT script_var_opt cmd_list RPAR { Script ($3, $4) @@ at () }
+  | LPAR INPUT script_var_opt TEXT RPAR { Input ($3, $4) @@ at () }
+  | LPAR OUTPUT script_var_opt TEXT RPAR { Output ($3, Some $4) @@ at () }
+  | LPAR OUTPUT script_var_opt RPAR { Output ($3, None) @@ at () }
+;
+
 const :
   | LPAR CONST literal RPAR { snd (literal $2 $3) @@ ati 3 }
 ;
diff --git a/ml-proto/host/run.ml b/ml-proto/host/run.ml
index 4596e370c3..e13bed01d7 100644
--- a/ml-proto/host/run.ml
+++ b/ml-proto/host/run.ml
@@ -1,85 +1,161 @@
+open Script
+open Source
+
+
+(* Errors & Tracing *)
+
+module Abort = Error.Make ()
+module Assert = Error.Make ()
+module IO = Error.Make ()
+
+exception Abort = Abort.Error
+exception Assert = Assert.Error
+exception IO = IO.Error
+
+let trace name = if !Flags.trace then print_endline ("-- " ^ name)
+
+
 (* File types *)
 
-let sexpr_ext = "wast"
 let binary_ext = "wasm"
+let binary_sexpr_ext = "bin.wast"
+let sexpr_ext = "wast"
+let js_ext = "js"
 
-let dispatch_file_ext on_sexpr on_binary file =
-  if Filename.check_suffix file sexpr_ext then
-    on_sexpr file
-  else if Filename.check_suffix file binary_ext then
+let is_binary_file_ext file = Filename.check_suffix file binary_ext
+
+let dispatch_file_ext on_binary on_binary_sexpr on_sexpr on_js file =
+  if Filename.check_suffix file binary_ext then
     on_binary file
+  else if Filename.check_suffix file binary_sexpr_ext then
+    on_binary_sexpr file
+  else if Filename.check_suffix file sexpr_ext then
+    on_sexpr file
+  else if Filename.check_suffix file js_ext then
+    on_js file
   else
-    raise (Sys_error (file ^ ": Unrecognized file type"))
+    raise (Sys_error (file ^ ": unrecognized file type"))
+
+
+(* Output *)
+
+let create_binary_file file m script =
+  trace ("Encoding (" ^ file ^ ")...");
+  let s = Encode.encode m in
+  let oc = open_out_bin file in
+  try
+    trace "Writing...";
+    output_string oc s;
+    close_out oc
+  with exn -> close_out oc; raise exn
+
+let create_sexpr_file mode file m script =
+  trace ("Formatting (" ^ file ^ ")...");
+  let sexprs = Arrange.script mode script in
+  let oc = open_out file in
+  try
+    trace "Writing...";
+    List.iter (Sexpr.output oc !Flags.width) sexprs;
+    close_out oc
+  with exn -> close_out oc; raise exn
+
+let create_js_file file m script =
+  trace ("Converting (" ^ file ^ ")...");
+  let js = Js.of_script script in
+  let oc = open_out file in
+  try
+    trace "Writing...";
+    output_string oc js;
+    close_out oc
+  with exn -> close_out oc; raise exn
+
+let output_file =
+  dispatch_file_ext
+    create_binary_file
+    (create_sexpr_file `Binary)
+    (create_sexpr_file `Textual)
+    create_js_file
+
+let output_stdout m =
+  trace "Formatting...";
+  let sexpr = Arrange.module_ m in
+  trace "Printing...";
+  Sexpr.output stdout !Flags.width sexpr
 
 
 (* Input *)
 
 let error at category msg =
-  Script.trace ("Error: ");
+  trace ("Error: ");
   prerr_endline (Source.string_of_region at ^ ": " ^ category ^ ": " ^ msg);
   false
 
-let run_from get_script =
+let input_from get_script run =
   try
     let script = get_script () in
-    Script.trace "Running...";
-    Script.run script;
+    trace "Running...";
+    run script;
     true
   with
   | Decode.Code (at, msg) -> error at "decoding error" msg
   | Parse.Syntax (at, msg) -> error at "syntax error" msg
-  | Script.Assert (at, msg) -> error at "assertion failure" msg
   | Check.Invalid (at, msg) -> error at "invalid module" msg
   | Import.Unknown (at, msg) -> error at "link failure" msg
   | Eval.Link (at, msg) -> error at "link failure" msg
   | Eval.Trap (at, msg) -> error at "runtime trap" msg
   | Eval.Crash (at, msg) -> error at "runtime crash" msg
-  | Script.IO (at, msg) -> error at "i/o error" msg
-  | Script.Abort _ -> false
+  | IO (at, msg) -> error at "i/o error" msg
+  | Assert (at, msg) -> error at "assertion failure" msg
+  | Abort _ -> false
 
-let run_sexpr name lexbuf start =
-  run_from (fun _ -> Parse.parse name lexbuf start)
+let input_sexpr name lexbuf start run =
+  input_from (fun _ -> Parse.parse name lexbuf start) run
 
-let run_binary name buf =
+let input_binary name buf run =
   let open Source in
-  run_from
-    (fun _ ->
-      let m = Decode.decode name buf in
-      [Script.Define (None, Script.Textual m @@ m.at) @@ m.at])
+  input_from (fun _ ->
+    [Module (None, Binary (name, buf) @@ no_region) @@ no_region]) run
 
-let run_sexpr_file file =
-  Script.trace ("Loading (" ^ file ^ ")...");
+let input_sexpr_file file run =
+  trace ("Loading (" ^ file ^ ")...");
   let ic = open_in file in
   try
     let lexbuf = Lexing.from_channel ic in
-    Script.trace "Parsing...";
-    let success = run_sexpr file lexbuf Parse.Script in
+    trace "Parsing...";
+    let success = input_sexpr file lexbuf Parse.Script run in
     close_in ic;
     success
   with exn -> close_in ic; raise exn
 
-let run_binary_file file =
-  Script.trace ("Loading (" ^ file ^ ")...");
+let input_binary_file file run =
+  trace ("Loading (" ^ file ^ ")...");
   let ic = open_in_bin file in
   try
     let len = in_channel_length ic in
     let buf = Bytes.make len '\x00' in
     really_input ic buf 0 len;
-    Script.trace "Decoding...";
-    let success = run_binary file buf in
+    trace "Decoding...";
+    let success = input_binary file buf run in
     close_in ic;
     success
   with exn -> close_in ic; raise exn
 
-let run_file = dispatch_file_ext run_sexpr_file run_binary_file
+let input_js_file file run =
+  raise (Sys_error (file ^ ": unrecognized input file type"))
 
-let run_string string =
-  Script.trace ("Running (\"" ^ String.escaped string ^ "\")...");
-  let lexbuf = Lexing.from_string string in
-  Script.trace "Parsing...";
-  run_sexpr "string" lexbuf Parse.Script
+let input_file file run =
+  dispatch_file_ext
+    input_binary_file
+    input_sexpr_file
+    input_sexpr_file
+    input_js_file
+    file run
 
-let () = Script.input_file := run_file
+let input_string string run =
+  trace ("Running (\"" ^ String.escaped string ^ "\")...");
+  let lexbuf = Lexing.from_string string in
+  trace "Parsing...";
+  input_sexpr "string" lexbuf Parse.Script run
 
 
 (* Interactive *)
@@ -97,13 +173,13 @@ let lexbuf_stdin buf len =
     if ch = '\n' then i + 1 else loop (i + 1)
   in
   let n = loop 0 in
-  if n = 1 then continuing := false else Script.trace "Parsing...";
+  if n = 1 then continuing := false else trace "Parsing...";
   n
 
-let rec run_stdin () =
+let rec input_stdin run =
   let lexbuf = Lexing.from_function lexbuf_stdin in
   let rec loop () =
-    let success = run_sexpr "stdin" lexbuf Parse.Script1 in
+    let success = input_sexpr "stdin" lexbuf Parse.Script1 run in
     if not success then Lexing.flush_input lexbuf;
     if Lexing.(lexbuf.lex_curr_pos >= lexbuf.lex_buffer_len - 1) then
       continuing := false;
@@ -111,38 +187,246 @@ let rec run_stdin () =
   in
   try loop () with End_of_file ->
     print_endline "";
-    Script.trace "Bye."
+    trace "Bye."
 
 
-(* Output *)
+(* Configuration *)
 
-let print_stdout m =
-  Script.trace "Formatting...";
-  let sexpr = Arrange.module_ m in
-  Script.trace "Printing...";
-  Sexpr.output stdout !Flags.width sexpr
+module Map = Map.Make(String)
 
-let create_sexpr_file file m =
-  Script.trace ("Formatting (" ^ file ^ ")...");
-  let sexpr = Arrange.module_ m in
-  let oc = open_out file in
-  try
-    Script.trace "Writing...";
-    Sexpr.output oc !Flags.width sexpr;
-    close_out oc
-  with exn -> close_out oc; raise exn
+let quote : script ref = ref []
+let scripts : script Map.t ref = ref Map.empty
+let modules : Ast.module_ Map.t ref = ref Map.empty
+let instances : Instance.instance Map.t ref = ref Map.empty
+let registry : Instance.instance Map.t ref = ref Map.empty
 
-let create_binary_file file m =
-  Script.trace ("Encoding (" ^ file ^ ")...");
-  let s = Encode.encode m in
-  let oc = open_out_bin file in
-  try
-    Script.trace "Writing...";
-    output_string oc s;
-    close_out oc
-  with exn -> close_out oc; raise exn
+let bind map x_opt y =
+  let map' =
+    match x_opt with
+    | None -> !map
+    | Some x -> Map.add x.it y !map
+  in map := Map.add "" y map'
+
+let lookup category map x_opt at =
+  let key = match x_opt with None -> "" | Some x -> x.it in
+  try Map.find key !map with Not_found ->
+    IO.error at
+      (if key = "" then "no " ^ category ^ " defined"
+       else "unknown " ^ category ^ " " ^ key)
+
+let lookup_script = lookup "script" scripts
+let lookup_module = lookup "module" modules
+let lookup_instance = lookup "module" instances
+
+let lookup_registry module_name item_name _t =
+  match Instance.export (Map.find module_name !registry) item_name with
+  | Some ext -> ext
+  | None -> raise Not_found
+
+
+(* Running *)
+
+let run_definition def =
+  match def.it with
+  | Textual m -> m
+  | Binary (name, bs) ->
+    trace "Decoding...";
+    Decode.decode name bs
+
+let run_action act =
+  match act.it with
+  | Invoke (x_opt, name, es) ->
+    trace ("Invoking function \"" ^ name ^ "\"...");
+    let inst = lookup_instance x_opt act.at in
+    (match Instance.export inst name with
+    | Some (Instance.ExternalFunc f) -> Eval.invoke f (List.map it es)
+    | Some _ -> Assert.error act.at "export is not a function"
+    | None -> Assert.error act.at "undefined export"
+    )
+
+ | Get (x_opt, name) ->
+    trace ("Getting global \"" ^ name ^ "\"...");
+    let inst = lookup_instance x_opt act.at in
+    (match Instance.export inst name with
+    | Some (Instance.ExternalGlobal v) -> [v]
+    | Some _ -> Assert.error act.at "export is not a global"
+    | None -> Assert.error act.at "undefined export"
+    )
+
+let run_assertion ass =
+  match ass.it with
+  | AssertMalformed (def, re) ->
+    trace "Asserting malformed...";
+    (match
+      ignore (run_definition def)
+    with
+    | exception Decode.Code (_, msg) ->
+      if not (Str.string_match (Str.regexp re) msg 0) then begin
+        print_endline ("Result: \"" ^ msg ^ "\"");
+        print_endline ("Expect: \"" ^ re ^ "\"");
+        Assert.error ass.at "wrong decoding error"
+      end
+    | _ ->
+      Assert.error ass.at "expected decoding error"
+    )
+
+  | AssertInvalid (def, re) ->
+    trace "Asserting invalid...";
+    (match
+      let m = run_definition def in
+      Check.check_module m
+    with
+    | exception Check.Invalid (_, msg) ->
+      if not (Str.string_match (Str.regexp re) msg 0) then begin
+        print_endline ("Result: \"" ^ msg ^ "\"");
+        print_endline ("Expect: \"" ^ re ^ "\"");
+        Assert.error ass.at "wrong validation error"
+      end
+    | _ ->
+      Assert.error ass.at "expected validation error"
+    )
+
+  | AssertUnlinkable (def, re) ->
+    trace "Asserting unlinkable...";
+    let m = run_definition def in
+    if not !Flags.unchecked then Check.check_module m;
+    (match
+      let imports = Import.link m in
+      ignore (Eval.init m imports)
+    with
+    | exception (Import.Unknown (_, msg) | Eval.Link (_, msg)) ->
+      if not (Str.string_match (Str.regexp re) msg 0) then begin
+        print_endline ("Result: \"" ^ msg ^ "\"");
+        print_endline ("Expect: \"" ^ re ^ "\"");
+        Assert.error ass.at "wrong linking error"
+      end
+    | _ ->
+      Assert.error ass.at "expected linking error"
+    )
+
+  | AssertReturn (act, es) ->
+    trace ("Asserting return...");
+    let got_vs = run_action act in
+    let expect_vs = List.map it es in
+    if got_vs <> expect_vs then begin
+      print_string "Result: "; Print.print_result got_vs;
+      print_string "Expect: "; Print.print_result expect_vs;
+      Assert.error ass.at "wrong return values"
+    end
+
+  | AssertReturnNaN act ->
+    trace ("Asserting return...");
+    let got_vs = run_action act in
+    if
+      match got_vs with
+      | [Values.F32 got_f32] ->
+        got_f32 <> F32.pos_nan && got_f32 <> F32.neg_nan
+      | [Values.F64 got_f64] ->
+        got_f64 <> F64.pos_nan && got_f64 <> F64.neg_nan
+      | _ -> true
+    then begin
+      print_string "Result: "; Print.print_result got_vs;
+      print_string "Expect: "; print_endline "nan";
+      Assert.error ass.at "wrong return value"
+    end
+
+  | AssertTrap (act, re) ->
+    trace ("Asserting trap...");
+    (match run_action act with
+    | exception Eval.Trap (_, msg) ->
+      if not (Str.string_match (Str.regexp re) msg 0) then begin
+        print_endline ("Result: \"" ^ msg ^ "\"");
+        print_endline ("Expect: \"" ^ re ^ "\"");
+        Assert.error ass.at "wrong runtime trap"
+      end
+    | _ ->
+      Assert.error ass.at "expected runtime trap"
+    )
+
+let rec run_command cmd =
+  match cmd.it with
+  | Module (x_opt, def) ->
+    quote := cmd :: !quote;
+    let m = run_definition def in
+    if not !Flags.unchecked then begin
+      trace "Checking...";
+      Check.check_module m;
+      if !Flags.print_sig then begin
+        trace "Signature:";
+        Print.print_module_sig m
+      end
+    end;
+    bind scripts x_opt [cmd];
+    bind modules x_opt m;
+    if not !Flags.dry then begin
+      trace "Initializing...";
+      let imports = Import.link m in
+      let inst = Eval.init m imports in
+      bind instances x_opt inst
+    end
+
+  | Register (name, x_opt) ->
+    quote := cmd :: !quote;
+    if not !Flags.dry then begin
+      trace ("Registering module \"" ^ name ^ "\"...");
+      let inst = lookup_instance x_opt cmd.at in
+      registry := Map.add name inst !registry;
+      Import.register name (lookup_registry name)
+    end
+
+  | Action act ->
+    quote := cmd :: !quote;
+    if not !Flags.dry then begin
+      let vs = run_action act in
+      if vs <> [] then Print.print_result vs
+    end
+
+  | Assertion ass ->
+    quote := cmd :: !quote;
+    if not !Flags.dry then begin
+      run_assertion ass
+    end
+
+  | Meta cmd ->
+    run_meta cmd
+
+and run_meta cmd =
+  match cmd.it with
+  | Script (x_opt, script) ->
+    run_quote_script script;
+    bind scripts x_opt (lookup_script None cmd.at)
+
+  | Input (x_opt, file) ->
+    (try if not (input_file file run_quote_script) then
+      Abort.error cmd.at "aborting"
+    with Sys_error msg -> IO.error cmd.at msg);
+    bind scripts x_opt (lookup_script None cmd.at);
+    if x_opt <> None then begin
+      bind modules x_opt (lookup_module None cmd.at);
+      if not !Flags.dry then begin
+        bind instances x_opt (lookup_instance None cmd.at)
+      end
+    end
+
+  | Output (x_opt, Some file) ->
+    (try
+      output_file file (lookup_module x_opt cmd.at) (lookup_script x_opt cmd.at)
+    with Sys_error msg -> IO.error cmd.at msg)
+
+  | Output (x_opt, None) ->
+    (try output_stdout (lookup_module x_opt cmd.at)
+    with Sys_error msg -> IO.error cmd.at msg)
+
+and run_script script =
+  List.iter run_command script
 
-let create_file = dispatch_file_ext create_sexpr_file create_binary_file
+and run_quote_script script =
+  let save_quote = !quote in
+  quote := [];
+  (try run_script script with exn -> quote := save_quote; raise exn);
+  bind scripts None (List.rev !quote);
+  quote := !quote @ save_quote
 
-let () = Script.output_file := create_file
-let () = Script.output_stdout := print_stdout
+let run_file file = input_file file run_script
+let run_string string = input_string string run_script
+let run_stdin () = input_stdin run_script
diff --git a/ml-proto/host/run.mli b/ml-proto/host/run.mli
index 8b57b619d9..39393d260c 100644
--- a/ml-proto/host/run.mli
+++ b/ml-proto/host/run.mli
@@ -1,5 +1,9 @@
+exception Abort of Source.region * string
+exception Assert of Source.region * string
+exception IO of Source.region * string
+
+val trace : string -> unit
+
 val run_string : string -> bool
 val run_file : string -> bool
 val run_stdin : unit -> unit
-
-val create_file : string -> Ast.module_ -> unit
diff --git a/ml-proto/host/script.ml b/ml-proto/host/script.ml
index 74b1abe05a..8dbae17957 100644
--- a/ml-proto/host/script.ml
+++ b/ml-proto/host/script.ml
@@ -1,269 +1,38 @@
-open Source
-open Instance
-
-
-(* Script representation *)
-
 type var = string Source.phrase
 
 type definition = definition' Source.phrase
 and definition' =
   | Textual of Ast.module_
-  | Binary of string
+  | Binary of string * string
 
 type action = action' Source.phrase
 and action' =
   | Invoke of var option * string * Ast.literal list
   | Get of var option * string
 
-type command = command' Source.phrase
-and command' =
-  | Define of var option * definition
-  | Register of string * var option
-  | Action of action
+type assertion = assertion' Source.phrase
+and assertion' =
+  | AssertMalformed of definition * string
   | AssertInvalid of definition * string
   | AssertUnlinkable of definition * string
   | AssertReturn of action * Ast.literal list
   | AssertReturnNaN of action
   | AssertTrap of action * string
-  | Input of string
-  | Output of var option * string option
-
-type script = command list
-
-
-(* Execution *)
-
-module Abort = Error.Make ()
-module Syntax = Error.Make ()
-module Assert = Error.Make ()
-module IO = Error.Make ()
-
-exception Abort = Abort.Error
-exception Syntax = Syntax.Error
-exception Assert = Assert.Error
-exception IO = IO.Error
-
-let trace name = if !Flags.trace then print_endline ("-- " ^ name)
-
-module Map = Map.Make(String)
-
-let registry : Instance.instance Map.t ref = ref Map.empty
-
-let lookup module_name item_name _t =
-  match Instance.export (Map.find module_name !registry) item_name with
-  | Some ext -> ext
-  | None -> raise Not_found
-
-let modules : Ast.module_ Map.t ref = ref Map.empty
-let instances : Instance.instance Map.t ref = ref Map.empty
-let current_module : Ast.module_ option ref = ref None
-let current_instance : Instance.instance option ref = ref None
-
-let bind map x_opt y =
-  match x_opt with
-  | None -> ()
-  | Some x -> map := Map.add x.it y !map
-
-let get_module x_opt at =
-  match x_opt, !current_module with
-  | None, Some m -> m
-  | None, None -> raise (Eval.Crash (at, "no module defined"))
-  | Some x, _ ->
-    try Map.find x.it !modules with Not_found ->
-      raise (Eval.Crash (x.at, "unknown module " ^ x.it))
 
-let get_instance x_opt at =
-  match x_opt, !current_instance with
-  | None, Some inst -> inst
-  | None, None -> raise (Eval.Crash (at, "no module defined"))
-  | Some x, _ ->
-    try Map.find x.it !instances with Not_found ->
-      raise (Eval.Crash (x.at, "unknown module " ^ x.it))
-
-let input_file = ref (fun _ -> assert false)
-let output_file = ref (fun _ -> assert false)
-let output_stdout = ref (fun _ -> assert false)
-
-let run_def def =
-  match def.it with
-  | Textual m -> m
-  | Binary bs ->
-    trace "Decoding...";
-    Decode.decode "binary" bs
-
-let run_action act =
-  match act.it with
-  | Invoke (x_opt, name, es) ->
-    trace ("Invoking function \"" ^ name ^ "\"...");
-    let inst = get_instance x_opt act.at in
-    (match Instance.export inst name with
-    | Some (ExternalFunc f) -> Eval.invoke f (List.map it es)
-    | Some _ -> Assert.error act.at "export is not a function"
-    | None -> Assert.error act.at "undefined export"
-    )
-
- | Get (x_opt, name) ->
-    trace ("Getting global \"" ^ name ^ "\"...");
-    let inst = get_instance x_opt act.at in
-    (match Instance.export inst name with
-    | Some (ExternalGlobal v) -> [v]
-    | Some _ -> Assert.error act.at "export is not a global"
-    | None -> Assert.error act.at "undefined export"
-    )
-
-let run_cmd cmd =
-  match cmd.it with
-  | Define (x_opt, def) ->
-    let m = run_def def in
-    if not !Flags.unchecked then begin
-      trace "Checking...";
-      Check.check_module m;
-      if !Flags.print_sig then begin
-        trace "Signature:";
-        Print.print_module_sig m
-      end
-    end;
-    trace "Initializing...";
-    let imports = Import.link m in
-    let inst = Eval.init m imports in
-    current_module := Some m;
-    current_instance := Some inst;
-    bind modules x_opt m;
-    bind instances x_opt inst
-
-  | Register (name, x_opt) ->
-    trace ("Registering module \"" ^ name ^ "\"...");
-    let inst = get_instance x_opt cmd.at in
-    registry := Map.add name inst !registry;
-    Import.register name (lookup name)
-
-  | Action act ->
-    let vs = run_action act in
-    if vs <> [] then Print.print_result vs
-
-  | AssertInvalid (def, re) ->
-    trace "Asserting invalid...";
-    (match
-      let m = run_def def in
-      Check.check_module m
-    with
-    | exception (Decode.Code (_, msg) | Check.Invalid (_, msg)) ->
-      if not (Str.string_match (Str.regexp re) msg 0) then begin
-        print_endline ("Result: \"" ^ msg ^ "\"");
-        print_endline ("Expect: \"" ^ re ^ "\"");
-        Assert.error cmd.at "wrong validation error"
-      end
-    | _ ->
-      Assert.error cmd.at "expected validation error"
-    )
-
-  | AssertUnlinkable (def, re) ->
-    trace "Asserting unlinkable...";
-    let m = run_def def in
-    if not !Flags.unchecked then Check.check_module m;
-    (match
-      let imports = Import.link m in
-      ignore (Eval.init m imports)
-    with
-    | exception (Import.Unknown (_, msg) | Eval.Link (_, msg)) ->
-      if not (Str.string_match (Str.regexp re) msg 0) then begin
-        print_endline ("Result: \"" ^ msg ^ "\"");
-        print_endline ("Expect: \"" ^ re ^ "\"");
-        Assert.error cmd.at "wrong linking error"
-      end
-    | _ ->
-      Assert.error cmd.at "expected linking error"
-    )
-
-  | AssertReturn (act, es) ->
-    trace ("Asserting return...");
-    let got_vs = run_action act in
-    let expect_vs = List.map it es in
-    if got_vs <> expect_vs then begin
-      print_string "Result: "; Print.print_result got_vs;
-      print_string "Expect: "; Print.print_result expect_vs;
-      Assert.error cmd.at "wrong return value"
-    end
-
-  | AssertReturnNaN act ->
-    trace ("Asserting return...");
-    let got_vs = run_action act in
-    if
-      match got_vs with
-      | [Values.F32 got_f32] ->
-        got_f32 <> F32.pos_nan && got_f32 <> F32.neg_nan
-      | [Values.F64 got_f64] ->
-        got_f64 <> F64.pos_nan && got_f64 <> F64.neg_nan
-      | _ -> true
-    then begin
-      print_string "Result: "; Print.print_result got_vs;
-      print_string "Expect: "; print_endline "nan";
-      Assert.error cmd.at "wrong return value"
-    end
-
-  | AssertTrap (act, re) ->
-    trace ("Asserting trap...");
-    (match run_action act with
-    | exception Eval.Trap (_, msg) ->
-      if not (Str.string_match (Str.regexp re) msg 0) then begin
-        print_endline ("Result: \"" ^ msg ^ "\"");
-        print_endline ("Expect: \"" ^ re ^ "\"");
-        Assert.error cmd.at "wrong runtime trap"
-      end
-    | _ ->
-      Assert.error cmd.at "expected runtime trap"
-    )
-
-  | Input file ->
-    (try if not (!input_file file) then Abort.error cmd.at "aborting"
-    with Sys_error msg -> IO.error cmd.at msg)
-
-  | Output (x_opt, Some file) ->
-    (try !output_file file (get_module x_opt cmd.at)
-    with Sys_error msg -> IO.error cmd.at msg)
-
-  | Output (x_opt, None) ->
-    (try !output_stdout (get_module x_opt cmd.at)
-    with Sys_error msg -> IO.error cmd.at msg)
+type command = command' Source.phrase
+and command' =
+  | Module of var option * definition
+  | Register of string * var option
+  | Action of action
+  | Assertion of assertion
+  | Meta of meta
 
-let dry_def def =
-  match def.it with
-  | Textual m -> m
-  | Binary bs ->
-    trace "Decoding...";
-    Decode.decode "binary" bs
+and meta = meta' Source.phrase
+and meta' =
+  | Input of var option * string
+  | Output of var option * string option
+  | Script of var option * script
 
-let dry_cmd cmd =
-  match cmd.it with
-  | Define (x_opt, def) ->
-    let m = dry_def def in
-    if not !Flags.unchecked then begin
-      trace "Checking...";
-      Check.check_module m;
-      if !Flags.print_sig then begin
-        trace "Signature:";
-        Print.print_module_sig m
-      end
-    end;
-    current_module := Some m;
-    bind modules x_opt m
-  | Input file ->
-    (try if not (!input_file file) then Abort.error cmd.at "aborting"
-    with Sys_error msg -> IO.error cmd.at msg)
-  | Output (x_opt, Some file) ->
-    (try !output_file file (get_module x_opt cmd.at)
-    with Sys_error msg -> IO.error cmd.at msg)
-  | Output (x_opt, None) ->
-    (try !output_stdout (get_module x_opt cmd.at)
-    with Sys_error msg -> IO.error cmd.at msg)
-  | Register _
-  | Action _
-  | AssertInvalid _
-  | AssertUnlinkable _
-  | AssertReturn _
-  | AssertReturnNaN _
-  | AssertTrap _ -> ()
+and script = command list
 
-let run script =
-  List.iter (if !Flags.dry then dry_cmd else run_cmd) script
+exception Syntax of Source.region * string
diff --git a/ml-proto/host/script.mli b/ml-proto/host/script.mli
deleted file mode 100644
index 60e21182bf..0000000000
--- a/ml-proto/host/script.mli
+++ /dev/null
@@ -1,40 +0,0 @@
-type var = string Source.phrase
-
-type definition = definition' Source.phrase
-and definition' =
-  | Textual of Ast.module_
-  | Binary of string
-
-type action = action' Source.phrase
-and action' =
-  | Invoke of var option * string * Ast.literal list
-  | Get of var option * string
-
-type command = command' Source.phrase
-and command' =
-  | Define of var option * definition
-  | Register of string * var option
-  | Action of action
-  | AssertInvalid of definition * string
-  | AssertUnlinkable of definition * string
-  | AssertReturn of action * Ast.literal list
-  | AssertReturnNaN of action
-  | AssertTrap of action * string
-  | Input of string
-  | Output of var option * string option
-
-type script = command list
-
-exception Abort of Source.region * string
-exception Syntax of Source.region * string
-exception Assert of Source.region * string
-exception IO of Source.region * string
-
-val run : script -> unit
-  (* raises Check.Invalid, Eval.Trap, Eval.Crash, Assert, IO *)
-
-val trace : string -> unit
-
-val input_file : (string -> bool) ref
-val output_file : (string -> Ast.module_ -> unit) ref
-val output_stdout : (Ast.module_ -> unit) ref
diff --git a/ml-proto/runtests.py b/ml-proto/runtests.py
index b235e892e1..2ad00cffab 100755
--- a/ml-proto/runtests.py
+++ b/ml-proto/runtests.py
@@ -51,25 +51,31 @@ def _runTestFile(self, shortName, fileName, interpreterPath):
       return
 
     # Convert to binary and validate again
-    wasmPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.wasm"))
-    logPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.wasm.log"))
+    wasmPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.bin.wast"))
+    logPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.bin.wast.log"))
     self._runCommand(("%s -d '%s' -o '%s'") % (interpreterPath, fileName, wasmPath))
     self._runCommand(("%s -d '%s'") % (interpreterPath, wasmPath), logPath)
 
     # Convert back to text and validate again
-    wastPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.wasm.wast"))
-    logPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.wasm.wast.log"))
+    wastPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.bin.wast.wast"))
+    logPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.bin.wast.wast.log"))
     self._runCommand(("%s -d '%s' -o '%s'") % (interpreterPath, wasmPath, wastPath))
     self._runCommand(("%s -d '%s' ") % (interpreterPath, wastPath), logPath)
 
     # Convert back to binary once more and compare
-    wasm2Path = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.wasm.wast.wasm"))
+    wasm2Path = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.bin.wast.wast.bin.wast"))
+    logPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".wast.bin.wast.wast.bin.wast.log"))
     self._runCommand(("%s -d '%s' -o '%s'") % (interpreterPath, wastPath, wasm2Path))
     self._runCommand(("%s -d '%s'") % (interpreterPath, wasm2Path), logPath)
     # TODO: The binary should stay the same, but OCaml's float-string conversions are inaccurate.
     # Once we upgrade to OCaml 4.03, use sprintf "%s" for printing floats.
     # self._compareFile(wasmPath, wasm2Path)
 
+    # Convert to JavaScript
+    jsPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".js"))
+    logPath = auxFile(fileName.replace("test/", "test/output/").replace(".wast", ".js.log"))
+    self._runCommand(("%s -d '%s' -o '%s'") % (interpreterPath, fileName, jsPath))
+
 def generate_test_case(rec):
   return lambda self : self._runTestFile(*rec)
 
diff --git a/ml-proto/spec/decode.ml b/ml-proto/spec/decode.ml
index ed13f4cb60..8513b43891 100644
--- a/ml-proto/spec/decode.ml
+++ b/ml-proto/spec/decode.ml
@@ -211,7 +211,7 @@ let arity s = u8 s
 
 let memop s =
   let align = vu32 s in
-  require (I32.lt_u align 32l) s (pos s - 1) "invalid memop flags";
+  require (I32.le_u align 32l) s (pos s - 1) "invalid memop flags";
   let offset = vu64 s in
   1 lsl Int32.to_int align, offset
 
diff --git a/ml-proto/test/binary.wast b/ml-proto/test/binary.wast
index b2b7908cb3..07fc114a9b 100644
--- a/ml-proto/test/binary.wast
+++ b/ml-proto/test/binary.wast
@@ -1,16 +1,15 @@
 (module "\00asm\0c\00\00\00")
 (module "\00asm" "\0c\00\00\00")
-(module $M "\00asm\0c\00\00\00")
-(module $M "\00asm" "\0c\00\00\00")
+(module $M1 "\00asm\0c\00\00\00")
+(module $M2 "\00asm" "\0c\00\00\00")
 
-(assert_invalid (module "") "unexpected end")
-(assert_invalid (module "\01") "unexpected end")
-(assert_invalid (module "\00as") "unexpected end")
-(assert_invalid (module "\01") "unexpected end")
-(assert_invalid (module "asm\00") "magic header not detected")
-
-(assert_invalid (module "\00asm") "unexpected end")
-(assert_invalid (module "\00asm\0c") "unexpected end")
-(assert_invalid (module "\00asm\0c\00\00") "unexpected end")
-(assert_invalid (module "\00asm\10\00\00\00") "unknown binary version")
+(assert_malformed (module "") "unexpected end")
+(assert_malformed (module "\01") "unexpected end")
+(assert_malformed (module "\00as") "unexpected end")
+(assert_malformed (module "\01") "unexpected end")
+(assert_malformed (module "asm\00") "magic header not detected")
 
+(assert_malformed (module "\00asm") "unexpected end")
+(assert_malformed (module "\00asm\0c") "unexpected end")
+(assert_malformed (module "\00asm\0c\00\00") "unexpected end")
+(assert_malformed (module "\00asm\10\00\00\00") "unknown binary version")
diff --git a/ml-proto/test/linking.wast b/ml-proto/test/linking.wast
index 0f35578962..616d62e631 100644
--- a/ml-proto/test/linking.wast
+++ b/ml-proto/test/linking.wast
@@ -1,53 +1,53 @@
 ;; Functions
 
-(module $M
+(module $Mf
   (func (export "call") (result i32) (call $g))
   (func $g (result i32) (i32.const 2))
 )
-(register "M" $M)
+(register "Mf" $Mf)
 
-(module $N
-  (func $f (import "M" "call") (result i32))
-  (export "M.call" (func $f))
-  (func (export "call M.call") (result i32) (call $f))
+(module $Nf
+  (func $f (import "Mf" "call") (result i32))
+  (export "Mf.call" (func $f))
+  (func (export "call Mf.call") (result i32) (call $f))
   (func (export "call") (result i32) (call $g))
   (func $g (result i32) (i32.const 3))
 )
 
-(assert_return (invoke $M "call") (i32.const 2))
-(assert_return (invoke $N "M.call") (i32.const 2))
-(assert_return (invoke $N "call") (i32.const 3))
-(assert_return (invoke $N "call M.call") (i32.const 2))
+(assert_return (invoke $Mf "call") (i32.const 2))
+(assert_return (invoke $Nf "Mf.call") (i32.const 2))
+(assert_return (invoke $Nf "call") (i32.const 3))
+(assert_return (invoke $Nf "call Mf.call") (i32.const 2))
 
 
 ;; Globals
 
-(module $M
+(module $Mg
   (global $glob (export "glob") i32 (i32.const 42))
   (func (export "get") (result i32) (get_global $glob))
 )
-(register "M" $M)
+(register "Mg" $Mg)
 
-(module $N
-  (global $x (import "M" "glob") i32)
-  (func $f (import "M" "get") (result i32))
-  (export "M.glob" (global $x))
-  (export "M.get" (func $f))
+(module $Ng
+  (global $x (import "Mg" "glob") i32)
+  (func $f (import "Mg" "get") (result i32))
+  (export "Mg.glob" (global $x))
+  (export "Mg.get" (func $f))
   (global $glob (export "glob") i32 (i32.const 43))
   (func (export "get") (result i32) (get_global $glob))
 )
 
-(assert_return (get $M "glob") (i32.const 42))
-(assert_return (get $N "M.glob") (i32.const 42))
-(assert_return (get $N "glob") (i32.const 43))
-(assert_return (invoke $M "get") (i32.const 42))
-(assert_return (invoke $N "M.get") (i32.const 42))
-(assert_return (invoke $N "get") (i32.const 43))
+(assert_return (get $Mg "glob") (i32.const 42))
+(assert_return (get $Ng "Mg.glob") (i32.const 42))
+(assert_return (get $Ng "glob") (i32.const 43))
+(assert_return (invoke $Mg "get") (i32.const 42))
+(assert_return (invoke $Ng "Mg.get") (i32.const 42))
+(assert_return (invoke $Ng "get") (i32.const 43))
 
 
 ;; Tables
 
-(module $M
+(module $Mt
   (type (func (result i32)))
   (type (func))
 
@@ -60,20 +60,20 @@
     (call_indirect 0 (get_local 0))
   )
 )
-(register "M" $M)
+(register "Mt" $Mt)
 
-(module $N
+(module $Nt
   (type (func))
   (type (func (result i32)))
 
-  (func $f (import "M" "call") (param i32) (result i32))
-  (func $h (import "M" "h") (result i32))
+  (func $f (import "Mt" "call") (param i32) (result i32))
+  (func $h (import "Mt" "h") (result i32))
 
   (table anyfunc (elem $g $g $g $h $f))
   (func $g (result i32) (i32.const 5))
 
-  (export "M.call" (func $f))
-  (func (export "call M.call") (param i32) (result i32)
+  (export "Mt.call" (func $f))
+  (func (export "call Mt.call") (param i32) (result i32)
     (call $f (get_local 0))
   )
   (func (export "call") (param i32) (result i32)
@@ -81,34 +81,34 @@
   )
 )
 
-(assert_return (invoke $M "call" (i32.const 2)) (i32.const 4))
-(assert_return (invoke $N "M.call" (i32.const 2)) (i32.const 4))
-(assert_return (invoke $N "call" (i32.const 2)) (i32.const 5))
-(assert_return (invoke $N "call M.call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4))
 
-(assert_trap (invoke $M "call" (i32.const 1)) "uninitialized")
-(assert_trap (invoke $N "M.call" (i32.const 1)) "uninitialized")
-(assert_return (invoke $N "call" (i32.const 1)) (i32.const 5))
-(assert_trap (invoke $N "call M.call" (i32.const 1)) "uninitialized")
+(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized")
 
-(assert_trap (invoke $M "call" (i32.const 0)) "uninitialized")
-(assert_trap (invoke $N "M.call" (i32.const 0)) "uninitialized")
-(assert_return (invoke $N "call" (i32.const 0)) (i32.const 5))
-(assert_trap (invoke $N "call M.call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
 
-(assert_trap (invoke $M "call" (i32.const 20)) "undefined")
-(assert_trap (invoke $N "M.call" (i32.const 20)) "undefined")
-(assert_trap (invoke $N "call" (i32.const 7)) "undefined")
-(assert_trap (invoke $N "call M.call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined")
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined")
 
-(assert_return (invoke $N "call" (i32.const 3)) (i32.const -4))
-(assert_trap (invoke $N "call" (i32.const 4)) "indirect call")
+(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4))
+(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call")
 
-(module $O
+(module $Ot
   (type (func (result i32)))
 
-  (func $h (import "M" "h") (result i32))
-  (table (import "M" "tab") 5 anyfunc)
+  (func $h (import "Mt" "h") (result i32))
+  (table (import "Mt" "tab") 5 anyfunc)
   (elem (i32.const 1) $i $h)
   (func $i (result i32) (i32.const 6))
 
@@ -117,47 +117,47 @@
   )
 )
 
-(assert_return (invoke $M "call" (i32.const 3)) (i32.const 4))
-(assert_return (invoke $N "M.call" (i32.const 3)) (i32.const 4))
-(assert_return (invoke $N "call M.call" (i32.const 3)) (i32.const 4))
-(assert_return (invoke $O "call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4))
 
-(assert_return (invoke $M "call" (i32.const 2)) (i32.const -4))
-(assert_return (invoke $N "M.call" (i32.const 2)) (i32.const -4))
-(assert_return (invoke $N "call" (i32.const 2)) (i32.const 5))
-(assert_return (invoke $N "call M.call" (i32.const 2)) (i32.const -4))
-(assert_return (invoke $O "call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4))
 
-(assert_return (invoke $M "call" (i32.const 1)) (i32.const 6))
-(assert_return (invoke $N "M.call" (i32.const 1)) (i32.const 6))
-(assert_return (invoke $N "call" (i32.const 1)) (i32.const 5))
-(assert_return (invoke $N "call M.call" (i32.const 1)) (i32.const 6))
-(assert_return (invoke $O "call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6))
 
-(assert_trap (invoke $M "call" (i32.const 0)) "uninitialized")
-(assert_trap (invoke $N "M.call" (i32.const 0)) "uninitialized")
-(assert_return (invoke $N "call" (i32.const 0)) (i32.const 5))
-(assert_trap (invoke $N "call M.call" (i32.const 0)) "uninitialized")
-(assert_trap (invoke $O "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized")
 
-(assert_trap (invoke $O "call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined")
 
 (assert_unlinkable
-  (module $Q
+  (module $Qt
     (func $host (import "spectest" "print"))
-    (table (import "M" "tab") 10 anyfunc)
+    (table (import "Mt" "tab") 10 anyfunc)
     (elem (i32.const 7) $own)
     (elem (i32.const 9) $host)
     (func $own (result i32) (i32.const 666))
   )
   "invalid use of host function"
 )
-(assert_trap (invoke $M "call" (i32.const 7)) "uninitialized")
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized")
 
 
 ;; Memories
 
-(module $M
+(module $Mm
   (memory (export "mem") 1 5)
   (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
 
@@ -165,26 +165,26 @@
     (i32.load8_u (get_local 0))
   )
 )
-(register "M" $M)
+(register "Mm" $Mm)
 
-(module $N
-  (func $loadM (import "M" "load") (param i32) (result i32))
+(module $Nm
+  (func $loadM (import "Mm" "load") (param i32) (result i32))
 
   (memory 1)
   (data (i32.const 10) "\f0\f1\f2\f3\f4\f5")
 
-  (export "M.load" (func $loadM))
+  (export "Mm.load" (func $loadM))
   (func (export "load") (param $a i32) (result i32)
     (i32.load8_u (get_local 0))
   )
 )
 
-(assert_return (invoke $M "load" (i32.const 12)) (i32.const 2))
-(assert_return (invoke $N "M.load" (i32.const 12)) (i32.const 2))
-(assert_return (invoke $N "load" (i32.const 12)) (i32.const 0xf2))
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
 
-(module $O
-  (memory (import "M" "mem") 1)
+(module $Om
+  (memory (import "Mm" "mem") 1)
   (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
 
   (func (export "load") (param $a i32) (result i32)
@@ -192,32 +192,32 @@
   )
 )
 
-(assert_return (invoke $M "load" (i32.const 12)) (i32.const 0xa7))
-(assert_return (invoke $N "M.load" (i32.const 12)) (i32.const 0xa7))
-(assert_return (invoke $N "load" (i32.const 12)) (i32.const 0xf2))
-(assert_return (invoke $O "load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7))
 
-(module $P
-  (memory (import "M" "mem") 1 8)
+(module $Pm
+  (memory (import "Mm" "mem") 1 8)
 
   (func (export "grow") (param $a i32) (result i32)
     (grow_memory (get_local 0))
   )
 )
 
-(assert_return (invoke $P "grow" (i32.const 0)) (i32.const 1))
-(assert_return (invoke $P "grow" (i32.const 2)) (i32.const 1))
-(assert_return (invoke $P "grow" (i32.const 0)) (i32.const 3))
-(assert_return (invoke $P "grow" (i32.const 1)) (i32.const 3))
-(assert_return (invoke $P "grow" (i32.const 1)) (i32.const 4))
-(assert_return (invoke $P "grow" (i32.const 0)) (i32.const 5))
-(assert_return (invoke $P "grow" (i32.const 1)) (i32.const -1))
-(assert_return (invoke $P "grow" (i32.const 0)) (i32.const 5))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
 
 (assert_unlinkable
-  (module $Q
+  (module $Qm
     (func $host (import "spectest" "print"))
-    (memory (import "M" "mem") 1)
+    (memory (import "Mm" "mem") 1)
     (table 10 anyfunc)
     (data (i32.const 0) "abc")
     (elem (i32.const 9) $host)
@@ -225,4 +225,4 @@
   )
   "invalid use of host function"
 )
-(assert_return (invoke $M "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))