sharedthread 1.0.0

package/dist/index.js

@@ -0,0 +1,976 @@
+// src/index.ts
+import { isMainThread as isMainThread2 } from "worker_threads";
+
+// src/Memory/TypeRegistry.ts
+var TypeRegistry = class _TypeRegistry {
+  static indexToType = /* @__PURE__ */ new Map();
+  static typeToIndex = /* @__PURE__ */ new Map();
+  static hashToType = /* @__PURE__ */ new Map();
+  static typeToHash = /* @__PURE__ */ new Map();
+  static indexToHash = new Uint32Array(0);
+  // private static cyrb53(str: string, seed: number = 0): number {
+  //     let h1 = 0xdeadbeef ^ seed;
+  //     let h2 = 0x41c6ce57 ^ seed;
+  //     for (let i = 0, ch: number; i < str.length; i++) {
+  //         ch = str.charCodeAt(i);
+  //         h1 = Math.imul(h1 ^ ch, 2654435761);
+  //         h2 = Math.imul(h2 ^ ch, 1597334677);
+  //     }
+  //     h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+  //     h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+  //     h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+  //     h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+  //     // Combine the two 32-bit hashes into a single 53-bit unsigned integer
+  //     return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+  // }
+  static fnv1(str) {
+    let hash = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+      hash ^= str.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+  }
+  static registerType(dataType) {
+    if (this.typeToIndex.has(dataType)) throw new Error("class is alreadly registered");
+    let idx = _TypeRegistry.indexToType.size;
+    let hash;
+    do {
+      hash = _TypeRegistry.fnv1(dataType.toString());
+    } while (_TypeRegistry.hashToType.has(hash));
+    _TypeRegistry.indexToType.set(idx, dataType);
+    _TypeRegistry.typeToIndex.set(dataType, idx);
+    _TypeRegistry.hashToType.set(hash, dataType);
+    _TypeRegistry.typeToHash.set(dataType, hash);
+    let nextHashes = new Uint32Array(idx + 1);
+    nextHashes.set(_TypeRegistry.indexToHash);
+    nextHashes[idx] = hash;
+    _TypeRegistry.indexToHash = nextHashes;
+    dataType.typeID = idx;
+    return idx;
+  }
+  static getTypeBuffer() {
+    return new Uint32Array(_TypeRegistry.indexToHash).buffer;
+  }
+  static verifyTypeBuffer(typeBuffer) {
+    const arrayEqual = (a, b) => a.length == b.length && a.every((v, i) => v == b[i]);
+    const setEqual = (a, b) => a.length === b.length && ((m) => a.every((x) => m.set(x, (m.get(x) || 0) + 1)) && b.every((x) => m.get(x) && m.set(x, m.get(x) - 1)))(/* @__PURE__ */ new Map());
+    let hashArray = new Uint32Array(typeBuffer);
+    let isEqual = arrayEqual(this.indexToHash, hashArray);
+    let isSetEqual = setEqual(this.indexToHash, hashArray);
+    if (!isEqual) {
+      if (isSetEqual) {
+        throw new Error("type registrations are out of order");
+      } else {
+        throw new Error("type registrations mismatched");
+      }
+    }
+  }
+  static getTypeByIndex(index) {
+    if (!this.indexToType.has(index)) throw new Error("cannot find type by index");
+    return this.indexToType.get(index);
+  }
+  static getTypeByHash(hash) {
+    if (!this.hashToType.has(hash)) throw new Error("cannot find type by hash");
+    return this.hashToType.get(hash);
+  }
+  static getIndexByType(type) {
+    if (!this.typeToIndex.has(type)) throw new Error("cannot find id by type");
+    return this.typeToIndex.get(type);
+  }
+  static getHashByType(type) {
+    if (!this.typeToHash.has(type)) throw new Error("cannot find hash by index");
+    return this.typeToHash.get(type);
+  }
+  constructor() {
+  }
+};
+
+// src/Memory/SharedHeap.ts
+var SharedHeap = class _SharedHeap {
+  static heaps = [];
+  static getHeapByID(i) {
+    if (_SharedHeap.heaps[i] === void 0) throw new Error(`cannot find heap with heapID`);
+    return _SharedHeap.heaps[i];
+  }
+  _heapID;
+  _heapSize;
+  _buffer;
+  _view;
+  // Bit-Packing Constants for the Lower 32-bit Header
+  static SHIFT_TYPEID = 0;
+  static SHIFT_ARRAY = 23;
+  static SHIFT_PTR = 26;
+  static SHIFT_ALLOC = 29;
+  static MASK_TYPEID = 8388607;
+  // 23 bits
+  static MASK_ARRAY = 7;
+  // 3 bits
+  static MASK_PTR = 7;
+  // 3 bits
+  static MASK_ALLOC = 7;
+  // 3 bits
+  constructor(b, heapID = _SharedHeap.heaps.length) {
+    if (_SharedHeap.heaps[heapID] !== void 0) throw new Error("heap assignment overlap");
+    this._heapID = heapID;
+    _SharedHeap.heaps[this._heapID] = this;
+    if (b instanceof SharedArrayBuffer) {
+      this._heapSize = b.byteLength;
+      this._buffer = b;
+      this._view = new DataView(this._buffer);
+    } else {
+      this._heapSize = b + 4 + 3 & ~3;
+      this._buffer = new SharedArrayBuffer(this._heapSize);
+      this._view = new DataView(this._buffer);
+      this.listHead = -1;
+      const initialPayloadSize = this._heapSize - 4 - 8;
+      this.writeHeader(4, initialPayloadSize, 0, 0, 0, 0);
+      this._view.setInt32(12, -1, true);
+      this._view.setInt32(16, -1, true);
+      this.syncFreeList();
+    }
+  }
+  get heapID() {
+    return this._heapID;
+  }
+  get view() {
+    return this._view;
+  }
+  get heapSize() {
+    return this._heapSize;
+  }
+  get buffer() {
+    return this._buffer;
+  }
+  // Dynamically reads and writes to the beginning of the SharedArrayBuffer
+  get listHead() {
+    return this._view.getInt32(0, true);
+  }
+  set listHead(offset) {
+    this._view.setInt32(0, offset, true);
+  }
+  // --- Fixed Dual 32-Bit Bit-Packing Utilities ---
+  getHeaderSize(offset) {
+    return this._view.getUint32(offset, true);
+  }
+  getHeaderAllocated(offset) {
+    const lowerHeader = this._view.getUint32(offset + 4, true);
+    return lowerHeader >>> _SharedHeap.SHIFT_ALLOC & _SharedHeap.MASK_ALLOC;
+  }
+  writeHeader(offset, size, alloc, ptr, array, typeID) {
+    if (typeID < 0 || typeID > _SharedHeap.MASK_TYPEID) throw new Error("typeID out of bounds");
+    if (size < 0 || size > 4294967295) throw new Error("size exceeds 32-bit limit");
+    if (alloc < 0 || alloc > 7 || ptr < 0 || ptr > 7 || array < 0 || array > 7) throw new Error("alloc, ptr, and array must fit in 3 bits (0-7)");
+    this._view.setUint32(offset, size, true);
+    const lowerHeader = (alloc & _SharedHeap.MASK_ALLOC) << _SharedHeap.SHIFT_ALLOC | (ptr & _SharedHeap.MASK_PTR) << _SharedHeap.SHIFT_PTR | (array & _SharedHeap.MASK_ARRAY) << _SharedHeap.SHIFT_ARRAY | (typeID & _SharedHeap.MASK_TYPEID) << _SharedHeap.SHIFT_TYPEID;
+    this._view.setUint32(offset + 4, lowerHeader >>> 0, true);
+  }
+  syncFreeList() {
+    let current = 4;
+    this.listHead = -1;
+    let lastFree = -1;
+    while (current < this._heapSize) {
+      const size = this.getHeaderSize(current);
+      const allocVal = this.getHeaderAllocated(current);
+      if (allocVal === 0) {
+        if (this.listHead === -1) {
+          this.listHead = current;
+        }
+        if (lastFree !== -1) {
+          this._view.setInt32(lastFree + 8, current, true);
+          this._view.setInt32(current + 12, lastFree, true);
+        }
+        lastFree = current;
+      }
+      current += 8 + size;
+    }
+    if (lastFree !== -1) {
+      this._view.setInt32(lastFree + 8, -1, true);
+    }
+  }
+  allocate(requestedSize, typeID, isPtr = false, isArray = false) {
+    if (isNaN(requestedSize)) throw new Error("cannot allocate NaN size");
+    if (requestedSize <= 0) throw new Error("cannot allocate negative size");
+    const allocValue = 1;
+    const ptrValue = isPtr ? 1 : 0;
+    const arrayValue = isArray ? 1 : 0;
+    const alignedSize = Math.max(requestedSize + 3 & ~3, 4);
+    let currentOffset = this.listHead;
+    while (currentOffset !== -1) {
+      const size = this.getHeaderSize(currentOffset);
+      if (size >= alignedSize) {
+        const remainingSpace = size - alignedSize - 8;
+        if (remainingSpace >= 12) {
+          const nextFreeOffset = currentOffset + 8 + alignedSize;
+          this.replaceFreeNode(currentOffset, nextFreeOffset);
+          this.writeHeader(currentOffset, alignedSize, allocValue, ptrValue, arrayValue, typeID);
+          this.writeHeader(nextFreeOffset, remainingSpace, 0, 0, 0, 0);
+        } else {
+          this.removeFreeNode(currentOffset);
+          this.writeHeader(currentOffset, size, allocValue, ptrValue, arrayValue, typeID);
+        }
+        return currentOffset + 8;
+      }
+      currentOffset = this._view.getInt32(currentOffset + 8, true);
+    }
+    throw new Error("heap out of memory");
+  }
+  free(ptr) {
+    if (ptr < 12 || ptr >= this._heapSize) throw new Error("cannot free out of bounds");
+    const headerOffset = ptr - 8;
+    const size = this.getHeaderSize(headerOffset);
+    this.writeHeader(headerOffset, size, 0, 0, 0, 0);
+    this.addFreeNodeToFront(headerOffset);
+  }
+  addFreeNodeToFront(offset) {
+    const oldHead = this.listHead;
+    this.listHead = offset;
+    this._view.setInt32(offset + 8, oldHead, true);
+    this._view.setInt32(offset + 12, -1, true);
+    if (oldHead !== -1) {
+      this._view.setInt32(oldHead + 12, offset, true);
+    }
+  }
+  // --- Public External Metadata Readers (Accepts Pointer Address, Reads Header) ---
+  getTypeIDAt(ptr) {
+    if (ptr < 12 || ptr >= this._heapSize) return 0;
+    const lowerHeader = this._view.getUint32(ptr - 4, true);
+    return lowerHeader >>> _SharedHeap.SHIFT_TYPEID & _SharedHeap.MASK_TYPEID;
+  }
+  getAllocAt(ptr) {
+    if (ptr < 12 || ptr >= this._heapSize) return 0;
+    const lowerHeader = this._view.getUint32(ptr - 4, true);
+    return lowerHeader >>> _SharedHeap.SHIFT_ALLOC & _SharedHeap.MASK_ALLOC;
+  }
+  getPtrAt(ptr) {
+    if (ptr < 12 || ptr >= this._heapSize) return 0;
+    const lowerHeader = this._view.getUint32(ptr - 4, true);
+    return lowerHeader >>> _SharedHeap.SHIFT_PTR & _SharedHeap.MASK_PTR;
+  }
+  getArrayAt(ptr) {
+    if (ptr < 12 || ptr >= this._heapSize) return 0;
+    const lowerHeader = this._view.getUint32(ptr - 4, true);
+    return lowerHeader >>> _SharedHeap.SHIFT_ARRAY & _SharedHeap.MASK_ARRAY;
+  }
+  // --- Private Free-List Node Handlers ---
+  removeFreeNode(offset) {
+    const next = this._view.getInt32(offset + 8, true);
+    const prev = this._view.getInt32(offset + 12, true);
+    if (prev !== -1) this._view.setInt32(prev + 8, next, true);
+    else this.listHead = next;
+    if (next !== -1) this._view.setInt32(next + 12, prev, true);
+  }
+  replaceFreeNode(oldOffset, newOffset) {
+    const next = this._view.getInt32(oldOffset + 8, true);
+    const prev = this._view.getInt32(oldOffset + 12, true);
+    if (next !== -1) this._view.setInt32(next + 12, newOffset, true);
+    if (prev !== -1) this._view.setInt32(prev + 8, newOffset, true);
+    else this.listHead = newOffset;
+    this._view.setInt32(newOffset + 8, next, true);
+    this._view.setInt32(newOffset + 12, prev, true);
+  }
+};
+
+// src/Memory/SharedType.ts
+var SharedType = class {
+  _addr;
+  _heap;
+  constructor(heap, addr) {
+    if (!isFinite(addr) || addr < 0) throw new Error("invalid address");
+    this._heap = heap;
+    this._addr = addr;
+  }
+  get addr() {
+    return this._addr;
+  }
+  get heap() {
+    return this._heap;
+  }
+};
+
+// src/Memory/SharedPrimitive.ts
+var SharedPrimitive = class extends SharedType {
+  static typeID;
+  static byteSize;
+  static isPtr = false;
+  static isArr = false;
+};
+
+// src/Memory/SharedReference.ts
+var SharedReference = class extends SharedType {
+  static typeID;
+  static isPtr = false;
+  static isArr = false;
+};
+
+// src/Memory/SharedPointer.ts
+var SharedPointer = class _SharedPointer extends SharedPrimitive {
+  static byteSize = 4;
+  static isPtr = true;
+  static fromData(heap, v) {
+    let addr = heap.allocate(_SharedPointer.byteSize, v.type.typeID, _SharedPointer.isPtr);
+    let obj = new _SharedPointer(heap, addr);
+    if (v.addr) obj.value = addr;
+    return obj;
+  }
+  _heldType;
+  _deref = null;
+  constructor(heap, addr, dataType) {
+    super(heap, addr);
+    this._heldType = dataType ?? TypeRegistry.getTypeByIndex(heap.getTypeIDAt(addr));
+  }
+  get heldType() {
+    return this._heldType;
+  }
+  get addr() {
+    return this._addr;
+  }
+  get heap() {
+    return this._heap;
+  }
+  set value(p) {
+    this._heap.view.setUint32(this._addr, p);
+    if (this.heap.getArrayAt(p)) {
+      if (this._heldType != SharedArray) throw new Error("pointer points to wrong type");
+    } else {
+      if (this._heldType != TypeRegistry.getTypeByIndex(this._heap.getTypeIDAt(this._addr))) throw new Error("pointer points to wrong type");
+    }
+    this._deref = new this._heldType(this._heap, p);
+  }
+  get value() {
+    return this._heap.view.getUint32(this._addr);
+  }
+  set deref(v) {
+    if (!(v instanceof this._heldType)) throw new Error("assigned wrong type to pointer");
+    this.value = v.addr;
+    this._deref = v;
+  }
+  get deref() {
+    return this._deref;
+  }
+};
+
+// src/Memory/SharedUint32.ts
+function Uint32(value) {
+  if (!Number.isInteger(value) || value < -2147483648 || value > 2147483647) {
+    throw new RangeError("cannot cast value to uint32");
+  }
+  return value;
+}
+var SharedUint32 = class _SharedUint32 extends SharedPrimitive {
+  static byteSize = 4;
+  static fromData(heap, v) {
+    let addr = heap.allocate(_SharedUint32.byteSize, _SharedUint32.typeID);
+    let obj = new _SharedUint32(heap, addr);
+    obj.value = v;
+    return obj;
+  }
+  set value(v) {
+    this._heap.view.setUint32(this._addr, Uint32(v));
+  }
+  get value() {
+    return this._heap.view.getUint32(this._addr);
+  }
+};
+TypeRegistry.registerType(SharedUint32);
+
+// src/Memory/SharedArray.ts
+var SharedArray = class extends SharedReference {
+  static isArr = true;
+  static properties = {
+    length: { type: SharedUint32 }
+  };
+  static fromData(heap, v) {
+    let length = v.length;
+    let type = v.type;
+    if (type.prototype instanceof SharedPrimitive) {
+      type = type;
+    } else {
+      type = SharedPointer;
+    }
+    let elementSize = type.byteSize;
+    let totalSize = 4 + elementSize * length;
+    let addr = heap.allocate(totalSize, type.typeID, false, true);
+    heap.view.setUint32(addr, length);
+    let obj = new this(heap, addr);
+    if (v.array) {
+      for (let i = 0; i < length; i++) {
+        obj.elements[i] = v.array[i];
+      }
+    }
+    return obj;
+  }
+  _heldType;
+  _elementType;
+  _elementSize;
+  _byteSize;
+  _length;
+  elements = [];
+  constructor(heap, addr) {
+    super(heap, addr);
+    this._elementType = TypeRegistry.getTypeByIndex(heap.getTypeIDAt(addr));
+    this._heldType = heap.getPtrAt(addr) ? SharedPointer : this._elementType;
+    this._elementSize = this._heldType.byteSize;
+    this._length = heap.view.getUint32(addr);
+    this._byteSize = 4 + this._elementSize * this._length;
+    let offset = 4;
+    for (let i = 0; i < this._length; i++, offset += this._elementSize) {
+      this.elements.push(new this._heldType(heap, addr + offset));
+    }
+    return new Proxy(this, {
+      get(target, prop, receiver) {
+        if (Number.isInteger(Number(prop)) && prop >= 0 && prop < target._length) {
+          return target.elements[prop];
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      set(target, prop, value, receiver) {
+        if (typeof prop == "number" && prop >= 0 && prop < target._length) {
+          if (target.elements[prop] && "value" in target.elements[prop]) {
+            target.elements[prop].value = value;
+            return true;
+          }
+        }
+        return Reflect.set(target, prop, value, receiver);
+      }
+    });
+  }
+  get addr() {
+    return this._addr;
+  }
+  get heap() {
+    return this._heap;
+  }
+  get heldType() {
+    return this._heldType;
+  }
+  get elementType() {
+    return this._elementType;
+  }
+  get elementSize() {
+    return this._elementSize;
+  }
+  static get byteSize() {
+    throw new Error("cannot precalculate array size");
+  }
+  get byteSize() {
+    return this._byteSize;
+  }
+  get length() {
+    return this._length;
+  }
+};
+
+// src/Memory/SharedInt32.ts
+function Int32(value) {
+  if (!Number.isInteger(value) || value < -2147483648 || value > 2147483647) {
+    throw new RangeError("cannot cast value to int32");
+  }
+  return value;
+}
+var SharedInt32 = class _SharedInt32 extends SharedPrimitive {
+  static byteSize = 4;
+  static fromData(heap, v) {
+    let addr = heap.allocate(_SharedInt32.byteSize, _SharedInt32.typeID);
+    let obj = new _SharedInt32(heap, addr);
+    obj.value = v;
+    return obj;
+  }
+  set value(v) {
+    this._heap.view.setInt32(this._addr, Int32(v));
+  }
+  get value() {
+    return this._heap.view.getInt32(this._addr);
+  }
+};
+TypeRegistry.registerType(SharedInt32);
+
+// src/Memory/SharedStruct.ts
+var SharedStruct = class _SharedStruct extends SharedReference {
+  static fromData(heap, param) {
+    let addr = heap.allocate(this.byteSize, this.typeID);
+    let obj = new this(heap, addr);
+    obj.imprint(param);
+    return obj;
+  }
+  static properties;
+  _byteSize = 0;
+  properties = {};
+  constructor(heap, addr) {
+    super(heap, addr);
+    const prop = this.constructor.properties;
+    for (let key in prop) {
+      let dataDeclaration = prop[key];
+      let dataType = dataDeclaration.type;
+      let params = dataDeclaration.param;
+      let data;
+      let propSize;
+      if (SharedPrimitive.isPrototypeOf(dataType)) {
+        dataType = dataType;
+        if (dataType == SharedPointer) {
+          data = new SharedPointer(heap, addr + this._byteSize, params.type);
+          propSize = SharedPointer.byteSize;
+        } else {
+          data = new dataType(heap, addr + this._byteSize);
+          if (params !== void 0) data.value = params;
+          propSize = dataType.byteSize;
+        }
+      } else if ("type" in dataDeclaration && "param" in dataDeclaration) {
+        data = dataDeclaration.type.fromData(heap, dataDeclaration.param);
+        let p = new SharedPointer(heap, addr + this._byteSize, dataDeclaration.type);
+        propSize = SharedPointer.byteSize;
+        p.value = data.addr;
+        data = p;
+      } else {
+        throw new Error("invalid declaration");
+      }
+      this._byteSize += propSize;
+      this.properties[key] = data;
+    }
+    queueMicrotask(() => {
+      Object.preventExtensions(this);
+    });
+    return new Proxy(this, {
+      get(target, prop2, receiver) {
+        if (prop2 in target.properties) {
+          let v = target.properties[prop2];
+          return v;
+        }
+        return Reflect.get(target, prop2, receiver);
+      }
+    });
+  }
+  imprint(obj) {
+    if (obj == void 0) return;
+    for (let key in obj) {
+      if (key in this.properties) {
+        let ref = this.properties[key];
+        if (ref instanceof _SharedStruct) {
+          ref.imprint(obj[key]);
+        } else if (ref instanceof SharedPrimitive) {
+          ref.value = obj[key];
+        }
+      }
+    }
+  }
+  static get byteSize() {
+    let size = 0;
+    let properties = this.properties;
+    for (let key in properties) {
+      let declaration = properties[key];
+      let dataType = declaration.type;
+      if (SharedPrimitive.isPrototypeOf(dataType)) {
+        size += dataType.byteSize;
+      } else {
+        size += SharedPointer.byteSize;
+      }
+    }
+    return size;
+  }
+  get byteSize() {
+    let size = 0;
+    let properties = this.constructor.properties;
+    for (let key in properties) {
+      let declaration = properties[key];
+      let dataType = declaration.type;
+      if (SharedPrimitive.isPrototypeOf(dataType)) {
+        size += dataType.byteSize;
+      } else {
+        size += SharedPointer.byteSize;
+      }
+    }
+    return size;
+  }
+};
+
+// src/Threads/MainThread.ts
+import { threadId, threadName, Worker } from "worker_threads";
+
+// src/Threads/Thread.ts
+import { EventEmitter } from "events";
+import { postMessageToThread } from "worker_threads";
+var Thread = class extends EventEmitter {
+  static async sendToThread(threadId3, data, label = null) {
+    if (!data) return;
+    return postMessageToThread(threadId3, {
+      tag: "message",
+      label,
+      data
+    });
+  }
+  static async transferToThread(threadId3, data, transferList, label = null) {
+    if (!data) return;
+    return postMessageToThread(threadId3, {
+      tag: "message",
+      label,
+      data
+    }, transferList);
+  }
+  port;
+  config;
+  constructor(port, config = {}) {
+    super();
+    this.port = port;
+    this.config = config;
+  }
+  send(data, label = null) {
+    if (!data) return;
+    this.port.postMessage({
+      tag: "message",
+      label,
+      data
+    });
+  }
+  sendWithTransfer(data, transferList, label = null) {
+    if (!data) return;
+    this.port.postMessage({
+      tag: "message",
+      label,
+      data
+    }, transferList);
+  }
+  async request(data, label = null) {
+    if (!data) return;
+    this.port.postMessage({
+      tag: "message",
+      label,
+      data
+    });
+    return new Promise((res, rej) => {
+      const handler = (data2, label2) => {
+        if (label == label2) {
+          res(data2);
+          this.off("message", handler);
+        }
+      };
+      this.on("message", handler);
+      if (this.config.timeout) setTimeout(() => {
+        rej(new Error("failed to receive response"));
+        this.off("message", handler);
+      }, this.config.timeout);
+    });
+  }
+  listenOnce(cb, label = null) {
+    const handler = (data, label2) => {
+      if (label == label2) {
+        cb(data);
+        this.off("message", handler);
+      }
+    };
+    this.on("message", handler);
+  }
+  listenAll(cb, label = null) {
+    this.on("message", (data, label2) => {
+      if (label == label2) {
+        cb(data);
+      }
+    });
+  }
+  respondOnce(cb, label = null) {
+    const handler = (data, label2) => {
+      if (label == label2) {
+        this.send(cb(data), label);
+        this.off("message", handler);
+      }
+    };
+    this.on("message", handler);
+  }
+  respondAll(cb, label = null) {
+    this.on("message", (data, label2) => {
+      if (label == label2) {
+        this.send(cb(data), label);
+      }
+    });
+  }
+  async addHeap(heap, name) {
+    if (heap instanceof SharedArrayBuffer) {
+      heap = new SharedHeap(heap);
+    }
+    const buffer = heap.buffer;
+    this.port.postMessage({
+      tag: "sync",
+      name,
+      buffer,
+      heapID: heap.heapID,
+      rebound: false
+    });
+    return new Promise((res, rej) => {
+      const handler = (name2, buffer2, heapID, rebound) => {
+        if (rebound && name == name2 && buffer2 == null && heapID == heap.heapID) {
+          res();
+          this.off("sync", handler);
+        }
+      };
+      this.on("sync", handler);
+      if (this.config.timeout) setTimeout(() => {
+        rej(new Error("failed to receive response"));
+        this.off("sync", handler);
+      }, this.config.timeout);
+    });
+  }
+  async syncHeap(name) {
+    return new Promise((res, rej) => {
+      const handler = (name2, buffer, heapID, rebound) => {
+        if (!rebound && name == name2) {
+          const heap = new SharedHeap(buffer, heapID);
+          this.port.postMessage({
+            tag: "sync",
+            name,
+            buffer: null,
+            heapID: heap.heapID,
+            rebound: true
+          });
+          this.off("sync", handler);
+          res(heap);
+        }
+      };
+      this.on("sync", handler);
+      if (this.config.timeout) setTimeout(() => {
+        rej(new Error("failed to receive response"));
+        this.off("sync", handler);
+      }, this.config.timeout);
+    });
+  }
+  async addVar(data, name) {
+    let heapID = data.heap.heapID;
+    let addr = data.addr;
+    this.port.postMessage({
+      tag: "assign",
+      name,
+      heapID,
+      addr,
+      rebound: false
+    });
+    return new Promise((res, rej) => {
+      const handler = (name2, heapID2, addr2, rebound) => {
+        if (rebound && name2 == name && heapID2 == heapID && addr2 == addr) {
+          this.off("assign", handler);
+          res();
+        }
+      };
+      this.on("assign", handler);
+      if (this.config.timeout) setTimeout(() => {
+        rej(new Error("failed to receive response"));
+        this.off("assign", handler);
+      }, this.config.timeout);
+    });
+  }
+  async syncVar(name) {
+    return new Promise((res, rej) => {
+      const handler = (name2, heapID, addr, rebound) => {
+        if (!rebound && name2 == name) {
+          let heap = SharedHeap.getHeapByID(heapID);
+          let isArr = heap.getArrayAt(addr);
+          let isPtr = heap.getPtrAt(addr);
+          let dataType = TypeRegistry.getTypeByIndex(heap.getTypeIDAt(addr));
+          let data;
+          if (isArr) {
+            data = new SharedArray(heap, addr);
+          } else if (isPtr) {
+            data = new SharedPointer(heap, addr);
+          } else {
+            data = new dataType(heap, addr);
+          }
+          this.port.postMessage({
+            tag: "assign",
+            name,
+            heapID,
+            addr,
+            rebound: true
+          });
+          res(data);
+          this.off("assign", handler);
+        }
+      };
+      this.on("assign", handler);
+      if (this.config.timeout) setTimeout(() => {
+        rej(new Error("failed to receive response"));
+        this.off("assign", handler);
+      }, this.config.timeout);
+    });
+  }
+};
+
+// src/Threads/MainThread.ts
+import os from "os";
+var MainThread = class extends Thread {
+  static get optimalTypeRegistrys() {
+    return os.availableParallelism();
+  }
+  worker;
+  active = false;
+  constructor(path, config = {}) {
+    config = { ...config };
+    config.workerOptions ??= {};
+    config.workerOptions.transferList ??= [];
+    config.workerOptions.workerData = {
+      config: {
+        timeout: config.timeout,
+        logLevel: config.logLevel
+      },
+      default: config.workerOptions.workerData
+    };
+    if (config.useTypescript) {
+      if (config.workerOptions.execArgv) {
+        config.workerOptions.execArgv.push("--import");
+        config.workerOptions.execArgv.push("tsx");
+      } else {
+        config.workerOptions.execArgv = [...process.execArgv, "--import", "tsx"];
+      }
+    }
+    let typeBuffer = TypeRegistry.getTypeBuffer();
+    config.workerOptions.transferList.push(typeBuffer);
+    config.workerOptions.workerData = {
+      orig: config.workerOptions.workerData,
+      //extra data here for syncing
+      types: typeBuffer
+    };
+    if (path instanceof Function) {
+      path = path.toString();
+      config.workerOptions.eval = true;
+    }
+    let worker = new Worker(path, config.workerOptions);
+    let port = worker;
+    super(port, config);
+    this.worker = worker;
+    this.port.on("message", (msg) => {
+      this.emit("internalmessage", msg);
+      switch (msg.tag) {
+        case "message":
+          this.emit("message", msg.data, msg.label);
+          break;
+        case "sync":
+          this.emit("sync", msg.name, msg.buffer, msg.heapID, msg.rebound);
+          break;
+        case "assign":
+          this.emit("assign", msg.name, msg.heapID, msg.addr, msg.rebound);
+          break;
+      }
+      if (this.config.transient) {
+        this.worker.terminate();
+      }
+    });
+    this.worker.on("error", (err) => {
+      let caught = this.emit("error", err);
+      if (!caught) {
+        this.err(err);
+      }
+    });
+    this.port.on("messageerror", (err) => {
+      let caught = this.emit("messageerror", err);
+      if (!caught) {
+        this.err(err);
+      }
+    });
+    this.worker.on("online", () => {
+      this.emit("online");
+      this.active = true;
+    });
+    this.worker.on("exit", (exitCode) => {
+      this.active = false;
+      this.emit("exit", exitCode);
+    });
+  }
+  async ready() {
+    if (this.active) return;
+    return new Promise((res) => {
+      this.port.once("online", () => {
+        res();
+      });
+    });
+  }
+  terminate() {
+    if (!this.active) this.err("cannot terminate worker(worker is not active)");
+    this.active = false;
+    return this.worker.terminate();
+  }
+  // private log(level: number, msg: string): void{
+  //     ///////TODO
+  //     if(level >= (this.config.logLevel ?? 0)){
+  //         console.log(`${new Date().toTimeString()} - ${threadName}(${threadId}) - ${msg}`);
+  //     }
+  // }
+  err(msg) {
+    throw new Error(`${(/* @__PURE__ */ new Date()).toTimeString()} - ${threadName}(${threadId}) - ${msg}`);
+  }
+  get isActive() {
+    return this.active;
+  }
+  //functions that pass through the call
+  ref() {
+    this.port.ref();
+  }
+  unref() {
+    this.port.unref();
+  }
+  //todo
+  // worker.cpuUsage([prev])
+  // worker.getHeapSnapshot([options])
+  // worker.getHeapStatistics()
+  // worker.performance
+  // worker.stderr
+  // worker.stdin
+  // worker.stdout
+};
+
+// src/Threads/WorkerThread.ts
+import { parentPort, threadName as threadName2, threadId as threadId2, workerData } from "worker_threads";
+var WorkerThread = class extends Thread {
+  _workerData = workerData.workerData;
+  constructor() {
+    if (parentPort == null) throw new Error("cannot find parent port");
+    super(parentPort, workerData.config);
+    this._workerData = workerData.default;
+    queueMicrotask(() => {
+      TypeRegistry.verifyTypeBuffer(workerData.types);
+    });
+    this.port.on("message", (msg) => {
+      this.emit("internalmessage", msg);
+      switch (msg.tag) {
+        case "message":
+          this.emit("message", msg.data, msg.label);
+          break;
+        case "sync":
+          this.emit("sync", msg.name, msg.buffer, msg.heapID, msg.rebound);
+          break;
+        case "assign":
+          this.emit("assign", msg.name, msg.heapID, msg.addr, msg.rebound);
+          break;
+      }
+    });
+    this.port.on("messageerror", (err) => {
+      let caught = this.emit("messageerror", err);
+      if (!caught) {
+        this.err(err);
+      }
+    });
+  }
+  get workerData() {
+    return this._workerData;
+  }
+  err(msg) {
+    throw new Error(`${(/* @__PURE__ */ new Date()).toTimeString()} - ${threadName2}(${threadId2}) - ${msg}`);
+  }
+};
+
+// src/Threads/index.ts
+import { isMainThread } from "worker_threads";
+var WorkerThreadExport = isMainThread ? WorkerThread : new WorkerThread();
+export {
+  Int32,
+  MainThread,
+  SharedArray,
+  SharedHeap,
+  SharedInt32,
+  SharedPointer,
+  SharedPrimitive,
+  SharedReference,
+  SharedStruct,
+  SharedType,
+  SharedUint32,
+  Thread,
+  TypeRegistry,
+  Uint32,
+  WorkerThreadExport as WorkerThread,
+  isMainThread2 as isMainThread
+};