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

package/src/image-names.mjs

@@ -0,0 +1,11 @@
+// What a recipe may name: an image, and the paths no image retains.
+
+// Image names: [a-z][a-z0-9]*(-[a-z0-9]+|\.[0-9]+)*, at most 32 bytes. A dot
+// starts a run of version digits, so a documentation copy such as
+// Dollyfile-example.txt is never a recipe.
+export const validName = name => /^[a-z][a-z0-9]*(?:-[a-z0-9]+|\.[0-9]+)*$/.test(name) && name.length <= 32;
+
+// No image retains scratch space.
+export function unretainedPath(value) {
+  return ["/tmp", "/workspace"].some((prefix) => value === prefix || value.startsWith(`${prefix}/`));
+}

package/src/images.mjs

@@ -0,0 +1,10 @@
+// The images a page runs and where their files are. An image directory holds
+// dist/dolly-images.mjs (its catalog), each image's metadata and packs under
+// dist/, and the recipes and sources at their site paths. The site is one such
+// directory; an embedding names its own (boot's `images`). The page and the
+// Worker each load it once, before anything reads it.
+export let DOLLY_IMAGES = [], DOLLY_STATIC_SOURCES = [], imageBase;
+export async function loadImages(base) {
+  imageBase = new URL(base);
+  ({ DOLLY_IMAGES, DOLLY_STATIC_SOURCES } = await import(new URL("dist/dolly-images.mjs", imageBase).href));
+}

package/src/kernel-plugin.mjs

@@ -0,0 +1,77 @@
+import { DOLLY_KERNEL_PLUGIN_ABI_DIGEST, DOLLY_KERNEL_PLUGIN_IMPORTS } from "../dist/dolly-kernel-plugin-abi.mjs";
+import { hex } from "./static-asset.mjs";
+import { Reader } from "./wasm-interface.mjs";
+
+// Boot-only Wasm linking, not a browser capability imported by the guest.
+// Inputs are bytes and real kernel Wasm exports. No paths, URLs, JavaScript
+// callbacks, dependency loading, or ambient symbol lookup enter this module.
+const maximumBytes = 64 * 1024 * 1024;
+
+function allocationRequirements(module) {
+  const sections = WebAssembly.Module.customSections(module, "dylink.0");
+  if (sections.length !== 1) throw new TypeError("plugin needs one dylink.0 record");
+  const reader = new Reader(new Uint8Array(sections[0]), "plugin dylink.0");
+  // This profile has exactly the memory/table allocation subsection, with no
+  // NEEDED libraries, runtime paths, or other loader extensions.
+  if (reader.unsigned(8) !== 1n) throw new TypeError("unsupported plugin linking record");
+  const record = reader.subreader(reader.u32(), "plugin allocation record");
+  const size = record.unsigned(64);
+  const alignment = record.unsigned(32);
+  const tableSize = record.unsigned(64);
+  const tableAlignment = record.unsigned(32);
+  if (!reader.done || !record.done || size > BigInt(maximumBytes) || alignment > 20n ||
+      tableSize > 65536n || tableAlignment !== 0n) {
+    throw new TypeError("unsupported plugin allocation requirements");
+  }
+  return { size, alignment: 1n << alignment, tableSize };
+}
+
+export function instantiateKernelPlugin(bytes, kernel, memory) {
+  if (!(bytes instanceof Uint8Array) || bytes.length < 8 || bytes.length > maximumBytes) {
+    throw new TypeError("invalid resident plugin bytes");
+  }
+  const module = new WebAssembly.Module(bytes);
+  const stamps = WebAssembly.Module.customSections(module, "dolly.abi");
+  if (stamps.length !== 1 || hex(stamps[0]) !== DOLLY_KERNEL_PLUGIN_ABI_DIGEST) {
+    throw new TypeError("resident plugin has the wrong ABI stamp");
+  }
+  for (const { name } of WebAssembly.Module.exports(module)) {
+    if (name.startsWith("__em_js__") || /^__(?:start|stop)_em_(?:asm|js)$/.test(name)) {
+      throw new TypeError("resident plugins cannot contain JavaScript bindings");
+    }
+  }
+  const table = kernel.__indirect_function_table;
+  const env = {
+    memory,
+    __indirect_function_table: table,
+    __stack_pointer: kernel.__stack_pointer,
+    __memory_base: undefined,
+    __table_base: undefined,
+    ...Object.fromEntries(DOLLY_KERNEL_PLUGIN_IMPORTS.map(name => [name, kernel[name]])),
+  };
+  for (const imported of WebAssembly.Module.imports(module)) {
+    if (imported.module !== "env" || !Object.hasOwn(env, imported.name)) {
+      throw new TypeError(`unsupported resident plugin import: ${imported.module}.${imported.name}`);
+    }
+  }
+  const { size, alignment, tableSize } = allocationRequirements(module);
+  const allocation = kernel.malloc(size + alignment);
+  if (allocation === 0n) throw new RangeError("resident plugin allocation failed");
+  const base = (allocation + alignment - 1n) & -alignment;
+  const end = base + size;
+  if (base < 0n || end > BigInt(memory.buffer.byteLength)) {
+    throw new RangeError("resident plugin allocation is outside kernel memory");
+  }
+  // Code, table entries, and static data are resident until the kernel dies.
+  // In particular, never free storage after a partially instantiated module
+  // might have installed table entries pointing at it.
+  new Uint8Array(memory.buffer, Number(base), Number(size)).fill(0);
+  env.__memory_base = new WebAssembly.Global({ value: "i64" }, base);
+  env.__table_base = new WebAssembly.Global({ value: "i64" }, table.grow(tableSize));
+  // These are actual Wasm function exports, not JS forwarding wrappers. The
+  // engine checks their exact function types at this instantiation boundary.
+  const instance = new WebAssembly.Instance(module, { env });
+  instance.exports.__wasm_apply_data_relocs?.();
+  instance.exports.__wasm_call_ctors?.();
+  return instance;
+}

