xitdb 0.11.0 → 0.13.0

package/dist/index.js

@@ -1,22 +1,4 @@
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = import.meta.require;
-
 // src/tag.ts
 var Tag;
 ((Tag2) => {
@@ -261,20 +243,20 @@ class CoreMemory {
   writer() {
     return this.memory;
   }
-  async length() {
+  length() {
     return this.memory.size();
   }
-  async seek(pos) {
+  seek(pos) {
     this.memory.seek(pos);
   }
   position() {
     return this.memory.getPosition();
   }
-  async setLength(len) {
+  setLength(len) {
     this.memory.setLength(len);
   }
-  async flush() {}
-  async sync() {}
+  flush() {}
+  sync() {}
 }
 
 class RandomAccessMemory {
@@ -327,7 +309,7 @@ class RandomAccessMemory {
   toByteArray() {
     return this.buffer.slice(0, this._count);
   }
-  async write(data) {
+  write(data) {
     const pos = this._position;
     if (pos < this._count) {
       const bytesBeforeEnd = Math.min(data.length, this._count - pos);
@@ -347,22 +329,22 @@ class RandomAccessMemory {
     }
     this._position = pos + data.length;
   }
-  async writeByte(v) {
-    await this.write(new Uint8Array([v & 255]));
+  writeByte(v) {
+    this.write(new Uint8Array([v & 255]));
   }
-  async writeShort(v) {
+  writeShort(v) {
     const buffer = new ArrayBuffer(2);
     const view = new DataView(buffer);
     view.setInt16(0, v, false);
-    await this.write(new Uint8Array(buffer));
+    this.write(new Uint8Array(buffer));
   }
-  async writeLong(v) {
+  writeLong(v) {
     const buffer = new ArrayBuffer(8);
     const view = new DataView(buffer);
     view.setBigInt64(0, BigInt(v), false);
-    await this.write(new Uint8Array(buffer));
+    this.write(new Uint8Array(buffer));
   }
-  async readFully(b) {
+  readFully(b) {
     const pos = this._position;
     if (pos + b.length > this._count) {
       throw new Error("End of stream");
@@ -370,49 +352,45 @@ class RandomAccessMemory {
     b.set(this.buffer.subarray(pos, pos + b.length));
     this._position = pos + b.length;
   }
-  async readByte() {
+  readByte() {
     const bytes = new Uint8Array(1);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     return bytes[0];
   }
-  async readShort() {
+  readShort() {
     const bytes = new Uint8Array(2);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return view.getInt16(0, false);
   }
-  async readInt() {
+  readInt() {
     const bytes = new Uint8Array(4);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return view.getInt32(0, false);
   }
-  async readLong() {
+  readLong() {
     const bytes = new Uint8Array(8);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return Number(view.getBigInt64(0, false));
   }
 }
 // src/core-file.ts
-import * as fs from "fs/promises";
+import * as fs from "fs";
 
 class CoreFile {
   filePath;
   _position = 0;
-  fileHandle;
-  constructor(filePath, fileHandle) {
+  fd;
+  constructor(filePath) {
     this.filePath = filePath;
-    this.fileHandle = fileHandle;
-  }
-  static async create(filePath) {
     try {
-      await fs.access(filePath);
+      fs.accessSync(filePath);
     } catch {
-      await fs.writeFile(filePath, new Uint8Array(0));
+      fs.writeFileSync(filePath, new Uint8Array(0));
     }
-    const fileHandle = await fs.open(filePath, "r+");
-    return new CoreFile(filePath, fileHandle);
+    this.fd = fs.openSync(filePath, "r+");
   }
   reader() {
     return new FileDataReader(this);
@@ -420,27 +398,25 @@ class CoreFile {
   writer() {
     return new FileDataWriter(this);
   }
-  async length() {
-    const stats = await this.fileHandle.stat();
+  length() {
+    const stats = fs.fstatSync(this.fd);
     return stats.size;
   }
-  async seek(pos) {
+  seek(pos) {
     this._position = pos;
   }
   position() {
     return this._position;
   }
-  async setLength(len) {
-    await this.fileHandle.truncate(len);
+  setLength(len) {
+    fs.ftruncateSync(this.fd, len);
   }
-  async flush() {}
-  async sync() {
-    await this.fileHandle.sync();
+  flush() {}
+  sync() {
+    fs.fsyncSync(this.fd);
   }
   [Symbol.dispose]() {
-    import("fs").then((fs2) => {
-      fs2.closeSync(this.fileHandle.fd);
-    });
+    fs.closeSync(this.fd);
   }
 }
 
@@ -449,31 +425,31 @@ class FileDataReader {
   constructor(core) {
     this.core = core;
   }
-  async readFully(b) {
+  readFully(b) {
     const position = this.core.position();
-    await this.core.fileHandle.readv([b], position);
+    fs.readSync(this.core.fd, b, 0, b.length, position);
     this.core.seek(position + b.length);
   }
-  async readByte() {
+  readByte() {
     const bytes = new Uint8Array(1);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     return bytes[0];
   }
-  async readShort() {
+  readShort() {
     const bytes = new Uint8Array(2);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return view.getInt16(0, false);
   }
-  async readInt() {
+  readInt() {
     const bytes = new Uint8Array(4);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return view.getInt32(0, false);
   }
-  async readLong() {
+  readLong() {
     const bytes = new Uint8Array(8);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return Number(view.getBigInt64(0, false));
   }
@@ -484,36 +460,32 @@ class FileDataWriter {
   constructor(core) {
     this.core = core;
   }
-  async write(buffer) {
+  write(buffer) {
     const position = this.core.position();
-    await this.core.fileHandle.writev([buffer], position);
+    fs.writeSync(this.core.fd, buffer, 0, buffer.length, position);
     this.core.seek(position + buffer.length);
   }
-  async writeByte(v) {
-    await this.write(new Uint8Array([v & 255]));
+  writeByte(v) {
+    this.write(new Uint8Array([v & 255]));
   }
-  async writeShort(v) {
+  writeShort(v) {
     const buffer = new ArrayBuffer(2);
     const view = new DataView(buffer);
     view.setInt16(0, v, false);
-    await this.write(new Uint8Array(buffer));
+    this.write(new Uint8Array(buffer));
   }
-  async writeLong(v) {
+  writeLong(v) {
     const buffer = new ArrayBuffer(8);
     const view = new DataView(buffer);
     view.setBigInt64(0, BigInt(v), false);
-    await this.write(new Uint8Array(buffer));
+    this.write(new Uint8Array(buffer));
   }
 }
 // src/core-buffered-file.ts
 class CoreBufferedFile {
   file;
-  constructor(file) {
-    this.file = file;
-  }
-  static async create(filePath, bufferSize) {
-    const file = await RandomAccessBufferedFile.create(filePath, bufferSize);
-    return new CoreBufferedFile(file);
+  constructor(filePath, bufferSize) {
+    this.file = new RandomAccessBufferedFile(filePath, bufferSize);
   }
   reader() {
     return this.file;
@@ -521,23 +493,23 @@ class CoreBufferedFile {
   writer() {
     return this.file;
   }
-  async length() {
-    return await this.file.length();
+  length() {
+    return this.file.length();
   }
-  async seek(pos) {
-    await this.file.seek(pos);
+  seek(pos) {
+    this.file.seek(pos);
   }
   position() {
     return this.file.position();
   }
-  async setLength(len) {
-    await this.file.setLength(len);
+  setLength(len) {
+    this.file.setLength(len);
   }
-  async flush() {
-    await this.file.flush();
+  flush() {
+    this.file.flush();
   }
-  async sync() {
-    await this.file.sync();
+  sync() {
+    this.file.sync();
   }
   [Symbol.dispose]() {
     this.file.file[Symbol.dispose]();
@@ -551,139 +523,138 @@ class RandomAccessBufferedFile {
   bufferSize;
   filePos;
   memoryPos;
-  constructor(file, bufferSize) {
-    this.file = file;
+  constructor(filePath, bufferSize = DEFAULT_BUFFER_SIZE) {
+    this.file = new CoreFile(filePath);
     this.memory = new CoreMemory;
     this.bufferSize = bufferSize;
     this.filePos = 0;
     this.memoryPos = 0;
   }
-  static async create(filePath, bufferSize = DEFAULT_BUFFER_SIZE) {
-    const file = await CoreFile.create(filePath);
-    return new RandomAccessBufferedFile(file, bufferSize);
-  }
-  async seek(pos) {
-    if (pos > this.memoryPos + await this.memory.length()) {
-      await this.flush();
+  seek(pos) {
+    if (pos > this.memoryPos + this.memory.length()) {
+      this.flush();
     }
     this.filePos = pos;
-    if (await this.memory.length() === 0) {
+    if (this.memory.length() === 0) {
       this.memoryPos = pos;
     }
   }
-  async length() {
-    return Math.max(this.memoryPos + await this.memory.length(), await this.file.length());
+  length() {
+    return Math.max(this.memoryPos + this.memory.length(), this.file.length());
   }
   position() {
     return this.filePos;
   }
-  async setLength(len) {
-    await this.flush();
-    await this.file.setLength(len);
+  setLength(len) {
+    this.flush();
+    this.file.setLength(len);
     this.filePos = Math.min(len, this.filePos);
   }
-  async flush() {
-    if (await this.memory.length() > 0) {
-      await this.file.seek(this.memoryPos);
-      await this.file.writer().write(this.memory.memory.toByteArray());
+  flush() {
+    if (this.memory.length() > 0) {
+      this.file.seek(this.memoryPos);
+      this.file.writer().write(this.memory.memory.toByteArray());
       this.memoryPos = 0;
       this.memory.memory.reset();
     }
   }
-  async sync() {
-    await this.flush();
-    await this.file.sync();
+  sync() {
+    this.flush();
+    this.file.sync();
   }
-  async write(buffer) {
-    if (await this.memory.length() + buffer.length > this.bufferSize) {
-      await this.flush();
+  write(buffer) {
+    if (this.memory.length() + buffer.length > this.bufferSize) {
+      this.flush();
     }
-    if (this.filePos >= this.memoryPos && this.filePos <= this.memoryPos + await this.memory.length()) {
+    if (this.filePos >= this.memoryPos && this.filePos <= this.memoryPos + this.memory.length()) {
       this.memory.seek(this.filePos - this.memoryPos);
-      await this.memory.memory.write(buffer);
+      this.memory.memory.write(buffer);
     } else {
-      await this.file.seek(this.filePos);
-      await this.file.writer().write(buffer);
+      this.file.seek(this.filePos);
+      this.file.writer().write(buffer);
     }
     this.filePos += buffer.length;
   }
-  async writeByte(v) {
-    await this.write(new Uint8Array([v & 255]));
+  writeByte(v) {
+    this.write(new Uint8Array([v & 255]));
   }
-  async writeShort(v) {
+  writeShort(v) {
     const buffer = new ArrayBuffer(2);
     const view = new DataView(buffer);
     view.setInt16(0, v & 65535, false);
-    await this.write(new Uint8Array(buffer));
+    this.write(new Uint8Array(buffer));
   }
-  async writeLong(v) {
+  writeLong(v) {
     const buffer = new ArrayBuffer(8);
     const view = new DataView(buffer);
     view.setBigInt64(0, BigInt(v), false);
-    await this.write(new Uint8Array(buffer));
+    this.write(new Uint8Array(buffer));
   }
-  async readFully(buffer) {
+  readFully(buffer) {
     let pos = 0;
     if (this.filePos < this.memoryPos) {
       const sizeBeforeMem = Math.min(this.memoryPos - this.filePos, buffer.length);
       const tempBuffer = new Uint8Array(sizeBeforeMem);
-      await this.file.seek(this.filePos);
-      await this.file.reader().readFully(tempBuffer);
+      this.file.seek(this.filePos);
+      this.file.reader().readFully(tempBuffer);
       buffer.set(tempBuffer, pos);
       pos += sizeBeforeMem;
       this.filePos += sizeBeforeMem;
     }
     if (pos === buffer.length)
       return;
-    if (this.filePos >= this.memoryPos && this.filePos < this.memoryPos + await this.memory.length()) {
+    if (this.filePos >= this.memoryPos && this.filePos < this.memoryPos + this.memory.length()) {
       const memPos = this.filePos - this.memoryPos;
-      const sizeInMem = Math.min(await this.memory.length() - memPos, buffer.length - pos);
+      const sizeInMem = Math.min(this.memory.length() - memPos, buffer.length - pos);
       this.memory.seek(memPos);
       const memBuffer = new Uint8Array(sizeInMem);
-      await this.memory.memory.readFully(memBuffer);
+      this.memory.memory.readFully(memBuffer);
       buffer.set(memBuffer, pos);
       pos += sizeInMem;
       this.filePos += sizeInMem;
     }
     if (pos === buffer.length)
       return;
-    if (this.filePos >= this.memoryPos + await this.memory.length()) {
+    if (this.filePos >= this.memoryPos + this.memory.length()) {
       const sizeAfterMem = buffer.length - pos;
       const tempBuffer = new Uint8Array(sizeAfterMem);
-      await this.file.seek(this.filePos);
-      await this.file.reader().readFully(tempBuffer);
+      this.file.seek(this.filePos);
+      this.file.reader().readFully(tempBuffer);
       buffer.set(tempBuffer, pos);
       pos += sizeAfterMem;
       this.filePos += sizeAfterMem;
     }
   }
-  async readByte() {
+  readByte() {
     const bytes = new Uint8Array(1);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     return bytes[0];
   }
-  async readShort() {
+  readShort() {
     const bytes = new Uint8Array(2);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return view.getInt16(0, false);
   }
-  async readInt() {
+  readInt() {
     const bytes = new Uint8Array(4);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return view.getInt32(0, false);
   }
-  async readLong() {
+  readLong() {
     const bytes = new Uint8Array(8);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return Number(view.getBigInt64(0, false));
   }
 }
 // src/hasher.ts
+import { createHash } from "crypto";
+
 class Hasher {
   algorithm;
+  nodeAlgorithm;
   id;
   digestLength;
   constructor(algorithm, id = 0) {
@@ -692,26 +663,26 @@ class Hasher {
     switch (algorithm) {
       case "SHA-1":
         this.digestLength = 20;
+        this.nodeAlgorithm = "sha1";
         break;
       case "SHA-256":
         this.digestLength = 32;
+        this.nodeAlgorithm = "sha256";
         break;
       case "SHA-384":
         this.digestLength = 48;
+        this.nodeAlgorithm = "sha384";
         break;
       case "SHA-512":
         this.digestLength = 64;
+        this.nodeAlgorithm = "sha512";
         break;
       default:
         throw new Error(`Unsupported hash algorithm: ${algorithm}`);
     }
   }
-  async digest(data) {
-    const buffer = new ArrayBuffer(data.length);
-    const view = new Uint8Array(buffer);
-    view.set(data);
-    const hashBuffer = await crypto.subtle.digest(this.algorithm, buffer);
-    return new Uint8Array(hashBuffer);
+  digest(data) {
+    return new Uint8Array(createHash(this.nodeAlgorithm).update(data).digest());
   }
   static stringToId(hashIdName) {
     const bytes = new TextEncoder().encode(hashIdName);
@@ -750,9 +721,9 @@ class ReadCursor {
   slot() {
     return this.slotPtr.slot;
   }
-  async readPath(path) {
+  readPath(path) {
     try {
-      const slotPtr = await this.db.readSlotPointer(0 /* READ_ONLY */, path, 0, this.slotPtr);
+      const slotPtr = this.db.readSlotPointer(0 /* READ_ONLY */, path, 0, this.slotPtr);
       return new ReadCursor(slotPtr, this.db);
     } catch (e) {
       if (e instanceof KeyNotFoundException) {
@@ -761,9 +732,9 @@ class ReadCursor {
       throw e;
     }
   }
-  async readPathSlot(path) {
+  readPathSlot(path) {
     try {
-      const slotPtr = await this.db.readSlotPointer(0 /* READ_ONLY */, path, 0, this.slotPtr);
+      const slotPtr = this.db.readSlotPointer(0 /* READ_ONLY */, path, 0, this.slotPtr);
       if (!slotPtr.slot.empty()) {
         return slotPtr.slot;
       } else {
@@ -799,29 +770,29 @@ class ReadCursor {
     view.setBigInt64(0, this.slotPtr.slot.value, false);
     return view.getFloat64(0, false);
   }
-  async readBytes(maxSizeMaybe = null) {
-    const bytesObj = await this.readBytesObject(maxSizeMaybe);
+  readBytes(maxSizeMaybe = null) {
+    const bytesObj = this.readBytesObject(maxSizeMaybe);
     return bytesObj.value;
   }
-  async readBytesObject(maxSizeMaybe = null) {
+  readBytesObject(maxSizeMaybe = null) {
     const reader = this.db.core.reader();
     switch (this.slotPtr.slot.tag) {
       case 0 /* NONE */:
         return new Bytes(new Uint8Array(0));
       case 6 /* BYTES */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
-        const valueSize = await reader.readLong();
+        this.db.core.seek(Number(this.slotPtr.slot.value));
+        const valueSize = reader.readLong();
         if (maxSizeMaybe !== null && valueSize > maxSizeMaybe) {
           throw new StreamTooLongException;
         }
         const startPosition = this.db.core.position();
         const value = new Uint8Array(valueSize);
-        await reader.readFully(value);
+        reader.readFully(value);
         let formatTag = null;
         if (this.slotPtr.slot.full) {
-          await this.db.core.seek(startPosition + valueSize);
+          this.db.core.seek(startPosition + valueSize);
           formatTag = new Uint8Array(2);
-          await reader.readFully(formatTag);
+          reader.readFully(formatTag);
         }
         return new Bytes(value, formatTag);
       }
@@ -850,26 +821,26 @@ class ReadCursor {
         throw new UnexpectedTagException;
     }
   }
-  async readKeyValuePair() {
+  readKeyValuePair() {
     const reader = this.db.core.reader();
     if (this.slotPtr.slot.tag !== 5 /* KV_PAIR */) {
       throw new UnexpectedTagException;
     }
-    await this.db.core.seek(Number(this.slotPtr.slot.value));
+    this.db.core.seek(Number(this.slotPtr.slot.value));
     const kvPairBytes = new Uint8Array(KeyValuePair.length(this.db.header.hashSize));
-    await reader.readFully(kvPairBytes);
+    reader.readFully(kvPairBytes);
     const kvPair = KeyValuePair.fromBytes(kvPairBytes, this.db.header.hashSize);
     const hashPos = Number(this.slotPtr.slot.value);
     const keySlotPos = hashPos + this.db.header.hashSize;
     const valueSlotPos = keySlotPos + Slot.LENGTH;
     return new KeyValuePairCursor(new ReadCursor(new SlotPointer(valueSlotPos, kvPair.valueSlot), this.db), new ReadCursor(new SlotPointer(keySlotPos, kvPair.keySlot), this.db), kvPair.hash);
   }
-  async reader() {
+  reader() {
     const reader = this.db.core.reader();
     switch (this.slotPtr.slot.tag) {
       case 6 /* BYTES */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
-        const size = await reader.readLong();
+        this.db.core.seek(Number(this.slotPtr.slot.value));
+        const size = reader.readLong();
         const startPosition = this.db.core.position();
         return new Reader(this, size, startPosition, 0);
       }
@@ -892,27 +863,27 @@ class ReadCursor {
         throw new UnexpectedTagException;
     }
   }
-  async count() {
+  count() {
     const reader = this.db.core.reader();
     switch (this.slotPtr.slot.tag) {
       case 0 /* NONE */:
         return 0;
       case 2 /* ARRAY_LIST */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
+        this.db.core.seek(Number(this.slotPtr.slot.value));
         const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-        await reader.readFully(headerBytes);
+        reader.readFully(headerBytes);
         const header = ArrayListHeader.fromBytes(headerBytes);
         return header.size;
       }
       case 3 /* LINKED_ARRAY_LIST */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
+        this.db.core.seek(Number(this.slotPtr.slot.value));
         const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-        await reader.readFully(headerBytes);
+        reader.readFully(headerBytes);
         const header = LinkedArrayListHeader.fromBytes(headerBytes);
         return header.size;
       }
       case 6 /* BYTES */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
+        this.db.core.seek(Number(this.slotPtr.slot.value));
         return reader.readLong();
       }
       case 7 /* SHORT_BYTES */: {
@@ -931,25 +902,25 @@ class ReadCursor {
       }
       case 12 /* COUNTED_HASH_MAP */:
       case 13 /* COUNTED_HASH_SET */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
+        this.db.core.seek(Number(this.slotPtr.slot.value));
         return reader.readLong();
       }
       default:
         throw new UnexpectedTagException;
     }
   }
-  async* [Symbol.asyncIterator]() {
-    const iterator = await this.iterator();
-    while (await iterator.hasNext()) {
-      const next = await iterator.next();
+  *[Symbol.iterator]() {
+    const iterator = this.iterator();
+    while (iterator.hasNext()) {
+      const next = iterator.next();
       if (next !== null) {
         yield next;
       }
     }
   }
-  async iterator() {
+  iterator() {
     const iterator = new CursorIterator(this);
-    await iterator.init();
+    iterator.init();
     return iterator;
   }
 }
@@ -965,52 +936,52 @@ class Reader {
     this.startPosition = startPosition;
     this.relativePosition = relativePosition;
   }
-  async read(buffer) {
+  read(buffer) {
     if (this.size < this.relativePosition)
       throw new EndOfStreamException;
-    await this.parent.db.core.seek(this.startPosition + this.relativePosition);
+    this.parent.db.core.seek(this.startPosition + this.relativePosition);
     const readSize = Math.min(buffer.length, this.size - this.relativePosition);
     if (readSize === 0)
       return -1;
     const reader = this.parent.db.core.reader();
     const tempBuffer = new Uint8Array(readSize);
-    await reader.readFully(tempBuffer);
+    reader.readFully(tempBuffer);
     buffer.set(tempBuffer);
     this.relativePosition += readSize;
     return readSize;
   }
-  async readFully(buffer) {
+  readFully(buffer) {
     if (this.size < this.relativePosition || this.size - this.relativePosition < buffer.length) {
       throw new EndOfStreamException;
     }
-    await this.parent.db.core.seek(this.startPosition + this.relativePosition);
+    this.parent.db.core.seek(this.startPosition + this.relativePosition);
     const reader = this.parent.db.core.reader();
-    await reader.readFully(buffer);
+    reader.readFully(buffer);
     this.relativePosition += buffer.length;
   }
-  async readByte() {
+  readByte() {
     const bytes = new Uint8Array(1);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     return bytes[0];
   }
-  async readShort() {
+  readShort() {
     const readSize = 2;
     const bytes = new Uint8Array(readSize);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return view.getInt16(0, false);
   }
-  async readInt() {
+  readInt() {
     const readSize = 4;
     const bytes = new Uint8Array(readSize);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return view.getInt32(0, false);
   }
-  async readLong() {
+  readLong() {
     const readSize = 8;
     const bytes = new Uint8Array(readSize);
-    await this.readFully(bytes);
+    this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return Number(view.getBigInt64(0, false));
   }
@@ -1042,7 +1013,7 @@ class CursorIterator {
   constructor(cursor) {
     this.cursor = cursor;
   }
-  async init() {
+  init() {
     switch (this.cursor.slotPtr.slot.tag) {
       case 0 /* NONE */:
         this.size = 0;
@@ -1051,49 +1022,49 @@ class CursorIterator {
         break;
       case 2 /* ARRAY_LIST */: {
         const position = Number(this.cursor.slotPtr.slot.value);
-        await this.cursor.db.core.seek(position);
+        this.cursor.db.core.seek(position);
         const reader = this.cursor.db.core.reader();
         const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-        await reader.readFully(headerBytes);
+        reader.readFully(headerBytes);
         const header = ArrayListHeader.fromBytes(headerBytes);
-        this.size = await this.cursor.count();
+        this.size = this.cursor.count();
         this.index = 0;
-        this.stack = await this.initStack(this.cursor, header.ptr, INDEX_BLOCK_SIZE);
+        this.stack = this.initStack(this.cursor, header.ptr, INDEX_BLOCK_SIZE);
         break;
       }
       case 3 /* LINKED_ARRAY_LIST */: {
         const position = Number(this.cursor.slotPtr.slot.value);
-        await this.cursor.db.core.seek(position);
+        this.cursor.db.core.seek(position);
         const reader = this.cursor.db.core.reader();
         const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-        await reader.readFully(headerBytes);
+        reader.readFully(headerBytes);
         const header = LinkedArrayListHeader.fromBytes(headerBytes);
-        this.size = await this.cursor.count();
+        this.size = this.cursor.count();
         this.index = 0;
-        this.stack = await this.initStack(this.cursor, header.ptr, LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
+        this.stack = this.initStack(this.cursor, header.ptr, LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
         break;
       }
       case 4 /* HASH_MAP */:
       case 11 /* HASH_SET */:
         this.size = 0;
         this.index = 0;
-        this.stack = await this.initStack(this.cursor, Number(this.cursor.slotPtr.slot.value), INDEX_BLOCK_SIZE);
+        this.stack = this.initStack(this.cursor, Number(this.cursor.slotPtr.slot.value), INDEX_BLOCK_SIZE);
         break;
       case 12 /* COUNTED_HASH_MAP */:
       case 13 /* COUNTED_HASH_SET */:
         this.size = 0;
         this.index = 0;
-        this.stack = await this.initStack(this.cursor, Number(this.cursor.slotPtr.slot.value) + 8, INDEX_BLOCK_SIZE);
+        this.stack = this.initStack(this.cursor, Number(this.cursor.slotPtr.slot.value) + 8, INDEX_BLOCK_SIZE);
         break;
       default:
         throw new UnexpectedTagException;
     }
   }
-  async initStack(cursor, position, blockSize) {
-    await cursor.db.core.seek(position);
+  initStack(cursor, position, blockSize) {
+    cursor.db.core.seek(position);
     const reader = cursor.db.core.reader();
     const indexBlockBytes = new Uint8Array(blockSize);
-    await reader.readFully(indexBlockBytes);
+    reader.readFully(indexBlockBytes);
     const indexBlock = new Array(SLOT_COUNT);
     const slotSize = blockSize / SLOT_COUNT;
     for (let i = 0;i < SLOT_COUNT; i++) {
@@ -1102,7 +1073,7 @@ class CursorIterator {
     }
     return [new IteratorLevel(position, indexBlock, 0)];
   }
-  async hasNext() {
+  hasNext() {
     switch (this.cursor.slotPtr.slot.tag) {
       case 0 /* NONE */:
         return false;
@@ -1115,24 +1086,24 @@ class CursorIterator {
       case 12 /* COUNTED_HASH_MAP */:
       case 13 /* COUNTED_HASH_SET */:
         if (this.nextCursorMaybe === null) {
-          this.nextCursorMaybe = await this.nextInternal(INDEX_BLOCK_SIZE);
+          this.nextCursorMaybe = this.nextInternal(INDEX_BLOCK_SIZE);
         }
         return this.nextCursorMaybe !== null;
       default:
         return false;
     }
   }
-  async next() {
+  next() {
     switch (this.cursor.slotPtr.slot.tag) {
       case 0 /* NONE */:
         return null;
       case 2 /* ARRAY_LIST */:
-        if (!await this.hasNext())
+        if (!this.hasNext())
           return null;
         this.index += 1;
         return this.nextInternal(INDEX_BLOCK_SIZE);
       case 3 /* LINKED_ARRAY_LIST */:
-        if (!await this.hasNext())
+        if (!this.hasNext())
           return null;
         this.index += 1;
         return this.nextInternal(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
@@ -1151,7 +1122,7 @@ class CursorIterator {
         throw new UnexpectedTagException;
     }
   }
-  async nextInternal(blockSize) {
+  nextInternal(blockSize) {
     while (this.stack.length > 0) {
       const level = this.stack[this.stack.length - 1];
       if (level.index === level.block.length) {
@@ -1164,10 +1135,10 @@ class CursorIterator {
         const nextSlot = level.block[level.index];
         if (nextSlot.tag === 1 /* INDEX */) {
           const nextPos = Number(nextSlot.value);
-          await this.cursor.db.core.seek(nextPos);
+          this.cursor.db.core.seek(nextPos);
           const reader = this.cursor.db.core.reader();
           const indexBlockBytes = new Uint8Array(blockSize);
-          await reader.readFully(indexBlockBytes);
+          reader.readFully(indexBlockBytes);
           const indexBlock = new Array(SLOT_COUNT);
           const slotSize = blockSize / SLOT_COUNT;
           for (let i = 0;i < SLOT_COUNT; i++) {
@@ -1206,46 +1177,46 @@ class WriteCursor extends ReadCursor {
   constructor(slotPtr, db) {
     super(slotPtr, db);
   }
-  async writePath(path) {
-    const slotPtr = await this.db.readSlotPointer(1 /* READ_WRITE */, path, 0, this.slotPtr);
+  writePath(path) {
+    const slotPtr = this.db.readSlotPointer(1 /* READ_WRITE */, path, 0, this.slotPtr);
     if (this.db.txStart === null) {
-      await this.db.core.sync();
+      this.db.core.sync();
     }
     return new WriteCursor(slotPtr, this.db);
   }
-  async write(data) {
-    const cursor = await this.writePath([new WriteData(data)]);
+  write(data) {
+    const cursor = this.writePath([new WriteData(data)]);
     this.slotPtr = cursor.slotPtr;
   }
-  async writeIfEmpty(data) {
+  writeIfEmpty(data) {
     if (this.slotPtr.slot.empty()) {
-      await this.write(data);
+      this.write(data);
     }
   }
-  async readKeyValuePair() {
-    const kvPairCursor = await super.readKeyValuePair();
+  readKeyValuePair() {
+    const kvPairCursor = super.readKeyValuePair();
     return new WriteKeyValuePairCursor(new WriteCursor(kvPairCursor.valueCursor.slotPtr, this.db), new WriteCursor(kvPairCursor.keyCursor.slotPtr, this.db), kvPairCursor.hash);
   }
-  async writer() {
+  writer() {
     const writer = this.db.core.writer();
-    const ptrPos = await this.db.core.length();
-    await this.db.core.seek(ptrPos);
-    await writer.writeLong(0);
-    const startPosition = await this.db.core.length();
+    const ptrPos = this.db.core.length();
+    this.db.core.seek(ptrPos);
+    writer.writeLong(0);
+    const startPosition = this.db.core.length();
     return new Writer(this, 0, new Slot(ptrPos, 6 /* BYTES */), startPosition, 0);
   }
-  async* [Symbol.asyncIterator]() {
-    const iterator = await this.iterator();
-    while (await iterator.hasNext()) {
-      const next = await iterator.next();
+  *[Symbol.iterator]() {
+    const iterator = this.iterator();
+    while (iterator.hasNext()) {
+      const next = iterator.next();
       if (next !== null) {
         yield next;
       }
     }
   }
-  async iterator() {
+  iterator() {
     const iterator = new WriteCursorIterator(this);
-    await iterator.init();
+    iterator.init();
     return iterator;
   }
 }
@@ -1264,34 +1235,34 @@ class Writer {
     this.startPosition = startPosition;
     this.relativePosition = relativePosition;
   }
-  async write(buffer) {
+  write(buffer) {
     if (this.size < this.relativePosition)
       throw new EndOfStreamException;
-    await this.parent.db.core.seek(this.startPosition + this.relativePosition);
+    this.parent.db.core.seek(this.startPosition + this.relativePosition);
     const writer = this.parent.db.core.writer();
-    await writer.write(buffer);
+    writer.write(buffer);
     this.relativePosition += buffer.length;
     if (this.relativePosition > this.size) {
       this.size = this.relativePosition;
     }
   }
-  async finish() {
+  finish() {
     const writer = this.parent.db.core.writer();
     if (this.formatTag !== null) {
       this.slot = this.slot.withFull(true);
-      const formatTagPos = await this.parent.db.core.length();
-      await this.parent.db.core.seek(formatTagPos);
+      const formatTagPos = this.parent.db.core.length();
+      this.parent.db.core.seek(formatTagPos);
       if (this.startPosition + this.size !== formatTagPos)
         throw new UnexpectedWriterPositionException;
-      await writer.write(this.formatTag);
+      writer.write(this.formatTag);
     }
-    await this.parent.db.core.seek(Number(this.slot.value));
-    await writer.writeLong(this.size);
+    this.parent.db.core.seek(Number(this.slot.value));
+    writer.writeLong(this.size);
     if (this.parent.slotPtr.position === null)
       throw new CursorNotWriteableException;
     const position = this.parent.slotPtr.position;
-    await this.parent.db.core.seek(position);
-    await writer.write(this.slot.toBytes());
+    this.parent.db.core.seek(position);
+    writer.write(this.slot.toBytes());
     this.parent.slotPtr = this.parent.slotPtr.withSlot(this.slot);
   }
   seek(position) {
@@ -1305,8 +1276,8 @@ class WriteCursorIterator extends CursorIterator {
   constructor(cursor) {
     super(cursor);
   }
-  async next() {
-    const readCursor = await super.next();
+  next() {
+    const readCursor = super.next();
     if (readCursor !== null) {
       return new WriteCursor(readCursor.slotPtr, readCursor.db);
     } else {
@@ -1356,20 +1327,20 @@ class Header {
     view.setInt32(8, this.hashId, false);
     return arr;
   }
-  static async read(core) {
+  static read(core) {
     const reader = core.reader();
     const magicNumber = new Uint8Array(3);
-    await reader.readFully(magicNumber);
-    const tagByte = await reader.readByte();
+    reader.readFully(magicNumber);
+    const tagByte = reader.readByte();
     const tag = tagValueOf(tagByte & 127);
-    const version = await reader.readShort();
-    const hashSize = await reader.readShort();
-    const hashId = await reader.readInt();
+    const version = reader.readShort();
+    const hashSize = reader.readShort();
+    const hashId = reader.readInt();
     return new Header(hashId, hashSize, version, tag, magicNumber);
   }
-  async write(core) {
+  write(core) {
     const writer = core.writer();
-    await writer.write(this.toBytes());
+    writer.write(this.toBytes());
   }
   validate() {
     if (!arraysEqual(this.magicNumber, MAGIC_NUMBER)) {
@@ -1569,19 +1540,19 @@ class HashMapGetValue {
 
 class ArrayListInit {
   kind = "ArrayListInit";
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (isTopLevel) {
       const writer = db.core.writer();
       if (db.header.tag === 0 /* NONE */) {
-        await db.core.seek(Header.LENGTH);
+        db.core.seek(Header.LENGTH);
         const arrayListPtr = Header.LENGTH + TopLevelArrayListHeader.LENGTH;
-        await writer.write(new TopLevelArrayListHeader(0, new ArrayListHeader(arrayListPtr, 0)).toBytes());
-        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-        await db.core.seek(0);
+        writer.write(new TopLevelArrayListHeader(0, new ArrayListHeader(arrayListPtr, 0)).toBytes());
+        writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+        db.core.seek(0);
         db.header = db.header.withTag(2 /* ARRAY_LIST */);
-        await writer.write(db.header.toBytes());
+        writer.write(db.header.toBytes());
       }
       const nextSlotPtr = slotPtr.withSlot(slotPtr.slot.withTag(2 /* ARRAY_LIST */));
       return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
@@ -1592,14 +1563,14 @@ class ArrayListInit {
     switch (slotPtr.slot.tag) {
       case 0 /* NONE */: {
         const writer = db.core.writer();
-        let arrayListStart = await db.core.length();
-        await db.core.seek(arrayListStart);
+        let arrayListStart = db.core.length();
+        db.core.seek(arrayListStart);
         const arrayListPtr = arrayListStart + ArrayListHeader.LENGTH;
-        await writer.write(new ArrayListHeader(arrayListPtr, 0).toBytes());
-        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+        writer.write(new ArrayListHeader(arrayListPtr, 0).toBytes());
+        writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
         const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 2 /* ARRAY_LIST */));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
+        db.core.seek(position);
+        writer.write(nextSlotPtr.slot.toBytes());
         return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
       }
       case 2 /* ARRAY_LIST */: {
@@ -1608,26 +1579,26 @@ class ArrayListInit {
         let arrayListStart = Number(slotPtr.slot.value);
         if (db.txStart !== null) {
           if (arrayListStart < db.txStart) {
-            await db.core.seek(arrayListStart);
+            db.core.seek(arrayListStart);
             const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-            await reader.readFully(headerBytes);
+            reader.readFully(headerBytes);
             const header = ArrayListHeader.fromBytes(headerBytes);
-            await db.core.seek(header.ptr);
+            db.core.seek(header.ptr);
             const arrayListIndexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-            await reader.readFully(arrayListIndexBlock);
-            arrayListStart = await db.core.length();
-            await db.core.seek(arrayListStart);
+            reader.readFully(arrayListIndexBlock);
+            arrayListStart = db.core.length();
+            db.core.seek(arrayListStart);
             const nextArrayListPtr = arrayListStart + ArrayListHeader.LENGTH;
             const newHeader = header.withPtr(nextArrayListPtr);
-            await writer.write(newHeader.toBytes());
-            await writer.write(arrayListIndexBlock);
+            writer.write(newHeader.toBytes());
+            writer.write(arrayListIndexBlock);
           }
         } else if (db.header.tag === 2 /* ARRAY_LIST */) {
           throw new ExpectedTxStartException;
         }
         const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 2 /* ARRAY_LIST */));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
+        db.core.seek(position);
+        writer.write(nextSlotPtr.slot.toBytes());
         return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
       }
       default:
@@ -1642,7 +1613,7 @@ class ArrayListGet2 {
   constructor(index) {
     this.index = index;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     const tag = isTopLevel ? db.header.tag : slotPtr.slot.tag;
     switch (tag) {
       case 0 /* NONE */:
@@ -1654,10 +1625,10 @@ class ArrayListGet2 {
     }
     const nextArrayListStart = Number(slotPtr.slot.value);
     let index = this.index;
-    await db.core.seek(nextArrayListStart);
+    db.core.seek(nextArrayListStart);
     const reader = db.core.reader();
     const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
+    reader.readFully(headerBytes);
     const header = ArrayListHeader.fromBytes(headerBytes);
     if (index >= header.size || index < -header.size) {
       throw new KeyNotFoundException;
@@ -1665,14 +1636,14 @@ class ArrayListGet2 {
     const key = index < 0 ? header.size - Math.abs(index) : index;
     const lastKey = header.size - 1;
     const shift = lastKey < SLOT_COUNT ? 0 : Math.floor(Math.log(lastKey) / Math.log(SLOT_COUNT));
-    const finalSlotPtr = await db.readArrayListSlot(header.ptr, key, shift, writeMode, isTopLevel);
+    const finalSlotPtr = db.readArrayListSlot(header.ptr, key, shift, writeMode, isTopLevel);
     return db.readSlotPointer(writeMode, path, pathI + 1, finalSlotPtr);
   }
 }
 
 class ArrayListAppend {
   kind = "ArrayListAppend";
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     const tag = isTopLevel ? db.header.tag : slotPtr.slot.tag;
@@ -1680,22 +1651,22 @@ class ArrayListAppend {
       throw new UnexpectedTagException;
     const reader = db.core.reader();
     const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
+    db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
+    reader.readFully(headerBytes);
     const origHeader = ArrayListHeader.fromBytes(headerBytes);
-    const appendResult = await db.readArrayListSlotAppend(origHeader, writeMode, isTopLevel);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, appendResult.slotPtr);
+    const appendResult = db.readArrayListSlotAppend(origHeader, writeMode, isTopLevel);
+    const finalSlotPtr = db.readSlotPointer(writeMode, path, pathI + 1, appendResult.slotPtr);
     const writer = db.core.writer();
     if (isTopLevel) {
-      await db.core.flush();
-      const fileSize = await db.core.length();
+      db.core.flush();
+      const fileSize = db.core.length();
       const header = new TopLevelArrayListHeader(fileSize, appendResult.header);
-      await db.core.seek(nextArrayListStart);
-      await writer.write(header.toBytes());
+      db.core.seek(nextArrayListStart);
+      writer.write(header.toBytes());
     } else {
-      await db.core.seek(nextArrayListStart);
-      await writer.write(appendResult.header.toBytes());
+      db.core.seek(nextArrayListStart);
+      writer.write(appendResult.header.toBytes());
     }
     return finalSlotPtr;
   }
@@ -1707,29 +1678,29 @@ class ArrayListSlice {
   constructor(size) {
     this.size = size;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (slotPtr.slot.tag !== 2 /* ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
     const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
+    db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
+    reader.readFully(headerBytes);
     const origHeader = ArrayListHeader.fromBytes(headerBytes);
-    const sliceHeader = await db.readArrayListSlice(origHeader, this.size);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
+    const sliceHeader = db.readArrayListSlice(origHeader, this.size);
+    const finalSlotPtr = db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
     const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(sliceHeader.toBytes());
+    db.core.seek(nextArrayListStart);
+    writer.write(sliceHeader.toBytes());
     return finalSlotPtr;
   }
 }
 
 class LinkedArrayListInit {
   kind = "LinkedArrayListInit";
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (isTopLevel)
@@ -1740,14 +1711,14 @@ class LinkedArrayListInit {
     switch (slotPtr.slot.tag) {
       case 0 /* NONE */: {
         const writer = db.core.writer();
-        const arrayListStart = await db.core.length();
-        await db.core.seek(arrayListStart);
+        const arrayListStart = db.core.length();
+        db.core.seek(arrayListStart);
         const arrayListPtr = arrayListStart + LinkedArrayListHeader.LENGTH;
-        await writer.write(new LinkedArrayListHeader(0, arrayListPtr, 0).toBytes());
-        await writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
+        writer.write(new LinkedArrayListHeader(0, arrayListPtr, 0).toBytes());
+        writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
         const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 3 /* LINKED_ARRAY_LIST */));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
+        db.core.seek(position);
+        writer.write(nextSlotPtr.slot.toBytes());
         return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
       }
       case 3 /* LINKED_ARRAY_LIST */: {
@@ -1756,26 +1727,26 @@ class LinkedArrayListInit {
         let arrayListStart = Number(slotPtr.slot.value);
         if (db.txStart !== null) {
           if (arrayListStart < db.txStart) {
-            await db.core.seek(arrayListStart);
+            db.core.seek(arrayListStart);
             const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-            await reader.readFully(headerBytes);
+            reader.readFully(headerBytes);
             const header = LinkedArrayListHeader.fromBytes(headerBytes);
-            await db.core.seek(header.ptr);
+            db.core.seek(header.ptr);
             const arrayListIndexBlock = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-            await reader.readFully(arrayListIndexBlock);
-            arrayListStart = await db.core.length();
-            await db.core.seek(arrayListStart);
+            reader.readFully(arrayListIndexBlock);
+            arrayListStart = db.core.length();
+            db.core.seek(arrayListStart);
             const nextArrayListPtr = arrayListStart + LinkedArrayListHeader.LENGTH;
             const newHeader = header.withPtr(nextArrayListPtr);
-            await writer.write(newHeader.toBytes());
-            await writer.write(arrayListIndexBlock);
+            writer.write(newHeader.toBytes());
+            writer.write(arrayListIndexBlock);
           }
         } else if (db.header.tag === 2 /* ARRAY_LIST */) {
           throw new ExpectedTxStartException;
         }
         const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 3 /* LINKED_ARRAY_LIST */));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
+        db.core.seek(position);
+        writer.write(nextSlotPtr.slot.toBytes());
         return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
       }
       default:
@@ -1790,7 +1761,7 @@ class LinkedArrayListGet {
   constructor(index) {
     this.index = index;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     switch (slotPtr.slot.tag) {
       case 0 /* NONE */:
         throw new KeyNotFoundException;
@@ -1800,38 +1771,38 @@ class LinkedArrayListGet {
         throw new UnexpectedTagException;
     }
     let index = this.index;
-    await db.core.seek(Number(slotPtr.slot.value));
+    db.core.seek(Number(slotPtr.slot.value));
     const reader = db.core.reader();
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
+    reader.readFully(headerBytes);
     const header = LinkedArrayListHeader.fromBytes(headerBytes);
     if (index >= header.size || index < -header.size) {
       throw new KeyNotFoundException;
     }
     const key = index < 0 ? header.size - Math.abs(index) : index;
-    const finalSlotPtr = await db.readLinkedArrayListSlot(header.ptr, key, header.shift, writeMode, isTopLevel);
+    const finalSlotPtr = db.readLinkedArrayListSlot(header.ptr, key, header.shift, writeMode, isTopLevel);
     return db.readSlotPointer(writeMode, path, pathI + 1, finalSlotPtr.slotPtr);
   }
 }
 
 class LinkedArrayListAppend {
   kind = "LinkedArrayListAppend";
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
     const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
+    db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
+    reader.readFully(headerBytes);
     const origHeader = LinkedArrayListHeader.fromBytes(headerBytes);
-    const appendResult = await db.readLinkedArrayListSlotAppend(origHeader, writeMode, isTopLevel);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, appendResult.slotPtr.slotPtr);
+    const appendResult = db.readLinkedArrayListSlotAppend(origHeader, writeMode, isTopLevel);
+    const finalSlotPtr = db.readSlotPointer(writeMode, path, pathI + 1, appendResult.slotPtr.slotPtr);
     const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(appendResult.header.toBytes());
+    db.core.seek(nextArrayListStart);
+    writer.write(appendResult.header.toBytes());
     return finalSlotPtr;
   }
 }
@@ -1844,22 +1815,22 @@ class LinkedArrayListSlice {
     this.offset = offset;
     this.size = size;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
     const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
+    db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
+    reader.readFully(headerBytes);
     const origHeader = LinkedArrayListHeader.fromBytes(headerBytes);
-    const sliceHeader = await db.readLinkedArrayListSlice(origHeader, this.offset, this.size);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
+    const sliceHeader = db.readLinkedArrayListSlice(origHeader, this.offset, this.size);
+    const finalSlotPtr = db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
     const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(sliceHeader.toBytes());
+    db.core.seek(nextArrayListStart);
+    writer.write(sliceHeader.toBytes());
     return finalSlotPtr;
   }
 }
@@ -1870,7 +1841,7 @@ class LinkedArrayListConcat {
   constructor(list) {
     this.list = list;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
@@ -1879,19 +1850,19 @@ class LinkedArrayListConcat {
       throw new UnexpectedTagException;
     const reader = db.core.reader();
     const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
+    db.core.seek(nextArrayListStart);
     const headerBytesA = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytesA);
+    reader.readFully(headerBytesA);
     const headerA = LinkedArrayListHeader.fromBytes(headerBytesA);
-    await db.core.seek(Number(this.list.value));
+    db.core.seek(Number(this.list.value));
     const headerBytesB = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytesB);
+    reader.readFully(headerBytesB);
     const headerB = LinkedArrayListHeader.fromBytes(headerBytesB);
-    const concatHeader = await db.readLinkedArrayListConcat(headerA, headerB);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
+    const concatHeader = db.readLinkedArrayListConcat(headerA, headerB);
+    const finalSlotPtr = db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
     const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(concatHeader.toBytes());
+    db.core.seek(nextArrayListStart);
+    writer.write(concatHeader.toBytes());
     return finalSlotPtr;
   }
 }
@@ -1902,31 +1873,31 @@ class LinkedArrayListInsert {
   constructor(index) {
     this.index = index;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
     const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
+    db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
+    reader.readFully(headerBytes);
     const origHeader = LinkedArrayListHeader.fromBytes(headerBytes);
     let index = this.index;
     if (index >= origHeader.size || index < -origHeader.size) {
       throw new KeyNotFoundException;
     }
     const key = index < 0 ? origHeader.size - Math.abs(index) : index;
-    const headerA = await db.readLinkedArrayListSlice(origHeader, 0, key);
-    const headerB = await db.readLinkedArrayListSlice(origHeader, key, origHeader.size - key);
-    const appendResult = await db.readLinkedArrayListSlotAppend(headerA, writeMode, isTopLevel);
-    const concatHeader = await db.readLinkedArrayListConcat(appendResult.header, headerB);
-    const nextSlotPtr = await db.readLinkedArrayListSlot(concatHeader.ptr, key, concatHeader.shift, 0 /* READ_ONLY */, isTopLevel);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr.slotPtr);
+    const headerA = db.readLinkedArrayListSlice(origHeader, 0, key);
+    const headerB = db.readLinkedArrayListSlice(origHeader, key, origHeader.size - key);
+    const appendResult = db.readLinkedArrayListSlotAppend(headerA, writeMode, isTopLevel);
+    const concatHeader = db.readLinkedArrayListConcat(appendResult.header, headerB);
+    const nextSlotPtr = db.readLinkedArrayListSlot(concatHeader.ptr, key, concatHeader.shift, 0 /* READ_ONLY */, isTopLevel);
+    const finalSlotPtr = db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr.slotPtr);
     const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(concatHeader.toBytes());
+    db.core.seek(nextArrayListStart);
+    writer.write(concatHeader.toBytes());
     return finalSlotPtr;
   }
 }
@@ -1937,30 +1908,30 @@ class LinkedArrayListRemove {
   constructor(index) {
     this.index = index;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
     const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
+    db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
+    reader.readFully(headerBytes);
     const origHeader = LinkedArrayListHeader.fromBytes(headerBytes);
     let index = this.index;
     if (index >= origHeader.size || index < -origHeader.size) {
       throw new KeyNotFoundException;
     }
     const key = index < 0 ? origHeader.size - Math.abs(index) : index;
-    const headerA = await db.readLinkedArrayListSlice(origHeader, 0, key);
-    const headerB = await db.readLinkedArrayListSlice(origHeader, key + 1, origHeader.size - (key + 1));
-    const concatHeader = await db.readLinkedArrayListConcat(headerA, headerB);
+    const headerA = db.readLinkedArrayListSlice(origHeader, 0, key);
+    const headerB = db.readLinkedArrayListSlice(origHeader, key + 1, origHeader.size - (key + 1));
+    const concatHeader = db.readLinkedArrayListConcat(headerA, headerB);
     const nextSlotPtr = new SlotPointer(concatHeader.ptr, new Slot(nextArrayListStart, 3 /* LINKED_ARRAY_LIST */));
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
+    const finalSlotPtr = db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
     const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(concatHeader.toBytes());
+    db.core.seek(nextArrayListStart);
+    writer.write(concatHeader.toBytes());
     return finalSlotPtr;
   }
 }
@@ -1973,21 +1944,21 @@ class HashMapInit {
     this.counted = counted;
     this.set = set;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     const tag = this.counted ? this.set ? 13 /* COUNTED_HASH_SET */ : 12 /* COUNTED_HASH_MAP */ : this.set ? 11 /* HASH_SET */ : 4 /* HASH_MAP */;
     if (isTopLevel) {
       const writer = db.core.writer();
       if (db.header.tag === 0 /* NONE */) {
-        await db.core.seek(Header.LENGTH);
+        db.core.seek(Header.LENGTH);
         if (this.counted) {
-          await writer.writeLong(0);
+          writer.writeLong(0);
         }
-        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-        await db.core.seek(0);
+        writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+        db.core.seek(0);
         db.header = db.header.withTag(tag);
-        await writer.write(db.header.toBytes());
+        writer.write(db.header.toBytes());
       }
       const nextSlotPtr = slotPtr.withSlot(slotPtr.slot.withTag(tag));
       return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
@@ -1998,15 +1969,15 @@ class HashMapInit {
     switch (slotPtr.slot.tag) {
       case 0 /* NONE */: {
         const writer = db.core.writer();
-        const mapStart = await db.core.length();
-        await db.core.seek(mapStart);
+        const mapStart = db.core.length();
+        db.core.seek(mapStart);
         if (this.counted) {
-          await writer.writeLong(0);
+          writer.writeLong(0);
         }
-        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+        writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
         const nextSlotPtr = new SlotPointer(position, new Slot(mapStart, tag));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
+        db.core.seek(position);
+        writer.write(nextSlotPtr.slot.toBytes());
         return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
       }
       case 4 /* HASH_MAP */:
@@ -2035,26 +2006,26 @@ class HashMapInit {
         let mapStart = Number(slotPtr.slot.value);
         if (db.txStart !== null) {
           if (mapStart < db.txStart) {
-            await db.core.seek(mapStart);
+            db.core.seek(mapStart);
             let mapCountMaybe = null;
             if (this.counted) {
-              mapCountMaybe = await reader.readLong();
+              mapCountMaybe = reader.readLong();
             }
             const mapIndexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-            await reader.readFully(mapIndexBlock);
-            mapStart = await db.core.length();
-            await db.core.seek(mapStart);
+            reader.readFully(mapIndexBlock);
+            mapStart = db.core.length();
+            db.core.seek(mapStart);
             if (mapCountMaybe !== null) {
-              await writer.writeLong(mapCountMaybe);
+              writer.writeLong(mapCountMaybe);
             }
-            await writer.write(mapIndexBlock);
+            writer.write(mapIndexBlock);
           }
         } else if (db.header.tag === 2 /* ARRAY_LIST */) {
           throw new ExpectedTxStartException;
         }
         const nextSlotPtr = new SlotPointer(position, new Slot(mapStart, tag));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
+        db.core.seek(position);
+        writer.write(nextSlotPtr.slot.toBytes());
         return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
       }
       default:
@@ -2069,7 +2040,7 @@ class HashMapGet {
   constructor(target) {
     this.target = target;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     let counted = false;
     switch (slotPtr.slot.tag) {
       case 0 /* NONE */:
@@ -2086,14 +2057,14 @@ class HashMapGet {
     }
     const indexPos = counted ? Number(slotPtr.slot.value) + 8 : Number(slotPtr.slot.value);
     const hash = db.checkHash(this.target);
-    const res = await db.readMapSlot(indexPos, hash, 0, writeMode, isTopLevel, this.target);
+    const res = db.readMapSlot(indexPos, hash, 0, writeMode, isTopLevel, this.target);
     if (writeMode === 1 /* READ_WRITE */ && counted && res.isEmpty) {
       const reader = db.core.reader();
       const writer = db.core.writer();
-      await db.core.seek(Number(slotPtr.slot.value));
-      const mapCount = await reader.readLong();
-      await db.core.seek(Number(slotPtr.slot.value));
-      await writer.writeLong(mapCount + 1);
+      db.core.seek(Number(slotPtr.slot.value));
+      const mapCount = reader.readLong();
+      db.core.seek(Number(slotPtr.slot.value));
+      writer.writeLong(mapCount + 1);
     }
     return db.readSlotPointer(writeMode, path, pathI + 1, res.slotPtr);
   }
@@ -2105,7 +2076,7 @@ class HashMapRemove {
   constructor(hash) {
     this.hash = hash;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     let counted = false;
@@ -2126,7 +2097,7 @@ class HashMapRemove {
     const hash = db.checkHashBytes(this.hash);
     let keyFound = true;
     try {
-      await db.removeMapSlot(indexPos, hash, 0, isTopLevel);
+      db.removeMapSlot(indexPos, hash, 0, isTopLevel);
     } catch (e) {
       if (e instanceof KeyNotFoundException) {
         keyFound = false;
@@ -2137,10 +2108,10 @@ class HashMapRemove {
     if (writeMode === 1 /* READ_WRITE */ && counted && keyFound) {
       const reader = db.core.reader();
       const writer = db.core.writer();
-      await db.core.seek(Number(slotPtr.slot.value));
-      const mapCount = await reader.readLong();
-      await db.core.seek(Number(slotPtr.slot.value));
-      await writer.writeLong(mapCount - 1);
+      db.core.seek(Number(slotPtr.slot.value));
+      const mapCount = reader.readLong();
+      db.core.seek(Number(slotPtr.slot.value));
+      writer.writeLong(mapCount - 1);
     }
     if (!keyFound)
       throw new KeyNotFoundException;
@@ -2154,7 +2125,7 @@ class WriteData {
   constructor(data) {
     this.data = data;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (slotPtr.position === null)
@@ -2189,10 +2160,10 @@ class WriteData {
         slot = new Slot(longValue, 7 /* SHORT_BYTES */, data.formatTag !== null);
       } else {
         const nextCursor = new WriteCursor(slotPtr, db);
-        const cursorWriter = await nextCursor.writer();
+        const cursorWriter = nextCursor.writer();
         cursorWriter.formatTag = data.formatTag;
-        await cursorWriter.write(data.value);
-        await cursorWriter.finish();
+        cursorWriter.write(data.value);
+        cursorWriter.finish();
         slot = cursorWriter.slot;
       }
     } else {
@@ -2201,8 +2172,8 @@ class WriteData {
     if (slot.tag === 0 /* NONE */) {
       slot = slot.withFull(true);
     }
-    await db.core.seek(position);
-    await writer.write(slot.toBytes());
+    db.core.seek(position);
+    writer.write(slot.toBytes());
     const nextSlotPtr = new SlotPointer(slotPtr.position, slot);
     return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
   }
@@ -2214,17 +2185,17 @@ class Context {
   constructor(fn) {
     this.fn = fn;
   }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
+  readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
     if (writeMode === 0 /* READ_ONLY */)
       throw new WriteNotAllowedException;
     if (pathI !== path.length - 1)
       throw new PathPartMustBeAtEndException;
     const nextCursor = new WriteCursor(slotPtr, db);
     try {
-      await this.fn(nextCursor);
+      this.fn(nextCursor);
     } catch (e) {
       try {
-        await db.truncate();
+        db.truncate();
       } catch (_) {}
       throw e;
     }
@@ -2289,88 +2260,88 @@ class Database3 {
   constructor(core, hasher) {
     this.core = core;
     this.hasher = hasher;
-  }
-  static async create(core, hasher) {
-    const db = new Database3(core, hasher);
-    await core.seek(0);
-    if (await core.length() === 0) {
-      db.header = new Header(hasher.id, hasher.digestLength, VERSION, 0 /* NONE */, MAGIC_NUMBER);
-      await db.header.write(core);
-      await core.flush();
+    core.seek(0);
+    if (core.length() === 0) {
+      this.header = new Header(hasher.id, hasher.digestLength, VERSION, 0 /* NONE */, MAGIC_NUMBER);
+      this.header.write(core);
+      core.flush();
     } else {
-      db.header = await Header.read(core);
-      db.header.validate();
-      if (db.header.hashSize !== hasher.digestLength) {
+      this.header = Header.read(core);
+      this.header.validate();
+      if (this.header.hashSize !== hasher.digestLength) {
         throw new InvalidHashSizeException;
       }
-      await db.truncate();
+      this.truncate();
     }
-    return db;
   }
   rootCursor() {
+    if (this.header.tag === 0 /* NONE */) {
+      this.core.seek(0);
+      this.header = Header.read(this.core);
+    }
     return new WriteCursor(new SlotPointer(null, new Slot(Header.LENGTH, this.header.tag)), this);
   }
-  async freeze() {
+  freeze() {
     if (this.txStart !== null) {
-      this.txStart = await this.core.length();
+      this.txStart = this.core.length();
     } else {
       throw new ExpectedTxStartException;
     }
   }
-  async compact(targetCore) {
+  compact(targetCore) {
     const offsetMap = new Map;
     const hasher = new Hasher(this.hasher.algorithm, this.header.hashId);
-    const target = await Database3.create(targetCore, hasher);
+    const target = new Database3(targetCore, hasher);
     if (this.header.tag === 0 /* NONE */)
       return target;
     if (this.header.tag !== 2 /* ARRAY_LIST */)
       throw new UnexpectedTagException;
-    await this.core.seek(Header.LENGTH);
+    this.core.seek(Header.LENGTH);
     const sourceReader = this.core.reader();
     const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-    await sourceReader.readFully(headerBytes);
+    sourceReader.readFully(headerBytes);
     const sourceHeader = ArrayListHeader.fromBytes(headerBytes);
     if (sourceHeader.size === 0)
       return target;
     const lastKey = sourceHeader.size - 1;
     const shift = lastKey < SLOT_COUNT ? 0 : Math.floor(Math.log(lastKey) / Math.log(SLOT_COUNT));
-    const lastSlotPtr = await this.readArrayListSlot(sourceHeader.ptr, lastKey, shift, 0 /* READ_ONLY */, true);
+    const lastSlotPtr = this.readArrayListSlot(sourceHeader.ptr, lastKey, shift, 0 /* READ_ONLY */, true);
     const momentSlot = lastSlotPtr.slot;
     const targetWriter = targetCore.writer();
-    await targetCore.seek(Header.LENGTH);
+    targetCore.seek(Header.LENGTH);
     const targetArrayListPtr = Header.LENGTH + TopLevelArrayListHeader.LENGTH;
-    await targetWriter.write(new TopLevelArrayListHeader(0, new ArrayListHeader(targetArrayListPtr, 1)).toBytes());
-    await targetWriter.write(new Uint8Array(INDEX_BLOCK_SIZE));
-    const remappedMoment = await remapSlot(this.core, targetCore, this.header.hashSize, offsetMap, momentSlot);
-    await targetCore.seek(targetArrayListPtr);
-    await targetWriter.write(remappedMoment.toBytes());
+    targetWriter.write(new TopLevelArrayListHeader(0, new ArrayListHeader(targetArrayListPtr, 1)).toBytes());
+    targetWriter.write(new Uint8Array(INDEX_BLOCK_SIZE));
+    const remappedMoment = remapSlot(this.core, targetCore, this.header.hashSize, offsetMap, momentSlot);
+    targetCore.seek(targetArrayListPtr);
+    targetWriter.write(remappedMoment.toBytes());
     target.header = target.header.withTag(2 /* ARRAY_LIST */);
-    await targetCore.seek(0);
-    await target.header.write(targetCore);
-    await targetCore.flush();
-    const fileSize = await targetCore.length();
-    await targetCore.seek(Header.LENGTH + ArrayListHeader.LENGTH);
-    await targetWriter.writeLong(fileSize);
-    await targetCore.flush();
+    targetCore.seek(0);
+    target.header.write(targetCore);
+    targetCore.flush();
+    const fileSize = targetCore.length();
+    targetCore.seek(Header.LENGTH + ArrayListHeader.LENGTH);
+    targetWriter.writeLong(fileSize);
+    targetCore.flush();
     return target;
   }
-  async truncate() {
+  truncate() {
     if (this.header.tag !== 2 /* ARRAY_LIST */)
       return;
     const rootCursor = this.rootCursor();
-    const listSize = await rootCursor.count();
+    const listSize = rootCursor.count();
     if (listSize === 0)
       return;
-    await this.core.seek(Header.LENGTH + ArrayListHeader.LENGTH);
+    this.core.seek(Header.LENGTH + ArrayListHeader.LENGTH);
     const reader = this.core.reader();
-    const headerFileSize = await reader.readLong();
+    const headerFileSize = reader.readLong();
     if (headerFileSize === 0)
       return;
-    const fileSize = await this.core.length();
+    const fileSize = this.core.length();
     if (fileSize === headerFileSize)
       return;
     try {
-      await this.core.setLength(headerFileSize);
+      this.core.setLength(headerFileSize);
     } catch (_) {}
   }
   checkHashBytes(hash) {
@@ -2382,7 +2353,7 @@ class Database3 {
   checkHash(target) {
     return this.checkHashBytes(target.hash);
   }
-  async readSlotPointer(writeMode, path, pathI, slotPtr) {
+  readSlotPointer(writeMode, path, pathI, slotPtr) {
     if (pathI === path.length) {
       if (writeMode === 0 /* READ_ONLY */ && slotPtr.slot.tag === 0 /* NONE */) {
         throw new KeyNotFoundException;
@@ -2393,17 +2364,17 @@ class Database3 {
     const isTopLevel = slotPtr.slot.value === BigInt(Header.LENGTH);
     const isTxStart = isTopLevel && this.header.tag === 2 /* ARRAY_LIST */ && this.txStart === null;
     if (isTxStart) {
-      this.txStart = await this.core.length();
+      this.txStart = this.core.length();
     }
     try {
-      return await part.readSlotPointer(this, isTopLevel, writeMode, path, pathI, slotPtr);
+      return part.readSlotPointer(this, isTopLevel, writeMode, path, pathI, slotPtr);
     } finally {
       if (isTxStart) {
         this.txStart = null;
       }
     }
   }
-  async readMapSlot(indexPos, keyHash, keyOffset, writeMode, isTopLevel, target) {
+  readMapSlot(indexPos, keyHash, keyOffset, writeMode, isTopLevel, target) {
     if (keyOffset > this.header.hashSize * 8 / BIT_COUNT) {
       throw new KeyOffsetExceededException;
     }
@@ -2411,9 +2382,9 @@ class Database3 {
     const writer = this.core.writer();
     const i = Number(bigIntShiftRight(keyHash, keyOffset * BIT_COUNT) & MASK);
     const slotPos = indexPos + Slot.LENGTH * i;
-    await this.core.seek(slotPos);
+    this.core.seek(slotPos);
     const slotBytes = new Uint8Array(Slot.LENGTH);
-    await reader.readFully(slotBytes);
+    reader.readFully(slotBytes);
     const slot = Slot.fromBytes(slotBytes);
     const ptr = Number(slot.value);
     switch (slot.tag) {
@@ -2422,15 +2393,15 @@ class Database3 {
           case 0 /* READ_ONLY */:
             throw new KeyNotFoundException;
           case 1 /* READ_WRITE */: {
-            const hashPos = await this.core.length();
-            await this.core.seek(hashPos);
+            const hashPos = this.core.length();
+            this.core.seek(hashPos);
             const keySlotPos = hashPos + this.header.hashSize;
             const valueSlotPos = keySlotPos + Slot.LENGTH;
             const kvPair = new KeyValuePair(new Slot, new Slot, keyHash);
-            await writer.write(kvPair.toBytes());
+            writer.write(kvPair.toBytes());
             const nextSlot = new Slot(hashPos, 5 /* KV_PAIR */);
-            await this.core.seek(slotPos);
-            await writer.write(nextSlot.toBytes());
+            this.core.seek(slotPos);
+            writer.write(nextSlot.toBytes());
             let nextSlotPtr;
             if (target.kind === "kv_pair") {
               nextSlotPtr = new SlotPointer(slotPos, nextSlot);
@@ -2450,14 +2421,14 @@ class Database3 {
         if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
           if (this.txStart !== null) {
             if (nextPtr < this.txStart) {
-              await this.core.seek(ptr);
+              this.core.seek(ptr);
               const indexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-              await reader.readFully(indexBlock);
-              nextPtr = await this.core.length();
-              await this.core.seek(nextPtr);
-              await writer.write(indexBlock);
-              await this.core.seek(slotPos);
-              await writer.write(new Slot(nextPtr, 1 /* INDEX */).toBytes());
+              reader.readFully(indexBlock);
+              nextPtr = this.core.length();
+              this.core.seek(nextPtr);
+              writer.write(indexBlock);
+              this.core.seek(slotPos);
+              writer.write(new Slot(nextPtr, 1 /* INDEX */).toBytes());
             }
           } else if (this.header.tag === 2 /* ARRAY_LIST */) {
             throw new ExpectedTxStartException;
@@ -2466,22 +2437,22 @@ class Database3 {
         return this.readMapSlot(nextPtr, keyHash, keyOffset + 1, writeMode, isTopLevel, target);
       }
       case 5 /* KV_PAIR */: {
-        await this.core.seek(ptr);
+        this.core.seek(ptr);
         const kvPairBytes = new Uint8Array(KeyValuePair.length(this.header.hashSize));
-        await reader.readFully(kvPairBytes);
+        reader.readFully(kvPairBytes);
         const kvPair = KeyValuePair.fromBytes(kvPairBytes, this.header.hashSize);
         if (arraysEqual(kvPair.hash, keyHash)) {
           if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
             if (this.txStart !== null) {
               if (ptr < this.txStart) {
-                const hashPos = await this.core.length();
-                await this.core.seek(hashPos);
+                const hashPos = this.core.length();
+                this.core.seek(hashPos);
                 const keySlotPos2 = hashPos + this.header.hashSize;
                 const valueSlotPos2 = keySlotPos2 + Slot.LENGTH;
-                await writer.write(kvPair.toBytes());
+                writer.write(kvPair.toBytes());
                 const nextSlot = new Slot(hashPos, 5 /* KV_PAIR */);
-                await this.core.seek(slotPos);
-                await writer.write(nextSlot.toBytes());
+                this.core.seek(slotPos);
+                writer.write(nextSlot.toBytes());
                 let nextSlotPtr2;
                 if (target.kind === "kv_pair") {
                   nextSlotPtr2 = new SlotPointer(slotPos, nextSlot);
@@ -2516,14 +2487,14 @@ class Database3 {
                 throw new KeyOffsetExceededException;
               }
               const nextI = Number(bigIntShiftRight(kvPair.hash, (keyOffset + 1) * BIT_COUNT) & MASK);
-              const nextIndexPos = await this.core.length();
-              await this.core.seek(nextIndexPos);
-              await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-              await this.core.seek(nextIndexPos + Slot.LENGTH * nextI);
-              await writer.write(slot.toBytes());
-              const res = await this.readMapSlot(nextIndexPos, keyHash, keyOffset + 1, writeMode, isTopLevel, target);
-              await this.core.seek(slotPos);
-              await writer.write(new Slot(nextIndexPos, 1 /* INDEX */).toBytes());
+              const nextIndexPos = this.core.length();
+              this.core.seek(nextIndexPos);
+              writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+              this.core.seek(nextIndexPos + Slot.LENGTH * nextI);
+              writer.write(slot.toBytes());
+              const res = this.readMapSlot(nextIndexPos, keyHash, keyOffset + 1, writeMode, isTopLevel, target);
+              this.core.seek(slotPos);
+              writer.write(new Slot(nextIndexPos, 1 /* INDEX */).toBytes());
               return res;
             }
             default:
@@ -2535,16 +2506,16 @@ class Database3 {
         throw new UnexpectedTagException;
     }
   }
-  async removeMapSlot(indexPos, keyHash, keyOffset, isTopLevel) {
+  removeMapSlot(indexPos, keyHash, keyOffset, isTopLevel) {
     if (keyOffset > this.header.hashSize * 8 / BIT_COUNT) {
       throw new KeyOffsetExceededException;
     }
     const reader = this.core.reader();
     const writer = this.core.writer();
     const slotBlock = new Array(SLOT_COUNT);
-    await this.core.seek(indexPos);
+    this.core.seek(indexPos);
     const indexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-    await reader.readFully(indexBlock);
+    reader.readFully(indexBlock);
     for (let i2 = 0;i2 < SLOT_COUNT; i2++) {
       const slotBytes = indexBlock.slice(i2 * Slot.LENGTH, (i2 + 1) * Slot.LENGTH);
       slotBlock[i2] = Slot.fromBytes(slotBytes);
@@ -2557,12 +2528,12 @@ class Database3 {
       case 0 /* NONE */:
         throw new KeyNotFoundException;
       case 1 /* INDEX */:
-        nextSlot = await this.removeMapSlot(Number(slot.value), keyHash, keyOffset + 1, isTopLevel);
+        nextSlot = this.removeMapSlot(Number(slot.value), keyHash, keyOffset + 1, isTopLevel);
         break;
       case 5 /* KV_PAIR */: {
-        await this.core.seek(Number(slot.value));
+        this.core.seek(Number(slot.value));
         const kvPairBytes = new Uint8Array(KeyValuePair.length(this.header.hashSize));
-        await reader.readFully(kvPairBytes);
+        reader.readFully(kvPairBytes);
         const kvPair = KeyValuePair.fromBytes(kvPairBytes, this.header.hashSize);
         if (arraysEqual(kvPair.hash, keyHash)) {
           nextSlot = new Slot;
@@ -2575,8 +2546,8 @@ class Database3 {
         throw new UnexpectedTagException;
     }
     if (keyOffset === 0) {
-      await this.core.seek(slotPos);
-      await writer.write(nextSlot.toBytes());
+      this.core.seek(slotPos);
+      writer.write(nextSlot.toBytes());
       return new Slot(indexPos, 1 /* INDEX */);
     }
     let slotToReturnMaybe = new Slot;
@@ -2604,48 +2575,48 @@ class Database3 {
     if (!isTopLevel) {
       if (this.txStart !== null) {
         if (indexPos < this.txStart) {
-          const nextIndexPos = await this.core.length();
-          await this.core.seek(nextIndexPos);
-          await writer.write(indexBlock);
+          const nextIndexPos = this.core.length();
+          this.core.seek(nextIndexPos);
+          writer.write(indexBlock);
           const nextSlotPos = nextIndexPos + Slot.LENGTH * i;
-          await this.core.seek(nextSlotPos);
-          await writer.write(nextSlot.toBytes());
+          this.core.seek(nextSlotPos);
+          writer.write(nextSlot.toBytes());
           return new Slot(nextIndexPos, 1 /* INDEX */);
         }
       } else if (this.header.tag === 2 /* ARRAY_LIST */) {
         throw new ExpectedTxStartException;
       }
     }
-    await this.core.seek(slotPos);
-    await writer.write(nextSlot.toBytes());
+    this.core.seek(slotPos);
+    writer.write(nextSlot.toBytes());
     return new Slot(indexPos, 1 /* INDEX */);
   }
-  async readArrayListSlotAppend(header, writeMode, isTopLevel) {
+  readArrayListSlotAppend(header, writeMode, isTopLevel) {
     const writer = this.core.writer();
     let indexPos = header.ptr;
     const key = header.size;
     const prevShift = key < SLOT_COUNT ? 0 : Math.floor(Math.log(key - 1) / Math.log(SLOT_COUNT));
     const nextShift = key < SLOT_COUNT ? 0 : Math.floor(Math.log(key) / Math.log(SLOT_COUNT));
     if (prevShift !== nextShift) {
-      const nextIndexPos = await this.core.length();
-      await this.core.seek(nextIndexPos);
-      await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-      await this.core.seek(nextIndexPos);
-      await writer.write(new Slot(indexPos, 1 /* INDEX */).toBytes());
+      const nextIndexPos = this.core.length();
+      this.core.seek(nextIndexPos);
+      writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+      this.core.seek(nextIndexPos);
+      writer.write(new Slot(indexPos, 1 /* INDEX */).toBytes());
       indexPos = nextIndexPos;
     }
-    const slotPtr = await this.readArrayListSlot(indexPos, key, nextShift, writeMode, isTopLevel);
+    const slotPtr = this.readArrayListSlot(indexPos, key, nextShift, writeMode, isTopLevel);
     return new ArrayListAppendResult(new ArrayListHeader(indexPos, header.size + 1), slotPtr);
   }
-  async readArrayListSlot(indexPos, key, shift, writeMode, isTopLevel) {
+  readArrayListSlot(indexPos, key, shift, writeMode, isTopLevel) {
     if (shift >= MAX_BRANCH_LENGTH)
       throw new MaxShiftExceededException;
     const reader = this.core.reader();
     const i = key >>> shift * BIT_COUNT & SLOT_COUNT - 1;
     const slotPos = indexPos + Slot.LENGTH * i;
-    await this.core.seek(slotPos);
+    this.core.seek(slotPos);
     const slotBytes = new Uint8Array(Slot.LENGTH);
-    await reader.readFully(slotBytes);
+    reader.readFully(slotBytes);
     const slot = Slot.fromBytes(slotBytes);
     if (shift === 0) {
       return new SlotPointer(slotPos, slot);
@@ -2658,16 +2629,16 @@ class Database3 {
             throw new KeyNotFoundException;
           case 1 /* READ_WRITE */: {
             const writer = this.core.writer();
-            const nextIndexPos = await this.core.length();
-            await this.core.seek(nextIndexPos);
-            await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+            const nextIndexPos = this.core.length();
+            this.core.seek(nextIndexPos);
+            writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
             if (isTopLevel) {
-              const fileSize = await this.core.length();
-              await this.core.seek(Header.LENGTH + ArrayListHeader.LENGTH);
-              await writer.writeLong(fileSize);
+              const fileSize = this.core.length();
+              this.core.seek(Header.LENGTH + ArrayListHeader.LENGTH);
+              writer.writeLong(fileSize);
             }
-            await this.core.seek(slotPos);
-            await writer.write(new Slot(nextIndexPos, 1 /* INDEX */).toBytes());
+            this.core.seek(slotPos);
+            writer.write(new Slot(nextIndexPos, 1 /* INDEX */).toBytes());
             return this.readArrayListSlot(nextIndexPos, key, shift - 1, writeMode, isTopLevel);
           }
           default:
@@ -2679,15 +2650,15 @@ class Database3 {
         if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
           if (this.txStart !== null) {
             if (nextPtr < this.txStart) {
-              await this.core.seek(ptr);
+              this.core.seek(ptr);
               const indexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-              await reader.readFully(indexBlock);
+              reader.readFully(indexBlock);
               const writer = this.core.writer();
-              nextPtr = await this.core.length();
-              await this.core.seek(nextPtr);
-              await writer.write(indexBlock);
-              await this.core.seek(slotPos);
-              await writer.write(new Slot(nextPtr, 1 /* INDEX */).toBytes());
+              nextPtr = this.core.length();
+              this.core.seek(nextPtr);
+              writer.write(indexBlock);
+              this.core.seek(slotPos);
+              writer.write(new Slot(nextPtr, 1 /* INDEX */).toBytes());
             }
           } else if (this.header.tag === 2 /* ARRAY_LIST */) {
             throw new ExpectedTxStartException;
@@ -2699,7 +2670,7 @@ class Database3 {
         throw new UnexpectedTagException;
     }
   }
-  async readArrayListSlice(header, size) {
+  readArrayListSlice(header, size) {
     const reader = this.core.reader();
     if (size > header.size || size < 0) {
       throw new KeyNotFoundException;
@@ -2712,9 +2683,9 @@ class Database3 {
       let shift = prevShift;
       let indexPos = header.ptr;
       while (shift > nextShift) {
-        await this.core.seek(indexPos);
+        this.core.seek(indexPos);
         const slotBytes = new Uint8Array(Slot.LENGTH);
-        await reader.readFully(slotBytes);
+        reader.readFully(slotBytes);
         const slot = Slot.fromBytes(slotBytes);
         shift -= 1;
         indexPos = Number(slot.value);
@@ -2722,24 +2693,24 @@ class Database3 {
       return new ArrayListHeader(indexPos, size);
     }
   }
-  async readLinkedArrayListSlotAppend(header, writeMode, isTopLevel) {
+  readLinkedArrayListSlotAppend(header, writeMode, isTopLevel) {
     const writer = this.core.writer();
     let ptr = header.ptr;
     const key = header.size;
     let shift = header.shift;
     let slotPtr;
     try {
-      slotPtr = await this.readLinkedArrayListSlot(ptr, key, shift, writeMode, isTopLevel);
+      slotPtr = this.readLinkedArrayListSlot(ptr, key, shift, writeMode, isTopLevel);
     } catch (e) {
       if (e instanceof NoAvailableSlotsException) {
-        const nextPtr = await this.core.length();
-        await this.core.seek(nextPtr);
-        await writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
-        await this.core.seek(nextPtr);
-        await writer.write(new LinkedArrayListSlot2(header.size, new Slot(ptr, 1 /* INDEX */, true)).toBytes());
+        const nextPtr = this.core.length();
+        this.core.seek(nextPtr);
+        writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
+        this.core.seek(nextPtr);
+        writer.write(new LinkedArrayListSlot2(header.size, new Slot(ptr, 1 /* INDEX */, true)).toBytes());
         ptr = nextPtr;
         shift += 1;
-        slotPtr = await this.readLinkedArrayListSlot(ptr, key, shift, writeMode, isTopLevel);
+        slotPtr = this.readLinkedArrayListSlot(ptr, key, shift, writeMode, isTopLevel);
       } else {
         throw e;
       }
@@ -2749,8 +2720,8 @@ class Database3 {
     if (slotPtr.slotPtr.position === null)
       throw new CursorNotWriteableException;
     const position = slotPtr.slotPtr.position;
-    await this.core.seek(position);
-    await writer.write(new LinkedArrayListSlot2(0, newSlot).toBytes());
+    this.core.seek(position);
+    writer.write(new LinkedArrayListSlot2(0, newSlot).toBytes());
     if (header.size < SLOT_COUNT && shift > 0) {
       throw new MustSetNewSlotsToFullException;
     }
@@ -2810,15 +2781,15 @@ class Database3 {
     }
     return { key: nextKey, index: i };
   }
-  async readLinkedArrayListSlot(indexPos, key, shift, writeMode, isTopLevel) {
+  readLinkedArrayListSlot(indexPos, key, shift, writeMode, isTopLevel) {
     if (shift >= MAX_BRANCH_LENGTH)
       throw new MaxShiftExceededException;
     const reader = this.core.reader();
     const writer = this.core.writer();
     const slotBlock = new Array(SLOT_COUNT);
-    await this.core.seek(indexPos);
+    this.core.seek(indexPos);
     const indexBlock = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-    await reader.readFully(indexBlock);
+    reader.readFully(indexBlock);
     for (let i2 = 0;i2 < SLOT_COUNT; i2++) {
       const slotBytes = indexBlock.slice(i2 * LinkedArrayListSlot2.LENGTH, (i2 + 1) * LinkedArrayListSlot2.LENGTH);
       slotBlock[i2] = LinkedArrayListSlot2.fromBytes(slotBytes);
@@ -2841,14 +2812,14 @@ class Database3 {
           case 0 /* READ_ONLY */:
             throw new KeyNotFoundException;
           case 1 /* READ_WRITE */: {
-            const nextIndexPos = await this.core.length();
-            await this.core.seek(nextIndexPos);
-            await writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
-            const nextSlotPtr = await this.readLinkedArrayListSlot(nextIndexPos, nextKey, shift - 1, writeMode, isTopLevel);
+            const nextIndexPos = this.core.length();
+            this.core.seek(nextIndexPos);
+            writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
+            const nextSlotPtr = this.readLinkedArrayListSlot(nextIndexPos, nextKey, shift - 1, writeMode, isTopLevel);
             slotBlock[i] = slotBlock[i].withSize(nextSlotPtr.leafCount);
             const leafCount = Database3.blockLeafCount(slotBlock, shift, i);
-            await this.core.seek(slotPos);
-            await writer.write(new LinkedArrayListSlot2(nextSlotPtr.leafCount, new Slot(nextIndexPos, 1 /* INDEX */)).toBytes());
+            this.core.seek(slotPos);
+            writer.write(new LinkedArrayListSlot2(nextSlotPtr.leafCount, new Slot(nextIndexPos, 1 /* INDEX */)).toBytes());
             return new LinkedArrayListSlotPointer(nextSlotPtr.slotPtr, leafCount);
           }
           default:
@@ -2860,23 +2831,23 @@ class Database3 {
         if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
           if (this.txStart !== null) {
             if (nextPtr < this.txStart) {
-              await this.core.seek(ptr);
+              this.core.seek(ptr);
               const indexBlockCopy = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-              await reader.readFully(indexBlockCopy);
-              nextPtr = await this.core.length();
-              await this.core.seek(nextPtr);
-              await writer.write(indexBlockCopy);
+              reader.readFully(indexBlockCopy);
+              nextPtr = this.core.length();
+              this.core.seek(nextPtr);
+              writer.write(indexBlockCopy);
             }
           } else if (this.header.tag === 2 /* ARRAY_LIST */) {
             throw new ExpectedTxStartException;
           }
         }
-        const nextSlotPtr = await this.readLinkedArrayListSlot(nextPtr, nextKey, shift - 1, writeMode, isTopLevel);
+        const nextSlotPtr = this.readLinkedArrayListSlot(nextPtr, nextKey, shift - 1, writeMode, isTopLevel);
         slotBlock[i] = slotBlock[i].withSize(nextSlotPtr.leafCount);
         const leafCount = Database3.blockLeafCount(slotBlock, shift, i);
         if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
-          await this.core.seek(slotPos);
-          await writer.write(new LinkedArrayListSlot2(nextSlotPtr.leafCount, new Slot(nextPtr, 1 /* INDEX */)).toBytes());
+          this.core.seek(slotPos);
+          writer.write(new LinkedArrayListSlot2(nextSlotPtr.leafCount, new Slot(nextPtr, 1 /* INDEX */)).toBytes());
         }
         return new LinkedArrayListSlotPointer(nextSlotPtr.slotPtr, leafCount);
       }
@@ -2884,12 +2855,12 @@ class Database3 {
         throw new UnexpectedTagException;
     }
   }
-  async readLinkedArrayListBlocks(indexPos, key, shift, blocks) {
+  readLinkedArrayListBlocks(indexPos, key, shift, blocks) {
     const reader = this.core.reader();
     const slotBlock = new Array(SLOT_COUNT);
-    await this.core.seek(indexPos);
+    this.core.seek(indexPos);
     const indexBlock = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-    await reader.readFully(indexBlock);
+    reader.readFully(indexBlock);
     for (let i2 = 0;i2 < SLOT_COUNT; i2++) {
       const slotBytes = indexBlock.slice(i2 * LinkedArrayListSlot2.LENGTH, (i2 + 1) * LinkedArrayListSlot2.LENGTH);
       slotBlock[i2] = LinkedArrayListSlot2.fromBytes(slotBytes);
@@ -2909,7 +2880,7 @@ class Database3 {
       case 0 /* NONE */:
         throw new EmptySlotException;
       case 1 /* INDEX */:
-        await this.readLinkedArrayListBlocks(Number(slot.slot.value), nextKey, shift - 1, blocks);
+        this.readLinkedArrayListBlocks(Number(slot.slot.value), nextKey, shift - 1, blocks);
         break;
       default:
         throw new UnexpectedTagException;
@@ -2920,16 +2891,16 @@ class Database3 {
       arr[i] = new LinkedArrayListSlot2(0, new Slot);
     }
   }
-  async readLinkedArrayListSlice(header, offset, size) {
+  readLinkedArrayListSlice(header, offset, size) {
     const writer = this.core.writer();
     if (offset + size > header.size) {
       throw new KeyNotFoundException;
     }
     const leftBlocks = [];
-    await this.readLinkedArrayListBlocks(header.ptr, offset, header.shift, leftBlocks);
+    this.readLinkedArrayListBlocks(header.ptr, offset, header.shift, leftBlocks);
     const rightBlocks = [];
     const rightKey = offset + size === 0 ? 0 : offset + size - 1;
-    await this.readLinkedArrayListBlocks(header.ptr, rightKey, header.shift, rightBlocks);
+    this.readLinkedArrayListBlocks(header.ptr, rightKey, header.shift, rightBlocks);
     const blockCount = leftBlocks.length;
     let nextSlots = [null, null];
     let nextShift = 0;
@@ -2997,7 +2968,7 @@ class Database3 {
         nextShift += 1;
       }
       nextSlots = [null, null];
-      await this.core.seek(await this.core.length());
+      this.core.seek(this.core.length());
       for (let j = 0;j < 2; j++) {
         const blockMaybe = nextBlocks[j];
         const origBlockInfo = origBlockInfos[j];
@@ -3014,11 +2985,11 @@ class Database3 {
           if (eql) {
             nextSlots[j] = origBlockInfo.parentSlot;
           } else {
-            const nextPtr = await this.core.position();
+            const nextPtr = this.core.position();
             let leafCount = 0;
             for (let k = 0;k < blockMaybe.length; k++) {
               const blockSlot = blockMaybe[k];
-              await writer.write(blockSlot.toBytes());
+              writer.write(blockSlot.toBytes());
               if (isLeafNode) {
                 if (!blockSlot.slot.empty()) {
                   leafCount += 1;
@@ -3040,13 +3011,13 @@ class Database3 {
       throw new ExpectedRootNodeException;
     return new LinkedArrayListHeader(nextShift, Number(rootSlot.slot.value), size);
   }
-  async readLinkedArrayListConcat(headerA, headerB) {
+  readLinkedArrayListConcat(headerA, headerB) {
     const writer = this.core.writer();
     const blocksA = [];
     const keyA = headerA.size === 0 ? 0 : headerA.size - 1;
-    await this.readLinkedArrayListBlocks(headerA.ptr, keyA, headerA.shift, blocksA);
+    this.readLinkedArrayListBlocks(headerA.ptr, keyA, headerA.shift, blocksA);
     const blocksB = [];
-    await this.readLinkedArrayListBlocks(headerB.ptr, 0, headerB.shift, blocksB);
+    this.readLinkedArrayListBlocks(headerB.ptr, 0, headerB.shift, blocksB);
     let nextSlots = [null, null];
     let nextShift = 0;
     for (let i = 0;i < Math.max(blocksA.length, blocksB.length); i++) {
@@ -3133,16 +3104,16 @@ class Database3 {
           blocks[0][j] = slotsToWrite[j];
         }
       }
-      await this.core.seek(await this.core.length());
+      this.core.seek(this.core.length());
       for (let blockI = 0;blockI < blocks.length; blockI++) {
         const block = blocks[blockI];
         if (block[0].slot.empty()) {
           break;
         }
-        const nextPtr = await this.core.position();
+        const nextPtr = this.core.position();
         let leafCount = 0;
         for (const blockSlot of block) {
-          await writer.write(blockSlot.toBytes());
+          writer.write(blockSlot.toBytes());
           if (isLeafNode) {
             if (!blockSlot.slot.empty()) {
               leafCount += 1;
@@ -3161,9 +3132,9 @@ class Database3 {
         this.populateArray(block);
         block[0] = nextSlots[0];
         block[1] = nextSlots[1];
-        const newPtr = await this.core.length();
+        const newPtr = this.core.length();
         for (const blockSlot of block) {
-          await writer.write(blockSlot.toBytes());
+          writer.write(blockSlot.toBytes());
         }
         if (nextShift === MAX_BRANCH_LENGTH)
           throw new MaxShiftExceededException;
@@ -3178,7 +3149,7 @@ class Database3 {
     return new LinkedArrayListHeader(nextShift, rootPtr, headerA.size + headerB.size);
   }
 }
-async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
+function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
   switch (slot.tag) {
     case 0 /* NONE */:
     case 8 /* UINT */:
@@ -3190,7 +3161,7 @@ async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
       const mapped = offsetMap.get(Number(slot.value));
       if (mapped !== undefined)
         return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapBytes(sourceCore, targetCore, slot);
+      const newOffset = remapBytes(sourceCore, targetCore, slot);
       offsetMap.set(Number(slot.value), newOffset);
       return new Slot(newOffset, slot.tag, slot.full);
     }
@@ -3198,7 +3169,7 @@ async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
       const mapped = offsetMap.get(Number(slot.value));
       if (mapped !== undefined)
         return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapIndex(sourceCore, targetCore, hashSize, offsetMap, slot);
+      const newOffset = remapIndex(sourceCore, targetCore, hashSize, offsetMap, slot);
       offsetMap.set(Number(slot.value), newOffset);
       return new Slot(newOffset, slot.tag, slot.full);
     }
@@ -3206,7 +3177,7 @@ async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
       const mapped = offsetMap.get(Number(slot.value));
       if (mapped !== undefined)
         return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapArrayList(sourceCore, targetCore, hashSize, offsetMap, slot);
+      const newOffset = remapArrayList(sourceCore, targetCore, hashSize, offsetMap, slot);
       offsetMap.set(Number(slot.value), newOffset);
       return new Slot(newOffset, slot.tag, slot.full);
     }
@@ -3214,7 +3185,7 @@ async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
       const mapped = offsetMap.get(Number(slot.value));
       if (mapped !== undefined)
         return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapLinkedArrayList(sourceCore, targetCore, hashSize, offsetMap, slot);
+      const newOffset = remapLinkedArrayList(sourceCore, targetCore, hashSize, offsetMap, slot);
       offsetMap.set(Number(slot.value), newOffset);
       return new Slot(newOffset, slot.tag, slot.full);
     }
@@ -3223,7 +3194,7 @@ async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
       const mapped = offsetMap.get(Number(slot.value));
       if (mapped !== undefined)
         return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, false);
+      const newOffset = remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, false);
       offsetMap.set(Number(slot.value), newOffset);
       return new Slot(newOffset, slot.tag, slot.full);
     }
@@ -3232,7 +3203,7 @@ async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
       const mapped = offsetMap.get(Number(slot.value));
       if (mapped !== undefined)
         return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, true);
+      const newOffset = remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, true);
       offsetMap.set(Number(slot.value), newOffset);
       return new Slot(newOffset, slot.tag, slot.full);
     }
@@ -3240,7 +3211,7 @@ async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
       const mapped = offsetMap.get(Number(slot.value));
       if (mapped !== undefined)
         return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapKvPair(sourceCore, targetCore, hashSize, offsetMap, slot);
+      const newOffset = remapKvPair(sourceCore, targetCore, hashSize, offsetMap, slot);
       offsetMap.set(Number(slot.value), newOffset);
       return new Slot(newOffset, slot.tag, slot.full);
     }
@@ -3248,80 +3219,80 @@ async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
       throw new UnexpectedTagException;
   }
 }
-async function remapBytes(sourceCore, targetCore, slot) {
-  await sourceCore.seek(Number(slot.value));
+function remapBytes(sourceCore, targetCore, slot) {
+  sourceCore.seek(Number(slot.value));
   const sourceReader = sourceCore.reader();
-  const length = await sourceReader.readLong();
+  const length = sourceReader.readLong();
   const formatTagSize = slot.full ? 2 : 0;
   const totalPayload = length + formatTagSize;
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
+  const newOffset = targetCore.length();
+  targetCore.seek(newOffset);
   const targetWriter = targetCore.writer();
-  await targetWriter.writeLong(length);
+  targetWriter.writeLong(length);
   let remaining = totalPayload;
   while (remaining > 0) {
     const chunk = Math.min(remaining, 4096);
     const buf = new Uint8Array(chunk);
-    await sourceReader.readFully(buf);
-    await targetWriter.write(buf);
+    sourceReader.readFully(buf);
+    targetWriter.write(buf);
     remaining -= chunk;
   }
   return newOffset;
 }
-async function remapIndex(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  await sourceCore.seek(Number(slot.value));
+function remapIndex(sourceCore, targetCore, hashSize, offsetMap, slot) {
+  sourceCore.seek(Number(slot.value));
   const sourceReader = sourceCore.reader();
   const blockBytes = new Uint8Array(INDEX_BLOCK_SIZE);
-  await sourceReader.readFully(blockBytes);
+  sourceReader.readFully(blockBytes);
   const remappedSlots = [];
   for (let i = 0;i < SLOT_COUNT; i++) {
     const slotBytes = blockBytes.slice(i * Slot.LENGTH, (i + 1) * Slot.LENGTH);
     const childSlot = Slot.fromBytes(slotBytes);
-    remappedSlots.push(await remapSlot(sourceCore, targetCore, hashSize, offsetMap, childSlot));
+    remappedSlots.push(remapSlot(sourceCore, targetCore, hashSize, offsetMap, childSlot));
   }
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
+  const newOffset = targetCore.length();
+  targetCore.seek(newOffset);
   const targetWriter = targetCore.writer();
   for (const s of remappedSlots) {
-    await targetWriter.write(s.toBytes());
+    targetWriter.write(s.toBytes());
   }
   return newOffset;
 }
-async function remapArrayList(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  await sourceCore.seek(Number(slot.value));
+function remapArrayList(sourceCore, targetCore, hashSize, offsetMap, slot) {
+  sourceCore.seek(Number(slot.value));
   const sourceReader = sourceCore.reader();
   const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-  await sourceReader.readFully(headerBytes);
+  sourceReader.readFully(headerBytes);
   const header = ArrayListHeader.fromBytes(headerBytes);
   const indexSlot = new Slot(header.ptr, 1 /* INDEX */);
-  const remappedIndex = await remapSlot(sourceCore, targetCore, hashSize, offsetMap, indexSlot);
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
+  const remappedIndex = remapSlot(sourceCore, targetCore, hashSize, offsetMap, indexSlot);
+  const newOffset = targetCore.length();
+  targetCore.seek(newOffset);
   const targetWriter = targetCore.writer();
-  await targetWriter.write(new ArrayListHeader(Number(remappedIndex.value), header.size).toBytes());
+  targetWriter.write(new ArrayListHeader(Number(remappedIndex.value), header.size).toBytes());
   return newOffset;
 }
-async function remapLinkedArrayList(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  await sourceCore.seek(Number(slot.value));
+function remapLinkedArrayList(sourceCore, targetCore, hashSize, offsetMap, slot) {
+  sourceCore.seek(Number(slot.value));
   const sourceReader = sourceCore.reader();
   const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-  await sourceReader.readFully(headerBytes);
+  sourceReader.readFully(headerBytes);
   const header = LinkedArrayListHeader.fromBytes(headerBytes);
-  const remappedPtr = await remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, header.ptr);
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
+  const remappedPtr = remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, header.ptr);
+  const newOffset = targetCore.length();
+  targetCore.seek(newOffset);
   const targetWriter = targetCore.writer();
-  await targetWriter.write(new LinkedArrayListHeader(header.shift, remappedPtr, header.size).toBytes());
+  targetWriter.write(new LinkedArrayListHeader(header.shift, remappedPtr, header.size).toBytes());
   return newOffset;
 }
-async function remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, blockOffset) {
+function remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, blockOffset) {
   const mapped = offsetMap.get(blockOffset);
   if (mapped !== undefined)
     return mapped;
-  await sourceCore.seek(blockOffset);
+  sourceCore.seek(blockOffset);
   const sourceReader = sourceCore.reader();
   const blockBytes = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-  await sourceReader.readFully(blockBytes);
+  sourceReader.readFully(blockBytes);
   const slots = [];
   for (let i = 0;i < SLOT_COUNT; i++) {
     const slotBytes = blockBytes.slice(i * LinkedArrayListSlot2.LENGTH, (i + 1) * LinkedArrayListSlot2.LENGTH);
@@ -3330,62 +3301,62 @@ async function remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offse
   const remappedSlots = [];
   for (const s of slots) {
     if (s.slot.tag === 1 /* INDEX */) {
-      const remappedPtr = await remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, Number(s.slot.value));
+      const remappedPtr = remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, Number(s.slot.value));
       remappedSlots.push(new LinkedArrayListSlot2(s.size, new Slot(remappedPtr, 1 /* INDEX */, s.slot.full)));
     } else if (s.slot.empty()) {
       remappedSlots.push(s);
     } else {
-      const remapped = await remapSlot(sourceCore, targetCore, hashSize, offsetMap, s.slot);
+      const remapped = remapSlot(sourceCore, targetCore, hashSize, offsetMap, s.slot);
       remappedSlots.push(new LinkedArrayListSlot2(s.size, remapped));
     }
   }
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
+  const newOffset = targetCore.length();
+  targetCore.seek(newOffset);
   const targetWriter = targetCore.writer();
   for (const s of remappedSlots) {
-    await targetWriter.write(s.toBytes());
+    targetWriter.write(s.toBytes());
   }
   offsetMap.set(blockOffset, newOffset);
   return newOffset;
 }
-async function remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, counted) {
-  await sourceCore.seek(Number(slot.value));
+function remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, counted) {
+  sourceCore.seek(Number(slot.value));
   const sourceReader = sourceCore.reader();
   let countValue = -1;
   if (counted) {
-    countValue = await sourceReader.readLong();
+    countValue = sourceReader.readLong();
   }
   const blockBytes = new Uint8Array(INDEX_BLOCK_SIZE);
-  await sourceReader.readFully(blockBytes);
+  sourceReader.readFully(blockBytes);
   const remappedSlots = [];
   for (let i = 0;i < SLOT_COUNT; i++) {
     const slotBytes = blockBytes.slice(i * Slot.LENGTH, (i + 1) * Slot.LENGTH);
     const childSlot = Slot.fromBytes(slotBytes);
-    remappedSlots.push(await remapSlot(sourceCore, targetCore, hashSize, offsetMap, childSlot));
+    remappedSlots.push(remapSlot(sourceCore, targetCore, hashSize, offsetMap, childSlot));
   }
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
+  const newOffset = targetCore.length();
+  targetCore.seek(newOffset);
   const targetWriter = targetCore.writer();
   if (counted) {
-    await targetWriter.writeLong(countValue);
+    targetWriter.writeLong(countValue);
   }
   for (const s of remappedSlots) {
-    await targetWriter.write(s.toBytes());
+    targetWriter.write(s.toBytes());
   }
   return newOffset;
 }
-async function remapKvPair(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  await sourceCore.seek(Number(slot.value));
+function remapKvPair(sourceCore, targetCore, hashSize, offsetMap, slot) {
+  sourceCore.seek(Number(slot.value));
   const sourceReader = sourceCore.reader();
   const kvPairBytes = new Uint8Array(KeyValuePair.length(hashSize));
-  await sourceReader.readFully(kvPairBytes);
+  sourceReader.readFully(kvPairBytes);
   const kvPair = KeyValuePair.fromBytes(kvPairBytes, hashSize);
-  const remappedKey = await remapSlot(sourceCore, targetCore, hashSize, offsetMap, kvPair.keySlot);
-  const remappedValue = await remapSlot(sourceCore, targetCore, hashSize, offsetMap, kvPair.valueSlot);
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
+  const remappedKey = remapSlot(sourceCore, targetCore, hashSize, offsetMap, kvPair.keySlot);
+  const remappedValue = remapSlot(sourceCore, targetCore, hashSize, offsetMap, kvPair.valueSlot);
+  const newOffset = targetCore.length();
+  targetCore.seek(newOffset);
   const targetWriter = targetCore.writer();
-  await targetWriter.write(new KeyValuePair(remappedValue, remappedKey, kvPair.hash).toBytes());
+  targetWriter.write(new KeyValuePair(remappedValue, remappedKey, kvPair.hash).toBytes());
   return newOffset;
 }
 // src/read-array-list.ts
@@ -3406,66 +3377,61 @@ class ReadArrayList {
   slot() {
     return this.cursor.slot();
   }
-  async count() {
+  count() {
     return this.cursor.count();
   }
-  async iterator() {
+  iterator() {
     return this.cursor.iterator();
   }
-  async* [Symbol.asyncIterator]() {
+  *[Symbol.iterator]() {
     yield* this.cursor;
   }
-  async getCursor(index) {
+  getCursor(index) {
     return this.cursor.readPath([new ArrayListGet2(index)]);
   }
-  async getSlot(index) {
+  getSlot(index) {
     return this.cursor.readPathSlot([new ArrayListGet2(index)]);
   }
 }
 // src/write-array-list.ts
 class WriteArrayList extends ReadArrayList {
-  constructor() {
+  constructor(cursor) {
     super();
+    this.cursor = cursor.writePath([new ArrayListInit]);
   }
-  static async create(cursor) {
-    const list = new WriteArrayList;
-    const newCursor = await cursor.writePath([new ArrayListInit]);
-    list.cursor = newCursor;
-    return list;
-  }
-  async iterator() {
+  iterator() {
     return this.cursor.iterator();
   }
-  async* [Symbol.asyncIterator]() {
+  *[Symbol.iterator]() {
     yield* this.cursor;
   }
-  async put(index, data) {
-    await this.cursor.writePath([
+  put(index, data) {
+    this.cursor.writePath([
       new ArrayListGet2(index),
       new WriteData(data)
     ]);
   }
-  async putCursor(index) {
+  putCursor(index) {
     return this.cursor.writePath([new ArrayListGet2(index)]);
   }
-  async append(data) {
-    await this.cursor.writePath([
+  append(data) {
+    this.cursor.writePath([
       new ArrayListAppend,
       new WriteData(data)
     ]);
   }
-  async appendCursor() {
+  appendCursor() {
     return this.cursor.writePath([new ArrayListAppend]);
   }
-  async appendContext(data, fn) {
-    await this.cursor.writePath([
+  appendContext(data, fn) {
+    this.cursor.writePath([
       new ArrayListAppend,
       new WriteData(data),
       new Context(fn)
     ]);
   }
-  async slice(size) {
-    await this.cursor.writePath([new ArrayListSlice(size)]);
+  slice(size) {
+    this.cursor.writePath([new ArrayListSlice(size)]);
   }
 }
 // src/read-hash-map.ts
@@ -3487,38 +3453,38 @@ class ReadHashMap {
   slot() {
     return this.cursor.slot();
   }
-  async iterator() {
+  iterator() {
     return this.cursor.iterator();
   }
-  async* [Symbol.asyncIterator]() {
+  *[Symbol.iterator]() {
     yield* this.cursor;
   }
-  async getCursor(key) {
-    const hash = await this.resolveHash(key);
+  getCursor(key) {
+    const hash = this.resolveHash(key);
     return this.cursor.readPath([new HashMapGet(new HashMapGetValue(hash))]);
   }
-  async getSlot(key) {
-    const hash = await this.resolveHash(key);
+  getSlot(key) {
+    const hash = this.resolveHash(key);
     return this.cursor.readPathSlot([new HashMapGet(new HashMapGetValue(hash))]);
   }
-  async getKeyCursor(key) {
-    const hash = await this.resolveHash(key);
+  getKeyCursor(key) {
+    const hash = this.resolveHash(key);
     return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
   }
-  async getKeySlot(key) {
-    const hash = await this.resolveHash(key);
+  getKeySlot(key) {
+    const hash = this.resolveHash(key);
     return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
   }
-  async getKeyValuePair(key) {
-    const hash = await this.resolveHash(key);
-    const cursor = await this.cursor.readPath([new HashMapGet(new HashMapGetKVPair(hash))]);
+  getKeyValuePair(key) {
+    const hash = this.resolveHash(key);
+    const cursor = this.cursor.readPath([new HashMapGet(new HashMapGetKVPair(hash))]);
     if (cursor === null) {
       return null;
     } else {
       return cursor.readKeyValuePair();
     }
   }
-  async resolveHash(key) {
+  resolveHash(key) {
     if (key instanceof Uint8Array) {
       return key;
     } else if (typeof key === "string") {
@@ -3530,59 +3496,54 @@ class ReadHashMap {
 }
 // src/write-hash-map.ts
 class WriteHashMap extends ReadHashMap {
-  constructor() {
+  constructor(cursor, counted = false) {
     super();
+    this.cursor = cursor.writePath([new HashMapInit(counted, false)]);
   }
-  static async create(cursor) {
-    const map = new WriteHashMap;
-    const newCursor = await cursor.writePath([new HashMapInit(false, false)]);
-    map.cursor = newCursor;
-    return map;
-  }
-  async iterator() {
+  iterator() {
     return this.cursor.iterator();
   }
-  async* [Symbol.asyncIterator]() {
+  *[Symbol.iterator]() {
     yield* this.cursor;
   }
-  async put(key, data) {
+  put(key, data) {
     if (typeof key === "string") {
-      const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-      await this.putKeyInternal(hash, new Bytes(key));
-      await this.putInternal(hash, data);
+      const hash = this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+      this.putKeyInternal(hash, new Bytes(key));
+      this.putInternal(hash, data);
     } else if (key instanceof Bytes) {
-      const hash = await this.cursor.db.hasher.digest(key.value);
-      await this.putKeyInternal(hash, key);
-      await this.putInternal(hash, data);
+      const hash = this.cursor.db.hasher.digest(key.value);
+      this.putKeyInternal(hash, key);
+      this.putInternal(hash, data);
     } else {
-      await this.putInternal(key, data);
+      this.putInternal(key, data);
     }
   }
-  async putCursor(key) {
+  putCursor(key) {
     if (typeof key === "string") {
-      const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-      await this.putKeyInternal(hash, new Bytes(key));
+      const hash = this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+      this.putKeyInternal(hash, new Bytes(key));
       return this.putCursorInternal(hash);
     } else if (key instanceof Bytes) {
-      const hash = await this.cursor.db.hasher.digest(key.value);
-      await this.putKeyInternal(hash, key);
+      const hash = this.cursor.db.hasher.digest(key.value);
+      this.putKeyInternal(hash, key);
       return this.putCursorInternal(hash);
     } else {
       return this.putCursorInternal(key);
     }
   }
-  async putKey(key, data) {
-    const hash = await this.resolveHash(key);
-    await this.putKeyInternal(hash, data);
+  putKey(key, data) {
+    const hash = this.resolveHash(key);
+    this.putKeyInternal(hash, data);
   }
-  async putKeyCursor(key) {
-    const hash = await this.resolveHash(key);
+  putKeyCursor(key) {
+    const hash = this.resolveHash(key);
     return this.putKeyCursorInternal(hash);
   }
-  async remove(key) {
-    const hash = await this.resolveHash(key);
+  remove(key) {
+    const hash = this.resolveHash(key);
     try {
-      await this.cursor.writePath([new HashMapRemove(hash)]);
+      this.cursor.writePath([new HashMapRemove(hash)]);
     } catch (e) {
       if (e instanceof KeyNotFoundException) {
         return false;
@@ -3591,24 +3552,24 @@ class WriteHashMap extends ReadHashMap {
     }
     return true;
   }
-  async putInternal(hash, data) {
-    await this.cursor.writePath([
+  putInternal(hash, data) {
+    this.cursor.writePath([
       new HashMapGet(new HashMapGetValue(hash)),
       new WriteData(data)
     ]);
   }
-  async putCursorInternal(hash) {
+  putCursorInternal(hash) {
     return this.cursor.writePath([
       new HashMapGet(new HashMapGetValue(hash))
     ]);
   }
-  async putKeyInternal(hash, data) {
-    const cursor = await this.cursor.writePath([
+  putKeyInternal(hash, data) {
+    const cursor = this.cursor.writePath([
       new HashMapGet(new HashMapGetKey(hash))
     ]);
-    await cursor.writeIfEmpty(data);
+    cursor.writeIfEmpty(data);
   }
-  async putKeyCursorInternal(hash) {
+  putKeyCursorInternal(hash) {
     return this.cursor.writePath([
       new HashMapGet(new HashMapGetKey(hash))
     ]);
@@ -3633,21 +3594,21 @@ class ReadHashSet {
   slot() {
     return this.cursor.slot();
   }
-  async iterator() {
+  iterator() {
     return this.cursor.iterator();
   }
-  async* [Symbol.asyncIterator]() {
+  *[Symbol.iterator]() {
     yield* this.cursor;
   }
-  async getCursor(key) {
-    const hash = await this.resolveHash(key);
+  getCursor(key) {
+    const hash = this.resolveHash(key);
     return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
   }
-  async getSlot(key) {
-    const hash = await this.resolveHash(key);
+  getSlot(key) {
+    const hash = this.resolveHash(key);
     return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
   }
-  async resolveHash(key) {
+  resolveHash(key) {
     if (key instanceof Uint8Array) {
       return key;
     } else if (typeof key === "string") {
@@ -3659,41 +3620,36 @@ class ReadHashSet {
 }
 // src/write-hash-set.ts
 class WriteHashSet extends ReadHashSet {
-  constructor() {
+  constructor(cursor, counted = false) {
     super();
+    this.cursor = cursor.writePath([new HashMapInit(counted, true)]);
   }
-  static async create(cursor) {
-    const set = new WriteHashSet;
-    const newCursor = await cursor.writePath([new HashMapInit(false, true)]);
-    set.cursor = newCursor;
-    return set;
-  }
-  async iterator() {
+  iterator() {
     return this.cursor.iterator();
   }
-  async* [Symbol.asyncIterator]() {
+  *[Symbol.iterator]() {
     yield* this.cursor;
   }
-  async put(key, data) {
+  put(key, data) {
     if (typeof key === "string") {
       const bytes = new TextEncoder().encode(key);
-      const hash = await this.cursor.db.hasher.digest(bytes);
-      await this.putInternal(hash, new Bytes(bytes));
+      const hash = this.cursor.db.hasher.digest(bytes);
+      this.putInternal(hash, new Bytes(bytes));
     } else if (key instanceof Bytes) {
-      const hash = await this.cursor.db.hasher.digest(key.value);
-      await this.putInternal(hash, key);
+      const hash = this.cursor.db.hasher.digest(key.value);
+      this.putInternal(hash, key);
     } else {
-      await this.putInternal(key, data);
+      this.putInternal(key, data);
     }
   }
-  async putCursor(key) {
-    const hash = await this.resolveHash(key);
+  putCursor(key) {
+    const hash = this.resolveHash(key);
     return this.putCursorInternal(hash);
   }
-  async remove(key) {
-    const hash = await this.resolveHash(key);
+  remove(key) {
+    const hash = this.resolveHash(key);
     try {
-      await this.cursor.writePath([new HashMapRemove(hash)]);
+      this.cursor.writePath([new HashMapRemove(hash)]);
     } catch (e) {
       if (e instanceof KeyNotFoundException) {
         return false;
@@ -3702,13 +3658,13 @@ class WriteHashSet extends ReadHashSet {
     }
     return true;
   }
-  async putInternal(hash, data) {
-    const cursor = await this.cursor.writePath([
+  putInternal(hash, data) {
+    const cursor = this.cursor.writePath([
       new HashMapGet(new HashMapGetKey(hash))
     ]);
-    await cursor.writeIfEmpty(data);
+    cursor.writeIfEmpty(data);
   }
-  async putCursorInternal(hash) {
+  putCursorInternal(hash) {
     return this.cursor.writePath([
       new HashMapGet(new HashMapGetKey(hash))
     ]);
@@ -3732,76 +3688,71 @@ class ReadLinkedArrayList {
   slot() {
     return this.cursor.slot();
   }
-  async count() {
+  count() {
     return this.cursor.count();
   }
-  async iterator() {
+  iterator() {
     return this.cursor.iterator();
   }
-  async* [Symbol.asyncIterator]() {
+  *[Symbol.iterator]() {
     yield* this.cursor;
   }
-  async getCursor(index) {
+  getCursor(index) {
     return this.cursor.readPath([new LinkedArrayListGet(index)]);
   }
-  async getSlot(index) {
+  getSlot(index) {
     return this.cursor.readPathSlot([new LinkedArrayListGet(index)]);
   }
 }
 // src/write-linked-array-list.ts
 class WriteLinkedArrayList extends ReadLinkedArrayList {
-  constructor() {
+  constructor(cursor) {
     super();
+    this.cursor = cursor.writePath([new LinkedArrayListInit]);
   }
-  static async create(cursor) {
-    const list = new WriteLinkedArrayList;
-    const newCursor = await cursor.writePath([new LinkedArrayListInit]);
-    list.cursor = newCursor;
-    return list;
-  }
-  async iterator() {
+  iterator() {
     return this.cursor.iterator();
   }
-  async* [Symbol.asyncIterator]() {
+  *[Symbol.iterator]() {
     yield* this.cursor;
   }
-  async put(index, data) {
-    await this.cursor.writePath([
+  put(index, data) {
+    this.cursor.writePath([
       new LinkedArrayListGet(index),
       new WriteData(data)
     ]);
   }
-  async putCursor(index) {
+  putCursor(index) {
     return this.cursor.writePath([new LinkedArrayListGet(index)]);
   }
-  async append(data) {
-    await this.cursor.writePath([
+  append(data) {
+    this.cursor.writePath([
       new LinkedArrayListAppend,
       new WriteData(data)
     ]);
   }
-  async appendCursor() {
+  appendCursor() {
     return this.cursor.writePath([new LinkedArrayListAppend]);
   }
-  async slice(offset, size) {
-    await this.cursor.writePath([
+  slice(offset, size) {
+    this.cursor.writePath([
       new LinkedArrayListSlice(offset, size)
     ]);
   }
-  async concat(list) {
-    await this.cursor.writePath([new LinkedArrayListConcat(list)]);
+  concat(list) {
+    this.cursor.writePath([new LinkedArrayListConcat(list)]);
   }
-  async insert(index, data) {
-    await this.cursor.writePath([
+  insert(index, data) {
+    this.cursor.writePath([
       new LinkedArrayListInsert(index),
       new WriteData(data)
     ]);
   }
-  async insertCursor(index) {
+  insertCursor(index) {
     return this.cursor.writePath([new LinkedArrayListInsert(index)]);
   }
-  async remove(index) {
-    await this.cursor.writePath([new LinkedArrayListRemove(index)]);
+  remove(index) {
+    this.cursor.writePath([new LinkedArrayListRemove(index)]);
   }
 }
 // src/read-counted-hash-map.ts
@@ -3818,31 +3769,24 @@ class ReadCountedHashMap extends ReadHashMap {
         throw new UnexpectedTagException;
     }
   }
-  async count() {
+  count() {
     return this.cursor.count();
   }
 }
 // src/write-counted-hash-map.ts
 class WriteCountedHashMap extends WriteHashMap {
-  constructor() {
-    super();
-  }
-  static async create(cursor) {
-    const map = new WriteCountedHashMap;
+  constructor(cursor) {
     switch (cursor.slotPtr.slot.tag) {
       case 0 /* NONE */:
       case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */: {
-        const newCursor = await cursor.writePath([new HashMapInit(true, false)]);
-        map.cursor = newCursor;
+      case 13 /* COUNTED_HASH_SET */:
+        super(cursor, true);
         break;
-      }
       default:
         throw new UnexpectedTagException;
     }
-    return map;
   }
-  async count() {
+  count() {
     return this.cursor.count();
   }
 }
@@ -3860,31 +3804,24 @@ class ReadCountedHashSet extends ReadHashSet {
         throw new UnexpectedTagException;
     }
   }
-  async count() {
+  count() {
     return this.cursor.count();
   }
 }
 // src/write-counted-hash-set.ts
 class WriteCountedHashSet extends WriteHashSet {
-  constructor() {
-    super();
-  }
-  static async create(cursor) {
-    const set = new WriteCountedHashSet;
+  constructor(cursor) {
     switch (cursor.slotPtr.slot.tag) {
       case 0 /* NONE */:
       case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */: {
-        const newCursor = await cursor.writePath([new HashMapInit(true, true)]);
-        set.cursor = newCursor;
+      case 13 /* COUNTED_HASH_SET */:
+        super(cursor, true);
         break;
-      }
       default:
         throw new UnexpectedTagException;
     }
-    return set;
   }
-  async count() {
+  count() {
     return this.cursor.count();
   }
 }