@daugasauron/dolly 0.0.0-stage → 0.1.4-rc.1

package/dist/dolly-process-dso.mjs

@@ -0,0 +1,1575 @@
+// dist/dolly-process-abi.mjs
+var DOLLY_PROCESS_ABI_DIGEST = "8002d2ac9e15e7d366e3eae77fdb1c61ac7650239792dc0c1ca64b7a1c3f4730";
+
+// host/dso/abi.mjs
+var DOLLY_DSO_OPEN = 112;
+var DOLLY_DSO_SYMBOL = 113;
+var DOLLY_DSO_CLOSE = 114;
+var DOLLY_DSO_GLOBAL = 1;
+var DOLLY_DSO_LIMIT = 536870912;
+var DOLLY_DSO_ERROR_CAPACITY = 240;
+var DOLLY_FFI_CALL = 120;
+var DOLLY_FFI_CLOSURE_ALLOC = 121;
+var DOLLY_FFI_CLOSURE_FREE = 122;
+var DOLLY_FFI_CLOSURE_PREP = 123;
+var DOLLY_ERRNO = Object.freeze({ E2BIG: 1, EACCES: 2, EADDRINUSE: 3, EADDRNOTAVAIL: 4, EAFNOSUPPORT: 5, EAGAIN: 6, EALREADY: 7, EBADF: 8, EBADMSG: 9, EBUSY: 10, ECANCELED: 11, ECHILD: 12, ECONNABORTED: 13, ECONNREFUSED: 14, ECONNRESET: 15, EDEADLK: 16, EDESTADDRREQ: 17, EDOM: 18, EDQUOT: 19, EEXIST: 20, EFAULT: 21, EFBIG: 22, EHOSTUNREACH: 23, EIDRM: 24, EILSEQ: 25, EINPROGRESS: 26, EINTR: 27, EINVAL: 28, EIO: 29, EISCONN: 30, EISDIR: 31, ELOOP: 32, EMFILE: 33, EMLINK: 34, EMSGSIZE: 35, EMULTIHOP: 36, ENAMETOOLONG: 37, ENETDOWN: 38, ENETRESET: 39, ENETUNREACH: 40, ENFILE: 41, ENOBUFS: 42, ENODEV: 43, ENOENT: 44, ENOEXEC: 45, ENOLCK: 46, ENOLINK: 47, ENOMEM: 48, ENOMSG: 49, ENOPROTOOPT: 50, ENOSPC: 51, ENOSYS: 52, ENOTCONN: 53, ENOTDIR: 54, ENOTEMPTY: 55, ENOTRECOVERABLE: 56, ENOTSOCK: 57, ENOTTY: 59, ENXIO: 60, EOVERFLOW: 61, EOWNERDEAD: 62, EPERM: 63, EPIPE: 64, EPROTO: 65, EPROTONOSUPPORT: 66, EPROTOTYPE: 67, ERANGE: 68, EROFS: 69, ESPIPE: 70, ESRCH: 71, ESTALE: 72, ETIMEDOUT: 73, ETXTBSY: 74, EXDEV: 75, ENODATA: 116, ENOTSUP: 138 });
+
+// src/wasm-interface.mjs
+var decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+var valueTypes = /* @__PURE__ */ new Map([
+  [127, "i32"],
+  [126, "i64"],
+  [125, "f32"],
+  [124, "f64"],
+  [123, "v128"],
+  [112, "funcref"],
+  [111, "externref"],
+  [105, "exnref"],
+  [116, "nullexnref"]
+]);
+var Reader = class _Reader {
+  constructor(bytes, label = "WebAssembly binary") {
+    this.bytes = bytes;
+    this.offset = 0;
+    this.label = label;
+  }
+  get done() {
+    return this.offset === this.bytes.length;
+  }
+  fail(message) {
+    throw new Error(`${this.label} at byte ${this.offset}: ${message}`);
+  }
+  u8() {
+    if (this.offset >= this.bytes.length) this.fail("unexpected end of file");
+    return this.bytes[this.offset++];
+  }
+  take(length) {
+    if (!Number.isSafeInteger(length) || length < 0 || this.offset + length > this.bytes.length) {
+      this.fail(`invalid byte range of length ${length}`);
+    }
+    const result = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return result;
+  }
+  subreader(length, label) {
+    return new _Reader(this.take(length), label);
+  }
+  unsigned(bits = 32) {
+    let result = 0n;
+    let shift = 0n;
+    const limit = Math.ceil(bits / 7);
+    for (let index = 0; index < limit; index += 1) {
+      const byte = this.u8();
+      result |= BigInt(byte & 127) << shift;
+      if ((byte & 128) === 0) {
+        if (result >= 1n << BigInt(bits)) this.fail(`unsigned LEB exceeds ${bits} bits`);
+        return result;
+      }
+      shift += 7n;
+    }
+    this.fail(`unterminated unsigned ${bits}-bit LEB`);
+  }
+  signed(bits = 32) {
+    let result = 0n;
+    let shift = 0n;
+    let byte = 0;
+    const limit = Math.ceil(bits / 7);
+    for (let index = 0; index < limit; index += 1) {
+      byte = this.u8();
+      result |= BigInt(byte & 127) << shift;
+      shift += 7n;
+      if ((byte & 128) === 0) {
+        if ((byte & 64) !== 0 && shift < BigInt(bits)) result |= -1n << shift;
+        return result;
+      }
+    }
+    this.fail(`unterminated signed ${bits}-bit LEB`);
+  }
+  u32() {
+    return Number(this.unsigned(32));
+  }
+  string() {
+    const length = this.u32();
+    try {
+      return decoder.decode(this.take(length));
+    } catch {
+      this.fail("invalid UTF-8 string");
+    }
+  }
+};
+function readValueType(reader) {
+  const byte = reader.u8();
+  const type = valueTypes.get(byte);
+  if (!type) reader.fail(`unsupported value type 0x${byte.toString(16)}`);
+  return type;
+}
+function readVector(reader, readElement, result = []) {
+  const count = reader.u32();
+  if (count > reader.bytes.length - reader.offset) reader.fail("vector count exceeds section size");
+  for (let index = 0; index < count; index++) result.push(readElement(reader));
+  return result;
+}
+function readLimits(reader) {
+  const flags = reader.u32();
+  if ((flags & ~7) !== 0) reader.fail(`unsupported limits flags 0x${flags.toString(16)}`);
+  const hasMaximum = (flags & 1) !== 0;
+  const shared = (flags & 2) !== 0;
+  const address64 = (flags & 4) !== 0;
+  const readBound = () => reader.unsigned(address64 ? 64 : 32);
+  const minimum = readBound();
+  const maximum = hasMaximum ? readBound() : null;
+  if (shared && maximum === null) reader.fail("shared limits require a maximum");
+  return { minimum, maximum, shared, address64 };
+}
+function readTableType(reader) {
+  return { kind: "table", element: readValueType(reader), ...readLimits(reader) };
+}
+function readMemoryType(reader) {
+  return { kind: "memory", ...readLimits(reader) };
+}
+function readGlobalType(reader) {
+  return { kind: "global", value: readValueType(reader), mutable: reader.u8() !== 0 };
+}
+function readTagType(reader, types) {
+  const attribute = reader.u32();
+  return { kind: "tag", attribute, type: functionType(types, reader.u32(), reader) };
+}
+function skipConstantExpression(reader) {
+  for (; ; ) {
+    const opcode = reader.u8();
+    switch (opcode) {
+      case 11:
+        return;
+      case 65:
+        reader.signed(32);
+        break;
+      case 66:
+        reader.signed(64);
+        break;
+      case 67:
+        reader.take(4);
+        break;
+      case 68:
+        reader.take(8);
+        break;
+      case 35:
+      case 210:
+        reader.u32();
+        break;
+      case 208:
+        readValueType(reader);
+        break;
+      case 106:
+      // i32.add
+      case 107:
+      // i32.sub
+      case 108:
+      // i32.mul
+      case 124:
+      // i64.add
+      case 125:
+      // i64.sub
+      case 126:
+        break;
+      default:
+        reader.fail(`unsupported constant-expression opcode 0x${opcode.toString(16)}`);
+    }
+  }
+}
+function readElementExpression(reader) {
+  const opcode = reader.u8();
+  let index = null;
+  if (opcode === 210) index = reader.u32();
+  else if (opcode === 208) readValueType(reader);
+  else reader.fail(`unsupported element expression opcode 0x${opcode.toString(16)}`);
+  if (reader.u8() !== 11) reader.fail("element expression has more than one instruction");
+  return index;
+}
+function readElementSegment(reader) {
+  const flags = reader.u32();
+  if (flags > 7) reader.fail(`unsupported element segment flags ${flags}`);
+  const active = (flags & 1) === 0;
+  if (flags === 2 || flags === 6) reader.u32();
+  if (active) skipConstantExpression(reader);
+  if (flags & 4) {
+    if (flags !== 4) readValueType(reader);
+    const indices2 = readVector(reader, readElementExpression);
+    return active ? indices2.filter((index) => index !== null) : [];
+  }
+  if (flags !== 0 && reader.u8() !== 0) reader.fail("unsupported element kind");
+  const indices = readVector(reader, (item) => item.u32());
+  return active ? indices : [];
+}
+function castEmulationParameters(tableFunctions) {
+  const [type] = tableFunctions;
+  const thunk = type && type.params.length >= 16 && type.params.every((param) => param === "i64") && type.results.length === 1 && type.results[0] === "i64";
+  return thunk && tableFunctions.every((other) => other === type) ? type.params.length : 0;
+}
+function functionType(types, index, reader) {
+  const type = types[index];
+  if (!type) reader.fail(`function references missing type ${index}`);
+  return type;
+}
+function parseWasmInterface(input, label = "WebAssembly binary") {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const reader = new Reader(bytes, label);
+  const expectedHeader = [0, 97, 115, 109, 1, 0, 0, 0];
+  for (const byte of expectedHeader) {
+    if (reader.u8() !== byte) reader.fail("invalid WebAssembly header");
+  }
+  const types = [];
+  const imports = [];
+  const definedFunctionTypes = [];
+  const importedTables = [];
+  const definedTables = [];
+  const importedMemories = [];
+  const definedMemories = [];
+  const importedGlobals = [];
+  const definedGlobals = [];
+  const importedTags = [];
+  const definedTags = [];
+  const rawExports = [];
+  const tableFunctionIndices = [];
+  const customSections = [];
+  const customSectionData = [];
+  while (!reader.done) {
+    const id = reader.u8();
+    const size = reader.u32();
+    const section2 = reader.subreader(size, `${label} section ${id}`);
+    if (id === 0) {
+      const name = section2.string();
+      customSections.push(name);
+      customSectionData.push({ name, data: section2.take(section2.bytes.length - section2.offset) });
+    } else if (id === 1) {
+      readVector(section2, (item) => {
+        if (item.u8() !== 96) item.fail("only function types are supported");
+        return {
+          kind: "func",
+          params: readVector(item, readValueType),
+          results: readVector(item, readValueType)
+        };
+      }, types);
+    } else if (id === 2) {
+      readVector(section2, (item) => {
+        const module = item.string();
+        const name = item.string();
+        const externalKind = item.u8();
+        let type;
+        if (externalKind === 0) {
+          const typeIndex = item.u32();
+          type = functionType(types, typeIndex, item);
+        } else if (externalKind === 1) {
+          type = readTableType(item);
+          importedTables.push(type);
+        } else if (externalKind === 2) {
+          type = readMemoryType(item);
+          importedMemories.push(type);
+        } else if (externalKind === 3) {
+          type = readGlobalType(item);
+          importedGlobals.push(type);
+        } else if (externalKind === 4) {
+          type = readTagType(item, types);
+          importedTags.push(type);
+        } else {
+          item.fail(`unknown import kind ${externalKind}`);
+        }
+        return { module, name, type };
+      }, imports);
+    } else if (id === 3) {
+      readVector(section2, (item) => item.u32(), definedFunctionTypes);
+    } else if (id === 4) {
+      readVector(section2, readTableType, definedTables);
+    } else if (id === 5) {
+      readVector(section2, readMemoryType, definedMemories);
+    } else if (id === 6) {
+      readVector(section2, (item) => {
+        const type = readGlobalType(item);
+        skipConstantExpression(item);
+        return type;
+      }, definedGlobals);
+    } else if (id === 7) {
+      readVector(section2, (item) => ({
+        name: item.string(),
+        externalKind: item.u8(),
+        index: item.u32()
+      }), rawExports);
+    } else if (id === 9) {
+      for (const indices of readVector(section2, readElementSegment)) for (const index of indices) tableFunctionIndices.push(index);
+    } else if (id === 13) {
+      readVector(section2, (item) => readTagType(item, types), definedTags);
+    } else {
+      section2.take(section2.bytes.length - section2.offset);
+    }
+    if (!section2.done) section2.fail("section has trailing bytes");
+  }
+  const importedFunctions = imports.filter((entry) => entry.type.kind === "func").map((entry) => entry.type);
+  const functions = [
+    ...importedFunctions,
+    ...definedFunctionTypes.map((index) => functionType(types, index, reader))
+  ];
+  const tables = [...importedTables, ...definedTables];
+  const memories = [...importedMemories, ...definedMemories];
+  const globals = [...importedGlobals, ...definedGlobals];
+  const collections = [functions, tables, memories, globals, [...importedTags, ...definedTags]];
+  const kindNames = ["func", "table", "memory", "global", "tag"];
+  const exports = rawExports.map(({ name, externalKind, index }) => {
+    const collection = collections[externalKind];
+    const type = collection?.[index];
+    if (!type) reader.fail(`export ${name} references unknown ${kindNames[externalKind] ?? externalKind} ${index}`);
+    return { name, type };
+  });
+  const tableFunctions = tableFunctionIndices.map((index) => functions[index] ?? reader.fail(`element segment references unknown function ${index}`));
+  return {
+    label,
+    imports,
+    exports,
+    castEmulationParameters: castEmulationParameters(tableFunctions),
+    customSections,
+    customSectionData
+  };
+}
+function formatLimits(type) {
+  const width = type.address64 ? "64" : "32";
+  const maximum = type.maximum === null ? "*" : type.maximum;
+  return `${width}(min=${type.minimum},max=${maximum}${type.shared ? ",shared" : ""})`;
+}
+function formatWasmType(type) {
+  if (type.kind === "func") {
+    return `func(${type.params.join(",")})->(${type.results.join(",")})`;
+  }
+  if (type.kind === "global") {
+    return `global(${type.mutable ? "mut " : ""}${type.value})`;
+  }
+  if (type.kind === "memory") return `memory${formatLimits(type)}`;
+  if (type.kind === "table") return `table${formatLimits(type)}:${type.element}`;
+  if (type.kind === "tag") return `tag(${formatWasmType(type.type)})`;
+  throw new Error(`unknown WebAssembly type kind ${type.kind}`);
+}
+function arraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameWasmType(left, right) {
+  if (left.kind !== right.kind) return false;
+  if (left.kind === "func") {
+    return arraysEqual(left.params, right.params) && arraysEqual(left.results, right.results);
+  }
+  if (left.kind === "global") return left.value === right.value && left.mutable === right.mutable;
+  if (left.kind === "tag") return left.attribute === right.attribute && sameWasmType(left.type, right.type);
+  if (left.kind === "memory") {
+    return left.address64 === right.address64 && left.shared === right.shared && left.minimum === right.minimum && left.maximum === right.maximum;
+  }
+  if (left.kind === "table") {
+    return left.element === right.element && left.address64 === right.address64 && left.minimum === right.minimum && left.maximum === right.maximum;
+  }
+  return false;
+}
+function providerSatisfiesImport(provider, required, { dynamicTable = false } = {}) {
+  if (provider.kind !== required.kind) return false;
+  if (["func", "global", "tag"].includes(provider.kind)) return sameWasmType(provider, required);
+  if (provider.kind === "memory" || provider.kind === "table") {
+    if (provider.address64 !== required.address64 || provider.shared !== required.shared) return false;
+    if (provider.kind === "table" && provider.element !== required.element) return false;
+    if (!dynamicTable && provider.minimum < required.minimum) return false;
+    if (required.maximum !== null) {
+      if (provider.maximum === null || provider.maximum > required.maximum) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+// host/abi.mjs
+var DOLLY_HOST_RECORD_BYTES = 72;
+var DOLLY_HOST_NAME_BYTES = 32;
+var DOLLY_HOST_DIGEST_BYTES = 32;
+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;
+
+// src/version.mjs
+var DOLLY_VERSION = "0.1.4";
+
+// src/static-asset.mjs
+var STATIC_PART_BYTES = 20 * 1024 * 1024;
+var hex = (bytes) => Array.from(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+var sitePrefix = `/v${DOLLY_VERSION}`;
+
+// host/requirements.mjs
+var pattern = /^([a-z][a-z0-9-]{0,30})@(0|[1-9][0-9]{0,4})$/;
+function hostRequirement(value) {
+  const match = typeof value === "string" && pattern.exec(value);
+  if (!match || Number(match[2]) > 65535) throw new TypeError(`invalid host requirement: ${value}`);
+  return { name: match[1], version: Number(match[2]) };
+}
+function hostRequirements(values = []) {
+  if (!Array.isArray(values)) throw new TypeError("invalid host requirements");
+  const versions = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const { name, version } = hostRequirement(value);
+    if (versions.has(name) && versions.get(name) !== version) throw new Error(`conflicting host ABI requirements for ${name}`);
+    versions.set(name, version);
+  }
+  if (versions.size > DOLLY_HOST_MAX_RECORDS) throw new TypeError("too many host requirements");
+  return [...versions].sort(([a], [b]) => a.localeCompare(b)).map(([name, version]) => `${name}@${version}`);
+}
+function executableHostRequirements(module) {
+  const required = /* @__PURE__ */ new Map(), decoder4 = new TextDecoder("utf-8", { fatal: true });
+  let records = 0;
+  for (const { name, data } of module.customSectionData) {
+    if (name !== "dolly.host") continue;
+    records += data.length / DOLLY_HOST_RECORD_BYTES;
+    if (data.length === 0 || data.length % DOLLY_HOST_RECORD_BYTES || records > DOLLY_HOST_MAX_RECORDS) {
+      throw new Error("invalid dolly.host record count");
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    for (let offset = 0; offset < data.length; offset += DOLLY_HOST_RECORD_BYTES) {
+      const bytes = data.subarray(offset, offset + DOLLY_HOST_NAME_BYTES), end = bytes.indexOf(0);
+      if (end < 1 || bytes.subarray(end).some((byte) => byte !== 0) || view.getUint32(offset + DOLLY_HOST_NAME_BYTES + 4, true) !== 0) {
+        throw new Error("invalid dolly.host record");
+      }
+      const requirement = `${decoder4.decode(bytes.subarray(0, end))}@${view.getUint32(offset + DOLLY_HOST_NAME_BYTES, true)}`;
+      const digest = hex(data.subarray(offset + DOLLY_HOST_RECORD_BYTES - DOLLY_HOST_DIGEST_BYTES, offset + DOLLY_HOST_RECORD_BYTES));
+      if (required.has(requirement) && required.get(requirement) !== digest) {
+        throw new Error(`conflicting host ABI digests for ${requirement}`);
+      }
+      required.set(requirement, digest);
+    }
+  }
+  hostRequirements([...required.keys()]);
+  return required;
+}
+function checkHostAbi(required, available) {
+  for (const [requirement, digest] of required) {
+    if (!available.has(requirement)) throw new Error(available.has("nena@0") ? `host module ${requirement} is not enabled: nena enable ${hostRequirement(requirement).name}` : `host module ${requirement} is not declared by this image (REQUIRES HOST)`);
+    if (available.get(requirement) !== digest) throw new Error(`host module ${requirement} has a different layout than this program was built for`);
+  }
+}
+
+// host/dso/ffi.mjs
+var FFI_OK = 0;
+var FFI_WASM64_EMSCRIPTEN = 2;
+var VARARGS_FLAG = 1;
+var MAX_ARGS = 1e3;
+var FFI_TYPE_VOID = 0;
+var FFI_TYPE_INT = 1;
+var FFI_TYPE_FLOAT = 2;
+var FFI_TYPE_DOUBLE = 3;
+var FFI_TYPE_LONGDOUBLE = 4;
+var FFI_TYPE_UINT8 = 5;
+var FFI_TYPE_SINT8 = 6;
+var FFI_TYPE_UINT16 = 7;
+var FFI_TYPE_SINT16 = 8;
+var FFI_TYPE_UINT32 = 9;
+var FFI_TYPE_SINT32 = 10;
+var FFI_TYPE_UINT64 = 11;
+var FFI_TYPE_SINT64 = 12;
+var FFI_TYPE_STRUCT = 13;
+var FFI_TYPE_POINTER = 14;
+var FFI_TYPE_COMPLEX = 15;
+var localOperations = /* @__PURE__ */ new Set([
+  DOLLY_FFI_CALL,
+  DOLLY_FFI_CLOSURE_ALLOC,
+  DOLLY_FFI_CLOSURE_FREE,
+  DOLLY_FFI_CLOSURE_PREP
+]);
+function uleb(value) {
+  const bytes = [];
+  let remaining = BigInt(value);
+  do {
+    let byte = Number(remaining & 0x7fn);
+    remaining >>= 7n;
+    if (remaining !== 0n) byte |= 128;
+    bytes.push(byte);
+  } while (remaining !== 0n);
+  return bytes;
+}
+var castEmulationBits = new DataView(new ArrayBuffer(8));
+function toCastEmulation(values, types, parameters) {
+  if (values.length > parameters) {
+    throw new TypeError(`a cast-emulated call takes at most ${parameters} arguments`);
+  }
+  const converted = values.map((value, index) => {
+    switch (types[index]) {
+      case "i32":
+        return BigInt(value >>> 0);
+      case "f32":
+        castEmulationBits.setFloat32(0, value, true);
+        return BigInt(castEmulationBits.getUint32(0, true));
+      case "f64":
+        castEmulationBits.setFloat64(0, value, true);
+        return castEmulationBits.getBigUint64(0, true);
+      default:
+        return BigInt.asUintN(64, value);
+    }
+  });
+  while (converted.length < parameters) converted.push(0n);
+  return converted;
+}
+function fromCastEmulation(result, type) {
+  castEmulationBits.setBigUint64(0, BigInt.asUintN(64, result), true);
+  switch (type) {
+    case "i32":
+      return castEmulationBits.getInt32(0, true);
+    case "f32":
+      return castEmulationBits.getFloat32(0, true);
+    case "f64":
+      return castEmulationBits.getFloat64(0, true);
+    case "i64":
+      return result;
+    default:
+      return void 0;
+  }
+}
+function section(id, body) {
+  return [id, ...uleb(body.length), ...body];
+}
+function wasmName(value) {
+  const bytes = new TextEncoder().encode(value);
+  return [...uleb(bytes.length), ...bytes];
+}
+function wasmType(name) {
+  switch (name) {
+    case "i32":
+      return 127;
+    case "i64":
+      return 126;
+    case "f32":
+      return 125;
+    case "f64":
+      return 124;
+    default:
+      throw new TypeError(`unsupported FFI Wasm type ${name}`);
+  }
+}
+function typedWasmFunction(function_, parameters, result) {
+  const functionType2 = [
+    96,
+    ...uleb(parameters.length),
+    ...parameters.map(wasmType),
+    ...result === null ? [0] : [1, wasmType(result)]
+  ];
+  const typeSection = section(1, [1, ...functionType2]);
+  const importSection = section(2, [
+    1,
+    ...wasmName("dolly"),
+    ...wasmName("closure"),
+    0,
+    0
+  ]);
+  const exportSection = section(7, [
+    1,
+    ...wasmName("closure"),
+    0,
+    0
+  ]);
+  const bytes = new Uint8Array([
+    0,
+    97,
+    115,
+    109,
+    1,
+    0,
+    0,
+    0,
+    ...typeSection,
+    ...importSection,
+    ...exportSection
+  ]);
+  const module = new WebAssembly.Module(bytes);
+  return new WebAssembly.Instance(module, {
+    dolly: { closure: function_ }
+  }).exports.closure;
+}
+function createProcessFfi({
+  memory,
+  getInstance,
+  getTable,
+  growTable: growTable2,
+  setTable: setTable2,
+  castEmulationParameters: castEmulationParameters2 = 0
+}) {
+  if (!(memory instanceof WebAssembly.Memory) || typeof getInstance !== "function" || typeof getTable !== "function" || typeof growTable2 !== "function" || typeof setTable2 !== "function") {
+    throw new TypeError("invalid process FFI configuration");
+  }
+  const closures = /* @__PURE__ */ new Map();
+  const freeTableIndices = [];
+  function asBigInt(value, description) {
+    if (typeof value === "bigint") return BigInt.asUintN(64, value);
+    if (Number.isSafeInteger(value) && value >= 0) return BigInt(value);
+    throw new RangeError(`invalid ${description}`);
+  }
+  function address(value, size = 0, description = "FFI address") {
+    const integer = asBigInt(value, description);
+    if (integer > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new RangeError(`${description} exceeds JavaScript's exact address range`);
+    }
+    const result = Number(integer);
+    const length = memory.buffer.byteLength;
+    if (!Number.isSafeInteger(size) || size < 0 || result > length - size || size !== 0 && result === 0) {
+      throw new RangeError(`${description} is outside process memory`);
+    }
+    return result;
+  }
+  function view(value, size, description) {
+    return new DataView(memory.buffer, address(value, size, description), size);
+  }
+  function bytes(value, size, description) {
+    return new Uint8Array(memory.buffer, address(value, size, description), size);
+  }
+  function readPointer(value, offset = 0) {
+    return view(asBigInt(value, "pointer") + BigInt(offset), 8, "pointer field").getBigUint64(0, true);
+  }
+  function writePointer(value, offset, pointer) {
+    view(asBigInt(value, "pointer") + BigInt(offset), 8, "pointer field").setBigUint64(0, asBigInt(pointer, "pointer value"), true);
+  }
+  function typeInfo(typePointer) {
+    const pointer = asBigInt(typePointer, "ffi_type pointer");
+    const data = view(pointer, 24, "ffi_type");
+    const size = data.getBigUint64(0, true);
+    if (size > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new RangeError("FFI type is too large");
+    }
+    return {
+      pointer,
+      size: Number(size),
+      alignment: data.getUint16(8, true),
+      id: data.getUint16(10, true),
+      elements: data.getBigUint64(16, true)
+    };
+  }
+  function unboxType(typePointer) {
+    let type = typeInfo(typePointer);
+    for (let depth = 0; type.id === FFI_TYPE_STRUCT; ++depth) {
+      if (depth === 64) throw new TypeError("recursive singleton FFI structure");
+      if (type.size > 16) break;
+      if (type.elements === 0n) return { ...type, id: FFI_TYPE_VOID };
+      const first = readPointer(type.elements, 0);
+      if (first === 0n) return { ...type, id: FFI_TYPE_VOID };
+      if (readPointer(type.elements, 8) !== 0n) break;
+      type = typeInfo(first);
+    }
+    return type;
+  }
+  function cifInfo(cifPointer) {
+    const pointer = asBigInt(cifPointer, "ffi_cif pointer");
+    const data = view(pointer, 36, "ffi_cif");
+    const abi = data.getUint32(0, true);
+    const nargs = data.getUint32(4, true);
+    const argTypes = data.getBigUint64(8, true);
+    const returnType = data.getBigUint64(16, true);
+    const flags = data.getUint32(28, true);
+    const fixed = data.getUint32(32, true);
+    if (abi !== FFI_WASM64_EMSCRIPTEN || nargs > MAX_ARGS || fixed > nargs || returnType === 0n || nargs !== 0 && argTypes === 0n) {
+      throw new TypeError("invalid wasm64 ffi_cif");
+    }
+    const types = [];
+    for (let index = 0; index < nargs; ++index) {
+      const typePointer = readPointer(argTypes, index * 8);
+      if (typePointer === 0n) throw new TypeError("null FFI argument type");
+      types.push(unboxType(typePointer));
+    }
+    return {
+      pointer,
+      nargs,
+      fixed,
+      flags,
+      types,
+      returnType: unboxType(returnType)
+    };
+  }
+  function stack() {
+    const global = getInstance()?.exports?.__stack_pointer;
+    if (!(global instanceof WebAssembly.Global) || typeof global.value !== "bigint") {
+      throw new TypeError("process has no memory64 stack pointer");
+    }
+    const original = BigInt.asUintN(64, global.value);
+    let current = original;
+    return {
+      allocate(size, alignment) {
+        if (!Number.isSafeInteger(size) || size < 0 || !Number.isSafeInteger(alignment) || alignment <= 0 || (alignment & alignment - 1) !== 0) {
+          throw new RangeError("invalid FFI stack allocation");
+        }
+        const count = BigInt(size);
+        const boundary = BigInt(alignment);
+        if (count > current) throw new RangeError("FFI stack exhausted");
+        current = current - count & -boundary;
+        address(current, size, "FFI stack allocation");
+        return current;
+      },
+      publish() {
+        current &= -16n;
+        address(current, 0, "FFI stack pointer");
+        global.value = current;
+      },
+      restore() {
+        global.value = original;
+      }
+    };
+  }
+  function copy(target, source, size) {
+    const destination = bytes(target, size, "FFI structure destination");
+    const input = new Uint8Array(bytes(source, size, "FFI structure source"));
+    destination.set(input);
+  }
+  function readArgument(pointer, type) {
+    const location = asBigInt(pointer, "FFI argument pointer");
+    switch (type.id) {
+      case FFI_TYPE_INT:
+      case FFI_TYPE_UINT32:
+      case FFI_TYPE_SINT32:
+        return [view(location, 4, "FFI i32 argument").getUint32(0, true)];
+      case FFI_TYPE_FLOAT:
+        return [view(location, 4, "FFI f32 argument").getFloat32(0, true)];
+      case FFI_TYPE_DOUBLE:
+        return [view(location, 8, "FFI f64 argument").getFloat64(0, true)];
+      case FFI_TYPE_UINT8:
+        return [view(location, 1, "FFI u8 argument").getUint8(0)];
+      case FFI_TYPE_SINT8:
+        return [view(location, 1, "FFI i8 argument").getInt8(0)];
+      case FFI_TYPE_UINT16:
+        return [view(location, 2, "FFI u16 argument").getUint16(0, true)];
+      case FFI_TYPE_SINT16:
+        return [view(location, 2, "FFI i16 argument").getInt16(0, true)];
+      case FFI_TYPE_UINT64:
+      case FFI_TYPE_SINT64:
+      case FFI_TYPE_POINTER:
+        return [view(location, 8, "FFI i64 argument").getBigUint64(0, true)];
+      case FFI_TYPE_LONGDOUBLE: {
+        const data = view(location, 16, "FFI long-double argument");
+        return [data.getBigUint64(0, true), data.getBigUint64(8, true)];
+      }
+      case FFI_TYPE_COMPLEX:
+        throw new TypeError("complex FFI arguments are unsupported");
+      default:
+        throw new TypeError(`unsupported FFI argument type ${type.id}`);
+    }
+  }
+  function storeResult(pointer, type, result) {
+    const location = asBigInt(pointer, "FFI result pointer");
+    switch (type.id) {
+      case FFI_TYPE_VOID:
+        return;
+      case FFI_TYPE_INT:
+      case FFI_TYPE_UINT32:
+      case FFI_TYPE_SINT32:
+        view(location, 4, "FFI i32 result").setUint32(0, result, true);
+        return;
+      case FFI_TYPE_FLOAT:
+        view(location, 4, "FFI f32 result").setFloat32(0, result, true);
+        return;
+      case FFI_TYPE_DOUBLE:
+        view(location, 8, "FFI f64 result").setFloat64(0, result, true);
+        return;
+      case FFI_TYPE_UINT8:
+      case FFI_TYPE_SINT8:
+        view(location, 1, "FFI i8 result").setUint8(0, result);
+        return;
+      case FFI_TYPE_UINT16:
+      case FFI_TYPE_SINT16:
+        view(location, 2, "FFI i16 result").setUint16(0, result, true);
+        return;
+      case FFI_TYPE_UINT64:
+      case FFI_TYPE_SINT64:
+      case FFI_TYPE_POINTER:
+        view(location, 8, "FFI i64 result").setBigUint64(
+          0,
+          BigInt.asUintN(64, result),
+          true
+        );
+        return;
+      case FFI_TYPE_COMPLEX:
+        throw new TypeError("complex FFI results are unsupported");
+      default:
+        throw new TypeError(`unsupported FFI result type ${type.id}`);
+    }
+  }
+  function tableFunction(indexValue, description) {
+    const index = asBigInt(indexValue, `${description} table index`);
+    if (index >= getTable().length) {
+      throw new RangeError(`${description} table index is out of range`);
+    }
+    const function_ = getTable().get(index);
+    if (typeof function_ !== "function") {
+      throw new TypeError(`${description} table slot is empty`);
+    }
+    return function_;
+  }
+  function performCall(packet, entered) {
+    const cif = cifInfo(packet.getBigUint64(0, true));
+    const functionIndex2 = packet.getBigUint64(8, true);
+    const returnValue = packet.getBigUint64(16, true);
+    const argumentValues = packet.getBigUint64(24, true);
+    const frame = stack();
+    const arguments_ = [];
+    const types = [];
+    const push = (type, ...values) => {
+      for (const value of values) {
+        arguments_.push(value);
+        types.push(type);
+      }
+    };
+    const returnByArgument = cif.returnType.id === FFI_TYPE_STRUCT || cif.returnType.id === FFI_TYPE_LONGDOUBLE;
+    if (returnByArgument) push("i64", returnValue);
+    for (let index = 0; index < cif.fixed; ++index) {
+      const argumentPointer = readPointer(argumentValues, index * 8);
+      const type = cif.types[index];
+      if (type.id === FFI_TYPE_STRUCT) {
+        const temporary = frame.allocate(type.size, type.alignment);
+        copy(temporary, argumentPointer, type.size);
+        push("i64", temporary);
+      } else {
+        push(argumentWasmType(type), ...readArgument(argumentPointer, type));
+      }
+    }
+    if ((cif.flags & VARARGS_FLAG) !== 0) {
+      const structures = [];
+      for (let index = cif.nargs - 1; index >= cif.fixed; --index) {
+        const argumentPointer = readPointer(argumentValues, index * 8);
+        const type = cif.types[index];
+        switch (type.id) {
+          case FFI_TYPE_UINT8:
+          case FFI_TYPE_SINT8: {
+            const slot = frame.allocate(1, 1);
+            bytes(slot, 1, "FFI variadic byte")[0] = bytes(argumentPointer, 1, "FFI variadic byte source")[0];
+            break;
+          }
+          case FFI_TYPE_UINT16:
+          case FFI_TYPE_SINT16: {
+            const slot = frame.allocate(2, 2);
+            copy(slot, argumentPointer, 2);
+            break;
+          }
+          case FFI_TYPE_INT:
+          case FFI_TYPE_UINT32:
+          case FFI_TYPE_SINT32:
+          case FFI_TYPE_FLOAT: {
+            const slot = frame.allocate(4, 4);
+            copy(slot, argumentPointer, 4);
+            break;
+          }
+          case FFI_TYPE_DOUBLE:
+          case FFI_TYPE_UINT64:
+          case FFI_TYPE_SINT64:
+          case FFI_TYPE_POINTER: {
+            const slot = frame.allocate(8, 8);
+            copy(slot, argumentPointer, 8);
+            break;
+          }
+          case FFI_TYPE_LONGDOUBLE: {
+            const slot = frame.allocate(16, 8);
+            copy(slot, argumentPointer, 16);
+            break;
+          }
+          case FFI_TYPE_STRUCT: {
+            const pointerSlot = frame.allocate(8, 8);
+            structures.push({ pointerSlot, argumentPointer, type });
+            break;
+          }
+          default:
+            throw new TypeError(`unsupported variadic FFI type ${type.id}`);
+        }
+      }
+      const variadicArguments = frame.allocate(0, 1);
+      push("i64", variadicArguments);
+      for (const structure of structures) {
+        const temporary = frame.allocate(
+          structure.type.size,
+          structure.type.alignment
+        );
+        copy(temporary, structure.argumentPointer, structure.type.size);
+        writePointer(structure.pointerSlot, 0, temporary);
+      }
+    } else if (cif.fixed !== cif.nargs) {
+      throw new TypeError("inconsistent variadic FFI metadata");
+    }
+    frame.publish();
+    let result;
+    try {
+      const target = tableFunction(functionIndex2, "FFI target");
+      entered();
+      result = castEmulationParameters2 ? fromCastEmulation(
+        target(...toCastEmulation(arguments_, types, castEmulationParameters2)),
+        resultWasmType(cif.returnType)
+      ) : target(...arguments_);
+    } finally {
+      frame.restore();
+    }
+    if (!returnByArgument) storeResult(returnValue, cif.returnType, result);
+  }
+  function argumentWasmType(type) {
+    switch (type.id) {
+      case FFI_TYPE_FLOAT:
+        return "f32";
+      case FFI_TYPE_DOUBLE:
+        return "f64";
+      case FFI_TYPE_UINT64:
+      case FFI_TYPE_SINT64:
+      case FFI_TYPE_POINTER:
+      case FFI_TYPE_LONGDOUBLE:
+        return "i64";
+      default:
+        return "i32";
+    }
+  }
+  function resultWasmType(type) {
+    switch (type.id) {
+      case FFI_TYPE_VOID:
+        return null;
+      case FFI_TYPE_INT:
+      case FFI_TYPE_UINT8:
+      case FFI_TYPE_SINT8:
+      case FFI_TYPE_UINT16:
+      case FFI_TYPE_SINT16:
+      case FFI_TYPE_UINT32:
+      case FFI_TYPE_SINT32:
+        return "i32";
+      case FFI_TYPE_FLOAT:
+        return "f32";
+      case FFI_TYPE_DOUBLE:
+        return "f64";
+      case FFI_TYPE_UINT64:
+      case FFI_TYPE_SINT64:
+      case FFI_TYPE_POINTER:
+        return "i64";
+      case FFI_TYPE_STRUCT:
+      case FFI_TYPE_LONGDOUBLE:
+        return null;
+      default:
+        throw new TypeError(`unsupported FFI closure result type ${type.id}`);
+    }
+  }
+  function argumentWasmTypes(type) {
+    switch (type.id) {
+      case FFI_TYPE_INT:
+      case FFI_TYPE_UINT8:
+      case FFI_TYPE_SINT8:
+      case FFI_TYPE_UINT16:
+      case FFI_TYPE_SINT16:
+      case FFI_TYPE_UINT32:
+      case FFI_TYPE_SINT32:
+        return ["i32"];
+      case FFI_TYPE_FLOAT:
+        return ["f32"];
+      case FFI_TYPE_DOUBLE:
+        return ["f64"];
+      case FFI_TYPE_LONGDOUBLE:
+        return ["i64", "i64"];
+      case FFI_TYPE_UINT64:
+      case FFI_TYPE_SINT64:
+      case FFI_TYPE_STRUCT:
+      case FFI_TYPE_POINTER:
+        return ["i64"];
+      default:
+        throw new TypeError(`unsupported FFI closure argument type ${type.id}`);
+    }
+  }
+  function writeCallbackArgument(pointer, type, values, index) {
+    switch (type.id) {
+      case FFI_TYPE_UINT8:
+      case FFI_TYPE_SINT8:
+        view(pointer, 1, "FFI callback byte").setUint8(0, values[index]);
+        return index + 1;
+      case FFI_TYPE_UINT16:
+      case FFI_TYPE_SINT16:
+        view(pointer, 2, "FFI callback i16").setUint16(0, values[index], true);
+        return index + 1;
+      case FFI_TYPE_INT:
+      case FFI_TYPE_UINT32:
+      case FFI_TYPE_SINT32:
+        view(pointer, 4, "FFI callback i32").setUint32(0, values[index], true);
+        return index + 1;
+      case FFI_TYPE_FLOAT:
+        view(pointer, 4, "FFI callback f32").setFloat32(0, values[index], true);
+        return index + 1;
+      case FFI_TYPE_DOUBLE:
+        view(pointer, 8, "FFI callback f64").setFloat64(0, values[index], true);
+        return index + 1;
+      case FFI_TYPE_UINT64:
+      case FFI_TYPE_SINT64:
+      case FFI_TYPE_POINTER:
+        view(pointer, 8, "FFI callback i64").setBigUint64(
+          0,
+          BigInt.asUintN(64, values[index]),
+          true
+        );
+        return index + 1;
+      case FFI_TYPE_LONGDOUBLE: {
+        const data = view(pointer, 16, "FFI callback long double");
+        data.setBigUint64(0, BigInt.asUintN(64, values[index]), true);
+        data.setBigUint64(8, BigInt.asUintN(64, values[index + 1]), true);
+        return index + 2;
+      }
+      default:
+        throw new TypeError(`unsupported FFI callback type ${type.id}`);
+    }
+  }
+  function callbackResult(pointer, type) {
+    switch (resultWasmType(type)) {
+      case null:
+        return void 0;
+      case "i32":
+        return view(pointer, 4, "FFI callback result").getUint32(0, true);
+      case "i64":
+        return view(pointer, 8, "FFI callback result").getBigUint64(0, true);
+      case "f32":
+        return view(pointer, 4, "FFI callback result").getFloat32(0, true);
+      case "f64":
+        return view(pointer, 8, "FFI callback result").getFloat64(0, true);
+      default:
+        throw new TypeError("invalid FFI callback result");
+    }
+  }
+  function prepareClosure(closure, cif, callbackIndex, userData) {
+    const returnByArgument = cif.returnType.id === FFI_TYPE_STRUCT || cif.returnType.id === FFI_TYPE_LONGDOUBLE;
+    const parameters = [];
+    if (returnByArgument) parameters.push("i64");
+    for (let index = 0; index < cif.fixed; ++index) {
+      parameters.push(...argumentWasmTypes(cif.types[index]));
+    }
+    if ((cif.flags & VARARGS_FLAG) !== 0) parameters.push("i64");
+    const result = returnByArgument ? null : resultWasmType(cif.returnType);
+    return typedWasmFunction((...arguments_) => {
+      const frame = stack();
+      let valueIndex = 0;
+      const returnPointer = returnByArgument ? asBigInt(arguments_[valueIndex++], "FFI closure return pointer") : frame.allocate(8, 8);
+      const argumentArray = frame.allocate(cif.nargs * 8, 8);
+      for (let index = 0; index < cif.fixed; ++index) {
+        const type = cif.types[index];
+        let argumentPointer;
+        if (type.id === FFI_TYPE_STRUCT) {
+          const source = asBigInt(
+            arguments_[valueIndex++],
+            "FFI closure structure pointer"
+          );
+          argumentPointer = frame.allocate(type.size, type.alignment);
+          copy(argumentPointer, source, type.size);
+        } else {
+          const alignment = type.id === FFI_TYPE_UINT8 || type.id === FFI_TYPE_SINT8 || type.id === FFI_TYPE_UINT16 || type.id === FFI_TYPE_SINT16 ? 4 : Math.max(1, Math.min(type.alignment, 8));
+          argumentPointer = frame.allocate(Math.max(type.size, 1), alignment);
+          valueIndex = writeCallbackArgument(
+            argumentPointer,
+            type,
+            arguments_,
+            valueIndex
+          );
+        }
+        writePointer(argumentArray, index * 8, argumentPointer);
+      }
+      if ((cif.flags & VARARGS_FLAG) !== 0) {
+        let variadic = asBigInt(
+          arguments_[arguments_.length - 1],
+          "FFI closure variadic pointer"
+        );
+        for (let index = cif.fixed; index < cif.nargs; ++index) {
+          const type = cif.types[index];
+          if (type.id === FFI_TYPE_STRUCT) {
+            const source = readPointer(variadic, 0);
+            const copyPointer = frame.allocate(type.size, type.alignment);
+            copy(copyPointer, source, type.size);
+            writePointer(argumentArray, index * 8, copyPointer);
+          } else {
+            writePointer(argumentArray, index * 8, variadic);
+          }
+          variadic += 8n;
+        }
+      }
+      frame.publish();
+      try {
+        tableFunction(callbackIndex, "FFI closure callback")(
+          cif.pointer,
+          returnPointer,
+          argumentArray,
+          userData
+        );
+      } finally {
+        frame.restore();
+      }
+      return returnByArgument ? void 0 : callbackResult(returnPointer, cif.returnType);
+    }, parameters, result);
+  }
+  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 });
+    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);
+    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);
+    writePointer(closure, 8, cifPointer);
+    writePointer(closure, 16, callbackIndex);
+    writePointer(closure, 24, userData);
+    record.prepared = true;
+    return BigInt(FFI_OK);
+  }
+  return Object.freeze({
+    handles(operation) {
+      return localOperations.has(operation);
+    },
+    call(operation, request, response) {
+      if (!(getTable() instanceof WebAssembly.Table) || !(getInstance()?.exports.__stack_pointer instanceof WebAssembly.Global)) {
+        return -BigInt(DOLLY_ERRNO.ENOSYS);
+      }
+      let decoding = true;
+      try {
+        if (operation === DOLLY_FFI_CALL) {
+          if (request.size !== 32 || response.size !== 0) return -BigInt(DOLLY_ERRNO.EINVAL);
+          performCall(view(request.address, 32, "FFI call request"), () => {
+            decoding = false;
+          });
+          return 0n;
+        }
+        if (operation === DOLLY_FFI_CLOSURE_ALLOC) return allocateClosure(request, response);
+        if (operation === DOLLY_FFI_CLOSURE_FREE) return freeClosure(request);
+        return configureClosure(request);
+      } catch (error) {
+        if (!decoding || !(error instanceof TypeError || error instanceof RangeError)) throw error;
+        return -BigInt(error instanceof RangeError ? DOLLY_ERRNO.EFAULT : DOLLY_ERRNO.EINVAL);
+      }
+    }
+  });
+}
+
+// src/process-abi.mjs
+function unique(entries, key) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const name = key(entry);
+    if (result.has(name)) throw new TypeError(`duplicate process interface entry ${name}`);
+    result.set(name, entry);
+  }
+  return result;
+}
+
+// host/dso/interface.mjs
+function requireDsoType(actual, expected, name) {
+  if (!actual || !providerSatisfiesImport(actual, expected)) {
+    throw new TypeError(`DSO ${name}: expected ${formatWasmType(expected)}, got ${actual ? formatWasmType(actual) : "missing symbol"}`);
+  }
+}
+function validateDsoHost(contract, exports) {
+  for (const name of ["__indirect_function_table", "__stack_pointer", "__dolly_dso_allocate"]) {
+    requireDsoType(
+      exports.get(name)?.type,
+      contract.exports.find((entry) => entry.name === name).type,
+      name
+    );
+  }
+}
+function validateDsoInterface(contract, dso, digest) {
+  const stamps = dso.customSectionData.filter((section2) => section2.name === "dolly.process.dso");
+  if (stamps.length !== 1 || hex(stamps[0].data) !== digest) {
+    throw new TypeError("shared object has the wrong dolly.process.dso stamp");
+  }
+  if (dso.customSections.includes("dolly.process")) throw new TypeError("shared object must not carry a process entry stamp");
+  if (dso.customSections.filter((name) => name === "dylink.0").length !== 1) {
+    throw new TypeError("shared object needs one dylink.0 section");
+  }
+  const key = (entry) => `${entry.module}\0${entry.name}`;
+  const imports = unique(dso.imports, key);
+  const exports = unique(dso.exports, (entry) => entry.name);
+  const allowed = new Map(contract.imports.map((entry) => [key(entry), entry.type]));
+  if (!imports.has("env\0memory")) throw new TypeError("shared object needs exactly one memory import");
+  for (const entry of imports.values()) {
+    const expected = allowed.get(key(entry)) ?? allowed.get(`${entry.module}\0symbol`);
+    if (expected) {
+      const actual = entry.type;
+      if (expected.kind === "memory" || expected.kind === "table") {
+        if (actual.kind !== expected.kind || actual.address64 !== expected.address64 || actual.shared !== expected.shared || actual.element !== expected.element || expected.maximum !== null && (actual.maximum === null || actual.maximum > expected.maximum)) {
+          throw new TypeError(`DSO ${entry.module}.${entry.name}: incompatible ${formatWasmType(actual)}`);
+        }
+      } else requireDsoType(actual, expected, `${entry.module}.${entry.name}`);
+    } else if (entry.module !== "env" || !["func", "tag"].includes(entry.type.kind)) {
+      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"]) {
+    if (exports.has(name)) requireDsoType(
+      exports.get(name).type,
+      contract.exports.find((entry) => entry.name === name).type,
+      name
+    );
+  }
+  return { imports, exports };
+}
+
+// host/dso/process.mjs
+var DSO_RESPONSE_SIZE = 16 + DOLLY_DSO_ERROR_CAPACITY;
+var encoder = new TextEncoder();
+var decoder3 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+var configuration;
+var instance;
+var processTable;
+var processSymbols;
+var dsoHostValidated = false;
+var nextDsoHandle = 2n;
+var loadedDsos = /* @__PURE__ */ new Map();
+var globalDsos = [];
+var functionIndices = /* @__PURE__ */ new WeakMap();
+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");
+  const reader = new Reader(new Uint8Array(sections[0]), "dylink.0");
+  let requirements;
+  const needed = [];
+  const weakImports = /* @__PURE__ */ new Set();
+  while (!reader.done) {
+    const id = Number(reader.unsigned(8));
+    const section2 = reader.subreader(reader.u32(), "dylink.0 subsection");
+    if (id === 1) {
+      if (requirements) throw new TypeError("duplicate dylink memory metadata");
+      requirements = {
+        memorySize: section2.unsigned(64),
+        memoryAlignment: section2.unsigned(32),
+        tableSize: section2.unsigned(64),
+        tableAlignment: section2.unsigned(32)
+      };
+    } else if (id === 2) {
+      for (let count = section2.u32(); count > 0; --count) {
+        const name = section2.string();
+        if (!name || name.includes("/") || name.includes("..")) {
+          throw new TypeError("unsafe dylink dependency name");
+        }
+        needed.push(name);
+      }
+    } else if (id === 4) {
+      for (let count = section2.u32(); count > 0; --count) {
+        const moduleName = section2.string();
+        const symbolName = section2.string();
+        const flags = section2.unsigned(32);
+        if ((flags & 3n) === 1n) weakImports.add(`${moduleName}\0${symbolName}`);
+      }
+    }
+  }
+  if (!requirements) throw new TypeError("shared object lacks dylink memory metadata");
+  if (requirements.memorySize > BigInt(DOLLY_DSO_LIMIT) || requirements.memoryAlignment > 31n || requirements.tableSize > 0xffffffffn || requirements.tableAlignment > 31n) {
+    throw new RangeError("shared object requirements are out of range");
+  }
+  return { ...requirements, needed, weakImports };
+}
+function growTable(delta) {
+  if (delta === 0n) return processTable.length;
+  if (delta > 0xffffffffn) throw new RangeError("shared object table is too large");
+  return processTable.grow(delta);
+}
+function setTable(index, value) {
+  processTable.set(index, value);
+}
+function functionIndex(value) {
+  const previous = functionIndices.get(value);
+  if (previous !== void 0) return previous;
+  const index = growTable(1n);
+  setTable(index, value);
+  functionIndices.set(value, index);
+  return index;
+}
+function typedSymbols(exports, values, memoryBase = 0n) {
+  return new Map([...exports].map((entry) => {
+    let value = values[entry.name];
+    if (memoryBase !== 0n && entry.type.kind === "global" && entry.type.value === "i64" && !entry.type.mutable) {
+      value = new WebAssembly.Global({ value: "i64", mutable: false }, memoryBase + value.value);
+    }
+    return [entry.name, { type: entry.type, value }];
+  }));
+}
+function globalSymbol(name) {
+  const main = processSymbols.get(name);
+  if (main !== void 0) return main;
+  for (const dso of globalDsos) {
+    const value = dso.symbols.get(name);
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function symbolAddress({ value }) {
+  if (typeof value === "function") return functionIndex(value);
+  if (value instanceof WebAssembly.Global) {
+    const raw = value.value;
+    return typeof raw === "bigint" ? raw : BigInt(raw);
+  }
+  throw new TypeError("symbol is not a callable or data address");
+}
+function aligned(value, power) {
+  const alignment = 1n << power;
+  return value + alignment - 1n & -alignment;
+}
+function instantiateDso(bytes, flags) {
+  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);
+  const module = new WebAssembly.Module(bytes);
+  const requirements = dylinkRequirements(module);
+  if (requirements.needed.length !== 0) {
+    throw new TypeError(
+      `shared object has unloaded dependencies: ${requirements.needed.join(", ")}`
+    );
+  }
+  const currentTable = processTable.length;
+  const tableBase = aligned(currentTable, requirements.tableAlignment);
+  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,
+    minimum: BigInt(configuration.memory.buffer.byteLength / 65536)
+  });
+  infrastructure.set("__indirect_function_table", {
+    ...processSymbols.get("__indirect_function_table").type,
+    minimum: tableBase + requirements.tableSize
+  });
+  const bindings = /* @__PURE__ */ new Map();
+  for (const [key, imported] of parsed.imports) {
+    if (imported.module === "env" && infrastructure.has(imported.name)) {
+      requireDsoType(infrastructure.get(imported.name), imported.type, imported.name);
+      continue;
+    }
+    const symbol = parsed.exports.get(imported.name) ?? globalSymbol(imported.name);
+    const weak = requirements.weakImports.has(key);
+    if (!symbol && !weak) throw new TypeError(`undefined symbol: ${imported.name}`);
+    if (symbol) {
+      if (imported.module === "env") requireDsoType(symbol.type, imported.type, imported.name);
+      else if (imported.module === "GOT.mem") {
+        requireDsoType(symbol.type, infrastructure.get("__memory_base"), `GOT.mem.${imported.name}`);
+      } else if (symbol.type.kind !== "func") {
+        throw new TypeError(`DSO GOT.func.${imported.name}: expected a function symbol`);
+      }
+    }
+    bindings.set(key, symbol);
+  }
+  const memoryAlignment = 1n << requirements.memoryAlignment;
+  const memoryBase = instance.exports.__dolly_dso_allocate(
+    requirements.memorySize,
+    memoryAlignment
+  );
+  if (typeof memoryBase !== "bigint" || memoryBase === 0n) {
+    throw new RangeError("process could not reserve shared-object memory");
+  }
+  growTable(tableBase - currentTable + requirements.tableSize);
+  const imports = {
+    env: Object.assign(/* @__PURE__ */ Object.create(null), {
+      memory: configuration.memory,
+      __memory_base: new WebAssembly.Global({ value: "i64", mutable: false }, memoryBase),
+      __table_base: new WebAssembly.Global({ value: "i64", mutable: false }, tableBase),
+      __stack_pointer: instance.exports.__stack_pointer,
+      __indirect_function_table: processTable
+    }),
+    "GOT.mem": /* @__PURE__ */ Object.create(null),
+    "GOT.func": /* @__PURE__ */ Object.create(null)
+  };
+  const relocations = [];
+  const pendingFunctions = [];
+  let dsoInstance;
+  let dsoSymbols;
+  function resolveFunction(pending) {
+    const symbol = dsoSymbols?.get(pending.name) ?? globalSymbol(pending.name);
+    requireDsoType(symbol?.type, pending.type, pending.name);
+    return symbol.value;
+  }
+  for (const [key, imported] of parsed.imports) {
+    if (imported.module === "env" && !Object.hasOwn(imports.env, imported.name)) {
+      const symbol = bindings.get(key);
+      if (symbol?.value !== void 0) {
+        imports.env[imported.name] = symbol.value;
+      } else if (imported.type.kind === "func") {
+        const pending = {
+          name: imported.name,
+          type: imported.type,
+          weak: requirements.weakImports.has(key),
+          value: void 0
+        };
+        imports.env[imported.name] = (...arguments_) => {
+          pending.value ??= resolveFunction(pending);
+          return pending.value(...arguments_);
+        };
+        pendingFunctions.push(pending);
+      } else {
+        throw new TypeError(`undefined symbol: ${imported.name}`);
+      }
+    } else if (imported.module === "GOT.mem" || imported.module === "GOT.func") {
+      const global = new WebAssembly.Global({ value: "i64", mutable: true }, 0n);
+      imports[imported.module][imported.name] = global;
+      relocations.push({
+        module: imported.module,
+        name: imported.name,
+        global,
+        weak: requirements.weakImports.has(key)
+      });
+    }
+  }
+  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);
+  }
+  dsoInstance = new WebAssembly.Instance(module, imports);
+  dsoSymbols = typedSymbols(parsed.exports.values(), dsoInstance.exports, memoryBase);
+  for (const pending of pendingFunctions) {
+    if (pending.weak && !globalSymbol(pending.name) && !dsoSymbols.has(pending.name)) continue;
+    pending.value = resolveFunction(pending);
+  }
+  for (const relocation of relocations) {
+    const symbol = dsoSymbols.get(relocation.name) ?? globalSymbol(relocation.name);
+    if (symbol !== void 0) relocation.global.value = symbolAddress(symbol);
+    else if (relocation.weak) {
+      relocation.global.value = 0n;
+    } else {
+      throw new TypeError(`undefined ${relocation.module} symbol: ${relocation.name}`);
+    }
+  }
+  const applyDataRelocations = dsoInstance.exports.__wasm_apply_data_relocs;
+  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;
+  if (constructors !== void 0) constructors();
+  return handle;
+}
+function writeDsoResponse(response, value = 0n, error = 0, message = "") {
+  if (response.size < DSO_RESPONSE_SIZE) return -BigInt(DOLLY_ERRNO.ENOBUFS);
+  const bytes = encoder.encode(message);
+  const messageSize = Math.min(bytes.length, DOLLY_DSO_ERROR_CAPACITY);
+  const output = new Uint8Array(
+    configuration.memory.buffer,
+    response.address,
+    DSO_RESPONSE_SIZE
+  );
+  output.fill(0);
+  const view = new DataView(
+    configuration.memory.buffer,
+    response.address,
+    DSO_RESPONSE_SIZE
+  );
+  view.setBigUint64(0, BigInt.asUintN(64, value), true);
+  view.setInt32(8, error, true);
+  view.setUint32(12, messageSize, true);
+  output.set(bytes.subarray(0, messageSize), 16);
+  return BigInt(DSO_RESPONSE_SIZE);
+}
+function processDsoCall(operation, request, response) {
+  if (!(processTable instanceof WebAssembly.Table) || !(instance?.exports.__stack_pointer instanceof WebAssembly.Global) || typeof instance.exports.__dolly_dso_allocate !== "function") {
+    return writeDsoResponse(
+      response,
+      0n,
+      DOLLY_ERRNO.ENOSYS,
+      "process does not provide a dynamic-link namespace"
+    );
+  }
+  try {
+    if (!dsoHostValidated) {
+      validateDsoHost(configuration.contract, processSymbols);
+      dsoHostValidated = true;
+    }
+    const view = new DataView(configuration.memory.buffer, request.address, request.size);
+    if (operation === DOLLY_DSO_OPEN) {
+      if (request.size < 16) throw new TypeError("short DSO_OPEN packet");
+      const flags = view.getUint32(0, true);
+      const reserved = view.getUint32(4, true);
+      const size = view.getBigUint64(8, true);
+      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
+      );
+      return writeDsoResponse(response, handle);
+    }
+    if (operation === DOLLY_DSO_SYMBOL) {
+      if (request.size < 16) throw new TypeError("short DSO_SYMBOL packet");
+      const handle = view.getBigUint64(0, true);
+      const nameSize = view.getUint32(8, true);
+      if (view.getUint32(12, true) !== 0 || nameSize !== request.size - 16 || nameSize === 0) throw new TypeError("invalid DSO_SYMBOL packet");
+      const name = decoder3.decode(Uint8Array.from(new Uint8Array(
+        configuration.memory.buffer,
+        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 (value === void 0) {
+        return writeDsoResponse(response, 0n, DOLLY_ERRNO.ENOENT, `undefined symbol: ${name}`);
+      }
+      return writeDsoResponse(response, symbolAddress(value));
+    }
+    if (operation === DOLLY_DSO_CLOSE) {
+      if (request.size !== 8) throw new TypeError("invalid DSO_CLOSE packet");
+      const handle = view.getBigUint64(0, true);
+      if (handle === 1n) return writeDsoResponse(response);
+      const dso = loadedDsos.get(handle);
+      if (!dso) return writeDsoResponse(response, 0n, DOLLY_ERRNO.EBADF, "invalid DSO handle");
+      if (dso.references !== 0) --dso.references;
+      return writeDsoResponse(response);
+    }
+    return writeDsoResponse(response, 0n, DOLLY_ERRNO.ENOSYS, "unknown process-local operation");
+  } catch (error) {
+    return writeDsoResponse(
+      response,
+      0n,
+      error instanceof RangeError ? DOLLY_ERRNO.ENOMEM : DOLLY_ERRNO.ENOEXEC,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function serve(context) {
+  configuration = context;
+  instance = context.instance;
+  processTable = instance.exports.__indirect_function_table;
+  processSymbols = typedSymbols(configuration.processInterface.exports, instance.exports);
+  const ffi = createProcessFfi({
+    memory: configuration.memory,
+    getInstance: () => instance,
+    getTable: () => processTable,
+    growTable,
+    setTable,
+    castEmulationParameters: context.processInterface.castEmulationParameters
+  });
+  const callsOnly = context.threaded || 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"
+  );
+  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)
+  };
+}
+export {
+  serve
+};