@scriptc/cli-darwin-x64 0.2.1 → 0.2.3

package/dist/lib/runtime-sources/src/scr_web.c

@@ -5,9 +5,11 @@
  * under -DSCR_DYNAMIC, like scr_island.c.
  *
  * This file owns the semantics-heavy globals: the streams library
- * (ReadableStream, TransformStream), the encoders (TextEncoder,
+ * (ReadableStream, WritableStream with queued sink writes and strategy
+ * backpressure, TransformStream with readable-side backpressure), the encoders
+ * (TextEncoder,
  * TextDecoder — the WHATWG utf-8 state machine exactly, other labels
- * fenced — and TextDecoderStream), URLSearchParams, btoa/atob, Headers,
+ * fenced — and TextEncoderStream/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
@@ -24,16 +26,12 @@
  * 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.
+ * stream transfer, and non-utf-8 TextDecoder labels. Default-stream piping,
+ * teeing, reader/controller lifecycles, and transform backpressure are
+ * pinned by differential fixtures; the limitations page records the boundaries.
  *
- * The JS was verified line-for-line against Node's native WHATWG
- * implementations (a transcript battery: reader protocol, pull timing,
+ * JS behavior is pinned against Node's native WHATWG implementations
+ * by differential fixtures (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. */
@@ -62,54 +60,477 @@ static const char web_prelude[] =
     "   * (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"
+    "   * object with real ref/unref/refresh/close operations. Immediates\n"
+    "   * use the native check queue, independently of timer ids. */\n"
+    "  const timers = new Map();\n"
     "  class Timeout {\n"
-    "    constructor(fn, delay, repeat) {\n"
+    "    constructor(fn, delay, args, repeat) {\n"
     "      this._fn = fn;\n"
     "      this._delay = delay;\n"
+    "      this._args = args;\n"
     "      this._repeat = repeat;\n"
-    "      this._id = host.setTimer(fn, delay, repeat);\n"
+    "      this._reffed = true;\n"
+    "      this._closed = false;\n"
+    "      this._callback = () => {\n"
+    "        if (!this._repeat) { this._destroyed = true; timers.delete(this._id); }\n"
+    "        this._fn.apply(this, this._args);\n"
+    "      };\n"
+    "      this._arm();\n"
     "    }\n"
-    "    ref() { return this; }\n"
-    "    unref() { return this; }\n"
-    "    hasRef() { return true; }\n"
+    "    _arm() {\n"
+    "      this._destroyed = false;\n"
+    "      this._id = host.setTimer(this._callback, this._delay, this._repeat, false);\n"
+    "      timers.set(this._id, this);\n"
+    "      if (!this._reffed) host.refTimer(this._id, false, false);\n"
+    "    }\n"
+    "    ref() { this._reffed = true; host.refTimer(this._id, true, false); return this; }\n"
+    "    unref() { this._reffed = false; host.refTimer(this._id, false, false); return this; }\n"
+    "    hasRef() { return this._reffed; }\n"
     "    refresh() {\n"
-    "      host.clearTimer(this._id);\n"
-    "      this._id = host.setTimer(this._fn, this._delay, this._repeat);\n"
+    "      if (this._closed) return this;\n"
+    "      if (this._destroyed) this._arm();\n"
+    "      else host.refreshTimer(this._id);\n"
     "      return this;\n"
     "    }\n"
-    "    close() { host.clearTimer(this._id); return this; }\n"
+    "    close() { this._closed = true; this._destroyed = true; timers.delete(this._id); host.clearTimer(this._id, false); return this; }\n"
+    "    [Symbol.dispose]() { this.close(); }\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"
+    "    return new Timeout(fn, Number(ms), args, 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"
+    "    if (Number.isFinite(id)) {\n"
+    "      const timer = timers.get(id);\n"
+    "      if (timer) timer.close(); else host.clearTimer(id, false);\n"
+    "    }\n"
     "  };\n"
     "  g.clearInterval = g.clearTimeout;\n"
+    "  class Immediate {\n"
+    "    constructor(fn, args) {\n"
+    "      this._reffed = true; this._destroyed = false;\n"
+    "      this._id = host.setTimer(() => {\n"
+    "        this._destroyed = true; this._reffed = false; fn.apply(this, args);\n"
+    "      }, 0, false, true);\n"
+    "    }\n"
+    "    ref() { if (!this._destroyed) { this._reffed = true; host.refTimer(this._id, true, true); } return this; }\n"
+    "    unref() { if (!this._destroyed) { this._reffed = false; host.refTimer(this._id, false, true); } return this; }\n"
+    "    hasRef() { return this._reffed; }\n"
+    "    _close() { this._destroyed = true; this._reffed = false; host.clearTimer(this._id, true); }\n"
+    "    [Symbol.dispose]() { this._close(); }\n"
+    "  }\n"
+    "  g.setImmediate = (fn, ...args) => {\n"
+    "    if (typeof fn !== 'function') throw new TypeError('The \"callback\" argument must be of type function. Received type ' + typeof fn);\n"
+    "    return new Immediate(fn, args);\n"
+    "  };\n"
+    "  g.clearImmediate = (immediate) => { if (immediate instanceof Immediate) immediate._close(); };\n"
+    "\n"
+    "  // Queue sizing is shared by the readable and writable default streams.\n"
+    "  const streamError = (Ctor, code, message) => Object.assign(new Ctor(message), { code });\n"
+    "  const streamReceived = (v) => {\n"
+    "    if (v === null || v === undefined) return String(v);\n"
+    "    if (typeof v === 'function') return 'function ' + v.name;\n"
+    "    if (typeof v === 'object') return 'an instance of ' + (v.constructor && v.constructor.name || 'Object');\n"
+    "    return 'type ' + typeof v + ' (' + (typeof v === 'string' ? \"'\" + v + \"'\" : String(v) + (typeof v === 'bigint' ? 'n' : '')) + ')';\n"
+    "  };\n"
+    "  const streamArgument = (name, expected, v) => streamError(TypeError, 'ERR_INVALID_ARG_TYPE',\n"
+    "    'The \"' + name + '\" ' + (name.includes('.') ? 'property' : 'argument') + ' must be ' + expected + '. Received ' + streamReceived(v));\n"
+    "  const streamInvalidThis = (name) => streamError(TypeError, 'ERR_INVALID_THIS', 'Value of \"this\" must be of type ' + name);\n"
+    "  const streamInvalidState = (message) => streamError(TypeError, 'ERR_INVALID_STATE', 'Invalid state: ' + message);\n"
+    "  const streamInvalidValue = (name, value) => streamError(RangeError, 'ERR_INVALID_ARG_VALUE',\n"
+    "    \"The \" + (name.includes('.') ? 'property' : 'argument') + \" '\" + name + \"' is invalid. Received \" + (typeof value === 'string' ? \"'\" + value + \"'\" : String(value)));\n"
+    "  const streamStrategy = (strategy, fallback) => {\n"
+    "    if (strategy === undefined || strategy === null) strategy = {};\n"
+    "    if (typeof strategy !== 'object' && typeof strategy !== 'function') throw streamArgument('strategy', 'of type object', strategy);\n"
+    "    const size = strategy.size;\n"
+    "    if (size !== undefined && typeof size !== 'function') throw streamArgument('strategy.size', 'of type function', size);\n"
+    "    const value = strategy.highWaterMark;\n"
+    "    const highWaterMark = value === undefined ? fallback : +value;\n"
+    "    if (Number.isNaN(highWaterMark) || highWaterMark < 0) throw streamInvalidValue('strategy.highWaterMark', highWaterMark);\n"
+    "    return { size: size === undefined ? () => 1 : size, highWaterMark };\n"
+    "  };\n"
+    "  const streamChunkSize = (value) => {\n"
+    "    const size = +value;\n"
+    "    if (!Number.isFinite(size) || size < 0) throw streamInvalidValue('size', size);\n"
+    "    return size;\n"
+    "  };\n"
+    "  const streamDeferred = (handled = false) => {\n"
+    "    const d = { settled: false };\n"
+    "    d.promise = new Promise((resolve, reject) => {\n"
+    "      d.resolve = () => { d.settled = true; resolve(); };\n"
+    "      d.reject = (e) => { d.settled = true; reject(e); };\n"
+    "    });\n"
+    "    if (handled) d.promise.catch(() => {});\n"
+    "    return d;\n"
+    "  };\n"
+    "  const streamRejectSlot = (owner, key, e) => {\n"
+    "    if (owner[key].settled) owner[key] = streamDeferred(true);\n"
+    "    owner[key].reject(e);\n"
+    "  };\n"
+    "  const countStrategyStates = new WeakMap();\n"
+    "  const byteStrategyStates = new WeakMap();\n"
+    "  const countSize = Object.defineProperty(() => 1, 'name', { value: 'size' });\n"
+    "  const byteSize = Object.defineProperty((chunk) => chunk.byteLength, 'name', { value: 'size' });\n"
+    "  const strategyInit = (init) => {\n"
+    "    if (init === null || typeof init !== 'object' || Array.isArray(init)) throw streamArgument('init', 'of type object', init);\n"
+    "    if (init.highWaterMark === undefined) throw streamError(TypeError, 'ERR_MISSING_OPTION', 'init.highWaterMark is required');\n"
+    "    return +init.highWaterMark;\n"
+    "  };\n"
+    "  class CountQueuingStrategy {\n"
+    "    constructor(init) { countStrategyStates.set(this, strategyInit(init)); }\n"
+    "    get highWaterMark() { if (!countStrategyStates.has(this)) throw new TypeError('Invalid CountQueuingStrategy receiver'); return countStrategyStates.get(this); }\n"
+    "    get size() { if (!countStrategyStates.has(this)) throw new TypeError('Invalid CountQueuingStrategy receiver'); return countSize; }\n"
+    "  }\n"
+    "  class ByteLengthQueuingStrategy {\n"
+    "    constructor(init) { byteStrategyStates.set(this, strategyInit(init)); }\n"
+    "    get highWaterMark() { if (!byteStrategyStates.has(this)) throw new TypeError('Invalid ByteLengthQueuingStrategy receiver'); return byteStrategyStates.get(this); }\n"
+    "    get size() { if (!byteStrategyStates.has(this)) throw new TypeError('Invalid ByteLengthQueuingStrategy receiver'); return byteSize; }\n"
+    "  }\n"
+    "\n"
+    "  const writableStreams = new WeakMap();\n"
+    "  const writableWriters = new WeakMap();\n"
+    "  const writableControllers = new WeakMap();\n"
+    "  const writableToken = Symbol('WritableStreamDefaultController');\n"
+    "  const writableWriterState = (s) => s.writer === undefined ? undefined : writableWriters.get(s.writer);\n"
+    "  const writableBackpressure = (s) => {\n"
+    "    const pressure = s.highWaterMark - s.queueSize <= 0;\n"
+    "    const w = writableWriterState(s);\n"
+    "    if (w && s.backpressure !== pressure) {\n"
+    "      if (pressure) w.ready = streamDeferred(true);\n"
+    "      else w.ready.resolve();\n"
+    "    }\n"
+    "    s.backpressure = pressure;\n"
+    "  };\n"
+    "  const writableClear = (s) => { s.write = s.close = s.abort = s.size = undefined; };\n"
+    "  const writableRejectClosed = (s) => {\n"
+    "    if (s.closeRequest) { s.closeRequest.reject(s.error); s.closeRequest = undefined; }\n"
+    "    const w = writableWriterState(s);\n"
+    "    if (w) w.closed.reject(s.error);\n"
+    "  };\n"
+    "  const writableFinishError = (s) => {\n"
+    "    s.state = 'errored';\n"
+    "    for (const q of s.queue) if (q.kind === 'write') q.request.reject(s.error);\n"
+    "    s.queue = []; s.queueSize = 0;\n"
+    "    const a = s.abortRequest;\n"
+    "    s.abortRequest = undefined;\n"
+    "    if (!a) { writableRejectClosed(s); return; }\n"
+    "    if (a.alreadyErroring) { a.request.reject(s.error); writableRejectClosed(s); return; }\n"
+    "    const result = writableInvoke(s.abort, s.sink, [a.reason]);\n"
+    "    writableClear(s);\n"
+    "    result.then(\n"
+    "      () => { a.request.resolve(); writableRejectClosed(s); },\n"
+    "      (e) => { a.request.reject(e); writableRejectClosed(s); },\n"
+    "    );\n"
+    "  };\n"
+    "  const writableError = (s, e) => {\n"
+    "    if (s.state !== 'writable') return;\n"
+    "    s.state = 'erroring'; s.error = e;\n"
+    "    const w = writableWriterState(s);\n"
+    "    if (w) streamRejectSlot(w, 'ready', e);\n"
+    "    if (s.started && !s.inFlight) writableFinishError(s);\n"
+    "  };\n"
+    "  // Async callback wrappers adopt returned thenables and turn sync throws into rejections.\n"
+    "  const writableInvoke = async (fn, receiver, args) => fn ? fn.apply(receiver, args) : undefined;\n"
+    "  const writableAdvance = (s) => {\n"
+    "    if (!s.started || s.inFlight || s.state === 'closed' || s.state === 'errored') return;\n"
+    "    if (s.state === 'erroring') { writableFinishError(s); return; }\n"
+    "    if (!s.queue.length) return;\n"
+    "    const q = s.queue[0];\n"
+    "    s.inFlight = q;\n"
+    "    if (q.kind === 'close') {\n"
+    "      s.queue.shift();\n"
+    "      const result = writableInvoke(s.close, s.sink, []);\n"
+    "      writableClear(s);\n"
+    "      result.then(\n"
+    "        () => {\n"
+    "          q.request.resolve(); s.inFlight = undefined;\n"
+    "          if (s.abortRequest) { s.abortRequest.request.resolve(); s.abortRequest = undefined; }\n"
+    "          s.state = 'closed'; s.error = undefined; s.closeRequest = undefined;\n"
+    "          const w = writableWriterState(s);\n"
+    "          if (w) w.closed.resolve();\n"
+    "        },\n"
+    "        (e) => {\n"
+    "          q.request.reject(e); s.inFlight = undefined; s.closeRequest = undefined;\n"
+    "          if (s.abortRequest) { s.abortRequest.request.reject(e); s.abortRequest = undefined; }\n"
+    "          if (s.state === 'writable') writableError(s, e); else writableFinishError(s);\n"
+    "        },\n"
+    "      );\n"
+    "      return;\n"
+    "    }\n"
+    "    writableInvoke(s.write, s.sink, [q.chunk, s.controller]).then(\n"
+    "      () => {\n"
+    "        q.request.resolve(); s.inFlight = undefined; s.queue.shift();\n"
+    "        s.queueSize = Math.max(0, s.queueSize - q.size);\n"
+    "        if (s.state === 'writable' && !s.closeRequest) writableBackpressure(s);\n"
+    "        writableAdvance(s);\n"
+    "      },\n"
+    "      (e) => {\n"
+    "        q.request.reject(e); s.inFlight = undefined; s.queue.shift();\n"
+    "        if (s.state === 'writable') { writableClear(s); writableError(s, e); }\n"
+    "        else writableFinishError(s);\n"
+    "      },\n"
+    "    );\n"
+    "  };\n"
+    "  const writableAbort = (s, reason) => {\n"
+    "    if (s.state === 'closed' || s.state === 'errored') return Promise.resolve();\n"
+    "    s.abortController.abort(reason);\n"
+    "    if (s.abortRequest) return s.abortRequest.request.promise;\n"
+    "    // Signal listeners may have closed or errored the stream synchronously.\n"
+    "    if (s.state === 'closed' || s.state === 'errored') return Promise.resolve();\n"
+    "    const alreadyErroring = s.state === 'erroring';\n"
+    "    const request = streamDeferred();\n"
+    "    s.abortRequest = { request, reason, alreadyErroring };\n"
+    "    if (!alreadyErroring) writableError(s, reason);\n"
+    "    return request.promise;\n"
+    "  };\n"
+    "  const writableClose = (s, writer) => {\n"
+    "    if (s.closeRequest) return Promise.reject(streamInvalidState(writer ? 'Failure to close WritableStream' : 'Failure closing WritableStream'));\n"
+    "    if (s.state === 'closed' || s.state === 'errored') return Promise.reject(streamInvalidState('WritableStream is closed'));\n"
+    "    const request = streamDeferred();\n"
+    "    s.closeRequest = request;\n"
+    "    const w = writableWriterState(s);\n"
+    "    if (w && s.backpressure && s.state === 'writable') w.ready.resolve();\n"
+    "    s.queue.push({ kind: 'close', request });\n"
+    "    writableAdvance(s);\n"
+    "    return request.promise;\n"
+    "  };\n"
+    "  class WritableStream {\n"
+    "    constructor(sink = {}, strategy) {\n"
+    "      if (sink === null || (typeof sink !== 'object' && typeof sink !== 'function')) throw streamArgument('sink', 'of type object', sink);\n"
+    "      const type = sink.type;\n"
+    "      if (type !== undefined) throw streamInvalidValue('type', type);\n"
+    "      const { size, highWaterMark } = streamStrategy(strategy, 1);\n"
+    "      // Capture algorithms once: replacing sink methods later must not change the stream.\n"
+    "      const start = sink.start, write = sink.write, close = sink.close, abort = sink.abort;\n"
+    "      for (const [name, fn] of [['write', write], ['close', close], ['abort', abort]]) {\n"
+    "        if (fn && typeof fn !== 'function') throw streamArgument('sink.' + name, 'of type function', fn);\n"
+    "      }\n"
+    "      if (start && typeof start !== 'function') throw new TypeError('Bind must be called on a function');\n"
+    "      const s = { sink, size, highWaterMark, write, close, abort, state: 'writable', error: undefined,\n"
+    "        queue: [], queueSize: 0, started: false, inFlight: undefined, writer: undefined,\n"
+    "        closeRequest: undefined, abortRequest: undefined, backpressure: highWaterMark <= 0, abortController: new g.AbortController() };\n"
+    "      writableStreams.set(this, s);\n"
+    "      s.controller = new WritableStreamDefaultController(writableToken, s);\n"
+    "      const result = start ? start.call(sink, s.controller) : undefined;\n"
+    "      new Promise((resolve) => resolve(result)).then(\n"
+    "        () => { s.started = true; writableAdvance(s); },\n"
+    "        (e) => { s.started = true; if (s.state === 'writable') writableError(s, e); else writableFinishError(s); },\n"
+    "      );\n"
+    "    }\n"
+    "    get locked() { const s = writableStreams.get(this); if (!s) throw streamInvalidThis('WritableStream'); return s.writer !== undefined; }\n"
+    "    getWriter() { if (!writableStreams.has(this)) throw streamInvalidThis('WritableStream'); return new WritableStreamDefaultWriter(this); }\n"
+    "    abort(reason) {\n"
+    "      const s = writableStreams.get(this);\n"
+    "      if (!s) return Promise.reject(streamInvalidThis('WritableStream'));\n"
+    "      if (s.writer !== undefined) return Promise.reject(streamInvalidState('WritableStream is locked'));\n"
+    "      return writableAbort(s, reason);\n"
+    "    }\n"
+    "    close() {\n"
+    "      const s = writableStreams.get(this);\n"
+    "      if (!s) return Promise.reject(streamInvalidThis('WritableStream'));\n"
+    "      if (s.writer !== undefined) return Promise.reject(streamInvalidState('WritableStream is locked'));\n"
+    "      return writableClose(s, false);\n"
+    "    }\n"
+    "  }\n"
+    "  class WritableStreamDefaultWriter {\n"
+    "    constructor(stream) {\n"
+    "      const s = writableStreams.get(stream);\n"
+    "      if (!s) throw streamArgument('stream', 'an instance of WritableStream', stream);\n"
+    "      if (s.writer !== undefined) throw streamInvalidState('WritableStream is locked');\n"
+    "      const w = { stream: s, ready: streamDeferred(true), closed: streamDeferred(true) };\n"
+    "      writableWriters.set(this, w); s.writer = this;\n"
+    "      if (s.state === 'writable') { if (!s.backpressure || s.closeRequest) w.ready.resolve(); }\n"
+    "      else if (s.state === 'closed') { w.ready.resolve(); w.closed.resolve(); }\n"
+    "      else { w.ready.reject(s.error); if (s.state === 'errored') w.closed.reject(s.error); }\n"
+    "    }\n"
+    "    get closed() { const w = writableWriters.get(this); return w ? w.closed.promise : Promise.reject(streamInvalidThis('WritableStreamDefaultWriter')); }\n"
+    "    get ready() { const w = writableWriters.get(this); return w ? w.ready.promise : Promise.reject(streamInvalidThis('WritableStreamDefaultWriter')); }\n"
+    "    get desiredSize() {\n"
+    "      const w = writableWriters.get(this);\n"
+    "      if (!w) throw streamInvalidThis('WritableStreamDefaultWriter');\n"
+    "      if (!w.stream) throw streamInvalidState('Writer is not bound to a WritableStream');\n"
+    "      const s = w.stream;\n"
+    "      return s.state === 'closed' ? 0 : s.state === 'writable' ? s.highWaterMark - s.queueSize : null;\n"
+    "    }\n"
+    "    write(chunk) {\n"
+    "      const w = writableWriters.get(this);\n"
+    "      if (!w) return Promise.reject(streamInvalidThis('WritableStreamDefaultWriter'));\n"
+    "      const s = w.stream;\n"
+    "      if (!s) return Promise.reject(streamInvalidState('Writer is not bound to a WritableStream'));\n"
+    "      let value = 1;\n"
+    "      try { if (s.size) value = s.size.call(undefined, chunk); }\n"
+    "      catch (e) { if (s.state === 'writable') { writableClear(s); writableError(s, e); } }\n"
+    "      if (w.stream !== s) return Promise.reject(streamInvalidState('Mismatched WritableStreams'));\n"
+    "      if (s.state === 'errored') return Promise.reject(s.error);\n"
+    "      if (s.closeRequest || s.state === 'closed') return Promise.reject(streamInvalidState('WritableStream is closed'));\n"
+    "      if (s.state === 'erroring') return Promise.reject(s.error);\n"
+    "      const request = streamDeferred();\n"
+    "      let size;\n"
+    "      try { size = streamChunkSize(value); }\n"
+    "      catch (e) {\n"
+    "        // The write request joins the queue before invalid sizing errors the stream.\n"
+    "        s.queue.push({ kind: 'write', request }); writableClear(s); writableError(s, e);\n"
+    "        return request.promise;\n"
+    "      }\n"
+    "      s.queue.push({ kind: 'write', chunk, size, request }); s.queueSize += size;\n"
+    "      writableBackpressure(s); writableAdvance(s);\n"
+    "      return request.promise;\n"
+    "    }\n"
+    "    close() {\n"
+    "      const w = writableWriters.get(this);\n"
+    "      if (!w) return Promise.reject(streamInvalidThis('WritableStreamDefaultWriter'));\n"
+    "      if (!w.stream) return Promise.reject(streamInvalidState('Writer is not bound to a WritableStream'));\n"
+    "      return writableClose(w.stream, true);\n"
+    "    }\n"
+    "    abort(reason) {\n"
+    "      const w = writableWriters.get(this);\n"
+    "      if (!w) return Promise.reject(streamInvalidThis('WritableStreamDefaultWriter'));\n"
+    "      if (!w.stream) return Promise.reject(streamInvalidState('Writer is not bound to a WritableStream'));\n"
+    "      return writableAbort(w.stream, reason);\n"
+    "    }\n"
+    "    releaseLock() {\n"
+    "      const w = writableWriters.get(this);\n"
+    "      if (!w) throw streamInvalidThis('WritableStreamDefaultWriter');\n"
+    "      if (!w.stream) return;\n"
+    "      const e = streamInvalidState('Writer has been released');\n"
+    "      streamRejectSlot(w, 'ready', e); streamRejectSlot(w, 'closed', e);\n"
+    "      w.stream.writer = undefined; w.stream = undefined;\n"
+    "    }\n"
+    "  }\n"
+    "  class WritableStreamDefaultController {\n"
+    "    constructor(token, stream) {\n"
+    "      if (token !== writableToken) throw streamError(TypeError, 'ERR_ILLEGAL_CONSTRUCTOR', 'Illegal constructor');\n"
+    "      writableControllers.set(this, stream);\n"
+    "    }\n"
+    "    get signal() { const s = writableControllers.get(this); if (!s) throw streamInvalidThis('WritableStreamDefaultController'); return s.abortController.signal; }\n"
+    "    error(e) {\n"
+    "      const s = writableControllers.get(this);\n"
+    "      if (!s) throw streamInvalidThis('WritableStreamDefaultController');\n"
+    "      if (s.state === 'writable') { writableClear(s); writableError(s, e); }\n"
+    "    }\n"
+    "  }\n"
+    "  for (const C of [WritableStream, WritableStreamDefaultWriter, WritableStreamDefaultController, CountQueuingStrategy, ByteLengthQueuingStrategy]) {\n"
+    "    Object.defineProperty(C.prototype, Symbol.toStringTag, { value: C.name, configurable: true });\n"
+    "    for (const name of Object.getOwnPropertyNames(C.prototype)) {\n"
+    "      if (name !== 'constructor') Object.defineProperty(C.prototype, name, { enumerable: true });\n"
+    "    }\n"
+    "    g[C.name] = C;\n"
+    "  }\n"
+    "\n"
+    "  const readableStreams = new WeakSet();\n"
+    "  const readableReaders = new WeakMap(), readableControllers = new WeakMap();\n"
+    "  const readableToken = Symbol('ReadableStreamDefaultController');\n"
+    "  const readableControllerStream = (controller) => {\n"
+    "    const stream = readableControllers.get(controller);\n"
+    "    if (!stream) throw new TypeError('Invalid ReadableStreamDefaultController receiver');\n"
+    "    return stream;\n"
+    "  };\n"
+    "  class ReadableStreamDefaultController {\n"
+    "    constructor(token, stream) {\n"
+    "      if (token !== readableToken) throw streamError(TypeError, 'ERR_ILLEGAL_CONSTRUCTOR', 'Illegal constructor');\n"
+    "      readableControllers.set(this, stream);\n"
+    "    }\n"
+    "    get desiredSize() {\n"
+    "      const s = readableControllerStream(this);\n"
+    "      return s._state === 'errored' ? null : s._state === 'closed' ? 0 : s._highWaterMark - s._queueSize;\n"
+    "    }\n"
+    "    enqueue(chunk) {\n"
+    "      const s = readableControllerStream(this);\n"
+    "      if (s._closeRequested || s._state !== 'readable') throw streamInvalidState('Controller is already closed');\n"
+    "      if (s._reads.length) s._reads.shift().resolve({ value: chunk, done: false });\n"
+    "      else {\n"
+    "        let size;\n"
+    "        try { size = streamChunkSize(s._size.call(undefined, chunk)); }\n"
+    "        catch (e) { s._errorStream(e); throw e; }\n"
+    "        s._queue.push({ chunk, size }); s._queueSize += size;\n"
+    "      }\n"
+    "      s._maybePull();\n"
+    "    }\n"
+    "    close() {\n"
+    "      const s = readableControllerStream(this);\n"
+    "      if (s._closeRequested || s._state !== 'readable') throw streamInvalidState('Controller is already closed');\n"
+    "      s._closeRequested = true;\n"
+    "      if (!s._queue.length) s._finishClose();\n"
+    "    }\n"
+    "    error(e) { readableControllerStream(this)._errorStream(e); }\n"
+    "  }\n"
+    "  class ReadableStreamDefaultReader {\n"
+    "    constructor(stream) {\n"
+    "      if (!readableStreams.has(stream)) throw streamArgument('stream', 'an instance of ReadableStream', stream);\n"
+    "      if (stream._locked) throw streamInvalidState('ReadableStream is locked');\n"
+    "      const r = { stream, closed: streamDeferred(true) };\n"
+    "      readableReaders.set(this, r); stream._locked = true;\n"
+    "      stream._closedResolve = r.closed.resolve; stream._closedReject = r.closed.reject;\n"
+    "      if (stream._state === 'closed') r.closed.resolve();\n"
+    "      else if (stream._state === 'errored') r.closed.reject(stream._storedError);\n"
+    "    }\n"
+    "    get closed() {\n"
+    "      const r = readableReaders.get(this);\n"
+    "      return r ? r.closed.promise : Promise.reject(streamInvalidThis('ReadableStreamDefaultReader'));\n"
+    "    }\n"
+    "    read() {\n"
+    "      const r = readableReaders.get(this);\n"
+    "      if (!r) return Promise.reject(streamInvalidThis('ReadableStreamDefaultReader'));\n"
+    "      const s = r.stream;\n"
+    "      if (!s) return Promise.reject(streamInvalidState('The reader is not attached to a stream'));\n"
+    "      if (s._queue.length) {\n"
+    "        const queued = s._queue.shift();\n"
+    "        s._queueSize = Math.max(0, s._queueSize - queued.size);\n"
+    "        if (s._closeRequested && !s._queue.length) s._finishClose(); else s._maybePull();\n"
+    "        return Promise.resolve({ value: queued.chunk, done: false });\n"
+    "      }\n"
+    "      if (s._state === 'closed') return Promise.resolve({ value: undefined, done: true });\n"
+    "      if (s._state === 'errored') return Promise.reject(s._storedError);\n"
+    "      return new Promise((resolve, reject) => { s._reads.push({ resolve, reject }); s._maybePull(); });\n"
+    "    }\n"
+    "    cancel(reason) {\n"
+    "      const r = readableReaders.get(this);\n"
+    "      if (!r) return Promise.reject(streamInvalidThis('ReadableStreamDefaultReader'));\n"
+    "      if (!r.stream) return Promise.reject(streamInvalidState('The reader is not attached to a stream'));\n"
+    "      return r.stream._cancelInternal(reason);\n"
+    "    }\n"
+    "    releaseLock() {\n"
+    "      const r = readableReaders.get(this);\n"
+    "      if (!r) throw streamInvalidThis('ReadableStreamDefaultReader');\n"
+    "      const s = r.stream;\n"
+    "      if (!s) return;\n"
+    "      streamRejectSlot(r, 'closed', streamInvalidState('Reader released'));\n"
+    "      const reads = s._reads; s._reads = [];\n"
+    "      const error = streamInvalidState('Releasing reader');\n"
+    "      for (const request of reads) request.reject(error);\n"
+    "      s._locked = false; s._closedResolve = s._closedReject = null; r.stream = undefined;\n"
+    "    }\n"
+    "  }\n"
+    "  for (const C of [ReadableStreamDefaultReader, ReadableStreamDefaultController]) {\n"
+    "    Object.defineProperty(C.prototype, Symbol.toStringTag, { value: C.name, configurable: true });\n"
+    "    for (const name of Object.getOwnPropertyNames(C.prototype)) if (name !== 'constructor') Object.defineProperty(C.prototype, name, { enumerable: true });\n"
+    "    g[C.name] = C;\n"
+    "  }\n"
     "\n"
     "  class ReadableStream {\n"
-    "    constructor(source, _strategy) {\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"
+    "      if (source === null || (typeof source !== 'object' && typeof source !== 'function')) {\n"
+    "        throw streamArgument('source', 'of type object', source);\n"
     "      }\n"
-    "      this._src = source;\n"
+    "      if (strategy !== undefined && strategy !== null && typeof strategy !== 'object' && typeof strategy !== 'function') throw streamArgument('strategy', 'of type object', strategy);\n"
+    "      const size = strategy?.size, mark = strategy?.highWaterMark, type = source.type;\n"
+    "      if (`${type}` === 'bytes') throw new RangeError(\"byte streams (type: 'bytes') are not supported in the scriptc island\");\n"
+    "      if (type !== undefined) throw streamError(TypeError, 'ERR_INVALID_ARG_VALUE', \"The property 'source.type' is invalid. Received \" + (typeof type === 'string' ? \"'\" + type + \"'\" : String(type)));\n"
+    "      const highWaterMark = mark === undefined ? 1 : +mark;\n"
+    "      if (Number.isNaN(highWaterMark) || highWaterMark < 0) throw streamInvalidValue('strategy.highWaterMark', highWaterMark);\n"
+    "      const sizing = streamStrategy({ size, highWaterMark }, 1);\n"
+    "      this._highWaterMark = sizing.highWaterMark;\n"
+    "      this._size = sizing.size;\n"
+    "      this._queueSize = 0;\n"
+    "      this._src = source; readableStreams.add(this);\n"
     "      this._queue = [];\n"
     "      this._state = 'readable';\n"
     "      this._storedError = undefined;\n"
@@ -121,34 +542,15 @@ static const char web_prelude[] =
     "      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"
+    "      const start = source.start, pull = source.pull, cancel = source.cancel;\n"
+    "      for (const [name, fn] of [['pull', pull], ['cancel', cancel]]) {\n"
+    "        if (fn && typeof fn !== 'function') throw streamArgument('source.' + name, 'of type function', fn);\n"
+    "      }\n"
+    "      if (start && typeof start !== 'function') throw new TypeError('Bind must be called on a function');\n"
+    "      this._pull = pull; this._cancel = cancel;\n"
+    "      this._controller = new ReadableStreamDefaultController(readableToken, this);\n"
     "      let startResult;\n"
-    "      if (source.start) startResult = source.start(this._controller); // a sync throw propagates, per spec\n"
+    "      if (start) startResult = start.call(source, 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"
@@ -156,7 +558,7 @@ static const char web_prelude[] =
     "    }\n"
     "    _finishClose() {\n"
     "      if (this._state !== 'readable') return;\n"
-    "      this._state = 'closed';\n"
+    "      this._state = 'closed'; this._pull = this._cancel = this._size = undefined;\n"
     "      const reads = this._reads;\n"
     "      this._reads = [];\n"
     "      for (const r of reads) r.resolve({ value: undefined, done: true });\n"
@@ -165,96 +567,59 @@ static const char web_prelude[] =
     "    _errorStream(e) {\n"
     "      if (this._state !== 'readable') return;\n"
     "      this._state = 'errored';\n"
-    "      this._storedError = e;\n"
-    "      this._queue.length = 0;\n"
+    "      this._storedError = e; this._pull = this._cancel = this._size = undefined;\n"
+    "      this._queue.length = 0; this._queueSize = 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"
+    "    /* Pull while demand is pending or the strategy has queue capacity. */\n"
     "    _maybePull() {\n"
     "      const src = this._src;\n"
-    "      if (!src.pull || !this._started) return;\n"
+    "      if (!this._pull || !this._started) return;\n"
     "      if (this._state !== 'readable' || this._closeRequested) return;\n"
-    "      if (this._queue.length >= 1) return;\n"
+    "      if (!this._reads.length && this._highWaterMark - this._queueSize <= 0) 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"
+    "        try { r = this._pull.call(src, 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"
+    "            if (this._pullAgain) { this._pullAgain = false; this._maybePull(); }\n"
     "          },\n"
     "          (e) => { this._pulling = false; this._errorStream(e); },\n"
     "        );\n"
     "      });\n"
     "    }\n"
-    "    get locked() { return this._locked; }\n"
+    "    get locked() { if (!readableStreams.has(this)) throw streamInvalidThis('ReadableStream'); return this._locked; }\n"
     "    cancel(reason) {\n"
-    "      if (this._locked) return Promise.reject(new TypeError('cannot cancel a locked ReadableStream'));\n"
+    "      if (!readableStreams.has(this)) return Promise.reject(streamInvalidThis('ReadableStream'));\n"
+    "      if (this._locked) return Promise.reject(streamInvalidState('ReadableStream is locked'));\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"
+    "      const cancel = this._cancel;\n"
+    "      this._queue.length = 0; this._queueSize = 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"
+    "      return writableInvoke(cancel, src, [reason]).then(() => undefined);\n"
     "    }\n"
     "    getReader(options) {\n"
-    "      if (options !== undefined && options !== null && options.mode !== undefined) {\n"
+    "      if (!readableStreams.has(this)) throw streamInvalidThis('ReadableStream');\n"
+    "      if (options !== undefined && options !== null && typeof options !== 'object' && typeof options !== 'function') throw streamArgument('options', 'of type object', options);\n"
+    "      const mode = options?.mode;\n"
+    "      if (mode !== undefined) {\n"
+    "        if (`${mode}` !== 'byob') throw streamError(TypeError, 'ERR_INVALID_ARG_VALUE', \"The property 'options.mode' is invalid. Received \" + (typeof mode === 'string' ? \"'\" + mode + \"'\" : String(mode)));\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"
+    "      return new ReadableStreamDefaultReader(this);\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"
@@ -267,7 +632,8 @@ static const char web_prelude[] =
     "     * 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"
+    "      if (!readableStreams.has(this)) throw streamInvalidThis('ReadableStream');\n"
+    "      const reader = new ReadableStreamDefaultReader(this);\n"
     "      let finished = false;\n"
     "      const it = {\n"
     "        next() {\n"
@@ -351,160 +717,312 @@ static const char web_prelude[] =
     "      });\n"
     "    }\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"
+    "      if (!readableStreams.has(this)) throw streamInvalidThis('ReadableStream');\n"
+    "      const readable = transform?.readable;\n"
+    "      if (!readableStreams.has(readable)) throw streamArgument('transform.readable', 'an instance of ReadableStream', readable);\n"
+    "      const writable = transform?.writable;\n"
+    "      if (!writableStreams.has(writable)) throw streamArgument('transform.writable', 'an instance of WritableStream', writable);\n"
+    "      const opts = pipeOptions(options); pipeLocks(this, writable);\n"
+    "      pipeStreams(this, writable, opts).catch(() => {});\n"
+    "      return readable;\n"
+    "    }\n"
+    "    pipeTo(destination, options) {\n"
+    "      try {\n"
+    "        if (!readableStreams.has(this)) throw streamInvalidThis('ReadableStream');\n"
+    "        if (!writableStreams.has(destination)) throw streamArgument('transform.writable', 'an instance of WritableStream', destination);\n"
+    "        const opts = pipeOptions(options); pipeLocks(this, destination);\n"
+    "        return pipeStreams(this, destination, opts);\n"
+    "      } catch (e) { return Promise.reject(e); }\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"
+    "      if (!readableStreams.has(this)) throw streamInvalidThis('ReadableStream');\n"
+    "      return readableTee(this);\n"
     "    }\n"
     "  }\n"
     "\n"
-    "  const pump = (rs, ws) => {\n"
-    "    const reader = rs.getReader();\n"
-    "    const writer = ws.getWriter();\n"
-    "    const step = () =>\n"
+    "  const readableTee = (source) => {\n"
+    "    const reader = new ReadableStreamDefaultReader(source);\n"
+    "    const canceled = [false, false], reasons = [], branches = [];\n"
+    "    let reading = false, resolveCancel;\n"
+    "    const cancelPromise = new Promise((resolve) => { resolveCancel = resolve; });\n"
+    "    const pull = () => {\n"
+    "      if (reading) return;\n"
+    "      reading = true;\n"
     "      reader.read().then((r) => {\n"
-    "        if (r.done) return writer.close();\n"
-    "        return writer.write(r.value).then(step);\n"
+    "        if (r.done) {\n"
+    "          // Node defers branch close until its nextTick phase; the island's\n"
+    "          // next microtask preserves final-chunk delivery before closing.\n"
+    "          Promise.resolve().then(() => {\n"
+    "            reading = false;\n"
+    "            for (let i = 0; i < 2; i++) if (!canceled[i] && branches[i]._state === 'readable' && !branches[i]._closeRequested) branches[i]._controller.close();\n"
+    "            if (!canceled[0] || !canceled[1]) resolveCancel();\n"
+    "          });\n"
+    "        } else {\n"
+    "          reading = false;\n"
+    "          for (let i = 0; i < 2; i++) if (!canceled[i] && branches[i]._state === 'readable') branches[i]._controller.enqueue(r.value);\n"
+    "        }\n"
+    "      }, () => { reading = false; });\n"
+    "    };\n"
+    "    for (let i = 0; i < 2; i++) branches.push(new ReadableStream({\n"
+    "      pull,\n"
+    "      cancel(reason) {\n"
+    "        canceled[i] = true; reasons[i] = reason;\n"
+    "        if (canceled[0] && canceled[1]) resolveCancel(source._cancelInternal([reasons[0], reasons[1]]));\n"
+    "        return cancelPromise;\n"
+    "      },\n"
+    "    }));\n"
+    "    reader.closed.catch((e) => {\n"
+    "      for (const branch of branches) branch._errorStream(e);\n"
+    "      if (!canceled[0] || !canceled[1]) resolveCancel();\n"
+    "    });\n"
+    "    return branches;\n"
+    "  };\n"
+    "\n"
+    "  const pipeOptions = (options) => {\n"
+    "    if (options !== undefined && options !== null && typeof options !== 'object' && typeof options !== 'function') throw streamArgument('options', 'of type object', options);\n"
+    "    const preventAbort = options?.preventAbort, preventCancel = options?.preventCancel, preventClose = options?.preventClose, signal = options?.signal;\n"
+    "    if (signal !== undefined && (signal === null || typeof signal !== 'object' || !('aborted' in signal))) throw streamArgument('options.signal', 'an instance of AbortSignal', signal);\n"
+    "    return { preventAbort: !!preventAbort, preventCancel: !!preventCancel, preventClose: !!preventClose, signal };\n"
+    "  };\n"
+    "  const pipeLocks = (source, dest) => {\n"
+    "    if (source._locked) throw streamInvalidState('The ReadableStream is locked');\n"
+    "    if (writableStreams.get(dest).writer !== undefined) throw streamInvalidState('The WritableStream is locked');\n"
+    "  };\n"
+    "  const pipeStreams = (source, dest, { preventClose, preventAbort, preventCancel, signal }) => {\n"
+    "    const reader = new ReadableStreamDefaultReader(source), writer = new WritableStreamDefaultWriter(dest), sink = writableStreams.get(dest);\n"
+    "    const completion = streamDeferred();\n"
+    "    let shuttingDown = false, currentWrite = Promise.resolve(), listening = false;\n"
+    "    const finalize = (rejected, error) => {\n"
+    "      writer.releaseLock(); reader.releaseLock();\n"
+    "      if (listening) signal.removeEventListener('abort', abort);\n"
+    "      if (rejected) completion.reject(error); else completion.resolve();\n"
+    "    };\n"
+    "    const waitForWrites = async () => {\n"
+    "      let write;\n"
+    "      do { write = currentWrite; await write; } while (write !== currentWrite);\n"
+    "    };\n"
+    "    const shutdown = (action, rejected = false, error) => {\n"
+    "      if (shuttingDown) return;\n"
+    "      shuttingDown = true;\n"
+    "      const waiting = sink.state === 'writable' && !sink.closeRequest ? waitForWrites() : Promise.resolve();\n"
+    "      waiting.then(() => action ? action() : undefined).then(\n"
+    "        () => finalize(rejected, error), (e) => finalize(true, e));\n"
+    "    };\n"
+    "    const abort = () => {\n"
+    "      const reason = signal.reason;\n"
+    "      shutdown(() => {\n"
+    "        const actions = [];\n"
+    "        if (!preventAbort && sink.state === 'writable') actions.push(writer.abort(reason));\n"
+    "        if (!preventCancel && source._state === 'readable') actions.push(reader.cancel(reason));\n"
+    "        return Promise.all(actions);\n"
+    "      }, true, reason);\n"
+    "    };\n"
+    "    const writeChunk = (chunk) => { currentWrite = writer.write(chunk); currentWrite.catch(() => {}); };\n"
+    "    // Buffered reads register their write before source.closed observers run. Pending\n"
+    "    // reads queue the write during enqueue, ahead of a subsequent close notification.\n"
+    "    const step = async () => {\n"
+    "      if (shuttingDown) return true;\n"
+    "      if (sink.backpressure) { await writer.ready; if (shuttingDown) return true; }\n"
+    "      if (source._state === 'readable' && source._queue.length) {\n"
+    "        while (source._queue.length) {\n"
+    "          if (shuttingDown) return true;\n"
+    "          const queued = source._queue.shift();\n"
+    "          source._queueSize = Math.max(0, source._queueSize - queued.size);\n"
+    "          if (source._closeRequested && !source._queue.length) source._finishClose();\n"
+    "          writeChunk(queued.chunk);\n"
+    "          if (sink.backpressure || sink.state !== 'writable' || sink.closeRequest) break;\n"
+    "        }\n"
+    "        source._maybePull();\n"
+    "        return source._state === 'closed';\n"
+    "      }\n"
+    "      if (source._state === 'closed') return true;\n"
+    "      if (source._state === 'errored') throw source._storedError;\n"
+    "      return new Promise((resolve, reject) => {\n"
+    "        source._reads.push({ resolve(r) {\n"
+    "          if (r.done) resolve(true);\n"
+    "          else Promise.resolve().then(() => { writeChunk(r.value); resolve(false); });\n"
+    "        }, reject });\n"
+    "        source._maybePull();\n"
     "      });\n"
-    "    step().catch((e) => {\n"
-    "      writer.abort(e).catch(() => {});\n"
-    "      reader.cancel(e).catch(() => {});\n"
+    "    };\n"
+    "    if (signal !== undefined) {\n"
+    "      if (signal.aborted) { abort(); return completion.promise; }\n"
+    "      signal.addEventListener('abort', abort, { once: true, [Symbol.for('scriptc.events.resistStopPropagation')]: true });\n"
+    "      listening = true;\n"
+    "    }\n"
+    "    (async () => { while (!await step()); })().catch(() => {});\n"
+    "    const sourceError = (e) => shutdown(preventAbort ? undefined : () => writer.abort(e), true, e);\n"
+    "    const sinkError = (e) => shutdown(preventCancel ? undefined : () => reader.cancel(e), true, e);\n"
+    "    const sourceClose = () => shutdown(preventClose ? undefined : () => {\n"
+    "      if (sink.closeRequest || sink.state === 'closed') return;\n"
+    "      if (sink.state === 'errored') throw sink.error;\n"
+    "      return writer.close();\n"
     "    });\n"
+    "    if (source._state === 'errored') sourceError(source._storedError); else reader.closed.catch(sourceError);\n"
+    "    if (sink.state === 'errored') sinkError(sink.error); else writer.closed.catch(sinkError);\n"
+    "    if (source._state === 'closed') sourceClose(); else reader.closed.then(sourceClose, () => {});\n"
+    "    if (sink.closeRequest || sink.state === 'closed') {\n"
+    "      const e = streamInvalidState('Destination WritableStream is closed');\n"
+    "      shutdown(preventCancel ? undefined : () => reader.cancel(e), true, e);\n"
+    "    }\n"
+    "    return completion.promise;\n"
     "  };\n"
     "\n"
+    "  const transformStreams = new WeakMap(), transformControllers = new WeakMap();\n"
+    "  const transformToken = Symbol('TransformStreamDefaultController');\n"
+    "  const transformPressure = (s, pressure) => {\n"
+    "    if (s.change) s.change.resolve();\n"
+    "    s.change = streamDeferred(); s.backpressure = pressure;\n"
+    "  };\n"
+    "  const transformClear = (s) => { s.transform = s.flush = s.cancel = undefined; };\n"
+    "  const transformUnblock = (s) => { if (s.backpressure) transformPressure(s, false); };\n"
+    "  const transformErrorWritable = (s, e) => {\n"
+    "    transformClear(s);\n"
+    "    const w = writableStreams.get(s.writable);\n"
+    "    if (w.state === 'writable') { writableClear(w); writableError(w, e); }\n"
+    "    transformUnblock(s);\n"
+    "  };\n"
+    "  const transformError = (s, e) => { s.readable._errorStream(e); transformErrorWritable(s, e); };\n"
+    "  const transformFinish = (s, kind, reason) => {\n"
+    "    if (s.finish) return s.finish;\n"
+    "    const d = streamDeferred(); s.finish = d.promise;\n"
+    "    const result = writableInvoke(kind === 'close' ? s.flush : s.cancel, s.transformer, kind === 'close' ? [s.controller] : [reason]);\n"
+    "    transformClear(s);\n"
+    "    result.then(() => {\n"
+    "      if (kind === 'cancel') {\n"
+    "        const w = writableStreams.get(s.writable);\n"
+    "        if (w.state === 'errored') { d.reject(w.error); return; }\n"
+    "        transformErrorWritable(s, reason);\n"
+    "      } else {\n"
+    "        if (s.readable._state === 'errored') { d.reject(s.readable._storedError); return; }\n"
+    "        if (kind === 'close') { if (s.readable._state === 'readable' && !s.readable._closeRequested) s.readable._controller.close(); }\n"
+    "        else s.readable._errorStream(reason);\n"
+    "      }\n"
+    "      d.resolve();\n"
+    "    }, (e) => {\n"
+    "      if (kind === 'cancel') transformErrorWritable(s, e); else s.readable._errorStream(e);\n"
+    "      d.reject(e);\n"
+    "    }).catch((e) => d.reject(e));\n"
+    "    return s.finish;\n"
+    "  };\n"
+    "  class TransformStreamDefaultController {\n"
+    "    constructor(token, stream) {\n"
+    "      if (token !== transformToken) throw streamError(TypeError, 'ERR_ILLEGAL_CONSTRUCTOR', 'Illegal constructor');\n"
+    "      transformControllers.set(this, stream);\n"
+    "    }\n"
+    "    get desiredSize() {\n"
+    "      const s = transformControllers.get(this);\n"
+    "      if (!s) throw streamInvalidThis('TransformStreamDefaultController');\n"
+    "      return s.readable._controller.desiredSize;\n"
+    "    }\n"
+    "    enqueue(chunk) {\n"
+    "      const s = transformControllers.get(this);\n"
+    "      if (!s) throw streamInvalidThis('TransformStreamDefaultController');\n"
+    "      const r = s.readable;\n"
+    "      if (r._state !== 'readable' || r._closeRequested) throw streamInvalidState('Unable to enqueue');\n"
+    "      try { r._controller.enqueue(chunk); }\n"
+    "      catch (e) { transformErrorWritable(s, e); throw r._storedError; }\n"
+    "      if (!r._reads.length && r._controller.desiredSize <= 0 && !s.backpressure) transformPressure(s, true);\n"
+    "    }\n"
+    "    error(e) {\n"
+    "      const s = transformControllers.get(this);\n"
+    "      if (!s) throw streamInvalidThis('TransformStreamDefaultController');\n"
+    "      transformError(s, e);\n"
+    "    }\n"
+    "    terminate() {\n"
+    "      const s = transformControllers.get(this);\n"
+    "      if (!s) throw streamInvalidThis('TransformStreamDefaultController');\n"
+    "      if (s.readable._state === 'readable' && !s.readable._closeRequested) s.readable._controller.close();\n"
+    "      transformErrorWritable(s, streamInvalidState('TransformStream has been terminated'));\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"
+    "    constructor(transformer = {}, ws, rs) {\n"
+    "      if (transformer === null || (typeof transformer !== 'object' && typeof transformer !== 'function')) throw streamArgument('transformer', 'of type object', transformer);\n"
+    "      for (const [name, value] of [['writableStrategy', ws], ['readableStrategy', rs]]) {\n"
+    "        if (value !== undefined && value !== null && typeof value !== 'object' && typeof value !== 'function') throw streamArgument(name, 'of type object', value);\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"
+    "      const readableType = transformer.readableType, writableType = transformer.writableType, start = transformer.start;\n"
+    "      if (readableType !== undefined) throw streamInvalidValue('transformer.readableType', readableType);\n"
+    "      if (writableType !== undefined) throw streamInvalidValue('transformer.writableType', writableType);\n"
+    "      const readableSizing = streamStrategy(rs, 0), writableSizing = streamStrategy(ws, 1);\n"
+    "      const s = { transformer, finish: undefined, backpressure: true };\n"
+    "      transformPressure(s, true); transformStreams.set(this, s);\n"
+    "      let resolveStart;\n"
+    "      const startGate = new Promise((resolve) => { resolveStart = resolve; });\n"
+    "      s.writable = new WritableStream({\n"
+    "        start() { return startGate; },\n"
+    "        async write(chunk) {\n"
+    "          if (s.backpressure) {\n"
+    "            await s.change.promise;\n"
+    "            const w = writableStreams.get(s.writable);\n"
+    "            if (w.state === 'erroring' || w.state === 'errored') throw w.error;\n"
+    "          }\n"
+    "          try { if (s.transform) await s.transform.call(transformer, chunk, s.controller); }\n"
+    "          catch (e) { transformError(s, e); throw e; }\n"
     "        },\n"
-    "        abort(e) { self._readable._errorStream(e); },\n"
-    "      });\n"
-    "      if (t.start) t.start(tc); // sync start, like eventsource-parser needs\n"
+    "        close() { return transformFinish(s, 'close'); },\n"
+    "        abort(reason) { return transformFinish(s, 'abort', reason); },\n"
+    "      }, writableSizing);\n"
+    "      s.readable = new ReadableStream({\n"
+    "        start() { return startGate; },\n"
+    "        pull() { transformPressure(s, false); return s.change.promise; },\n"
+    "        cancel(reason) { return transformFinish(s, 'cancel', reason); },\n"
+    "      }, readableSizing);\n"
+    "      s.controller = new TransformStreamDefaultController(transformToken, s);\n"
+    "      const transform = transformer.transform, flush = transformer.flush, cancel = transformer.cancel;\n"
+    "      for (const [name, fn] of [['transform', transform], ['flush', flush], ['cancel', cancel]]) {\n"
+    "        if (fn && typeof fn !== 'function') throw streamArgument('transformer.' + name, 'of type function', fn);\n"
+    "      }\n"
+    "      s.transform = transform || ((chunk, controller) => controller.enqueue(chunk)); s.flush = flush; s.cancel = cancel;\n"
+    "      const startResult = start === undefined ? undefined : start.call(transformer, s.controller);\n"
+    "      resolveStart(Promise.resolve(startResult).catch((e) => { transformError(s, e); throw e; }));\n"
     "    }\n"
-    "    get readable() { return this._readable; }\n"
-    "    get writable() { return this._writable; }\n"
+    "    get readable() { const s = transformStreams.get(this); if (!s) throw streamInvalidThis('TransformStream'); return s.readable; }\n"
+    "    get writable() { const s = transformStreams.get(this); if (!s) throw streamInvalidThis('TransformStream'); return s.writable; }\n"
+    "  }\n"
+    "  for (const C of [TransformStream, TransformStreamDefaultController]) {\n"
+    "    Object.defineProperty(C.prototype, Symbol.toStringTag, { value: C.name, configurable: true });\n"
+    "    for (const name of Object.getOwnPropertyNames(C.prototype)) if (name !== 'constructor') Object.defineProperty(C.prototype, name, { enumerable: true });\n"
+    "    g[C.name] = C;\n"
     "  }\n"
-    "\n"
     "  g.ReadableStream = ReadableStream;\n"
-    "  g.TransformStream = TransformStream;\n"
-    "\n"
     "\n"
+    "  const textEncoders = new WeakSet();\n"
     "  class TextEncoder {\n"
+    "    constructor() { textEncoders.add(this); }\n"
     "    get encoding() { return 'utf-8'; }\n"
+    "    encodeInto(src, dest) {\n"
+    "      const fail = (name, expected, value) => {\n"
+    "        let received;\n"
+    "        if (value === null || value === undefined) received = String(value);\n"
+    "        else if (typeof value === 'object' || typeof value === 'function') received = 'an instance of ' + (value.constructor && value.constructor.name || 'Object');\n"
+    "        else if (typeof value === 'string') received = \"type string ('\" + value + \"')\";\n"
+    "        else received = 'type ' + typeof value + ' (' + String(value) + (typeof value === 'bigint' ? 'n' : '') + ')';\n"
+    "        const error = new TypeError('The \"' + name + '\" argument must be ' + expected + '. Received ' + received);\n"
+    "        error.code = 'ERR_INVALID_ARG_TYPE'; throw error;\n"
+    "      };\n"
+    "      if (!textEncoders.has(this)) { const error = new TypeError('Value of \"this\" must be of type TextEncoder'); error.code = 'ERR_INVALID_THIS'; throw error; }\n"
+    "      if (typeof src !== 'string') fail('src', 'of type string', src);\n"
+    "      if (!(dest instanceof Uint8Array)) fail('dest', 'an instance of Uint8Array', dest);\n"
+    "      let read = 0, written = 0;\n"
+    "      while (read < src.length) {\n"
+    "        let cp = src.charCodeAt(read), units = 1;\n"
+    "        if (cp >= 0xd800 && cp <= 0xdbff) {\n"
+    "          const low = src.charCodeAt(read + 1);\n"
+    "          if (low >= 0xdc00 && low <= 0xdfff) { cp = 0x10000 + ((cp - 0xd800) << 10) + low - 0xdc00; units = 2; }\n"
+    "          else cp = 0xfffd;\n"
+    "        } else if (cp >= 0xdc00 && cp <= 0xdfff) cp = 0xfffd;\n"
+    "        const size = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;\n"
+    "        if (written + size > dest.length) break;\n"
+    "        if (size === 1) dest[written++] = cp;\n"
+    "        else if (size === 2) { dest[written++] = 0xc0 | (cp >> 6); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        else if (size === 3) { dest[written++] = 0xe0 | (cp >> 12); dest[written++] = 0x80 | ((cp >> 6) & 63); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        else { dest[written++] = 0xf0 | (cp >> 18); dest[written++] = 0x80 | ((cp >> 12) & 63); dest[written++] = 0x80 | ((cp >> 6) & 63); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        read += units;\n"
+    "      }\n"
+    "      return { read, written };\n"
+    "    }\n"
     "    encode(input) {\n"
     "      const s = input === undefined ? '' : String(input);\n"
     "      const bytes = [];\n"
@@ -608,6 +1126,37 @@ static const char web_prelude[] =
     "    }\n"
     "  }\n"
     "\n"
+    "  class TextEncoderStream {\n"
+    "    #transform;\n"
+    "    constructor() {\n"
+    "      const encoder = new TextEncoder();\n"
+    "      let pending = null;\n"
+    "      this.#transform = new TransformStream({\n"
+    "        transform(chunk, controller) {\n"
+    "          chunk = String(chunk);\n"
+    "          let text = '';\n"
+    "          for (let i = 0; i < chunk.length; i++) {\n"
+    "            const unit = chunk.charCodeAt(i), item = chunk[i];\n"
+    "            if (pending !== null) {\n"
+    "              const high = pending; pending = null;\n"
+    "              if (unit >= 0xdc00 && unit <= 0xdfff) { text += high + item; continue; }\n"
+    "              text += '\\ufffd';\n"
+    "            }\n"
+    "            if (unit >= 0xd800 && unit <= 0xdbff) pending = item;\n"
+    "            else text += unit >= 0xdc00 && unit <= 0xdfff ? '\\ufffd' : item;\n"
+    "          }\n"
+    "          if (text) controller.enqueue(encoder.encode(text));\n"
+    "        },\n"
+    "        flush(controller) { if (pending !== null) controller.enqueue(new Uint8Array([0xef, 0xbf, 0xbd])); },\n"
+    "      });\n"
+    "    }\n"
+    "    get encoding() { this.#transform; return 'utf-8'; }\n"
+    "    get readable() { return this.#transform.readable; }\n"
+    "    get writable() { return this.#transform.writable; }\n"
+    "  }\n"
+    "  for (const name of ['encoding', 'readable', 'writable']) Object.defineProperty(TextEncoderStream.prototype, name, { enumerable: true });\n"
+    "  g.TextEncoderStream = TextEncoderStream;\n"
+    "\n"
     "  class TextDecoderStream extends g.TransformStream {\n"
     "    constructor(label, options) {\n"
     "      const dec = new TextDecoder(label, options);\n"
@@ -891,13 +1440,14 @@ static const char web_prelude[] =
     "      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"
+    "      const resistant = !!(options && options[Symbol.for('scriptc.events.resistStopPropagation')]);\n"
+    "      list.push({ listener, once, resistant });\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"
+    "      if (i >= 0) list.splice(i, 1)[0].removed = true;\n"
     "    }\n"
     "    dispatchEvent(event) {\n"
     "      if (!(event instanceof Event)) throw new TypeError('The \"event\" argument must be an instance of Event.');\n"
@@ -907,7 +1457,8 @@ static const char web_prelude[] =
     "      const list = this._et[event.type];\n"
     "      if (list) {\n"
     "        for (const e of [...list]) {\n"
-    "          if (event._stopImmediate) break;\n"
+    "          if (e.removed) continue;\n"
+    "          if (event._stopImmediate && !e.resistant) continue;\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"
@@ -1054,13 +1605,16 @@ static const char web_prelude[] =
     "    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"
+    "    const ev = new Event('abort');\n"
+    "    ev.target = s; ev.currentTarget = s; ev.eventPhase = Event.AT_TARGET; ev.isTrusted = true;\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.removed) continue;\n"
+    "      if (ev._stopImmediate && !l.resistant) continue;\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"
@@ -1076,13 +1630,15 @@ static const char web_prelude[] =
     "    throwIfAborted() { if (this._aborted) throw this._reason; }\n"
     "    addEventListener(type, fn, options) {\n"
     "      if (String(type) !== 'abort' || typeof fn !== 'function') return;\n"
+    "      if (this._listeners.some(l => l.fn === fn)) return;\n"
     "      const once = options !== undefined && options !== null && !!options.once;\n"
-    "      this._listeners.push({ fn, once });\n"
+    "      const resistant = !!(options && options[Symbol.for('scriptc.events.resistStopPropagation')]);\n"
+    "      this._listeners.push({ fn, once, resistant });\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"
+    "      if (i >= 0) this._listeners.splice(i, 1)[0].removed = true;\n"
     "    }\n"
     "    static abort(reason) {\n"
     "      const s = mkSignal();\n"
@@ -1633,7 +2189,6 @@ static void web_timer_fire_cb(ScrClosure *env) {
 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;
@@ -1649,17 +2204,45 @@ static JSValue web_host_set_timer(JSContext *ctx, JSValueConst this_val,
   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);
+  bool immediate = argc > 3 && JS_ToBool(ctx, argv[3]) > 0;
+  double id = immediate ? scr_set_immediate(cb)
+                        : 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;
+  double id = 0;
+  if (JS_ToFloat64(ctx, &id, argv[0])) return JS_EXCEPTION;
+  if (argc > 1 && JS_ToBool(ctx, argv[1]) > 0) scr_clear_immediate(id);
+  else scr_clear_interval(id);
+  return JS_UNDEFINED;
+}
+
+static JSValue web_host_ref_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;
+  bool reffed = JS_ToBool(ctx, argv[1]) > 0;
+  bool immediate = JS_ToBool(ctx, argv[2]) > 0;
+  if (immediate) {
+    if (reffed) scr_immediate_ref(id); else scr_immediate_unref(id);
+  } else {
+    if (reffed) scr_timer_ref(id); else scr_timer_unref(id);
+  }
+  return JS_UNDEFINED;
+}
+
+static JSValue web_host_refresh_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);
+  scr_timer_refresh(id);
   return JS_UNDEFINED;
 }
 
@@ -1837,8 +2420,10 @@ void scr_island_web_boot(void *jsctx) {
   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));
+  JS_SetPropertyStr(ctx, host, "setTimer", JS_NewCFunction(ctx, web_host_set_timer, "setTimer", 4));
+  JS_SetPropertyStr(ctx, host, "clearTimer", JS_NewCFunction(ctx, web_host_clear_timer, "clearTimer", 2));
+  JS_SetPropertyStr(ctx, host, "refTimer", JS_NewCFunction(ctx, web_host_ref_timer, "refTimer", 3));
+  JS_SetPropertyStr(ctx, host, "refreshTimer", JS_NewCFunction(ctx, web_host_refresh_timer, "refreshTimer", 1));
   JSValue r = JS_Call(ctx, fn, JS_UNDEFINED, 1, (JSValueConst *)&host);
   JS_FreeValue(ctx, host);
   JS_FreeValue(ctx, fn);