moonscratch 0.1.1 → 0.1.2

package/src/api_program_wasm.mbt

@@ -1,1647 +0,0 @@
-///|
-const IMPORT_GET_VAR_NUM_INDEX : Int = 0
-
-///|
-const IMPORT_SET_VAR_NUM_INDEX : Int = 1
-
-///|
-const IMPORT_SET_VAR_JSON_INDEX : Int = 2
-
-///|
-const IMPORT_MOD_INDEX : Int = 3
-
-///|
-const IMPORT_EXEC_OPCODE_INDEX : Int = 4
-
-///|
-const IMPORT_EXEC_TAIL_INDEX : Int = 5
-
-///|
-const IMPORT_EXEC_DRAW_OPCODE_INDEX : Int = 6
-
-///|
-const LOOP_COUNTER_LOCAL : Int = 0
-
-///|
-const LOOP_GUARD_LOCAL : Int = 1
-
-///|
-const LOOP_GUARD_MAX : Int = 10000
-
-///|
-const RUNNER_CACHED_LOCAL_START : Int = 2
-
-///|
-const RUNNER_CACHE_BASE_USE_THRESHOLD : Int = 4
-
-///|
-const RUNNER_CACHE_MAX_VARIABLES : Int = 32
-
-///|
-priv struct RunnerLiteralRef {
-  ptr : Int
-  len : Int
-}
-
-///|
-priv struct WasmDataSegment {
-  offset : Int
-  bytes : Array[Byte]
-}
-
-///|
-priv struct RunnerCachedVar {
-  key : String
-  target : Int
-  variable_id : String
-  local_index : Int
-  use_count : Int
-}
-
-///|
-priv enum RunnerNumExpr {
-  Num(Double)
-  VarNum(Int, String)
-  BinNum(String, RunnerNumExpr, RunnerNumExpr)
-  UnaryNum(String, RunnerNumExpr)
-}
-
-///|
-priv enum RunnerBoolExpr {
-  Bool(Bool)
-  CmpNum(String, RunnerNumExpr, RunnerNumExpr)
-  BinBool(String, RunnerBoolExpr, RunnerBoolExpr)
-  Not(RunnerBoolExpr)
-}
-
-///|
-priv enum RunnerCommand {
-  SetNumExpr(Int, String, RunnerNumExpr)
-  SetJsonConst(Int, String, String)
-  ChangeNumExpr(Int, String, RunnerNumExpr)
-  DrawOpcode(Int, String, RunnerNumExpr, RunnerNumExpr, Int)
-  If(RunnerBoolExpr, Array[RunnerCommand])
-  IfElse(RunnerBoolExpr, Array[RunnerCommand], Array[RunnerCommand])
-  Repeat(RunnerNumExpr, Array[RunnerCommand])
-  RepeatUntil(RunnerBoolExpr, Array[RunnerCommand])
-  While(RunnerBoolExpr, Array[RunnerCommand])
-  HostOpcode(Int, Int)
-  HostTail(Int, Int)
-}
-
-///|
-fn bytes_from_ints(values : Array[Int]) -> Array[Byte] {
-  let out = []
-  for value in values {
-    out.push(value.to_byte())
-  }
-  out
-}
-
-///|
-fn append_bytes(target : Array[Byte], source : Array[Byte]) -> Unit {
-  for value in source {
-    target.push(value)
-  }
-}
-
-///|
-fn encode_utf8_bytes(value : String) -> Array[Byte] {
-  @utf8.encode(value.view()).to_array()
-}
-
-///|
-fn encode_u32_leb_step(value : Int, out : Array[Byte]) -> Unit {
-  let mut byte = value & 0x7f
-  let next = value >> 7
-  if next != 0 {
-    byte = byte | 0x80
-  }
-  out.push(byte.to_byte())
-  if next != 0 {
-    encode_u32_leb_step(next, out)
-  }
-}
-
-///|
-fn encode_u32_leb(input : Int) -> Array[Byte] {
-  if input < 0 {
-    return []
-  }
-  let out = []
-  encode_u32_leb_step(input, out)
-  out
-}
-
-///|
-fn encode_i32_leb_step(value : Int, out : Array[Byte]) -> Unit {
-  let mut byte = value & 0x7f
-  let next = value >> 7
-  let sign_bit = (byte & 0x40) != 0
-  let done = (next == 0 && !sign_bit) || (next == -1 && sign_bit)
-  if !done {
-    byte = byte | 0x80
-  }
-  out.push(byte.to_byte())
-  if !done {
-    encode_i32_leb_step(next, out)
-  }
-}
-
-///|
-fn encode_i32_leb(input : Int) -> Array[Byte] {
-  let out = []
-  encode_i32_leb_step(input, out)
-  out
-}
-
-///|
-fn encode_name(value : String) -> Array[Byte] {
-  let bytes = encode_utf8_bytes(value)
-  let out = []
-  append_bytes(out, encode_u32_leb(bytes.length()))
-  append_bytes(out, bytes)
-  out
-}
-
-///|
-fn encode_section(id : Int, payload : Array[Byte]) -> Array[Byte] {
-  let out = [id.to_byte()]
-  append_bytes(out, encode_u32_leb(payload.length()))
-  append_bytes(out, payload)
-  out
-}
-
-///|
-fn push_i32_const(out : Array[Byte], input : Int) -> Unit {
-  out.push((0x41).to_byte())
-  append_bytes(out, encode_i32_leb(input))
-}
-
-///|
-fn push_f64_const(out : Array[Byte], input : Double) -> Unit {
-  out.push((0x44).to_byte())
-  append_bytes(out, input.reinterpret_as_uint64().to_le_bytes().to_array())
-}
-
-///|
-fn push_call(out : Array[Byte], function_index : Int) -> Unit {
-  out.push((0x10).to_byte())
-  append_bytes(out, encode_u32_leb(function_index))
-}
-
-///|
-fn push_local_get(out : Array[Byte], local_index : Int) -> Unit {
-  out.push((0x20).to_byte())
-  append_bytes(out, encode_u32_leb(local_index))
-}
-
-///|
-fn push_local_set(out : Array[Byte], local_index : Int) -> Unit {
-  out.push((0x21).to_byte())
-  append_bytes(out, encode_u32_leb(local_index))
-}
-
-///|
-fn push_br(out : Array[Byte], depth : Int) -> Unit {
-  out.push((0x0c).to_byte())
-  append_bytes(out, encode_u32_leb(depth))
-}
-
-///|
-fn push_br_if(out : Array[Byte], depth : Int) -> Unit {
-  out.push((0x0d).to_byte())
-  append_bytes(out, encode_u32_leb(depth))
-}
-
-///|
-fn runner_variable_key(target : Int, variable_id : String) -> String {
-  "\{target}:\{variable_id}"
-}
-
-///|
-fn json_to_non_negative_int(raw : Json?) -> Int? {
-  match raw {
-    Some(Number(n, ..)) =>
-      if n.is_nan() || n.is_inf() {
-        None
-      } else {
-        let out = n.to_int()
-        if out < 0 {
-          None
-        } else {
-          Some(out)
-        }
-      }
-    _ => None
-  }
-}
-
-///|
-fn parse_runner_num_expr(raw : Json, depth : Int) -> RunnerNumExpr? {
-  if depth > 64 {
-    return None
-  }
-  let obj = match raw {
-    Object(value) => value
-    _ => return None
-  }
-  let kind = object_get_string_or(obj, "kind", "")
-  if kind == "num" {
-    match obj.get("value") {
-      Some(Number(value, ..)) =>
-        if value.is_nan() || value.is_inf() {
-          None
-        } else {
-          Some(RunnerNumExpr::Num(value))
-        }
-      _ => None
-    }
-  } else if kind == "var_num" {
-    let target = json_to_non_negative_int(obj.get("target"))
-    let variable_id = object_get_string_or(obj, "id", "")
-    match target {
-      Some(value) if variable_id != "" =>
-        Some(RunnerNumExpr::VarNum(value, variable_id))
-      _ => None
-    }
-  } else if kind == "bin_num" {
-    let op = object_get_string_or(obj, "op", "")
-    if op != "add" && op != "sub" && op != "mul" && op != "div" && op != "mod" {
-      return None
-    }
-    match
-      (
-        parse_runner_num_expr(
-          object_get_or(obj, "left", Json::null()),
-          depth + 1,
-        ),
-        parse_runner_num_expr(
-          object_get_or(obj, "right", Json::null()),
-          depth + 1,
-        ),
-      ) {
-      (Some(left), Some(right)) => Some(RunnerNumExpr::BinNum(op, left, right))
-      _ => None
-    }
-  } else if kind == "unary_num" {
-    let op = object_get_string_or(obj, "op", "")
-    if op != "round" &&
-      op != "abs" &&
-      op != "floor" &&
-      op != "ceil" &&
-      op != "sqrt" {
-      return None
-    }
-    match
-      parse_runner_num_expr(
-        object_get_or(obj, "value", Json::null()),
-        depth + 1,
-      ) {
-      Some(value) => Some(RunnerNumExpr::UnaryNum(op, value))
-      None => None
-    }
-  } else {
-    None
-  }
-}
-
-///|
-fn parse_runner_bool_expr(raw : Json, depth : Int) -> RunnerBoolExpr? {
-  if depth > 64 {
-    return None
-  }
-  let obj = match raw {
-    Object(value) => value
-    _ => return None
-  }
-  let kind = object_get_string_or(obj, "kind", "")
-  if kind == "bool" {
-    match obj.get("value") {
-      Some(True) => Some(RunnerBoolExpr::Bool(true))
-      Some(False) => Some(RunnerBoolExpr::Bool(false))
-      _ => None
-    }
-  } else if kind == "cmp_num" {
-    let op = object_get_string_or(obj, "op", "")
-    if op != "lt" && op != "gt" && op != "eq" && op != "ne" {
-      return None
-    }
-    match
-      (
-        parse_runner_num_expr(
-          object_get_or(obj, "left", Json::null()),
-          depth + 1,
-        ),
-        parse_runner_num_expr(
-          object_get_or(obj, "right", Json::null()),
-          depth + 1,
-        ),
-      ) {
-      (Some(left), Some(right)) => Some(RunnerBoolExpr::CmpNum(op, left, right))
-      _ => None
-    }
-  } else if kind == "bin_bool" {
-    let op = object_get_string_or(obj, "op", "")
-    if op != "and" && op != "or" {
-      return None
-    }
-    match
-      (
-        parse_runner_bool_expr(
-          object_get_or(obj, "left", Json::null()),
-          depth + 1,
-        ),
-        parse_runner_bool_expr(
-          object_get_or(obj, "right", Json::null()),
-          depth + 1,
-        ),
-      ) {
-      (Some(left), Some(right)) =>
-        Some(RunnerBoolExpr::BinBool(op, left, right))
-      _ => None
-    }
-  } else if kind == "not" {
-    match
-      parse_runner_bool_expr(
-        object_get_or(obj, "value", Json::null()),
-        depth + 1,
-      ) {
-      Some(value) => Some(RunnerBoolExpr::Not(value))
-      None => None
-    }
-  } else {
-    None
-  }
-}
-
-///|
-fn parse_runner_command_array(
-  raw : Array[Json],
-  depth : Int,
-) -> Array[RunnerCommand]? {
-  let out = []
-  for item in raw {
-    match parse_runner_command(item, depth + 1) {
-      Some(parsed) => out.push(parsed)
-      None => return None
-    }
-  }
-  Some(out)
-}
-
-///|
-fn parse_runner_command(raw : Json, depth : Int) -> RunnerCommand? {
-  if depth > 64 {
-    return None
-  }
-  let obj = match raw {
-    Object(value) => value
-    _ => return None
-  }
-  let op = object_get_string_or(obj, "op", "")
-  let target = json_to_non_negative_int(obj.get("target"))
-  let variable_id = object_get_string_or(obj, "id", "")
-
-  if op == "set_var" || op == "set_var_num_expr" || op == "set_var_json_const" {
-    match target {
-      Some(target_value) if variable_id != "" =>
-        if op == "set_var_num_expr" {
-          match
-            parse_runner_num_expr(
-              object_get_or(obj, "expr", Json::null()),
-              depth + 1,
-            ) {
-            Some(expr) =>
-              Some(RunnerCommand::SetNumExpr(target_value, variable_id, expr))
-            None => None
-          }
-        } else if op == "set_var_json_const" {
-          let value_json = object_get_or(obj, "value", Json::null()).stringify()
-          Some(
-            RunnerCommand::SetJsonConst(target_value, variable_id, value_json),
-          )
-        } else {
-          match obj.get("value") {
-            Some(Number(value, ..)) if !value.is_nan() && !value.is_inf() =>
-              Some(
-                RunnerCommand::SetNumExpr(
-                  target_value,
-                  variable_id,
-                  RunnerNumExpr::Num(value),
-                ),
-              )
-            _ =>
-              Some(
-                RunnerCommand::SetJsonConst(
-                  target_value,
-                  variable_id,
-                  object_get_or(obj, "value", Json::null()).stringify(),
-                ),
-              )
-          }
-        }
-      _ => None
-    }
-  } else if op == "change_var" || op == "change_var_num_expr" {
-    match target {
-      Some(target_value) if variable_id != "" =>
-        if op == "change_var_num_expr" {
-          match
-            parse_runner_num_expr(
-              object_get_or(obj, "expr", Json::null()),
-              depth + 1,
-            ) {
-            Some(expr) =>
-              Some(
-                RunnerCommand::ChangeNumExpr(target_value, variable_id, expr),
-              )
-            None => None
-          }
-        } else {
-          let delta = match obj.get("delta") {
-            Some(Number(value, ..)) if !value.is_nan() && !value.is_inf() =>
-              value
-            _ => 0.0
-          }
-          Some(
-            RunnerCommand::ChangeNumExpr(
-              target_value,
-              variable_id,
-              RunnerNumExpr::Num(delta),
-            ),
-          )
-        }
-      _ => None
-    }
-  } else if op == "draw_opcode" {
-    match target {
-      Some(target_value) => {
-        let draw_opcode = object_get_string_or(obj, "opcode", "")
-        let extra = match obj.get("extra") {
-          Some(Number(value, ..)) if !value.is_nan() && !value.is_inf() =>
-            value.to_int()
-          _ => 0
-        }
-        if draw_opcode == "" {
-          None
-        } else {
-          let arg0 = match
-            parse_runner_num_expr(
-              object_get_or(obj, "arg0", Json::null()),
-              depth + 1,
-            ) {
-            Some(value) => value
-            None => RunnerNumExpr::Num(0.0)
-          }
-          let arg1 = match
-            parse_runner_num_expr(
-              object_get_or(obj, "arg1", Json::null()),
-              depth + 1,
-            ) {
-            Some(value) => value
-            None => RunnerNumExpr::Num(0.0)
-          }
-          Some(
-            RunnerCommand::DrawOpcode(
-              target_value, draw_opcode, arg0, arg1, extra,
-            ),
-          )
-        }
-      }
-      None => None
-    }
-  } else if op == "if" {
-    match
-      (
-        parse_runner_bool_expr(
-          object_get_or(obj, "cond", Json::null()),
-          depth + 1,
-        ),
-        match obj.get("then") {
-          Some(Array(values)) => parse_runner_command_array(values, depth + 1)
-          _ => None
-        },
-      ) {
-      (Some(cond), Some(then_commands)) =>
-        Some(RunnerCommand::If(cond, then_commands))
-      _ => None
-    }
-  } else if op == "if_else" {
-    match
-      (
-        parse_runner_bool_expr(
-          object_get_or(obj, "cond", Json::null()),
-          depth + 1,
-        ),
-        match obj.get("then") {
-          Some(Array(values)) => parse_runner_command_array(values, depth + 1)
-          _ => None
-        },
-        match obj.get("else") {
-          Some(Array(values)) => parse_runner_command_array(values, depth + 1)
-          _ => None
-        },
-      ) {
-      (Some(cond), Some(then_commands), Some(else_commands)) =>
-        Some(RunnerCommand::IfElse(cond, then_commands, else_commands))
-      _ => None
-    }
-  } else if op == "repeat" {
-    match
-      (
-        parse_runner_num_expr(
-          object_get_or(obj, "times", Json::null()),
-          depth + 1,
-        ),
-        match obj.get("body") {
-          Some(Array(values)) => parse_runner_command_array(values, depth + 1)
-          _ => None
-        },
-      ) {
-      (Some(times), Some(body)) => Some(RunnerCommand::Repeat(times, body))
-      _ => None
-    }
-  } else if op == "repeat_until" {
-    match
-      (
-        parse_runner_bool_expr(
-          object_get_or(obj, "cond", Json::null()),
-          depth + 1,
-        ),
-        match obj.get("body") {
-          Some(Array(values)) => parse_runner_command_array(values, depth + 1)
-          _ => None
-        },
-      ) {
-      (Some(cond), Some(body)) => Some(RunnerCommand::RepeatUntil(cond, body))
-      _ => None
-    }
-  } else if op == "while" {
-    match
-      (
-        parse_runner_bool_expr(
-          object_get_or(obj, "cond", Json::null()),
-          depth + 1,
-        ),
-        match obj.get("body") {
-          Some(Array(values)) => parse_runner_command_array(values, depth + 1)
-          _ => None
-        },
-      ) {
-      (Some(cond), Some(body)) => Some(RunnerCommand::While(cond, body))
-      _ => None
-    }
-  } else if op == "host_tail" {
-    match (target, json_to_non_negative_int(obj.get("pc"))) {
-      (Some(target_value), Some(start_pc)) =>
-        Some(RunnerCommand::HostTail(target_value, start_pc))
-      _ => None
-    }
-  } else if op == "host_opcode" {
-    match (target, json_to_non_negative_int(obj.get("pc"))) {
-      (Some(target_value), Some(pc)) =>
-        Some(RunnerCommand::HostOpcode(target_value, pc))
-      _ => None
-    }
-  } else {
-    None
-  }
-}
-
-///|
-fn parse_runner_commands_json(commands_json : String) -> Array[RunnerCommand] {
-  if commands_json.trim().is_empty() {
-    return []
-  }
-  let parsed = try? @json.parse(commands_json)
-  let commands_raw = match parsed {
-    Ok(Array(values)) => values
-    Ok(Object(obj)) =>
-      match obj.get("exec") {
-        Some(Array(values)) => values
-        _ => []
-      }
-    _ => []
-  }
-  match parse_runner_command_array(commands_raw, 0) {
-    Some(commands) => commands
-    None => []
-  }
-}
-
-///|
-fn runner_cached_var_usage_touch(
-  usage : Map[String, RunnerCachedVar],
-  order : Array[String],
-  target : Int,
-  variable_id : String,
-  weight : Int,
-) -> Unit {
-  let normalized_weight = if weight <= 0 { 1 } else { weight }
-  let key = runner_variable_key(target, variable_id)
-  match usage.get(key) {
-    Some(current) =>
-      usage[key] = {
-        key: current.key,
-        target: current.target,
-        variable_id: current.variable_id,
-        local_index: current.local_index,
-        use_count: current.use_count + normalized_weight,
-      }
-    None => {
-      usage[key] = {
-        key,
-        target,
-        variable_id,
-        local_index: -1,
-        use_count: normalized_weight,
-      }
-      order.push(key)
-    }
-  }
-}
-
-///|
-fn runner_usage_weight(loop_depth : Int) -> Int {
-  let capped = if loop_depth < 0 {
-    0
-  } else if loop_depth > 4 {
-    4
-  } else {
-    loop_depth
-  }
-  1 << capped
-}
-
-///|
-fn runner_collect_num_expr_usage(
-  expr : RunnerNumExpr,
-  usage : Map[String, RunnerCachedVar],
-  order : Array[String],
-  weight : Int,
-) -> Unit {
-  match expr {
-    Num(_) => ()
-    VarNum(target, variable_id) =>
-      runner_cached_var_usage_touch(usage, order, target, variable_id, weight)
-    BinNum(_, left, right) => {
-      runner_collect_num_expr_usage(left, usage, order, weight)
-      runner_collect_num_expr_usage(right, usage, order, weight)
-    }
-    UnaryNum(_, value) =>
-      runner_collect_num_expr_usage(value, usage, order, weight)
-  }
-}
-
-///|
-fn runner_collect_bool_expr_usage(
-  expr : RunnerBoolExpr,
-  usage : Map[String, RunnerCachedVar],
-  order : Array[String],
-  weight : Int,
-) -> Unit {
-  match expr {
-    Bool(_) => ()
-    CmpNum(_, left, right) => {
-      runner_collect_num_expr_usage(left, usage, order, weight)
-      runner_collect_num_expr_usage(right, usage, order, weight)
-    }
-    BinBool(_, left, right) => {
-      runner_collect_bool_expr_usage(left, usage, order, weight)
-      runner_collect_bool_expr_usage(right, usage, order, weight)
-    }
-    Not(value) => runner_collect_bool_expr_usage(value, usage, order, weight)
-  }
-}
-
-///|
-fn runner_collect_usage_from_commands(
-  commands : Array[RunnerCommand],
-  usage : Map[String, RunnerCachedVar],
-  order : Array[String],
-  blocked : Map[String, Bool],
-  loop_depth : Int,
-) -> Int {
-  let current_weight = runner_usage_weight(loop_depth)
-  let mut host_barrier_count = 0
-  for command in commands {
-    host_barrier_count += match command {
-      SetNumExpr(target, variable_id, expr) => {
-        runner_cached_var_usage_touch(
-          usage, order, target, variable_id, current_weight,
-        )
-        runner_collect_num_expr_usage(expr, usage, order, current_weight)
-        0
-      }
-      SetJsonConst(target, variable_id, _) => {
-        blocked[runner_variable_key(target, variable_id)] = true
-        0
-      }
-      ChangeNumExpr(target, variable_id, expr) => {
-        runner_cached_var_usage_touch(
-          usage, order, target, variable_id, current_weight,
-        )
-        runner_collect_num_expr_usage(expr, usage, order, current_weight)
-        0
-      }
-      DrawOpcode(_, _, arg0, arg1, _) => {
-        runner_collect_num_expr_usage(arg0, usage, order, current_weight)
-        runner_collect_num_expr_usage(arg1, usage, order, current_weight)
-        0
-      }
-      If(cond, then_commands) => {
-        runner_collect_bool_expr_usage(cond, usage, order, current_weight)
-        runner_collect_usage_from_commands(
-          then_commands, usage, order, blocked, loop_depth,
-        )
-      }
-      IfElse(cond, then_commands, else_commands) => {
-        runner_collect_bool_expr_usage(cond, usage, order, current_weight)
-        runner_collect_usage_from_commands(
-          then_commands, usage, order, blocked, loop_depth,
-        ) +
-        runner_collect_usage_from_commands(
-          else_commands, usage, order, blocked, loop_depth,
-        )
-      }
-      Repeat(times, body) => {
-        runner_collect_num_expr_usage(times, usage, order, current_weight)
-        runner_collect_usage_from_commands(
-          body,
-          usage,
-          order,
-          blocked,
-          loop_depth + 1,
-        )
-      }
-      RepeatUntil(cond, body) => {
-        runner_collect_bool_expr_usage(
-          cond,
-          usage,
-          order,
-          runner_usage_weight(loop_depth + 1),
-        )
-        runner_collect_usage_from_commands(
-          body,
-          usage,
-          order,
-          blocked,
-          loop_depth + 1,
-        )
-      }
-      While(cond, body) => {
-        runner_collect_bool_expr_usage(
-          cond,
-          usage,
-          order,
-          runner_usage_weight(loop_depth + 1),
-        )
-        runner_collect_usage_from_commands(
-          body,
-          usage,
-          order,
-          blocked,
-          loop_depth + 1,
-        )
-      }
-      HostOpcode(_, _) | HostTail(_, _) => current_weight
-    }
-  }
-  host_barrier_count
-}
-
-///|
-fn runner_cache_min_use_count(host_barrier_count : Int) -> Int {
-  let _ignored = host_barrier_count
-  RUNNER_CACHE_BASE_USE_THRESHOLD
-}
-
-///|
-fn build_runner_cached_vars(
-  commands : Array[RunnerCommand],
-) -> (Map[String, RunnerCachedVar], Array[RunnerCachedVar]) {
-  let usage : Map[String, RunnerCachedVar] = {}
-  let order = []
-  let blocked : Map[String, Bool] = {}
-  let host_barrier_count = runner_collect_usage_from_commands(
-    commands, usage, order, blocked, 0,
-  )
-  let min_use_count = runner_cache_min_use_count(host_barrier_count)
-  let cached_by_key : Map[String, RunnerCachedVar] = {}
-  let cached_vars = []
-  let mut next_local_index = RUNNER_CACHED_LOCAL_START
-  for key in order {
-    if cached_vars.length() < RUNNER_CACHE_MAX_VARIABLES &&
-      !blocked.contains(key) {
-      match usage.get(key) {
-        Some(candidate) =>
-          if candidate.use_count >= min_use_count {
-            let cached = {
-              key: candidate.key,
-              target: candidate.target,
-              variable_id: candidate.variable_id,
-              local_index: next_local_index,
-              use_count: candidate.use_count,
-            }
-            cached_by_key[key] = cached
-            cached_vars.push(cached)
-            next_local_index += 1
-          }
-        None => ()
-      }
-    }
-  }
-  (cached_by_key, cached_vars)
-}
-
-///|
-fn runner_cached_var_lookup(
-  cached_by_key : Map[String, RunnerCachedVar],
-  target : Int,
-  variable_id : String,
-) -> RunnerCachedVar? {
-  cached_by_key.get(runner_variable_key(target, variable_id))
-}
-
-///|
-fn emit_runner_load_cached_var(
-  cached : RunnerCachedVar,
-  refs : Map[String, RunnerLiteralRef],
-  out : Array[Byte],
-) -> Bool {
-  match refs.get("id:\{cached.variable_id}") {
-    Some(id_ref) => {
-      push_i32_const(out, cached.target)
-      push_i32_const(out, id_ref.ptr)
-      push_i32_const(out, id_ref.len)
-      push_call(out, IMPORT_GET_VAR_NUM_INDEX)
-      push_local_set(out, cached.local_index)
-      true
-    }
-    None => false
-  }
-}
-
-///|
-fn emit_runner_flush_cached_var(
-  cached : RunnerCachedVar,
-  refs : Map[String, RunnerLiteralRef],
-  out : Array[Byte],
-) -> Bool {
-  match refs.get("id:\{cached.variable_id}") {
-    Some(id_ref) => {
-      push_i32_const(out, cached.target)
-      push_i32_const(out, id_ref.ptr)
-      push_i32_const(out, id_ref.len)
-      push_local_get(out, cached.local_index)
-      push_call(out, IMPORT_SET_VAR_NUM_INDEX)
-      true
-    }
-    None => false
-  }
-}
-
-///|
-fn emit_runner_sync_cached_vars(
-  cached_vars : Array[RunnerCachedVar],
-  refs : Map[String, RunnerLiteralRef],
-  out : Array[Byte],
-  load_mode : Bool,
-) -> Bool {
-  for cached in cached_vars {
-    let ok = if load_mode {
-      emit_runner_load_cached_var(cached, refs, out)
-    } else {
-      emit_runner_flush_cached_var(cached, refs, out)
-    }
-    if !ok {
-      return false
-    }
-  }
-  true
-}
-
-///|
-fn runner_register_literal(
-  refs : Map[String, RunnerLiteralRef],
-  bytes : Array[Byte],
-  base_ptr : Int,
-  key : String,
-  literal : String,
-) -> Unit {
-  match refs.get(key) {
-    Some(_) => return
-    None => ()
-  }
-  let encoded = encode_utf8_bytes(literal)
-  refs[key] = { ptr: base_ptr + bytes.length(), len: encoded.length() }
-  append_bytes(bytes, encoded)
-}
-
-///|
-fn collect_num_expr_literals(
-  expr : RunnerNumExpr,
-  refs : Map[String, RunnerLiteralRef],
-  bytes : Array[Byte],
-  base_ptr : Int,
-) -> Unit {
-  match expr {
-    Num(_) => ()
-    VarNum(_, variable_id) =>
-      runner_register_literal(
-        refs,
-        bytes,
-        base_ptr,
-        "id:\{variable_id}",
-        variable_id,
-      )
-    BinNum(_, left, right) => {
-      collect_num_expr_literals(left, refs, bytes, base_ptr)
-      collect_num_expr_literals(right, refs, bytes, base_ptr)
-    }
-    UnaryNum(_, value) =>
-      collect_num_expr_literals(value, refs, bytes, base_ptr)
-  }
-}
-
-///|
-fn collect_bool_expr_literals(
-  expr : RunnerBoolExpr,
-  refs : Map[String, RunnerLiteralRef],
-  bytes : Array[Byte],
-  base_ptr : Int,
-) -> Unit {
-  match expr {
-    Bool(_) => ()
-    CmpNum(_, left, right) => {
-      collect_num_expr_literals(left, refs, bytes, base_ptr)
-      collect_num_expr_literals(right, refs, bytes, base_ptr)
-    }
-    BinBool(_, left, right) => {
-      collect_bool_expr_literals(left, refs, bytes, base_ptr)
-      collect_bool_expr_literals(right, refs, bytes, base_ptr)
-    }
-    Not(value) => collect_bool_expr_literals(value, refs, bytes, base_ptr)
-  }
-}
-
-///|
-fn collect_command_literals(
-  command : RunnerCommand,
-  refs : Map[String, RunnerLiteralRef],
-  bytes : Array[Byte],
-  base_ptr : Int,
-) -> Unit {
-  match command {
-    SetNumExpr(_, variable_id, expr) => {
-      runner_register_literal(
-        refs,
-        bytes,
-        base_ptr,
-        "id:\{variable_id}",
-        variable_id,
-      )
-      collect_num_expr_literals(expr, refs, bytes, base_ptr)
-    }
-    SetJsonConst(_, variable_id, value_json) => {
-      runner_register_literal(
-        refs,
-        bytes,
-        base_ptr,
-        "id:\{variable_id}",
-        variable_id,
-      )
-      runner_register_literal(
-        refs,
-        bytes,
-        base_ptr,
-        "json:\{value_json}",
-        value_json,
-      )
-    }
-    ChangeNumExpr(_, variable_id, expr) => {
-      runner_register_literal(
-        refs,
-        bytes,
-        base_ptr,
-        "id:\{variable_id}",
-        variable_id,
-      )
-      collect_num_expr_literals(expr, refs, bytes, base_ptr)
-    }
-    DrawOpcode(_, opcode, arg0, arg1, _) => {
-      runner_register_literal(refs, bytes, base_ptr, "opcode:\{opcode}", opcode)
-      collect_num_expr_literals(arg0, refs, bytes, base_ptr)
-      collect_num_expr_literals(arg1, refs, bytes, base_ptr)
-    }
-    If(cond, then_commands) => {
-      collect_bool_expr_literals(cond, refs, bytes, base_ptr)
-      for child in then_commands {
-        collect_command_literals(child, refs, bytes, base_ptr)
-      }
-    }
-    IfElse(cond, then_commands, else_commands) => {
-      collect_bool_expr_literals(cond, refs, bytes, base_ptr)
-      for child in then_commands {
-        collect_command_literals(child, refs, bytes, base_ptr)
-      }
-      for child in else_commands {
-        collect_command_literals(child, refs, bytes, base_ptr)
-      }
-    }
-    Repeat(times, body) => {
-      collect_num_expr_literals(times, refs, bytes, base_ptr)
-      for child in body {
-        collect_command_literals(child, refs, bytes, base_ptr)
-      }
-    }
-    RepeatUntil(cond, body) => {
-      collect_bool_expr_literals(cond, refs, bytes, base_ptr)
-      for child in body {
-        collect_command_literals(child, refs, bytes, base_ptr)
-      }
-    }
-    While(cond, body) => {
-      collect_bool_expr_literals(cond, refs, bytes, base_ptr)
-      for child in body {
-        collect_command_literals(child, refs, bytes, base_ptr)
-      }
-    }
-    HostOpcode(_, _) | HostTail(_, _) => ()
-  }
-}
-
-///|
-fn build_runner_literal_pool(
-  commands : Array[RunnerCommand],
-  base_ptr : Int,
-) -> (Array[Byte], Map[String, RunnerLiteralRef]) {
-  let refs : Map[String, RunnerLiteralRef] = {}
-  let bytes = []
-  for command in commands {
-    collect_command_literals(command, refs, bytes, base_ptr)
-  }
-  (bytes, refs)
-}
-
-///|
-fn emit_runner_num_expr(
-  expr : RunnerNumExpr,
-  refs : Map[String, RunnerLiteralRef],
-  cached_by_key : Map[String, RunnerCachedVar],
-  out : Array[Byte],
-) -> Bool {
-  match expr {
-    Num(value) => {
-      push_f64_const(out, value)
-      true
-    }
-    VarNum(target, variable_id) =>
-      match runner_cached_var_lookup(cached_by_key, target, variable_id) {
-        Some(cached) => {
-          push_local_get(out, cached.local_index)
-          true
-        }
-        None =>
-          match refs.get("id:\{variable_id}") {
-            Some(id_ref) => {
-              push_i32_const(out, target)
-              push_i32_const(out, id_ref.ptr)
-              push_i32_const(out, id_ref.len)
-              push_call(out, IMPORT_GET_VAR_NUM_INDEX)
-              true
-            }
-            None => false
-          }
-      }
-    BinNum(op, left, right) => {
-      if !emit_runner_num_expr(left, refs, cached_by_key, out) ||
-        !emit_runner_num_expr(right, refs, cached_by_key, out) {
-        return false
-      }
-      if op == "add" {
-        out.push((0xa0).to_byte())
-      } else if op == "sub" {
-        out.push((0xa1).to_byte())
-      } else if op == "mul" {
-        out.push((0xa2).to_byte())
-      } else if op == "div" {
-        out.push((0xa3).to_byte())
-      } else {
-        push_call(out, IMPORT_MOD_INDEX)
-      }
-      true
-    }
-    UnaryNum(op, value) => {
-      if !emit_runner_num_expr(value, refs, cached_by_key, out) {
-        return false
-      }
-      if op == "round" {
-        out.push((0x9e).to_byte())
-      } else if op == "abs" {
-        out.push((0x99).to_byte())
-      } else if op == "floor" {
-        out.push((0x9c).to_byte())
-      } else if op == "ceil" {
-        out.push((0x9b).to_byte())
-      } else {
-        out.push((0x9f).to_byte())
-      }
-      true
-    }
-  }
-}
-
-///|
-fn emit_runner_bool_expr(
-  expr : RunnerBoolExpr,
-  refs : Map[String, RunnerLiteralRef],
-  cached_by_key : Map[String, RunnerCachedVar],
-  out : Array[Byte],
-) -> Bool {
-  match expr {
-    Bool(value) => {
-      push_i32_const(out, if value { 1 } else { 0 })
-      true
-    }
-    CmpNum(op, left, right) => {
-      if !emit_runner_num_expr(left, refs, cached_by_key, out) ||
-        !emit_runner_num_expr(right, refs, cached_by_key, out) {
-        return false
-      }
-      if op == "lt" {
-        out.push((0x63).to_byte())
-      } else if op == "gt" {
-        out.push((0x64).to_byte())
-      } else if op == "eq" {
-        out.push((0x61).to_byte())
-      } else {
-        out.push((0x61).to_byte())
-        out.push((0x45).to_byte())
-      }
-      true
-    }
-    BinBool(op, left, right) => {
-      if !emit_runner_bool_expr(left, refs, cached_by_key, out) ||
-        !emit_runner_bool_expr(right, refs, cached_by_key, out) {
-        return false
-      }
-      out.push(if op == "and" { (0x71).to_byte() } else { (0x72).to_byte() })
-      true
-    }
-    Not(value) => {
-      if !emit_runner_bool_expr(value, refs, cached_by_key, out) {
-        return false
-      }
-      out.push((0x45).to_byte())
-      true
-    }
-  }
-}
-
-///|
-fn emit_runner_commands(
-  commands : Array[RunnerCommand],
-  refs : Map[String, RunnerLiteralRef],
-  cached_by_key : Map[String, RunnerCachedVar],
-  cached_vars : Array[RunnerCachedVar],
-  out : Array[Byte],
-) -> Bool {
-  for command in commands {
-    match command {
-      SetNumExpr(target, variable_id, expr) =>
-        match runner_cached_var_lookup(cached_by_key, target, variable_id) {
-          Some(cached) => {
-            if !emit_runner_num_expr(expr, refs, cached_by_key, out) {
-              return false
-            }
-            push_local_set(out, cached.local_index)
-          }
-          None =>
-            match refs.get("id:\{variable_id}") {
-              Some(id_ref) => {
-                push_i32_const(out, target)
-                push_i32_const(out, id_ref.ptr)
-                push_i32_const(out, id_ref.len)
-                if !emit_runner_num_expr(expr, refs, cached_by_key, out) {
-                  return false
-                }
-                push_call(out, IMPORT_SET_VAR_NUM_INDEX)
-              }
-              None => return false
-            }
-        }
-      SetJsonConst(target, variable_id, value_json) =>
-        match (refs.get("id:\{variable_id}"), refs.get("json:\{value_json}")) {
-          (Some(id_ref), Some(json_ref)) => {
-            push_i32_const(out, target)
-            push_i32_const(out, id_ref.ptr)
-            push_i32_const(out, id_ref.len)
-            push_i32_const(out, json_ref.ptr)
-            push_i32_const(out, json_ref.len)
-            push_call(out, IMPORT_SET_VAR_JSON_INDEX)
-          }
-          _ => return false
-        }
-      ChangeNumExpr(target, variable_id, expr) =>
-        match runner_cached_var_lookup(cached_by_key, target, variable_id) {
-          Some(cached) => {
-            push_local_get(out, cached.local_index)
-            if !emit_runner_num_expr(expr, refs, cached_by_key, out) {
-              return false
-            }
-            out.push((0xa0).to_byte())
-            push_local_set(out, cached.local_index)
-          }
-          None =>
-            match refs.get("id:\{variable_id}") {
-              Some(id_ref) => {
-                push_i32_const(out, target)
-                push_i32_const(out, id_ref.ptr)
-                push_i32_const(out, id_ref.len)
-                push_i32_const(out, target)
-                push_i32_const(out, id_ref.ptr)
-                push_i32_const(out, id_ref.len)
-                push_call(out, IMPORT_GET_VAR_NUM_INDEX)
-                if !emit_runner_num_expr(expr, refs, cached_by_key, out) {
-                  return false
-                }
-                out.push((0xa0).to_byte())
-                push_call(out, IMPORT_SET_VAR_NUM_INDEX)
-              }
-              None => return false
-            }
-        }
-      DrawOpcode(target, opcode, arg0, arg1, extra) =>
-        match refs.get("opcode:\{opcode}") {
-          Some(opcode_ref) => {
-            push_i32_const(out, target)
-            push_i32_const(out, opcode_ref.ptr)
-            push_i32_const(out, opcode_ref.len)
-            if !emit_runner_num_expr(arg0, refs, cached_by_key, out) ||
-              !emit_runner_num_expr(arg1, refs, cached_by_key, out) {
-              return false
-            }
-            push_i32_const(out, extra)
-            push_call(out, IMPORT_EXEC_DRAW_OPCODE_INDEX)
-            out.push((0x1a).to_byte())
-          }
-          None => return false
-        }
-      If(cond, then_commands) => {
-        if !emit_runner_bool_expr(cond, refs, cached_by_key, out) {
-          return false
-        }
-        out.push((0x04).to_byte())
-        out.push((0x40).to_byte())
-        if !emit_runner_commands(
-            then_commands, refs, cached_by_key, cached_vars, out,
-          ) {
-          return false
-        }
-        out.push((0x0b).to_byte())
-      }
-      IfElse(cond, then_commands, else_commands) => {
-        if !emit_runner_bool_expr(cond, refs, cached_by_key, out) {
-          return false
-        }
-        out.push((0x04).to_byte())
-        out.push((0x40).to_byte())
-        if !emit_runner_commands(
-            then_commands, refs, cached_by_key, cached_vars, out,
-          ) {
-          return false
-        }
-        out.push((0x05).to_byte())
-        if !emit_runner_commands(
-            else_commands, refs, cached_by_key, cached_vars, out,
-          ) {
-          return false
-        }
-        out.push((0x0b).to_byte())
-      }
-      Repeat(times, body) => {
-        if !emit_runner_num_expr(times, refs, cached_by_key, out) {
-          return false
-        }
-        push_local_set(out, LOOP_COUNTER_LOCAL)
-        push_i32_const(out, LOOP_GUARD_MAX)
-        push_local_set(out, LOOP_GUARD_LOCAL)
-        out.push((0x02).to_byte())
-        out.push((0x40).to_byte())
-        out.push((0x03).to_byte())
-        out.push((0x40).to_byte())
-        push_local_get(out, LOOP_GUARD_LOCAL)
-        out.push((0x45).to_byte())
-        push_br_if(out, 1)
-        push_local_get(out, LOOP_COUNTER_LOCAL)
-        push_f64_const(out, 0.0)
-        out.push((0x65).to_byte())
-        push_br_if(out, 1)
-        if !emit_runner_commands(body, refs, cached_by_key, cached_vars, out) {
-          return false
-        }
-        push_local_get(out, LOOP_COUNTER_LOCAL)
-        push_f64_const(out, 1.0)
-        out.push((0xa1).to_byte())
-        push_local_set(out, LOOP_COUNTER_LOCAL)
-        push_local_get(out, LOOP_GUARD_LOCAL)
-        push_i32_const(out, 1)
-        out.push((0x6b).to_byte())
-        push_local_set(out, LOOP_GUARD_LOCAL)
-        push_br(out, 0)
-        out.push((0x0b).to_byte())
-        out.push((0x0b).to_byte())
-      }
-      RepeatUntil(cond, body) => {
-        push_i32_const(out, LOOP_GUARD_MAX)
-        push_local_set(out, LOOP_GUARD_LOCAL)
-        out.push((0x02).to_byte())
-        out.push((0x40).to_byte())
-        out.push((0x03).to_byte())
-        out.push((0x40).to_byte())
-        push_local_get(out, LOOP_GUARD_LOCAL)
-        out.push((0x45).to_byte())
-        push_br_if(out, 1)
-        if !emit_runner_bool_expr(cond, refs, cached_by_key, out) {
-          return false
-        }
-        push_br_if(out, 1)
-        if !emit_runner_commands(body, refs, cached_by_key, cached_vars, out) {
-          return false
-        }
-        push_local_get(out, LOOP_GUARD_LOCAL)
-        push_i32_const(out, 1)
-        out.push((0x6b).to_byte())
-        push_local_set(out, LOOP_GUARD_LOCAL)
-        push_br(out, 0)
-        out.push((0x0b).to_byte())
-        out.push((0x0b).to_byte())
-      }
-      While(cond, body) => {
-        push_i32_const(out, LOOP_GUARD_MAX)
-        push_local_set(out, LOOP_GUARD_LOCAL)
-        out.push((0x02).to_byte())
-        out.push((0x40).to_byte())
-        out.push((0x03).to_byte())
-        out.push((0x40).to_byte())
-        push_local_get(out, LOOP_GUARD_LOCAL)
-        out.push((0x45).to_byte())
-        push_br_if(out, 1)
-        if !emit_runner_bool_expr(cond, refs, cached_by_key, out) {
-          return false
-        }
-        out.push((0x45).to_byte())
-        push_br_if(out, 1)
-        if !emit_runner_commands(body, refs, cached_by_key, cached_vars, out) {
-          return false
-        }
-        push_local_get(out, LOOP_GUARD_LOCAL)
-        push_i32_const(out, 1)
-        out.push((0x6b).to_byte())
-        push_local_set(out, LOOP_GUARD_LOCAL)
-        push_br(out, 0)
-        out.push((0x0b).to_byte())
-        out.push((0x0b).to_byte())
-      }
-      HostTail(target, start_pc) => {
-        if !emit_runner_sync_cached_vars(cached_vars, refs, out, false) {
-          return false
-        }
-        push_i32_const(out, target)
-        push_i32_const(out, start_pc)
-        push_call(out, IMPORT_EXEC_TAIL_INDEX)
-        out.push((0x1a).to_byte())
-        if !emit_runner_sync_cached_vars(cached_vars, refs, out, true) {
-          return false
-        }
-      }
-      HostOpcode(target, pc) => {
-        if !emit_runner_sync_cached_vars(cached_vars, refs, out, false) {
-          return false
-        }
-        push_i32_const(out, target)
-        push_i32_const(out, pc)
-        push_call(out, IMPORT_EXEC_OPCODE_INDEX)
-        out.push((0x1a).to_byte())
-        if !emit_runner_sync_cached_vars(cached_vars, refs, out, true) {
-          return false
-        }
-      }
-    }
-  }
-  true
-}
-
-///|
-fn append_runner_exec_locals(
-  body : Array[Byte],
-  cached_var_count : Int,
-) -> Unit {
-  if cached_var_count > 0 {
-    body.push((0x03).to_byte())
-    body.push((0x01).to_byte())
-    body.push((0x7c).to_byte())
-    body.push((0x01).to_byte())
-    body.push((0x7f).to_byte())
-    append_bytes(body, encode_u32_leb(cached_var_count))
-    body.push((0x7c).to_byte())
-  } else {
-    body.push((0x02).to_byte())
-    body.push((0x01).to_byte())
-    body.push((0x7c).to_byte())
-    body.push((0x01).to_byte())
-    body.push((0x7f).to_byte())
-  }
-}
-
-///|
-fn build_runner_exec_body(
-  commands : Array[RunnerCommand],
-  refs : Map[String, RunnerLiteralRef],
-) -> Array[Byte] {
-  let (cached_by_key, cached_vars) = build_runner_cached_vars(commands)
-  let body = []
-  append_runner_exec_locals(body, cached_vars.length())
-  if !emit_runner_sync_cached_vars(cached_vars, refs, body, true) ||
-    !emit_runner_commands(commands, refs, cached_by_key, cached_vars, body) ||
-    !emit_runner_sync_cached_vars(cached_vars, refs, body, false) {
-    push_i32_const(body, 0)
-    body.push((0x0b).to_byte())
-    return body
-  }
-  push_i32_const(body, commands.length())
-  body.push((0x0b).to_byte())
-  body
-}
-
-///|
-fn append_const_i32_function_body(
-  code_payload : Array[Byte],
-  value : Int,
-) -> Unit {
-  let body = bytes_from_ints([0x00, 0x41])
-  append_bytes(body, encode_i32_leb(value))
-  body.push((0x0b).to_byte())
-  append_bytes(code_payload, encode_u32_leb(body.length()))
-  append_bytes(code_payload, body)
-}
-
-///|
-fn build_program_wasm_binary(
-  abi_version : Int,
-  project_base64 : String,
-  assets_base64 : String,
-  commands_base64 : String,
-  runner_commands : Array[RunnerCommand],
-) -> Array[Byte] {
-  let project_bytes = encode_utf8_bytes(project_base64)
-  let assets_bytes = encode_utf8_bytes(assets_base64)
-  let commands_bytes = encode_utf8_bytes(commands_base64)
-  let project_len = project_bytes.length()
-  let assets_ptr = project_len
-  let assets_len = assets_bytes.length()
-  let commands_ptr = assets_ptr + assets_len
-  let commands_len = commands_bytes.length()
-  let runner_literal_pool_ptr = commands_ptr + commands_len
-  let (runner_literal_pool_bytes, runner_literal_pool_refs) = build_runner_literal_pool(
-    runner_commands, runner_literal_pool_ptr,
-  )
-  let total_bytes = project_len +
-    assets_len +
-    commands_len +
-    runner_literal_pool_bytes.length()
-  let memory_pages = page_count_for_bytes(total_bytes)
-  let has_exec_runner = if runner_commands.is_empty() { 0 } else { 1 }
-
-  let module_bytes = bytes_from_ints([
-    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,
-  ])
-
-  let type_payload = bytes_from_ints([
-    0x07, 0x60, 0x00, 0x01, 0x7f, 0x60, 0x03, 0x7f, 0x7f, 0x7f, 0x01, 0x7c, 0x60,
-    0x04, 0x7f, 0x7f, 0x7f, 0x7c, 0x00, 0x60, 0x05, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-    0x00, 0x60, 0x02, 0x7c, 0x7c, 0x01, 0x7c, 0x60, 0x02, 0x7f, 0x7f, 0x01, 0x7f,
-    0x60, 0x06, 0x7f, 0x7f, 0x7f, 0x7c, 0x7c, 0x7f, 0x01, 0x7f,
-  ])
-  append_bytes(module_bytes, encode_section(1, type_payload))
-
-  let import_payload = []
-  append_bytes(import_payload, encode_u32_leb(7))
-  let imports : Array[(String, String, Int)] = [
-    ("env", "ms_get_var_num", 1),
-    ("env", "ms_set_var_num", 2),
-    ("env", "ms_set_var_json", 3),
-    ("env", "ms_mod", 4),
-    ("env", "ms_exec_opcode", 5),
-    ("env", "ms_exec_tail", 5),
-    ("env", "ms_exec_draw_opcode", 6),
-  ]
-  for item in imports {
-    append_bytes(import_payload, encode_name(item.0))
-    append_bytes(import_payload, encode_name(item.1))
-    import_payload.push((0x00).to_byte())
-    append_bytes(import_payload, encode_u32_leb(item.2))
-  }
-  append_bytes(module_bytes, encode_section(2, import_payload))
-
-  let function_payload = []
-  append_bytes(function_payload, encode_u32_leb(9))
-  append_bytes(function_payload, bytes_from_ints([0, 0, 0, 0, 0, 0, 0, 0, 0]))
-  append_bytes(module_bytes, encode_section(3, function_payload))
-
-  let memory_payload = [(0x01).to_byte(), (0x00).to_byte()]
-  append_bytes(memory_payload, encode_u32_leb(memory_pages))
-  append_bytes(module_bytes, encode_section(5, memory_payload))
-
-  let exports_payload = []
-  let defined_function_base = imports.length()
-  let exports : Array[(String, Int, Int)] = [
-    ("memory", 0x02, 0),
-    ("ms_abi_version", 0x00, defined_function_base + 0),
-    ("ms_project_ptr", 0x00, defined_function_base + 1),
-    ("ms_project_len", 0x00, defined_function_base + 2),
-    ("ms_assets_ptr", 0x00, defined_function_base + 3),
-    ("ms_assets_len", 0x00, defined_function_base + 4),
-    ("ms_commands_ptr", 0x00, defined_function_base + 5),
-    ("ms_commands_len", 0x00, defined_function_base + 6),
-    ("ms_has_exec_runner", 0x00, defined_function_base + 7),
-    ("ms_exec_green_flag", 0x00, defined_function_base + 8),
-  ]
-  append_bytes(exports_payload, encode_u32_leb(exports.length()))
-  for item in exports {
-    append_bytes(exports_payload, encode_name(item.0))
-    exports_payload.push(item.1.to_byte())
-    append_bytes(exports_payload, encode_u32_leb(item.2))
-  }
-  append_bytes(module_bytes, encode_section(7, exports_payload))
-
-  let code_payload = []
-  let function_consts = [
-    abi_version, 0, project_len, assets_ptr, assets_len, commands_ptr, commands_len,
-    has_exec_runner,
-  ]
-  append_bytes(code_payload, encode_u32_leb(function_consts.length() + 1))
-  for value in function_consts {
-    append_const_i32_function_body(code_payload, value)
-  }
-  let exec_body = build_runner_exec_body(
-    runner_commands, runner_literal_pool_refs,
-  )
-  append_bytes(code_payload, encode_u32_leb(exec_body.length()))
-  append_bytes(code_payload, exec_body)
-  append_bytes(module_bytes, encode_section(10, code_payload))
-
-  let segments : Array[WasmDataSegment] = [
-    { offset: 0, bytes: project_bytes },
-    { offset: assets_ptr, bytes: assets_bytes },
-    { offset: commands_ptr, bytes: commands_bytes },
-  ]
-  if !runner_literal_pool_bytes.is_empty() {
-    segments.push({
-      offset: runner_literal_pool_ptr,
-      bytes: runner_literal_pool_bytes,
-    })
-  }
-  let data_payload = []
-  append_bytes(data_payload, encode_u32_leb(segments.length()))
-  for segment in segments {
-    data_payload.push((0x00).to_byte())
-    data_payload.push((0x41).to_byte())
-    append_bytes(data_payload, encode_i32_leb(segment.offset))
-    data_payload.push((0x0b).to_byte())
-    append_bytes(data_payload, encode_u32_leb(segment.bytes.length()))
-    append_bytes(data_payload, segment.bytes)
-  }
-  append_bytes(module_bytes, encode_section(11, data_payload))
-
-  module_bytes
-}
-
-///|
-pub fn vm_compile_project_to_wasm(
-  project_json : String,
-  assets_json? : String,
-) -> String raise VmError {
-  let bundle = parse_bundle(project_json, assets_json)
-  let (targets, _) = parse_project_targets(bundle.project_json, bundle.assets)
-  let project_base64 = base64_utf8(bundle.project_json)
-  let assets_raw = json_object(bundle.assets).stringify()
-  let assets_base64 = base64_utf8(assets_raw)
-  let commands_json = match compile_aot_commands_json(targets) {
-    Some(commands) => commands
-    None => ""
-  }
-  let commands_base64 = base64_utf8(commands_json)
-  let runner_commands = parse_runner_commands_json(commands_json)
-  let wasm_bytes = build_program_wasm_binary(
-    PROGRAM_ABI_VERSION,
-    project_base64,
-    assets_base64,
-    commands_base64,
-    runner_commands,
-  )
-  let wasm = Bytes::from_array(wasm_bytes[:])
-  @base64.encode(wasm[:])
-}