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

package/dist/dolly-process-stack.mjs

@@ -0,0 +1,50 @@
+// host/stack/abi.mjs
+var DOLLY_STACK_CONTINUE = 116;
+var DOLLY_STACK_CHECK_SLOTS = 16384;
+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 });
+
+// host/stack/process.mjs
+var entry = new WebAssembly.Module(Uint8Array.from(atob(
+  "AGFzbQEAAAABBAFgAAACFAEHcHJvZ3JhbQhjb250aW51ZQAAAwMCAAAGCwJpAdBpC38BQQALBxoDBGRvbmUDAQVlbnRlcgABB3JldGhyb3cAAgoqAhgAAmkfQAEDABAAC0EBJAEPCyQAQQIkAQsPAQFpIwAhANBpJAAgAAoL"
+), (character) => character.charCodeAt(0)));
+var probeSlots = 23;
+var roomOf = (probes) => Math.floor(probes * probeSlots / 2);
+function serve({ instance, stack }) {
+  const { dolly_stack_room: room, dolly_stack_continue: resume } = instance.exports;
+  if (!(room instanceof WebAssembly.Global) || typeof resume !== "function") {
+    throw new TypeError("an executable recording stack@0 must export dolly_stack_room and dolly_stack_continue");
+  }
+  const fresh = roomOf(stack.depths.promising);
+  room.value = stack.promisingEntry ? fresh : roomOf(stack.depths.direct);
+  let failure, helper, enter;
+  return {
+    handles: (operation) => operation === DOLLY_STACK_CONTINUE,
+    call(operation, request, response) {
+      if (request.size || response.size) return -BigInt(DOLLY_ERRNO.EINVAL);
+      if (!WebAssembly.promising || fresh < DOLLY_STACK_CHECK_SLOTS) {
+        failure ??= new Error(WebAssembly.promising ? `a fresh stack gives ${fresh} slots, fewer than stack@0 needs` : "this browser has no WebAssembly.promising, which stack@0 needs");
+        return -BigInt(DOLLY_ERRNO.ENOSYS);
+      }
+      helper ??= new WebAssembly.Instance(entry, { program: { continue: resume } });
+      enter ??= WebAssembly.promising(helper.exports.enter);
+      const { done, rethrow } = helper.exports;
+      const saved = room.value;
+      room.value = fresh;
+      done.value = 0;
+      enter().catch((error) => {
+        failure ??= error;
+      });
+      room.value = saved;
+      const outcome = done.value;
+      done.value = 0;
+      if (outcome === 2) rethrow();
+      return outcome === 1 ? 0n : 1n;
+    },
+    get failure() {
+      return failure;
+    }
+  };
+}
+export {
+  serve
+};

package/dist/dolly-process-worker.mjs

