@daugasauron/dolly 0.1.4 → 0.1.5

package/dist/dolly-process-dso.mjs

@@ -1,13 +1,15 @@
 // dist/dolly-process-abi.mjs
-var DOLLY_PROCESS_ABI_DIGEST = "8002d2ac9e15e7d366e3eae77fdb1c61ac7650239792dc0c1ca64b7a1c3f4730";
+var DOLLY_PROCESS_ABI_DIGEST = "36d9bdf963bcc094b53c3b7e44f244aeb2e9213d99a729a90fd01b2f9a368c5f";
 
 // host/dso/abi.mjs
 var DOLLY_DSO_OPEN = 112;
 var DOLLY_DSO_SYMBOL = 113;
 var DOLLY_DSO_CLOSE = 114;
+var DOLLY_DSO_WAIT = 115;
 var DOLLY_DSO_GLOBAL = 1;
 var DOLLY_DSO_LIMIT = 536870912;
 var DOLLY_DSO_ERROR_CAPACITY = 240;
+var DOLLY_DSO_THREADS_SIZE = 272;
 var DOLLY_FFI_CALL = 120;
 var DOLLY_FFI_CLOSURE_ALLOC = 121;
 var DOLLY_FFI_CLOSURE_FREE = 122;
@@ -387,9 +389,10 @@ var DOLLY_HOST_MAX_RECORDS = 64;
 // src/snapshot-records.mjs
 var decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 var MAX_SNAPSHOT_BYTES = 2 * 1024 * 1024 * 1024;
+var MAX_SNAPSHOT_PACKS = MAX_SNAPSHOT_BYTES / (1024 * 1024);
 
 // src/version.mjs
-var DOLLY_VERSION = "0.1.4";
+var DOLLY_VERSION = "0.1.5";
 
 // src/static-asset.mjs
 var STATIC_PART_BYTES = 20 * 1024 * 1024;
