@scriptc/runtime 0.0.0 → 0.0.2

package/src/scr_web.c

@@ -0,0 +1,1778 @@
+/* Web-platform globals for the dynamic island: a pure-JS prelude evaluated
+ * once at engine boot (before any embedded module runs — eventsource-parser
+ * subclasses TransformStream at module-eval time), defining the WHATWG
+ * subset the embedded-npm request paths exercise. Compiled and linked ONLY
+ * under -DSCR_DYNAMIC, like scr_island.c.
+ *
+ * This file owns the semantics-heavy globals: the streams library
+ * (ReadableStream, TransformStream), the encoders (TextEncoder,
+ * TextDecoder — the WHATWG utf-8 state machine exactly, other labels
+ * fenced — and TextDecoderStream), URLSearchParams, btoa/atob, Headers,
+ * the fetch value classes (Request/Response with stream-or-bytes bodies,
+ * consumed through text/json/bytes/arrayBuffer; clone() fenced; plus the
+ * __scr_mk_response seam scr_fetch.c's glue builds wire responses
+ * through), DOMException and AbortController/AbortSignal (pure JS state;
+ * AbortSignal.timeout arms an unref'd island timer through host.timer —
+ * the machinery at the bottom of this file; fetch's signal wiring lives
+ * in scr_fetch.c's glue), crypto (getRandomValues/randomUUID over host functions
+ * bridging to the SAME arc4random_buf CSPRNG the static crypto lowerings
+ * use), and a console shim (String()-formatted writes to the real fds —
+ * no printf formatting, no object inspection). fetch itself lives in
+ * scr_fetch.c, linked only when the embedded graph references it. The correctness bar is the WHATWG
+ * subset the AI-SDK / eventsource-parser paths use — implemented honestly
+ * and pinned by the differential harness against Node's REAL
+ * implementations (the web-streams npm fixture, corpus 1120) plus
+ * scriptc-only fence tests (tests/harness/web-globals.test.ts). OUT,
+ * with clear errors: byte streams ('type': 'bytes') and BYOB readers,
+ * tee(), pipeTo(), custom queuing strategies (accepted, ignored — HWM is
+ * always 1), a global WritableStream (TransformStream.writable is an
+ * internal writable; the class is not exposed), and non-utf-8 TextDecoder
+ * labels. One documented behavioral divergence: transforms run EAGERLY on
+ * write (no readable-side backpressure), so writer.write() never blocks
+ * on downstream demand — order-exact, buffering-different. SEMANTICS.md
+ * states the subset; keep the three in sync.
+ *
+ * The JS was verified line-for-line against Node's native WHATWG
+ * implementations (a transcript battery: reader protocol, pull timing,
+ * error propagation both directions, cancel-on-break, flush ordering,
+ * utf-8 maximal-subpart replacement, BOM handling, form encoding, header
+ * combining/sorting) running under BOTH engines before being embedded. */
+#ifdef SCR_DYNAMIC
+
+#include "scr_runtime.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "quickjs.h"
+
+/* The prelude: one arrow function evaluated at boot and called with a host
+ * object (I/O-free today; the host parameter is the seam later slices —
+ * encoders, crypto — bridge through). */
+static const char web_prelude[] =
+    "(host) => {\n"
+    "  'use strict';\n"
+    "  const g = globalThis;\n"
+    "\n"
+    "  /* Timers: Node's setTimeout/clearTimeout/setInterval/clearInterval\n"
+    "   * for embedded code, bridged onto the SHARED static timer heap\n"
+    "   * (host.setTimer/host.clearTimer) — REF'd like Node's (an armed\n"
+    "   * timer keeps the process alive), FIFO-ordered against static\n"
+    "   * timers on one heap, Node's <1ms clamp. Returns a Timeout-shaped\n"
+    "   * object (ref/unref/refresh/close, numeric via toPrimitive) that\n"
+    "   * clearTimeout/clearInterval accept alongside plain ids; unref is\n"
+    "   * accepted but not honored (the entry stays ref'd — a documented\n"
+    "   * approximation). */\n"
+    "  class Timeout {\n"
+    "    constructor(fn, delay, repeat) {\n"
+    "      this._fn = fn;\n"
+    "      this._delay = delay;\n"
+    "      this._repeat = repeat;\n"
+    "      this._id = host.setTimer(fn, delay, repeat);\n"
+    "    }\n"
+    "    ref() { return this; }\n"
+    "    unref() { return this; }\n"
+    "    hasRef() { return true; }\n"
+    "    refresh() {\n"
+    "      host.clearTimer(this._id);\n"
+    "      this._id = host.setTimer(this._fn, this._delay, this._repeat);\n"
+    "      return this;\n"
+    "    }\n"
+    "    close() { host.clearTimer(this._id); return this; }\n"
+    "    [Symbol.toPrimitive]() { return this._id; }\n"
+    "  }\n"
+    "  const mkTimer = (fn, ms, args, repeat) => {\n"
+    "    if (typeof fn !== 'function') {\n"
+    "      throw new TypeError('The \"callback\" argument must be of type function. Received type ' + typeof fn);\n"
+    "    }\n"
+    "    const cb = args.length === 0 ? fn : () => fn(...args);\n"
+    "    return new Timeout(cb, Number(ms), repeat);\n"
+    "  };\n"
+    "  g.setTimeout = (fn, ms, ...args) => mkTimer(fn, ms, args, false);\n"
+    "  g.setInterval = (fn, ms, ...args) => mkTimer(fn, ms, args, true);\n"
+    "  g.clearTimeout = (t) => {\n"
+    "    if (t === undefined || t === null) return;\n"
+    "    const id = typeof t === 'number' ? t : Number(t);\n"
+    "    if (Number.isFinite(id)) host.clearTimer(id);\n"
+    "  };\n"
+    "  g.clearInterval = g.clearTimeout;\n"
+    "\n"
+    "  class ReadableStream {\n"
+    "    constructor(source, _strategy) {\n"
+    "      if (source === undefined) source = {};\n"
+    "      if (source === null || typeof source !== 'object') {\n"
+    "        throw new TypeError('underlying source must be an object');\n"
+    "      }\n"
+    "      if (source.type !== undefined) {\n"
+    "        throw new RangeError(\"byte streams (type: 'bytes') are not supported in the scriptc island\");\n"
+    "      }\n"
+    "      this._src = source;\n"
+    "      this._queue = [];\n"
+    "      this._state = 'readable';\n"
+    "      this._storedError = undefined;\n"
+    "      this._locked = false;\n"
+    "      this._reads = [];\n"
+    "      this._closeRequested = false;\n"
+    "      this._started = false;\n"
+    "      this._pulling = false;\n"
+    "      this._pullAgain = false;\n"
+    "      this._closedResolve = null;\n"
+    "      this._closedReject = null;\n"
+    "      const self = this;\n"
+    "      this._controller = {\n"
+    "        get desiredSize() {\n"
+    "          if (self._state === 'errored') return null;\n"
+    "          if (self._state === 'closed') return 0;\n"
+    "          return 1 - self._queue.length;\n"
+    "        },\n"
+    "        enqueue(chunk) {\n"
+    "          if (self._closeRequested || self._state !== 'readable') {\n"
+    "            throw new TypeError('cannot enqueue on a stream that is ' + (self._closeRequested ? 'closing' : self._state));\n"
+    "          }\n"
+    "          if (self._reads.length > 0) self._reads.shift().resolve({ value: chunk, done: false });\n"
+    "          else self._queue.push(chunk);\n"
+    "          self._maybePull();\n"
+    "        },\n"
+    "        close() {\n"
+    "          if (self._closeRequested || self._state !== 'readable') {\n"
+    "            throw new TypeError('cannot close a stream that is ' + (self._closeRequested ? 'closing' : self._state));\n"
+    "          }\n"
+    "          self._closeRequested = true;\n"
+    "          if (self._queue.length === 0) self._finishClose();\n"
+    "        },\n"
+    "        error(e) {\n"
+    "          self._errorStream(e);\n"
+    "        },\n"
+    "      };\n"
+    "      let startResult;\n"
+    "      if (source.start) startResult = source.start(this._controller); // a sync throw propagates, per spec\n"
+    "      Promise.resolve(startResult).then(\n"
+    "        () => { this._started = true; this._maybePull(); },\n"
+    "        (e) => this._errorStream(e),\n"
+    "      );\n"
+    "    }\n"
+    "    _finishClose() {\n"
+    "      if (this._state !== 'readable') return;\n"
+    "      this._state = 'closed';\n"
+    "      const reads = this._reads;\n"
+    "      this._reads = [];\n"
+    "      for (const r of reads) r.resolve({ value: undefined, done: true });\n"
+    "      if (this._closedResolve) this._closedResolve();\n"
+    "    }\n"
+    "    _errorStream(e) {\n"
+    "      if (this._state !== 'readable') return;\n"
+    "      this._state = 'errored';\n"
+    "      this._storedError = e;\n"
+    "      this._queue.length = 0;\n"
+    "      const reads = this._reads;\n"
+    "      this._reads = [];\n"
+    "      for (const r of reads) r.reject(e);\n"
+    "      if (this._closedReject) this._closedReject(e);\n"
+    "    }\n"
+    "    /* Proactive pull, like the spec with the default HWM-1 strategy: pull\n"
+    "     * whenever there is space (queue empty), started, and no pull running. */\n"
+    "    _maybePull() {\n"
+    "      const src = this._src;\n"
+    "      if (!src.pull || !this._started) return;\n"
+    "      if (this._state !== 'readable' || this._closeRequested) return;\n"
+    "      if (this._queue.length >= 1) return;\n"
+    "      if (this._pulling) { this._pullAgain = true; return; }\n"
+    "      this._pulling = true;\n"
+    "      Promise.resolve().then(() => {\n"
+    "        if (this._state !== 'readable' || this._closeRequested) { this._pulling = false; return; }\n"
+    "        let r;\n"
+    "        try { r = src.pull(this._controller); } catch (e) { this._pulling = false; this._errorStream(e); return; }\n"
+    "        Promise.resolve(r).then(\n"
+    "          () => {\n"
+    "            this._pulling = false;\n"
+    "            if (this._pullAgain || this._queue.length === 0) { this._pullAgain = false; this._maybePull(); }\n"
+    "          },\n"
+    "          (e) => { this._pulling = false; this._errorStream(e); },\n"
+    "        );\n"
+    "      });\n"
+    "    }\n"
+    "    get locked() { return this._locked; }\n"
+    "    cancel(reason) {\n"
+    "      if (this._locked) return Promise.reject(new TypeError('cannot cancel a locked ReadableStream'));\n"
+    "      return this._cancelInternal(reason);\n"
+    "    }\n"
+    "    _cancelInternal(reason) {\n"
+    "      if (this._state === 'closed') return Promise.resolve();\n"
+    "      if (this._state === 'errored') return Promise.reject(this._storedError);\n"
+    "      this._queue.length = 0;\n"
+    "      this._closeRequested = true;\n"
+    "      this._finishClose();\n"
+    "      const src = this._src;\n"
+    "      return Promise.resolve(src.cancel ? src.cancel(reason) : undefined).then(() => undefined);\n"
+    "    }\n"
+    "    getReader(options) {\n"
+    "      if (options !== undefined && options !== null && options.mode !== undefined) {\n"
+    "        throw new TypeError('BYOB readers are not supported in the scriptc island');\n"
+    "      }\n"
+    "      if (this._locked) throw new TypeError('ReadableStream is locked');\n"
+    "      this._locked = true;\n"
+    "      const self = this;\n"
+    "      let res, rej;\n"
+    "      const closed = new Promise((a, b) => { res = a; rej = b; });\n"
+    "      closed.catch(() => {});\n"
+    "      this._closedResolve = res;\n"
+    "      this._closedReject = rej;\n"
+    "      if (this._state === 'closed') res();\n"
+    "      else if (this._state === 'errored') rej(this._storedError);\n"
+    "      let released = false;\n"
+    "      return {\n"
+    "        get closed() { return closed; },\n"
+    "        read() {\n"
+    "          if (released) return Promise.reject(new TypeError('reader has been released'));\n"
+    "          if (self._queue.length > 0) {\n"
+    "            const chunk = self._queue.shift();\n"
+    "            if (self._closeRequested && self._queue.length === 0) self._finishClose();\n"
+    "            else self._maybePull();\n"
+    "            return Promise.resolve({ value: chunk, done: false });\n"
+    "          }\n"
+    "          if (self._state === 'closed') return Promise.resolve({ value: undefined, done: true });\n"
+    "          if (self._state === 'errored') return Promise.reject(self._storedError);\n"
+    "          return new Promise((resolve, reject) => {\n"
+    "            self._reads.push({ resolve, reject });\n"
+    "            self._maybePull();\n"
+    "          });\n"
+    "        },\n"
+    "        releaseLock() {\n"
+    "          if (released) return;\n"
+    "          released = true;\n"
+    "          const reads = self._reads;\n"
+    "          self._reads = [];\n"
+    "          for (const r of reads) r.reject(new TypeError('reader was released'));\n"
+    "          self._locked = false;\n"
+    "          self._closedResolve = null;\n"
+    "          self._closedReject = null;\n"
+    "        },\n"
+    "        cancel(reason) {\n"
+    "          if (released) return Promise.reject(new TypeError('reader has been released'));\n"
+    "          return self._cancelInternal(reason);\n"
+    "        },\n"
+    "      };\n"
+    "    }\n"
+    "    /* The iterator carries a `finished` latch because the ENGINE's\n"
+    "     * for-await closes more eagerly than V8: quickjs-ng calls return()\n"
+    "     * on NORMAL completion and after a next() rejection (V8 does\n"
+    "     * neither), and an unlatched return() would then cancel a released\n"
+    "     * reader — minting a rejected promise nobody awaits, which the\n"
+    "     * unhandled-rejection tracker reports at exit. Same story for the\n"
+    "     * no-op catch on return()'s result: the engine drops it on those\n"
+    "     * paths, so a real cancel rejection must be pre-observed (callers\n"
+    "     * who DO await it — the break path — still see the rejection). */\n"
+    "    values(options) {\n"
+    "      const preventCancel = options !== undefined && options !== null && !!options.preventCancel;\n"
+    "      const reader = this.getReader();\n"
+    "      let finished = false;\n"
+    "      const it = {\n"
+    "        next() {\n"
+    "          if (finished) return Promise.resolve({ value: undefined, done: true });\n"
+    "          return reader.read().then(\n"
+    "            (r) => {\n"
+    "              if (r.done) { finished = true; reader.releaseLock(); }\n"
+    "              return r;\n"
+    "            },\n"
+    "            (e) => { finished = true; reader.releaseLock(); throw e; },\n"
+    "          );\n"
+    "        },\n"
+    "        return(v) {\n"
+    "          if (finished) return Promise.resolve({ value: v, done: true });\n"
+    "          finished = true;\n"
+    "          const p = preventCancel ? Promise.resolve() : reader.cancel(v);\n"
+    "          reader.releaseLock();\n"
+    "          const res = p.then(() => ({ value: v, done: true }));\n"
+    "          res.catch(() => {});\n"
+    "          return res;\n"
+    "        },\n"
+    "        [Symbol.asyncIterator]() { return this; },\n"
+    "      };\n"
+    "      return it;\n"
+    "    }\n"
+    "    [Symbol.asyncIterator](options) { return this.values(options); }\n"
+    "    pipeThrough(transform, options) {\n"
+    "      if (transform === null || typeof transform !== 'object' || !transform.writable || !transform.readable) {\n"
+    "        throw new TypeError('pipeThrough requires a { writable, readable } pair');\n"
+    "      }\n"
+    "      if (options !== undefined && options !== null && options.signal !== undefined) {\n"
+    "        throw new Error('scriptc: AbortSignal is not supported by island streams yet');\n"
+    "      }\n"
+    "      pump(this, transform.writable);\n"
+    "      return transform.readable;\n"
+    "    }\n"
+    "    pipeTo() {\n"
+    "      throw new Error('ReadableStream.pipeTo is not supported in the scriptc island (use pipeThrough or a reader)');\n"
+    "    }\n"
+    "    tee() {\n"
+    "      throw new Error('ReadableStream.tee is not supported in the scriptc island');\n"
+    "    }\n"
+    "  }\n"
+    "\n"
+    "  /* The internal writable half of TransformStream. Deliberately NOT\n"
+    "   * installed as a global WritableStream: the island fences the class\n"
+    "   * (nothing in the supported graph constructs one). */\n"
+    "  class WritableLite {\n"
+    "    constructor(sink) {\n"
+    "      this._sink = sink;\n"
+    "      this._state = 'writable';\n"
+    "      this._err = undefined;\n"
+    "      this._locked = false;\n"
+    "      this._closedRes = null;\n"
+    "      this._closedRej = null;\n"
+    "    }\n"
+    "    get locked() { return this._locked; }\n"
+    "    _error(e) {\n"
+    "      if (this._state === 'errored') return;\n"
+    "      this._state = 'errored';\n"
+    "      this._err = e;\n"
+    "      if (this._closedRej) this._closedRej(e);\n"
+    "    }\n"
+    "    abort(e) {\n"
+    "      if (this._state === 'errored') return Promise.resolve();\n"
+    "      this._error(e);\n"
+    "      return Promise.resolve(this._sink.abort ? this._sink.abort(e) : undefined).then(() => undefined);\n"
+    "    }\n"
+    "    getWriter() {\n"
+    "      if (this._locked) throw new TypeError('WritableStream is locked');\n"
+    "      this._locked = true;\n"
+    "      const self = this;\n"
+    "      let res, rej;\n"
+    "      const closed = new Promise((a, b) => { res = a; rej = b; });\n"
+    "      closed.catch(() => {});\n"
+    "      this._closedRes = res;\n"
+    "      this._closedRej = rej;\n"
+    "      if (this._state === 'errored') rej(this._err);\n"
+    "      return {\n"
+    "        get closed() { return closed; },\n"
+    "        get ready() { return self._state === 'errored' ? Promise.reject(self._err) : Promise.resolve(); },\n"
+    "        get desiredSize() {\n"
+    "          if (self._state === 'errored') return null;\n"
+    "          return self._state === 'writable' ? 1 : 0;\n"
+    "        },\n"
+    "        write(chunk) {\n"
+    "          if (self._state === 'errored') return Promise.reject(self._err);\n"
+    "          if (self._state !== 'writable') return Promise.reject(new TypeError('cannot write to a ' + self._state + ' stream'));\n"
+    "          let r;\n"
+    "          try { r = self._sink.write(chunk); } catch (e) { self._error(e); return Promise.reject(e); }\n"
+    "          return Promise.resolve(r).catch((e) => { self._error(e); throw e; });\n"
+    "        },\n"
+    "        close() {\n"
+    "          if (self._state === 'errored') return Promise.reject(self._err);\n"
+    "          if (self._state !== 'writable') return Promise.reject(new TypeError('cannot close a ' + self._state + ' stream'));\n"
+    "          self._state = 'closed';\n"
+    "          let r;\n"
+    "          try { r = self._sink.close ? self._sink.close() : undefined; } catch (e) { self._state = 'errored'; self._err = e; rej(e); return Promise.reject(e); }\n"
+    "          return Promise.resolve(r).then(\n"
+    "            () => { res(); },\n"
+    "            (e) => { self._state = 'errored'; self._err = e; rej(e); throw e; },\n"
+    "          );\n"
+    "        },\n"
+    "        abort(e) { return self.abort(e); },\n"
+    "        releaseLock() { self._locked = false; },\n"
+    "      };\n"
+    "    }\n"
+    "  }\n"
+    "\n"
+    "  const pump = (rs, ws) => {\n"
+    "    const reader = rs.getReader();\n"
+    "    const writer = ws.getWriter();\n"
+    "    const step = () =>\n"
+    "      reader.read().then((r) => {\n"
+    "        if (r.done) return writer.close();\n"
+    "        return writer.write(r.value).then(step);\n"
+    "      });\n"
+    "    step().catch((e) => {\n"
+    "      writer.abort(e).catch(() => {});\n"
+    "      reader.cancel(e).catch(() => {});\n"
+    "    });\n"
+    "  };\n"
+    "\n"
+    "  class TransformStream {\n"
+    "    constructor(transformer, _ws, _rs) {\n"
+    "      if (transformer === undefined || transformer === null) transformer = {};\n"
+    "      if (transformer.readableType !== undefined || transformer.writableType !== undefined) {\n"
+    "        throw new RangeError('readableType/writableType are not supported in the scriptc island');\n"
+    "      }\n"
+    "      const t = transformer;\n"
+    "      const self = this;\n"
+    "      let rc = null;\n"
+    "      this._readable = new ReadableStream({\n"
+    "        start(c) { rc = c; },\n"
+    "        cancel(reason) { self._writable._error(reason); },\n"
+    "      });\n"
+    "      const tc = {\n"
+    "        enqueue(chunk) { rc.enqueue(chunk); },\n"
+    "        error(e) {\n"
+    "          self._readable._errorStream(e);\n"
+    "          self._writable._error(e);\n"
+    "        },\n"
+    "        terminate() {\n"
+    "          if (self._readable._state === 'readable' && !self._readable._closeRequested) rc.close();\n"
+    "          self._writable._error(new TypeError('The transform stream has been terminated'));\n"
+    "        },\n"
+    "        get desiredSize() { return rc.desiredSize; },\n"
+    "      };\n"
+    "      this._controller = tc;\n"
+    "      this._writable = new WritableLite({\n"
+    "        /* Eager transform: writes run the transformer immediately (no\n"
+    "         * readable-side backpressure) — order-exact, documented. */\n"
+    "        write(chunk) {\n"
+    "          let r;\n"
+    "          try { r = t.transform ? t.transform(chunk, tc) : tc.enqueue(chunk); } catch (e) { tc.error(e); throw e; }\n"
+    "          return Promise.resolve(r).catch((e) => { tc.error(e); throw e; });\n"
+    "        },\n"
+    "        close() {\n"
+    "          let r;\n"
+    "          try { r = t.flush ? t.flush(tc) : undefined; } catch (e) { tc.error(e); throw e; }\n"
+    "          return Promise.resolve(r).then(\n"
+    "            () => {\n"
+    "              if (self._readable._state === 'readable' && !self._readable._closeRequested) rc.close();\n"
+    "            },\n"
+    "            (e) => { tc.error(e); throw e; },\n"
+    "          );\n"
+    "        },\n"
+    "        abort(e) { self._readable._errorStream(e); },\n"
+    "      });\n"
+    "      if (t.start) t.start(tc); // sync start, like eventsource-parser needs\n"
+    "    }\n"
+    "    get readable() { return this._readable; }\n"
+    "    get writable() { return this._writable; }\n"
+    "  }\n"
+    "\n"
+    "  g.ReadableStream = ReadableStream;\n"
+    "  g.TransformStream = TransformStream;\n"
+    "\n"
+    "\n"
+    "  class TextEncoder {\n"
+    "    get encoding() { return 'utf-8'; }\n"
+    "    encode(input) {\n"
+    "      const s = input === undefined ? '' : String(input);\n"
+    "      const bytes = [];\n"
+    "      for (let i = 0; i < s.length; i++) {\n"
+    "        let c = s.charCodeAt(i);\n"
+    "        if (c >= 0xd800 && c <= 0xdbff) {\n"
+    "          const n = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;\n"
+    "          if (n >= 0xdc00 && n <= 0xdfff) { c = 0x10000 + ((c - 0xd800) << 10) + (n - 0xdc00); i++; }\n"
+    "          else c = 0xfffd;\n"
+    "        } else if (c >= 0xdc00 && c <= 0xdfff) c = 0xfffd;\n"
+    "        if (c <= 0x7f) bytes.push(c);\n"
+    "        else if (c <= 0x7ff) bytes.push(0xc0 | (c >> 6), 0x80 | (c & 63));\n"
+    "        else if (c <= 0xffff) bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));\n"
+    "        else bytes.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));\n"
+    "      }\n"
+    "      return new Uint8Array(bytes);\n"
+    "    }\n"
+    "  }\n"
+    "\n"
+    "  /* The WHATWG utf-8 decoder state machine, exactly (maximal-subpart\n"
+    "   * replacement, streaming carry, BOM stripping, fatal mode). */\n"
+    "  class TextDecoder {\n"
+    "    constructor(label, options) {\n"
+    "      const l = String(label === undefined ? 'utf-8' : label).trim().toLowerCase();\n"
+    "      if (l !== 'utf-8' && l !== 'utf8' && l !== 'unicode-1-1-utf-8') {\n"
+    "        throw new RangeError(\"the scriptc island's TextDecoder supports utf-8 only (got '\" + l + \"')\");\n"
+    "      }\n"
+    "      this._fatal = !!(options && options.fatal);\n"
+    "      this._ignoreBOM = !!(options && options.ignoreBOM);\n"
+    "      this._cp = 0; this._needed = 0; this._seen = 0; this._lo = 0x80; this._hi = 0xbf;\n"
+    "      this._bomPending = !this._ignoreBOM;\n"
+    "    }\n"
+    "    get encoding() { return 'utf-8'; }\n"
+    "    get fatal() { return this._fatal; }\n"
+    "    get ignoreBOM() { return this._ignoreBOM; }\n"
+    "    _reset() {\n"
+    "      this._cp = 0; this._needed = 0; this._seen = 0; this._lo = 0x80; this._hi = 0xbf;\n"
+    "      this._bomPending = !this._ignoreBOM;\n"
+    "    }\n"
+    "    decode(input, options) {\n"
+    "      const stream = !!(options && options.stream);\n"
+    "      let bytes;\n"
+    "      if (input === undefined) bytes = new Uint8Array(0);\n"
+    "      else if (input instanceof Uint8Array) bytes = input;\n"
+    "      else if (input instanceof ArrayBuffer) bytes = new Uint8Array(input);\n"
+    "      else if (ArrayBuffer.isView(input)) bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);\n"
+    "      else throw new TypeError('TextDecoder.decode takes an ArrayBuffer or ArrayBufferView');\n"
+    "      const units = [];\n"
+    "      const fail = () => {\n"
+    "        if (this._fatal) { this._reset(); throw new TypeError('The encoded data was not valid utf-8'); }\n"
+    "        units.push(0xfffd);\n"
+    "      };\n"
+    "      const emit = (cp) => {\n"
+    "        if (cp <= 0xffff) units.push(cp);\n"
+    "        else { cp -= 0x10000; units.push(0xd800 + (cp >> 10), 0xdc00 + (cp & 0x3ff)); }\n"
+    "      };\n"
+    "      for (let i = 0; i < bytes.length; i++) {\n"
+    "        const b = bytes[i];\n"
+    "        if (this._needed === 0) {\n"
+    "          if (b <= 0x7f) { emit(b); continue; }\n"
+    "          if (b >= 0xc2 && b <= 0xdf) { this._needed = 1; this._cp = b & 0x1f; }\n"
+    "          else if (b >= 0xe0 && b <= 0xef) {\n"
+    "            if (b === 0xe0) this._lo = 0xa0;\n"
+    "            if (b === 0xed) this._hi = 0x9f;\n"
+    "            this._needed = 2; this._cp = b & 0xf;\n"
+    "          } else if (b >= 0xf0 && b <= 0xf4) {\n"
+    "            if (b === 0xf0) this._lo = 0x90;\n"
+    "            if (b === 0xf4) this._hi = 0x8f;\n"
+    "            this._needed = 3; this._cp = b & 0x7;\n"
+    "          } else fail();\n"
+    "          continue;\n"
+    "        }\n"
+    "        if (b < this._lo || b > this._hi) {\n"
+    "          this._cp = 0; this._needed = 0; this._seen = 0; this._lo = 0x80; this._hi = 0xbf;\n"
+    "          fail();\n"
+    "          i--; // reprocess as a sequence start\n"
+    "          continue;\n"
+    "        }\n"
+    "        this._lo = 0x80; this._hi = 0xbf;\n"
+    "        this._cp = (this._cp << 6) | (b & 0x3f);\n"
+    "        if (++this._seen === this._needed) {\n"
+    "          emit(this._cp);\n"
+    "          this._cp = 0; this._needed = 0; this._seen = 0;\n"
+    "        }\n"
+    "      }\n"
+    "      if (!stream && this._needed !== 0) {\n"
+    "        this._cp = 0; this._needed = 0; this._seen = 0; this._lo = 0x80; this._hi = 0xbf;\n"
+    "        fail();\n"
+    "      }\n"
+    "      let start = 0;\n"
+    "      if (this._bomPending && units.length > 0) {\n"
+    "        this._bomPending = false;\n"
+    "        if (units[0] === 0xfeff) start = 1;\n"
+    "      }\n"
+    "      let s = '';\n"
+    "      for (let i = start; i < units.length; i += 4096) {\n"
+    "        s += String.fromCharCode.apply(null, units.slice(i, i + 4096));\n"
+    "      }\n"
+    "      if (!stream) { const keepIgnore = this._ignoreBOM; this._reset(); this._bomPending = !keepIgnore; }\n"
+    "      return s;\n"
+    "    }\n"
+    "  }\n"
+    "\n"
+    "  class TextDecoderStream extends g.TransformStream {\n"
+    "    constructor(label, options) {\n"
+    "      const dec = new TextDecoder(label, options);\n"
+    "      super({\n"
+    "        transform(chunk, c) {\n"
+    "          const s = dec.decode(chunk, { stream: true });\n"
+    "          if (s !== '') c.enqueue(s);\n"
+    "        },\n"
+    "        flush(c) {\n"
+    "          const s = dec.decode();\n"
+    "          if (s !== '') c.enqueue(s);\n"
+    "        },\n"
+    "      });\n"
+    "      this._dec = dec;\n"
+    "    }\n"
+    "    get encoding() { return this._dec.encoding; }\n"
+    "    get fatal() { return this._dec.fatal; }\n"
+    "    get ignoreBOM() { return this._dec.ignoreBOM; }\n"
+    "  }\n"
+    "\n"
+    "  /* application/x-www-form-urlencoded serializer/parser (URLSearchParams). */\n"
+    "  const FORM_SAFE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789*-._';\n"
+    "  const formEncode = (s) => {\n"
+    "    const bytes = new TextEncoder().encode(s);\n"
+    "    let out = '';\n"
+    "    for (let i = 0; i < bytes.length; i++) {\n"
+    "      const b = bytes[i];\n"
+    "      const ch = String.fromCharCode(b);\n"
+    "      if (b === 0x20) out += '+';\n"
+    "      else if (FORM_SAFE.indexOf(ch) >= 0) out += ch;\n"
+    "      else out += '%' + (b < 16 ? '0' : '') + b.toString(16).toUpperCase();\n"
+    "    }\n"
+    "    return out;\n"
+    "  };\n"
+    "  const formDecode = (s) => {\n"
+    "    const bytes = [];\n"
+    "    for (let i = 0; i < s.length; i++) {\n"
+    "      const ch = s[i];\n"
+    "      if (ch === '+') bytes.push(0x20);\n"
+    "      else if (ch === '%' && i + 2 < s.length && /^[0-9a-fA-F]{2}$/.test(s.slice(i + 1, i + 3))) {\n"
+    "        bytes.push(parseInt(s.slice(i + 1, i + 3), 16));\n"
+    "        i += 2;\n"
+    "      } else {\n"
+    "        const enc = new TextEncoder().encode(ch);\n"
+    "        for (let j = 0; j < enc.length; j++) bytes.push(enc[j]);\n"
+    "      }\n"
+    "    }\n"
+    "    return new TextDecoder().decode(new Uint8Array(bytes));\n"
+    "  };\n"
+    "\n"
+    "  class URLSearchParams {\n"
+    "    constructor(init) {\n"
+    "      this._pairs = [];\n"
+    "      if (init === undefined || init === null) return;\n"
+    "      if (init instanceof URLSearchParams) {\n"
+    "        for (const [k, v] of init._pairs) this._pairs.push([k, v]);\n"
+    "        return;\n"
+    "      }\n"
+    "      if (typeof init === 'string') {\n"
+    "        let s = init;\n"
+    "        if (s.startsWith('?')) s = s.slice(1);\n"
+    "        if (s === '') return;\n"
+    "        for (const part of s.split('&')) {\n"
+    "          if (part === '') continue;\n"
+    "          const eq = part.indexOf('=');\n"
+    "          if (eq < 0) this._pairs.push([formDecode(part), '']);\n"
+    "          else this._pairs.push([formDecode(part.slice(0, eq)), formDecode(part.slice(eq + 1))]);\n"
+    "        }\n"
+    "        return;\n"
+    "      }\n"
+    "      if (typeof init === 'object') {\n"
+    "        if (typeof init[Symbol.iterator] === 'function') {\n"
+    "          for (const pair of init) {\n"
+    "            const p = [...pair];\n"
+    "            if (p.length !== 2) throw new TypeError('URLSearchParams sequence init entries must be [name, value] pairs');\n"
+    "            this._pairs.push([String(p[0]), String(p[1])]);\n"
+    "          }\n"
+    "        } else {\n"
+    "          for (const k of Object.keys(init)) this._pairs.push([String(k), String(init[k])]);\n"
+    "        }\n"
+    "        return;\n"
+    "      }\n"
+    "      throw new TypeError('unsupported URLSearchParams init');\n"
+    "    }\n"
+    "    get size() { return this._pairs.length; }\n"
+    "    append(name, value) { this._pairs.push([String(name), String(value)]); }\n"
+    "    delete(name, value) {\n"
+    "      name = String(name);\n"
+    "      const hasValue = value !== undefined;\n"
+    "      if (hasValue) value = String(value);\n"
+    "      this._pairs = this._pairs.filter(([k, v]) => k !== name || (hasValue && v !== value));\n"
+    "    }\n"
+    "    get(name) {\n"
+    "      name = String(name);\n"
+    "      for (const [k, v] of this._pairs) if (k === name) return v;\n"
+    "      return null;\n"
+    "    }\n"
+    "    getAll(name) {\n"
+    "      name = String(name);\n"
+    "      const out = [];\n"
+    "      for (const [k, v] of this._pairs) if (k === name) out.push(v);\n"
+    "      return out;\n"
+    "    }\n"
+    "    has(name, value) {\n"
+    "      name = String(name);\n"
+    "      const hasValue = value !== undefined;\n"
+    "      if (hasValue) value = String(value);\n"
+    "      for (const [k, v] of this._pairs) if (k === name && (!hasValue || v === value)) return true;\n"
+    "      return false;\n"
+    "    }\n"
+    "    set(name, value) {\n"
+    "      name = String(name);\n"
+    "      value = String(value);\n"
+    "      let found = false;\n"
+    "      const next = [];\n"
+    "      for (const pair of this._pairs) {\n"
+    "        if (pair[0] !== name) { next.push(pair); continue; }\n"
+    "        if (!found) { next.push([name, value]); found = true; }\n"
+    "      }\n"
+    "      if (!found) next.push([name, value]);\n"
+    "      this._pairs = next;\n"
+    "    }\n"
+    "    sort() {\n"
+    "      // stable sort by name (code units), preserving value order per name\n"
+    "      this._pairs = this._pairs\n"
+    "        .map((p, i) => [p, i])\n"
+    "        .sort((a, b) => (a[0][0] < b[0][0] ? -1 : a[0][0] > b[0][0] ? 1 : a[1] - b[1]))\n"
+    "        .map((x) => x[0]);\n"
+    "    }\n"
+    "    toString() {\n"
+    "      return this._pairs.map(([k, v]) => formEncode(k) + '=' + formEncode(v)).join('&');\n"
+    "    }\n"
+    "    forEach(fn, thisArg) {\n"
+    "      for (const [k, v] of this._pairs.slice()) fn.call(thisArg, v, k, this);\n"
+    "    }\n"
+    "    *entries() { for (const [k, v] of this._pairs) yield [k, v]; }\n"
+    "    *keys() { for (const [k] of this._pairs) yield k; }\n"
+    "    *values() { for (const [, v] of this._pairs) yield v; }\n"
+    "    [Symbol.iterator]() { return this.entries(); }\n"
+    "  }\n"
+    "\n"
+    "  const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n"
+    "  const invalidChar = (op) => {\n"
+    "    const e = new Error(\"Invalid character\");\n"
+    "    e.name = 'InvalidCharacterError';\n"
+    "    return e;\n"
+    "  };\n"
+    "  const btoa = (data) => {\n"
+    "    const s = String(data);\n"
+    "    let out = '';\n"
+    "    for (let i = 0; i < s.length; i += 3) {\n"
+    "      const c0 = s.charCodeAt(i), c1 = i + 1 < s.length ? s.charCodeAt(i + 1) : NaN, c2 = i + 2 < s.length ? s.charCodeAt(i + 2) : NaN;\n"
+    "      if (c0 > 0xff || c1 > 0xff || c2 > 0xff) throw invalidChar('btoa');\n"
+    "      const n = (c0 << 16) | ((c1 || 0) << 8) | (c2 || 0);\n"
+    "      out += B64[(n >> 18) & 63] + B64[(n >> 12) & 63] +\n"
+    "        (Number.isNaN(c1) ? '=' : B64[(n >> 6) & 63]) +\n"
+    "        (Number.isNaN(c2) ? '=' : B64[n & 63]);\n"
+    "    }\n"
+    "    return out;\n"
+    "  };\n"
+    "  const atob = (data) => {\n"
+    "    // forgiving-base64: strip ASCII whitespace, then up to two trailing '='\n"
+    "    let s = String(data).replace(/[\\t\\n\\f\\r ]+/g, '');\n"
+    "    if (s.length % 4 === 0) s = s.replace(/={1,2}$/, '');\n"
+    "    if (s.length % 4 === 1) throw invalidChar('atob');\n"
+    "    let out = '';\n"
+    "    let buf = 0, bits = 0;\n"
+    "    for (let i = 0; i < s.length; i++) {\n"
+    "      const v = B64.indexOf(s[i]);\n"
+    "      if (v < 0) throw invalidChar('atob');\n"
+    "      buf = (buf << 6) | v;\n"
+    "      bits += 6;\n"
+    "      if (bits >= 8) {\n"
+    "        bits -= 8;\n"
+    "        out += String.fromCharCode((buf >> bits) & 0xff);\n"
+    "      }\n"
+    "    }\n"
+    "    return out;\n"
+    "  };\n"
+    "\n"
+    "  /* Headers: lowercase names, combine-on-append, sorted iteration. */\n"
+    "  const HDR_TOKEN = /^[!#$%&'*+\\-.^_`|~0-9A-Za-z]+$/;\n"
+    "  const normValue = (v) => String(v).replace(/^[\\t\\n\\r ]+|[\\t\\n\\r ]+$/g, '');\n"
+    "  class Headers {\n"
+    "    constructor(init) {\n"
+    "      this._map = new Map(); // lowercased name -> [values]\n"
+    "      if (init === undefined || init === null) return;\n"
+    "      if (init instanceof Headers) {\n"
+    "        for (const [k, vs] of init._map) this._map.set(k, vs.slice());\n"
+    "        return;\n"
+    "      }\n"
+    "      if (typeof init === 'object' && typeof init[Symbol.iterator] === 'function') {\n"
+    "        for (const pair of init) {\n"
+    "          const p = [...pair];\n"
+    "          if (p.length !== 2) throw new TypeError('Headers sequence init entries must be [name, value] pairs');\n"
+    "          this.append(p[0], p[1]);\n"
+    "        }\n"
+    "        return;\n"
+    "      }\n"
+    "      if (typeof init === 'object') {\n"
+    "        for (const k of Object.keys(init)) this.append(k, init[k]);\n"
+    "        return;\n"
+    "      }\n"
+    "      throw new TypeError('unsupported Headers init');\n"
+    "    }\n"
+    "    _check(name) {\n"
+    "      const n = String(name).toLowerCase();\n"
+    "      if (!HDR_TOKEN.test(n)) throw new TypeError(`Invalid header name: \"${name}\"`);\n"
+    "      return n;\n"
+    "    }\n"
+    "    append(name, value) {\n"
+    "      const n = this._check(name);\n"
+    "      const list = this._map.get(n);\n"
+    "      if (list) list.push(normValue(value));\n"
+    "      else this._map.set(n, [normValue(value)]);\n"
+    "    }\n"
+    "    set(name, value) { this._map.set(this._check(name), [normValue(value)]); }\n"
+    "    get(name) {\n"
+    "      const list = this._map.get(this._check(name));\n"
+    "      return list ? list.join(', ') : null;\n"
+    "    }\n"
+    "    has(name) { return this._map.has(this._check(name)); }\n"
+    "    delete(name) { this._map.delete(this._check(name)); }\n"
+    "    getSetCookie() {\n"
+    "      const list = this._map.get('set-cookie');\n"
+    "      return list ? list.slice() : [];\n"
+    "    }\n"
+    "    _sorted() {\n"
+    "      return [...this._map.keys()].sort().map((k) => [k, this._map.get(k).join(', ')]);\n"
+    "    }\n"
+    "    forEach(fn, thisArg) {\n"
+    "      for (const [k, v] of this._sorted()) fn.call(thisArg, v, k, this);\n"
+    "    }\n"
+    "    *entries() { for (const p of this._sorted()) yield p; }\n"
+    "    *keys() { for (const [k] of this._sorted()) yield k; }\n"
+    "    *values() { for (const [, v] of this._sorted()) yield v; }\n"
+    "    [Symbol.iterator]() { return this.entries(); }\n"
+    "  }\n"
+    "\n"
+    /* Event + EventTarget + CustomEvent — the DOM event plumbing Node
+     * exposes as globals since v15. Synchronous dispatch on one target
+     * (no tree, no phases — composedPath answers []), once/capture-shaped
+     * options accepted, handleEvent objects honored, dispatchEvent
+     * answers !defaultPrevented. undici's fileapi/websocket classes
+     * extend Event at LOAD. */
+    "  class Event {\n"
+    "    constructor(type, init) {\n"
+    "      if (arguments.length === 0) throw new TypeError(\"Failed to construct 'Event': 1 argument required, but only 0 present.\");\n"
+    "      this._type = String(type);\n"
+    "      this.bubbles = !!(init && init.bubbles);\n"
+    "      this.cancelable = !!(init && init.cancelable);\n"
+    "      this.composed = !!(init && init.composed);\n"
+    "      this.defaultPrevented = false;\n"
+    "      this.target = null;\n"
+    "      this.currentTarget = null;\n"
+    "      this.srcElement = null;\n"
+    "      this.eventPhase = 0;\n"
+    "      this.isTrusted = false;\n"
+    "      this.returnValue = true;\n"
+    "      this.timeStamp = Date.now();\n"
+    "      this._stopImmediate = false;\n"
+    "    }\n"
+    "    get type() { return this._type; }\n"
+    "    preventDefault() { if (this.cancelable) { this.defaultPrevented = true; this.returnValue = false; } }\n"
+    "    stopPropagation() {}\n"
+    "    stopImmediatePropagation() { this._stopImmediate = true; }\n"
+    "    composedPath() { return []; }\n"
+    "  }\n"
+    "  Event.NONE = 0; Event.CAPTURING_PHASE = 1; Event.AT_TARGET = 2; Event.BUBBLING_PHASE = 3;\n"
+    "  class CustomEvent extends Event {\n"
+    "    constructor(type, init) {\n"
+    "      super(type, init);\n"
+    "      this.detail = init !== null && init !== undefined && init.detail !== undefined ? init.detail : null;\n"
+    "    }\n"
+    "  }\n"
+    "  class EventTarget {\n"
+    "    constructor() { this._et = Object.create(null); }\n"
+    "    addEventListener(type, listener, options) {\n"
+    "      if (listener === null || listener === undefined) return;\n"
+    "      const t = String(type);\n"
+    "      const once = !!(options !== null && typeof options === 'object' && options.once);\n"
+    "      const list = this._et[t] || (this._et[t] = []);\n"
+    "      for (const e of list) { if (e.listener === listener) return; }\n"
+    "      list.push({ listener, once });\n"
+    "    }\n"
+    "    removeEventListener(type, listener) {\n"
+    "      const list = this._et[String(type)];\n"
+    "      if (!list) return;\n"
+    "      const i = list.findIndex((e) => e.listener === listener);\n"
+    "      if (i >= 0) list.splice(i, 1);\n"
+    "    }\n"
+    "    dispatchEvent(event) {\n"
+    "      if (!(event instanceof Event)) throw new TypeError('The \"event\" argument must be an instance of Event.');\n"
+    "      event.target = this;\n"
+    "      event.currentTarget = this;\n"
+    "      event.eventPhase = Event.AT_TARGET;\n"
+    "      const list = this._et[event.type];\n"
+    "      if (list) {\n"
+    "        for (const e of [...list]) {\n"
+    "          if (event._stopImmediate) break;\n"
+    "          if (e.once) this.removeEventListener(event.type, e.listener);\n"
+    "          if (typeof e.listener === 'function') e.listener.call(this, event);\n"
+    "          else if (e.listener !== null && typeof e.listener.handleEvent === 'function') e.listener.handleEvent(event);\n"
+    "        }\n"
+    "      }\n"
+    "      event.eventPhase = Event.NONE;\n"
+    "      event.currentTarget = null;\n"
+    "      return !event.defaultPrevented;\n"
+    "    }\n"
+    "  }\n"
+    "\n"
+    /* Blob + File — the WHATWG classes Node exposes as globals (and
+     * re-exports from node:buffer) since v18. Bytes concatenate at
+     * construction (strings through TextEncoder, views copied, nested
+     * Blobs flattened); type normalizes per spec (printable-ASCII-only,
+     * lowercased, else ""); slice carries WHATWG's negative-index
+     * clamping; stream() rides the prelude's own ReadableStream. undici
+     * (in embedded graphs) extends buffer.Blob at load. */
+    "  const blobBytesOf = (parts) => {\n"
+    "    const chunks = [];\n"
+    "    let total = 0;\n"
+    "    for (const p of parts) {\n"
+    "      let u8;\n"
+    "      if (typeof p === 'string') u8 = new TextEncoder().encode(p);\n"
+    "      else if (p instanceof Blob) u8 = p._bytes;\n"
+    "      else if (p instanceof ArrayBuffer) u8 = new Uint8Array(p.slice(0));\n"
+    "      else if (ArrayBuffer.isView(p)) u8 = new Uint8Array(p.buffer.slice(p.byteOffset, p.byteOffset + p.byteLength));\n"
+    "      else u8 = new TextEncoder().encode(String(p));\n"
+    "      chunks.push(u8);\n"
+    "      total += u8.length;\n"
+    "    }\n"
+    "    const out = new Uint8Array(total);\n"
+    "    let off = 0;\n"
+    "    for (const c of chunks) { out.set(c, off); off += c.length; }\n"
+    "    return out;\n"
+    "  };\n"
+    "  const blobTypeOf = (t) => {\n"
+    "    const s = String(t);\n"
+    "    for (let i = 0; i < s.length; i++) {\n"
+    "      const c = s.charCodeAt(i);\n"
+    "      if (c < 0x20 || c > 0x7e) return '';\n"
+    "    }\n"
+    "    return s.toLowerCase();\n"
+    "  };\n"
+    "  class Blob {\n"
+    "    constructor(parts = [], options = {}) {\n"
+    "      if (typeof parts !== 'object' || parts === null || typeof parts[Symbol.iterator] !== 'function') {\n"
+    "        throw new TypeError('The \"sources\" argument must be an instance of Iterable. Received ' + (parts === null ? 'null' : typeof parts));\n"
+    "      }\n"
+    "      this._bytes = blobBytesOf([...parts]);\n"
+    "      this._type = options !== null && options !== undefined && options.type !== undefined ? blobTypeOf(options.type) : '';\n"
+    "    }\n"
+    "    get size() { return this._bytes.length; }\n"
+    "    get type() { return this._type; }\n"
+    "    async arrayBuffer() {\n"
+    "      return this._bytes.buffer.slice(this._bytes.byteOffset, this._bytes.byteOffset + this._bytes.byteLength);\n"
+    "    }\n"
+    "    async bytes() { return new Uint8Array(this._bytes); }\n"
+    "    async text() { return new TextDecoder().decode(this._bytes); }\n"
+    "    slice(start, end, contentType) {\n"
+    "      const size = this._bytes.length;\n"
+    "      let s = start === undefined ? 0 : Math.trunc(Number(start) || 0);\n"
+    "      s = s < 0 ? Math.max(size + s, 0) : Math.min(s, size);\n"
+    "      let e = end === undefined ? size : Math.trunc(Number(end) || 0);\n"
+    "      e = e < 0 ? Math.max(size + e, 0) : Math.min(e, size);\n"
+    "      const b = new Blob([], contentType === undefined ? {} : { type: contentType });\n"
+    "      b._bytes = this._bytes.slice(s, Math.max(e, s));\n"
+    "      return b;\n"
+    "    }\n"
+    "    stream() {\n"
+    "      const bytes = this._bytes;\n"
+    "      return new ReadableStream({\n"
+    "        start(c) {\n"
+    "          if (bytes.length > 0) c.enqueue(new Uint8Array(bytes));\n"
+    "          c.close();\n"
+    "        },\n"
+    "      });\n"
+    "    }\n"
+    "    get [Symbol.toStringTag]() { return 'Blob'; }\n"
+    "  }\n"
+    "  class File extends Blob {\n"
+    "    constructor(fileBits, fileName, options = {}) {\n"
+    "      if (arguments.length < 2) throw new TypeError('The \"fileName\" argument must be specified');\n"
+    "      super(fileBits, options);\n"
+    "      this._name = String(fileName);\n"
+    "      this._lastModified = options !== null && options !== undefined && options.lastModified !== undefined ? Number(options.lastModified) : Date.now();\n"
+    "    }\n"
+    "    get name() { return this._name; }\n"
+    "    get lastModified() { return this._lastModified; }\n"
+    "    get webkitRelativePath() { return ''; }\n"
+    "    get [Symbol.toStringTag]() { return 'File'; }\n"
+    "  }\n"
+    "\n"
+    "  g.TextEncoder = TextEncoder;\n"
+    "  g.TextDecoder = TextDecoder;\n"
+    "  g.TextDecoderStream = TextDecoderStream;\n"
+    "  g.URLSearchParams = URLSearchParams;\n"
+    "  g.btoa = btoa;\n"
+    "  g.atob = atob;\n"
+    "  g.Headers = Headers;\n"
+    "  g.Blob = Blob;\n"
+    "  g.File = File;\n"
+    "  g.Event = Event;\n"
+    "  g.CustomEvent = CustomEvent;\n"
+    "  g.EventTarget = EventTarget;\n"
+    "\n"
+    "  /* DOMException + AbortController/AbortSignal: pure JS state, with the\n"
+    "   * ONE host hook AbortSignal.timeout needs (host.timer arms a one-shot\n"
+    "   * island timer — unref'd like Node's, so an armed timeout never keeps\n"
+    "   * the process alive). Default abort reasons match Node exactly:\n"
+    "   * DOMException AbortError 'This operation was aborted' and\n"
+    "   * TimeoutError 'The operation was aborted due to timeout'. */\n"
+    "  const DOM_CODES = {\n"
+    "    IndexSizeError: 1, HierarchyRequestError: 3, WrongDocumentError: 4,\n"
+    "    InvalidCharacterError: 5, NoModificationAllowedError: 7, NotFoundError: 8,\n"
+    "    NotSupportedError: 9, InUseAttributeError: 10, InvalidStateError: 11,\n"
+    "    SyntaxError: 12, InvalidModificationError: 13, NamespaceError: 14,\n"
+    "    InvalidAccessError: 15, TypeMismatchError: 17, SecurityError: 18,\n"
+    "    NetworkError: 19, AbortError: 20, URLMismatchError: 21,\n"
+    "    QuotaExceededError: 22, TimeoutError: 23, InvalidNodeTypeError: 24,\n"
+    "    DataCloneError: 25,\n"
+    "  };\n"
+    "  class DOMException extends Error {\n"
+    "    constructor(message, name) {\n"
+    "      super(message === undefined ? '' : String(message));\n"
+    "      this.name = name === undefined ? 'Error' : String(name);\n"
+    "    }\n"
+    "    get code() { return DOM_CODES[this.name] || 0; }\n"
+    "  }\n"
+    "\n"
+    "  const mkAbortError = () => new DOMException('This operation was aborted', 'AbortError');\n"
+    "  const mkSignal = () => {\n"
+    "    const s = Object.create(AbortSignal.prototype);\n"
+    "    s._aborted = false;\n"
+    "    s._reason = undefined;\n"
+    "    s._onabort = null;\n"
+    "    s._listeners = [];\n"
+    "    return s;\n"
+    "  };\n"
+    "  /* Fires listeners in registration order (onabort first), each once-\n"
+    "   * unregistered BEFORE its call like EventTarget; a throwing listener\n"
+    "   * doesn't stop the others — the first error rethrows at the end. */\n"
+    "  const signalAbort = (s, reason) => {\n"
+    "    if (s._aborted) return;\n"
+    "    s._aborted = true;\n"
+    "    s._reason = reason === undefined ? mkAbortError() : reason;\n"
+    "    const ev = { type: 'abort', target: s, currentTarget: s };\n"
+    "    let firstErr;\n"
+    "    let threw = false;\n"
+    "    if (s._onabort !== null) {\n"
+    "      try { s._onabort.call(s, ev); } catch (e) { firstErr = e; threw = true; }\n"
+    "    }\n"
+    "    for (const l of s._listeners.slice()) {\n"
+    "      if (l.once) s.removeEventListener('abort', l.fn);\n"
+    "      try { l.fn.call(s, ev); } catch (e) { if (!threw) { firstErr = e; threw = true; } }\n"
+    "    }\n"
+    "    if (threw) throw firstErr;\n"
+    "  };\n"
+    "\n"
+    "  class AbortSignal {\n"
+    "    constructor() { throw new TypeError('Illegal constructor'); }\n"
+    "    get aborted() { return this._aborted; }\n"
+    "    get reason() { return this._reason; }\n"
+    "    get onabort() { return this._onabort; }\n"
+    "    set onabort(fn) { this._onabort = typeof fn === 'function' ? fn : null; }\n"
+    "    throwIfAborted() { if (this._aborted) throw this._reason; }\n"
+    "    addEventListener(type, fn, options) {\n"
+    "      if (String(type) !== 'abort' || typeof fn !== 'function') return;\n"
+    "      const once = options !== undefined && options !== null && !!options.once;\n"
+    "      this._listeners.push({ fn, once });\n"
+    "    }\n"
+    "    removeEventListener(type, fn) {\n"
+    "      if (String(type) !== 'abort') return;\n"
+    "      const i = this._listeners.findIndex((l) => l.fn === fn);\n"
+    "      if (i >= 0) this._listeners.splice(i, 1);\n"
+    "    }\n"
+    "    static abort(reason) {\n"
+    "      const s = mkSignal();\n"
+    "      s._aborted = true;\n"
+    "      s._reason = reason === undefined ? mkAbortError() : reason;\n"
+    "      return s;\n"
+    "    }\n"
+    "    static timeout(ms) {\n"
+    "      const s = mkSignal();\n"
+    "      host.timer(() => {\n"
+    "        signalAbort(s, new DOMException('The operation was aborted due to timeout', 'TimeoutError'));\n"
+    "      }, Number(ms));\n"
+    "      return s;\n"
+    "    }\n"
+    "    static any(signals) {\n"
+    "      const list = [...signals];\n"
+    "      const s = mkSignal();\n"
+    "      for (const src of list) {\n"
+    "        if (!(src instanceof AbortSignal)) throw new TypeError('AbortSignal.any takes AbortSignals');\n"
+    "        if (src._aborted) {\n"
+    "          s._aborted = true;\n"
+    "          s._reason = src._reason;\n"
+    "          return s;\n"
+    "        }\n"
+    "      }\n"
+    "      const handlers = [];\n"
+    "      for (const src of list) {\n"
+    "        const h = () => {\n"
+    "          for (const [sig, fn] of handlers) sig.removeEventListener('abort', fn);\n"
+    "          signalAbort(s, src._reason);\n"
+    "        };\n"
+    "        handlers.push([src, h]);\n"
+    "        src.addEventListener('abort', h);\n"
+    "      }\n"
+    "      return s;\n"
+    "    }\n"
+    "  }\n"
+    "\n"
+    "  class AbortController {\n"
+    "    constructor() { this._signal = mkSignal(); }\n"
+    "    get signal() { return this._signal; }\n"
+    "    abort(reason) { signalAbort(this._signal, reason); }\n"
+    "  }\n"
+    "\n"
+    "  g.DOMException = DOMException;\n"
+    "  g.AbortSignal = AbortSignal;\n"
+    "  g.AbortController = AbortController;\n"
+    "\n"
+    "  /* structuredClone — the HTML StructuredSerialize subset the island\n"
+    "   * honestly carries: primitives (bigint included), plain objects and\n"
+    "   * arrays (cycles preserved through a memo, like Node), Map/Set/Date/\n"
+    "   * RegExp/ArrayBuffer/typed arrays, Blob/File (shared immutable\n"
+    "   * bytes), and DOMException (name/message per WebIDL serialization).\n"
+    "   * Class instances flatten to plain own-enumerable copies (the\n"
+    "   * spec's default record path). Functions and symbols throw the\n"
+    "   * spec's DataCloneError; transfer LISTS with members throw\n"
+    "   * DataCloneError too (nothing here is transferable — divergence:\n"
+    "   * Node transfers its streams). Option validation is Node's, byte\n"
+    "   * for byte. */\n"
+    "  const scErr = (m) => { const e = new TypeError(m); e.code = 'ERR_INVALID_ARG_TYPE'; return e; };\n"
+    "  const scClone = (v, memo) => {\n"
+    "    switch (typeof v) {\n"
+    "    case 'undefined': case 'boolean': case 'number': case 'string': case 'bigint':\n"
+    "      return v;\n"
+    "    case 'symbol':\n"
+    "      throw new DOMException('symbol could not be cloned.', 'DataCloneError');\n"
+    "    case 'function':\n"
+    "      throw new DOMException(String(v) + ' could not be cloned.', 'DataCloneError');\n"
+    "    }\n"
+    "    if (v === null) return null;\n"
+    "    const seen = memo.get(v);\n"
+    "    if (seen !== undefined) return seen;\n"
+    "    if (v instanceof Date) return new Date(v.getTime());\n"
+    "    if (v instanceof RegExp) return new RegExp(v.source, v.flags);\n"
+    "    if (v instanceof DOMException) return new DOMException(v.message, v.name);\n"
+    "    if (v instanceof ArrayBuffer) return v.slice(0);\n"
+    "    if (ArrayBuffer.isView(v)) return new v.constructor(v.buffer.slice(0), v.byteOffset, v.length);\n"
+    "    if (typeof g.Blob === 'function' && v instanceof g.Blob) return v;\n"
+    "    if (v instanceof Map) {\n"
+    "      const m = new Map();\n"
+    "      memo.set(v, m);\n"
+    "      for (const [k, val] of v) m.set(scClone(k, memo), scClone(val, memo));\n"
+    "      return m;\n"
+    "    }\n"
+    "    if (v instanceof Set) {\n"
+    "      const s = new Set();\n"
+    "      memo.set(v, s);\n"
+    "      for (const val of v) s.add(scClone(val, memo));\n"
+    "      return s;\n"
+    "    }\n"
+    "    if (Array.isArray(v)) {\n"
+    "      const a = new Array(v.length);\n"
+    "      memo.set(v, a);\n"
+    "      for (let i = 0; i < v.length; i++) if (i in v) a[i] = scClone(v[i], memo);\n"
+    "      return a;\n"
+    "    }\n"
+    "    /* Errors serialize name/message (the spec's error record). */\n"
+    "    if (v instanceof Error) {\n"
+    "      const e = new Error(v.message);\n"
+    "      e.name = v.name;\n"
+    "      memo.set(v, e);\n"
+    "      return e;\n"
+    "    }\n"
+    "    /* The default record path: own enumerable properties onto a plain\n"
+    "     * object (class prototypes flatten, like the spec). */\n"
+    "    const o = {};\n"
+    "    memo.set(v, o);\n"
+    "    for (const k of Object.keys(v)) o[k] = scClone(v[k], memo);\n"
+    "    return o;\n"
+    "  };\n"
+    "  g.structuredClone = function structuredClone(value, options) {\n"
+    "    if (arguments.length === 0) {\n"
+    "      const e = new TypeError('The \"The value argument must be specified\" argument must be specified');\n"
+    "      e.code = 'ERR_MISSING_ARGS';\n"
+    "      throw e;\n"
+    "    }\n"
+    "    if (options !== undefined && options !== null) {\n"
+    "      if (typeof options !== 'object' && typeof options !== 'function') {\n"
+    "        throw scErr(\"Failed to execute 'structuredClone': Options cannot be converted to a dictionary\");\n"
+    "      }\n"
+    "      const tr = options.transfer;\n"
+    "      if (tr !== undefined) {\n"
+    "        let list;\n"
+    "        /* WebIDL sequence conversion rejects strings (iterable or\n"
+    "         * not) — Node's transfer:'' error is the member error. */\n"
+    "        try {\n"
+    "          if (typeof tr === 'string') throw 0;\n"
+    "          list = [...tr];\n"
+    "        } catch (e) {\n"
+    "          throw scErr(\"Failed to execute 'structuredClone': transfer in Options can not be converted to sequence.\");\n"
+    "        }\n"
+    "        if (list.length > 0) {\n"
+    "          throw new DOMException('Found invalid value in transferList.', 'DataCloneError');\n"
+    "        }\n"
+    "      }\n"
+    "    }\n"
+    "    return scClone(value, new WeakMap());\n"
+    "  };\n"
+    "\n"
+    "  /* MessageEvent + MessagePort/MessageChannel — Node globals (v15+),\n"
+    "   * the same-thread subset: postMessage queues a structuredClone COPY\n"
+    "   * on the peer; the queue drains as 'message' events on a microtask\n"
+    "   * once start() runs (adding a 'message' listener via on() starts,\n"
+    "   * like Node), and worker_threads' receiveMessageOnPort drains the\n"
+    "   * queue directly (its consumers — undici's structuredClone\n"
+    "   * fallback — never start()). on/once/off are the NodeEventTarget\n"
+    "   * compat surface: 'message' handlers receive the DATA, like Node. */\n"
+    "  class MessageEvent extends Event {\n"
+    "    constructor(type, init) {\n"
+    "      super(type, init);\n"
+    "      const d = init || {};\n"
+    "      this._data = d.data !== undefined ? d.data : null;\n"
+    "      this._origin = d.origin || '';\n"
+    "      this._lastEventId = d.lastEventId || '';\n"
+    "      this._ports = d.ports ? [...d.ports] : [];\n"
+    "    }\n"
+    "    get data() { return this._data; }\n"
+    "    get origin() { return this._origin; }\n"
+    "    get lastEventId() { return this._lastEventId; }\n"
+    "    get ports() { return this._ports; }\n"
+    "  }\n"
+    "  class MessagePort extends EventTarget {\n"
+    "    constructor() {\n"
+    "      super();\n"
+    "      this._other = null;\n"
+    "      this._queue = [];\n"
+    "      this._started = false;\n"
+    "      this._nodeHandlers = new Map();\n"
+    "    }\n"
+    "    postMessage(value) {\n"
+    "      if (this._other === null) return;\n"
+    "      this._other._queue.push({ message: g.structuredClone(value) });\n"
+    "      this._other._drain();\n"
+    "    }\n"
+    "    _drain() {\n"
+    "      if (!this._started) return;\n"
+    "      queueMicrotask(() => {\n"
+    "        while (this._started && this._queue.length > 0) {\n"
+    "          const { message } = this._queue.shift();\n"
+    "          this.dispatchEvent(new MessageEvent('message', { data: message }));\n"
+    "        }\n"
+    "      });\n"
+    "    }\n"
+    "    start() { this._started = true; this._drain(); }\n"
+    "    close() { this._started = false; queueMicrotask(() => this.dispatchEvent(new Event('close'))); }\n"
+    "    ref() { return this; }\n"
+    "    unref() { return this; }\n"
+    "    on(name, fn) {\n"
+    "      const h = (ev) => fn(name === 'message' || name === 'messageerror' ? ev.data : ev);\n"
+    "      this._nodeHandlers.set(fn, h);\n"
+    "      this.addEventListener(name, h);\n"
+    "      if (name === 'message') this.start();\n"
+    "      return this;\n"
+    "    }\n"
+    "    once(name, fn) {\n"
+    "      const h = (ev) => fn(name === 'message' || name === 'messageerror' ? ev.data : ev);\n"
+    "      this._nodeHandlers.set(fn, h);\n"
+    "      this.addEventListener(name, h, { once: true });\n"
+    "      if (name === 'message') this.start();\n"
+    "      return this;\n"
+    "    }\n"
+    "    off(name, fn) {\n"
+    "      const h = this._nodeHandlers.get(fn);\n"
+    "      if (h) { this.removeEventListener(name, h); this._nodeHandlers.delete(fn); }\n"
+    "      return this;\n"
+    "    }\n"
+    "  }\n"
+    "  MessagePort.prototype.addListener = MessagePort.prototype.on;\n"
+    "  MessagePort.prototype.removeListener = MessagePort.prototype.off;\n"
+    "  class MessageChannel {\n"
+    "    constructor() {\n"
+    "      this.port1 = new MessagePort();\n"
+    "      this.port2 = new MessagePort();\n"
+    "      this.port1._other = this.port2;\n"
+    "      this.port2._other = this.port1;\n"
+    "    }\n"
+    "  }\n"
+    "  g.MessageEvent = MessageEvent;\n"
+    "  g.MessagePort = MessagePort;\n"
+    "  g.MessageChannel = MessageChannel;\n"
+    "\n"
+    "  const te = () => new g.TextEncoder();\n"
+    "\n"
+    "  const coerceBodyBytes = (body) => {\n"
+    "    // → [bytes|stream, implicit content-type or null]\n"
+    "    if (typeof body === 'string') return [te().encode(body), 'text/plain;charset=UTF-8'];\n"
+    "    if (body instanceof g.URLSearchParams) {\n"
+    "      return [te().encode(String(body)), 'application/x-www-form-urlencoded;charset=UTF-8'];\n"
+    "    }\n"
+    "    if (body instanceof Uint8Array) return [new Uint8Array(body), null];\n"
+    "    if (body instanceof ArrayBuffer) return [new Uint8Array(body.slice(0)), null];\n"
+    "    if (ArrayBuffer.isView(body)) {\n"
+    "      return [new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)), null];\n"
+    "    }\n"
+    "    if (body instanceof g.ReadableStream) return [body, null];\n"
+    "    throw new TypeError('unsupported body type in the scriptc island (string, Uint8Array, ArrayBuffer, URLSearchParams, or ReadableStream)');\n"
+    "  };\n"
+    "\n"
+    "  const consume = (self) => {\n"
+    "    if (self._bodyUsed) return Promise.reject(new TypeError('Body is unusable: Body has already been read'));\n"
+    "    self._bodyUsed = true;\n"
+    "    const body = self._body;\n"
+    "    if (body === null) return Promise.resolve(new Uint8Array(0));\n"
+    "    if (body instanceof Uint8Array) return Promise.resolve(body);\n"
+    "    // a ReadableStream of Uint8Array (or string) chunks\n"
+    "    const chunks = [];\n"
+    "    let total = 0;\n"
+    "    const reader = body.getReader();\n"
+    "    const step = () =>\n"
+    "      reader.read().then((r) => {\n"
+    "        if (r.done) {\n"
+    "          const out = new Uint8Array(total);\n"
+    "          let off = 0;\n"
+    "          for (const c of chunks) { out.set(c, off); off += c.length; }\n"
+    "          return out;\n"
+    "        }\n"
+    "        const c = typeof r.value === 'string' ? te().encode(r.value) : r.value;\n"
+    "        if (!(c instanceof Uint8Array)) throw new TypeError('body stream produced a non-byte chunk');\n"
+    "        chunks.push(c);\n"
+    "        total += c.length;\n"
+    "        return step();\n"
+    "      });\n"
+    "    return step();\n"
+    "  };\n"
+    "\n"
+    "  const bodyMixin = (cls) => {\n"
+    "    Object.defineProperties(cls.prototype, {\n"
+    "      body: {\n"
+    "        get() {\n"
+    "          if (this._body === null) return null;\n"
+    "          if (this._body instanceof Uint8Array) {\n"
+    "            // lazily wrap fixed bytes in a stream, once\n"
+    "            const bytes = this._body;\n"
+    "            const self = this;\n"
+    "            this._body = new g.ReadableStream({\n"
+    "              start(c) { c.enqueue(bytes); c.close(); },\n"
+    "              cancel() { self._bodyUsed = true; },\n"
+    "            });\n"
+    "          }\n"
+    "          return this._body;\n"
+    "        },\n"
+    "        configurable: true,\n"
+    "      },\n"
+    "      bodyUsed: { get() { return this._bodyUsed; }, configurable: true },\n"
+    "    });\n"
+    "    cls.prototype.arrayBuffer = function () {\n"
+    "      return consume(this).then((b) => b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength));\n"
+    "    };\n"
+    "    cls.prototype.bytes = function () { return consume(this); };\n"
+    "    cls.prototype.text = function () {\n"
+    "      return consume(this).then((b) => new g.TextDecoder().decode(b));\n"
+    "    };\n"
+    "    cls.prototype.json = function () { return this.text().then((t) => JSON.parse(t)); };\n"
+    "    cls.prototype.clone = function () {\n"
+    "      throw new Error(cls.name + '.clone is not supported in the scriptc island');\n"
+    "    };\n"
+    "  };\n"
+    "\n"
+    "  const normalizeMethod = (m) => {\n"
+    "    const s = String(m);\n"
+    "    const u = s.toUpperCase();\n"
+    "    if (u === 'DELETE' || u === 'GET' || u === 'HEAD' || u === 'OPTIONS' || u === 'POST' || u === 'PUT') return u;\n"
+    "    if (u === 'CONNECT' || u === 'TRACE' || u === 'TRACK') throw new TypeError(`'${s}' HTTP method is unsupported.`);\n"
+    "    return s;\n"
+    "  };\n"
+    "\n"
+    "  class Request {\n"
+    "    constructor(input, init) {\n"
+    "      init = init === undefined || init === null ? {} : init;\n"
+    "      if (input instanceof Request) {\n"
+    "        this._url = input._url;\n"
+    "        this._method = input._method;\n"
+    "        this._headers = new g.Headers(input._headers);\n"
+    "        this._body = input._body; // shared bytes; fetch copies\n"
+    "        this._signal = input._signal;\n"
+    "      } else {\n"
+    "        this._url = String(input);\n"
+    "        this._method = 'GET';\n"
+    "        this._headers = new g.Headers();\n"
+    "        this._body = null;\n"
+    "        this._signal = null;\n"
+    "      }\n"
+    "      if (init.method !== undefined) this._method = normalizeMethod(init.method);\n"
+    "      if (init.headers !== undefined) this._headers = new g.Headers(init.headers);\n"
+    "      if (init.signal !== undefined) {\n"
+    "        if (init.signal !== null && !(init.signal instanceof g.AbortSignal)) {\n"
+    "          throw new TypeError('Request init.signal must be an AbortSignal or null');\n"
+    "        }\n"
+    "        this._signal = init.signal;\n"
+    "      }\n"
+    "      if (init.body !== undefined && init.body !== null) {\n"
+    "        if (this._method === 'GET' || this._method === 'HEAD') {\n"
+    "          throw new TypeError('Request with GET/HEAD method cannot have body.');\n"
+    "        }\n"
+    "        const [bytes, ct] = coerceBodyBytes(init.body);\n"
+    "        this._body = bytes;\n"
+    "        if (ct !== null && !this._headers.has('content-type')) this._headers.set('content-type', ct);\n"
+    "      }\n"
+    "      this._bodyUsed = false;\n"
+    "    }\n"
+    "    get url() { return this._url; }\n"
+    "    get method() { return this._method; }\n"
+    "    get headers() { return this._headers; }\n"
+    "    /* Node's Request.signal is never null — a request built without one\n"
+    "     * carries an inert signal; mint it lazily on first access. */\n"
+    "    get signal() {\n"
+    "      if (this._signal === null) this._signal = mkSignal();\n"
+    "      return this._signal;\n"
+    "    }\n"
+    "  }\n"
+    "  bodyMixin(Request);\n"
+    "\n"
+    "  class Response {\n"
+    "    constructor(body, init) {\n"
+    "      init = init === undefined || init === null ? {} : init;\n"
+    "      const status = init.status === undefined ? 200 : Number(init.status);\n"
+    "      if (!Number.isInteger(status) || status < 200 || status > 599) {\n"
+    "        throw new RangeError(`init[\"status\"] must be in the range of 200 to 599, inclusive.`);\n"
+    "      }\n"
+    "      this._status = status;\n"
+    "      this._statusText = init.statusText === undefined ? '' : String(init.statusText);\n"
+    "      this._headers = new g.Headers(init.headers);\n"
+    "      this._url = '';\n"
+    "      this._redirected = false;\n"
+    "      this._bodyUsed = false;\n"
+    "      if (body === undefined || body === null) {\n"
+    "        this._body = null;\n"
+    "      } else {\n"
+    "        const [bytes, ct] = coerceBodyBytes(body);\n"
+    "        this._body = bytes;\n"
+    "        if (ct !== null && !this._headers.has('content-type')) this._headers.set('content-type', ct);\n"
+    "      }\n"
+    "    }\n"
+    "    get status() { return this._status; }\n"
+    "    get statusText() { return this._statusText; }\n"
+    "    get ok() { return this._status >= 200 && this._status <= 299; }\n"
+    "    get headers() { return this._headers; }\n"
+    "    get url() { return this._url; }\n"
+    "    get redirected() { return this._redirected; }\n"
+    "    get type() { return 'default'; }\n"
+    "    static json(data, init) {\n"
+    "      const r = new Response(JSON.stringify(data), init);\n"
+    "      r._headers.set('content-type', 'application/json');\n"
+    "      return r;\n"
+    "    }\n"
+    "  }\n"
+    "  bodyMixin(Response);\n"
+    "\n"
+    "  g.Request = Request;\n"
+    "  g.Response = Response;\n"
+    "  /* Internal: fetch builds Responses outside the constructor's 200–599\n"
+    "   * validation surface (statusText from the wire, url/redirected set). */\n"
+    "  g.__scr_mk_response = (status, statusText, headers, url, redirected, bodyStream) => {\n"
+    "    const r = new Response(null, { statusText: String(statusText) });\n"
+    "    r._status = status;\n"
+    "    r._headers = headers;\n"
+    "    r._url = url;\n"
+    "    r._redirected = redirected;\n"
+    "    r._body = bodyStream;\n"
+    "    return r;\n"
+    "  };\n"
+    "  /* crypto: randomness bridges to the HOST functions (one source of truth —\n"
+    "   * the same arc4random_buf CSPRNG behind the static crypto lowerings). */\n"
+    "  const intTA = ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'BigInt64Array', 'BigUint64Array'];\n"
+    "  g.crypto = {\n"
+    "    getRandomValues(ta) {\n"
+    "      const tag = ta === null || typeof ta !== 'object' ? '' : Object.prototype.toString.call(ta).slice(8, -1);\n"
+    "      if (intTA.indexOf(tag) < 0) {\n"
+    "        const e = new TypeError('crypto.getRandomValues takes an integer TypedArray');\n"
+    "        e.name = 'TypeMismatchError';\n"
+    "        throw e;\n"
+    "      }\n"
+    "      if (ta.byteLength > 65536) {\n"
+    "        const e = new Error('The requested length exceeds 65,536 bytes');\n"
+    "        e.name = 'QuotaExceededError';\n"
+    "        throw e;\n"
+    "      }\n"
+    "      host.fill(ta);\n"
+    "      return ta;\n"
+    "    },\n"
+    "    randomUUID() { return host.uuid(); },\n"
+    "  };\n"
+    "\n"
+    "  /* console: String()-formatted, space-joined, newline-terminated writes to\n"
+    "   * the REAL fds (same stdio buffers as static console.log). No printf-style\n"
+    "   * formatting and no object inspection — SEMANTICS.md documents the\n"
+    "   * subset. */\n"
+    "  const consoleFmt = (args) => {\n"
+    "    let s = '';\n"
+    "    for (let i = 0; i < args.length; i++) {\n"
+    "      if (i > 0) s += ' ';\n"
+    "      try { s += String(args[i]); } catch (_e) { s += '[value]'; }\n"
+    "    }\n"
+    "    return s + '\\n';\n"
+    "  };\n"
+    "  const consoleTo = (fd) => (...args) => { host.write(fd, consoleFmt(args)); };\n"
+    "  g.console = {\n"
+    "    log: consoleTo(1),\n"
+    "    info: consoleTo(1),\n"
+    "    debug: consoleTo(1),\n"
+    "    warn: consoleTo(2),\n"
+    "    error: consoleTo(2),\n"
+    "    trace: consoleTo(2),\n"
+    "  };\n"
+    "\n"
+    "  /* Date#toString/#toTimeString: the engine stops at the GMT offset\n"
+    "   * (\"Tue Jan 02 2024 00:00:00 GMT+0000\"); Node/V8 appends the zone's\n"
+    "   * long name (\"(Coordinated Universal Time)\"). The suffix rides\n"
+    "   * host.tzname(ms) — exact for UTC, the C library's zone name for\n"
+    "   * other zones (long names outside UTC are ICU data the runtime does\n"
+    "   * not carry; SEMANTICS.md). */\n"
+    "  {\n"
+    "    const dToString = Date.prototype.toString;\n"
+    "    const dToTimeString = Date.prototype.toTimeString;\n"
+    "    const dGetTime = Date.prototype.getTime;\n"
+    "    const withZone = (self, base) => {\n"
+    "      if (base === 'Invalid Date') return base;\n"
+    "      const name = host.tzname(dGetTime.call(self));\n"
+    "      return name === '' ? base : base + ' (' + name + ')';\n"
+    "    };\n"
+    "    Date.prototype.toString = function toString() { return withZone(this, dToString.call(this)); };\n"
+    "    Date.prototype.toTimeString = function toTimeString() { return withZone(this, dToTimeString.call(this)); };\n"
+    "  }\n"
+    "}\n";
+
+/* ── island timers (AbortSignal.timeout) ──────────────────────────────
+ * One-shot engine callbacks on the loop's monotonic clock, armed by the
+ * prelude's host.timer(fn, ms). UNREF'd like Node's AbortSignal.timeout
+ * timer: an armed timer never keeps the loop alive (it joins neither the
+ * exhaustion test nor io-pending unless already DUE); the island's io
+ * poll caps its sleeps at the earliest deadline and fires due timers, so
+ * a fetch timeout fires on time while the transfer keeps the loop
+ * running. Fired on the main stack from the io hook — isl_entry already
+ * re-anchored the engine. Unfired callbacks are freed at teardown. */
+
+typedef struct WebTimer {
+  double deadline_ms;
+  JSContext *ctx;
+  JSValue fn; /* owned */
+  struct WebTimer *next;
+} WebTimer;
+
+static WebTimer *web_timers = NULL;
+
+/* ── the setTimeout/setInterval bridge (the prelude's host.setTimer) ──
+ * Entries live on the STATIC timer heap (scr_async.c): ref'd liveness,
+ * FIFO ordering against static timers, and clearing all come from there.
+ * Each entry's closure captures the engine callback through a SCR_BOX_OBJ
+ * whose retain/release manage this little handle. */
+
+typedef struct {
+  size_t rc;
+  JSContext *ctx;
+  JSValue fn; /* owned */
+} WebTimerFn;
+
+static void *web_timerfn_retain(void *p) {
+  WebTimerFn *h = p;
+  h->rc++;
+  return p;
+}
+
+static void web_timerfn_release(void *p) {
+  WebTimerFn *h = p;
+  if (--h->rc == 0) {
+    JS_FreeValue(h->ctx, h->fn);
+    free(h);
+  }
+}
+
+/* The static-heap closure body: calls the engine callback on the main
+ * stack (where the loop fires every timer), then drains the engine jobs
+ * it queued (Node runs microtasks right after the macrotask). A throw
+ * bridges into the loop's uncaught path, exactly like a static timer
+ * callback's throw. */
+static void web_timer_fire_cb(ScrClosure *env) {
+  WebTimerFn *h = scr_box_get_ref(env->caps[0]); /* +1 */
+  JSValue r = JS_Call(h->ctx, h->fn, JS_UNDEFINED, 0, NULL);
+  if (JS_IsException(r)) {
+    scr_island_bridge_exception();
+  } else {
+    JS_FreeValue(h->ctx, r);
+    scr_island_drain_jobs();
+  }
+  web_timerfn_release(h);
+}
+
+static JSValue web_host_set_timer(JSContext *ctx, JSValueConst this_val,
+                                  int argc, JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  double ms = 0;
+  if (JS_ToFloat64(ctx, &ms, argv[1])) return JS_EXCEPTION;
+  bool repeat = JS_ToBool(ctx, argv[2]) > 0;
+  WebTimerFn *h = malloc(sizeof *h);
+  if (!h) {
+    fprintf(stderr, "scriptc: out of memory\n");
+    abort();
+  }
+  h->rc = 1;
+  h->ctx = ctx;
+  h->fn = JS_DupValue(ctx, argv[0]);
+  ScrBox *box = scr_box_new_obj(web_timerfn_retain, web_timerfn_release, NULL);
+  scr_box_set_ref(box, h); /* the box owns the +1 */
+  ScrClosure *cb = scr_closure_new((void *)web_timer_fire_cb, 1);
+  cb->caps[0] = box;
+  double id = repeat ? scr_set_interval(cb, ms) : scr_set_timeout_handle(cb, ms);
+  return JS_NewFloat64(ctx, id);
+}
+
+static JSValue web_host_clear_timer(JSContext *ctx, JSValueConst this_val,
+                                    int argc, JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  double id = 0;
+  if (JS_ToFloat64(ctx, &id, argv[0])) return JS_EXCEPTION;
+  scr_clear_interval(id);
+  return JS_UNDEFINED;
+}
+
+static JSValue web_host_timer(JSContext *ctx, JSValueConst this_val, int argc,
+                              JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  double ms = 0;
+  if (JS_ToFloat64(ctx, &ms, argv[1])) return JS_EXCEPTION;
+  if (!(ms >= 0)) ms = 0; /* NaN/negative clamp, like the static setTimeout */
+  WebTimer *t = malloc(sizeof *t);
+  if (!t) {
+    fprintf(stderr, "scriptc: out of memory\n");
+    abort();
+  }
+  t->deadline_ms = scr_now_ms() + ms;
+  t->ctx = ctx;
+  t->fn = JS_DupValue(ctx, argv[0]);
+  t->next = web_timers;
+  web_timers = t;
+  return JS_UNDEFINED;
+}
+
+double scr_island_timers_deadline(void) {
+  double best = HUGE_VAL;
+  for (WebTimer *t = web_timers; t; t = t->next) {
+    if (t->deadline_ms < best) best = t->deadline_ms;
+  }
+  return best;
+}
+
+bool scr_island_timers_due(void) {
+  return web_timers != NULL && scr_island_timers_deadline() <= scr_now_ms();
+}
+
+/* Fires every due timer (a callback may arm new ones — the scan restarts
+ * after each firing, so late arrivals with passed deadlines fire too).
+ * A throwing callback is our own glue misbehaving: reported, never fatal,
+ * the remaining timers still fire. */
+bool scr_island_timers_fire_due(void) {
+  bool fired = false;
+  double now = scr_now_ms();
+  for (;;) {
+    WebTimer **link = &web_timers;
+    WebTimer *due = NULL;
+    while (*link) {
+      if ((*link)->deadline_ms <= now) {
+        due = *link;
+        *link = due->next;
+        break;
+      }
+      link = &(*link)->next;
+    }
+    if (!due) break;
+    JSValue r = JS_Call(due->ctx, due->fn, JS_UNDEFINED, 0, NULL);
+    if (JS_IsException(r)) {
+      JSValue e = JS_GetException(due->ctx);
+      const char *msg = JS_ToCString(due->ctx, e);
+      fprintf(stderr, "scriptc: island timer callback threw: %s\n", msg ? msg : "?");
+      if (msg) JS_FreeCString(due->ctx, msg);
+      JS_FreeValue(due->ctx, e);
+    } else {
+      JS_FreeValue(due->ctx, r);
+    }
+    JS_FreeValue(due->ctx, due->fn);
+    free(due);
+    fired = true;
+  }
+  return fired;
+}
+
+void scr_island_timers_teardown(void) {
+  while (web_timers) {
+    WebTimer *t = web_timers;
+    web_timers = t->next;
+    JS_FreeValue(t->ctx, t->fn);
+    free(t);
+  }
+}
+
+/* ── host functions ───────────────────────────────────────────────────
+ * The prelude's I/O-free exceptions: randomness (bridged to the SAME
+ * arc4random_buf CSPRNG behind the static crypto lowerings — one source
+ * of truth), console's fd writes (the real stdio buffers, interleaving
+ * correctly with static console.log), and the timer above. Engine
+ * ownership rules as ever: argv borrowed, results owned. */
+
+/* host.fill(typedArray): fill the view's bytes with CSPRNG output. The
+ * JS side already validated the view kind and the 65536-byte quota. */
+static JSValue web_host_fill(JSContext *ctx, JSValueConst this_val, int argc,
+                             JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  size_t off = 0, len = 0, bpe = 0;
+  JSValue ab = JS_GetTypedArrayBuffer(ctx, argv[0], &off, &len, &bpe);
+  if (JS_IsException(ab)) return JS_EXCEPTION;
+  size_t absize = 0;
+  uint8_t *buf = JS_GetArrayBuffer(ctx, &absize, ab);
+  JS_FreeValue(ctx, ab);
+  if (!buf) return JS_EXCEPTION;
+  if (len > 0) arc4random_buf(buf + off, len);
+  return JS_UNDEFINED;
+}
+
+static JSValue web_host_uuid(JSContext *ctx, JSValueConst this_val, int argc,
+                             JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  (void)argv;
+  ScrStr *s = scr_crypto_random_uuid(); /* +1 */
+  JSValue r = JS_NewStringLen(ctx, s->data, s->len);
+  scr_str_release(s);
+  return r;
+}
+
+/* Date#toString's timezone-name suffix (the prelude's Date patch): Node
+ * prints the zone's CLDR long name ("Coordinated Universal Time"); without
+ * ICU data the C library only knows the zone's own name for the instant
+ * (tm_zone: "UTC", "CST" — DST-correct via localtime). UTC maps to its
+ * exact CLDR spelling; every other zone renders the C library name — the
+ * documented divergence in SEMANTICS.md. */
+static JSValue web_host_tzname(JSContext *ctx, JSValueConst this_val, int argc,
+                               JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  double ms = 0;
+  if (JS_ToFloat64(ctx, &ms, argv[0])) return JS_EXCEPTION;
+  if (!isfinite(ms)) return JS_NewString(ctx, "");
+  time_t t = (time_t)floor(ms / 1000.0);
+#if defined(_WIN32)
+  /* MinGW's struct tm carries no tm_zone; tzname[] (after tzset) holds the
+   * CRT's zone names — full names on Windows ("Central Standard Time"). */
+  struct tm *lt = localtime(&t);
+  if (lt == NULL) return JS_NewString(ctx, "");
+  tzset();
+  const char *name = tzname[lt->tm_isdst > 0 ? 1 : 0];
+#else
+  struct tm tmv;
+  if (localtime_r(&t, &tmv) == NULL) return JS_NewString(ctx, "");
+  const char *name = tmv.tm_zone;
+#endif
+  if (name == NULL) name = "";
+  if (strcmp(name, "UTC") == 0) name = "Coordinated Universal Time";
+  return JS_NewString(ctx, name);
+}
+
+static JSValue web_host_write(JSContext *ctx, JSValueConst this_val, int argc,
+                              JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  int32_t fd = 1;
+  JS_ToInt32(ctx, &fd, argv[0]);
+  size_t len;
+  const char *s = JS_ToCStringLen(ctx, &len, argv[1]);
+  if (!s) return JS_EXCEPTION;
+  fwrite(s, 1, len, fd == 2 ? stderr : stdout);
+  JS_FreeCString(ctx, s);
+  return JS_UNDEFINED;
+}
+
+void scr_island_web_boot(void *jsctx) {
+  JSContext *ctx = (JSContext *)jsctx;
+  JSValue fn = JS_Eval(ctx, web_prelude, sizeof web_prelude - 1,
+                       "<scr-web>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(fn)) {
+    fprintf(stderr, "scriptc: island web prelude failed to evaluate\n");
+    JSValue e = JS_GetException(ctx);
+    JS_FreeValue(ctx, e);
+    abort();
+  }
+  JSValue host = JS_NewObject(ctx);
+  /* JS_SetPropertyStr consumes the function values. */
+  JS_SetPropertyStr(ctx, host, "fill", JS_NewCFunction(ctx, web_host_fill, "fill", 1));
+  JS_SetPropertyStr(ctx, host, "uuid", JS_NewCFunction(ctx, web_host_uuid, "uuid", 0));
+  JS_SetPropertyStr(ctx, host, "write", JS_NewCFunction(ctx, web_host_write, "write", 2));
+  JS_SetPropertyStr(ctx, host, "tzname", JS_NewCFunction(ctx, web_host_tzname, "tzname", 1));
+  JS_SetPropertyStr(ctx, host, "timer", JS_NewCFunction(ctx, web_host_timer, "timer", 2));
+  JS_SetPropertyStr(ctx, host, "setTimer", JS_NewCFunction(ctx, web_host_set_timer, "setTimer", 3));
+  JS_SetPropertyStr(ctx, host, "clearTimer", JS_NewCFunction(ctx, web_host_clear_timer, "clearTimer", 1));
+  JSValue r = JS_Call(ctx, fn, JS_UNDEFINED, 1, (JSValueConst *)&host);
+  JS_FreeValue(ctx, host);
+  JS_FreeValue(ctx, fn);
+  if (JS_IsException(r)) {
+    fprintf(stderr, "scriptc: island web prelude failed to run\n");
+    JSValue e = JS_GetException(ctx);
+    JS_FreeValue(ctx, e);
+    abort();
+  }
+  JS_FreeValue(ctx, r);
+}
+
+#endif /* SCR_DYNAMIC */