wasm-quickjs-dom 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SoraKumo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the \"Software\"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,223 @@
-# Temporary Holding Version
+# wasm-quickjs-dom
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Run a web page's JavaScript **without a browser and without `eval`** — and read the resulting DOM.
+
+It is a small JSDOM for places where JSDOM cannot go: Cloudflare Workers, Vercel / Next.js Edge, Deno, Bun, browsers, and plain Node.js. The page's scripts run in [QuickJS-ng](https://github.com/quickjs-ng/quickjs) compiled to WebAssembly, on a [linkedom](https://github.com/WebReflection/linkedom) DOM, so nothing needs `eval`, native modules or a headless browser.
+
+```ts
+import { createDOM } from "wasm-quickjs-dom";
+
+const dom = await createDOM({ url: "https://example.com/" });
+console.log(await dom.eval("document.title"));
+console.log(dom.serialize()); // the HTML after the page's scripts ran
+dom.close();
+```
+
+**Good for:** pre-rendering single-page apps to HTML (SEO, OGP, link previews), reading data that a page builds with JavaScript, running DOM code in tests on edge runtimes, and handing a scripted page to an image renderer such as [wasm-html-to-image](https://www.npmjs.com/package/wasm-html-to-image).
+
+**Not a browser:** there is no layout of its own, no canvas, no `WebSocket` or `Worker`, and QuickJS is an interpreter, so very heavy pages are slow. See [What works](#what-works-and-what-does-not).
+
+## Install
+
+```sh
+npm install wasm-quickjs-dom
+```
+
+ESM only. Node.js 20 or later; the other runtimes below need nothing extra.
+
+## Quick start
+
+### Get the HTML a page has after its scripts ran
+
+```ts
+import { createDOM } from "wasm-quickjs-dom";
+
+const dom = await createDOM(
+  { url: "https://example.com/" },          // or { html: "<p>…</p>", baseUrl: "https://example.com/" }
+  { waitFor: "#app" },                      // wait until this selector matches (default: let timers and requests settle)
+);
+try {
+  const html = dom.serialize();
+} finally {
+  dom.close();                              // always close: it frees the page
+}
+```
+
+### Read values out of the page
+
+`eval` runs code in the page and gives you the result as JSON. It takes a string, or a function and JSON arguments:
+
+```ts
+const title = await dom.eval("document.title");
+const count = await dom.eval((selector: string) => document.querySelectorAll(selector).length, "a.item");
+const rows = await dom.eval(() => [...document.querySelectorAll("tr")].map((tr) => tr.textContent));
+```
+
+A DOM node cannot cross the boundary: return what you read from it. A function is sent as source text, so it cannot use variables from your own scope.
+
+### Drive the page
+
+```ts
+await dom.type("#search", "wasm");           // sets the value, fires input and change
+await dom.click("button[type=submit]");      // dispatches a bubbling click
+await dom.waitForSelector(".results");       // resolves true, or false if it never appears
+dom.expose("saveRow", (row) => db.save(row)); // the page can call: await window.saveRow({...})
+```
+
+### Inside a Worker
+
+```ts
+import { createDOM } from "wasm-quickjs-dom";
+
+export default {
+  async fetch(request: Request) {
+    const target = new URL(request.url).searchParams.get("url")!;
+    const dom = await createDOM(
+      { url: target },
+      { limits: { allowedProtocols: ["https:"], blockPrivateHosts: true, maxResourceBytes: 5_000_000 } },
+    );
+    try {
+      return new Response(dom.serialize(), { headers: { "content-type": "text/html; charset=utf-8" } });
+    } finally {
+      dom.close();
+    }
+  },
+};
+```
+
+There is nothing to configure for the WebAssembly: the right way to load it is picked for the runtime. A complete Worker is in the repository: [`packages/cloudflare-prerender`](../cloudflare-prerender).
+
+### From the command line
+
+```sh
+npx wasm-quickjs-dom https://example.com/ --wait "#app" > rendered.html
+npx wasm-quickjs-dom https://example.com/ -e "document.title"
+npx wasm-quickjs-dom page.html --base-url https://example.com/      # a file; "-" reads standard input
+```
+
+See [Command line](#command-line) below.
+
+## Pages you do not control
+
+A page's scripts can `fetch`, and so can the scripts and modules it loads. **Without `limits`, a page can reach every host your runtime can reach, internal ones included.** For anything you did not write, set them:
+
+```ts
+const dom = await createDOM({ url }, {
+  limits: {
+    allowedProtocols: ["https:"],
+    allowedHosts: ["example.com", "cdn.example.com"], // exact hostnames
+    blockPrivateHosts: true,                          // localhost, private, loopback, link-local
+    maxResourceCount: 50,
+    maxResourceBytes: 5_000_000,
+    maxTotalResourceBytes: 20_000_000,
+  },
+});
+```
+
+- The limits cover the page itself (`url`), the page's own `fetch` / `XMLHttpRequest`, and every script and module it loads. With host or protocol limits, each redirect is checked before it is followed.
+- `blockPrivateHosts` looks at hostnames and IP literals. It cannot see where a hostname resolves through DNS, so use `allowedHosts` as well when the target is not trusted.
+- The scripts run inside the WebAssembly sandbox: they have no file system, no `process`, and reach the outside only through `fetch` (the limits above) and the functions you `expose`.
+- Also bounded for you: each call is limited by `timeout`, and memory and stack by fixed caps.
+
+## API
+
+### `createDOM(source, options?)` → `Promise<QuickJSDOM>`
+
+`source` is `{ url }`, or `{ html, baseUrl? }` for markup you already have (`baseUrl` is where relative URLs resolve and what `location` says).
+
+| Option | Default | |
+| ------ | ------- | --- |
+| `timeout` | `10000` | Upper limit in ms for **each call** into the page (the initial run, each `eval`, `settle`, …). |
+| `settleMs` | `1000` | After load, run timers and requests for at most this long. It is an upper bound: the page finishes as soon as nothing is pending. |
+| `waitFor` | | A CSS selector to wait for after load instead of `settleMs`. |
+| `width` | `800` | `window.innerWidth`; also what `matchMedia` answers for. |
+| `limits` | none | What the page may fetch (see above). |
+| `skip` | | `(url) => boolean`: return `true` for a URL the page should not get. The request fails without going to the network (a `<script>` gets its `error` event, a `fetch` rejects). Analytics and ads are most of a real site's script time, and a render rarely needs them. The page itself is never skipped. |
+| `onLog` | | Called with each log entry as it happens (see `logs`). |
+| `quickjsWasm` | | A compiled `WebAssembly.Module` of your own, instead of the packaged one. |
+
+### The page: `QuickJSDOM`
+
+| Member | |
+| ------ | --- |
+| `baseUrl` | The document's URL (after redirects, when it was fetched). |
+| `eval(code)` / `eval(fn, ...args)` | Run code in the page's global scope; get the result as JSON. Promises are awaited. A throw becomes a rejected promise. Calls run one after another. |
+| `waitForSelector(selector)` | Wait up to `timeout` for a match; `false` if there is none (or can no longer be). |
+| `click(selector)` | Dispatch a bubbling `click` on the first match; `false` if nothing matched. |
+| `type(selector, text)` | Set the first match's `value` (or text), then fire `input` and `change`; `false` if nothing matched. |
+| `expose(name, fn)` | Make a function of yours callable from the page as `await window[name](...args)`. Arguments and result are JSON; a throw rejects with the same message. |
+| `settle(ms?)` | Let timers and requests run for up to `ms` (default `settleMs`). |
+| `serialize()` | The document as HTML, as it is now. |
+| `logs` | What happened so far (the last 1000): `console` output, script errors, unhandled promise rejections, and requests with their status or failure. The first place to look when a page comes back empty. |
+| `close()` | Free the page. It cannot be used afterwards. |
+| `toOptions(options)` | Fill `value` (the serialized DOM) and `baseUrl` of an options object — for example the render options of wasm-html-to-image. |
+| `markForLayout()` / `setLayout(boxes)` | Give the page a layout (see below). |
+
+**The page's clock runs only while one of these calls is waiting.** Timers and requests progress during `eval`, `settle`, `waitForSelector` and so on, and stand still in between.
+
+Log entries look like `{ type: "console", level, message }`, `{ type: "error", message, source }`, `{ type: "rejection", message }` and `{ type: "request", method, url, status?, error? }`.
+
+### `runPageScriptsQuickJS(source, options?)` → `Promise<{ html, baseUrl }>`
+
+For when you only want the HTML: runs the page with the same options as `createDOM` and closes it for you.
+
+### Layout
+
+There is no layout inside QuickJS, so `getBoundingClientRect()`, `offsetWidth` and the like return 0 — until you give the page boxes with `setLayout({ [elementNumber]: [x, y, width, height] })`. With `wasm-html-to-image` this is one call, `measureLayout(dom, render)`, which lays the page out with its engine and fills the boxes in (inline elements included). Use it for pages whose scripts size things from the real layout.
+
+## What works, and what does not
+
+**Works:** inline, external, dynamically added and `type="module"` scripts (static `import`s and `import("literal")` are fetched up front); `fetch` and `XMLHttpRequest` (binary safe); timers, `requestAnimationFrame`, promises; `history.pushState`, `localStorage` / `sessionStorage` (in memory), `customElements`, `MutationObserver`, `crypto.getRandomValues` / `randomUUID`; `matchMedia` for the viewport width; `getComputedStyle` (the element's own style plus initial values); `IntersectionObserver` and `ResizeObserver` (each reports once on `observe()`, so lazy content loads). React and Next.js clients hydrate and run their effects.
+
+**Does not:** layout (see above), `canvas`, `WebSocket`, `EventSource`, `Worker`, `iframe` content, CSS cascade computation, and anything that needs a real browser engine. A DOM smaller than JSDOM's. If a script throws, the page carries on with what it had; `dom.logs` tells you what went wrong.
+
+**Speed:** a page starts in about 3 ms (the first in a process pays about 120 ms). A typical page, including its network, takes a few hundred ms; parsing runs at roughly 0.3 MB/s, so very large pages take seconds.
+
+## Where it runs
+
+| Runtime | How the WebAssembly is loaded |
+| ------- | ----------------------------- |
+| Cloudflare Workers | imported as a pre-compiled module (`workerd` condition) |
+| Vercel / Next.js Edge | imported with `?module` (`edge-light` condition) |
+| Node.js, Bun | read from the package and compiled once |
+| Deno, browsers | fetched from beside the module and compiled once |
+
+All of that is automatic. If your setup differs, pass your own module: `createDOM(source, { quickjsWasm })` (`wasm-quickjs-dom/quickjs.wasm` is the file).
+
+## Command line
+
+```sh
+wasm-quickjs-dom [options] <url | file | ->
+```
+
+Prints the HTML after the page's scripts ran.
+
+| Option | |
+| ------ | --- |
+| `-o, --output <file>` | Write to a file instead of standard output. |
+| `-e, --eval <code>` | Print the value of this code instead (a string as it is, anything else as JSON). |
+| `--json` | Print `{ baseUrl, html, logs }` as JSON. |
+| `--logs` | Also write the page's log (console, errors, rejections, requests) to standard error. |
+| `--wait <selector>`, `--settle <ms>`, `--timeout <ms>`, `--width <px>` | Shape the run (same as the options above). |
+| `--base-url <url>` | The page's URL, for a file or standard input. |
+| `--protocol <p>`, `--allow-host <h>`, `--block-host <h>`, `--block-private`, `--max-bytes <n>`, `--max-requests <n>` | The limits (repeat `--protocol`, `--allow-host` and `--block-host`). Set them for pages you do not control. |
+| `--skip <text>` | Do not fetch URLs containing this text (repeatable). |
+
+Exit code `0` is done, `1` the page could not be loaded (or `-e` threw), `2` wrong usage. `--help` lists everything.
+
+## How it works
+
+Each page gets its own WebAssembly instance of QuickJS-ng. The browser APIs a bare QuickJS lacks, and linkedom, are compiled to QuickJS bytecode when the package is built; the first page of a process starts that program, and every later page is a copy of that started instance, which is why a page starts in about 3 ms. Nothing is shared between pages. Each gets its own clock origin and `Math.random` seed.
+
+## For contributors
+
+The package builds its own QuickJS: `vendor/quickjs` (QuickJS-ng, unmodified) and `csrc/qjsdom.c` are compiled to a standalone `dist/quickjs.wasm` with Emscripten (`emcc` on `PATH`), and the guest program is compiled to bytecode with that very wasm.
+
+```sh
+pnpm --filter wasm-quickjs-dom build
+pnpm --filter wasm-quickjs-dom test
+```
+
+## License
+
+MIT. QuickJS-ng, linkedom and web-streams-polyfill are included under their own licenses: see `THIRD-PARTY-NOTICES.md`.

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,32 @@
+# Third-party notices
+
+`wasm-quickjs-dom` ships these works inside `dist/`.
+
+- **QuickJS-ng** (v0.18.0, <https://github.com/quickjs-ng/quickjs>), compiled to `dist/quickjs.wasm`. Source in `vendor/quickjs/`. MIT:
+
+    The MIT License (MIT)
+     
+    Copyright (c) 2017-2026 Fabrice Bellard
+    Copyright (c) 2017-2024 Charlie Gordon
+    Copyright (c) 2023-2026 Ben Noordhuis
+    Copyright (c) 2023-2026 Saúl Ibarra Corretgé
+    
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+    
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+
+- **linkedom** (<https://github.com/WebReflection/linkedom>), ISC, and **web-streams-polyfill** (<https://github.com/MattiasBuelens/web-streams-polyfill>), MIT, are bundled into the guest program `dist/edge-js-payload.js`.

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { run } from "./cli.js";
+const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+const code = await run(process.argv.slice(2), {
+    stdin: async () => {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(chunk);
+        return Buffer.concat(chunks).toString("utf8");
+    },
+    // a pipe closed early (`| head`) is not an error worth a stack trace
+    stdout: (text) => void process.stdout.write(text),
+    stderr: (text) => void process.stderr.write(text),
+}, version);
+process.exitCode = code;

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+export interface CliIO {
+    /** Everything of standard input (read only when the input is `-`). */
+    stdin(): Promise<string>;
+    stdout(text: string): void;
+    stderr(text: string): void;
+}
+/** Run the command. Returns the exit code: 0 done, 1 the page could not be loaded, 2 wrong usage. */
+export declare function run(argv: string[], io: CliIO, version?: string): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,197 @@
+/**
+ * The `wasm-quickjs-dom` command: load a page, let its scripts run, print the result.
+ *
+ *   wasm-quickjs-dom https://example.com/ --wait "#app" > rendered.html
+ *   wasm-quickjs-dom page.html --base-url https://example.com/ -e "document.title"
+ *   curl -s https://example.com/ | wasm-quickjs-dom - --base-url https://example.com/
+ *
+ * `run` takes its streams as arguments so it can be tested; `bin.ts` wires it to the process.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { createDOM } from "./index.js";
+const HELP = `wasm-quickjs-dom - run a page's scripts in QuickJS (WebAssembly) and print the result
+
+Usage: wasm-quickjs-dom [options] <url | file | ->
+
+  <url>      an http(s) page to fetch and run
+  <file>     an HTML file ("-" reads standard input); use --base-url to say where it belongs,
+             which is also where its relative scripts are fetched from
+
+Output (default: the HTML as it is after the scripts ran)
+  -o, --output <file>      write to a file instead of standard output
+  -e, --eval <code>        print the value of this code, run in the page (strings as they are, the rest as JSON)
+      --json               print { baseUrl, html, logs } as JSON
+      --logs               also print what happened in the page (console, errors, rejections, requests) to standard error
+
+Running
+      --wait <selector>    wait until a CSS selector matches (up to --timeout)
+      --settle <ms>        at most this long for timers and requests after load (default 1000; ends early when idle)
+      --timeout <ms>       upper limit for the scripts (default 10000)
+      --width <px>         window width of the page (default 800)
+      --base-url <url>     the page's URL, for file and standard input
+
+Limits (set these for pages you do not control)
+      --protocol <p>       allowed protocol such as https: (repeatable)
+      --allow-host <host>  only these hosts may be fetched (repeatable)
+      --block-host <host>  these hosts may not be fetched (repeatable)
+      --block-private      refuse localhost and private networks
+      --max-bytes <n>      refuse a response over n bytes
+      --max-requests <n>   at most n requests
+      --skip <text>        do not fetch URLs containing text (repeatable; analytics, ads, ...)
+
+  -h, --help               show this help
+  -v, --version            show the version
+`;
+const fail = (io, message) => {
+    io.stderr(`wasm-quickjs-dom: ${message}\n`);
+    return 2;
+};
+/** An error's message with the reason under it (Node's `fetch failed` hides the real one in `cause`). */
+function describe(error) {
+    const e = error;
+    const why = e.cause?.message ?? e.cause?.code;
+    return why && !e.message.includes(why) ? `${e.message}: ${why}` : e.message;
+}
+function number(name, value) {
+    if (value === undefined)
+        return undefined;
+    const n = Number(value);
+    return Number.isFinite(n) && n >= 0 ? n : new Error(`--${name} needs a number, got "${value}"`);
+}
+function formatLog(entry) {
+    switch (entry.type) {
+        case "console":
+            return `console.${entry.level}: ${entry.message}`;
+        case "error":
+            return `error in ${entry.source}: ${entry.message.trim()}`;
+        case "rejection":
+            return `unhandled rejection: ${entry.message.trim()}`;
+        case "request":
+            return `${entry.method} ${entry.url} -> ${entry.error ?? entry.status}`;
+    }
+}
+/** Run the command. Returns the exit code: 0 done, 1 the page could not be loaded, 2 wrong usage. */
+export async function run(argv, io, version = "0.0.0") {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                output: { type: "string", short: "o" },
+                eval: { type: "string", short: "e" },
+                json: { type: "boolean" },
+                logs: { type: "boolean" },
+                wait: { type: "string" },
+                settle: { type: "string" },
+                timeout: { type: "string" },
+                width: { type: "string" },
+                "base-url": { type: "string" },
+                protocol: { type: "string", multiple: true },
+                "allow-host": { type: "string", multiple: true },
+                "block-host": { type: "string", multiple: true },
+                "block-private": { type: "boolean" },
+                "max-bytes": { type: "string" },
+                "max-requests": { type: "string" },
+                skip: { type: "string", multiple: true },
+                help: { type: "boolean", short: "h" },
+                version: { type: "boolean", short: "v" },
+            },
+        });
+    }
+    catch (error) {
+        return fail(io, `${error.message}\nTry --help.`);
+    }
+    const { values, positionals } = parsed;
+    if (values.help) {
+        io.stdout(HELP);
+        return 0;
+    }
+    if (values.version) {
+        io.stdout(`${version}\n`);
+        return 0;
+    }
+    if (positionals.length !== 1)
+        return fail(io, `give exactly one page (a URL, a file, or - for standard input)\nTry --help.`);
+    if (values.json && values.eval !== undefined)
+        return fail(io, "--json and --eval cannot be used together");
+    const numbers = {
+        settle: number("settle", values.settle),
+        timeout: number("timeout", values.timeout),
+        width: number("width", values.width),
+        maxBytes: number("max-bytes", values["max-bytes"]),
+        maxRequests: number("max-requests", values["max-requests"]),
+    };
+    for (const v of Object.values(numbers))
+        if (v instanceof Error)
+            return fail(io, v.message);
+    const n = numbers;
+    const limits = {
+        allowedProtocols: values.protocol,
+        allowedHosts: values["allow-host"],
+        blockedHosts: values["block-host"],
+        blockPrivateHosts: values["block-private"] || undefined,
+        maxResourceBytes: n.maxBytes,
+        maxResourceCount: n.maxRequests,
+    };
+    const skips = values.skip ?? [];
+    const options = {
+        settleMs: n.settle,
+        timeout: n.timeout,
+        waitFor: values.wait,
+        width: n.width,
+        limits,
+        skip: skips.length ? (url) => skips.some((s) => url.includes(s)) : undefined,
+    };
+    const input = positionals[0];
+    let source;
+    try {
+        if (/^https?:\/\//i.test(input))
+            source = { url: input };
+        else
+            source = { html: input === "-" ? await io.stdin() : readFileSync(input, "utf8"), baseUrl: values["base-url"] };
+    }
+    catch (error) {
+        return fail(io, `cannot read ${input}: ${error.message}`);
+    }
+    let dom;
+    try {
+        dom = await createDOM(source, options);
+    }
+    catch (error) {
+        io.stderr(`wasm-quickjs-dom: ${describe(error)}\n`);
+        return 1;
+    }
+    try {
+        let out;
+        if (values.eval !== undefined) {
+            const value = await dom.eval(values.eval);
+            out = typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? "undefined";
+        }
+        else if (values.json) {
+            out = JSON.stringify({ baseUrl: dom.baseUrl, html: dom.serialize(), logs: dom.logs }, null, 2);
+        }
+        else {
+            out = dom.serialize();
+        }
+        if (values.logs)
+            for (const entry of dom.logs)
+                io.stderr(`${formatLog(entry)}\n`);
+        if (values.output)
+            writeFileSync(values.output, out.endsWith("\n") ? out : `${out}\n`);
+        else
+            io.stdout(out.endsWith("\n") ? out : `${out}\n`);
+        return 0;
+    }
+    catch (error) {
+        if (values.logs)
+            for (const entry of dom.logs)
+                io.stderr(`${formatLog(entry)}\n`);
+        io.stderr(`wasm-quickjs-dom: ${error.message}\n`);
+        return 1;
+    }
+    finally {
+        dom.close();
+    }
+}