@@ -588,7 +591,8 @@ function createProcessFfi({
   getTable,
   growTable: growTable2,
   setTable: setTable2,
-  castEmulationParameters: castEmulationParameters2 = 0
+  castEmulationParameters: castEmulationParameters2 = 0,
+  change = (operation, values, apply) => apply()
 }) {
   if (!(memory instanceof WebAssembly.Memory) || typeof getInstance !== "function" || typeof getTable !== "function" || typeof growTable2 !== "function" || typeof setTable2 !== "function") {
     throw new TypeError("invalid process FFI configuration");
@@ -1089,47 +1093,62 @@ function createProcessFfi({
       return returnByArgument ? void 0 : callbackResult(returnPointer, cif.returnType);
     }, parameters, result);
   }
+  const closureChanges = {
+    [DOLLY_FFI_CLOSURE_ALLOC](closure) {
+      address(closure, 32, "FFI closure");
+      if (closures.has(closure)) throw new TypeError("FFI closure is allocated");
+      const index = freeTableIndices.length === 0 ? growTable2(1n) : freeTableIndices.pop();
+      closures.set(closure, { index, prepared: false });
+      return index;
+    },
+    [DOLLY_FFI_CLOSURE_FREE](closure) {
+      const record = closures.get(closure);
+      if (!record) throw new TypeError("FFI closure is not allocated");
+      setTable2(record.index, null);
+      freeTableIndices.push(record.index);
+      closures.delete(closure);
+      return record.index;
+    },
+    [DOLLY_FFI_CLOSURE_PREP](closure, cifPointer, callbackIndex, userData, code) {
+      const record = closures.get(closure);
+      if (!record || code !== record.index) throw new TypeError("FFI closure is not allocated");
+      setTable2(record.index, prepareClosure(closure, cifInfo(cifPointer), callbackIndex, userData));
+      record.prepared = true;
+      return record.index;
+    }
+  };
+  function changeClosure(operation, values) {
+    return change(operation, values, () => closureChanges[operation](...values));
+  }
   function allocateClosure(request, response) {
     if (request.size !== 8 || response.size < 8) return -BigInt(DOLLY_ERRNO.EINVAL);
     const closure = view(request.address, 8, "FFI closure allocation request").getBigUint64(0, true);
-    address(closure, 32, "FFI closure");
-    if (closures.has(closure)) return -BigInt(DOLLY_ERRNO.EINVAL);
-    const index = freeTableIndices.length === 0 ? growTable2(1n) : freeTableIndices.pop();
-    closures.set(closure, { index, prepared: false });
+    const index = changeClosure(DOLLY_FFI_CLOSURE_ALLOC, [closure]);
     view(response.address, 8, "FFI closure allocation response").setBigUint64(0, index, true);
     return 8n;
   }
   function freeClosure(request) {
     if (request.size !== 8) return -BigInt(DOLLY_ERRNO.EINVAL);
-    const closure = view(request.address, 8, "FFI closure free request").getBigUint64(0, true);
-    const record = closures.get(closure);
-    if (!record) return -BigInt(DOLLY_ERRNO.EINVAL);
-    setTable2(record.index, null);
-    freeTableIndices.push(record.index);
-    closures.delete(closure);
+    changeClosure(DOLLY_FFI_CLOSURE_FREE, [view(request.address, 8, "FFI closure free request").getBigUint64(0, true)]);
     return 0n;
   }
   function configureClosure(request) {
     if (request.size !== 40) return -BigInt(DOLLY_ERRNO.EINVAL);
     const packet = view(request.address, 40, "FFI closure preparation request");
-    const closure = packet.getBigUint64(0, true);
-    const cifPointer = packet.getBigUint64(8, true);
-    const callbackIndex = packet.getBigUint64(16, true);
-    const userData = packet.getBigUint64(24, true);
-    const code = packet.getBigUint64(32, true);
-    const record = closures.get(closure);
-    if (!record || code !== record.index) return -BigInt(DOLLY_ERRNO.EINVAL);
-    const cif = cifInfo(cifPointer);
-    const wrapper = prepareClosure(closure, cif, callbackIndex, userData);
-    setTable2(record.index, wrapper);
-    writePointer(closure, 0, record.index);
+    const values = [0, 8, 16, 24, 32].map((offset) => packet.getBigUint64(offset, true));
+    const [closure, cifPointer, callbackIndex, userData] = values;
+    const index = changeClosure(DOLLY_FFI_CLOSURE_PREP, values);
+    writePointer(closure, 0, index);
     writePointer(closure, 8, cifPointer);
     writePointer(closure, 16, callbackIndex);
     writePointer(closure, 24, userData);
-    record.prepared = true;
     return BigInt(FFI_OK);
   }
   return Object.freeze({
+    // Repeats another thread's closure change: the table index it gave.
+    repeat(operation, values) {
+      return closureChanges[operation](...values);
+    },
     handles(operation) {
       return localOperations.has(operation);
     },
@@ -1210,7 +1229,7 @@ function validateDsoInterface(contract, dso, digest) {
       throw new TypeError(`shared-object import is outside the process namespace: ${entry.module}.${entry.name}`);
     }
   }
-  for (const name of ["__wasm_apply_data_relocs", "__wasm_call_ctors"]) {
+  for (const name of ["__wasm_apply_data_relocs", "__wasm_call_ctors", "__wasm_init_tls", "__tls_size", "__tls_align"]) {
     if (exports.has(name)) requireDsoType(
       exports.get(name).type,
       contract.exports.find((entry) => entry.name === name).type,
@@ -1220,8 +1239,173 @@ function validateDsoInterface(contract, dso, digest) {
   return { imports, exports };
 }
 
+// host/dso/threads.mjs
+var LOCK = 0;
+var COUNT = 1;
+var RECORDS = 1;
+var CAPACITY = 4;
+var SLOTS = 5;
+var SLOT_COUNT = DOLLY_DSO_THREADS_SIZE / 4 - SLOTS;
+var TAKEN = 1 << 31;
+var WAITING = 1 << 30;
+var APPLIED = WAITING - 1;
+var RECORD_SIZE = 48;
+var FIRST_CAPACITY = 64;
+var ThreadRecordError = class extends Error {
+};
+function createThreadRecords({ memory, address, allocate, apply }) {
+  let words, bigWords;
+  function view() {
+    if (words?.buffer !== memory.buffer) {
+      words = new Int32Array(memory.buffer, Number(address), DOLLY_DSO_THREADS_SIZE / 4);
+      bigWords = new BigInt64Array(memory.buffer, Number(address), 2);
+    }
+    return words;
+  }
+  let slot = -1, applied = 0, waiting = true, applying = false, locks = 0;
+  for (let index = 0; slot < 0 && index < SLOT_COUNT; ++index) {
+    if (Atomics.compareExchange(view(), SLOTS + index, 0, TAKEN | WAITING) === 0) slot = index;
+  }
+  if (slot < 0) throw new RangeError("dso@0 has no room for another thread");
+  function publishState() {
+    Atomics.store(view(), SLOTS + slot, TAKEN | (waiting ? WAITING : 0) | applied);
+    Atomics.notify(view(), SLOTS + slot);
+  }
+  function recordView(array, index) {
+    return new DataView(memory.buffer, Number(array) + index * RECORD_SIZE, RECORD_SIZE);
+  }
+  function readRecord(array, index) {
+    const data = recordView(array, index);
+    return {
+      kind: data.getUint32(0, true),
+      word: data.getUint32(4, true),
+      values: [8, 16, 24, 32, 40].map((offset) => data.getBigUint64(offset, true))
+    };
+  }
+  function synchronize() {
+    if (applying) return;
+    applying = true;
+    try {
+      for (let count; applied < (count = Atomics.load(view(), COUNT)); ) {
+        const array = Atomics.load(bigWords, RECORDS);
+        const records = Array.from({ length: count - applied }, (_, index) => readRecord(array, applied + index));
+        records.forEach((_, index) => {
+          try {
+            apply(records, index);
+          } catch (error) {
+            throw error instanceof ThreadRecordError ? error : new ThreadRecordError(`dso@0: this thread could not make another's change: ${error.message}`, { cause: error });
+          }
+          ++applied;
+          publishState();
+        });
+      }
+    } finally {
+      applying = false;
+    }
+  }
+  function enterHost() {
+    waiting = true;
+    publishState();
+  }
+  function leaveHost() {
+    waiting = false;
+    publishState();
+    synchronize();
+  }
+  function awaitApplied(target) {
+    enterHost();
+    for (let index = 0; index < SLOT_COUNT; ++index) {
+      if (index === slot) continue;
+      for (; ; ) {
+        const state = Atomics.load(view(), SLOTS + index);
+        if (!(state & TAKEN) || state & WAITING || (state & APPLIED) >= target) break;
+        Atomics.wait(view(), SLOTS + index, state);
+      }
+    }
+    leaveHost();
+  }
+  function reserve() {
+    const count = Atomics.load(view(), COUNT), current = view()[CAPACITY];
+    if (count < current) return;
+    const capacity = current === 0 ? FIRST_CAPACITY : current * 2;
+    const grown = allocate(BigInt(capacity * RECORD_SIZE), 8n);
+    if (!grown) throw new RangeError("process could not reserve dso@0's thread records");
+    if (count !== 0) {
+      new Uint8Array(memory.buffer, Number(grown), count * RECORD_SIZE).set(new Uint8Array(memory.buffer, Number(Atomics.load(bigWords, RECORDS)), count * RECORD_SIZE));
+    }
+    Atomics.store(bigWords, RECORDS, grown);
+    view()[CAPACITY] = capacity;
+  }
+  function publish({ kind, word = 0, values }, acknowledged) {
+    const count = Atomics.load(view(), COUNT);
+    const data = recordView(Atomics.load(bigWords, RECORDS), count);
+    data.setUint32(0, kind, true);
+    data.setUint32(4, word, true);
+    values.forEach((value, index) => data.setBigUint64(8 + index * 8, value, true));
+    applied = count + 1;
+    publishState();
+    Atomics.store(view(), COUNT, applied);
+    if (acknowledged) awaitApplied(applied);
+  }
+  function lock() {
+    if (locks++) return;
+    const owner = slot + 1;
+    if (Atomics.compareExchange(view(), LOCK, 0, owner) === 0) return;
+    enterHost();
+    for (let holder; (holder = Atomics.compareExchange(view(), LOCK, 0, owner)) !== 0; ) {
+      Atomics.wait(view(), LOCK, holder);
+    }
+    leaveHost();
+  }
+  function unlock() {
+    if (--locks) return;
+    Atomics.store(view(), LOCK, 0);
+    Atomics.notify(view(), LOCK, 1);
+  }
+  return {
+    synchronize,
+    // run(publish) changes this Worker's table and publishes the record of
+    // the change; one change at a time in the process.
+    change(run) {
+      lock();
+      try {
+        synchronize();
+        reserve();
+        return run(publish);
+      } finally {
+        unlock();
+      }
+    },
+    // A wait for the host's answer, during which no change waits for this
+    // thread: it applies them before it returns.
+    awaitHost(run) {
+      enterHost();
+      const result = run();
+      leaveHost();
+      return result;
+    },
+    // A futex wait on the 32-bit word at address, or none: Atomics.wait's outcome.
+    wait(wordAddress, value, milliseconds) {
+      if (wordAddress === 0) {
+        leaveHost();
+        return "ok";
+      }
+      enterHost();
+      const outcome = Atomics.wait(new Int32Array(memory.buffer, wordAddress, 1), 0, value, milliseconds);
+      leaveHost();
+      return outcome;
+    },
+    // The thread ends: no change waits for it again.
+    leaving() {
+      Atomics.store(view(), SLOTS + slot, 0);
+      Atomics.notify(view(), SLOTS + slot);
+    }
+  };
+}
+
 // host/dso/process.mjs
 var DSO_RESPONSE_SIZE = 16 + DOLLY_DSO_ERROR_CAPACITY;
+var LOAD_FAILED = 2147483648;
 var encoder = new TextEncoder();
 var decoder3 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 var configuration;
@@ -1233,6 +1417,8 @@ var nextDsoHandle = 2n;
 var loadedDsos = /* @__PURE__ */ new Map();
 var globalDsos = [];
 var functionIndices = /* @__PURE__ */ new WeakMap();
+var threadRecords;
+var ffi;
 function dylinkRequirements(module) {
   const sections = WebAssembly.Module.customSections(module, "dylink.0");
   if (sections.length !== 1) throw new TypeError("shared object needs one dylink.0 section");
@@ -1264,7 +1450,9 @@ function dylinkRequirements(module) {
         const moduleName = section2.string();
         const symbolName = section2.string();
         const flags = section2.unsigned(32);
-        if ((flags & 3n) === 1n) weakImports.add(`${moduleName}\0${symbolName}`);
+        if ((flags & 3n) !== 1n) continue;
+        weakImports.add(`${moduleName}\0${symbolName}`);
+        if (moduleName === "env") for (const got of ["GOT.func", "GOT.mem"]) weakImports.add(`${got}\0${symbolName}`);
       }
     }
   }
@@ -1316,16 +1504,34 @@ function symbolAddress({ value }) {
   }
   throw new TypeError("symbol is not a callable or data address");
 }
+function gotAddress(relocation, symbol) {
+  if (relocation.module === "GOT.mem" && processSymbols.get(relocation.name) === symbol) {
+    const name = relocation.name;
+    const wrapper = processSymbols.get(name.startsWith("_Z") ? `_ZTW${name.slice(2)}` : `_ZTW${name.length}${name}`);
+    if (typeof wrapper?.value === "function") return BigInt(wrapper.value());
+  }
+  return symbolAddress(symbol);
+}
 function aligned(value, power) {
   const alignment = 1n << power;
   return value + alignment - 1n & -alignment;
 }
-function instantiateDso(bytes, flags) {
+function initializeThreadLocals(exports) {
+  if (exports.__tls_size.value === 0n) return;
+  const block = instance.exports.__dolly_dso_allocate(exports.__tls_size.value, exports.__tls_align.value);
+  if (!block) throw new RangeError("process could not reserve a shared object's thread-locals");
+  exports.__wasm_init_tls(block);
+}
+function instantiateDso(bytes, flags, placement = {}) {
+  const first = placement.tableBase === void 0;
   bytes = bytes.slice();
   const contract = configuration.contract;
   const source = parseWasmInterface(bytes);
   const parsed = validateDsoInterface(contract, source, DOLLY_PROCESS_ABI_DIGEST);
   checkHostAbi(executableHostRequirements(source), configuration.hostAbi);
+  if (threadRecords && !["__wasm_init_tls", "__tls_size", "__tls_align"].every((name) => parsed.exports.has(name))) {
+    throw new TypeError("shared object exports no __wasm_init_tls for other threads: link it again with this cc");
+  }
   const module = new WebAssembly.Module(bytes);
   const requirements = dylinkRequirements(module);
   if (requirements.needed.length !== 0) {
@@ -1335,6 +1541,7 @@ function instantiateDso(bytes, flags) {
   }
   const currentTable = processTable.length;
   const tableBase = aligned(currentTable, requirements.tableAlignment);
+  if (!first && placement.tableBase !== tableBase) throw new Error("dso@0: this thread's table is not the loading thread's");
   const infrastructure = new Map(contract.imports.filter((entry) => entry.module === "env").map((entry) => [entry.name, entry.type]));
   infrastructure.set("memory", {
     ...configuration.processInterface.imports.find((entry) => entry.type.kind === "memory").type,
@@ -1364,14 +1571,16 @@ function instantiateDso(bytes, flags) {
     bindings.set(key, symbol);
   }
   const memoryAlignment = 1n << requirements.memoryAlignment;
-  const memoryBase = instance.exports.__dolly_dso_allocate(
+  const memoryBase = first ? instance.exports.__dolly_dso_allocate(
     requirements.memorySize,
     memoryAlignment
-  );
+  ) : placement.memoryBase;
   if (typeof memoryBase !== "bigint" || memoryBase === 0n) {
     throw new RangeError("process could not reserve shared-object memory");
   }
+  if (first) Object.assign(placement, { memoryBase, bytes: placement.keep?.(bytes) });
   growTable(tableBase - currentTable + requirements.tableSize);
+  placement.tableBase = tableBase;
   const imports = {
     env: Object.assign(/* @__PURE__ */ Object.create(null), {
       memory: configuration.memory,
@@ -1426,7 +1635,7 @@ function instantiateDso(bytes, flags) {
   for (const relocation of relocations) {
     if (parsed.exports.has(relocation.name)) continue;
     const existing = globalSymbol(relocation.name);
-    if (existing !== void 0) relocation.global.value = symbolAddress(existing);
+    if (existing !== void 0) relocation.global.value = gotAddress(relocation, existing);
   }
   dsoInstance = new WebAssembly.Instance(module, imports);
   dsoSymbols = typedSymbols(parsed.exports.values(), dsoInstance.exports, memoryBase);
@@ -1436,7 +1645,7 @@ function instantiateDso(bytes, flags) {
   }
   for (const relocation of relocations) {
     const symbol = dsoSymbols.get(relocation.name) ?? globalSymbol(relocation.name);
-    if (symbol !== void 0) relocation.global.value = symbolAddress(symbol);
+    if (symbol !== void 0) relocation.global.value = gotAddress(relocation, symbol);
     else if (relocation.weak) {
       relocation.global.value = 0n;
     } else {
@@ -1444,14 +1653,106 @@ function instantiateDso(bytes, flags) {
     }
   }
   const applyDataRelocations = dsoInstance.exports.__wasm_apply_data_relocs;
-  if (applyDataRelocations !== void 0) applyDataRelocations();
+  if (!first) initializeThreadLocals(dsoInstance.exports);
+  else if (applyDataRelocations !== void 0) applyDataRelocations();
   const handle = nextDsoHandle++;
   const record = { handle, module, instance: dsoInstance, symbols: dsoSymbols, flags, references: 1 };
   loadedDsos.set(handle, record);
   if ((flags & DOLLY_DSO_GLOBAL) !== 0) globalDsos.push(record);
-  const constructors = dsoInstance.exports.__wasm_call_ctors;
+  return record;
+}
+function construct(dso) {
+  const constructors = dso.instance.exports.__wasm_call_ctors;
   if (constructors !== void 0) constructors();
-  return handle;
+  return dso.handle;
+}
+function memoryBytes(address, size) {
+  return new Uint8Array(configuration.memory.buffer, Number(address), Number(size));
+}
+function keep(bytes) {
+  const copy = instance.exports.__dolly_dso_allocate(BigInt(bytes.length), 1n);
+  if (!copy) throw new RangeError("process could not keep a shared object for its threads");
+  memoryBytes(copy, bytes.length).set(bytes);
+  return copy;
+}
+function openDsoForThreads(bytes, flags) {
+  return threadRecords.change((publish) => {
+    const placement = { keep };
+    const record = (word) => ({
+      kind: DOLLY_DSO_OPEN,
+      word,
+      values: [placement.bytes, BigInt(bytes.length), placement.memoryBase, placement.tableBase, 0n]
+    });
+    let dso;
+    try {
+      dso = instantiateDso(bytes, flags, placement);
+    } catch (error) {
+      if (placement.tableBase !== void 0) publish(record(flags | LOAD_FAILED));
+      throw error;
+    }
+    publish(record(flags), true);
+    return construct(dso);
+  });
+}
+function lookupSymbol(handle, name) {
+  if (handle === 0n) return globalSymbol(name);
+  if (handle === 1n) return processSymbols.get(name);
+  return loadedDsos.get(handle)?.symbols.get(name);
+}
+function symbolIndex(handle, name, value) {
+  if (!threadRecords || typeof value.value !== "function") return symbolAddress(value);
+  return threadRecords.change((publish) => {
+    const indexed = functionIndices.get(value.value);
+    if (indexed !== void 0) return indexed;
+    const bytes = encoder.encode(name);
+    const copy = keep(bytes);
+    const index = functionIndex(value.value);
+    publish({ kind: DOLLY_DSO_SYMBOL, values: [handle, copy, BigInt(bytes.length), index, 0n] }, true);
+    return index;
+  });
+}
+var divergence = () => new ThreadRecordError("dso@0: this thread's table is not the one that changed it");
+function freedLater(records, index, closure) {
+  for (let later = index + 1; later < records.length; ++later) {
+    if (records[later].kind === DOLLY_FFI_CLOSURE_FREE && records[later].values[0] === closure) return true;
+  }
+  return false;
+}
+function applyRecord(records, index) {
+  const { kind, word, values } = records[index];
+  if (kind === DOLLY_DSO_OPEN) {
+    const [bytes, size, memoryBase, tableBase] = values;
+    try {
+      instantiateDso(memoryBytes(bytes, size), word & ~LOAD_FAILED, { memoryBase, tableBase });
+    } catch (error) {
+      if (word & LOAD_FAILED) return;
+      throw error;
+    }
+    if (word & LOAD_FAILED) throw divergence();
+  } else if (kind === DOLLY_DSO_SYMBOL) {
+    const [handle, name, size, index2] = values;
+    const value = lookupSymbol(handle, decoder3.decode(Uint8Array.from(memoryBytes(name, size))));
+    if (typeof value?.value !== "function" || functionIndex(value.value) !== index2) throw divergence();
+  } else if (kind === DOLLY_FFI_CLOSURE_PREP && freedLater(records, index, values[0])) {
+    return;
+  } else if (ffi.handles(kind) && kind !== DOLLY_FFI_CALL) {
+    if (ffi.repeat(kind, values) !== BigInt(word)) throw divergence();
+  } else {
+    throw new TypeError(`dso@0 has no thread record of kind ${kind}`);
+  }
+}
+function futexWait(request) {
+  if (request.size !== 24) return -BigInt(DOLLY_ERRNO.EINVAL);
+  const packet = new DataView(configuration.memory.buffer, request.address, 24);
+  const address = packet.getBigUint64(0, true), timeout = packet.getBigInt64(16, true);
+  if (packet.getUint32(12, true) !== 0 || address % 4n !== 0n) return -BigInt(DOLLY_ERRNO.EINVAL);
+  if (address > BigInt(configuration.memory.buffer.byteLength - 4)) return -BigInt(DOLLY_ERRNO.EFAULT);
+  const outcome = threadRecords.wait(
+    Number(address),
+    packet.getUint32(8, true) | 0,
+    timeout < 0n ? Infinity : Number(timeout) / 1e6
+  );
+  return outcome === "ok" ? 0n : -BigInt(outcome === "not-equal" ? DOLLY_ERRNO.EAGAIN : DOLLY_ERRNO.ETIMEDOUT);
 }
 function writeDsoResponse(response, value = 0n, error = 0, message = "") {
   if (response.size < DSO_RESPONSE_SIZE) return -BigInt(DOLLY_ERRNO.ENOBUFS);
@@ -1497,10 +1798,8 @@ function processDsoCall(operation, request, response) {
       if ((flags & ~DOLLY_DSO_GLOBAL) !== 0 || reserved !== 0 || size !== BigInt(request.size - 16) || size > BigInt(DOLLY_DSO_LIMIT)) {
         throw new TypeError("invalid DSO_OPEN packet");
       }
-      const handle = size === 0n ? 1n : instantiateDso(
-        new Uint8Array(configuration.memory.buffer, request.address + 16, Number(size)),
-        flags
-      );
+      const bytes = new Uint8Array(configuration.memory.buffer, request.address + 16, Number(size));
+      const handle = size === 0n ? 1n : threadRecords ? openDsoForThreads(bytes, flags) : construct(instantiateDso(bytes, flags));
       return writeDsoResponse(response, handle);
     }
     if (operation === DOLLY_DSO_SYMBOL) {
@@ -1513,18 +1812,14 @@ function processDsoCall(operation, request, response) {
         request.address + 16,
         nameSize
       )));
-      let value;
-      if (handle === 0n) value = globalSymbol(name);
-      else if (handle === 1n) value = processSymbols.get(name);
-      else {
-        const dso = loadedDsos.get(handle);
-        if (!dso) return writeDsoResponse(response, 0n, DOLLY_ERRNO.EBADF, "invalid DSO handle");
-        value = dso.symbols.get(name);
+      if (handle > 1n && !loadedDsos.has(handle)) {
+        return writeDsoResponse(response, 0n, DOLLY_ERRNO.EBADF, "invalid DSO handle");
       }
+      const value = lookupSymbol(handle, name);
       if (value === void 0) {
         return writeDsoResponse(response, 0n, DOLLY_ERRNO.ENOENT, `undefined symbol: ${name}`);
       }
-      return writeDsoResponse(response, symbolAddress(value));
+      return writeDsoResponse(response, symbolIndex(handle, name, value));
     }
     if (operation === DOLLY_DSO_CLOSE) {
       if (request.size !== 8) throw new TypeError("invalid DSO_CLOSE packet");
@@ -1537,6 +1832,7 @@ function processDsoCall(operation, request, response) {
     }
     return writeDsoResponse(response, 0n, DOLLY_ERRNO.ENOSYS, "unknown process-local operation");
   } catch (error) {
+    if (error instanceof ThreadRecordError) throw error;
     return writeDsoResponse(
       response,
       0n,
@@ -1550,24 +1846,57 @@ function serve(context) {
   instance = context.instance;
   processTable = instance.exports.__indirect_function_table;
   processSymbols = typedSymbols(configuration.processInterface.exports, instance.exports);
-  const ffi = createProcessFfi({
+  const threads = processSymbols.get("__dolly_dso_threads");
+  if (context.threaded && threads && typeof instance.exports.__dolly_dso_allocate === "function") {
+    requireDsoType(
+      threads.type,
+      context.contract.exports.find((entry) => entry.name === "__dolly_dso_threads").type,
+      "__dolly_dso_threads"
+    );
+    const address = threads.value.value;
+    if (address === 0n || address > BigInt(context.memory.buffer.byteLength - DOLLY_DSO_THREADS_SIZE)) {
+      throw new RangeError("__dolly_dso_threads is outside the process memory");
+    }
+    threadRecords = createThreadRecords({
+      memory: context.memory,
+      address,
+      apply: applyRecord,
+      allocate: (size, alignment) => instance.exports.__dolly_dso_allocate(size, alignment)
+    });
+  }
+  ffi = createProcessFfi({
     memory: configuration.memory,
     getInstance: () => instance,
     getTable: () => processTable,
     growTable,
     setTable,
-    castEmulationParameters: context.processInterface.castEmulationParameters
+    castEmulationParameters: context.processInterface.castEmulationParameters,
+    change: threadRecords && ((operation, values, apply) => threadRecords.change((publish) => {
+      const index = apply();
+      publish(
+        { kind: operation, word: Number(index), values: [...values, 0n, 0n, 0n, 0n].slice(0, 5) },
+        operation === DOLLY_FFI_CLOSURE_PREP
+      );
+      return index;
+    }))
   });
-  const callsOnly = context.threaded || context.processInterface.castEmulationParameters > 0;
+  const callsOnly = context.threaded && !threadRecords || context.processInterface.castEmulationParameters > 0;
   const refusal = (operation, response) => ffi.handles(operation) ? -BigInt(DOLLY_ERRNO.ENOTSUP) : writeDsoResponse(
     response,
     0n,
     DOLLY_ERRNO.ENOTSUP,
-    context.threaded ? "not in a program using threads@0" : "not in a cast-emulated program"
+    context.threaded ? "not in a program using threads@0 without -rdynamic" : "not in a cast-emulated program"
   );
   return {
-    handles: (operation) => operation >= DOLLY_DSO_OPEN && operation <= DOLLY_DSO_CLOSE || ffi.handles(operation),
-    call: (operation, request, response) => callsOnly && operation !== DOLLY_FFI_CALL ? refusal(operation, response) : ffi.handles(operation) ? ffi.call(operation, request, response) : processDsoCall(operation, request, response)
+    handles: (operation) => operation >= DOLLY_DSO_OPEN && operation <= DOLLY_DSO_WAIT || ffi.handles(operation),
+    call(operation, request, response) {
+      if (operation === DOLLY_DSO_WAIT) return threadRecords ? futexWait(request) : -BigInt(DOLLY_ERRNO.ENOTSUP);
+      if (callsOnly && operation !== DOLLY_FFI_CALL) return refusal(operation, response);
+      threadRecords?.synchronize();
+      return ffi.handles(operation) ? ffi.call(operation, request, response) : processDsoCall(operation, request, response);
+    },
+    awaitHost: threadRecords?.awaitHost,
+    leaving: threadRecords?.leaving
   };
 }
 export {