@statewalker/webrun-http-browser 0.3.3 → 0.4.2

package/dist/index.js

@@ -1,820 +1,2683 @@
-// @statewalker/webrun-http-browser v0.3.3 https://github.com/statewalker/statewalker-webrun-http-browser Copyright 2023 Mikhail Kotelnikov
+//#region ../webrun-streams/dist/index.js
+/** Collect all items from an async iterable into an array. */
+async function collect(input) {
+	const items = [];
+	for await (const item of input) items.push(item);
+	return items;
+}
+/** Concatenate all Uint8Array chunks into a single Uint8Array. */
+async function collectBytes(input) {
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of input) {
+		chunks.push(chunk);
+		total += chunk.length;
+	}
+	if (chunks.length === 1) return chunks[0] ?? /* @__PURE__ */ new Uint8Array(0);
+	const result = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+/** Concatenate all string chunks into a single string. */
+async function collectString(input) {
+	let result = "";
+	for await (const chunk of input) result += chunk;
+	return result;
+}
+/**
+* Thrown by `emulateMux` and adapters when the underlying transport closes
+* while one or more `Duplex` calls are in flight. Consumers can catch by
+* `instanceof TransportClosedError` or by checking `error.name`.
+*/
+var TransportClosedError = class extends Error {
+	name = "TransportClosedError";
+	constructor(message = "transport closed") {
+		super(message);
+	}
+};
 function serializeError(error) {
-  return Object.assign({
-    message: error,
-    stack: error.stack,
-  }, error);
+	if (error instanceof Error) {
+		const out = {
+			message: error.message,
+			stack: error.stack
+		};
+		const bag = error;
+		for (const key of Object.keys(bag)) out[key] = bag[key];
+		return out;
+	}
+	if (typeof error === "object" && error !== null) {
+		const bag = error;
+		return {
+			message: String(bag.message ?? error),
+			...bag
+		};
+	}
+	return { message: String(error) };
 }