package/src/packaged-snapshot.mjs

@@ -0,0 +1,175 @@
+// The images of an image directory as the page and the Worker load them: each
+// one's metadata, checked against the catalog and the recipes the directory
+// serves, and its packs, streamed or whole.
+import { DOLLY_IMAGE_BUILD_ID } from "../dist/dolly-image-build-id.mjs";
+import { DOLLY_IMAGES, imageBase } from "./images.mjs";
+import { imageInputs, imageInputsMatch } from "./image-inputs.mjs";
+import { hostRequirements } from "../host/requirements.mjs";
+import { siteReference, sitePath, decodeStaticAsset, sha256 } from "./static-asset.mjs";
+import { mergeSnapshotRecords, validateSnapshotPacks, MAX_SNAPSHOT_BYTES as snapshotSizeLimit } from "./snapshot-records.mjs";
+import { unretainedPath } from "./image-names.mjs";
+const definitionOf = image => DOLLY_IMAGES.find(definition => definition.image === image);
+const encoder = new TextEncoder();
+const expectedRecipes = image => definitionOf(image).recipes;
+
+function validSnapshotPath(path) {
+  return typeof path === "string" && path.startsWith("/") && path.length > 1 &&
+    path.length <= 4096 && !path.includes("\\") && !path.includes("\0") &&
+    !path.includes("//") &&
+    !path.split("/").some((part) => part === "." || part === "..") &&
+    !unretainedPath(path);
+}
+
+async function verifyVisibleRecipes(recipes) {
+  for (const recipe of recipes) {
+    const response = await fetch(new URL(sitePath(recipe.sourcePath).slice(1), imageBase), {
+      cache: "no-store", credentials: "same-origin", redirect: "error",
+    });
+    if (!response.ok) throw new Error(`${recipe.sourcePath} returned HTTP ${response.status}`);
+    const bytes = await response.arrayBuffer();
+    if (bytes.byteLength !== recipe.byteLength || await sha256(bytes) !== recipe.sha256) {
+      throw new Error(`${recipe.sourcePath} does not match the packaged snapshot recipe`);
+    }
+  }
+}
+
+export async function loadPackagedSnapshotMetadata(image, checked = new Map(), active = new Set()) {
+  if (checked.has(image)) return checked.get(image);
+  if (active.has(image)) throw new Error("packaged image cycle");
+  active.add(image);
+  const metadataUrl = new URL(
+    `dist/dolly-${image}-system-snapshot.mjs`, imageBase,
+  );
+  let metadata;
+  try {
+    ({ DOLLY_SYSTEM_SNAPSHOT: metadata } = await import(metadataUrl.href));
+  } catch {
+    throw new Error(`The packaged ${image} snapshot is missing. Run npm run image -- ${image} first.`);
+  }
+  const recipes = expectedRecipes(image);
+  if (metadata === null || typeof metadata !== "object" ||
+      metadata.image !== image || metadata.buildId !== DOLLY_IMAGE_BUILD_ID ||
+      metadata.formatVersion !== 2 || metadata.identityVersion !== 2 ||
+      JSON.stringify(metadata.recipes) !== JSON.stringify(recipes) ||
+      JSON.stringify(hostRequirements(metadata.hostRequirements)) !== JSON.stringify(definitionOf(image).hostRequirements ?? []) ||
+      !Number.isSafeInteger(metadata.byteLength) || metadata.byteLength <= 0 ||
+      metadata.byteLength > snapshotSizeLimit ||
+      (![undefined, "gzip", "packs"].includes(metadata.encoding)) ||
+      (metadata.encoding === "gzip" &&
+       (!Number.isSafeInteger(metadata.encodedByteLength) ||
+        metadata.encodedByteLength <= 0 || metadata.encodedByteLength > snapshotSizeLimit)) ||
+      !/^[0-9a-f]{64}$/.test(metadata.sha256) ||
+      !Array.isArray(metadata.manifest) || metadata.manifest.length === 0 ||
+      metadata.manifest.length > 100_000) {
+    throw new Error("The packaged system snapshot metadata does not match this Dolly build");
+  }
+  if (metadata.encoding === "packs") validateSnapshotPacks(metadata);
+  const inputs = imageInputs(metadata.inputs);
+  const references = [...new Set(definitionOf(image).artifacts.map(reference => reference.sha256))].sort();
+  if (JSON.stringify(inputs.map(input => input.recipeSha256)) !== JSON.stringify(references)) {
+    throw new Error("The packaged system snapshot has stale image inputs");
+  }
+  let manifestBytes = 0;
+  // The Wasm reader validates ordering by UTF-8 bytes, not JS UTF-16 strings.
+  for (const path of metadata.manifest) {
+    if (!validSnapshotPath(path)) {
+      throw new Error("The packaged system snapshot has an invalid retained-path manifest");
+    }
+    manifestBytes += encoder.encode(path).byteLength + 1;
+  }
+  if (manifestBytes > 8 * 1024 * 1024) {
+    throw new Error("The packaged system snapshot manifest is too large");
+  }
+  for (const required of [
+    "/etc/dolly/Dollyfile",
+    "/etc/dolly/environment",
+    "/etc/dolly/image",
+    "/etc/dolly/recipes.lock",
+  ]) {
+    if (!metadata.manifest.includes(required)) {
+      throw new Error(`The packaged system snapshot is missing ${required}`);
+    }
+  }
+  const expectedInputs = [];
+  for (const reference of definitionOf(image).artifacts) {
+    const dependency = DOLLY_IMAGES.find(candidate =>
+      siteReference(candidate.dollyfile) === reference.location && candidate.sha256 === reference.sha256);
+    if (!dependency) throw new Error("packaged image input is missing");
+    const parent = await loadPackagedSnapshotMetadata(dependency.image, checked, active);
+    expectedInputs.push({ recipeSha256: reference.sha256, sha256: parent.sha256 });
+  }
+  if (!imageInputsMatch(inputs, expectedInputs)) throw new Error("The packaged system snapshot has stale image inputs");
+  if (active.size === 1) await verifyVisibleRecipes(recipes);
+  active.delete(image);
+  checked.set(image, metadata);
+  return metadata;
+}
+
+async function* packagedSnapshotParts(image, metadata, signal) {
+  const packed = metadata.encoding === "packs";
+  const parts = packed ? validateSnapshotPacks(metadata) : [metadata];
+  for (const part of parts) {
+    signal?.throwIfAborted();
+    const compressed = packed || metadata.encoding === "gzip";
+    const url = packed
+      ? new URL(`dist/packs/${part.sha256}.snapshot.gz`, imageBase)
+      : new URL(`dist/dolly-${image}-system.snapshot${compressed ? ".gz" : ""}`, imageBase);
+    const init = { cache: packed ? "force-cache" : "no-store", credentials: "same-origin", redirect: "error", signal };
+    const expected = compressed ? part.encodedByteLength : part.byteLength;
+    const response = await decodeStaticAsset(await fetch(url, init), url, init, expected);
+    if (!response.ok || !response.body) throw new Error(`snapshot returned HTTP ${response.status}`);
+    const declared = response.headers.get("content-length");
+    if (declared !== null && Number(declared) !== expected) throw new Error("snapshot HTTP content length mismatch");
+    const body = compressed ? response.body.pipeThrough(new DecompressionStream("gzip")) : response.body;
+    yield { ...part, body };
+  }
+}
+
+// The sink owns incremental hashing. Every part is checked before another is
+// requested; the caller verifies the complete canonical image before booting.
+export async function streamPackagedSystemSnapshot(image, metadata, write, endPart, signal) {
+  for await (const part of packagedSnapshotParts(image, metadata, signal)) {
+    const reader = part.body.getReader();
+    let size = 0;
+    try {
+      for (;;) {
+        signal?.throwIfAborted();
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value.length > part.byteLength - size) throw new Error("snapshot exceeds declared size");
+        await write(value);
+        size += value.length;
+      }
+      if (size !== part.byteLength || await endPart() !== part.sha256) throw new Error("snapshot integrity mismatch");
+    } catch (error) {
+      await reader.cancel().catch(() => {});
+      throw error;
+    } finally { reader.releaseLock(); }
+  }
+}
+
+export async function loadPackagedSystemSnapshot(image, metadata, signal) {
+  const parts = [];
+  for await (const part of packagedSnapshotParts(image, metadata, signal)) {
+    const reader = part.body.getReader(), bytes = new Uint8Array(part.byteLength);
+    let offset = 0;
+    try {
+      for (;;) {
+        signal?.throwIfAborted();
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value.length > bytes.length - offset) throw new Error("snapshot exceeds declared size");
+        bytes.set(value, offset);
+        offset += value.length;
+      }
+      if (offset !== bytes.length || await sha256(bytes) !== part.sha256) throw new Error("snapshot integrity mismatch");
+      parts.push(bytes);
+    } catch (error) {
+      await reader.cancel().catch(() => {});
+      throw error;
+    } finally { reader.releaseLock(); }
+  }
+  const bytes = parts.length === 1 ? parts[0] : mergeSnapshotRecords(parts);
+  if (bytes.length !== metadata.byteLength || await sha256(bytes) !== metadata.sha256) throw new Error("packed snapshot integrity mismatch");
+  return bytes.buffer;
+}