@@ -0,0 +1,275 @@
+// src/process-constants.mjs
+var DOLLY_PROCESS_PACKET_LIMIT = 1048576;
+var DOLLY_PROCESS_EXIT = 5;
+var DOLLY_PROCESS_CLOCK_TIME = 48;
+var DOLLY_PROCESS_INTERRUPT_POLL = 66;
+var DOLLY_PROCESS_CLOCK_REALTIME = 0;
+var DOLLY_PROCESS_CLOCK_MONOTONIC = 1;
+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
+});
+var DOLLY_PROCESS_SIZEOF = Object.freeze({
+  dolly_process_vector_sizes: 16,
+  dolly_process_fd_io_request: 16,
+  dolly_process_fd_pread_request: 24,
+  dolly_process_fd_truncate_request: 16,
+  dolly_process_fd_request: 8,
+  dolly_process_timestamp: 16,
+  dolly_process_fd_times_request: 40,
+  dolly_process_fd_dup_request: 16,
+  dolly_process_fd_flags: 8,
+  dolly_process_fd_lock_request: 32,
+  dolly_process_fd_lock_response: 24,
+  dolly_process_poll_request: 16,
+  dolly_process_poll_query: 8,
+  dolly_process_poll_response: 16,
+  dolly_process_poll_result: 8,
+  dolly_process_directory_entry: 24,
+  dolly_process_directory_request: 24,
+  dolly_process_stat_response: 88,
+  dolly_process_filesystem_stat_response: 96,
+  dolly_process_spawn_request: 56,
+  dolly_process_fd_mapping: 8,
+  dolly_process_exec_state: 16,
+  dolly_process_exec_request: 48,
+  dolly_process_pipe_request: 8,
+  dolly_process_two_path_request: 16,
+  dolly_process_path_times_request: 48,
+  dolly_process_terminal_request: 24,
+  dolly_process_terminal_response: 16,
+  dolly_process_clock_sleep_request: 16,
+  dolly_process_exit_request: 8,
+  dolly_process_wait_request: 8,
+  dolly_process_wait_response: 16,
+  dolly_process_signal_request: 8,
+  dolly_process_alarm: 16,
+  dolly_process_fd_seek_request: 16,
+  dolly_process_clock_request: 16,
+  dolly_process_path_request: 16
+});
+
+// host/threads/abi.mjs
+var DOLLY_THREAD_EXIT = 146;
+var DOLLY_ERRNO2 = 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/process-worker.mjs
+var PROCESS_EXIT = Symbol("Dolly process exit");
+var THREAD_EXIT = Symbol("Dolly thread exit");
+var configuration = await new Promise((resolve, reject) => {
+  const timeout = setTimeout(
+    () => reject(new Error("Dolly process configuration was not provided")),
+    1e4
+  );
+  self.addEventListener("message", function configure(event) {
+    if (event.data?.type !== "configure") return;
+    self.removeEventListener("message", configure);
+    clearTimeout(timeout);
+    resolve(event.data);
+  });
+});
+if (!(configuration.module instanceof WebAssembly.Module) || !(configuration.memory instanceof WebAssembly.Memory) || !(configuration.control instanceof SharedArrayBuffer) || !Array.isArray(configuration.local) || configuration.control.byteLength !== 16 || !Number.isFinite(configuration.clockOrigin) || !Number.isInteger(configuration.pid) || configuration.pid <= 0) {
+  throw new Error("Dolly process received an invalid configuration");
+}
+var control = new Int32Array(configuration.control);
+var clockOffset = performance.timeOrigin - configuration.clockOrigin;
+var lastSignalCheck = -Infinity;
+var threadResult;
+var instance;
+var localModules = [];
+function packetRange(addressValue, sizeValue) {
+  const address = Number(addressValue);
+  const size = Number(sizeValue);
+  const length = configuration.memory.buffer.byteLength;
+  return !Number.isSafeInteger(address) || !Number.isSafeInteger(size) || address < 0 || size < 0 || address > length - size || size !== 0 && address === 0 ? null : { address, size };
+}
+function decodeResult() {
+  const low = BigInt(Atomics.load(control, 2) >>> 0);
+  const high = BigInt(Atomics.load(control, 3) >>> 0);
+  return BigInt.asIntN(64, low | high << 32n);
+}
+function clockResponse(clock, response, now) {
+  const nanoseconds = Math.round(
+    (clock === DOLLY_PROCESS_CLOCK_REALTIME ? Date.now() : now + clockOffset) * 1e6
+  );
+  new DataView(configuration.memory.buffer, response.address, 8).setBigUint64(0, BigInt(nanoseconds), true);
+  return 8n;
+}
+function call(operation, requestAddressValue, requestSizeValue, responseAddressValue, responseCapacityValue) {
+  operation >>>= 0;
+  const request = packetRange(requestAddressValue, requestSizeValue);
+  const response = packetRange(responseAddressValue, responseCapacityValue);
+  if (!request || !response) return -BigInt(DOLLY_ERRNO.EFAULT);
+  for (const module of localModules) {
+    if (module.handles(operation)) return module.call(operation, request, response);
+  }
+  const exitingResult = operation === DOLLY_THREAD_EXIT && request.size === 8 ? new DataView(configuration.memory.buffer, request.address, 8).getBigUint64(0, true) : void 0;
+  let clock;
+  if (operation === DOLLY_PROCESS_CLOCK_TIME && request.size === 16 && response.size >= 8 && response.size <= DOLLY_PROCESS_PACKET_LIMIT) {
+    const packet = new DataView(configuration.memory.buffer, request.address, 16);
+    const id = packet.getUint32(0, true);
+    if ((id === DOLLY_PROCESS_CLOCK_REALTIME || id === DOLLY_PROCESS_CLOCK_MONOTONIC) && packet.getUint32(4, true) === 0) clock = id;
+    const now = performance.now();
+    if (clock !== void 0 && now - lastSignalCheck < 1) return clockResponse(clock, response, now);
+  }
+  if (operation === DOLLY_PROCESS_INTERRUPT_POLL && request.size === 0 && response.size >= 4 && performance.now() - lastSignalCheck < 1) {
+    new DataView(configuration.memory.buffer, response.address, 4).setInt32(0, 0, true);
+    return 4n;
+  }
+  if (request.size > DOLLY_PROCESS_PACKET_LIMIT || response.size > DOLLY_PROCESS_PACKET_LIMIT) {
+    return -BigInt(DOLLY_ERRNO.E2BIG);
+  }
+  const sequence = Atomics.load(control, 0) % 2147483647 + 1;
+  Atomics.store(control, 0, sequence);
+  self.postMessage({
+    type: "syscall",
+    pid: configuration.pid,
+    tid: configuration.tid,
+    sequence,
+    operation,
+    requestAddress: request.address,
+    requestSize: request.size,
+    responseAddress: response.address,
+    responseCapacity: response.size
+  });
+  for (; ; ) {
+    const observed = Atomics.load(control, 1);
+    if (observed === sequence) break;
+    Atomics.wait(control, 1, observed);
+  }
+  const result = decodeResult();
+  if (result === -(1n << 63n)) throw PROCESS_EXIT;
+  lastSignalCheck = result === -BigInt(DOLLY_ERRNO.EINTR) ? -Infinity : performance.now();
+  if (operation === DOLLY_THREAD_EXIT && result >= 0n) {
+    threadResult = exitingResult;
+    throw THREAD_EXIT;
+  }
+  if (clock !== void 0 && result === 8n) return clockResponse(clock, response, lastSignalCheck);
+  if (operation === DOLLY_PROCESS_EXIT && result >= 0n) throw PROCESS_EXIT;
+  return result;
+}
+try {
+  instance = await WebAssembly.instantiate(configuration.module, {
+    env: { memory: configuration.memory },
+    dolly_process_0: { call }
+  });
+  if (typeof instance.exports._start !== "function") {
+    throw new TypeError("Dolly process does not export _start");
+  }
+  localModules = await Promise.all(configuration.local.map(async ({ bundle, configuration: options }) => {
+    const url = URL.createObjectURL(bundle);
+    try {
+      return (await import(url)).serve({
+        ...options,
+        instance,
+        memory: configuration.memory,
+        processInterface: configuration.processInterface,
+        threaded: configuration.threaded,
+        stack: { promisingEntry: configuration.promisingEntry, depths: configuration.stackDepths }
+      });
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }));
+  self.postMessage({ type: "started", pid: configuration.pid, tid: configuration.tid });
+  const enter = configuration.promisingEntry ? WebAssembly.promising : (entry) => entry;
+  if (configuration.argument !== void 0) {
+    threadResult = await enter(instance.exports.dolly_thread_start)(configuration.tid, configuration.argument);
+    self.postMessage({ type: "thread-finished", pid: configuration.pid, tid: configuration.tid, result: threadResult });
+  } else {
+    await enter(instance.exports._start)();
+    self.postMessage({ type: "finished", pid: configuration.pid, tid: configuration.tid });
+  }
+} catch (caught) {
+  if (caught === THREAD_EXIT && configuration.threaded && typeof threadResult === "bigint") {
+    self.postMessage({ type: "thread-finished", pid: configuration.pid, tid: configuration.tid, result: threadResult });
+  } else if (caught === PROCESS_EXIT) {
+    self.postMessage({ type: "finished", pid: configuration.pid, tid: configuration.tid });
+  } else {
+    await null;
+    const error = localModules.map((module) => module.failure).find(Boolean) ?? caught;
+    self.postMessage({
+      type: "failed",
+      pid: configuration.pid,
+      tid: configuration.tid,
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack ?? "" : ""
+    });
+  }
+} finally {
+  self.close();
+}

package/host/abi.mjs

@@ -0,0 +1,5 @@
+// Generated from abi/dolly-host-0.wat.
+export const DOLLY_HOST_RECORD_BYTES = 72;
+export const DOLLY_HOST_NAME_BYTES = 32;
+export const DOLLY_HOST_DIGEST_BYTES = 32;
+export const DOLLY_HOST_MAX_RECORDS = 64;

package/host/dso/abi.mjs

@@ -0,0 +1,13 @@
+// Generated from host/dso/dolly-dso-0.wat, host/dso/dso.h, include/dolly/process.h.
+export const DOLLY_DSO_OPEN = 112;
+export const DOLLY_DSO_SYMBOL = 113;
+export const DOLLY_DSO_CLOSE = 114;
+export const DOLLY_DSO_GLOBAL = 1;
+export const DOLLY_DSO_LIMIT = 536870912;
+export const DOLLY_DSO_ERROR_CAPACITY = 240;
+export const DOLLY_FFI_CALL = 120;
+export const DOLLY_FFI_CLOSURE_ALLOC = 121;
+export const DOLLY_FFI_CLOSURE_FREE = 122;
+export const DOLLY_FFI_CLOSURE_PREP = 123;
+export const 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 });
+export const DOLLY_DSO_ABI_DIGEST = "f620970cf60972fe67e4d14dd3441edb9652092ed2ebc27a511c24d2931fb800";