-
 function deserializeError(error) {
-  if (typeof error === "string") {
-    error = { message: error };
-  }
-  return Object.assign(new Error(error.message), error);
-}
-
-async function callChannel(mainChannel, callType, params, ...transfers) {
-  return new Promise((resolve, reject) => {
-    const channel = new MessageChannel();
-    channel.port1.onmessage = (ev) => {
-      const { result, error } = ev.data;
-      if (error) reject(deserializeError(error));
-      else resolve(result);
-    };
-    mainChannel.postMessage({ type: callType, params }, [
-      channel.port2,
-      ...transfers,
-    ]);
-  });
-}
-
-function handleChannelCalls(mainChannel, callType, handler) {
-  const messageListener = async (event) => {
-    if (!event.data || event.data.type !== callType) return;
-    const [port, ...transfers] = event.ports;
-    let response = {};
-    try {
-      const params = event.data.params;
-      response.result = await handler(event, params, ...transfers);
-    } catch (error) {
-      response.error = serializeError(error);
-    }
-    port.postMessage(response);
-  };
-  mainChannel.addEventListener("message", messageListener);
-  try {
-    mainChannel.start && mainChannel.start();
-  } catch (e) {}
-  return () => mainChannel.removeEventListener("message", messageListener);
-}
-
-// See https://github.com/agenjs/agen-utils/blob/main/src/iterator.js
-async function* iterate(init, queue = []) {
-  let promise, notify, push = async (error, value, done) => {
-    const slot = { error, value, done };
-    slot.promise = new Promise(n => slot.notify = n);
-    await queue.push(slot);
-    notify && notify();
-    notify = null;
-    return slot.promise;
-  };
-  const next = (value) => push(undefined, value, false);
-  const complete = () => push(undefined, undefined, true);
-  const error = err => push(err, undefined, true);
-  const unsubscribe = init(Object.assign([next, complete, error], { next, complete, error }));
-  let slot;
-  try {
-    while (true) {
-      slot = await queue.shift();
-      if (slot) {
-        try {
-          if (slot.error) { throw slot.error; }
-          else if (slot.done) { break; }
-          else { yield slot.value; }
-        } finally {
-          slot.notify(true);
-        }
-      } else {
-        await (promise = notify ? promise : new Promise(n => notify = n));
-      }
-    }
-  } finally {
-    notify && notify();
-    push = () => false; // Stop pushing in the queue...
-    ((typeof unsubscribe === 'function') && (await unsubscribe()));
-    while (slot = await queue.shift()) { slot.notify(false); }
-  }
-}
-
-function newRegistry(onError = console.error) {
-  let counter = 0;
-  const registrations = {};
-  const register = (action) => {
-    const id = counter++;
-    return (registrations[id] = Object.assign(
-      function (skip) {
-        try {
-          delete registrations[id];
-          return !skip && action && action();
-        } catch (error) {
-          onError(error);
-        }
-      },
-      { action }
-    ));
-  };
-  const unregister = (action) =>
-    Object.values(registrations).forEach((r) => r.action === action && r(true));
-  const clear = () => Object.values(registrations).forEach((r) => r());
-  return Object.assign([register, clear, unregister], {
-    register,
-    clear,
-    unregister
-  });
-}
-
-async function* recieveData(onMessage) {
-  yield* iterate((iterator) => {
-    return onMessage(async ({ done = true, value, error } = {}) => {
-      if (error) {
-        await iterator.error(error);
-      } else if (done) {
-        await iterator.complete();
-      } else {
-        await iterator.next(value);
-      }
-    });
-  });
-}
-
-async function sendData(send, it) {
-  let error;
-  try {
-    for await (let value of it) {
-      await send({ done: false, value });
-    }
-  } catch (err) {
-    error = err;
-  } finally {
-    await send({ done: true, error });
-  }
-}
-
-async function* sendStream(communicationPort, input, params = {}) {
-  const messageChannel = new MessageChannel();
-  communicationPort.postMessage({ type: "START_CALL", params }, [
-    messageChannel.port2,
-  ]);
-
-  const channel = newChannel(messageChannel.port1);
-  try {
-    await channel.start();
-    channel.sendAll(input);
-    yield* channel.recieveAll();
-  } finally {
-    await channel.close();
-  }
-}
-
-function handleStreams(communicationPort, handler) {
-  const listener = async (event) => {
-    const { type, params } = event.data || {};
-    if (type !== "START_CALL") return;
-    const port = event.ports[0];
-    const channel = newChannel(port);
-    try {
-      await channel.start();
-      const input = channel.recieveAll();
-      const response = await handler(input, params);
-      await channel.sendAll(response);
-    } finally {
-      await channel.close();
-    }
-  };
-  communicationPort.addEventListener("message", listener);
-  try {
-    communicationPort.start && communicationPort.start();
-  } catch (e) {}
-  return () => communicationPort.removeEventListener("message", listener);
-}
-
-/**
- * This method creates and returns methods allowing to send and recieve data over the specified port.
- * The main characteristics of the returned methods is that they properly manage backpressure - sender
- * iterators are waiting to send the next value until the previous one is consumed on the other side.
- * @param {*} port
- * @returns an object with the following methods:
- *  * `start` - starts the connection over the specified port
- *  * `close`- stops all iterators and closes the port
- *  * `recieveAll() : AsyncIterator` - returns an AsyncIterator over all values send by the peer
- *  * `sendAll(it : AsyncIterator) : Promise<any>` - sends all values defined by the given
- *     AsyncIterator to the peer
- */
-function newChannel(port) {
-  let listeners = [];
-  let iterators = [];
-
-  const notifyAll = async (data) => {
-    for (let listener of listeners) {
-      await listener(data);
-    }
-  };
-  const channel = newInvokationChannel({
-    port,
-    handler: notifyAll,
-  });
-
-  const start = () => channel.start();
-
-  const close = async () => {
-    await notifyAll({ done: true });
-    [...iterators].forEach((it) => it.return && it.return());
-    await channel.close();
-  };
-
-  async function* recieveAll() {
-    yield* recieveData((listener) => {
-      listeners.push(listener);
-      return () => listeners = listeners.filter((l) => l !== listener);
-    });
-  }
-
-  async function sendAll(it) {
-    await sendData(
-      channel.invoke,
-      (async function* () {
-        try {
-          iterators.push(it);
-          yield* it;
-        } finally {
-          iterators = iterators.filter((i) => i !== it);
-        }
-      })(),
-    );
-  }
-  return {
-    start,
-    close,
-    recieveAll,
-    sendAll,
-  };
-}
-
-function newInvokationChannel({
-  port,
-  handler = () => {
-    throw new Error("Handler not implemented");
-  },
-  onError = console.error,
-  newCallId = () =>
-    newInvokationChannel.__counter = (newInvokationChannel.__counter || 0) + 1,
-}) {
-  const MESSAGE_TYPE_REQUEST = "REQUEST";
-  const MESSAGE_TYPE_RESPONSE = "RESPONSE";
-  const EVENT_MESSAGE = "message";
-
-  const requests = {};
-  const listener = async (event) => {
-    const data = event.data || {};
-    const { type, callId } = data;
-    if (type === MESSAGE_TYPE_REQUEST) {
-      try {
-        const { request } = data;
-        let result = await handler(request, ...(event.ports || []));
-        const [response, ...transfers] = Array.isArray(result)
-          ? result
-          : result !== undefined
-          ? [result]
-          : [];
-        port.postMessage(
-          { type: MESSAGE_TYPE_RESPONSE, callId, response },
-          transfers,
-        );
-      } catch (error) {
-        port.postMessage({
-          type: MESSAGE_TYPE_RESPONSE,
-          callId,
-          error: serializeError(error),
-        });
-      }
-    } else if (type === MESSAGE_TYPE_RESPONSE) {
-      const { callId, response, error } = data;
-      const request = requests[callId];
-      delete requests[callId];
-      if (request) {
-        error
-          ? request.reject(deserializeError(error))
-          : request.resolve(response);
-      }
-    }
-  };
-
-  const start = async () => {
-    try {
-      port.addEventListener(EVENT_MESSAGE, listener);
-      port.start && await port.start();
-    } catch (e) {
-      onError(e);
-    }
-  };
-
-  const close = async () => {
-    try {
-      port.removeEventListener(EVENT_MESSAGE, listener);
-      port.close && await port.close();
-    } catch (e) {
-      onError(e);
-    }
-  };
-
-  const invoke = async function (request = {}, ...transfers) {
-    const callId = newCallId();
-    return new Promise((resolve, reject) => {
-      try {
-        requests[callId] = { resolve, reject };
-        port.postMessage(
-          { type: MESSAGE_TYPE_REQUEST, callId, request },
-          transfers,
-        );
-      } catch (error) {
-        reject(error);
-        delete request[callId];
-      }
-    });
-  };
-
-  return {
-    start,
-    close,
-    invoke,
-  };
-}
-
+	const payload = typeof error === "string" ? { message: error } : error;
+	return Object.assign(new Error(payload.message), payload);
+}
+function newCreditLedger(initial = 0) {
+	let available = initial;
+	let failure;
+	const waiters = [];
+	const pump = () => {
+		while (waiters.length > 0 && available > 0) {
+			const next = waiters[0];
+			if (!next) return;
+			waiters.shift();
+			const granted = Math.min(next.upTo, available);
+			available -= granted;
+			next.resolve(granted);
+		}
+	};
+	return {
+		get available() {
+			return available;
+		},
+		reserve(upTo) {
+			if (failure) return Promise.reject(failure);
+			if (!(upTo >= 1)) return Promise.reject(/* @__PURE__ */ new RangeError(`newCreditLedger: reserve(${upTo}) — upTo must be at least 1`));
+			if (waiters.length === 0 && available > 0) {
+				const granted = Math.min(upTo, available);
+				available -= granted;
+				return Promise.resolve(granted);
+			}
+			return new Promise((resolve, reject) => {
+				waiters.push({
+					upTo,
+					resolve,
+					reject
+				});
+			});
+		},
+		grant(units) {
+			if (failure) return;
+			available += units;
+			pump();
+		},
+		fail(err) {
+			failure ??= err;
+			while (waiters.length > 0) waiters.shift()?.reject(err);
+		}
+	};
+}
+/**
+* Grants are batched: replenishing on every chunk while the receiver is
+* behind would reinvent the per-frame ACK this change exists to remove.
+* `threshold` is the fraction of the window that must drain before a grant is
+* emitted.
+*
+* The batch is flushed unconditionally once the receive queue is empty, even
+* below the threshold, so the receiver never sits on credit it owes. Note what
+* this is and is not: paired with a {@link CreditLedger}, a sender blocks only
+* at *exactly* zero credit, and at that point the receiver holds the entire
+* window as `pending` — above any threshold at or below the whole window — so
+* the threshold alone cannot deadlock that pairing. The flush is what keeps
+* that from being an argument about a global accounting identity: it is
+* locally decidable from one boolean, and it returns owed credit now rather
+* than at the next threshold crossing. It costs an extra frame only when the
+* consumer is keeping pace, which is exactly when the sender is not blocked
+* and the frame is cheap.
+*/
+function newCreditGrantor(window, threshold = .5) {
+	const trigger = Math.max(1, Math.floor(window * threshold));
+	let pending = 0;
+	return { consumed(units, queueEmpty) {
+		pending += units;
+		if (pending === 0) return 0;
+		if (pending < trigger && !queueEmpty) return 0;
+		const grant = pending;
+		pending = 0;
+		return grant;
+	} };
+}
+/**
+* Credit payloads are a single big-endian uint32, matching the frame header's
+* byte order.
+*
+* Deliberately **not** re-exported from `index.ts`: this is an internal codec
+* for the `emulateMux` wire format, not a compatibility commitment. Tests
+* import it by path.
+*/
+/** The largest credit a single frame can advertise or grant: 2^32 - 1. */
+const MAX_UINT32 = 4294967295;
+/**
+* Clamps rather than wraps. `n >>> 0` is the obvious spelling and it is wrong
+* here: 2^32 becomes **0**, so a 4 GiB window advertises *zero credit* and the
+* peer stalls forever with no error — the exact silent hang credit exists to
+* remove. 2^32 + 5 becomes 5, which looks like a working window and is worse.
+* Anything above the ceiling is advertised as the ceiling.
+*/
+function encodeUint32(n) {
+	const bytes = /* @__PURE__ */ new Uint8Array(4);
+	const clamped = Number.isFinite(n) ? Math.min(MAX_UINT32, Math.max(0, Math.floor(n))) : 0;
+	new DataView(bytes.buffer).setUint32(0, clamped, false);
+	return bytes;
+}
+/**
+* Returns `undefined` rather than a garbage number when the payload is too
+* short, so a truncated frame — or one from a peer predating credit — is
+* detectable at the call site instead of silently granting nonsense.
+*/
+function decodeUint32(bytes) {
+	if (bytes.byteLength < 4) return void 0;
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, false);
+}
+const TYPE_OPEN = 1;
+const TYPE_DATA = 2;
+const TYPE_ACK = 3;
+const TYPE_END = 4;
+const TYPE_ERROR = 5;
+const TYPE_CLOSE = 6;
+const DEFAULT_MAX_STREAMS = 256;
+const DEFAULT_MTU = 65536;
+const DEFAULT_MAX_STREAM_BUFFER = 8388608;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function emulateMux(channel, opts = {}) {
+	const maxStreams = opts.maxStreams ?? DEFAULT_MAX_STREAMS;
+	const mtu = opts.mtu ?? DEFAULT_MTU;
+	const maxStreamBuffer = opts.maxStreamBuffer ?? DEFAULT_MAX_STREAM_BUFFER;
+	if (!(maxStreamBuffer >= 1)) throw new RangeError(`emulateMux: maxStreamBuffer must be at least 1, got ${maxStreamBuffer}`);
+	const side = opts.side ?? "initiator";
+	const streams = /* @__PURE__ */ new Map();
+	let nextLocalId = side === "initiator" ? 2 : 1;
+	let handler = null;
+	let muxClosed = false;
+	const sendFrame = (id, type, payload) => {
+		if (muxClosed) return;
+		const idEnc = encodeVarint(id);
+		const total = idEnc.length + 1 + (payload?.byteLength ?? 0);
+		const frame = new Uint8Array(total);
+		frame.set(idEnc, 0);
+		frame[idEnc.length] = type;
+		if (payload && payload.byteLength > 0) frame.set(payload, idEnc.length + 1);
+		try {
+			channel.send(frame);
+		} catch {}
+	};
+	const teardownStream = (s, err) => {
+		if (s.closed) return;
+		s.closed = true;
+		s.outboundCredit.fail(err ?? new TransportClosedError("emulateMux: stream closed"));
+		s.doneIn(err);
+		s.cancelInput?.();
+		streams.delete(s.id);
+	};
+	/**
+	* Graceful counterpart to `teardownStream`. A stream occupies a slot in
+	* `streams` until BOTH directions finish; releasing on inbound END alone
+	* would set `closed` while our own `pumpOutbound` is still sending, and it
+	* checks that flag to decide whether to keep going.
+	*
+	* Without this, only abnormal endings (cancel, ERROR, CLOSE, transport
+	* failure) ever freed a slot, so every normally-completed call leaked one
+	* until `maxStreams` began rejecting new calls.
+	*/
+	const releaseIfComplete = (s) => {
+		if (s.closed || !s.inDone || !s.outDone) return;
+		s.closed = true;
+		streams.delete(s.id);
+	};
+	const failAll = (err) => {
+		if (muxClosed) return;
+		muxClosed = true;
+		for (const s of [...streams.values()]) teardownStream(s, err);
+		streams.clear();
+	};
+	const createStream = (id) => {
+		const queue = makeInboundQueue();
+		const state = {
+			id,
+			inbound: queue.generator(() => {
+				if (!state.closed && !muxClosed) sendFrame(state.id, TYPE_CLOSE);
+				teardownStream(state);
+			}),
+			pushIn: queue.push,
+			doneIn: queue.done,
+			outboundCredit: newCreditLedger(0),
+			grantor: newCreditGrantor(maxStreamBuffer),
+			closed: false,
+			inDone: false,
+			outDone: false,
+			queuedBytes: 0
+		};
+		return state;
+	};
+	const pumpOutbound = async (s, input) => {
+		const iterator = input[Symbol.asyncIterator]?.() ?? input[Symbol.iterator]();
+		s.cancelInput = () => {
+			iterator.return?.(void 0);
+		};
+		try {
+			for (;;) {
+				const next = await iterator.next();
+				if (next.done === true) break;
+				const chunk = next.value;
+				if (s.closed || muxClosed) return;
+				if (chunk.byteLength === 0) continue;
+				let off = 0;
+				while (off < chunk.byteLength) {
+					if (s.closed || muxClosed) return;
+					const take = await s.outboundCredit.reserve(Math.min(mtu, chunk.byteLength - off));
+					if (s.closed || muxClosed) return;
+					const end = off + take;
+					sendFrame(s.id, TYPE_DATA, chunk.subarray(off, end));
+					off = end;
+				}
+			}
+			if (!s.closed && !muxClosed) {
+				sendFrame(s.id, TYPE_END);
+				s.outDone = true;
+				releaseIfComplete(s);
+			}
+		} catch (err) {
+			if (!s.closed && !muxClosed) {
+				const e = err instanceof Error ? err : new Error(String(err));
+				sendFrame(s.id, TYPE_ERROR, encodeError(e));
+				teardownStream(s, e);
+			}
+		}
+	};
+	const runHandler = async (s, h) => {
+		let outbound;
+		try {
+			outbound = h(s.inbound);
+		} catch (err) {
+			const e = err instanceof Error ? err : new Error(String(err));
+			sendFrame(s.id, TYPE_ERROR, encodeError(e));
+			teardownStream(s, e);
+			return;
+		}
+		await pumpOutbound(s, outbound);
+		if (!s.inDone && !s.closed && !muxClosed) {
+			sendFrame(s.id, TYPE_CLOSE);
+			teardownStream(s);
+		}
+	};
+	const handleFrame = (frame) => {
+		if (muxClosed) return;
+		if (frame.byteLength < 2) return;
+		let id;
+		let offset;
+		try {
+			({value: id, offset} = decodeVarint(frame, 0));
+		} catch {
+			return;
+		}
+		if (offset >= frame.byteLength) return;
+		const type = frame[offset];
+		const payload = frame.subarray(offset + 1);
+		if (type === TYPE_OPEN) {
+			if (streams.has(id)) return;
+			if (streams.size >= maxStreams) {
+				sendFrame(id, TYPE_ERROR, encodeError(/* @__PURE__ */ new RangeError(`emulateMux: maxStreams=${maxStreams} exceeded`)));
+				return;
+			}
+			if (!handler) {
+				sendFrame(id, TYPE_ERROR, encodeError(/* @__PURE__ */ new Error("emulateMux: no handler registered")));
+				return;
+			}
+			const s = createStream(id);
+			streams.set(id, s);
+			const advertised = decodeUint32(payload);
+			if (advertised !== void 0) s.outboundCredit.grant(advertised);
+			sendFrame(id, TYPE_ACK, encodeUint32(maxStreamBuffer));
+			runHandler(s, handler);
+			return;
+		}
+		const s = streams.get(id);
+		if (!s) return;
+		switch (type) {
+			case TYPE_DATA: {
+				s.queuedBytes += payload.byteLength;
+				if (s.queuedBytes > maxStreamBuffer) {
+					const err = /* @__PURE__ */ new RangeError(`emulateMux: stream ${id} buffered ${s.queuedBytes} bytes past maxStreamBuffer=${maxStreamBuffer} without being drained`);
+					sendFrame(id, TYPE_ERROR, encodeError(err));
+					teardownStream(s, err);
+					return;
+				}
+				const copy = payload.byteLength === 0 ? payload : new Uint8Array(payload);
+				s.pushIn(copy).then((handled) => {
+					s.queuedBytes -= copy.byteLength;
+					if (!handled || s.closed || muxClosed) return;
+					const grant = s.grantor.consumed(copy.byteLength, s.queuedBytes === 0);
+					if (grant > 0) sendFrame(id, TYPE_ACK, encodeUint32(grant));
+				});
+				return;
+			}
+			case TYPE_ACK: {
+				const granted = decodeUint32(payload);
+				if (granted !== void 0) s.outboundCredit.grant(granted);
+				return;
+			}
+			case TYPE_END:
+				s.inDone = true;
+				s.doneIn();
+				releaseIfComplete(s);
+				return;
+			case TYPE_ERROR:
+				teardownStream(s, decodeError(payload));
+				return;
+			case TYPE_CLOSE:
+				teardownStream(s);
+				return;
+			default: return;
+		}
+	};
+	(async () => {
+		try {
+			for await (const frame of channel.recv) {
+				if (muxClosed) break;
+				handleFrame(frame);
+			}
+		} catch (err) {
+			failAll(err instanceof Error ? err : new Error(String(err)));
+			return;
+		}
+		failAll(new TransportClosedError());
+	})();
+	channel.closed.then(() => failAll(new TransportClosedError())).catch(() => {});
+	const call = (input) => {
+		if (muxClosed) return failedGenerator(new TransportClosedError());
+		if (streams.size >= maxStreams) return failedGenerator(/* @__PURE__ */ new RangeError(`emulateMux: maxStreams=${maxStreams} exceeded`));
+		const id = nextLocalId;
+		nextLocalId += 2;
+		const s = createStream(id);
+		streams.set(id, s);
+		sendFrame(id, TYPE_OPEN, encodeUint32(maxStreamBuffer));
+		pumpOutbound(s, input);
+		return s.inbound;
+	};
+	const serve = (h) => {
+		handler = h;
+		let torn = false;
+		return async () => {
+			if (torn) return;
+			torn = true;
+			if (handler === h) handler = null;
+		};
+	};
+	const close = async () => {
+		if (muxClosed) return;
+		failAll(new TransportClosedError());
+		try {
+			channel.close();
+		} catch {}
+	};
+	return {
+		call,
+		serve,
+		close
+	};
+}
+function failedGenerator(err) {
+	return (async function* () {
+		throw err;
+	})();
+}
+/**
+* Push/pull queue with eager push/done handles. Unlike `newAsyncGenerator`, the
+* push and done functions are usable *before* the consumer begins iterating —
+* `emulateMux` needs to enqueue frames from inbound traffic regardless of when
+* (or whether) the consumer pulls them.
+*
+* `onCancel` fires only when the consumer terminates the generator before
+* `done()` was called — i.e., a unilateral cancellation. If `done()` is
+* called first (peer END/ERROR/CLOSE), the generator ends naturally and
+* `onCancel` does not fire.
+*/
+function makeInboundQueue() {
+	const slots = [];
+	let wake = null;
+	let queueClosed = false;
+	let doneCalled = false;
+	const push = (chunk) => {
+		if (queueClosed) return Promise.resolve(false);
+		return new Promise((resolve) => {
+			slots.push({
+				type: "value",
+				value: chunk,
+				resolve
+			});
+			wake?.();
+		});
+	};
+	const done = (err) => {
+		if (queueClosed || doneCalled) return Promise.resolve(false);
+		doneCalled = true;
+		return new Promise((resolve) => {
+			slots.push({
+				type: "done",
+				err,
+				resolve
+			});
+			wake?.();
+		});
+	};
+	async function* generator(onCancel) {
+		try {
+			while (true) {
+				if (slots.length === 0) {
+					await new Promise((r) => {
+						wake = r;
+					});
+					wake = null;
+					continue;
+				}
+				const slot = slots.shift();
+				if (slot.type === "done") {
+					slot.resolve(true);
+					if (slot.err) throw slot.err;
+					return;
+				}
+				yield slot.value;
+				slot.resolve(true);
+			}
+		} finally {
+			queueClosed = true;
+			for (const s of slots) s.resolve(false);
+			slots.length = 0;
+			if (!doneCalled) onCancel();
+		}
+	}
+	return {
+		generator,
+		push,
+		done
+	};
+}
+function encodeVarint(value) {
+	if (!Number.isInteger(value) || value < 0) throw new RangeError(`encodeVarint: ${value} is not a non-negative integer`);
+	const out = [];
+	let v = value;
+	while (v >= 128) {
+		out.push(v & 127 | 128);
+		v >>>= 7;
+	}
+	out.push(v & 127);
+	return new Uint8Array(out);
+}
+function decodeVarint(buf, start) {
+	let value = 0;
+	let shift = 0;
+	let i = start;
+	while (i < buf.length) {
+		const b = buf[i++];
+		value |= (b & 127) << shift;
+		if ((b & 128) === 0) return {
+			value: value >>> 0,
+			offset: i
+		};
+		shift += 7;
+		if (shift > 28) throw new Error("decodeVarint: too long");
+	}
+	throw new Error("decodeVarint: truncated");
+}
+function encodeError(err) {
+	return textEncoder.encode(JSON.stringify(serializeError(err)));
+}
+function decodeError(buf) {
+	if (buf.byteLength === 0) return /* @__PURE__ */ new Error("unknown stream error");
+	try {
+		return deserializeError(JSON.parse(textDecoder.decode(buf)));
+	} catch {
+		return new Error(textDecoder.decode(buf));
+	}
+}
+/** Split a stream of string chunks into individual lines (delimited by \n). */
+async function* splitLines(input) {
+	let buffer = "";
+	for await (const chunk of input) {
+		buffer += chunk;
+		let idx = buffer.indexOf("\n");
+		while (idx !== -1) {
+			yield buffer.slice(0, idx);
+			buffer = buffer.slice(idx + 1);
+			idx = buffer.indexOf("\n");
+		}
+	}
+	if (buffer) yield buffer;
+}
+/** Append \n to each string in the stream. */
+async function* joinLines(input) {
+	for await (const line of input) yield `${line}\n`;
+}
+/** Apply a sync or async function to each item in a stream. */
+async function* map(input, fn) {
+	for await (const item of input) yield await fn(item);
+}
+/** Encode each value as a JSON line (terminated by \n). */
+async function* encodeJsonl(input) {
+	yield* map(input, (item) => `${JSON.stringify(item)}\n`);
+}
+/** Decode each line as a JSON value. Skips empty lines. */
+async function* decodeJsonl(input) {
+	for await (const line of splitLines(input)) {
+		const trimmed = line.trim();
+		if (trimmed) yield JSON.parse(trimmed);
+	}
+}
+/**
+* The newAsyncGenerator function creates async generators from callback-based initialization
+* functions, providing a bridge between imperative event handling and declarative async
+* iteration patterns.
+*
+* The initialization function receives two callback functions that control the generator's
+* behavior. The `next` function yields values to consumers, while the `done` function
+* signals completion or error conditions. The initialization function can return a cleanup
+* function that will be called when the generator is closed or an error occurs.
+*
+* The generator manages an internal queue of values and completion signals, ensuring that
+* producers can yield values without overwhelming consumers. Proper backpressure is implemented
+* by having the `next` and `done` functions return promises that resolve only after the
+* consumer has processed the values. This prevents memory leaks and ensures that producers
+* are aware of whether their values were successfully handled.
+* The generator also handles cleanup by draining any remaining items in the queue and notifying
+* producers that their values were not processed if the generator is closed early. This ensures
+* that resources are properly managed and that no memory leaks occur.
+*
+* Example usage:
+* ```typescript
+* const asyncGen = newAsyncGenerator<number>((next, done) => {
+*   let count = 0;
+*   const interval = setInterval(() => {
+*     if (count < 5) {
+*       next(count++);
+*     } else {
+*       done();
+*       clearInterval(interval);
+*     }
+*   }, 1000);
+*   return () => clearInterval(interval); // Cleanup function
+* });
+* (async () => {
+*   for await (const num of asyncGen) {
+*     console.log(num); // Logs numbers 0 to 4 at 1 second intervals
+*   }
+*   console.log("Completed");
+* })();
+* ```
+* @template T The type of values yielded by the generator
+* @template E The type of errors that can be thrown; defaults to Error
+* @param init Initialization function that sets up the generator behavior with next/done callbacks;
+*  The first parameter - `next` function - is used to yield values to consumers;
+*  It returns a Promise<boolean> indicating whether the value was successfully handled;
+*  The second parameter - `done` function - is used to signal completion or error;
+*  It returns a Promise<boolean> indicating whether the completion was successfully handled;
+*  The initialization function can optionally return a cleanup function that will be called
+*  when the generator is closed or an error occurs;
+* @param skipValues If true, only the most recent value is kept in the queue,
+* skipping intermediate values (not consumed values are considered skipped);
+* This is useful for scenarios where only the latest value matters, such as UI updates.
+* Defaults to false, meaning all values are queued and processed in order.
+* @returns AsyncGenerator that properly manages backpressure and resource cleanup
+*/
+async function* newAsyncGenerator(init, skipValues = false) {
+	let head;
+	let tail;
+	/** Flag to prevent new values from being queued after generator closes */
+	let closed = false;
+	/** Wake-up function to notify the generator loop of new items */
+	let wakeUp;
+	/**
+	* Drains the internal queue, notifying all pending producers that their values
+	* were not processed due to generator closure. This prevents memory leaks and
+	* ensures proper backpressure signaling.
+	*/
+	const drainQueue = () => {
+		for (; head; head = head.next) {
+			closed = closed || head.done;
+			head.resolve(false);
+		}
+		tail = void 0;
+	};
+	/**
+	* Enqueues a value or completion signal with a promise that resolves when the item
+	* is processed. This enables backpressure by allowing producers to know when their
+	* values have been consumed.
+	*/
+	const enqueue = (params) => {
+		if (skipValues) drainQueue();
+		return !closed ? new Promise((resolve) => {
+			const next = {
+				...params,
+				next: void 0,
+				resolve
+			};
+			if (tail) tail.next = next;
+			tail = next;
+			if (!head) head = tail;
+			wakeUp?.();
+		}) : Promise.resolve(false);
+	};
+	/**
+	* Producer function to yield a value to consumers. Returns a promise that resolves
+	* to true if the value was successfully processed, false if the generator is closed
+	* or the value was skipped due to backpressure.
+	*/
+	const next = (value) => enqueue({
+		done: false,
+		value
+	});
+	/**
+	* Producer function to signal completion or error. Optional error parameter will
+	* cause the generator to throw that error to consumers.
+	*/
+	const done = (error) => enqueue({
+		done: true,
+		error
+	});
+	const unsubscribe = init(next, done);
+	try {
+		while (!closed) {
+			if (!head) {
+				await new Promise((resolve) => {
+					wakeUp = resolve;
+				}).then(() => {
+					wakeUp = void 0;
+				});
+				continue;
+			}
+			const slot = head;
+			head = head.next;
+			if (tail === slot) tail = head;
+			try {
+				if (slot.done) {
+					closed = true;
+					if (slot.error !== void 0) throw slot.error;
+					break;
+				}
+				yield slot.value;
+			} finally {
+				slot.resolve(true);
+			}
+		}
+	} finally {
+		/**
+		* Cleanup phase - ensures proper resource management and notification of any
+		* remaining producers. This runs whether the generator completes normally,
+		* encounters an error, or is closed early by the consumer.
+		*/
+		closed = true;
+		wakeUp?.();
+		if (typeof unsubscribe === "function") await unsubscribe();
+		/**
+		* Drain any remaining items in the queue and notify their producers that
+		* the values were not processed. This prevents memory leaks and ensures
+		* proper backpressure signaling.
+		*/
+		drainQueue();
+	}
+}
+const utf8 = new TextEncoder();
+/**
+* Coerce common byte-like inputs into a `Uint8Array`. Strings encode as UTF-8.
+* Blobs return a `Promise<Uint8Array>`; every other input returns synchronously.
+* Throws `TypeError` for anything else.
+*/
+function normalizeToUint8Array(data) {
+	if (data instanceof Uint8Array) return data;
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	if (typeof Blob !== "undefined" && data instanceof Blob) return data.arrayBuffer().then((buf) => new Uint8Array(buf));
+	if (typeof data === "string") return utf8.encode(data);
+	throw new TypeError(`normalizeToUint8Array: unsupported input ${describe(data)}; expected Uint8Array, ArrayBuffer, ArrayBufferView, Blob, or string`);
+}
+function describe(value) {
+	if (value === null) return "null";
+	const t = typeof value;
+	if (t !== "object") return t;
+	return value.constructor?.name ?? "object";
+}
+/**
+* The iterator ↔ `ReadableStream` boundary.
+*
+* Both adapters must carry CANCELLATION, not just data: a response body leaves
+* a handler as a `ReadableStream`, crosses a transport as an iterator, and
+* becomes a `ReadableStream` again at the caller — so when the caller walks
+* away, the only path back to the handler's producer runs through both of
+* these functions. Teardown that stops at an adapter leaves a producer running
+* for ever.
+*/
 function toReadableStream(it) {
-  return new ReadableStream({
-    type: "bytes",
-    async pull(controller) {
-      let handled = false;
-      try {
-        while (true) {
-          const slot = await it.next();
-          if (!slot || slot.done) {
-            break;
-          }
-          controller.enqueue(await slot.value);
-        }
-      } catch (error) {
-        handled = true;
-        controller.error(error);
-      } finally {
-        !handled && controller.close();
-      }
-    },
-  });
-}
-
+	return new ReadableStream({
+		/**
+		* One chunk per pull. An earlier version drained the whole iterator inside
+		* a single `pull`, which defeated the stream's own backpressure (every
+		* chunk was enqueued as fast as the producer could make them, however slow
+		* the reader was) and left no point between chunks at which a cancellation
+		* could take effect.
+		*/
+		async pull(controller) {
+			try {
+				const slot = await it.next();
+				if (!slot || slot.done) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(await slot.value);
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		/**
+		* Release the source. NOT awaited: `.return()` on an async generator that
+		* is parked awaiting its own source is queued behind that pending
+		* `next()`, so awaiting it here would hang `reader.cancel()` on exactly
+		* the producers that most need cancelling.
+		*/
+		cancel(reason) {
+			Promise.resolve(it.return?.(reason)).catch(() => {});
+		}
+	});
+}
 async function* fromReadableStream(stream) {
-  const reader = await stream.getReader();
-  let done, value;
-  while (({ done, value } = await reader.read())) {
-    if (done) {
-      break;
-    }
-    yield await value;
-  }
-}
-
-/**
- * This method returns an HTTP handlers transforming
- * HTTP Request instances to binary representations and
- * sending them to a transport layer.
- * Results of these transport ivokations are deserialized
- * as meaningful Response instances and returned back to the caller.
- *
- * The specified `send` method is used to dispatch serialized
- * requests to return the serialized remote results.
- * This transport method accepts and returns objects with
- * the same structure:
- * * `options` - contains serialized request or response parameters
- * * `content` - an async iterator over binary blocks for
- *    the request or response
- *
- * @param {*} send transport function accepting serialized requests
- * and returning back serialized responses
- * @returns an async handler accepting standard
- *   HTTP `Request` instances and returning `Response` instances
- */
+	const reader = stream.getReader();
+	let drained = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				drained = true;
+				break;
+			}
+			if (value !== void 0) yield value;
+		}
+	} finally {
+		if (drained) reader.releaseLock();
+		else await reader.cancel().catch(() => {});
+	}
+}
+/**
+* Inverse of {@link sendIterator}: turns a sequence of `{done, value, error}`
+* chunks (delivered to the supplied callback by `installer`) into an async
+* generator.
+*
+* The `installer` is given a `deliver` function. It should call `deliver`
+* once for each incoming chunk and may return a cleanup callback that
+* runs when the consumer stops iterating.
+*/
+function recieveIterator(installer) {
+	return newAsyncGenerator((next, done) => {
+		const cleanup = installer(async (chunk = { done: true }) => {
+			const { done: isDone = true, value, error } = chunk;
+			if (error) return await done(error);
+			if (isDone) return await done();
+			return await next(value);
+		});
+		if (cleanup) return async () => {
+			await cleanup();
+		};
+	});
+}
+/**
+* Drain an async iterator into a sink that consumes one chunk at a time.
+*
+* Each yielded value becomes `{ done: false, value }`. Completion emits
+* `{ done: true }`. If the iterator throws, the error is caught and the
+* final `done` chunk carries it so the peer can rethrow on its side.
+*/
+async function sendIterator(send, it) {
+	let error;
+	try {
+		for await (const value of it) await send({
+			done: false,
+			value
+		});
+	} catch (err) {
+		error = err;
+	} finally {
+		await send({
+			done: true,
+			error
+		});
+	}
+}
+/** Decode Uint8Array chunks to string chunks via TextDecoder, handling split multi-byte characters. */
+async function* decodeText(input) {
+	const decoder = new TextDecoder("utf-8", { fatal: false });
+	for await (const chunk of input) {
+		const text = decoder.decode(chunk, { stream: true });
+		if (text) yield text;
+	}
+	const tail = decoder.decode();
+	if (tail) yield tail;
+}
+/** Encode string chunks to Uint8Array chunks via TextEncoder. */
+async function* encodeText(input) {
+	const encoder = new TextEncoder();
+	for await (const str of input) yield encoder.encode(str);
+}
+const DEFAULT_CHUNK_SIZE = 16384;
+/**
+* Curried `Duplex`-shaped transformer that splits incoming `Uint8Array`s into
+* chunks no larger than `size` bytes. Empty input chunks are skipped; small
+* input chunks pass through unchanged (zero-copy `subarray` views are used
+* when splitting, so no allocation per chunk).
+*
+* Use to respect transport MTUs before reaching `channel.send`. Reassembly on
+* the receive side is not needed — consumers iterate a continuous byte stream.
+*/
+function toChunks(size = DEFAULT_CHUNK_SIZE) {
+	if (!(Number.isInteger(size) && size > 0)) throw new RangeError(`toChunks: size must be a positive integer, got ${size}`);
+	return async function* (input) {
+		for await (const block of input) {
+			if (block.byteLength === 0) continue;
+			if (block.byteLength <= size) {
+				yield block;
+				continue;
+			}
+			let offset = 0;
+			while (offset < block.byteLength) {
+				const end = Math.min(offset + size, block.byteLength);
+				yield block.subarray(offset, end);
+				offset = end;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/core/data-calls.ts
+function callChannel(target, callType, params, ...transfers) {
+	return new Promise((resolve, reject) => {
+		const channel = new MessageChannel();
+		channel.port1.onmessage = (ev) => {
+			const { result, error } = ev.data;
+			if (error) reject(deserializeError(error));
+			else resolve(result);
+		};
+		target.postMessage({
+			type: callType,
+			params
+		}, [channel.port2, ...transfers]);
+	});
+}
+function handleChannelCalls(target, callType, handler) {
+	const listener = async (event) => {
+		if (!event.data || event.data.type !== callType) return;
+		const [port, ...transfers] = event.ports ?? [];
+		const response = {};
+		try {
+			response.result = await handler(event, event.data.params, ...transfers);
+		} catch (error) {
+			response.error = serializeError(error);
+		}
+		port?.postMessage(response);
+	};
+	target.addEventListener("message", listener);
+	target.start?.();
+	return () => target.removeEventListener("message", listener);
+}
+//#endregion
+//#region src/core/data-channels.ts
+const MESSAGE_TYPE_REQUEST = "REQUEST";
+const MESSAGE_TYPE_RESPONSE = "RESPONSE";
+let __invocationCounter = 0;
+function newInvokationChannel({ port, handler = () => {
+	throw new Error("Handler not implemented");
+}, onError = console.error, newCallId = () => ++__invocationCounter }) {
+	const requests = {};
+	const listener = async (event) => {
+		const data = event.data ?? {};
+		if (data.type === MESSAGE_TYPE_REQUEST) try {
+			const result = await handler(data.request, ...event.ports);
+			const [response, ...transfers] = Array.isArray(result) ? result : result !== void 0 ? [result] : [];
+			port.postMessage({
+				type: MESSAGE_TYPE_RESPONSE,
+				callId: data.callId,
+				response
+			}, transfers);
+		} catch (error) {
+			port.postMessage({
+				type: MESSAGE_TYPE_RESPONSE,
+				callId: data.callId,
+				error: serializeError(error)
+			});
+		}
+		else if (data.type === MESSAGE_TYPE_RESPONSE) {
+			const pending = requests[data.callId];
+			delete requests[data.callId];
+			if (!pending) return;
+			if (data.error) pending.reject(deserializeError(data.error));
+			else pending.resolve(data.response);
+		}
+	};
+	const start = async () => {
+		try {
+			port.addEventListener("message", listener);
+			await port.start?.();
+		} catch (e) {
+			onError(e);
+		}
+	};
+	const close = async () => {
+		try {
+			port.removeEventListener("message", listener);
+			await port.close?.();
+		} catch (e) {
+			onError(e);
+		}
+	};
+	const invoke = (request = {}, ...transfers) => {
+		const callId = newCallId();
+		return new Promise((resolve, reject) => {
+			try {
+				requests[callId] = {
+					resolve,
+					reject
+				};
+				port.postMessage({
+					type: MESSAGE_TYPE_REQUEST,
+					callId,
+					request
+				}, transfers);
+			} catch (error) {
+				delete requests[callId];
+				reject(error);
+			}
+		});
+	};
+	return {
+		start,
+		close,
+		invoke
+	};
+}
+async function* sendStream(communicationPort, input, params = {}) {
+	const messageChannel = new MessageChannel();
+	communicationPort.postMessage({
+		type: "START_CALL",
+		params
+	}, [messageChannel.port2]);
+	const channel = newStreamChannel(messageChannel.port1);
+	let drained = false;
+	try {
+		await channel.start();
+		channel.sendAll(input);
+		yield* channel.recieveAll();
+		drained = true;
+	} finally {
+		if (!drained) channel.cancel();
+		await channel.close();
+	}
+}
+function handleStreams(communicationPort, handler) {
+	const listener = async (event) => {
+		const { type, params } = event.data ?? {};
+		if (type !== "START_CALL") return;
+		const port = event.ports[0];
+		const channel = newStreamChannel(port);
+		try {
+			await channel.start();
+			const response = await handler(channel.recieveAll(), params ?? {});
+			await channel.sendAll(response);
+		} finally {
+			await channel.close();
+		}
+	};
+	communicationPort.addEventListener("message", listener);
+	communicationPort.start?.();
+	return () => communicationPort.removeEventListener("message", listener);
+}
+function newStreamChannel(port) {
+	let listeners = [];
+	let iterators = [];
+	const notifyAll = async (data) => {
+		for (const listener of listeners) await listener(data);
+	};
+	/**
+	* Release whatever we are sending. NOT awaited: `.return()` on an async
+	* generator parked awaiting its own source is queued behind that pending
+	* `next()`, so awaiting it here would block the message handler — and the
+	* chunk that would unblock it can only arrive through that same handler.
+	*/
+	const cancelOutgoing = () => {
+		for (const it of [...iterators]) {
+			const iterable = it;
+			Promise.resolve(iterable.return?.()).catch(() => {});
+		}
+	};
+	const channel = newInvokationChannel({
+		port,
+		handler: (data) => {
+			const message = data;
+			if (message?.cancel) {
+				cancelOutgoing();
+				return;
+			}
+			return notifyAll(message);
+		}
+	});
+	const start = () => channel.start();
+	const cancel = () => {
+		channel.invoke({ cancel: true }).catch(() => {});
+	};
+	const close = async () => {
+		await notifyAll({ done: true });
+		for (const it of [...iterators]) await it.return?.();
+		await channel.close();
+	};
+	async function* recieveAll() {
+		yield* recieveIterator((deliver) => {
+			listeners.push(deliver);
+			return () => {
+				listeners = listeners.filter((l) => l !== deliver);
+			};
+		});
+	}
+	async function sendAll(it) {
+		await sendIterator((chunk) => void channel.invoke(chunk), (async function* () {
+			try {
+				iterators.push(it);
+				yield* it;
+			} finally {
+				iterators = iterators.filter((i) => i !== it);
+			}
+		})());
+	}
+	return {
+		start,
+		close,
+		cancel,
+		recieveAll,
+		sendAll
+	};
+}
+//#endregion
+//#region src/core/registry.ts
+function newRegistry(onError = console.error) {
+	let counter = 0;
+	const registrations = {};
+	const register = (action) => {
+		const id = counter++;
+		const fn = Object.assign((skip) => {
+			try {
+				delete registrations[id];
+				return skip ? void 0 : action();
+			} catch (error) {
+				onError(error);
+			}
+		}, { action });
+		registrations[id] = fn;
+		return fn;
+	};
+	const unregister = (action) => {
+		for (const r of Object.values(registrations)) if (r.action === action) r(true);
+	};
+	const clear = () => {
+		for (const r of Object.values(registrations)) r();
+	};
+	return Object.assign([
+		register,
+		clear,
+		unregister
+	], {
+		register,
+		clear,
+		unregister
+	});
+}
+//#endregion
+//#region ../webrun-http-streams/dist/index.js
+const CR = 13;
+const LF = 10;
+const EMPTY = /* @__PURE__ */ new Uint8Array(0);
+var ByteStreamError = class extends Error {
+	name = "ByteStreamError";
+};
+function toAsyncIterator(input) {
+	const asyncIter = input[Symbol.asyncIterator];
+	if (asyncIter) return asyncIter.call(input);
+	const syncIter = input[Symbol.iterator]();
+	return { next() {
+		return Promise.resolve(syncIter.next());
+	} };
+}
+/**
+* Discard an iterable we are contractually forbidden from consuming — a body
+* skipped for HEAD/204, or one abandoned because the peer reported an error.
+*
+* The `.next()` is not optional: `.return()` on a generator still in suspended
+* start is a no-op, so the body never runs and its `try/finally` never unwinds.
+* Without it a wrapped ReadableStream or socket is never cancelled.
+*/
+async function discard(source) {
+	if (source === void 0) return;
+	const it = toAsyncIterator(source);
+	try {
+		await it.next();
+		await it.return?.();
+	} catch {}
+}
+function concatChunks(parts, totalLen) {
+	if (parts.length === 1) {
+		const only = parts[0];
+		if (only !== void 0) return only;
+	}
+	const out = new Uint8Array(totalLen);
+	let off = 0;
+	for (const p of parts) {
+		out.set(p, off);
+		off += p.byteLength;
+	}
+	return out;
+}
+/**
+* Pull-based reader over a byte source. Holds at most one pending buffer, and
+* hands out `subarray` views rather than copies — a body never passes through
+* an allocation here.
+*/
+var ByteReader = class {
+	#iter;
+	#buf = EMPTY;
+	#done = false;
+	constructor(input) {
+		this.#iter = toAsyncIterator(input);
+	}
+	/** Bytes already pulled from the source but not yet consumed. */
+	bufferedLength() {
+		return this.#buf.byteLength;
+	}
+	/** Pull one more non-empty chunk. Returns false at end of stream. */
+	async #pull() {
+		if (this.#done) return false;
+		while (true) {
+			const next = await this.#iter.next();
+			if (next.done) {
+				this.#done = true;
+				return false;
+			}
+			const chunk = next.value;
+			if (chunk.byteLength === 0) continue;
+			this.#buf = this.#buf.byteLength === 0 ? chunk : concatChunks([this.#buf, chunk], this.#buf.byteLength + chunk.byteLength);
+			return true;
+		}
+	}
+	async peekByte() {
+		while (this.#buf.byteLength === 0) if (!await this.#pull()) return void 0;
+		return this.#buf[0];
+	}
+	/** Up to `max` bytes. `undefined` means end of stream. */
+	async readSome(max) {
+		while (this.#buf.byteLength === 0) if (!await this.#pull()) return void 0;
+		const take = Math.min(max, this.#buf.byteLength);
+		const out = this.#buf.subarray(0, take);
+		this.#buf = this.#buf.subarray(take);
+		return out;
+	}
+	/**
+	* One CRLF-terminated line, without the CRLF. A bare LF is rejected: real
+	* peers always send CRLF, and tolerating a bare LF is precisely the lenience
+	* that lets request smuggling through a proxy pair.
+	*
+	* The `maxBytes` bound is best-effort: it only rejects a line if the check
+	* happens to run before the line is fully buffered. A line already sitting in
+	* the buffer bypasses the check. Callers needing a hard per-line limit or
+	* aggregate bounds must keep their own running total.
+	*/
+	async readLine(maxBytes) {
+		let searched = 0;
+		while (true) {
+			const idx = this.#buf.indexOf(LF, searched);
+			if (idx !== -1) {
+				if (idx === 0 || this.#buf[idx - 1] !== CR) throw new ByteStreamError("bare LF line terminator; CRLF required");
+				const line = this.#buf.subarray(0, idx - 1);
+				this.#buf = this.#buf.subarray(idx + 1);
+				return line;
+			}
+			searched = this.#buf.byteLength;
+			if (searched > maxBytes) throw new ByteStreamError(`line exceeds ${maxBytes} bytes without CRLF`);
+			if (!await this.#pull()) throw new ByteStreamError(`stream ended after ${searched} bytes without CRLF`);
+		}
+	}
+	/** Everything not yet consumed, lazily. */
+	async *rest() {
+		while (true) {
+			if (this.#buf.byteLength > 0) {
+				const out = this.#buf;
+				this.#buf = EMPTY;
+				yield out;
+				continue;
+			}
+			if (!await this.#pull()) return;
+		}
+	}
+};
+/**
+* Raised for any byte sequence this codec refuses to interpret. Every case is
+* a refusal to guess: HTTP/1.1 parsers that guess are how request smuggling
+* works.
+*/
+var HttpParseError = class extends Error {
+	name = "HttpParseError";
+};
+const NEWLINE = 10;
+/** Mirrors the HTTP/1.1 codec's default `maxHeaderBytes`. */
+const MAX_ENVELOPE_BYTES = 65536;
+const encoder$1 = new TextEncoder();
+const decoder = new TextDecoder();
+/**
+* Encode an HTTP envelope plus optional body as one continuous byte stream:
+*
+*     <JSON.stringify(envelope)>\n<body bytes...>
+*
+* `JSON.stringify` with default whitespace never emits a literal `\n`, so the
+* first `0x0a` byte unambiguously terminates the envelope.
+*
+* This is the same wire shape used by the legacy `webrun-http-port` package.
+*/
+async function* encodeMessage(envelope, body) {
+	yield encoder$1.encode(`${JSON.stringify(envelope)}\n`);
+	if (!body) return;
+	for await (const chunk of body) if (chunk.byteLength > 0) yield chunk;
+}
+/**
+* Consume an envelope-then-body byte stream. Returns the parsed envelope and
+* an async iterable over the remaining body bytes.
+*/
+async function decodeMessage(input) {
+	const iter = toAsyncIterator(input);
+	const accum = [];
+	let accumLen = 0;
+	let before;
+	let tail;
+	while (true) {
+		const next = await iter.next();
+		if (next.done) throw new HttpParseError(`decodeMessage: stream ended after ${accumLen} bytes without delimiter (\\n)`);
+		const chunk = next.value;
+		if (chunk.byteLength === 0) continue;
+		const nl = chunk.indexOf(NEWLINE);
+		if (nl === -1) {
+			accum.push(chunk);
+			accumLen += chunk.byteLength;
+			if (accumLen > MAX_ENVELOPE_BYTES) throw new HttpParseError(`decodeMessage: envelope exceeds ${MAX_ENVELOPE_BYTES} bytes without delimiter (\\n)`);
+			continue;
+		}
+		accum.push(chunk.subarray(0, nl));
+		accumLen += nl;
+		before = concatChunks(accum, accumLen);
+		tail = chunk.subarray(nl + 1);
+		break;
+	}
+	let envelope;
+	try {
+		envelope = JSON.parse(decoder.decode(before));
+	} catch (err) {
+		throw new HttpParseError(`decodeMessage: malformed envelope JSON at bytes 0..${before.byteLength}: ${err.message}`);
+	}
+	async function* body() {
+		if (tail.byteLength > 0) yield tail;
+		while (true) {
+			const next = await iter.next();
+			if (next.done) return;
+			if (next.value.byteLength > 0) yield next.value;
+		}
+	}
+	return {
+		envelope,
+		body: body()
+	};
+}
+const OPEN_BRACE = 123;
+/**
+* The original wire format — `<JSON.stringify(envelope)>\n<body bytes…>` —
+* expressed as a `MessageCodec`. Direction-agnostic: requests and responses
+* serialise identically.
+*
+* Retained so a peer pair can be upgraded in either order; see ADR-0006.
+*/
+const jsonEnvelopeCodec = {
+	name: "json-envelope",
+	sniff: (byte) => byte === OPEN_BRACE,
+	encodeRequest: (env, body) => encodeMessage(env, body),
+	encodeResponse: (env, body) => encodeMessage(env, body),
+	decodeRequest: (input) => decodeMessage(input),
+	decodeResponse: (input) => decodeMessage(input)
+};
+const TCHAR = /* @__PURE__ */ new Set("!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+const SP = 32;
+const HTAB = 9;
+function isTokenChar(byte) {
+	return byte > SP && byte < 127 && TCHAR.has(String.fromCharCode(byte));
+}
+function isToken(value) {
+	if (value.length === 0) return false;
+	for (const ch of value) if (!TCHAR.has(ch)) return false;
+	return true;
+}
+/**
+* Header bytes are latin-1: byte-preserving, matching Node, and lossless
+* across a decode/encode round-trip. Control characters are rejected
+* separately by `assertValidHeaderValue`.
+*/
+function decodeLatin1(bytes) {
+	let out = "";
+	for (const byte of bytes) out += String.fromCharCode(byte);
+	return out;
+}
+function encodeLatin1(text) {
+	const out = new Uint8Array(text.length);
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code > 255) throw new HttpParseError(`not latin-1 encodable: ${JSON.stringify(text)}`);
+		out[i] = code;
+	}
+	return out;
+}
+const HOST_IP_LITERAL = /^\[[0-9A-Fa-f:.]+\](:\d{1,5})?$/;
+const HOST_REG_NAME = /^[A-Za-z0-9._~-]+(:\d{1,5})?$/;
+/**
+* Validates a value that is about to become (or was read as) a `Host`
+* header: untrusted input either way, so an unrecognised shape is a refusal,
+* not a guess. Rejects a present-but-empty value, one carrying userinfo
+* (`evil.com@good.com`), and — the reason this also runs on encode — one
+* smuggling a CRLF-terminated line into the authority of a caller-supplied
+* url. Never applied to trusted configuration (a codec's `opts.host`).
+*/
+function assertValidHost(host) {
+	if (!HOST_IP_LITERAL.test(host) && !HOST_REG_NAME.test(host)) throw new HttpParseError(`invalid Host header: ${JSON.stringify(host)}`);
+}
+/**
+* A request-target must be entirely visible ASCII (RFC 9110 VCHAR) — nothing
+* `<= 0x20` (space and every control character, CR/LF included) and nothing
+* `>= 0x7F` (DEL and beyond). Applied on encode (`splitTarget`, so a
+* caller-supplied url can never inject a second request line) and on decode
+* (so a relay that decodes then re-encodes can never put an embedded control
+* character back on the wire).
+*/
+function assertValidTarget(target) {
+	for (let i = 0; i < target.length; i++) {
+		const code = target.charCodeAt(i);
+		if (code <= SP || code >= 127) throw new HttpParseError(`invalid request-target: ${JSON.stringify(target)}`);
+	}
+}
+/**
+* Shared control-character check behind both `assertValidHeaderValue` and
+* `assertValidStatusText` — the two were previously checked by different,
+* looser rules (statusText only rejected CR/LF), which is exactly the
+* asymmetry class C1 and M5 are both instances of. `label` is prepended
+* verbatim to each message, so callers keep their own wording.
+*/
+function assertNoControlChars(label, value) {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code === 13 || code === 10) throw new HttpParseError(`${label} contains CR or LF`);
+		if (code < SP && code !== HTAB || code === 127) throw new HttpParseError(`${label} contains a control character`);
+		if (code > 255) throw new HttpParseError(`${label} is not latin-1 encodable`);
+	}
+}
+function assertValidHeaderValue(name, value) {
+	assertNoControlChars(`header "${name}" value`, value);
+}
+/** Same character class as a header value (M5) — CR/LF, every C0 control, and DEL. */
+function assertValidStatusText(value) {
+	assertNoControlChars("statusText", value);
+}
+function encodeHeaderLines(headers) {
+	let out = "";
+	for (const [name, value] of headers) {
+		if (!isToken(name)) throw new HttpParseError(`invalid header name: ${JSON.stringify(name)}`);
+		assertValidHeaderValue(name, value);
+		out += `${name}: ${value}\r\n`;
+	}
+	return out;
+}
+/**
+* Read to the blank line. `alreadyUsed` is the byte count of the start line,
+* so the bound covers the whole head section rather than the headers alone.
+*/
+async function readHeaderSection(reader, maxHeaderBytes, alreadyUsed) {
+	const headers = [];
+	let used = alreadyUsed;
+	while (true) {
+		const remaining = maxHeaderBytes - used;
+		if (remaining <= 0) throw new HttpParseError(`head section exceeds ${maxHeaderBytes} bytes`);
+		const lineBytes = await reader.readLine(remaining);
+		used += lineBytes.byteLength + 2;
+		if (used > maxHeaderBytes) throw new HttpParseError(`head section exceeds ${maxHeaderBytes} bytes`);
+		if (lineBytes.byteLength === 0) return headers;
+		if (lineBytes[0] === SP || lineBytes[0] === HTAB) throw new HttpParseError("obs-fold header continuation is not accepted");
+		const line = decodeLatin1(lineBytes);
+		const colon = line.indexOf(":");
+		if (colon <= 0) throw new HttpParseError(`malformed header line: ${JSON.stringify(line)}`);
+		const name = line.slice(0, colon);
+		if (!isToken(name)) throw new HttpParseError(`invalid header name: ${JSON.stringify(name)}`);
+		const value = line.slice(colon + 1).replace(/^[ \t]+/, "").replace(/[ \t]+$/, "");
+		assertValidHeaderValue(name, value);
+		headers.push([name, value]);
+	}
+}
+function getAll(headers, name) {
+	const lower = name.toLowerCase();
+	return headers.filter(([k]) => k.toLowerCase() === lower).map(([, v]) => v);
+}
+function withoutHeaders(headers, names) {
+	const drop = new Set(names.map((n) => n.toLowerCase()));
+	return headers.filter(([k]) => !drop.has(k.toLowerCase()));
+}
+/**
+* Parse a `Content-Length` field into a single validated value.
+*
+* RFC 9110 §8.6 permits the value to be a comma-separated list of identical
+* numbers (a relay may have appended one), so the list is folded; differing
+* values are a refusal, not a choice. Shared by `resolveFraming` on decode and
+* by the encoder's declared-length check, which previously carried its own
+* copy that did NOT split on commas — so decode accepted `5, 5` while encode
+* rejected it, and a relay that decoded then re-encoded threw.
+*
+* Returns undefined when the field is absent.
+*/
+function parseContentLength(values) {
+	if (values.length === 0) return void 0;
+	const unique = new Set(values.flatMap((v) => v.split(",").map((s) => s.trim())));
+	if (unique.size !== 1) throw new HttpParseError(`conflicting Content-Length values: ${[...unique].join(", ")}`);
+	const raw = [...unique][0];
+	if (!/^\d{1,15}$/.test(raw)) throw new HttpParseError(`invalid Content-Length: ${JSON.stringify(raw)}`);
+	return Number(raw);
+}
+/**
+* Statuses that carry no body whatever the headers say (RFC 9110 §8.6): 1xx,
+* 204 and 304. Defined once because the encoder must not frame a body for
+* them and the decoder must not try to read one — two lists that agreed today
+* and were free to drift tomorrow.
+*
+* A response to HEAD is also bodyless, but that depends on the request rather
+* than the status, so callers test it separately.
+*/
+function isBodylessStatus(status) {
+	return status < 200 || status === 204 || status === 304;
+}
+/**
+* RFC 9112 §6.3, with every ambiguity turned into a refusal. In particular a
+* message declaring both Content-Length and Transfer-Encoding is rejected
+* rather than resolved — disagreeing on which one wins is request smuggling.
+*/
+function resolveFraming(headers, version) {
+	const te = getAll(headers, "transfer-encoding");
+	const cl = getAll(headers, "content-length");
+	if (te.length > 0 && cl.length > 0) throw new HttpParseError("message declares both Content-Length and Transfer-Encoding; refusing (request smuggling)");
+	if (te.length > 0) {
+		const encodings = te.join(",").split(",").map((s) => s.trim().toLowerCase()).filter((s) => s !== "");
+		if (encodings.length !== 1 || encodings[0] !== "chunked") throw new HttpParseError(`unsupported Transfer-Encoding: ${JSON.stringify(te.join(", "))}`);
+		if (version === "HTTP/1.0") throw new HttpParseError("Transfer-Encoding is not valid in HTTP/1.0");
+		return { kind: "chunked" };
+	}
+	const length = parseContentLength(cl);
+	if (length !== void 0) return {
+		kind: "length",
+		length
+	};
+	return { kind: "none" };
+}
+const CRLF = new Uint8Array([13, 10]);
+const LAST_CHUNK = new Uint8Array([
+	48,
+	13,
+	10,
+	13,
+	10
+]);
+const encoder = new TextEncoder();
+/**
+* Chunk sizes are written in HEXADECIMAL — a 21-byte chunk is `15`. Writing
+* them in decimal is the defect note 15 found in @libp2p/http, and it is the
+* one that cannot be caught downstream: decimal digits are also valid hex, so
+* a conforming parser silently reads the wrong length.
+*
+* Zero-length source chunks are skipped; a zero-sized chunk on the wire is the
+* body terminator.
+*/
+async function* encodeChunked(body) {
+	for await (const chunk of body) {
+		if (chunk.byteLength === 0) continue;
+		yield encoder.encode(`${chunk.byteLength.toString(16)}\r\n`);
+		yield chunk;
+		yield CRLF;
+	}
+	yield LAST_CHUNK;
+}
+/**
+* Decode a chunked body, yielding data chunks as they arrive. Nothing is
+* accumulated: a chunk larger than the transport's frame is yielded in pieces.
+*/
+async function* decodeChunked(reader, maxLineBytes) {
+	while (true) {
+		const sizeLine = decodeLatin1(await reader.readLine(maxLineBytes));
+		const semicolon = sizeLine.indexOf(";");
+		const sizeText = semicolon === -1 ? sizeLine : sizeLine.slice(0, semicolon);
+		if (!/^[0-9a-fA-F]{1,32}$/.test(sizeText)) throw new HttpParseError(`invalid chunk size: ${JSON.stringify(sizeLine)}`);
+		const size = Number.parseInt(sizeText, 16);
+		if (!Number.isSafeInteger(size)) throw new HttpParseError(`chunk size is too large: ${JSON.stringify(sizeLine)}`);
+		if (size === 0) {
+			let used = 0;
+			while (true) {
+				const remaining = maxLineBytes - used;
+				if (remaining <= 0) throw new HttpParseError(`trailer section exceeds ${maxLineBytes} bytes`);
+				const lineBytes = await reader.readLine(remaining);
+				used += lineBytes.byteLength + 2;
+				if (used > maxLineBytes) throw new HttpParseError(`trailer section exceeds ${maxLineBytes} bytes`);
+				if (lineBytes.byteLength === 0) break;
+			}
+			return;
+		}
+		let remaining = size;
+		while (remaining > 0) {
+			const part = await reader.readSome(remaining);
+			if (part === void 0) throw new HttpParseError(`chunk truncated: ${remaining} of ${size} bytes missing`);
+			remaining -= part.byteLength;
+			yield part;
+		}
+		try {
+			if ((await reader.readLine(2)).byteLength !== 0) throw new HttpParseError("chunk data not terminated by CRLF");
+		} catch (err) {
+			if (err instanceof ByteStreamError) throw new HttpParseError("chunk data not terminated by CRLF");
+			throw err;
+		}
+	}
+}
+const VERSIONS = /* @__PURE__ */ new Set(["HTTP/1.1", "HTTP/1.0"]);
+const ABSOLUTE_FORM = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//;
+/**
+* One message per Duplex call (ADR-0006), so bytes after a complete message
+* are an error. Checked against what is ALREADY BUFFERED rather than by
+* awaiting end-of-stream: a live socket from a keep-alive peer never reaches
+* EOF, so awaiting one would hang instead of failing.
+*/
+function assertNoBufferedBytes(reader) {
+	const extra = reader.bufferedLength();
+	if (extra > 0) throw new HttpParseError(`${extra} trailing bytes after a complete message`);
+}
+/**
+* The public error contract (I2): everything leaving `decodeRequest` /
+* `decodeResponse` is an `HttpParseError`, whether the refusal happened
+* synchronously (a malformed start line or header) or lazily while the body
+* is later drained. `ByteStreamError` — the `ByteReader`'s own class, never
+* exported — is the one thing converted here, message and all preserved via
+* `cause`. Anything else is a genuine failure of the underlying source (a
+* dropped socket, say) and must reach the caller unchanged: blanket-catching
+* would hide that distinction.
+*/
+function toHttpParseError(err) {
+	if (err instanceof ByteStreamError) throw new HttpParseError(err.message, { cause: err });
+	throw err;
+}
+/** Applies `toHttpParseError` across the whole lifetime of a body generator. */
+async function* convertBodyErrors(source) {
+	try {
+		yield* source;
+	} catch (err) {
+		toHttpParseError(err);
+	}
+}
+async function* readBody(reader, framing, opts, noneMeansEof) {
+	if (framing.kind === "chunked") {
+		yield* decodeChunked(reader, opts.maxHeaderBytes);
+		assertNoBufferedBytes(reader);
+		return;
+	}
+	if (framing.kind === "length") {
+		let remaining = framing.length;
+		while (remaining > 0) {
+			const part = await reader.readSome(remaining);
+			if (part === void 0) throw new HttpParseError(`body truncated: ${remaining} of ${framing.length} bytes missing`);
+			remaining -= part.byteLength;
+			yield part;
+		}
+		assertNoBufferedBytes(reader);
+		return;
+	}
+	if (noneMeansEof) {
+		yield* reader.rest();
+		return;
+	}
+	assertNoBufferedBytes(reader);
+}
+/**
+* `readLine`'s bound is best-effort — it is skipped when the line is already
+* buffered — so a very long start line can reach these messages intact. Since
+* a refusal is now echoed back to the sender in a 400 body, quote only enough
+* to diagnose rather than reflecting the whole thing.
+*/
+function quoteLine(line) {
+	const MAX = 120;
+	return line.length <= MAX ? JSON.stringify(line) : `${JSON.stringify(line.slice(0, MAX))} (truncated from ${line.length} chars)`;
+}
+async function decodeRequest(input, opts) {
+	const reader = new ByteReader(input);
+	try {
+		const startBytes = await reader.readLine(opts.maxHeaderBytes);
+		const startLine = decodeLatin1(startBytes);
+		const parts = startLine.split(" ");
+		if (parts.length !== 3) throw new HttpParseError(`malformed request line: ${quoteLine(startLine)}`);
+		const [method, target, version] = parts;
+		if (!isToken(method)) throw new HttpParseError(`invalid method: ${JSON.stringify(method)}`);
+		if (!VERSIONS.has(version)) throw new HttpParseError(`unsupported HTTP version: ${JSON.stringify(version)}`);
+		if (target === "*") throw new HttpParseError("asterisk-form request target is not supported");
+		assertValidTarget(target);
+		const headers = await readHeaderSection(reader, opts.maxHeaderBytes, startBytes.byteLength + 2);
+		const hosts = getAll(headers, "host");
+		if (hosts.length > 1) throw new HttpParseError("multiple Host headers");
+		const host = hosts[0];
+		let url;
+		if (target.startsWith("/")) {
+			if (version === "HTTP/1.1" && host === void 0) throw new HttpParseError("HTTP/1.1 request has no Host header");
+			if (host !== void 0) assertValidHost(host);
+			url = `${opts.scheme}://${host ?? opts.host}${target}`;
+		} else if (ABSOLUTE_FORM.test(target)) url = target;
+		else throw new HttpParseError(`unsupported request target: ${JSON.stringify(target)}`);
+		try {
+			new URL(url);
+		} catch {
+			throw new HttpParseError(`decoded url is not a valid URL: ${JSON.stringify(url)}`);
+		}
+		return {
+			envelope: {
+				url,
+				method,
+				headers
+			},
+			body: convertBodyErrors(readBody(reader, resolveFraming(headers, version), opts, false))
+		};
+	} catch (err) {
+		toHttpParseError(err);
+	}
+}
+async function decodeResponse(input, opts, method) {
+	const reader = new ByteReader(input);
+	try {
+		const startBytes = await reader.readLine(opts.maxHeaderBytes);
+		const startLine = decodeLatin1(startBytes);
+		const firstSp = startLine.indexOf(" ");
+		if (firstSp === -1) throw new HttpParseError(`malformed status line: ${quoteLine(startLine)}`);
+		const version = startLine.slice(0, firstSp);
+		if (!VERSIONS.has(version)) throw new HttpParseError(`unsupported HTTP version: ${JSON.stringify(version)}`);
+		const afterVersion = startLine.slice(firstSp + 1);
+		const secondSp = afterVersion.indexOf(" ");
+		const codeText = secondSp === -1 ? afterVersion : afterVersion.slice(0, secondSp);
+		if (!/^\d{3}$/.test(codeText)) throw new HttpParseError(`invalid status code: ${JSON.stringify(codeText)}`);
+		const status = Number(codeText);
+		const statusText = secondSp === -1 ? "" : afterVersion.slice(secondSp + 1);
+		const headers = await readHeaderSection(reader, opts.maxHeaderBytes, startBytes.byteLength + 2);
+		const bodyless = isBodylessStatus(status) || method.toUpperCase() === "HEAD";
+		const framing = bodyless ? { kind: "none" } : resolveFraming(headers, version);
+		return {
+			envelope: {
+				status,
+				statusText,
+				headers
+			},
+			body: convertBodyErrors(readBody(reader, framing, opts, !bodyless))
+		};
+	} catch (err) {
+		toHttpParseError(err);
+	}
+}
+/** Headers the codec owns: a caller-supplied copy is dropped and re-derived. */
+const REQUEST_OWNED = [
+	"host",
+	"connection",
+	"transfer-encoding"
+];
+const RESPONSE_OWNED = ["connection", "transfer-encoding"];
+/**
+* Split a URL into an origin-form request target and an authority *without*
+* going through `new URL()`. `URL` normalises percent-encoding and would
+* re-serialise the target — which is the exact class of defect note 15 found
+* in @libp2p/http, where rebuilding the request line silently dropped
+* `url.search`. Here the target is a verbatim slice of the caller's string.
+*/
+function splitTarget(url, opts) {
+	if (url.startsWith("/")) {
+		assertValidTarget(url);
+		return {
+			target: url,
+			authority: opts.host
+		};
+	}
+	const match = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/([^/?#]*)([^#]*)/.exec(url);
+	if (!match) throw new HttpParseError(`cannot derive a request target from url: ${JSON.stringify(url)}`);
+	const rawAuthority = match[1];
+	if (rawAuthority === "") throw new HttpParseError(`url has no authority: ${JSON.stringify(url)}`);
+	const at = rawAuthority.lastIndexOf("@");
+	const authority = at === -1 ? rawAuthority : rawAuthority.slice(at + 1);
+	assertValidHost(authority);
+	const rawTarget = match[2];
+	const target = rawTarget === "" ? "/" : rawTarget.startsWith("/") ? rawTarget : `/${rawTarget}`;
+	assertValidTarget(target);
+	return {
+		target,
+		authority
+	};
+}
+async function* emitBody(body, declared) {
+	if (declared === void 0) {
+		yield* encodeChunked(body);
+		return;
+	}
+	let sent = 0;
+	for await (const chunk of body) {
+		if (chunk.byteLength === 0) continue;
+		sent += chunk.byteLength;
+		if (sent > declared) throw new HttpParseError(`body exceeds declared Content-Length ${declared} (${sent} bytes so far)`);
+		yield chunk;
+	}
+	if (sent !== declared) throw new HttpParseError(`body is ${sent} bytes but Content-Length declares ${declared}`);
+}
+async function* encodeRequest(env, body, opts) {
+	if (!isToken(env.method)) throw new HttpParseError(`invalid method: ${JSON.stringify(env.method)}`);
+	const { target, authority } = splitTarget(env.url, opts);
+	if (authority === "") throw new HttpParseError("no Host available: url has no authority and no host is configured");
+	const carried = withoutHeaders(env.headers, REQUEST_OWNED);
+	const declared = parseContentLength(getAll(carried, "content-length"));
+	let head = `${env.method} ${target} HTTP/1.1\r\n`;
+	head += `Host: ${authority}\r\n`;
+	head += encodeHeaderLines(carried);
+	head += "Connection: close\r\n";
+	if (body !== void 0 && declared === void 0) head += "Transfer-Encoding: chunked\r\n";
+	head += "\r\n";
+	yield encodeLatin1(head);
+	if (body === void 0) {
+		if (declared !== void 0 && declared !== 0) throw new HttpParseError(`body is 0 bytes but Content-Length declares ${declared}`);
+		return;
+	}
+	yield* emitBody(body, declared);
+}
+async function* encodeResponse(env, body, _opts, requestMethod) {
+	if (!Number.isInteger(env.status) || env.status < 100 || env.status > 599) throw new HttpParseError(`invalid status: ${env.status}`);
+	const reason = env.statusText ?? "";
+	assertValidStatusText(reason);
+	const bodylessStatus = isBodylessStatus(env.status);
+	const bodyless = bodylessStatus || requestMethod?.toUpperCase() === "HEAD";
+	const owned = bodylessStatus ? [...RESPONSE_OWNED, "content-length"] : RESPONSE_OWNED;
+	const carried = withoutHeaders(env.headers, owned);
+	const declared = parseContentLength(getAll(carried, "content-length"));
+	let head = `HTTP/1.1 ${env.status} ${reason}\r\n`;
+	head += encodeHeaderLines(carried);
+	head += "Connection: close\r\n";
+	if (!bodyless && body !== void 0 && declared === void 0) head += "Transfer-Encoding: chunked\r\n";
+	head += "\r\n";
+	yield encodeLatin1(head);
+	if (bodyless) {
+		await discard(body);
+		return;
+	}
+	if (body === void 0) {
+		if (declared !== void 0 && declared !== 0) throw new HttpParseError(`body is 0 bytes but Content-Length declares ${declared}`);
+		return;
+	}
+	yield* emitBody(body, declared);
+}
+function newHttpCodec(options = {}) {
+	const opts = {
+		scheme: options.scheme ?? "http",
+		host: options.host ?? "localhost",
+		maxHeaderBytes: options.maxHeaderBytes ?? 65536
+	};
+	return {
+		name: "http/1.1",
+		sniff: (byte) => isTokenChar(byte),
+		encodeRequest: (env, body) => encodeRequest(env, body, opts),
+		encodeResponse: (env, body, o) => encodeResponse(env, body, opts, o?.method),
+		decodeRequest: (input) => decodeRequest(input, opts),
+		decodeResponse: (input, o) => decodeResponse(input, opts, o.method)
+	};
+}
+const httpCodec = newHttpCodec();
+/**
+* Dispatches on byte 0. The formats are self-identifying — a JSON envelope
+* always begins `{`, which is not a token character and so can never begin an
+* HTTP start-line — so no negotiation handshake, magic prefix, or version byte
+* is needed.
+*
+* This is what makes a mixed-version peer pair safe: readers accept either
+* format, so the two ends can be upgraded in any order.
+*/
+function newSniffingCodec(options) {
+	const { write, accept } = options;
+	async function pick(input) {
+		const reader = new ByteReader(input);
+		const first = await reader.peekByte();
+		if (first === void 0) throw new HttpParseError("sniff: stream ended before any bytes arrived");
+		const codec = accept.find((c) => c.sniff(first));
+		if (!codec) throw new HttpParseError(`sniff: no accepted codec recognises a message starting with byte 0x${first.toString(16).padStart(2, "0")}`);
+		return {
+			codec,
+			input: reader.rest()
+		};
+	}
+	return {
+		name: `sniff(write=${write.name}; accept=${accept.map((c) => c.name).join(",")})`,
+		sniff: (byte) => accept.some((c) => c.sniff(byte)),
+		encodeRequest: (env, body) => write.encodeRequest(env, body),
+		encodeResponse: (env, body, o) => write.encodeResponse(env, body, o),
+		decodeRequest: async (input) => {
+			const picked = await pick(input);
+			try {
+				return {
+					...await picked.codec.decodeRequest(picked.input),
+					codec: picked.codec
+				};
+			} catch (error) {
+				if (error !== null && typeof error === "object") error.codec = picked.codec;
+				throw error;
+			}
+		},
+		decodeResponse: async (input, o) => {
+			const picked = await pick(input);
+			return picked.codec.decodeResponse(picked.input, o);
+		}
+	};
+}
+/**
+* Writes HTTP/1.1; accepts HTTP/1.1 or the legacy JSON envelope. Used whenever
+* no `codec` option is supplied.
+*/
+const defaultCodec = newSniffingCodec({
+	write: httpCodec,
+	accept: [httpCodec, jsonEnvelopeCodec]
+});
+/** Carries the serialized JS error between two webrun peers. */
+const PEER_ERROR_HEADER = "x-webrun-error";
+/** Hard cap on the peer-error header (M3): see `encodeErrorResponse`. */
+const MAX_DETAIL_CHARS = 4096;
+/**
+* JSON with every non-printable-ASCII character escaped, so the result is a
+* legal latin-1 header value whatever the error message contained.
+*/
+function asciiJson(value) {
+	return JSON.stringify(value).replace(/[^\x20-\x7E]/g, (ch) => `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+/**
+* Decision 13: a real HTTP peer cannot receive a JavaScript exception, only a
+* response. So an uncaught handler error becomes a conforming 500 whose body
+* carries the message, with the serialized error in a namespaced header that
+* another webrun peer re-throws from.
+*/
+function encodeErrorResponse(codec, error, method, status = 500, statusText = "Internal Server Error") {
+	const serialized = serializeError(error);
+	let detail = asciiJson(serialized);
+	if (detail.length > MAX_DETAIL_CHARS) detail = asciiJson({ message: serialized.message });
+	if (detail.length > MAX_DETAIL_CHARS) detail = detail.slice(0, MAX_DETAIL_CHARS);
+	const message = serialized.message ?? statusText;
+	return codec.encodeResponse({
+		status,
+		statusText,
+		headers: [["Content-Type", "text/plain; charset=utf-8"], [PEER_ERROR_HEADER, detail]]
+	}, [new TextEncoder().encode(message)], { method });
+}
+/**
+* `output` is the `Duplex` call's own generator — one logical call, per the
+* `Duplex` contract in `@statewalker/webrun-streams`: "Consumer `.return()`
+* on the output → producer's `finally` runs." On a mux transport
+* (`emulateMux`), that `finally` is what frees the stream-table slot; skip it
+* and every peer-error response leaks one slot, unboundedly, until the mux
+* itself is exhausted (`maxStreams` reached, every further call rejected).
+*
+* Cancelling `output` here — not inside the codec's own decode logic — is
+* deliberate. `codec.decodeResponse` already pulled from `output` to read the
+* head before this function runs, so unlike the body case above there's no
+* suspended-start no-op to worry about. And it's safe specifically *because*
+* this is the client's own response-only generator: the request was already
+* fully sent before we got here, so there is nothing left to write on it.
+* The equivalent is NOT safe inside `src/http1/decode.ts`'s `ByteReader` —
+* that code also runs when a caller wires `codec.decodeRequest`/
+* `decodeResponse` directly onto a raw bidirectional socket (see
+* `tests/http1-node-interop.test.ts`), where the *same* object is read from
+* and then written back to (a server reads the request, then replies on the
+* same socket); cancelling the read side there tears down the whole
+* connection out from under the pending write. That was tried and reverted —
+* see the Task 11 report for the "socket hang up" failure it caused.
+*/
+async function throwIfPeerError(result, output) {
+	const found = result.envelope.headers.find(([k]) => k.toLowerCase() === PEER_ERROR_HEADER);
+	if (!found) return;
+	await discard(result.body);
+	try {
+		await output.return?.(void 0);
+	} catch {}
+	let payload;
+	try {
+		payload = JSON.parse(found[1]);
+	} catch {
+		payload = { message: found[1] };
+	}
+	throw deserializeError(payload);
+}
+/**
+* Initiate an HTTP call over a `Duplex`. The caller's `call: Duplex` is
+* obtained from any `webrun-streams-*` adapter's `connect`. Returns the
+* response envelope and an async iterable over the response body bytes.
+*
+* The call is one logical Duplex invocation; multiplexing of concurrent
+* calls is the adapter's concern (native or `emulateMux`).
+*/
+async function httpFetch(call, env, body, options = {}) {
+	const codec = options.codec ?? defaultCodec;
+	const output = call(codec.encodeRequest(env, body));
+	const result = await codec.decodeResponse(output, { method: env.method });
+	await throwIfPeerError(result, output);
+	return result;
+}
+/**
+* Wrap an HTTP handler as a `Duplex` so it can be registered with any
+* `webrun-streams-*` adapter's `serve`.
+*/
+function httpServe(handler, options = {}) {
+	const codec = options.codec ?? defaultCodec;
+	return async function* httpHandlerDuplex(input) {
+		let decoded;
+		try {
+			decoded = await codec.decodeRequest(input);
+		} catch (error) {
+			if (!(error instanceof HttpParseError)) throw error;
+			yield* encodeErrorResponse(error.codec ?? codec, error, "GET", 400, "Bad Request");
+			return;
+		}
+		const replyCodec = decoded.codec ?? codec;
+		let result;
+		try {
+			result = await handler(decoded.envelope, decoded.body);
+		} catch (error) {
+			yield* encodeErrorResponse(replyCodec, error, decoded.envelope.method);
+			return;
+		}
+		yield* replyCodec.encodeResponse(result.envelope, result.body, { method: decoded.envelope.method });
+	};
+}
+/**
+* The one place that knows a runtime may not implement request body streams,
+* and the buffering both fallbacks need. `fetch.ts` and `http-stubs.ts` each
+* carry a client and a server direction that must agree on the answer, so the
+* predicate lives here rather than being written out four times.
+*/
+/**
+* Whether `Request.prototype` exposes a `body` accessor. Two call sites read
+* that property, and two more depend on the constructor accepting a
+* `ReadableStream` as `init.body`; this predicate answers for all four.
+*
+* What was verified, and all that is claimed here: Firefox (146 at the time of
+* writing) has *neither*, and Chromium and Node have *both*. On Firefox it is
+* not that `body` is `undefined` on the instance —
+* `Object.getOwnPropertyDescriptor(Request.prototype, "body")` is `null`, the
+* accessor is genuinely absent — and because a `ReadableStream` is then not a
+* recognised `BodyInit`, the constructor falls through to the string branch and
+* stores the literal text `[object ReadableStream]`.
+*
+* The two halves are NOT guaranteed to ship together, so do not read this as a
+* test for "request streams" in general. Safari is the counterexample: it has
+* had `Request.body` since 11.1 but only accepts a stream as `init.body` from
+* Technology Preview 250, so a shipping Safari has the reader half without the
+* upload half and this returns `true` there. That looks benign — WebKit appears
+* to store the stream on the `Request` rather than stringify it, and its error
+* comes from `fetch()`, which this package never calls on the objects it builds
+* — but it is untested, and it is the case to look at first if a Safari report
+* arrives. The sharper probe, if one is ever needed, is whether
+* `new Request(url, {method:"POST", body:new ReadableStream(), duplex:"half"})`
+* has a `content-type` of `text/plain;charset=UTF-8` (stringified) or `null`
+* (stored); it is not used here because it costs a `Request` and a
+* `ReadableStream` per call and agrees with the descriptor check on every
+* runtime measured.
+*
+* A capability check, never a user-agent test: the question is what this
+* runtime does, and the answer flips on its own the day Firefox ships request
+* streams. Evaluated per call rather than cached at module load so that a test
+* can install a `Request` without the capability and exercise the real branch
+* under Node.
+*/
+function supportsRequestStreams() {
+	return typeof Request === "function" && Object.getOwnPropertyDescriptor(Request.prototype, "body") != null;
+}
+/**
+* Drain a body iterable into one contiguous buffer. Only the fallbacks need it.
+* Allocates its own buffer rather than reusing `bytes.ts`'s `concatChunks`,
+* which passes a single chunk straight through: that chunk is a view onto the
+* decoder's own read buffer, and the result here is handed to `new Request` and
+* outlives the decode. The allocation is also what makes it a
+* `Uint8Array<ArrayBuffer>`, which `BodyInit` accepts and the looser
+* `Uint8Array<ArrayBufferLike>` does not.
+*/
+async function collectBytes$1(source) {
+	const parts = [];
+	let total = 0;
+	for await (const chunk of source) {
+		if (chunk.byteLength === 0) continue;
+		parts.push(chunk);
+		total += chunk.byteLength;
+	}
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		out.set(part, offset);
+		offset += part.byteLength;
+	}
+	return out;
+}
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+	101,
+	103,
+	204,
+	205,
+	304
+]);
+const REQUEST_FIELDS = [
+	"url",
+	"method",
+	"mode",
+	"credentials",
+	"cache",
+	"redirect",
+	"referrer",
+	"referrerPolicy",
+	"integrity",
+	"keepalive"
+];
+/** `SerializedHttpEnvelope.content` is never absent, only empty. */
+async function* noBytes() {}
+async function* oneChunk(chunk) {
+	yield chunk;
+}
+/**
+* Returns an HTTP handler that serializes a Request, hands the envelope to
+* `send` for transport, and deserializes the reply into a Response. Used on
+* the caller side.
+*/
 function newHttpClientStub(send) {
-  return async (request) => {
-    request = await request;
-    const fields = [
-      "url",
-      "method",
-      "mode",
-      "credentials",
-      "cache",
-      "redirect",
-      "referrer",
-      "referrerPolicy",
-      "integrity",
-      "keepalive"
-    ];
-    const headers = [...request.headers].map(([key, value]) => {
-      return [key, value]
-    });
-    const requestOptions = fields.reduce((options, key) => {
-      const val = request[key];
-      if (val !== undefined) options[key] = val;
-      return options;
-    }, {
-      headers
-    });
-    const requestContent = (request.body)
-      ? fromReadableStream(request.body)
-      : [];
-    const result = await send({
-      options: requestOptions,
-      content: requestContent,
-    });
-    let responseBody = null;
-    let responseOptions = {};
-    if (!result) {
-      responseOptions = {
-        status: 404,
-        statusText: "Error 404: Not Found",
-      };
-    } else {
-      responseOptions = result.options;
-      const responseContent = result.content;
-      if (
-        requestOptions.method !== "HEAD" &&
-        requestOptions.method !== "OPTIONS"
-      ) {
-        responseBody = toReadableStream(responseContent);
-      } else if (responseContent && responseContent.return) {
-        responseContent.return();
-      }
-    }
-    return new Response(responseBody, responseOptions);
-  };
-}
-
-/**
- * This method returns the server-side call handler transforming
- * serialized requests to HTTP Request instances, delegating
- * their handing to the given `handler` method. This handler
- * should handle the HTTP request and return a valid Response instance.
- * The resulting instance is serialized as an object with the same
- * structure as the initial serialized request:
- * - `options` - contains serialized request or response parameters
- * - `content` - an async iterator over binary blocks for
- *    the request or response
- * @param {*} handler this handler method accepts standard HTTP Request
- * and returns back an HTTP Response instance
- * @returns a method deserializing HTTP requests and returning back
- * serialized HTTP responses
- */
+	return async (requestOrPromise) => {
+		const request = await requestOrPromise;
+		const headers = [...request.headers].map(([k, v]) => [k, v]);
+		const options = {
+			url: request.url,
+			headers
+		};
+		for (const field of REQUEST_FIELDS) {
+			const val = request[field];
+			if (val !== void 0 && field !== "url") options[field] = val;
+		}
+		let content;
+		if (request.body != null) content = fromReadableStream(request.body);
+		else if (!supportsRequestStreams()) content = oneChunk(new Uint8Array(await request.arrayBuffer()));
+		else content = noBytes();
+		const result = await send({
+			options,
+			content
+		});
+		if (!result) return new Response(null, {
+			status: 404,
+			statusText: "Error 404: Not Found"
+		});
+		const responseOptions = result.options;
+		const method = options.method;
+		if (method === "HEAD" || method === "OPTIONS" || NULL_BODY_STATUSES.has(responseOptions.status)) {
+			await discard(result.content);
+			return new Response(null, responseOptions);
+		}
+		return new Response(toReadableStream(result.content[Symbol.asyncIterator]()), responseOptions);
+	};
+}
+/**
+* Returns a server-side transport handler. It deserializes the incoming
+* request envelope, delegates to `handler`, and serializes the response.
+*/
 function newHttpServerStub(handler) {
-  return async (params) => {
-    const {
-      options: requestOptions,
-      content: requestContent,
-    } = await params;
-    let requestBody = undefined;
-    const { url, mode, headers = [] } = requestOptions;
-    const requestHeaders = new Headers();
-    for (let  [key, value] of headers) {
-      requestHeaders.append(key, value);
-    }
-    delete requestOptions.mode;
-    delete requestOptions.url;
-    if (
-      requestOptions.method !== "GET" &&
-      requestOptions.method !== "HEAD" &&
-      requestOptions.method !== "OPTIONS"
-    ) {
-      requestBody = toReadableStream(requestContent);
-      requestOptions.duplex = "half";
-    } else if (requestContent && requestContent.return) {
-      requestContent.return();
-    }
-    const request = new Request(url, {
-      ...requestOptions,
-      headers: requestHeaders,
-      // duplex: 'full',
-      body: requestBody,
-    });
-    const response = await handler(request);
-    const responseOptions = {
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries([...response.headers]),
-    };
-    const responseContent = await fromReadableStream(await response.body);
-    return {
-      options: responseOptions,
-      content: responseContent,
-    };
-  };
-}
-
-async function* httpToIterator(params) {
-  const { options, content } = await params;
-  const encoder = new TextEncoder();
-  yield encoder.encode(JSON.stringify(options));
-  yield* content;
-}
-
-async function httpFromIterator(it) {
-  it = await it;
-  const { done, value } = await it.next();
-  let options = {};
-  if (!done && value) {
-    const decoder = new TextDecoder();
-    const str = decoder.decode(value);
-    options = JSON.parse(str);
-  }
-  return {
-    options,
-    content: it,
-  };
-}
-
+	return async (envelopeOrPromise) => {
+		const { options, content } = await envelopeOrPromise;
+		const { url, method, headers = [], ...rest } = options;
+		const { mode: _mode, ...forwardable } = rest;
+		const requestHeaders = new Headers();
+		for (const [key, value] of headers) requestHeaders.append(key, value);
+		const hasBody = method !== "GET" && method !== "HEAD" && method !== "OPTIONS";
+		const requestInit = {
+			...forwardable,
+			method,
+			headers: requestHeaders
+		};
+		if (!hasBody) await discard(content);
+		else if (supportsRequestStreams()) {
+			requestInit.body = toReadableStream(content[Symbol.asyncIterator]());
+			requestInit.duplex = "half";
+		} else requestInit.body = await collectBytes$1(content);
+		const response = await handler(new Request(url, requestInit));
+		return {
+			options: {
+				status: response.status,
+				statusText: response.statusText,
+				headers: Object.fromEntries([...response.headers])
+			},
+			content: response.body ? fromReadableStream(response.body) : (async function* () {})()
+		};
+	};
+}
+/**
+* Connection-scoped headers. The codec surfaces them verbatim (decision 12),
+* but they are meaningless to a `Request`/`Response`, and re-emitting them
+* from a relay would corrupt its framing.
+*/
+const HOP_BY_HOP = /* @__PURE__ */ new Set([
+	"connection",
+	"host",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+]);
+function forwardableHeaders(headers) {
+	return headers.filter(([name]) => !HOP_BY_HOP.has(name.toLowerCase()));
+}
+function headersToArray(headers) {
+	const out = [];
+	headers.forEach((value, key) => {
+		out.push([key, value]);
+	});
+	return out;
+}
+async function* readableToAsyncIterable(stream) {
+	if (!stream) return;
+	const reader = stream.getReader();
+	let consumed = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				consumed = true;
+				return;
+			}
+			if (value) yield value;
+		}
+	} finally {
+		if (!consumed) try {
+			await reader.cancel();
+		} catch {}
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
+function asyncIterableToReadable(iter) {
+	const it = iter[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await it.next();
+				if (done) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(value);
+			} catch (err) {
+				controller.error(err);
+			}
+		},
+		async cancel() {
+			await it.return?.();
+		}
+	});
+}
+/**
+* Run a `Request` through a `Duplex` call and reconstruct the `Response` on
+* the other side. The request's `signal` is plumbed into the body iteration —
+* abort terminates the underlying call.
+*/
+async function fetchOverDuplex(call, request, options = {}) {
+	if (request.signal?.aborted) throw abortReason(request.signal);
+	const env = {
+		url: request.url,
+		method: request.method,
+		headers: headersToArray(request.headers)
+	};
+	let body;
+	if (request.body != null) body = readableToAsyncIterable(request.body);
+	else if (!supportsRequestStreams()) {
+		const buffered = new Uint8Array(await request.arrayBuffer());
+		if (buffered.byteLength > 0) body = [buffered];
+	}
+	const { envelope, body: respBody } = await httpFetch(call, env, body, options);
+	const responseInit = {
+		status: envelope.status,
+		statusText: envelope.statusText,
+		headers: forwardableHeaders(envelope.headers)
+	};
+	if (request.method === "HEAD" || request.method === "OPTIONS" || NULL_BODY_STATUSES.has(envelope.status)) {
+		await respBody.return?.();
+		return new Response(null, responseInit);
+	}
+	return new Response(asyncIterableToReadable(withAbort(respBody, request.signal)), responseInit);
+}
+/**
+* Wrap a `(Request) => Promise<Response>` handler as a `Duplex` so it can be
+* registered with any `webrun-streams-*` adapter's `serve`.
+*/
+function serveFetchOverDuplex(handler, options = {}) {
+	return httpServe(async (env, body) => {
+		const reqInit = {
+			method: env.method,
+			headers: forwardableHeaders(env.headers)
+		};
+		if (env.method !== "GET" && env.method !== "HEAD") {
+			if (supportsRequestStreams()) {
+				reqInit.body = asyncIterableToReadable(body);
+				reqInit.duplex = "half";
+			} else reqInit.body = await collectBytes$1(body);
+		}
+		const response = await handler(new Request(env.url, reqInit));
+		const respEnv = {
+			status: response.status,
+			statusText: response.statusText,
+			headers: headersToArray(response.headers)
+		};
+		if (env.method === "HEAD" || env.method === "OPTIONS" || NULL_BODY_STATUSES.has(response.status)) {
+			await response.body?.cancel();
+			return {
+				envelope: respEnv,
+				body: void 0
+			};
+		}
+		return {
+			envelope: respEnv,
+			body: response.body ? readableToAsyncIterable(response.body) : void 0
+		};
+	}, options);
+}
+async function* withAbort(iter, signal) {
+	if (!signal) {
+		yield* iter;
+		return;
+	}
+	for await (const chunk of iter) {
+		if (signal.aborted) throw abortReason(signal);
+		yield chunk;
+	}
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	const err = new Error(reason === void 0 ? "Aborted" : String(reason));
+	err.name = "AbortError";
+	return err;
+}
+/**
+* Host a `SiteHandler` over a `Connect/Serve` pair. The `start(serve, params)`
+* call hands the handler to any `webrun-streams-*` adapter's `serve`.
+*
+* ```ts
+* import { SiteBuilder } from "@statewalker/webrun-site-builder";
+* import { DuplexSiteBuilder } from "@statewalker/webrun-http-streams";
+* import { serve } from "@statewalker/webrun-rpc";
+*
+* const handler = new SiteBuilder()
+*   .setEndpoint("/api/time", () => new Response(new Date().toISOString()))
+*   .build();
+*
+* const stop = await new DuplexSiteBuilder().setHandler(handler).start(serve, { port });
+* // later: await stop();
+* ```
+*
+* Holds no site-configuration state. Endpoints, files, auth belong to the
+* `SiteHandler` producer (typically `SiteBuilder`).
+*/
+var DuplexSiteBuilder = class {
+	#handler;
+	#codec;
+	setHandler(handler) {
+		this.#handler = handler;
+		return this;
+	}
+	/** Pin the wire format. Defaults to HTTP/1.1 with legacy acceptance. */
+	setCodec(codec) {
+		this.#codec = codec;
+		return this;
+	}
+	async start(serve, params) {
+		if (!this.#handler) throw new Error("DuplexSiteBuilder.start: setHandler(handler) must be called before start()");
+		const handler = this.#handler;
+		return serve(params, serveFetchOverDuplex(async (req) => handler(req), { codec: this.#codec }));
+	}
+};
+var HttpError = class HttpError extends Error {
+	status;
+	statusText;
+	constructor(options = {}) {
+		super(options.message ?? options.statusText ?? "HTTP Error");
+		this.status = options.status;
+		this.statusText = options.statusText;
+	}
+	getResponseOptions(options = {}) {
+		return {
+			...this.toJson(),
+			...options
+		};
+	}
+	toJson() {
+		return {
+			status: this.status,
+			statusText: this.statusText,
+			message: this.message
+		};
+	}
+	static fromError(error) {
+		if (error instanceof HttpError) return error;
+		const message = error instanceof Error ? error.message : String(error);
+		return new HttpError({
+			status: 500,
+			statusText: "Bad Request",
+			message
+		});
+	}
+	static errorResourceNotFound(options = {}) {
+		return new HttpError({
+			status: 404,
+			statusText: "Error 404: Resource not found",
+			...options
+		});
+	}
+	static errorForbidden(options = {}) {
+		return new HttpError({
+			status: 403,
+			statusText: "Error 403: Forbidden",
+			...options
+		});
+	}
+	static errorResourceGone(options = {}) {
+		return new HttpError({
+			status: 410,
+			statusText: "Error 410: Resource Gone",
+			...options
+		});
+	}
+	static errorInternalError(options = {}) {
+		return new HttpError({
+			...options,
+			status: 500,
+			statusText: "Error 500: Internal error"
+		});
+	}
+};
+//#endregion
+//#region src/http/http-send-recieve.ts
+async function* httpToIterator(envelopeOrPromise) {
+	const { options, content } = await envelopeOrPromise;
+	yield new TextEncoder().encode(JSON.stringify(options));
+	yield* content;
+}
+async function httpFromIterator(iterable) {
+	const it = (await iterable)[Symbol.asyncIterator]();
+	const { done, value } = await it.next();
+	let options = {};
+	if (!done && value) {
+		const str = new TextDecoder().decode(value);
+		options = JSON.parse(str);
+	}
+	return {
+		options,
+		content: { [Symbol.asyncIterator]() {
+			return it;
+		} }
+	};
+}
+/**
+* Serve an `HttpHandler` over a `MessageTarget`, using this package's own
+* `handleStreams` transport.
+*
+* @deprecated Prefer the port stack in `@statewalker/webrun-rpc`: open a port
+* (`multiplexPort` over one pipe, or `transferPortMux` where the platform can
+* transfer a real `MessagePort`), turn it into a `Duplex` with
+* `serveDuplexOverPort`, and serve HTTP on that with
+* `httpServe(handler, options)` from `@statewalker/webrun-http-streams`.
+*
+* That path has backpressure; **this one does not.** `sendStream`'s chunk
+* sender discards the promise it is given, so a fast producer over a slow
+* consumer accumulates without bound. It also has no per-stream timeout and no
+* chunking to a transport's message ceiling.
+*
+* Kept for existing ServiceWorker setups built on the `MessageTarget` surface.
+*/
 function handleHttpRequests(communicationPort, handler) {
-  const serverStub = newHttpServerStub(handler);
-  return handleStreams(communicationPort, (it) => {
-    return httpToIterator(serverStub(httpFromIterator(it)));
-  });
+	const serverStub = newHttpServerStub(handler);
+	return handleStreams(communicationPort, async (it) => {
+		const envelope = await httpFromIterator(it);
+		return httpToIterator(await serverStub(envelope));
+	});
 }
-
+/**
+* Ship a `Request` over a `MessageTarget` and await the `Response`, using this
+* package's own `sendStream` transport.
+*
+* @deprecated Prefer the port stack in `@statewalker/webrun-rpc`: open a port
+* (`multiplexPort` over one pipe, or `transferPortMux` where the platform can
+* transfer a real `MessagePort`), turn it into a `Duplex` with
+* `duplexOverPort`, and drive HTTP over it with `httpFetch` from
+* `@statewalker/webrun-http-streams`.
+*
+* Same caveat as {@link handleHttpRequests}: the transport underneath this
+* helper has no backpressure, no per-stream timeout, and no chunking to a
+* transport's message ceiling. Kept for existing ServiceWorker setups.
+*/
 async function sendHttpRequest(communicationPort, request) {
-  const clientStub = newHttpClientStub(async (req) => {
-    return await httpFromIterator(
-      sendStream(communicationPort, httpToIterator(req)),
-    );
-  });
-  return await clientStub(request);
-}
-
+	return await newHttpClientStub(async (req) => {
+		return await httpFromIterator(sendStream(communicationPort, httpToIterator(req)));
+	})(request);
+}
+//#endregion
+//#region src/relay/split-service-url.ts
+/**
+* Splits a URL of the form `<base>/<separator><key>/<path>` into parts.
+* Example: `https://host/~FS/a/b` → `{ baseUrl: "https://host/~FS/", key: "FS", path: "a/b" }`.
+*/
 function splitServiceUrl(url, separator = "~") {
-  let key = "";
-  let path = "";
-  let str = url + "";
-  const idx = str.indexOf(separator);
-  let baseUrl = "";
-  if (idx >= 0) {
-    baseUrl = str.substring(0, idx + separator.length);
-    str.substring(idx + separator.length)
-      .replace(/^([^\/]+)/, (match, $1) => {
-        baseUrl += match;
-        if (baseUrl.length < str.length) baseUrl += "/";
-        key = $1;
-        path = str.substring(baseUrl.length);
-        return "";
-      });
-  }
-  return {
-    url,
-    key,
-    baseUrl,
-    path,
-  };
-}
-
+	const str = `${url}`;
+	const idx = str.indexOf(separator);
+	let baseUrl = "";
+	let key = "";
+	let path = "";
+	if (idx >= 0) {
+		baseUrl = str.substring(0, idx + separator.length);
+		str.substring(idx + separator.length).replace(/^([^/]+)/, (match, $1) => {
+			baseUrl += match;
+			if (baseUrl.length < str.length) baseUrl += "/";
+			key = $1;
+			path = str.substring(baseUrl.length);
+			return "";
+		});
+	}
+	return {
+		url: str,
+		key,
+		baseUrl,
+		path
+	};
+}
+//#endregion
+//#region src/relay/index.ts
+/**
+* Returns a MessagePort that transparently bridges messages to/from the
+* ServiceWorker controlling this page.
+*/
 function newServiceWorkerPort() {
-  // Bind the service worker to
-  const channel = new MessageChannel();
-  channel.port1.onmessage = (event) => {
-    navigator.serviceWorker.controller.postMessage(event.data, event.ports);
-  };
-  navigator.serviceWorker.addEventListener("message", (event) => {
-    channel.port1.postMessage(event.data, event.ports);
-  });
-  return channel.port2;
-}
-
-async function initServiceWorker1({ swUrl, scopeUrl, type }) {
-  const {
-    installing,
-    waiting,
-    active,
-  } = await navigator.serviceWorker.register(swUrl, {
-    // type: "module",
-    scope: scopeUrl,
-  });
-  (installing || waiting || active).addEventListener("statechange", (e) => {
-    console.log("state", e.target.state);
-  });
-
-  const serviceWorker = navigator.serviceWorker;
-  await new Promise((resolve) => {
-    // Resolve right away if this page is already controlled.
-    if (serviceWorker.controller) {
-      resolve();
-    } else {
-      const onChange = () => {
-        resolve();
-        serviceWorker.removeEventListener("controllerchange", onChange);
-        serviceWorker.oncontrollerchange = null;
-      };
-      serviceWorker.addEventListener("controllerchange", onChange);
-      serviceWorker.oncontrollerchange = onChange;
-    }
-  });
-  const worker = serviceWorker.controller;
-  const isActivated = () => worker.state === "activated";
-  return await new Promise(async (resolve) => {
-    if (isActivated()) resolve(worker);
-    else {
-      worker.onstatechange = () => {
-        if (!isActivated()) return;
-        worker.onstatechange = null;
-        resolve(worker);
-      };
-    }
-  });
-}
-
+	const channel = new MessageChannel();
+	channel.port1.onmessage = (event) => {
+		navigator.serviceWorker.controller?.postMessage(event.data, [...event.ports]);
+	};
+	navigator.serviceWorker.addEventListener("message", (event) => {
+		channel.port1.postMessage(event.data, [...event.ports]);
+	});
+	return channel.port2;
+}
+/**
+* Registers a ServiceWorker and resolves once it's activated and controlling the page.
+*/
 async function initServiceWorker({ swUrl, scopeUrl, type }) {
-  await navigator.serviceWorker.register(swUrl, {
-    type,
-    scope: scopeUrl,
-  });
-  const worker = await getServiceWorkerController();
-  await awaitServiceWorkerActivation(worker);
-  return worker;
-
-  async function getServiceWorkerController() {
-    return await new Promise((resolve) => {
-      // Resolve right away if this page is already controlled.
-      const serviceWorker = navigator.serviceWorker;
-      if (serviceWorker.controller) {
-        resolve(serviceWorker.controller);
-      } else {
-        const onChange = () => {
-          resolve(serviceWorker.controller);
-          serviceWorker.removeEventListener("controllerchange", onChange);
-          serviceWorker.oncontrollerchange = null;
-        };
-        serviceWorker.addEventListener("controllerchange", onChange);
-        serviceWorker.oncontrollerchange = onChange;
-      }
-    });
-  }
-
-  // ------------------------------
-  // Await until the service is ready
-  async function awaitServiceWorkerActivation(worker) {
-    const isActivated = () => worker.state === "activated";
-    await new Promise(async (resolve) => {
-      if (isActivated()) resolve();
-      else {
-        worker.onstatechange = () => {
-          if (!isActivated()) return;
-          worker.onstatechange = null;
-          resolve();
-        };
-      }
-    });
-  }
-}
-
-async function initHttpService(handler, {
-  key,
-  port,
-}) {
-  return await registerConnectionsHandler({
-    key,
-    communicationPort: port,
-    handler: async (event, data, callPort) => {
-      handleHttpRequests(callPort, handler);
-      return true;
-    },
-  });
-}
-
-async function callHttpService(request, {
-  key,
-  port,
-}) {
-  const callPort = await initializeConnection({
-    key,
-    communicationPort: port,
-  });
-  const result = await sendHttpRequest(callPort, request);
-  return result;
-}
-
-function getRelayWindowMessageHandler({
-  swUrl = new URL("./index-sw.js", import.meta.url) + "",
-  scopeUrl = new URL("../", import.meta.url) + "",
-} = {}) {
-  let externalPort;
-  return async (ev) => {
-    if (ev.data.type === "CONNECT") {
-      const newExternalPort = (ev.ports || [])[0];
-      if (externalPort) {
-        newExternalPort.close();
-        return;
-      }
-      externalPort = newExternalPort;
-      await initServiceWorker({
-        swUrl,
-        scopeUrl,
-      });
-      const serviceWorkerPort = newServiceWorkerPort();
-      serviceWorkerPort.onmessage = (event) => {
-        externalPort.postMessage(event.data, event.ports);
-      };
-
-      externalPort.onmessage = (event) => {
-        serviceWorkerPort.postMessage(event.data, event.ports);
-      };
-    }
-  };
-}
-
-async function newRemoteRelayChannel({
-  baseUrl = new URL("../public-relay/", import.meta.url),
-  url = new URL("relay.html", baseUrl),
-  container = document.body,
-} = {}) {
-  const messageChannel = new MessageChannel();
-  const { iframe, promise } = await newIFrame(url);
-  Object.assign(iframe.style, {
-    // height: "100px"
-    position: "fixed",
-    width: "1px",
-    height: "1px",
-    top: "-1000",
-    left: "-1000",
-    display: "block",
-    opacity: "0",
-    border: "none",
-    outline: "none",
-  });
-  container.appendChild(iframe);
-  promise.then(() => {
-    iframe.contentWindow.postMessage(
-      {
-        type: "CONNECT",
-      },
-      "*",
-      [messageChannel.port1],
-    );
-  });
-  return {
-    baseUrl,
-    port: messageChannel.port2,
-    close: () => {
-      iframe.parentElement && iframe.parentElement.removeChild(iframe);
-      messageChannel.port1.close();
-      messageChannel.port2.close();
-    },
-  };
-
-  async function newIFrame(url) {
-    const iframe = document.createElement("iframe");
-    iframe.src = url;
-    Object.assign(iframe.style, {
-      padding: 0,
-      margin: 0,
-      border: "none",
-      outline: "none",
-      width: "100%",
-      height: "100%",
-    });
-    return {
-      iframe,
-      promise: new Promise((resolve, reject) => {
-        try {
-          iframe.onerror = reject;
-          iframe.onload = () => resolve(iframe);
-        } catch (error) {
-          reject(error);
-        }
-      }),
-    };
-  }
-}
-// -------------------------------------------------------
-
-async function initializeConnection({
-  key,
-  communicationPort,
-  ...options
-}) {
-  const channel = new MessageChannel();
-  const accepted = await callChannel(
-    communicationPort,
-    "CONNECT",
-    { key, ...options },
-    channel.port2,
-  );
-  if (!accepted) {
-    channel.port1.close();
-    channel.port2.close();
-    return null;
-  }
-  return channel.port1;
-}
-
-async function registerConnectionsHandler({
-  key,
-  handler,
-  communicationPort,
-}) {
-  const [register, cleanup] = newRegistry();
-  await callChannel(communicationPort, "REGISTER", { key });
-  register(() => callChannel(communicationPort, "UNREGISTER", { key }));
-  register(
-    handleChannelCalls(
-      communicationPort,
-      "CONNECT",
-      handler,
-    ),
-  );
-  return cleanup;
-}
-
-export { callChannel, callHttpService, deserializeError, fromReadableStream, getRelayWindowMessageHandler, handleChannelCalls, handleHttpRequests, handleStreams, initHttpService, initServiceWorker, initServiceWorker1, initializeConnection, newHttpClientStub, newHttpServerStub, newInvokationChannel, newRegistry, newRemoteRelayChannel, newServiceWorkerPort, recieveData, registerConnectionsHandler, sendData, sendHttpRequest, sendStream, serializeError, splitServiceUrl, toReadableStream };
+	await navigator.serviceWorker.register(swUrl, {
+		type,
+		scope: scopeUrl
+	});
+	const worker = await getServiceWorkerController();
+	await awaitServiceWorkerActivation(worker);
+	return worker;
+}
+function getServiceWorkerController() {
+	return new Promise((resolve) => {
+		const container = navigator.serviceWorker;
+		if (container.controller) {
+			resolve(container.controller);
+			return;
+		}
+		const onChange = () => {
+			if (!container.controller) return;
+			resolve(container.controller);
+			container.removeEventListener("controllerchange", onChange);
+		};
+		container.addEventListener("controllerchange", onChange);
+	});
+}
+function awaitServiceWorkerActivation(worker) {
+	return new Promise((resolve) => {
+		if (worker.state === "activated") {
+			resolve();
+			return;
+		}
+		const onStateChange = () => {
+			if (worker.state !== "activated") return;
+			worker.removeEventListener("statechange", onStateChange);
+			resolve();
+		};
+		worker.addEventListener("statechange", onStateChange);
+	});
+}
+/**
+* Registers `handler` as the server for the given service `key` on the relay.
+* Returns a cleanup function that unregisters the service.
+*/
+async function initHttpService(handler, { key, port }) {
+	return await registerConnectionsHandler({
+		key,
+		communicationPort: port,
+		handler: async (_event, _data, callPort) => {
+			handleHttpRequests(callPort, handler);
+			return true;
+		}
+	});
+}
+/**
+* Sends a `Request` to the service registered under `key` on the relay and
+* resolves with the corresponding `Response`.
+*/
+async function callHttpService(request, { key, port }) {
+	const callPort = await initializeConnection({
+		key,
+		communicationPort: port
+	});
+	if (!callPort) throw new Error(`No service with key "${key}"`);
+	return await sendHttpRequest(callPort, request);
+}
+/**
+* Returns a `window.onmessage` handler for use inside the relay iframe:
+* it accepts a CONNECT message, starts the relay ServiceWorker, and bridges
+* the parent's MessagePort with the SW.
+*/
+function getRelayWindowMessageHandler({ swUrl = `${new URL("./index-sw.js", import.meta.url)}`, scopeUrl = `${new URL("../", import.meta.url)}` } = {}) {
+	let externalPort;
+	return async (ev) => {
+		if (ev.data?.type !== "CONNECT") return;
+		const newExternalPort = ev.ports?.[0];
+		if (!newExternalPort) return;
+		if (externalPort) {
+			newExternalPort.close();
+			return;
+		}
+		externalPort = newExternalPort;
+		await initServiceWorker({
+			swUrl,
+			scopeUrl
+		});
+		const serviceWorkerPort = newServiceWorkerPort();
+		serviceWorkerPort.onmessage = (event) => {
+			externalPort?.postMessage(event.data, [...event.ports]);
+		};
+		externalPort.onmessage = (event) => {
+			serviceWorkerPort.postMessage(event.data, [...event.ports]);
+		};
+	};
+}
+/**
+* Embeds a hidden relay iframe, establishes a MessageChannel with it, and
+* returns the port to be used with `initHttpService` / `callHttpService`.
+*/
+async function newRemoteRelayChannel({ baseUrl = new URL("../public-relay/", import.meta.url), url = new URL("relay.html", baseUrl), container = document.body } = {}) {
+	const messageChannel = new MessageChannel();
+	const { iframe, promise } = newIFrame(url);
+	Object.assign(iframe.style, {
+		position: "fixed",
+		width: "1px",
+		height: "1px",
+		top: "-1000px",
+		left: "-1000px",
+		display: "block",
+		opacity: "0",
+		border: "none",
+		outline: "none"
+	});
+	container.appendChild(iframe);
+	promise.then(() => {
+		iframe.contentWindow?.postMessage({ type: "CONNECT" }, "*", [messageChannel.port1]);
+	});
+	return {
+		baseUrl,
+		port: messageChannel.port2,
+		close: () => {
+			iframe.parentElement?.removeChild(iframe);
+			messageChannel.port1.close();
+			messageChannel.port2.close();
+		}
+	};
+	function newIFrame(src) {
+		const iframe = document.createElement("iframe");
+		iframe.src = `${src}`;
+		Object.assign(iframe.style, {
+			padding: "0",
+			margin: "0",
+			border: "none",
+			outline: "none",
+			width: "100%",
+			height: "100%"
+		});
+		return {
+			iframe,
+			promise: new Promise((resolve, reject) => {
+				iframe.onerror = () => reject(/* @__PURE__ */ new Error(`Failed to load ${src}`));
+				iframe.onload = () => resolve(iframe);
+			})
+		};
+	}
+}
+async function initializeConnection({ key, communicationPort, ...options }) {
+	const channel = new MessageChannel();
+	if (!await callChannel(communicationPort, "CONNECT", {
+		key,
+		...options
+	}, channel.port2)) {
+		channel.port1.close();
+		channel.port2.close();
+		return null;
+	}
+	return channel.port1;
+}
+async function registerConnectionsHandler({ key, handler, communicationPort }) {
+	const [register, cleanup] = newRegistry();
+	await callChannel(communicationPort, "REGISTER", { key });
+	register(() => callChannel(communicationPort, "UNREGISTER", { key }));
+	register(handleChannelCalls(communicationPort, "CONNECT", async (event, data, port) => {
+		return await handler(event, data, port);
+	}));
+	return cleanup;
+}
+//#endregion
+export { DuplexSiteBuilder, HttpError, HttpParseError, PEER_ERROR_HEADER, TransportClosedError, callChannel, callHttpService, collect, collectBytes, collectString, decodeJsonl, decodeMessage, decodeText, defaultCodec, deserializeError, emulateMux, encodeJsonl, encodeMessage, encodeText, fetchOverDuplex, fromReadableStream, getRelayWindowMessageHandler, handleChannelCalls, handleHttpRequests, handleStreams, httpCodec, httpFetch, httpServe, initHttpService, initServiceWorker, initializeConnection, joinLines, jsonEnvelopeCodec, map, newAsyncGenerator, newCreditGrantor, newCreditLedger, newHttpClientStub, newHttpCodec, newHttpServerStub, newInvokationChannel, newRegistry, newRemoteRelayChannel, newServiceWorkerPort, newSniffingCodec, normalizeToUint8Array, recieveIterator, registerConnectionsHandler, sendHttpRequest, sendIterator, sendStream, serializeError, serveFetchOverDuplex, splitLines, splitServiceUrl, toChunks, toReadableStream };