11 files changed, 160 insertions, 308 deletions

diff --git a/js/dispatch.ts b/js/dispatch.ts
index b59274f91..6c7551441 100644
--- a/js/dispatch.ts
+++ b/js/dispatch.ts
@@ -23,6 +23,29 @@ export const OP_OPEN = 15;
 export const OP_CLOSE = 16;
 export const OP_SEEK = 17;
 export const OP_FETCH = 18;
+export const OP_METRICS = 19;
+export const OP_REPL_START = 20;
+export const OP_REPL_READLINE = 21;
+export const OP_ACCEPT = 22;
+export const OP_DIAL = 23;
+export const OP_SHUTDOWN = 24;
+export const OP_LISTEN = 25;
+export const OP_RESOURCES = 26;
+export const OP_GET_RANDOM_VALUES = 27;
+export const OP_GLOBAL_TIMER_STOP = 28;
+export const OP_GLOBAL_TIMER = 29;
+export const OP_NOW = 30;
+export const OP_PERMISSIONS = 31;
+export const OP_REVOKE_PERMISSION = 32;
+export const OP_CREATE_WORKER = 33;
+export const OP_HOST_GET_WORKER_CLOSED = 34;
+export const OP_HOST_POST_MESSAGE = 35;
+export const OP_HOST_GET_MESSAGE = 36;
+export const OP_WORKER_POST_MESSAGE = 37;
+export const OP_WORKER_GET_MESSAGE = 38;
+export const OP_RUN = 39;
+export const OP_RUN_STATUS = 40;
+export const OP_KILL = 41;
 
 export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void {
   switch (opId) {
@@ -41,6 +64,15 @@ export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void {
     case OP_OPEN:
     case OP_SEEK:
     case OP_FETCH:
+    case OP_REPL_START:
+    case OP_REPL_READLINE:
+    case OP_ACCEPT:
+    case OP_DIAL:
+    case OP_GLOBAL_TIMER:
+    case OP_HOST_GET_WORKER_CLOSED:
+    case OP_HOST_GET_MESSAGE:
+    case OP_WORKER_GET_MESSAGE:
+    case OP_RUN_STATUS:
       json.asyncMsgFromRust(opId, ui8);
       break;
     default:
diff --git a/js/get_random_values.ts b/js/get_random_values.ts
index d5c0828c5..154e77f75 100644
--- a/js/get_random_values.ts
+++ b/js/get_random_values.ts
@@ -1,15 +1,8 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers";
+import * as dispatch from "./dispatch";
+import { sendSync } from "./dispatch_json";
 import { assert } from "./util";
 
-function req(
-  typedArray: ArrayBufferView
-): [flatbuffers.Builder, msg.Any, flatbuffers.Offset, ArrayBufferView] {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.GetRandomValues.createGetRandomValues(builder);
-  return [builder, msg.Any.GetRandomValues, inner, typedArray];
-}
-
 /** Synchronously collects cryptographically secure random values. The
  * underlying CSPRNG in use is Rust's `rand::rngs::ThreadRng`.
  *
@@ -28,6 +21,11 @@ export function getRandomValues<
 >(typedArray: T): T {
   assert(typedArray !== null, "Input must not be null");
   assert(typedArray.length <= 65536, "Input must not be longer than 65536");
-  sendSync(...req(typedArray as ArrayBufferView));
+  const ui8 = new Uint8Array(
+    typedArray.buffer,
+    typedArray.byteOffset,
+    typedArray.byteLength
+  );
+  sendSync(dispatch.OP_GET_RANDOM_VALUES, {}, ui8);
   return typedArray;
 }
diff --git a/js/metrics.ts b/js/metrics.ts
index e93e9528c..48e3102e5 100644
--- a/js/metrics.ts
+++ b/js/metrics.ts
@@ -1,6 +1,6 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { assert } from "./util";
-import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers";
+import * as dispatch from "./dispatch";
+import { sendSync } from "./dispatch_json";
 
 export interface Metrics {
   opsDispatched: number;
@@ -10,27 +10,6 @@ export interface Metrics {
   bytesReceived: number;
 }
 
-function req(): [flatbuffers.Builder, msg.Any, flatbuffers.Offset] {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.Metrics.createMetrics(builder);
-  return [builder, msg.Any.Metrics, inner];
-}
-
-function res(baseRes: null | msg.Base): Metrics {
-  assert(baseRes !== null);
-  assert(msg.Any.MetricsRes === baseRes!.innerType());
-  const res = new msg.MetricsRes();
-  assert(baseRes!.inner(res) !== null);
-
-  return {
-    opsDispatched: res.opsDispatched().toFloat64(),
-    opsCompleted: res.opsCompleted().toFloat64(),
-    bytesSentControl: res.bytesSentControl().toFloat64(),
-    bytesSentData: res.bytesSentData().toFloat64(),
-    bytesReceived: res.bytesReceived().toFloat64()
-  };
-}
-
 /** Receive metrics from the privileged side of Deno.
  *
  *      > console.table(Deno.metrics())
@@ -45,5 +24,5 @@ function res(baseRes: null | msg.Base): Metrics {
  *      └──────────────────┴────────┘
  */
 export function metrics(): Metrics {
-  return res(sendSync(...req()));
+  return sendSync(dispatch.OP_METRICS);
 }
diff --git a/js/net.ts b/js/net.ts
index 9c3bfbba5..b478ae613 100644
--- a/js/net.ts
+++ b/js/net.ts
@@ -1,8 +1,9 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
 import { EOF, Reader, Writer, Closer } from "./io";
-import { assert, notImplemented } from "./util";
-import { sendSync, sendAsync, msg, flatbuffers } from "./dispatch_flatbuffers";
+import { notImplemented } from "./util";
 import { read, write, close } from "./files";
+import * as dispatch from "./dispatch";
+import { sendSync, sendAsync } from "./dispatch_json";
 
 export type Network = "tcp";
 // TODO support other types:
@@ -36,10 +37,7 @@ enum ShutdownMode {
 }
 
 function shutdown(rid: number, how: ShutdownMode): void {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.Shutdown.createShutdown(builder, rid, how);
-  const baseRes = sendSync(builder, msg.Any.Shutdown, inner);
-  assert(baseRes == null);
+  sendSync(dispatch.OP_SHUTDOWN, { rid, how });
 }
 
 class ConnImpl implements Conn {
@@ -80,14 +78,9 @@ class ListenerImpl implements Listener {
   constructor(readonly rid: number) {}
 
   async accept(): Promise<Conn> {
-    const builder = flatbuffers.createBuilder();
-    const inner = msg.Accept.createAccept(builder, this.rid);
-    const baseRes = await sendAsync(builder, msg.Any.Accept, inner);
-    assert(baseRes != null);
-    assert(msg.Any.NewConn === baseRes!.innerType());
-    const res = new msg.NewConn();
-    assert(baseRes!.inner(res) != null);
-    return new ConnImpl(res.rid(), res.remoteAddr()!, res.localAddr()!);
+    const res = await sendAsync(dispatch.OP_ACCEPT, { rid: this.rid });
+    // TODO(bartlomieju): add remoteAddr and localAddr on Rust side
+    return new ConnImpl(res.rid, res.remoteAddr!, res.localAddr!);
   }
 
   close(): void {
@@ -143,16 +136,8 @@ export interface Conn extends Reader, Writer, Closer {
  * See `dial()` for a description of the network and address parameters.
  */
 export function listen(network: Network, address: string): Listener {
-  const builder = flatbuffers.createBuilder();
-  const network_ = builder.createString(network);
-  const address_ = builder.createString(address);
-  const inner = msg.Listen.createListen(builder, network_, address_);
-  const baseRes = sendSync(builder, msg.Any.Listen, inner);
-  assert(baseRes != null);
-  assert(msg.Any.ListenRes === baseRes!.innerType());
-  const res = new msg.ListenRes();
-  assert(baseRes!.inner(res) != null);
-  return new ListenerImpl(res.rid());
+  const rid = sendSync(dispatch.OP_LISTEN, { network, address });
+  return new ListenerImpl(rid);
 }
 
 /** Dial connects to the address on the named network.
@@ -183,16 +168,9 @@ export function listen(network: Network, address: string): Listener {
  *     dial("tcp", ":80")
  */
 export async function dial(network: Network, address: string): Promise<Conn> {
-  const builder = flatbuffers.createBuilder();
-  const network_ = builder.createString(network);
-  const address_ = builder.createString(address);
-  const inner = msg.Dial.createDial(builder, network_, address_);
-  const baseRes = await sendAsync(builder, msg.Any.Dial, inner);
-  assert(baseRes != null);
-  assert(msg.Any.NewConn === baseRes!.innerType());
-  const res = new msg.NewConn();
-  assert(baseRes!.inner(res) != null);
-  return new ConnImpl(res.rid(), res.remoteAddr()!, res.localAddr()!);
+  const res = await sendAsync(dispatch.OP_DIAL, { network, address });
+  // TODO(bartlomieju): add remoteAddr and localAddr on Rust side
+  return new ConnImpl(res.rid, res.remoteAddr!, res.localAddr!);
 }
 
 /** **RESERVED** */
diff --git a/js/performance.ts b/js/performance.ts
index 7aaa7ae45..d2f339c46 100644
--- a/js/performance.ts
+++ b/js/performance.ts
@@ -1,6 +1,11 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers";
-import { assert } from "./util";
+import * as dispatch from "./dispatch";
+import { sendSync } from "./dispatch_json";
+
+interface NowResponse {
+  seconds: number;
+  subsecNanos: number;
+}
 
 export class Performance {
   /** Returns a current time from Deno's start in milliseconds.
@@ -11,12 +16,7 @@ export class Performance {
    *       console.log(`${t} ms since start!`);
    */
   now(): number {
-    const builder = flatbuffers.createBuilder();
-    const inner = msg.Now.createNow(builder);
-    const baseRes = sendSync(builder, msg.Any.Now, inner)!;
-    assert(msg.Any.NowRes === baseRes.innerType());
-    const res = new msg.NowRes();
-    assert(baseRes.inner(res) != null);
-    return res.seconds().toFloat64() * 1e3 + res.subsecNanos() / 1e6;
+    const res = sendSync(dispatch.OP_NOW) as NowResponse;
+    return res.seconds * 1e3 + res.subsecNanos / 1e6;
   }
 }
diff --git a/js/permissions.ts b/js/permissions.ts
index 822ae8cbd..bc969f3a8 100644
--- a/js/permissions.ts
+++ b/js/permissions.ts
@@ -1,6 +1,6 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers";
-import { assert } from "./util";
+import * as dispatch from "./dispatch";
+import { sendSync } from "./dispatch_json";
 
 /** Permissions as granted by the caller */
 export interface Permissions {
@@ -15,23 +15,6 @@ export interface Permissions {
 
 export type Permission = keyof Permissions;
 
-function getReq(): [flatbuffers.Builder, msg.Any, flatbuffers.Offset] {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.Permissions.createPermissions(builder);
-  return [builder, msg.Any.Permissions, inner];
-}
-
-function createPermissions(inner: msg.PermissionsRes): Permissions {
-  return {
-    read: inner.read(),
-    write: inner.write(),
-    net: inner.net(),
-    env: inner.env(),
-    run: inner.run(),
-    hrtime: inner.hrtime()
-  };
-}
-
 /** Inspect granted permissions for the current program.
  *
  *       if (Deno.permissions().read) {
@@ -40,24 +23,7 @@ function createPermissions(inner: msg.PermissionsRes): Permissions {
  *       }
  */
 export function permissions(): Permissions {
-  const baseRes = sendSync(...getReq())!;
-  assert(msg.Any.PermissionsRes === baseRes.innerType());
-  const res = new msg.PermissionsRes();
-  assert(baseRes.inner(res) != null);
-  // TypeScript cannot track assertion above, therefore not null assertion
-  return createPermissions(res);
-}
-
-function revokeReq(
-  permission: string
-): [flatbuffers.Builder, msg.Any, flatbuffers.Offset] {
-  const builder = flatbuffers.createBuilder();
-  const permission_ = builder.createString(permission);
-  const inner = msg.PermissionRevoke.createPermissionRevoke(
-    builder,
-    permission_
-  );
-  return [builder, msg.Any.PermissionRevoke, inner];
+  return sendSync(dispatch.OP_PERMISSIONS) as Permissions;
 }
 
 /** Revoke a permission. When the permission was already revoked nothing changes
@@ -69,5 +35,5 @@ function revokeReq(
  *       Deno.readFile("example.test"); // -> error or permission prompt
  */
 export function revokePermission(permission: Permission): void {
-  sendSync(...revokeReq(permission));
+  sendSync(dispatch.OP_REVOKE_PERMISSION, { permission });
 }
diff --git a/js/process.ts b/js/process.ts
index b2b6d4734..dd4f70103 100644
--- a/js/process.ts
+++ b/js/process.ts
@@ -1,6 +1,6 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { sendSync, sendAsync, msg, flatbuffers } from "./dispatch_flatbuffers";
-
+import { sendSync, sendAsync } from "./dispatch_json";
+import * as dispatch from "./dispatch";
 import { File, close } from "./files";
 import { ReadCloser, WriteCloser } from "./io";
 import { readAll } from "./buffer";
@@ -31,21 +31,22 @@ export interface RunOptions {
   stdin?: ProcessStdio | number;
 }
 
-async function runStatus(rid: number): Promise<ProcessStatus> {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.RunStatus.createRunStatus(builder, rid);
+interface RunStatusResponse {
+  gotSignal: boolean;
+  exitCode: number;
+  exitSignal: number;
+}
 
-  const baseRes = await sendAsync(builder, msg.Any.RunStatus, inner);
-  assert(baseRes != null);
-  assert(msg.Any.RunStatusRes === baseRes!.innerType());
-  const res = new msg.RunStatusRes();
-  assert(baseRes!.inner(res) != null);
+async function runStatus(rid: number): Promise<ProcessStatus> {
+  const res = (await sendAsync(dispatch.OP_RUN_STATUS, {
+    rid
+  })) as RunStatusResponse;
 
-  if (res.gotSignal()) {
-    const signal = res.exitSignal();
+  if (res.gotSignal) {
+    const signal = res.exitSignal;
     return { signal, success: false };
   } else {
-    const code = res.exitCode();
+    const code = res.exitCode;
     return { code, success: code === 0 };
   }
 }
@@ -56,9 +57,7 @@ async function runStatus(rid: number): Promise<ProcessStatus> {
  * Requires the `--allow-run` flag.
  */
 export function kill(pid: number, signo: number): void {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.Kill.createKill(builder, pid, signo);
-  sendSync(builder, msg.Any.Kill, inner);
+  sendSync(dispatch.OP_KILL, { pid, signo });
 }
 
 export class Process {
@@ -69,20 +68,20 @@ export class Process {
   readonly stderr?: ReadCloser;
 
   // @internal
-  constructor(res: msg.RunRes) {
-    this.rid = res.rid();
-    this.pid = res.pid();
+  constructor(res: RunResponse) {
+    this.rid = res.rid;
+    this.pid = res.pid;
 
-    if (res.stdinRid() > 0) {
-      this.stdin = new File(res.stdinRid());
+    if (res.stdinRid && res.stdinRid > 0) {
+      this.stdin = new File(res.stdinRid);
     }
 
-    if (res.stdoutRid() > 0) {
-      this.stdout = new File(res.stdoutRid());
+    if (res.stdoutRid && res.stdoutRid > 0) {
+      this.stdout = new File(res.stdoutRid);
     }
 
-    if (res.stderrRid() > 0) {
-      this.stderr = new File(res.stderrRid());
+    if (res.stderrRid && res.stderrRid > 0) {
+      this.stderr = new File(res.stderrRid);
     }
   }
 
@@ -135,14 +134,13 @@ export interface ProcessStatus {
   signal?: number; // TODO: Make this a string, e.g. 'SIGTERM'.
 }
 
-function stdioMap(s: ProcessStdio): msg.ProcessStdio {
+// TODO: this method is only used to validate proper option, probably can be renamed
+function stdioMap(s: string): string {
   switch (s) {
     case "inherit":
-      return msg.ProcessStdio.Inherit;
     case "piped":
-      return msg.ProcessStdio.Piped;
     case "null":
-      return msg.ProcessStdio.Null;
+      return s;
     default:
       return unreachable();
   }
@@ -152,6 +150,13 @@ function isRid(arg: unknown): arg is number {
   return !isNaN(arg as number);
 }
 
+interface RunResponse {
+  rid: number;
+  pid: number;
+  stdinRid: number | null;
+  stdoutRid: number | null;
+  stderrRid: number | null;
+}
 /**
  * Spawns new subprocess.
  *
@@ -166,71 +171,56 @@ function isRid(arg: unknown): arg is number {
  * they can be set to either `ProcessStdio` or `rid` of open file.
  */
 export function run(opt: RunOptions): Process {
-  const builder = flatbuffers.createBuilder();
-  const argsOffset = msg.Run.createArgsVector(
-    builder,
-    opt.args.map((a): number => builder.createString(a))
-  );
-  const cwdOffset = opt.cwd == null ? 0 : builder.createString(opt.cwd);
-  const kvOffset: flatbuffers.Offset[] = [];
+  assert(opt.args.length > 0);
+  let env: Array<[string, string]> = [];
   if (opt.env) {
-    for (const [key, val] of Object.entries(opt.env)) {
-      const keyOffset = builder.createString(key);
-      const valOffset = builder.createString(String(val));
-      kvOffset.push(msg.KeyValue.createKeyValue(builder, keyOffset, valOffset));
-    }
+    env = Array.from(Object.entries(opt.env));
   }
-  const envOffset = msg.Run.createEnvVector(builder, kvOffset);
 
-  let stdInOffset = stdioMap("inherit");
-  let stdOutOffset = stdioMap("inherit");
-  let stdErrOffset = stdioMap("inherit");
-  let stdinRidOffset = 0;
-  let stdoutRidOffset = 0;
-  let stderrRidOffset = 0;
+  let stdin = stdioMap("inherit");
+  let stdout = stdioMap("inherit");
+  let stderr = stdioMap("inherit");
+  let stdinRid = 0;
+  let stdoutRid = 0;
+  let stderrRid = 0;
 
   if (opt.stdin) {
     if (isRid(opt.stdin)) {
-      stdinRidOffset = opt.stdin;
+      stdinRid = opt.stdin;
     } else {
-      stdInOffset = stdioMap(opt.stdin);
+      stdin = stdioMap(opt.stdin);
     }
   }
 
   if (opt.stdout) {
     if (isRid(opt.stdout)) {
-      stdoutRidOffset = opt.stdout;
+      stdoutRid = opt.stdout;
     } else {
-      stdOutOffset = stdioMap(opt.stdout);
+      stdout = stdioMap(opt.stdout);
     }
   }
 
   if (opt.stderr) {
     if (isRid(opt.stderr)) {
-      stderrRidOffset = opt.stderr;
+      stderrRid = opt.stderr;
     } else {
-      stdErrOffset = stdioMap(opt.stderr);
+      stderr = stdioMap(opt.stderr);
     }
   }
 
-  const inner = msg.Run.createRun(
-    builder,
-    argsOffset,
-    cwdOffset,
-    envOffset,
-    stdInOffset,
-    stdOutOffset,
-    stdErrOffset,
-    stdinRidOffset,
-    stdoutRidOffset,
-    stderrRidOffset
-  );
-  const baseRes = sendSync(builder, msg.Any.Run, inner);
-  assert(baseRes != null);
-  assert(msg.Any.RunRes === baseRes!.innerType());
-  const res = new msg.RunRes();
-  assert(baseRes!.inner(res) != null);
+  const req = {
+    args: opt.args.map(String),
+    cwd: opt.cwd,
+    env,
+    stdin,
+    stdout,
+    stderr,
+    stdinRid,
+    stdoutRid,
+    stderrRid
+  };
 
+  const res = sendSync(dispatch.OP_RUN, req) as RunResponse;
   return new Process(res);
 }
 
diff --git a/js/repl.ts b/js/repl.ts
index c971e4420..ac6700657 100644
--- a/js/repl.ts
+++ b/js/repl.ts
@@ -1,12 +1,12 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { assert } from "./util";
 import { close } from "./files";
-import { sendSync, sendAsync, msg, flatbuffers } from "./dispatch_flatbuffers";
 import { exit } from "./os";
 import { window } from "./window";
 import { core } from "./core";
 import { formatError } from "./format_error";
 import { stringifyArgs } from "./console";
+import * as dispatch from "./dispatch";
+import { sendSync, sendAsync } from "./dispatch_json";
 
 /**
  * REPL logging.
@@ -43,34 +43,12 @@ const replCommands = {
 };
 
 function startRepl(historyFile: string): number {
-  const builder = flatbuffers.createBuilder();
-  const historyFile_ = builder.createString(historyFile);
-  const inner = msg.ReplStart.createReplStart(builder, historyFile_);
-
-  const baseRes = sendSync(builder, msg.Any.ReplStart, inner);
-  assert(baseRes != null);
-  assert(msg.Any.ReplStartRes === baseRes!.innerType());
-  const innerRes = new msg.ReplStartRes();
-  assert(baseRes!.inner(innerRes) != null);
-  const rid = innerRes.rid();
-  return rid;
+  return sendSync(dispatch.OP_REPL_START, { historyFile });
 }
 
 // @internal
 export async function readline(rid: number, prompt: string): Promise<string> {
-  const builder = flatbuffers.createBuilder();
-  const prompt_ = builder.createString(prompt);
-  const inner = msg.ReplReadline.createReplReadline(builder, rid, prompt_);
-
-  const baseRes = await sendAsync(builder, msg.Any.ReplReadline, inner);
-
-  assert(baseRes != null);
-  assert(msg.Any.ReplReadlineRes === baseRes!.innerType());
-  const innerRes = new msg.ReplReadlineRes();
-  assert(baseRes!.inner(innerRes) != null);
-  const line = innerRes.line();
-  assert(line !== null);
-  return line || "";
+  return sendAsync(dispatch.OP_REPL_READLINE, { rid, prompt });
 }
 
 // Error messages that allow users to continue input
diff --git a/js/resources.ts b/js/resources.ts
index 49093fab1..6e2ec202b 100644
--- a/js/resources.ts
+++ b/js/resources.ts
@@ -1,6 +1,6 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { assert } from "./util";
-import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers";
+import * as dispatch from "./dispatch";
+import { sendSync } from "./dispatch_json";
 
 export interface ResourceMap {
   [rid: number]: string;
@@ -10,20 +10,10 @@ export interface ResourceMap {
  * representation.
  */
 export function resources(): ResourceMap {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.Resource.createResource(builder, 0, 0);
-  const baseRes = sendSync(builder, msg.Any.Resources, inner);
-  assert(baseRes !== null);
-  assert(msg.Any.ResourcesRes === baseRes!.innerType());
-  const res = new msg.ResourcesRes();
-  assert(baseRes!.inner(res) !== null);
-
+  const res = sendSync(dispatch.OP_RESOURCES) as Array<[number, string]>;
   const resources: ResourceMap = {};
-
-  for (let i = 0; i < res.resourcesLength(); i++) {
-    const item = res.resources(i)!;
-    resources[item.rid()!] = item.repr()!;
+  for (const resourceTuple of res) {
+    resources[resourceTuple[0]] = resourceTuple[1];
   }
-
   return resources;
 }
diff --git a/js/timers.ts b/js/timers.ts
index cb0fd531c..079e779c4 100644
--- a/js/timers.ts
+++ b/js/timers.ts
@@ -1,7 +1,8 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
 import { assert } from "./util";
-import { sendAsync, sendSync, msg, flatbuffers } from "./dispatch_flatbuffers";
 import { window } from "./window";
+import * as dispatch from "./dispatch";
+import { sendSync, sendAsync } from "./dispatch_json";
 
 interface Timer {
   id: number;
@@ -37,11 +38,8 @@ function getTime(): number {
 }
 
 function clearGlobalTimeout(): void {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.GlobalTimerStop.createGlobalTimerStop(builder);
   globalTimeoutDue = null;
-  let res = sendSync(builder, msg.Any.GlobalTimerStop, inner);
-  assert(res == null);
+  sendSync(dispatch.OP_GLOBAL_TIMER_STOP);
 }
 
 async function setGlobalTimeout(due: number, now: number): Promise<void> {
@@ -52,12 +50,8 @@ async function setGlobalTimeout(due: number, now: number): Promise<void> {
   assert(timeout >= 0);
 
   // Send message to the backend.
-  const builder = flatbuffers.createBuilder();
-  msg.GlobalTimer.startGlobalTimer(builder);
-  msg.GlobalTimer.addTimeout(builder, timeout);
-  const inner = msg.GlobalTimer.endGlobalTimer(builder);
   globalTimeoutDue = due;
-  await sendAsync(builder, msg.Any.GlobalTimer, inner);
+  await sendAsync(dispatch.OP_GLOBAL_TIMER, { timeout });
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
   fireTimers();
 }
diff --git a/js/workers.ts b/js/workers.ts
index e59e853c5..7bcbe6279 100644
--- a/js/workers.ts
+++ b/js/workers.ts
@@ -1,7 +1,8 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { sendAsync, sendSync, msg, flatbuffers } from "./dispatch_flatbuffers";
-import { assert, log } from "./util";
+import * as dispatch from "./dispatch";
+import { sendAsync, sendSync } from "./dispatch_json";
+import { log } from "./util";
 import { TextDecoder, TextEncoder } from "./text_encoding";
 import { window } from "./window";
 import { blobURLMap } from "./url";
@@ -26,61 +27,28 @@ function createWorker(
   hasSourceCode: boolean,
   sourceCode: Uint8Array
 ): number {
-  const builder = flatbuffers.createBuilder();
-  const specifier_ = builder.createString(specifier);
-  const sourceCode_ = builder.createString(sourceCode);
-  const inner = msg.CreateWorker.createCreateWorker(
-    builder,
-    specifier_,
+  return sendSync(dispatch.OP_CREATE_WORKER, {
+    specifier,
     includeDenoNamespace,
     hasSourceCode,
-    sourceCode_
-  );
-  const baseRes = sendSync(builder, msg.Any.CreateWorker, inner);
-  assert(baseRes != null);
-  assert(
-    msg.Any.CreateWorkerRes === baseRes!.innerType(),
-    `base.innerType() unexpectedly is ${baseRes!.innerType()}`
-  );
-  const res = new msg.CreateWorkerRes();
-  assert(baseRes!.inner(res) != null);
-  return res.rid();
+    sourceCode: new TextDecoder().decode(sourceCode)
+  });
 }
 
 async function hostGetWorkerClosed(rid: number): Promise<void> {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.HostGetWorkerClosed.createHostGetWorkerClosed(builder, rid);
-  await sendAsync(builder, msg.Any.HostGetWorkerClosed, inner);
+  await sendAsync(dispatch.OP_HOST_GET_WORKER_CLOSED, { rid });
 }
 
 function hostPostMessage(rid: number, data: any): void {
   const dataIntArray = encodeMessage(data);
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.HostPostMessage.createHostPostMessage(builder, rid);
-  const baseRes = sendSync(
-    builder,
-    msg.Any.HostPostMessage,
-    inner,
-    dataIntArray
-  );
-  assert(baseRes != null);
+  sendSync(dispatch.OP_HOST_POST_MESSAGE, { rid }, dataIntArray);
 }
 
 async function hostGetMessage(rid: number): Promise<any> {
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.HostGetMessage.createHostGetMessage(builder, rid);
-  const baseRes = await sendAsync(builder, msg.Any.HostGetMessage, inner);
-  assert(baseRes != null);
-  assert(
-    msg.Any.HostGetMessageRes === baseRes!.innerType(),
-    `base.innerType() unexpectedly is ${baseRes!.innerType()}`
-  );
-  const res = new msg.HostGetMessageRes();
-  assert(baseRes!.inner(res) != null);
-
-  const dataArray = res.dataArray();
-  if (dataArray != null) {
-    return decodeMessage(dataArray);
+  const res = await sendAsync(dispatch.OP_HOST_GET_MESSAGE, { rid });
+
+  if (res.data != null) {
+    return decodeMessage(new Uint8Array(res.data));
   } else {
     return null;
   }
@@ -91,36 +59,15 @@ export let onmessage: (e: { data: any }) => void = (): void => {};
 
 export function postMessage(data: any): void {
   const dataIntArray = encodeMessage(data);
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.WorkerPostMessage.createWorkerPostMessage(builder);
-  const baseRes = sendSync(
-    builder,
-    msg.Any.WorkerPostMessage,
-    inner,
-    dataIntArray
-  );
-  assert(baseRes != null);
+  sendSync(dispatch.OP_WORKER_POST_MESSAGE, {}, dataIntArray);
 }
 
 export async function getMessage(): Promise<any> {
   log("getMessage");
-  const builder = flatbuffers.createBuilder();
-  const inner = msg.WorkerGetMessage.createWorkerGetMessage(
-    builder,
-    0 /* unused */
-  );
-  const baseRes = await sendAsync(builder, msg.Any.WorkerGetMessage, inner);
-  assert(baseRes != null);
-  assert(
-    msg.Any.WorkerGetMessageRes === baseRes!.innerType(),
-    `base.innerType() unexpectedly is ${baseRes!.innerType()}`
-  );
-  const res = new msg.WorkerGetMessageRes();
-  assert(baseRes!.inner(res) != null);
-
-  const dataArray = res.dataArray();
-  if (dataArray != null) {
-    return decodeMessage(dataArray);
+  const res = await sendAsync(dispatch.OP_WORKER_GET_MESSAGE);
+
+  if (res.data != null) {
+    return decodeMessage(new Uint8Array(res.data));
   } else {
     return null;
   }