@daugasauron/dolly 0.1.5 → 0.1.6

package/dist/dolly-runtime-worker.mjs

@@ -0,0 +1,1544 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// host/abi.mjs
+var DOLLY_HOST_MAX_RECORDS;
+var init_abi = __esm({
+  "host/abi.mjs"() {
+    DOLLY_HOST_MAX_RECORDS = 64;
+  }
+});
+
+// page/image-names.mjs
+function unretainedPath(value) {
+  return value === "/tmp" || value.startsWith("/tmp/");
+}
+var init_image_names = __esm({
+  "page/image-names.mjs"() {
+  }
+});
+
+// host/runtime/abi.mjs
+var DOLLY_SNAPSHOT_HEADER_BYTES, DOLLY_SNAPSHOT_MAX_PATHS, DOLLY_SNAPSHOT_MAX_MEBIBYTES, DOLLY_ENTRY_VERSION, DOLLY_ENTRY_HEADER_BYTES, DOLLY_ENTRY_MAX_ARGUMENTS, DOLLY_ENTRY_ARGUMENT_MAX_BYTES, DOLLY_ENTRY_MAX_BYTES, DOLLY_ERRNO;
+var init_abi2 = __esm({
+  "host/runtime/abi.mjs"() {
+    DOLLY_SNAPSHOT_HEADER_BYTES = 16;
+    DOLLY_SNAPSHOT_MAX_PATHS = 1e5;
+    DOLLY_SNAPSHOT_MAX_MEBIBYTES = 2048;
+    DOLLY_ENTRY_VERSION = 1;
+    DOLLY_ENTRY_HEADER_BYTES = 16;
+    DOLLY_ENTRY_MAX_ARGUMENTS = 256;
+    DOLLY_ENTRY_ARGUMENT_MAX_BYTES = 4096;
+    DOLLY_ENTRY_MAX_BYTES = 65536;
+    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 });
+  }
+});
+
+// page/snapshot-records.mjs
+function validateSnapshotPacks(metadata) {
+  if (!Array.isArray(metadata.packs) || metadata.packs.length === 0 || metadata.packs.length > MAX_SNAPSHOT_PACKS) throw new Error("invalid snapshot packs");
+  const hashes = /* @__PURE__ */ new Set();
+  let size = DOLLY_SNAPSHOT_HEADER_BYTES;
+  for (const pack of metadata.packs) {
+    if (!/^[0-9a-f]{64}$/.test(pack.sha256) || hashes.has(pack.sha256) || !Number.isSafeInteger(pack.byteLength) || pack.byteLength < DOLLY_SNAPSHOT_HEADER_BYTES || pack.byteLength > MAX_SNAPSHOT_BYTES || !Number.isSafeInteger(pack.encodedByteLength) || pack.encodedByteLength <= 0 || pack.encodedByteLength > MAX_SNAPSHOT_BYTES) {
+      throw new Error("invalid snapshot pack descriptor");
+    }
+    hashes.add(pack.sha256);
+    size += pack.byteLength - DOLLY_SNAPSHOT_HEADER_BYTES;
+    if (size > MAX_SNAPSHOT_BYTES) throw new Error("packed snapshot exceeds size limit");
+  }
+  if (size !== metadata.byteLength) throw new Error("snapshot pack sizes do not match image");
+  return metadata.packs;
+}
+var decoder, encoder, MAX_SNAPSHOT_BYTES, MAX_SNAPSHOT_PACKS;
+var init_snapshot_records = __esm({
+  "page/snapshot-records.mjs"() {
+    init_image_names();
+    init_abi2();
+    decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    encoder = new TextEncoder();
+    MAX_SNAPSHOT_BYTES = DOLLY_SNAPSHOT_MAX_MEBIBYTES * 1024 * 1024;
+    MAX_SNAPSHOT_PACKS = MAX_SNAPSHOT_BYTES / (1024 * 1024);
+  }
+});
+
+// page/version.mjs
+var DOLLY_VERSION;
+var init_version = __esm({
+  "page/version.mjs"() {
+    DOLLY_VERSION = "0.1.6";
+  }
+});
+
+// page/static-asset.mjs
+async function sha256(bytes) {
+  return hex(await crypto.subtle.digest("SHA-256", bytes));
+}
+async function boundedAssetBody(response, limit, signal) {
+  if (!response.ok || !response.body) throw new Error(`asset returned HTTP ${response.status}`);
+  const reader = response.body.getReader(), chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      signal?.throwIfAborted();
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.length;
+      if (size > limit) {
+        await reader.cancel();
+        throw new Error("asset exceeds declared size");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+async function peeked(response, length) {
+  const reader = response.body.getReader(), chunks = [];
+  let size = 0, ended = false;
+  while (size < length) {
+    const next = await reader.read();
+    if (next.done) {
+      ended = true;
+      break;
+    }
+    chunks.push(next.value);
+    size += next.value.length;
+  }
+  const head = new Uint8Array(Math.min(size, length));
+  for (let offset = 0, index = 0; offset < head.length; ++index) {
+    const taken = chunks[index].subarray(0, head.length - offset);
+    head.set(taken, offset);
+    offset += taken.length;
+  }
+  const body = new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) controller.enqueue(chunk);
+      if (ended) controller.close();
+    },
+    async pull(controller) {
+      const next = await reader.read();
+      if (next.done) controller.close();
+      else controller.enqueue(next.value);
+    },
+    cancel: (reason) => reader.cancel(reason)
+  }, { highWaterMark: 0 });
+  const whole = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+  Object.defineProperty(whole, "url", { value: response.url });
+  return { head, whole };
+}
+async function decodeStaticAsset(given, target, init, maximumBytes, fetchRequest = globalThis.fetch.bind(globalThis)) {
+  if (given.status !== 200 || !given.body) return given;
+  const start = new TextEncoder().encode(PARTS_MANIFEST_START), { head, whole: response } = await peeked(given, start.length);
+  if (head.length !== start.length || head.some((byte, index2) => byte !== start[index2])) return response;
+  const url = new URL(target);
+  if ((init.method ?? "GET") !== "GET" || url.search || url.hash || url.username || url.password || !/^https?:$/.test(url.protocol)) throw new Error("invalid multipart asset request");
+  const manifest = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(await boundedAssetBody(response, 65536, init.signal)));
+  if (!Number.isSafeInteger(manifest.byteLength) || manifest.byteLength <= 0 || manifest.byteLength > maximumBytes || manifest.byteLength > MAX_SNAPSHOT_BYTES || !Array.isArray(manifest.parts) || manifest.parts.length < 2 || manifest.parts.length > staticMaxParts() || manifest.parts.some((part) => !Number.isSafeInteger(part.byteLength) || part.byteLength <= 0 || part.byteLength > STATIC_PART_BYTES || !/^[0-9a-f]{64}$/.test(part.sha256)) || manifest.parts.reduce((size, part) => size + part.byteLength, 0) !== manifest.byteLength) {
+    throw new Error("invalid multipart asset manifest");
+  }
+  let index = 0;
+  const body = new ReadableStream({
+    async pull(controller) {
+      if (index === manifest.parts.length) {
+        controller.close();
+        return;
+      }
+      const part = manifest.parts[index];
+      const partURL = new URL(url);
+      partURL.pathname += `.part-${index++}`;
+      const result = await fetchRequest(partURL, {
+        method: "GET",
+        credentials: "omit",
+        redirect: "error",
+        referrerPolicy: "no-referrer",
+        cache: "force-cache",
+        signal: init.signal
+      });
+      const chunk = await boundedAssetBody(result, part.byteLength, init.signal);
+      if (chunk.length !== part.byteLength || await sha256(chunk) !== part.sha256) throw new Error("asset part integrity mismatch");
+      controller.enqueue(chunk);
+    }
+  }, { highWaterMark: 0 });
+  const headers = new Headers(response.headers);
+  headers.delete("x-dolly-parts");
+  headers.delete("content-encoding");
+  headers.set("content-length", String(manifest.byteLength));
+  const decoded = new Response(body, { status: response.status, statusText: response.statusText, headers });
+  Object.defineProperty(decoded, "url", { value: response.url });
+  return decoded;
+}
+var STATIC_PART_BYTES, staticMaxParts, hex, sitePrefix, siteReference, PARTS_MANIFEST_START;
+var init_static_asset = __esm({
+  "page/static-asset.mjs"() {
+    init_snapshot_records();
+    init_version();
+    STATIC_PART_BYTES = 20 * 1024 * 1024;
+    staticMaxParts = () => Math.ceil(MAX_SNAPSHOT_BYTES / STATIC_PART_BYTES);
+    hex = (bytes) => Array.from(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    sitePrefix = `/v${DOLLY_VERSION}`;
+    siteReference = (path) => `${sitePrefix}/${path}`;
+    PARTS_MANIFEST_START = '{"byteLength":';
+  }
+});
+
+// host/requirements.mjs
+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}`);
+}
+var pattern;
+var init_requirements = __esm({
+  "host/requirements.mjs"() {
+    init_abi();
+    init_static_asset();
+    pattern = /^([a-z][a-z0-9-]{0,30})@(0|[1-9][0-9]{0,4})$/;
+  }
+});
+
+// page/process-constants.mjs
+var DOLLY_ERRNO2, DOLLY_PROCESS_SIZEOF, DOLLY_PROCESS_OFFSETOF;
+var init_process_constants = __esm({
+  "page/process-constants.mjs"() {
+    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
+    });
+    DOLLY_PROCESS_SIZEOF = Object.freeze({
+      dolly_process_vector_sizes: 16,
+      dolly_process_exit_request: 8,
+      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_io_result: 8,
+      dolly_process_fd_dup_request: 16,
+      dolly_process_fd_dup_response: 8,
+      dolly_process_fd_flags: 8,
+      dolly_process_fd_lock_request: 32,
+      dolly_process_fd_lock_response: 24,
+      dolly_process_pipe_request: 8,
+      dolly_process_pipe_response: 8,
+      dolly_process_poll_request: 16,
+      dolly_process_poll_query: 8,
+      dolly_process_poll_response: 16,
+      dolly_process_poll_result: 8,
+      dolly_process_directory_request: 24,
+      dolly_process_directory_entry: 24,
+      dolly_process_fd_seek_request: 16,
+      dolly_process_fd_seek_response: 8,
+      dolly_process_clock_request: 16,
+      dolly_process_clock_response: 8,
+      dolly_process_clock_sleep_request: 16,
+      dolly_process_exec_state: 16,
+      dolly_process_fd_mapping: 8,
+      dolly_process_spawn_request: 72,
+      dolly_process_spawn_response: 8,
+      dolly_process_exec_request: 48,
+      dolly_process_wait_request: 8,
+      dolly_process_wait_response: 16,
+      dolly_process_info_response: 8,
+      dolly_process_signal_request: 8,
+      dolly_process_signal_dispositions: 8,
+      dolly_process_alarm: 16,
+      dolly_process_terminal_request: 24,
+      dolly_process_terminal_response: 16,
+      dolly_process_path_request: 16,
+      dolly_process_path_times_request: 48,
+      dolly_process_path_open_response: 8,
+      dolly_process_stat_response: 88,
+      dolly_process_filesystem_stat_response: 96,
+      dolly_process_two_path_request: 16
+    });
+    DOLLY_PROCESS_OFFSETOF = Object.freeze({
+      dolly_process_vector_sizes: Object.freeze({ "count": 0, "reserved": 4, "bytes": 8 }),
+      dolly_process_exit_request: Object.freeze({ "status": 0, "signal_number": 4 }),
+      dolly_process_fd_io_request: Object.freeze({ "descriptor": 0, "reserved": 4, "size": 8 }),
+      dolly_process_fd_pread_request: Object.freeze({ "descriptor": 0, "reserved": 4, "offset": 8, "size": 16 }),
+      dolly_process_fd_truncate_request: Object.freeze({ "descriptor": 0, "reserved": 4, "size": 8 }),
+      dolly_process_fd_request: Object.freeze({ "descriptor": 0, "reserved": 4 }),
+      dolly_process_timestamp: Object.freeze({ "seconds": 0, "nanoseconds": 8, "flags": 12 }),
+      dolly_process_fd_times_request: Object.freeze({ "descriptor": 0, "reserved": 4, "access": 8, "modification": 24 }),
+      dolly_process_io_result: Object.freeze({ "size": 0 }),
+      dolly_process_fd_dup_request: Object.freeze({ "source_descriptor": 0, "target_descriptor": 4, "flags": 8, "reserved": 12 }),
+      dolly_process_fd_dup_response: Object.freeze({ "descriptor": 0, "reserved": 4 }),
+      dolly_process_fd_flags: Object.freeze({ "descriptor": 0, "flags": 4 }),
+      dolly_process_fd_lock_request: Object.freeze({ "descriptor": 0, "flags": 4, "type": 8, "whence": 12, "start": 16, "length": 24 }),
+      dolly_process_fd_lock_response: Object.freeze({ "type": 0, "pid": 4, "start": 8, "length": 16 }),
+      dolly_process_pipe_request: Object.freeze({ "flags": 0, "reserved": 4 }),
+      dolly_process_pipe_response: Object.freeze({ "read_descriptor": 0, "write_descriptor": 4 }),
+      dolly_process_poll_request: Object.freeze({ "deadline_nanoseconds": 0, "count": 8, "reserved": 12 }),
+      dolly_process_poll_query: Object.freeze({ "descriptor": 0, "events": 4, "reserved": 6 }),
+      dolly_process_poll_response: Object.freeze({ "ready": 0, "count": 4, "reserved": 8 }),
+      dolly_process_poll_result: Object.freeze({ "events": 0, "reserved": 2, "reserved2": 4 }),
+      dolly_process_directory_request: Object.freeze({ "descriptor": 0, "maximum_entries": 4, "cookie": 8, "reserved": 16 }),
+      dolly_process_directory_entry: Object.freeze({ "inode": 0, "next_cookie": 8, "file_type": 16, "name_size": 20 }),
+      dolly_process_fd_seek_request: Object.freeze({ "descriptor": 0, "whence": 4, "offset": 8 }),
+      dolly_process_fd_seek_response: Object.freeze({ "offset": 0 }),
+      dolly_process_clock_request: Object.freeze({ "clock_id": 0, "reserved": 4, "precision_nanoseconds": 8 }),
+      dolly_process_clock_response: Object.freeze({ "nanoseconds": 0 }),
+      dolly_process_clock_sleep_request: Object.freeze({ "clock_id": 0, "flags": 4, "deadline_nanoseconds": 8 }),
+      dolly_process_exec_state: Object.freeze({ "blocked_signals": 0, "ignored_signals": 4, "pending_signals": 8, "reserved": 12 }),
+      dolly_process_fd_mapping: Object.freeze({ "source_descriptor": 0, "target_descriptor": 4 }),
+      dolly_process_spawn_request: Object.freeze({ "flags": 0, "argument_count": 4, "environment_count": 8, "cwd_size": 12, "mapping_count": 16, "descriptor_inheritance": 20, "reserved": 24, "path_size": 28, "argument_bytes": 32, "environment_bytes": 40, "deadline_nanoseconds": 48, "signals": 56 }),
+      dolly_process_spawn_response: Object.freeze({ "pid": 0, "reserved": 4 }),
+      dolly_process_exec_request: Object.freeze({ "signals": 0, "argument_count": 16, "environment_count": 20, "path_size": 24, "reserved": 28, "argument_bytes": 32, "environment_bytes": 40 }),
+      dolly_process_wait_request: Object.freeze({ "pid": 0, "flags": 4 }),
+      dolly_process_wait_response: Object.freeze({ "pid": 0, "status": 4, "signal_number": 8, "reserved": 12 }),
+      dolly_process_info_response: Object.freeze({ "pid": 0, "parent_pid": 4 }),
+      dolly_process_signal_request: Object.freeze({ "pid": 0, "signal_number": 4 }),
+      dolly_process_signal_dispositions: Object.freeze({ "ignored_signals": 0, "handled_signals": 4 }),
+      dolly_process_alarm: Object.freeze({ "value_nanoseconds": 0, "interval_nanoseconds": 8 }),
+      dolly_process_terminal_request: Object.freeze({ "operation": 0, "descriptor": 4, "flags": 8, "reserved": 12, "deadline_nanoseconds": 16 }),
+      dolly_process_terminal_response: Object.freeze({ "value": 0, "columns": 8, "rows": 12 }),
+      dolly_process_path_request: Object.freeze({ "directory_descriptor": 0, "flags": 4, "reserved": 8, "path_size": 12 }),
+      dolly_process_path_times_request: Object.freeze({ "directory_descriptor": 0, "flags": 4, "reserved": 8, "path_size": 12, "access": 16, "modification": 32 }),
+      dolly_process_path_open_response: Object.freeze({ "descriptor": 0, "reserved": 4 }),
+      dolly_process_stat_response: Object.freeze({ "device": 0, "inode": 8, "size": 16, "access_nanoseconds": 24, "modification_nanoseconds": 32, "change_nanoseconds": 40, "blocks": 48, "mode": 56, "link_count": 60, "user": 64, "group": 68, "block_size": 72, "file_type": 76, "reserved": 80 }),
+      dolly_process_filesystem_stat_response: Object.freeze({ "type": 0, "block_size": 8, "blocks": 16, "blocks_free": 24, "blocks_available": 32, "files": 40, "files_free": 48, "maximum_name_length": 56, "fragment_size": 64, "flags": 72, "filesystem_id": 80, "reserved": 88 }),
+      dolly_process_two_path_request: Object.freeze({ "old_directory_descriptor": 0, "new_directory_descriptor": 4, "old_path_size": 8, "new_path_size": 12 })
+    });
+  }
+});
+
+// host/modules.mjs
+var modules_exports = {};
+__export(modules_exports, {
+  hostRegistry: () => hostRegistry
+});
+async function hostRegistry(urls) {
+  const definitions = await Promise.all(urls.map(async (url) => {
+    const { default: manifest } = await import(url, { with: { type: "json" } });
+    const contract = Object.freeze({ ...manifest, url });
+    let provider;
+    return { contract, provider: () => provider ??= import(new URL(contract.host, url).href) };
+  }));
+  const byName = /* @__PURE__ */ new Map(), owners = /* @__PURE__ */ new Map();
+  for (const module of definitions) {
+    if (byName.has(module.contract.name)) throw new Error(`duplicate host module: ${module.contract.name}`);
+    byName.set(module.contract.name, module);
+    for (const name of module.contract.imports) {
+      if (owners.has(name)) throw new Error(`duplicate host import owner: ${name}`);
+      owners.set(name, module.contract.name);
+    }
+  }
+  const contracts = Object.freeze(definitions.map((module) => module.contract));
+  const requirementsOf = (keep) => Object.freeze(contracts.filter(keep).map(({ name, version }) => `${name}@${version}`));
+  const runtimes = requirementsOf((contract) => contract.provides === "kernel");
+  const buildHost = requirementsOf((contract) => contract.build);
+  const registry2 = { byName, owners, contracts, runtimes };
+  return Object.freeze({
+    urls: Object.freeze([...urls]),
+    buildHostFor: (declared) => [...declared.filter((value) => runtimes.includes(value)), ...buildHost],
+    load: (values) => loadProviders(byName, values),
+    selectBoot: (route) => selectBoot(definitions, route),
+    createHost: (...values) => createHost(registry2, ...values)
+  });
+}
+async function selectBoot(definitions, route) {
+  if (!route.loadSession) return null;
+  let selection = null;
+  for (const module of definitions) {
+    const selected = await (await module.provider()).boot?.(route);
+    if (!selected) continue;
+    if (selection) throw new Error("two host modules selected the boot");
+    const { name, version } = module.contract;
+    selection = { ...selected, module: `${name}@${version}`, configuration: { [name]: selected.configuration } };
+  }
+  return selection;
+}
+function loadProviders(byName, values, seen = /* @__PURE__ */ new Set()) {
+  for (const value of values) {
+    const { name, version } = hostRequirement(value), module = byName.get(name);
+    if (seen.has(name) || module?.contract.version !== version) continue;
+    seen.add(name);
+    module.provider().catch(() => {
+    });
+    loadProviders(byName, module.contract.dependencies, seen);
+  }
+}
+async function createHost({ byName, owners, contracts, runtimes }, side, enabled, { send, resources = {}, configuration = {} } = {}) {
+  if (!["browser", "worker"].includes(side)) throw new TypeError("invalid host side");
+  const selected = hostRequirements(enabled), instances = /* @__PURE__ */ new Map(), reasons = /* @__PURE__ */ new Map(), messages = /* @__PURE__ */ new Map();
+  const kernels = selected.filter((value) => runtimes.includes(value));
+  const started = /* @__PURE__ */ new Set(), pending = /* @__PURE__ */ new Map(), transfers = [], config = {};
+  const switched = /* @__PURE__ */ new Map();
+  let switching = Promise.resolve(), startContext, entryContext;
+  const page = {}, builder = {}, inherited = {};
+  const admittedAbi = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const answers = /* @__PURE__ */ new Map();
+  let asked = 0;
+  const ask = (message, transfers2 = []) => new Promise((resolve, reject) => {
+    if (disposed) return reject(new Error("host providers closed"));
+    answers.set(++asked, { resolve, reject });
+    send({ ...message, answer: asked }, transfers2);
+  });
+  function requireModules(requirements) {
+    for (const value of hostRequirements(requirements)) {
+      const { name, version } = hostRequirement(value), module = byName.get(name);
+      const reason = !module ? "unknown host module" : module.contract.version !== version ? `host provides ABI ${module.contract.version}` : reasons.get(name) ?? (!instances.has(name) ? "not enabled by the host" : null);
+      if (reason) throw new Error(`Required host module ${value} is unavailable: ${reason}`);
+    }
+  }
+  const get = (name) => instances.get(name);
+  function claimsKey(event) {
+    for (const instance of instances.values()) {
+      const claim = instance.claimsKey?.(event);
+      if (claim) return claim;
+    }
+    return false;
+  }
+  const surfaceSize = () => [...instances.values()].find((instance) => instance.surfaceSize)?.surfaceSize;
+  function framePoint({ clientX, clientY }) {
+    const bounds = resources.canvas.getBoundingClientRect(), { width, height } = surfaceSize() ?? resources.canvas;
+    const scale = Math.min(bounds.width / width, bounds.height / height);
+    if (!(scale > 0)) return { x: 0, y: 0 };
+    return {
+      x: (clientX - bounds.left - (bounds.width - width * scale) / 2) / scale,
+      y: (clientY - bounds.top - (bounds.height - height * scale) / 2) / scale
+    };
+  }
+  async function attach(value, visiting = /* @__PURE__ */ new Set(), checked = false) {
+    const { name, version } = hostRequirement(value), module = byName.get(name);
+    if (instances.has(name) || reasons.has(name)) return;
+    if (!module || version !== module.contract.version) {
+      reasons.set(name, !module ? "unknown host module" : `host provides ABI ${module.contract.version}`);
+      return;
+    }
+    if (visiting.has(name)) throw new Error(`host module dependency cycle: ${name}`);
+    visiting.add(name);
+    for (const dependency2 of module.contract.dependencies) await attach(dependency2, visiting);
+    visiting.delete(name);
+    try {
+      requireModules(module.contract.dependencies);
+    } catch (error) {
+      reasons.set(name, error.message);
+      return;
+    }
+    const provider = await module.provider();
+    if (side === "browser" && !checked) {
+      const reason = await provider.check?.(resources);
+      if (reason) {
+        reasons.set(name, reason);
+        return;
+      }
+    }
+    const dependency = (name2) => {
+      if (!module.contract.dependencies.some((value2) => hostRequirement(value2).name === name2)) {
+        throw new Error(`${module.contract.name} accessed undeclared dependency ${name2}`);
+      }
+      return get(name2);
+    };
+    const instance = provider[side]?.({
+      ...resources,
+      switched: checked,
+      send,
+      ask,
+      get: dependency,
+      service: () => {
+        for (const instance2 of instances.values()) instance2.service?.();
+      },
+      claimsKey,
+      framePoint,
+      abi: admittedAbi,
+      modules: module.contract.switches && side === "browser" ? { list, enable, disable } : void 0,
+      configuration: configuration[name] ?? {}
+    }) ?? {};
+    instances.set(name, instance);
+    for (const [type, handler] of Object.entries(instance.messages ?? {})) {
+      if (messages.has(type)) throw new Error(`duplicate host message: ${type}`);
+      messages.set(type, handler);
+    }
+    config[name] = instance.configuration ?? {};
+    transfers.push(...instance.transfers ?? []);
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(instance.page ?? {}))) {
+      if (key in page) throw new Error(`duplicate page API member: ${key}`);
+      Object.defineProperty(page, key, descriptor);
+    }
+    if (instance.builder) builder[name] = instance.builder;
+    for (const [key, value2] of Object.entries(instance.inherited ?? {})) {
+      if (key in inherited) throw new Error(`duplicate inherited record: ${key}`);
+      inherited[key] = value2;
+    }
+  }
+  function detach(name) {
+    const instance = instances.get(name);
+    instance.dispose?.();
+    instance.disabled?.();
+    for (const type of Object.keys(instance.messages ?? {})) messages.delete(type);
+    for (const key of Object.keys(instance.page ?? {})) delete page[key];
+    for (const key of Object.keys(instance.inherited ?? {})) delete inherited[key];
+    delete builder[name];
+    delete config[name];
+    instances.delete(name);
+    started.delete(name);
+    admittedAbi.delete(`${name}@${byName.get(name).contract.version}`);
+  }
+  async function startProvider(name, instance, context) {
+    if (started.has(name)) throw new Error(`host provider ${name} initialized twice`);
+    started.add(name);
+    const descriptor = await instance.start(context);
+    if (descriptor === void 0) return;
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(name);
+        reject(new Error(`host provider ${name} did not acknowledge initialization`));
+      }, 1e4);
+      pending.set(name, { resolve: () => {
+        clearTimeout(timer);
+        resolve();
+      }, reject: (error) => {
+        clearTimeout(timer);
+        reject(error);
+      } });
+      send({ type: "host-ready", module: name, descriptor });
+    });
+  }
+  const requirementOf = ({ name, version }) => `${name}@${version}`;
+  const list = () => contracts.map((contract) => ({
+    name: contract.name,
+    version: contract.version,
+    gives: contract.gives ?? "",
+    fixed: contract.fixed ?? "",
+    enabled: instances.has(contract.name),
+    declared: selected.includes(requirementOf(contract))
+  }));
+  const workerSwitch = (value, enabling, name = hostRequirement(value).name) => new Promise((resolve) => {
+    switched.set(value, resolve);
+    if (enabling) send({ type: "host-switch", module: value, enabling, configuration: config[name] }, instances.get(name).transfers ?? []);
+    else send({ type: "host-switch", module: value, enabling });
+  });
+  const serially = (task) => switching = switching.then(task, task);
+  const enable = (value) => serially(async () => {
+    const { name, version } = hostRequirement(value), module = byName.get(name);
+    if (!module || module.contract.version !== version) return "this page has no such host module";
+    if (instances.has(name)) return null;
+    if (module.contract.fixed) return `fixed: ${module.contract.fixed}`;
+    const missing = module.contract.dependencies.find((dependency) => !instances.has(hostRequirement(dependency).name));
+    if (missing) return `it needs ${missing}`;
+    reasons.delete(name);
+    try {
+      const abandoned = new AbortController(), timer = setTimeout(() => abandoned.abort(), 5e3);
+      const unavailable = await Promise.race([(await module.provider()).check?.({ ...resources, signal: abandoned.signal }), new Promise((resolve) => abandoned.signal.addEventListener("abort", () => resolve("the browser did not answer in time")))]);
+      clearTimeout(timer);
+      if (unavailable) return unavailable;
+      await attach(value, /* @__PURE__ */ new Set(), true);
+      if (!instances.has(name)) return reasons.get(name);
+      const refusal = await workerSwitch(value, true);
+      if (refusal) {
+        detach(name);
+        return refusal;
+      }
+      if (entryContext) await instances.get(name).entryStarted?.(entryContext);
+    } catch (error) {
+      if (instances.has(name)) {
+        await workerSwitch(value, false);
+        detach(name);
+      }
+      return error.message;
+    }
+    return null;
+  });
+  const disable = (value) => serially(async () => {
+    const { name, version } = hostRequirement(value), module = byName.get(name);
+    if (!module || module.contract.version !== version) return "this page has no such host module";
+    if (!instances.has(name)) return null;
+    if (module.contract.fixed) return `fixed: ${module.contract.fixed}`;
+    const refusal = await workerSwitch(value, false);
+    if (refusal) return refusal;
+    detach(name);
+    return null;
+  });
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    for (const wait of [...pending.values(), ...answers.values()]) wait.reject(new Error("host providers closed"));
+    pending.clear();
+    answers.clear();
+    for (const instance of [...instances.values()].reverse()) instance.dispose?.();
+  }
+  try {
+    loadProviders(byName, selected);
+    for (const value of selected) await attach(value);
+    if (kernels.length !== 1) {
+      requireModules(selected);
+      throw new Error(kernels.length ? `${kernels.join(" and ")} both provide the kernel` : `no enabled host module provides the kernel: add REQUIRES HOST ${runtimes.join(" or ")}`);
+    }
+    requireModules(kernels);
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+  const kernel = hostRequirement(kernels[0]).name;
+  return {
+    transfers,
+    configuration: config,
+    page,
+    builder,
+    inherited,
+    kernel: instances.get(kernel),
+    get enabled() {
+      return [...instances.keys()].map((name) => requirementOf(byName.get(name).contract));
+    },
+    require: requireModules,
+    dispose,
+    // Executables may use only the modules the image declares. A declared module
+    // this host does not enable (a build host) answers its calls with ENOSYS.
+    async admit(requirements) {
+      const admitted = /* @__PURE__ */ new Map();
+      for (const value of hostRequirements(requirements)) {
+        const { name, version } = hostRequirement(value), module = byName.get(name);
+        const digest = module?.contract.version === version ? (await module.provider()).digest : void 0;
+        if (digest) admitted.set(value, digest);
+      }
+      admittedAbi.clear();
+      for (const [value, digest] of admitted) admittedAbi.set(value, digest);
+    },
+    // The Worker asks this before it restores the image: a module that restores
+    // the whole filesystem itself (a saved session, host/snapshot) says so, and
+    // no image is loaded.
+    async restoreFilesystem(context) {
+      for (const instance of instances.values()) if (await instance.restoreFilesystem?.(context)) return true;
+      return false;
+    },
+    // Whether restoreFilesystem will restore one, known from the configuration,
+    // before a kernel exists.
+    restoresFilesystem() {
+      return [...instances.values()].some((instance) => instance.restoresFilesystem?.());
+    },
+    // The Worker calls this after restoring the system image and before starting
+    // image-phase modules, in registry order.
+    async imageRestored(context) {
+      for (const instance of instances.values()) await instance.imageRestored?.(context);
+    },
+    // The page calls this once the image ENTRY may run, right before it lets
+    // the Worker start it: modules may then show their UI and admit services.
+    entryStarted(context) {
+      entryContext = context;
+      return Promise.all([...instances.values()].map((instance) => instance.entryStarted?.(context)));
+    },
+    // The page asks this when the image has ended, before it lets go of the
+    // modules: the links ({ text, href }) each one offers beside "start again".
+    ended: () => [...instances.values()].flatMap((instance) => instance.ended?.() ?? []),
+    // The kernel's whole import object: each import is the binding of the
+    // module whose manifest owns it.
+    imports(module) {
+      const imports = {};
+      for (const entry of WebAssembly.Module.imports(module)) {
+        const name = `${entry.module}.${entry.name}`, owner = owners.get(name);
+        if (!owner) {
+          (imports[entry.module] ??= {})[entry.name] = () => -DOLLY_ERRNO2.ENOSYS;
+          continue;
+        }
+        const binding = instances.has(owner) ? instances.get(owner).bindings?.[name] : () => -DOLLY_ERRNO2.ENOSYS;
+        if (binding === void 0) throw new Error(`missing host binding: ${name}`);
+        (imports[entry.module] ??= {})[entry.name] = byName.get(owner).contract.fixed ? binding : (...values) => instances.has(owner) ? instances.get(owner).bindings[name](...values) : -DOLLY_ERRNO2.ENOSYS;
+      }
+      return imports;
+    },
+    async handle(message) {
+      if (disposed) return false;
+      if (message.type === "host-ready-ack" && side === "worker") {
+        const wait = pending.get(message.module);
+        if (!wait) throw new Error("unexpected host acknowledgement");
+        pending.delete(message.module);
+        if (message.error) wait.reject(new Error(message.error));
+        else wait.resolve();
+        return true;
+      }
+      if (message.type === "host-ready" && side === "browser") {
+        try {
+          const instance = get(message.module);
+          if (!instance?.start || started.has(message.module)) throw new Error("invalid host provider handshake");
+          started.add(message.module);
+          await instance.start(message.descriptor);
+          send({ type: "host-ready-ack", module: message.module });
+        } catch (error) {
+          send({ type: "host-ready-ack", module: message.module, error: error.message });
+          throw error;
+        }
+        return true;
+      }
+      if (message.type === "host-switch" && side === "worker") {
+        const { name } = hostRequirement(message.module);
+        let refusal = null;
+        try {
+          if (message.enabling) {
+            configuration[name] = message.configuration;
+            reasons.delete(name);
+            await attach(message.module);
+            const instance = instances.get(name);
+            if (!instance) throw new Error(reasons.get(name));
+            if (instance.start) await startProvider(name, instance, startContext);
+            const { digest } = await byName.get(name).provider();
+            if (digest) admittedAbi.set(message.module, digest);
+          } else if (instances.has(name)) detach(name);
+        } catch (error) {
+          if (instances.has(name)) detach(name);
+          refusal = error.message;
+        }
+        send({ type: "host-switch-ack", module: message.module, refusal });
+        return true;
+      }
+      if (message.type === "host-switch-ack" && side === "browser") {
+        switched.get(message.module)?.(message.refusal);
+        switched.delete(message.module);
+        return true;
+      }
+      if (message.type === "host-answer") {
+        const waiting = answers.get(message.answer);
+        answers.delete(message.answer);
+        if (message.error === void 0) waiting?.resolve(message.result);
+        else waiting?.reject(new Error(message.error));
+        return true;
+      }
+      const handler = messages.get(message.type);
+      if (!handler) return false;
+      if (message.answer === void 0) {
+        await handler(message);
+        return true;
+      }
+      try {
+        send({ type: "host-answer", answer: message.answer, result: await handler(message) });
+      } catch (error) {
+        send({ type: "host-answer", answer: message.answer, error: error.message });
+      }
+      return true;
+    },
+    async start(phase, context) {
+      if (side !== "worker" || disposed) throw new Error("host cannot initialize providers");
+      startContext = context;
+      for (const [name, instance] of [...instances]) {
+        if (byName.get(name).contract.phase === phase && instance.start) await startProvider(name, instance, context);
+      }
+    }
+  };
+}
+var init_modules = __esm({
+  "host/modules.mjs"() {
+    init_requirements();
+    init_process_constants();
+  }
+});
+
+// page/images.mjs
+var DOLLY_IMAGES = [];
+var DOLLY_STATIC_SOURCES = [];
+var imageBase;
+async function loadImages(base) {
+  imageBase = new URL(base);
+  ({ images: DOLLY_IMAGES, staticSources: DOLLY_STATIC_SOURCES } = (await import(new URL("dist/dolly-images.json", imageBase).href, { with: { type: "json" } })).default);
+}
+var imageDefinition = (name) => DOLLY_IMAGES.find((definition) => definition.image === name);
+
+// page/generated.mjs
+import { DOLLY_BUILD_ID } from "../dist/dolly-build-id.mjs";
+import { DOLLY_IMAGE_BUILD_ID } from "../dist/dolly-image-build-id.mjs";
+import { DOLLY_PROCESS_ABI_DIGEST } from "../dist/dolly-process-abi.mjs";
+import { DOLLY_KERNEL_PLUGIN_ABI_DIGEST, DOLLY_KERNEL_PLUGIN_IMPORTS } from "../dist/dolly-kernel-plugin-abi.mjs";
+
+// page/sha256.mjs
+var K = Int32Array.of(
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+);
+var Sha256 = class {
+  state = Int32Array.of(1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225);
+  block = new Uint8Array(64);
+  used = 0;
+  length = 0;
+  words = new Int32Array(64);
+  compress(view, offset) {
+    const w = this.words, s = this.state;
+    for (let i = 0; i < 16; i++) w[i] = view.getInt32(offset + 4 * i);
+    for (let i = 16; i < 64; i++) {
+      const x = w[i - 15], y = w[i - 2];
+      w[i] = ((x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3) + w[i - 7] + ((y >>> 17 | y << 15) ^ (y >>> 19 | y << 13) ^ y >>> 10) + w[i - 16] | 0;
+    }
+    let a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
+    for (let i = 0; i < 64; i++) {
+      const t1 = h + ((e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7)) + (e & f ^ ~e & g) + K[i] + w[i] | 0;
+      const t2 = ((a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10)) + (a & b ^ a & c ^ b & c) | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    s[0] += a;
+    s[1] += b;
+    s[2] += c;
+    s[3] += d;
+    s[4] += e;
+    s[5] += f;
+    s[6] += g;
+    s[7] += h;
+  }
+  update(bytes) {
+    this.length += bytes.length;
+    let offset = 0;
+    if (this.used !== 0) {
+      offset = Math.min(64 - this.used, bytes.length);
+      this.block.set(bytes.subarray(0, offset), this.used);
+      this.used += offset;
+      if (this.used < 64) return;
+      this.compress(new DataView(this.block.buffer), 0);
+      this.used = 0;
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (; offset + 64 <= bytes.length; offset += 64) this.compress(view, offset);
+    this.block.set(bytes.subarray(offset));
+    this.used = bytes.length - offset;
+  }
+  // The lowercase hex digest; the hash takes no more bytes after it.
+  hex() {
+    const bits = this.length * 8;
+    this.update(Uint8Array.of(128));
+    this.update(new Uint8Array((120 - this.used) % 64));
+    const view = new DataView(this.block.buffer);
+    view.setUint32(56, Math.floor(bits / 2 ** 32));
+    view.setUint32(60, bits >>> 0);
+    this.compress(view, 0);
+    return [...this.state].map((word) => (word >>> 0).toString(16).padStart(8, "0")).join("");
+  }
+};
+
+// page/image-inputs.mjs
+function imageInputs(artifacts = []) {
+  if (!Array.isArray(artifacts) || artifacts.length > 256) throw new Error("invalid image inputs");
+  const inputs = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts) {
+    const { recipeSha256, sha256: sha2562 } = artifact ?? {};
+    if (!/^[0-9a-f]{64}$/.test(recipeSha256) || !/^[0-9a-f]{64}$/.test(sha2562)) {
+      throw new Error("invalid image input digest");
+    }
+    if (inputs.has(recipeSha256) && inputs.get(recipeSha256).sha256 !== sha2562) {
+      throw new Error("conflicting image inputs");
+    }
+    inputs.set(recipeSha256, { recipeSha256, sha256: sha2562 });
+  }
+  return [...inputs.values()].sort((a, b) => a.recipeSha256.localeCompare(b.recipeSha256));
+}
+function imageInputsMatch(actual, expected) {
+  return JSON.stringify(imageInputs(actual)) === JSON.stringify(imageInputs(expected));
+}
+function recipesDigest(recipes) {
+  const hash = new Sha256();
+  hash.update(new TextEncoder().encode(recipes.map(({ sha256: sha2562, byteLength, sourcePath }) => `${sha2562} ${byteLength} ${sourcePath}
+`).join("")));
+  return hash.hex();
+}
+
+// page/packaged-snapshot.mjs
+init_requirements();
+init_static_asset();
+init_snapshot_records();
+init_abi2();
+init_image_names();
+
+// page/pack-store.mjs
+init_static_asset();
+var STORE = "dolly-packs";
+var LOCK = "dolly-packs";
+var encoder2 = new TextEncoder();
+async function storeDirectories() {
+  const root = await (await navigator.storage.getDirectory()).getDirectoryHandle(STORE, { create: true });
+  const [packs, records] = await Promise.all(["packs", "images"].map((name) => root.getDirectoryHandle(name, { create: true })));
+  return { packs, records };
+}
+var hold = (mode) => new Promise((held, refused) => {
+  const released = navigator.locks.request(LOCK, { mode }, () => new Promise((release) => held(() => {
+    release();
+    return released;
+  })));
+  released.catch(refused);
+});
+async function writeFile(directory, name, data) {
+  const writable = await (await directory.getFileHandle(name, { create: true })).createWritable();
+  await writable.write(data);
+  await writable.close();
+}
+var noStore = {
+  kept: async () => null,
+  keeping: async (pack, body) => ({ body, keep() {
+  }, discard() {
+  } }),
+  close() {
+  }
+};
+async function openPackStore(image, packs) {
+  let store, release;
+  try {
+    store = await storeDirectories();
+    release = await hold("shared");
+    const record = { directory: imageBase.href, image, buildId: DOLLY_IMAGE_BUILD_ID, packs: packs.map((pack) => pack.sha256) };
+    await writeFile(store.records, await sha256(encoder2.encode(`${record.directory}\0${image}`)), JSON.stringify(record));
+  } catch {
+    release?.();
+    return noStore;
+  }
+  return {
+    async kept(pack) {
+      try {
+        const file = await (await store.packs.getFileHandle(pack.sha256)).getFile();
+        if (file.size !== pack.encodedByteLength) return null;
+        return { body: file.stream(), keep() {
+        }, discard: () => store.packs.removeEntry(pack.sha256).catch(() => {
+        }) };
+      } catch {
+        return null;
+      }
+    },
+    async keeping(pack, body) {
+      let writable = await store.packs.getFileHandle(pack.sha256, { create: true }).then((handle) => handle.createWritable()).catch(() => null);
+      const discard = async () => {
+        const unkept = writable;
+        writable = null;
+        await unkept?.abort().catch(() => {
+        });
+      };
+      return {
+        body: body.pipeThrough(new TransformStream({
+          async transform(chunk, controller) {
+            await writable?.write(chunk).catch(discard);
+            controller.enqueue(chunk);
+          }
+        })),
+        keep: () => writable?.close().catch(discard),
+        discard
+      };
+    },
+    close(complete) {
+      void release().then(() => complete && navigator.locks.request(LOCK, { ifAvailable: true }, (lock) => lock && prune(store))).catch(() => {
+      });
+    }
+  };
+}
+async function prune({ packs, records }) {
+  const used = /* @__PURE__ */ new Set(), stale = [], unused = [];
+  for await (const [name, handle] of records) {
+    try {
+      const record = JSON.parse(await (await handle.getFile()).text());
+      if (record.buildId === DOLLY_IMAGE_BUILD_ID && (record.directory !== imageBase.href || imageDefinition(record.image))) {
+        for (const pack of record.packs) used.add(pack);
+        continue;
+      }
+    } catch {
+    }
+    stale.push(name);
+  }
+  for (const name of stale) await records.removeEntry(name).catch(() => {
+  });
+  for await (const name of packs.keys()) if (!used.has(name)) unused.push(name);
+  for (const name of unused) await packs.removeEntry(name).catch(() => {
+  });
+}
+
+// page/packaged-snapshot.mjs
+var definitionOf = (image) => DOLLY_IMAGES.find((definition) => definition.image === image);
+var encoder3 = new TextEncoder();
+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);
+}
+var referenced = ({ location, sha256: sha2562 }) => DOLLY_IMAGES.find((candidate) => siteReference(candidate.dollyfile) === location && candidate.sha256 === sha2562);
+async function importMetadata(image) {
+  try {
+    return (await import(new URL(`dist/dolly-${image}-system-snapshot.json`, imageBase).href, { with: { type: "json" } })).default;
+  } catch {
+    throw new Error(`The packaged ${image} snapshot is missing. Run npm run image -- ${image} first.`);
+  }
+}
+async function loadImageMetadata(image) {
+  return checkedMetadata(image, await importMetadata(image), null);
+}
+function checkedMetadata(image, metadata, checked) {
+  if (metadata === null || typeof metadata !== "object" || metadata.image !== image || metadata.buildId !== DOLLY_IMAGE_BUILD_ID || metadata.formatVersion !== 2 || metadata.identityVersion !== 2 || !Array.isArray(metadata.recipes) || recipesDigest(metadata.recipes) !== definitionOf(image).recipesSha256 || JSON.stringify(hostRequirements(metadata.hostRequirements)) !== JSON.stringify(definitionOf(image).hostRequirements) || !Number.isSafeInteger(metadata.byteLength) || metadata.byteLength <= 0 || metadata.byteLength > MAX_SNAPSHOT_BYTES || metadata.encoding !== "packs" || !/^[0-9a-f]{64}$/.test(metadata.sha256) || !Array.isArray(metadata.manifest) || metadata.manifest.length === 0 || metadata.manifest.length > DOLLY_SNAPSHOT_MAX_PATHS) {
+    throw new Error("The packaged system snapshot metadata does not match this Dolly build");
+  }
+  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;
+  for (const path of metadata.manifest) {
+    if (!validSnapshotPath(path)) {
+      throw new Error("The packaged system snapshot has an invalid retained-path manifest");
+    }
+    manifestBytes += encoder3.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}`);
+    }
+  }
+  if (checked === null) return metadata;
+  const expectedInputs = definitionOf(image).artifacts.map((reference) => ({ recipeSha256: reference.sha256, sha256: checked.get(referenced(reference).image).sha256 }));
+  if (!imageInputsMatch(inputs, expectedInputs)) throw new Error("The packaged system snapshot has stale image inputs");
+  return metadata;
+}
+var PREFETCH_PACKS = 8;
+var PREFETCH_BYTES = 64 * 1024 * 1024;
+async function* packagedSnapshotParts(metadata, signal) {
+  const packs = validateSnapshotPacks(metadata), store = await openPackStore(metadata.image, packs);
+  const opened = async (pack) => {
+    const kept = await store.kept(pack);
+    return kept ? { part: kept, downloaded: false } : { part: await store.keeping(pack, await downloadedPack(pack, signal)), downloaded: true };
+  };
+  const ahead = [];
+  let next = 0, aheadBytes = 0, complete = false;
+  try {
+    while (next < packs.length || ahead.length) {
+      signal?.throwIfAborted();
+      while (next < packs.length && (!ahead.length || ahead.length < PREFETCH_PACKS && aheadBytes + packs[next].encodedByteLength <= PREFETCH_BYTES)) {
+        const pack2 = packs[next++], opening2 = opened(pack2);
+        opening2.catch(() => {
+        });
+        ahead.push({ pack: pack2, opening: opening2 });
+        aheadBytes += pack2.encodedByteLength;
+      }
+      const { pack, opening } = ahead.shift();
+      aheadBytes -= pack.encodedByteLength;
+      const { part } = await opening;
+      let verified = false;
+      try {
+        yield { ...pack, body: part.body, verified: () => {
+          verified = true;
+          return part.keep();
+        } };
+      } finally {
+        if (!verified) await part.discard();
+      }
+    }
+    complete = true;
+  } finally {
+    for (const { opening } of ahead) {
+      void opening.then(({ part, downloaded }) => {
+        void part.body.cancel().catch(() => {
+        });
+        if (downloaded) void part.discard();
+      }, () => {
+      });
+    }
+    store.close(complete);
+  }
+}
+async function downloadedPack(pack, signal) {
+  const url = new URL(`dist/packs/${pack.sha256}.snapshot.gz`, imageBase);
+  const init = { cache: "force-cache", credentials: "same-origin", redirect: "error", signal };
+  const response = await decodeStaticAsset(await fetch(url, init), url, init, pack.encodedByteLength);
+  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) !== pack.encodedByteLength) throw new Error("snapshot HTTP content length mismatch");
+  return response.body;
+}
+var gunzip = (body) => body.pipeThrough(new DecompressionStream("gzip"));
+async function* chunksOf(body, signal) {
+  const reader = body.getReader();
+  let finished = false;
+  try {
+    for (; ; ) {
+      signal?.throwIfAborted();
+      const { done, value } = await reader.read();
+      if (done) break;
+      yield value;
+    }
+    finished = true;
+  } finally {
+    if (!finished) await reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+}
+async function streamPackagedSystemSnapshot(metadata, write, endPart, signal) {
+  for await (const part of packagedSnapshotParts(metadata, signal)) {
+    const bytes = new Uint8Array(part.byteLength);
+    let size = 0;
+    for await (const chunk of chunksOf(gunzip(part.body), signal)) {
+      if (chunk.length > part.byteLength - size) throw new Error("snapshot exceeds declared size");
+      bytes.set(chunk, size);
+      await write(chunk);
+      size += chunk.length;
+    }
+    if (size !== part.byteLength || hex(await crypto.subtle.digest("SHA-256", bytes)) !== part.sha256) {
+      throw new Error("snapshot integrity mismatch");
+    }
+    await endPart();
+    await part.verified();
+  }
+}
+
+// page/runtime-worker.mjs
+init_static_asset();
+
+// page/image-entry.mjs
+init_abi2();
+function decodeImageEntry(bytes) {
+  if (!(bytes instanceof Uint8Array) || bytes.byteLength < DOLLY_ENTRY_HEADER_BYTES || bytes.byteLength > DOLLY_ENTRY_MAX_BYTES) {
+    throw new TypeError("invalid image ENTRY record");
+  }
+  const decoder4 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (decoder4.decode(bytes.subarray(0, 8)) !== "DOLLYENT" || view.getUint32(8, true) !== DOLLY_ENTRY_VERSION) {
+    throw new TypeError("invalid image ENTRY version");
+  }
+  const count = view.getUint32(12, true);
+  if (count === 0 || count > DOLLY_ENTRY_MAX_ARGUMENTS) throw new TypeError("invalid image ENTRY count");
+  let offset = DOLLY_ENTRY_HEADER_BYTES;
+  const arguments_ = [];
+  for (let index = 0; index < count; ++index) {
+    if (offset > bytes.byteLength - 4) throw new TypeError("truncated image ENTRY");
+    const size = view.getUint32(offset, true);
+    offset += 4;
+    if (size > DOLLY_ENTRY_ARGUMENT_MAX_BYTES || offset > bytes.byteLength - size) throw new TypeError("invalid image ENTRY argument");
+    const value = decoder4.decode(bytes.subarray(offset, offset + size));
+    if (value.includes("\0")) throw new TypeError("image ENTRY has a NUL argument");
+    arguments_.push(value);
+    offset += size;
+  }
+  if (offset !== bytes.byteLength || !arguments_[0].startsWith("/")) {
+    throw new TypeError("invalid image ENTRY payload");
+  }
+  return arguments_;
+}
+
+// page/worker-image.mjs
+init_snapshot_records();
+
+// page/process-supervisor.mjs
+init_process_constants();
+
+// page/wasm-interface.mjs
+var decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+
+// page/process-abi.mjs
+init_static_asset();
+
+// page/process-supervisor.mjs
+init_requirements();
+init_process_constants();
+init_static_asset();
+init_abi2();
+var encoder4 = new TextEncoder();
+var spawnHeaderSize = DOLLY_PROCESS_SIZEOF.dolly_process_spawn_request;
+var spawnField = DOLLY_PROCESS_OFFSETOF.dolly_process_spawn_request;
+var mappingField = DOLLY_PROCESS_OFFSETOF.dolly_process_fd_mapping;
+var mappingSize = DOLLY_PROCESS_SIZEOF.dolly_process_fd_mapping;
+var deferredResult = -(1n << 63n);
+var interruptedSystemCall = -BigInt(DOLLY_ERRNO2.EINTR);
+var processMemoryBudgetBytes = 4 * 1024 * 1024 * 1024;
+var compiledModuleCacheBytes = 256 * 1024 * 1024;
+var heldModuleBytes = 16 * 1024 * 1024;
+var holderUrl = URL.createObjectURL(new Blob([`let module;
+onmessage = async ({ data: { bytes, port } }) => {
+  if (port) return port.postMessage(module);
+  try {
+    module = await WebAssembly.compile(bytes);
+    postMessage(null);
+  } catch (error) {
+    postMessage(String(error?.message ?? error));
+  } finally {
+    bytes.transfer(0);
+  }
+};`], { type: "text/javascript" }));
+var largeInteractiveProcessBytes = 128 * 1024 * 1024;
+function terminalFailureReason(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const firstLine = message.split(/[\r\n]/, 1)[0].replace(/[^\x20-\x7e]/g, "?").slice(0, 512);
+  return firstLine || "unknown Worker failure";
+}
+
+// host/runtime/boot-files.mjs
+init_abi2();
+var encoder5 = new TextEncoder();
+function bootFiles(kernel, memory) {
+  const allocate = (size) => {
+    const address = Number(kernel.malloc(BigInt(Math.max(1, size))));
+    if (address === 0) throw new Error("Dolly boot allocation failed");
+    return address;
+  };
+  const withBytes = (bytes, use) => {
+    const address = allocate(bytes.length);
+    try {
+      new Uint8Array(memory.buffer, address, bytes.length).set(bytes);
+      return use(BigInt(address));
+    } finally {
+      kernel.free(BigInt(address));
+    }
+  };
+  const withPath = (path, use) => withBytes(encoder5.encode(`${path}\0`), use);
+  return {
+    write(path, value) {
+      const bytes = typeof value === "string" ? encoder5.encode(value) : value;
+      if (!(bytes instanceof Uint8Array)) throw new TypeError("invalid Dolly boot file");
+      const status = withPath(path, (pathAddress) => withBytes(bytes, (address) => kernel.dolly_write_file(pathAddress, address, BigInt(bytes.length))));
+      if (status !== 0) throw new Error(`Dolly could not write ${path}: status ${status}`);
+    },
+    // The build's input INPUT (the runtime's setBuildInputs), SIZE bytes, as PATH.
+    input(path, input, size) {
+      const status = withPath(path, (pathAddress) => kernel.dolly_build_input(pathAddress, input, BigInt(size)));
+      if (status !== 0) throw new Error(`Dolly could not place ${path}: status ${status}`);
+    },
+    // Guest-writable files are bounded before trusted code copies them.
+    read(path, limit) {
+      const address = allocate(limit);
+      try {
+        const size = withPath(path, (pathAddress) => kernel.dolly_read_file(pathAddress, BigInt(address), BigInt(limit)));
+        if (size === -DOLLY_ERRNO.EFBIG || size > limit) throw new Error(`${path} is larger than ${limit} bytes`);
+        if (size < 0) throw new Error(`Dolly could not read ${path}: status ${size}`);
+        return new Uint8Array(memory.buffer, address, size).slice();
+      } finally {
+        kernel.free(BigInt(address));
+      }
+    },
+    remove(path) {
+      const status = withPath(path, (pathAddress) => kernel.dolly_remove_file(pathAddress));
+      if (status !== 0 && status !== -DOLLY_ERRNO.ENOENT) throw new Error(`Dolly could not remove ${path}: status ${status}`);
+    }
+  };
+}
+
+// page/worker-image.mjs
+var decoder3 = new TextDecoder("utf-8", { ignoreBOM: true });
+var configured = new Promise((resolve) => {
+  self.addEventListener("message", function configure(event) {
+    if (event.data?.type !== "configure") return;
+    self.removeEventListener("message", configure);
+    resolve(event.data);
+  });
+});
+var registry = Promise.resolve().then(() => (init_modules(), modules_exports));
+self.addEventListener("message", function prepare(event) {
+  if (event.data?.type !== "prepare") return;
+  self.removeEventListener("message", prepare);
+  const { images, modules, hostModules } = event.data;
+  void (async () => {
+    await loadImages(images);
+    (await (await registry).hostRegistry(modules)).load(hostModules);
+  })().catch(() => {
+  });
+});
+var { hostRegistry: hostRegistry2 } = await registry;
+var runtimeBase = new URL("../", import.meta.url);
+var kernelArtifact = (path) => {
+  if (path !== "dolly.wasm" && path !== "dolly.data") throw new Error("unknown fixed kernel artifact");
+  return new URL(`dist/${path}`, runtimeBase).href;
+};
+function checkedMemoryRange(memory, addressValue, sizeValue) {
+  const address = Number(addressValue);
+  const size = Number(sizeValue);
+  if (!Number.isSafeInteger(address) || !Number.isSafeInteger(size) || address <= 0 || size <= 0 || size > MAX_SNAPSHOT_BYTES || address > memory.buffer.byteLength - size) {
+    throw new Error("Wasm published an invalid system snapshot memory range");
+  }
+  return { address, size };
+}
+var stage = (text) => self.postMessage({ type: "bootstrap", text: `${text}
+` });
+function acknowledged(type, failure) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error(failure)), 1e4);
+    self.addEventListener("message", function acknowledge(event) {
+      if (event.data?.type !== type) return;
+      self.removeEventListener("message", acknowledge);
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+}
+async function runImage(image) {
+  let host;
+  self.addEventListener("message", (event) => {
+    void host?.handle(event.data).catch((error) => {
+      host.dispose();
+      self.postMessage({ type: "error", message: error.message });
+    });
+  });
+  try {
+    const config = await configured;
+    if (!Array.isArray(config.modules) || config.modules.length > 64 || !config.modules.every((url) => typeof url === "string")) throw new Error("invalid host module list");
+    if (typeof config.images !== "string") throw new Error("invalid image directory");
+    await loadImages(config.images);
+    host = await (await hostRegistry2(config.modules)).createHost("worker", config.hostModules, {
+      send: (message, transfers = []) => self.postMessage(message, transfers),
+      configuration: config.hostConfiguration,
+      // The image directory reaches the modules here: one the bundle holds is not theirs.
+      resources: { runtimeBase, images: new URL(config.images) }
+    });
+    const steps = await image(config, host);
+    stage("creating wasm64 userspace kernel...");
+    const memory = host.kernel.memory;
+    await host.kernel.growing;
+    const kernelModule = await WebAssembly.compileStreaming(fetch(kernelArtifact("dolly.wasm")));
+    const kernel = new WebAssembly.Instance(kernelModule, host.imports(kernelModule)).exports;
+    kernel._initialize();
+    const files = bootFiles(kernel, memory);
+    await steps.prepare({ kernel, memory, files, stage });
+    stage("Dolly runtime loaded");
+    await host.start("kernel", { kernel, memory });
+    const restored = await steps.restore({ kernel, memory, files, stage });
+    if (restored.status !== 0) throw new Error(`Dolly bootstrap failed with status ${restored.status}`);
+    if (config.buildOnly) {
+      self.close();
+      return;
+    }
+    const supervisor = restored.supervisor ?? await host.kernel.supervisor(kernel);
+    await steps.finish?.({ kernel, stage });
+    await host.imageRestored({ kernel, memory, supervisor, stage, files, image: steps.name });
+    if (kernel.dolly_bootstrap_environment() !== 0) throw new Error("Dolly image environment is invalid");
+    await host.start("image", { kernel, memory });
+    const runtimeImage = decoder3.decode(files.read("/etc/dolly/image", 256));
+    if (steps.name !== "custom" && runtimeImage !== steps.name) {
+      throw new Error(`Dollyfile selected image ${runtimeImage}, expected ${steps.name}`);
+    }
+    stage("starting image entry...");
+    const entryReady = acknowledged("entry-ready-ack", "browser did not acknowledge image startup");
+    self.postMessage({ type: "ready", image: runtimeImage });
+    await entryReady;
+    const entry = async () => supervisor.spawn(decodeImageEntry(files.read("/etc/dolly/entry", 64 * 1024)), { foreground: true });
+    const ending = await entry().catch((error) => {
+      console.error(error);
+      return { status: 126, signal: 0, failure: error.reason ?? terminalFailureReason(error) };
+    });
+    host.dispose();
+    self.postMessage({ type: "exited", ...ending });
+  } catch (error) {
+    self.postMessage({
+      type: "error",
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack ?? "" : ""
+    });
+  } finally {
+    host?.dispose();
+  }
+}
+
+// page/runtime-worker.mjs
+await runImage(async ({ image, files: given = {} }, host) => {
+  const definition = imageDefinition(image);
+  if (!definition) throw new Error("invalid Dolly image selection");
+  const loading = host.restoresFilesystem() ? null : loadImageMetadata(image);
+  loading?.catch(() => {
+  });
+  host.require(definition.hostRequirements);
+  await host.admit(definition.hostRequirements);
+  return {
+    name: image,
+    prepare({ files }) {
+      files.write("/etc/dolly/recipe.locator", siteReference(definition.dollyfile));
+    },
+    async restore({ kernel, memory, files, stage: stage2 }) {
+      if (await host.restoreFilesystem({ kernel, memory, stage: stage2 })) return { status: 0 };
+      const metadata = await (loading ?? loadImageMetadata(image));
+      files.write("/etc/dolly/image.manifest", `${metadata.manifest.join("\n")}
+`);
+      stage2("loading precompiled userspace snapshot...");
+      const capacity = 1024 * 1024;
+      const address = kernel.dolly_snapshot_restore_address(BigInt(capacity));
+      const staging = () => {
+        const range = checkedMemoryRange(memory, address, capacity);
+        return new Uint8Array(memory.buffer, range.address, range.size);
+      };
+      if (kernel.dolly_bootstrap_snapshot_begin(BigInt(metadata.byteLength)) !== 0)
+        throw new Error("Dolly snapshot stream initialization failed");
+      let loaded = 0, reported = 0;
+      await streamPackagedSystemSnapshot(metadata, (bytes) => {
+        for (let offset = 0; offset < bytes.length; offset += capacity) {
+          const chunk = bytes.subarray(offset, offset + capacity);
+          staging().set(chunk);
+          if (kernel.dolly_snapshot_stream_write(BigInt(chunk.length), 0) !== 0)
+            throw new Error("Dolly rejected a snapshot stream record");
+        }
+        loaded += bytes.length;
+        if (performance.now() - reported >= 1e3) {
+          const mib = 1024 * 1024;
+          stage2(`loading userspace: ${Math.min(Math.floor(loaded / mib), Math.ceil(metadata.byteLength / mib))} / ${Math.ceil(metadata.byteLength / mib)} MiB`);
+          reported = performance.now();
+        }
+      }, () => {
+        if (kernel.dolly_snapshot_stream_write(0n, 1) !== 0)
+          throw new Error("Dolly rejected an incomplete snapshot part");
+      });
+      const status = kernel.dolly_bootstrap_snapshot_end();
+      if (status === 0) for (const [path, contents] of Object.entries(given)) files.write(path, contents);
+      return { status };
+    }
+  };
+});