1 files changed, 45 insertions, 44 deletions

diff --git a/cli/rt/30_fs.js b/cli/rt/30_fs.js
index 163c00604..d8171bdac 100644
--- a/cli/rt/30_fs.js
+++ b/cli/rt/30_fs.js
@@ -6,11 +6,11 @@
   const build = window.__bootstrap.build.build;
 
   function chmodSync(path, mode) {
-    sendSync("op_chmod", { path: pathFromURL(path), mode });
+    sendSync("op_chmod_sync", { path: pathFromURL(path), mode });
   }
 
   async function chmod(path, mode) {
-    await sendAsync("op_chmod", { path: pathFromURL(path), mode });
+    await sendAsync("op_chmod_async", { path: pathFromURL(path), mode });
   }
 
   function chownSync(
@@ -18,7 +18,7 @@
     uid,
     gid,
   ) {
-    sendSync("op_chown", { path: pathFromURL(path), uid, gid });
+    sendSync("op_chown_sync", { path: pathFromURL(path), uid, gid });
   }
 
   async function chown(
@@ -26,14 +26,14 @@
     uid,
     gid,
   ) {
-    await sendAsync("op_chown", { path: pathFromURL(path), uid, gid });
+    await sendAsync("op_chown_async", { path: pathFromURL(path), uid, gid });
   }
 
   function copyFileSync(
     fromPath,
     toPath,
   ) {
-    sendSync("op_copy_file", {
+    sendSync("op_copy_file_sync", {
       from: pathFromURL(fromPath),
       to: pathFromURL(toPath),
     });
@@ -43,7 +43,7 @@
     fromPath,
     toPath,
   ) {
-    await sendAsync("op_copy_file", {
+    await sendAsync("op_copy_file_async", {
       from: pathFromURL(fromPath),
       to: pathFromURL(toPath),
     });
@@ -58,19 +58,19 @@
   }
 
   function makeTempDirSync(options = {}) {
-    return sendSync("op_make_temp_dir", options);
+    return sendSync("op_make_temp_dir_sync", options);
   }
 
   function makeTempDir(options = {}) {
-    return sendAsync("op_make_temp_dir", options);
+    return sendAsync("op_make_temp_dir_async", options);
   }
 
   function makeTempFileSync(options = {}) {
-    return sendSync("op_make_temp_file", options);
+    return sendSync("op_make_temp_file_sync", options);
   }
 
   function makeTempFile(options = {}) {
-    return sendAsync("op_make_temp_file", options);
+    return sendAsync("op_make_temp_file_async", options);
   }
 
   function mkdirArgs(path, options) {
@@ -87,14 +87,14 @@
   }
 
   function mkdirSync(path, options) {
-    sendSync("op_mkdir", mkdirArgs(path, options));
+    sendSync("op_mkdir_sync", mkdirArgs(path, options));
   }
 
   async function mkdir(
     path,
     options,
   ) {
-    await sendAsync("op_mkdir", mkdirArgs(path, options));
+    await sendAsync("op_mkdir_async", mkdirArgs(path, options));
   }
 
   function res(response) {
@@ -102,15 +102,16 @@
   }
 
   function readDirSync(path) {
-    return res(sendSync("op_read_dir", { path: pathFromURL(path) }))[
+    return res(sendSync("op_read_dir_sync", { path: pathFromURL(path) }))[
       Symbol.iterator
     ]();
   }
 
   function readDir(path) {
-    const array = sendAsync("op_read_dir", { path: pathFromURL(path) }).then(
-      res,
-    );
+    const array = sendAsync("op_read_dir_async", { path: pathFromURL(path) })
+      .then(
+        res,
+      );
     return {
       async *[Symbol.asyncIterator]() {
         yield* await array;
@@ -119,26 +120,26 @@
   }
 
   function readLinkSync(path) {
-    return sendSync("op_read_link", { path });
+    return sendSync("op_read_link_sync", { path });
   }
 
   function readLink(path) {
-    return sendAsync("op_read_link", { path });
+    return sendAsync("op_read_link_async", { path });
   }
 
   function realPathSync(path) {
-    return sendSync("op_realpath", { path });
+    return sendSync("op_realpath_sync", { path });
   }
 
   function realPath(path) {
-    return sendAsync("op_realpath", { path });
+    return sendAsync("op_realpath_async", { path });
   }
 
   function removeSync(
     path,
     options = {},
   ) {
-    sendSync("op_remove", {
+    sendSync("op_remove_sync", {
       path: pathFromURL(path),
       recursive: !!options.recursive,
     });
@@ -148,18 +149,18 @@
     path,
     options = {},
   ) {
-    await sendAsync("op_remove", {
+    await sendAsync("op_remove_async", {
       path: pathFromURL(path),
       recursive: !!options.recursive,
     });
   }
 
   function renameSync(oldpath, newpath) {
-    sendSync("op_rename", { oldpath, newpath });
+    sendSync("op_rename_sync", { oldpath, newpath });
   }
 
   async function rename(oldpath, newpath) {
-    await sendAsync("op_rename", { oldpath, newpath });
+    await sendAsync("op_rename_async", { oldpath, newpath });
   }
 
   function parseFileInfo(response) {
@@ -188,15 +189,15 @@
   }
 
   function fstatSync(rid) {
-    return parseFileInfo(sendSync("op_fstat", { rid }));
+    return parseFileInfo(sendSync("op_fstat_sync", { rid }));
   }
 
   async function fstat(rid) {
-    return parseFileInfo(await sendAsync("op_fstat", { rid }));
+    return parseFileInfo(await sendAsync("op_fstat_async", { rid }));
   }
 
   async function lstat(path) {
-    const res = await sendAsync("op_stat", {
+    const res = await sendAsync("op_stat_async", {
       path: pathFromURL(path),
       lstat: true,
     });
@@ -204,7 +205,7 @@
   }
 
   function lstatSync(path) {
-    const res = sendSync("op_stat", {
+    const res = sendSync("op_stat_sync", {
       path: pathFromURL(path),
       lstat: true,
     });
@@ -212,7 +213,7 @@
   }
 
   async function stat(path) {
-    const res = await sendAsync("op_stat", {
+    const res = await sendAsync("op_stat_async", {
       path: pathFromURL(path),
       lstat: false,
     });
@@ -220,7 +221,7 @@
   }
 
   function statSync(path) {
-    const res = sendSync("op_stat", {
+    const res = sendSync("op_stat_sync", {
       path: pathFromURL(path),
       lstat: false,
     });
@@ -236,19 +237,19 @@
   }
 
   function ftruncateSync(rid, len) {
-    sendSync("op_ftruncate", { rid, len: coerceLen(len) });
+    sendSync("op_ftruncate_sync", { rid, len: coerceLen(len) });
   }
 
   async function ftruncate(rid, len) {
-    await sendAsync("op_ftruncate", { rid, len: coerceLen(len) });
+    await sendAsync("op_ftruncate_async", { rid, len: coerceLen(len) });
   }
 
   function truncateSync(path, len) {
-    sendSync("op_truncate", { path, len: coerceLen(len) });
+    sendSync("op_truncate_sync", { path, len: coerceLen(len) });
   }
 
   async function truncate(path, len) {
-    await sendAsync("op_truncate", { path, len: coerceLen(len) });
+    await sendAsync("op_truncate_async", { path, len: coerceLen(len) });
   }
 
   function umask(mask) {
@@ -256,11 +257,11 @@
   }
 
   function linkSync(oldpath, newpath) {
-    sendSync("op_link", { oldpath, newpath });
+    sendSync("op_link_sync", { oldpath, newpath });
   }
 
   async function link(oldpath, newpath) {
-    await sendAsync("op_link", { oldpath, newpath });
+    await sendAsync("op_link_async", { oldpath, newpath });
   }
 
   function toSecondsFromEpoch(v) {
@@ -272,7 +273,7 @@
     atime,
     mtime,
   ) {
-    sendSync("op_utime", {
+    sendSync("op_utime_sync", {
       path,
       // TODO(ry) split atime, mtime into [seconds, nanoseconds] tuple
       atime: toSecondsFromEpoch(atime),
@@ -285,7 +286,7 @@
     atime,
     mtime,
   ) {
-    await sendAsync("op_utime", {
+    await sendAsync("op_utime_async", {
       path,
       // TODO(ry) split atime, mtime into [seconds, nanoseconds] tuple
       atime: toSecondsFromEpoch(atime),
@@ -298,7 +299,7 @@
     newpath,
     options,
   ) {
-    sendSync("op_symlink", { oldpath, newpath, options });
+    sendSync("op_symlink_sync", { oldpath, newpath, options });
   }
 
   async function symlink(
@@ -306,23 +307,23 @@
     newpath,
     options,
   ) {
-    await sendAsync("op_symlink", { oldpath, newpath, options });
+    await sendAsync("op_symlink_async", { oldpath, newpath, options });
   }
 
   function fdatasyncSync(rid) {
-    sendSync("op_fdatasync", { rid });
+    sendSync("op_fdatasync_sync", { rid });
   }
 
   async function fdatasync(rid) {
-    await sendAsync("op_fdatasync", { rid });
+    await sendAsync("op_fdatasync_async", { rid });
   }
 
   function fsyncSync(rid) {
-    sendSync("op_fsync", { rid });
+    sendSync("op_fsync_sync", { rid });
   }
 
   async function fsync(rid) {
-    await sendAsync("op_fsync", { rid });
+    await sendAsync("op_fsync_async", { rid });
   }
 
   window.__bootstrap.fs = {