package/src/page-chords.mjs

@@ -0,0 +1,43 @@
+import { toggleIndicators } from "./page-indicators.mjs";
+
+// The page's own keys, taken before any host module or the guest reads them:
+// F11 toggles fullscreen and Ctrl+Shift+F the page's indicators. Listening
+// starts with the page, so they work while an image boots.
+export function pageChords(keyboard) {
+  async function toggleFullscreen() {
+    try {
+      if (document.fullscreenElement) {
+        await document.exitFullscreen();
+      } else {
+        await document.documentElement.requestFullscreen({ navigationUI: "hide" });
+      }
+    } catch {
+      document.documentElement.dataset.fullscreen = "failed";
+    }
+  }
+
+  // Ctrl+Shift+F, and the release of an F the page took.
+  let indicatorsKeyDown = false;
+  function indicatorsChord(event) {
+    if (event.code !== "KeyF") return false;
+    const taken = event.type === "keyup" ? indicatorsKeyDown
+      : event.ctrlKey && event.shiftKey && !event.altKey && !event.metaKey;
+    indicatorsKeyDown = taken && event.type === "keydown";
+    return taken;
+  }
+
+  function take(event) {
+    const fullscreen = event.key === "F11";
+    if (!fullscreen && !indicatorsChord(event)) return;
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    if (event.type === "keydown" && !event.repeat) fullscreen ? void toggleFullscreen() : toggleIndicators();
+  }
+  window.addEventListener("keydown", take, { capture: true });
+  window.addEventListener("keyup", take, { capture: true });
+  document.addEventListener("fullscreenchange", () => {
+    document.documentElement.dataset.fullscreen = document.fullscreenElement ? "on" : "off";
+    // Firefox lets focus leave a modal dialog once the page is fullscreen.
+    if (!document.querySelector("dialog[open]")) keyboard.focus({ preventScroll: true });
+  });
+}