package/host/dso/dso.mjs

@@ -0,0 +1,26 @@
+import { parseWasmInterface } from "../../src/wasm-interface.mjs";
+export { DOLLY_DSO_ABI_DIGEST as digest } from "./abi.mjs";
+
+// The loader and the FFI dispatcher (process.mjs) run inside the process Worker
+// of an executable that records dso@0. This side fetches their bundle and the
+// side-module contract once, as the supervisor fetches the process Worker:
+// starting a program makes no request.
+export function worker({ get, abi, runtimeBase }) {
+  return {
+    async start() {
+      const [contract, bundle] = await Promise.all(["dolly-dso-0.wasm", "dolly-process-dso.mjs"].map(async name => {
+        const response = await fetch(new URL(`dist/${name}`, runtimeBase), {
+          cache: "no-store", credentials: "same-origin", redirect: "error",
+        });
+        if (!response.ok) throw new Error(`Dolly ${name} returned HTTP ${response.status}`);
+        return response.arrayBuffer();
+      }));
+      // abi is the live set of modules the image admits; a loaded library's
+      // own records are checked against it.
+      // threads: it serves each thread's Worker of a program using threads@0.
+      get("runtime").serveInProcess("dso@0", { bundle: new Blob([bundle], { type: "text/javascript" }),
+        configuration: { contract: parseWasmInterface(contract, "dolly-dso-0"), hostAbi: abi }, threads: true });
+    },
+    disabled() { get("runtime").serveInProcess("dso@0"); },
+  };
+}