package/src/page-indicators.mjs

@@ -0,0 +1,27 @@
+// The page's own elements over the display's corners (class page-indicator:
+// the GPU adapter, the session Save button, download offers). They show when
+// the page is ready and when one changes state, hide ten seconds later unless
+// a state the user must not miss holds them, and Ctrl+Shift+F shows or hides
+// them (page-chords.mjs). Only page code calls this; a guest reaches none of
+// it.
+const holders = new Set();
+let timer;
+const set = shown => { document.documentElement.dataset.indicators = shown ? "shown" : "hidden"; };
+
+export function showIndicators() {
+  clearTimeout(timer);
+  set(true);
+  timer = setTimeout(() => { if (!holders.size) set(false); }, 10_000);
+}
+
+// Holding shows them until the holder lets go, then for ten more seconds.
+export function holdIndicators(holder, held) {
+  if (held) holders.add(holder);
+  else if (!holders.delete(holder)) return;
+  showIndicators();
+}
+
+export function toggleIndicators() {
+  clearTimeout(timer);
+  set(document.documentElement.dataset.indicators === "hidden");
+}

package/src/process-abi.mjs

@@ -0,0 +1,69 @@
+import { formatWasmType, sameWasmType } from "./wasm-interface.mjs";
+import { hex } from "./static-asset.mjs";
+
+export function unique(entries, key) {
+  const result = 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;
+}
+
+// Both the build tools and browser admission call this exact validator on
+// parsed bytes. The contract is assembled from abi/dolly-process-0.wat.
+export function validateProcessInterface(contract, process, digest) {
+  const fail = message => { throw new TypeError(`${process.label}: ${message}`); };
+  const section = name => {
+    const entries = process.customSectionData.filter(x => x.name === name);
+    if (entries.length !== 1) fail(`expected exactly one ${name} section`);
+    return entries[0].data;
+  };
+  if (process.customSections.includes("dylink.0")) {
+    fail("a process executable must not be a side module");
+  }
+  const stamp = hex(section("dolly.process"));
+  if (stamp !== digest) fail("wrong dolly.process stamp");
+  const key = x => `${x.module}.${x.name}`;
+  const allowed = unique(contract.imports, key);
+  const actual = unique(process.imports, key);
+  if (allowed.size !== 2 || !allowed.has("env.memory") || !allowed.has("dolly_process_0.call")) {
+    throw new TypeError("process contract must contain only memory and call");
+  }
+  for (const name of actual.keys()) if (!allowed.has(name)) fail(`import ${name} is outside dolly-process-0`);
+  if (actual.size !== allowed.size) fail("expected exactly the two dolly-process-0 imports");
+  let memory;
+  for (const [name, expected] of allowed) {
+    const entry = actual.get(name);
+    if (!entry) fail(`missing required import ${name}`);
+    const type = entry.type;
+    if (name === "env.memory") {
+      if (type.kind !== "memory" || expected.type.kind !== "memory" ||
+          type.address64 !== expected.type.address64 || type.shared !== expected.type.shared ||
+          type.minimum < expected.type.minimum || type.maximum === null ||
+          expected.type.maximum === null || type.maximum > expected.type.maximum ||
+          type.minimum > type.maximum) {
+        fail(`process memory is outside ${formatWasmType(expected.type)}`);
+      }
+      const bytes = section("dolly.process.memory");
+      if (bytes.length !== 16) fail("expected a 16-byte dolly.process.memory section");
+      const record = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      if (record.getBigUint64(0, true) !== type.minimum ||
+          record.getBigUint64(8, true) !== type.maximum) {
+        fail("dolly.process.memory does not match its memory import");
+      }
+      memory = { initial: type.minimum, maximum: type.maximum };
+    } else if (!sameWasmType(type, expected.type)) {
+      fail(`import ${name} must be ${formatWasmType(expected.type)}`);
+    }
+  }
+  const exports = unique(process.exports, x => x.name);
+  for (const expected of contract.exports) {
+    const entry = exports.get(expected.name);
+    if (!entry || !sameWasmType(entry.type, expected.type)) {
+      fail(`missing or incompatible process export ${expected.name}`);
+    }
+  }
+  return memory;
+}

package/src/process-constants.mjs

@@ -0,0 +1,242 @@
+// Generated from include/dolly/process.h.
+export const DOLLY_PROCESS_PACKET_LIMIT = 1048576;
+export const DOLLY_PROCESS_ARGUMENT_SIZES = 1;
+export const DOLLY_PROCESS_ARGUMENTS = 2;
+export const DOLLY_PROCESS_ENVIRONMENT_SIZES = 3;
+export const DOLLY_PROCESS_ENVIRONMENT = 4;
+export const DOLLY_PROCESS_EXIT = 5;
+export const DOLLY_PROCESS_FD_READ = 16;
+export const DOLLY_PROCESS_FD_WRITE = 17;
+export const DOLLY_PROCESS_FD_CLOSE = 18;
+export const DOLLY_PROCESS_FD_SEEK = 19;
+export const DOLLY_PROCESS_FD_STAT = 20;
+export const DOLLY_PROCESS_FD_SYNC = 21;
+export const DOLLY_PROCESS_FD_DUP = 22;
+export const DOLLY_PROCESS_FD_PIPE = 23;
+export const DOLLY_PROCESS_FD_READ_DIRECTORY = 24;
+export const DOLLY_PROCESS_FD_PREAD = 25;
+export const DOLLY_PROCESS_FD_TRUNCATE = 26;
+export const DOLLY_PROCESS_FD_STAT_FILESYSTEM = 27;
+export const DOLLY_PROCESS_FD_SET_TIMES = 28;
+export const DOLLY_PROCESS_FD_PWRITE = 29;
+export const DOLLY_PROCESS_FD_GET_FLAGS = 30;
+export const DOLLY_PROCESS_FD_SET_FLAGS = 31;
+export const DOLLY_PROCESS_PATH_OPEN = 32;
+export const DOLLY_PROCESS_PATH_STAT = 33;
+export const DOLLY_PROCESS_PATH_CREATE_DIRECTORY = 34;
+export const DOLLY_PROCESS_PATH_REMOVE = 35;
+export const DOLLY_PROCESS_PATH_RENAME = 36;
+export const DOLLY_PROCESS_PATH_LINK = 37;
+export const DOLLY_PROCESS_PATH_SYMLINK = 38;
+export const DOLLY_PROCESS_PATH_READLINK = 39;
+export const DOLLY_PROCESS_PATH_GET_CURRENT_DIRECTORY = 40;
+export const DOLLY_PROCESS_PATH_SET_CURRENT_DIRECTORY = 41;
+export const DOLLY_PROCESS_PATH_STAT_FILESYSTEM = 42;
+export const DOLLY_PROCESS_PATH_SET_TIMES = 43;
+export const DOLLY_PROCESS_CLOCK_TIME = 48;
+export const DOLLY_PROCESS_RANDOM = 49;
+export const DOLLY_PROCESS_TERMINAL = 50;
+export const DOLLY_PROCESS_CLOCK_RESOLUTION = 52;
+export const DOLLY_PROCESS_CLOCK_SLEEP = 53;
+export const DOLLY_PROCESS_FD_POLL = 54;
+export const DOLLY_PROCESS_FD_GET_DESCRIPTOR_FLAGS = 55;
+export const DOLLY_PROCESS_FD_SET_DESCRIPTOR_FLAGS = 56;
+export const DOLLY_PROCESS_FD_LOCK = 59;
+export const DOLLY_PROCESS_EXEC = 61;
+export const DOLLY_PROCESS_SPAWN = 64;
+export const DOLLY_PROCESS_WAIT = 65;
+export const DOLLY_PROCESS_INTERRUPT_POLL = 66;
+export const DOLLY_PROCESS_INFO = 67;
+export const DOLLY_PROCESS_SIGNAL = 68;
+export const DOLLY_PROCESS_SIGNAL_ACKNOWLEDGE = 69;
+export const DOLLY_PROCESS_ALARM = 70;
+export const DOLLY_PROCESS_ALARM_HANDLED = 71;
+export const DOLLY_PROCESS_SPAWN_INHERIT_ENVIRONMENT = 1;
+export const DOLLY_PROCESS_SPAWN_FOREGROUND = 2;
+export const DOLLY_PROCESS_SPAWN_INTERACTIVE = 4;
+export const DOLLY_PROCESS_INHERIT_FDS_NONE = 0;
+export const DOLLY_PROCESS_INHERIT_FDS_STDIO = 1;
+export const DOLLY_PROCESS_INHERIT_FDS_ALL = 2;
+export const DOLLY_PROCESS_FD_CLOEXEC = 1;
+export const DOLLY_PROCESS_FD_KEEP_LOCKS = 2;
+export const DOLLY_PROCESS_WAIT_NONBLOCK = 1;
+export const DOLLY_PROCESS_SIGHUP = 1;
+export const DOLLY_PROCESS_SIGINT = 2;
+export const DOLLY_PROCESS_SIGQUIT = 3;
+export const DOLLY_PROCESS_SIGABRT = 6;
+export const DOLLY_PROCESS_SIGKILL = 9;
+export const DOLLY_PROCESS_SIGPIPE = 13;
+export const DOLLY_PROCESS_SIGALRM = 14;
+export const DOLLY_PROCESS_SIGTERM = 15;
+export const DOLLY_PROCESS_SIGCHLD = 17;
+export const DOLLY_PROCESS_SIGWINCH = 28;
+export const DOLLY_PROCESS_SIGNAL_MASK = 268493390;
+export const DOLLY_PROCESS_FD_DUP_MINIMUM = 1;
+export const DOLLY_PROCESS_FD_DUP_CLOEXEC = 2;
+export const DOLLY_PROCESS_FD_STATUS_READ = 1;
+export const DOLLY_PROCESS_FD_STATUS_WRITE = 2;
+export const DOLLY_PROCESS_FD_STATUS_APPEND = 4;
+export const DOLLY_PROCESS_FD_STATUS_NONBLOCK = 8;
+export const DOLLY_PROCESS_SEEK_SET = 0;
+export const DOLLY_PROCESS_SEEK_CURRENT = 1;
+export const DOLLY_PROCESS_SEEK_END = 2;
+export const DOLLY_PROCESS_CLOCK_REALTIME = 0;
+export const DOLLY_PROCESS_CLOCK_MONOTONIC = 1;
+export const DOLLY_PROCESS_OPEN_READ = 1;
+export const DOLLY_PROCESS_OPEN_WRITE = 2;
+export const DOLLY_PROCESS_OPEN_CREATE = 4;
+export const DOLLY_PROCESS_OPEN_EXCLUSIVE = 8;
+export const DOLLY_PROCESS_OPEN_TRUNCATE = 16;
+export const DOLLY_PROCESS_OPEN_APPEND = 32;
+export const DOLLY_PROCESS_OPEN_DIRECTORY = 64;
+export const DOLLY_PROCESS_OPEN_NOFOLLOW = 128;
+export const DOLLY_PROCESS_OPEN_CLOEXEC = 256;
+export const DOLLY_PROCESS_PATH_DIRECTORY = 1;
+export const DOLLY_PROCESS_PATH_NOFOLLOW = 2;
+export const DOLLY_PROCESS_TIME_NOW = 1;
+export const DOLLY_PROCESS_TIME_OMIT = 2;
+export const DOLLY_PROCESS_FILE_UNKNOWN = 0;
+export const DOLLY_PROCESS_FILE_REGULAR = 1;
+export const DOLLY_PROCESS_FILE_DIRECTORY = 2;
+export const DOLLY_PROCESS_FILE_SYMBOLIC_LINK = 3;
+export const DOLLY_PROCESS_FILE_CHARACTER_DEVICE = 4;
+export const DOLLY_PROCESS_FILE_BLOCK_DEVICE = 5;
+export const DOLLY_PROCESS_FILE_FIFO = 6;
+export const DOLLY_PROCESS_FILE_SOCKET = 7;
+export const DOLLY_PROCESS_POLL_READ = 1;
+export const DOLLY_PROCESS_POLL_WRITE = 2;
+export const DOLLY_PROCESS_POLL_PRIORITY = 4;
+export const DOLLY_PROCESS_POLL_ERROR = 8;
+export const DOLLY_PROCESS_POLL_HANGUP = 16;
+export const DOLLY_PROCESS_POLL_INVALID = 32;
+export const DOLLY_PROCESS_POLL_IGNORED_DESCRIPTOR = 4294967295;
+export const DOLLY_PROCESS_TERMINAL_READ = 1;
+export const DOLLY_PROCESS_TERMINAL_ISATTY = 2;
+export const DOLLY_PROCESS_TERMINAL_MODE_GET = 3;
+export const DOLLY_PROCESS_TERMINAL_MODE_SET = 4;
+export const DOLLY_PROCESS_TERMINAL_SIZE = 5;
+export const DOLLY_PROCESS_TERMINAL_PUBLISH_RESULT = 6;
+export const DOLLY_PROCESS_LOCK_SHARED = 0;
+export const DOLLY_PROCESS_LOCK_EXCLUSIVE = 1;
+export const DOLLY_PROCESS_LOCK_UNLOCK = 2;
+export const DOLLY_PROCESS_LOCK_DESCRIPTION = 1;
+export const DOLLY_PROCESS_LOCK_WAIT = 2;
+export const DOLLY_PROCESS_LOCK_TEST = 4;
+export const DOLLY_PROCESS_FD_MAPPING_CLOSED = 4294967295;
+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_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,
+});