package/host/dso/module.json

@@ -0,0 +1,15 @@
+{
+  "name": "dso",
+  "version": 0,
+  "gives": "dlopen and FFI in the process's own Worker",
+  "dependencies": ["runtime@0"],
+  "phase": "kernel",
+  "imports": [],
+  "host": "dso.mjs",
+  "processWorker": "process.mjs",
+  "contracts": [],
+  "process": ["dolly-dso-0.wat"],
+  "headers": ["dso.h", "dso-abi.h"],
+  "kernel": [],
+  "client": ["client.c", "ffi.c"]
+}

package/host/http/abi.mjs

@@ -0,0 +1,28 @@
+// Generated from host/http/dolly-http-0.wat, host/http/http.h, include/dolly/process.h.
+export const DOLLY_HTTP_SLOT_COUNT = 16;
+export const DOLLY_HTTP_CHUNK_CAPACITY = 65536;
+export const DOLLY_HTTP_MAX_METHOD = 32;
+export const DOLLY_HTTP_MAX_URL = 8192;
+export const DOLLY_HTTP_MAX_HEADERS = 65536;
+export const DOLLY_HTTP_MAX_BODY = 8388608;
+export const DOLLY_HTTP_HEADER_SIZE = 64;
+export const DOLLY_HTTP_WORD_STATE = 0;
+export const DOLLY_HTTP_WORD_SEQUENCE = 1;
+export const DOLLY_HTTP_WORD_STATUS = 2;
+export const DOLLY_HTTP_WORD_LENGTH = 3;
+export const DOLLY_HTTP_WORD_EOF = 4;
+export const DOLLY_HTTP_WORD_ERROR = 5;
+export const DOLLY_HTTP_WORD_KIND = 6;
+export const DOLLY_HTTP_STATE_IDLE = 0;
+export const DOLLY_HTTP_STATE_WRITABLE = 1;
+export const DOLLY_HTTP_STATE_READABLE = 2;
+export const DOLLY_HTTP_STATE_FAILED = 3;
+export const DOLLY_HTTP_KIND_URL = 1;
+export const DOLLY_HTTP_KIND_HEADER = 2;
+export const DOLLY_HTTP_KIND_BODY = 3;
+export const DOLLY_HTTP_START = 80;
+export const DOLLY_HTTP_POLL = 81;
+export const DOLLY_HTTP_CANCEL = 82;
+export const DOLLY_HTTP_BODY_WRITE = 83;
+export const 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 });
+export const DOLLY_HTTP_ABI_DIGEST = "429f0fdb280240a4429fdeb550e6710453d81ac51b7eb662dd43b024fcfaaaed";