@statewalker/webrun-http-streams 0.1.1 → 0.2.2

package/README.md

@@ -1,50 +1,398 @@
 # @statewalker/webrun-http-streams
 
-HTTP request / response over a `Duplex` from any `webrun-streams-*` adapter. Replaces `webrun-http` + `webrun-http-port`.
+HTTP request / response over a `Duplex` from any `webrun-streams-*` adapter.
+Replaces the retired `webrun-http` + `webrun-http-port` packages.
 
-## Three layers
+## Install
+
+```sh
+npm install @statewalker/webrun-http-streams
+```
+
+One runtime dependency, [`@statewalker/webrun-streams`](../webrun-streams); no
+peer dependencies. ESM only (`"type": "module"`). Needs standard `Request`,
+`Response`, `ReadableStream`, `TextEncoder` and `TextDecoder` — present in
+browsers, Node 18+, Deno, Bun and Cloudflare Workers.
+
+Pair it with a transport adapter to get a `Duplex`:
+[`-ws`](../webrun-streams-ws), [`webrun-rpc`](../webrun-rpc),
+[`-webrtc`](../webrun-streams-webrtc), [`-libp2p`](../webrun-streams-libp2p),
+[`-livekit`](../webrun-streams-livekit), [`-peerjs`](../webrun-streams-peerjs).
+
+## Getting started
+
+Pick a transport, then move standard `Request` / `Response` objects across it.
+Here the transport is an in-process `MessageChannel`, so the whole exchange runs
+in one process with no network:
+
+```ts
+import { connect, serve } from "@statewalker/webrun-rpc";
+import { fetchOverDuplex, serveFetchOverDuplex } from "@statewalker/webrun-http-streams";
+
+// --- server side ---
+const channel = new MessageChannel();
+const stop = await serve(
+  { port: channel.port2 },
+  serveFetchOverDuplex(async (request) => {
+    const url = new URL(request.url);
+    return Response.json({ path: url.pathname, method: request.method });
+  }),
+);
+
+// --- client side ---
+const { call, close } = await connect({ port: channel.port1 });
+const response = await fetchOverDuplex(call, new Request("http://local/api/todo/7"));
+
+console.log(response.status);        // 200
+console.log(await response.json());  // { path: "/api/todo/7", method: "GET" }
+
+await close();
+await stop();
+```
+
+Swap `@statewalker/webrun-rpc` for
+[`-ws`](../webrun-streams-ws), [`-webrtc`](../webrun-streams-webrtc),
+[`-libp2p`](../webrun-streams-libp2p), [`-livekit`](../webrun-streams-livekit)
+or [`-peerjs`](../webrun-streams-peerjs) and nothing else changes — that is the
+whole point of the `Duplex` seam.
+
+Streaming bodies work as you would expect: a `Response` whose body is a
+`ReadableStream` streams across the transport chunk by chunk, which is what
+makes server-sent events work over a `MessagePort` or a WebRTC link.
+
+## Layers
+
+Three of them sit on the `Duplex` seam, plus one older transport-agnostic pair
+that predates it and is kept for `webrun-http-browser`.
 
 ### Data layer — `httpFetch` / `httpServe`
 
+Envelopes and body iterators, no `Request`/`Response` involved.
+
 ```ts
 import { httpFetch, httpServe } from "@statewalker/webrun-http-streams";
-import { connect } from "@statewalker/webrun-streams-ws";
 
-const { call } = await connect({ url });
+// `call` is a Duplex. In-process it can be the handler itself; over a
+// transport it comes from an adapter's `connect`:
+//   const { call } = await connect({ url });   // webrun-streams-ws
+const call = httpServe(async (env, body) => {
+  for await (const _chunk of body) {
+    /* drain the request body */
+  }
+  return {
+    envelope: { status: 200, statusText: "OK", headers: [["content-type", "text/plain"]] },
+    body: [new TextEncoder().encode(`hello ${new URL(env.url).pathname}`)],
+  };
+});
+
 const { envelope, body } = await httpFetch(call, {
-  url: "/api/time",
+  url: "http://peer.test/api/time",
   method: "GET",
   headers: [],
 });
+// envelope.status === 200; `body` is an AsyncIterable<Uint8Array>
 ```
 
-`httpServe(handler)` returns a `Duplex` you can hand to any adapter's `serve(...)`.
+`httpServe(handler)` returns a `Duplex` you can hand to any adapter's
+`serve(...)`. Because a `Duplex` is just `(input) => AsyncGenerator<Uint8Array>`,
+the handler side *is* a usable `call` with no transport at all — that is what
+the snippet above does, and it is the cheapest way to test a handler.
+
+A relative `url` in the envelope works, but note it does not survive the round
+trip verbatim: HTTP/1.1 origin-form carries no scheme or authority, so the
+decoder rebuilds an absolute url from the codec's `scheme`/`host` options.
+`url: "/api/time"` arrives at the handler as `http://localhost/api/time` unless
+you configure the codec (see below).
 
 ### Fetch layer — `fetchOverDuplex` / `serveFetchOverDuplex`
 
+The same thing in terms of standard `Request` / `Response`.
+
 ```ts
-const response = await fetchOverDuplex(call, new Request("/api/time"));
+import { fetchOverDuplex, serveFetchOverDuplex } from "@statewalker/webrun-http-streams";
+
+const call = serveFetchOverDuplex(
+  async (request) => new Response(`hello ${new URL(request.url).pathname}`),
+);
+const response = await fetchOverDuplex(call, new Request("http://peer.test/api/time"));
+await response.text(); // "hello /api/time"
 ```
 
-`serveFetchOverDuplex(handler)` adapts a `(Request) => Promise<Response>` handler.
+Hop-by-hop headers (`connection`, `transfer-encoding`, `host`, …) are stripped
+in both directions: the codec surfaces them verbatim, but they are meaningless
+to a `Request`/`Response` and re-emitting them from a relay would corrupt its
+framing.
+
+`fetchOverDuplex` plumbs `request.signal` into body iteration, so aborting the
+signal terminates the call.
 
 ### Site host — `DuplexSiteBuilder`
 
 ```ts
 import { DuplexSiteBuilder } from "@statewalker/webrun-http-streams";
-import { serve } from "@statewalker/webrun-streams-port";
+import { serve } from "@statewalker/webrun-rpc";
 
 const stop = await new DuplexSiteBuilder()
-  .setHandler(siteHandler)
+  .setHandler(siteHandler) // (Request) => Promise<Response>
   .start(serve, { port });
+// later: await stop();
 ```
 
-`DuplexSiteBuilder` is the cross-platform sibling of `HostedSiteBuilder` (browser+SW) — same `SiteHandler` seam, different transport.
+`.setCodec(codec)` pins the wire format. `DuplexSiteBuilder` is the
+cross-platform sibling of `HostedSiteBuilder` (browser + ServiceWorker) — same
+`SiteHandler` seam, different transport. It holds no site configuration of its
+own; endpoints, files and auth belong to the `SiteHandler` producer (typically
+`SiteBuilder`).
+
+> Not runnable as written above: it needs a live `MessagePort` and
+> `@statewalker/webrun-rpc`, which this package does not depend on.
+> `start` accepts any `Serve<P>`, so an in-process one is enough to exercise
+> it. Calling `start()` before `setHandler()` throws.
+
+### Transport-agnostic stubs — `newHttpClientStub` / `newHttpServerStub`
+
+Predates the `Duplex` seam and does **not** use it. Instead of bytes on a wire,
+these move a `SerializedHttpEnvelope` — a plain options object plus a body
+iterable — over whatever `send` function you give them. `webrun-http-browser`
+is built on this pair, because a MessagePort can structured-clone the envelope
+directly and never needs a byte encoding.
+
+```ts
+import { newHttpClientStub, newHttpServerStub } from "@statewalker/webrun-http-streams";
+
+const server = newHttpServerStub(async (request) => new Response(`echo ${await request.text()}`));
+const client = newHttpClientStub(server); // `send` is anything envelope-in, envelope-out
+
+const res = await client(new Request("http://peer.test/x", { method: "POST", body: "hi" }));
+await res.text(); // "echo hi"
+```
+
+A `send` that resolves `undefined` — no service registered for this call —
+becomes a `404` on the client side. `SerializedHttpEnvelope.content` must be
+*productive*: it has to yield or finish on its own, because a body neither stub
+is allowed to read is released by draining it, not by a bare `.return()`.
+
+Use the `Duplex` layers for anything new. These stay because the browser
+package's MessagePort transport is built around them.
 
 ## Wire format
 
-`<JSON.stringify(envelope)>\n<body bytes…>` — newline-delimited JSON header followed by raw body bytes. Same shape as the legacy `webrun-http-port` so a future bridging adapter could interop.
+Conforming **HTTP/1.1** by default — a `Duplex` carries bytes a real HTTP
+implementation can parse, and accepts bytes a real HTTP implementation
+produces. Verified against `node:http` in both directions.
+
+```
+POST /api?a=1 HTTP/1.1
+Host: peer.test
+Connection: close
+Transfer-Encoding: chunked
+
+5
+hello
+0
+
+```
+
+One message per `Duplex` call: `Connection: close` is always emitted, and bytes
+after a complete message are an error. Bodies use `Content-Length` when the
+caller declares one and chunked transfer coding otherwise; a message declaring
+both is refused.
+
+The codec is deliberately strict: every ambiguity is a refusal rather than a
+guess. One consequence worth calling out explicitly — RFC 9112 §2.2 permits a
+recipient to *tolerate* a single leading CRLF sent before the request-line
+("SHOULD ignore"). This codec declines that leniency and refuses it as a
+malformed request line; see ADR-0006.
+
+### Bodyless messages
+
+Responses with a null-body status — **204, 205, 304** — and responses to `HEAD`
+or `OPTIONS` put no bytes on the wire, in both directions, even if the
+handler's `Response` carries a body stream. The handler's stream is cancelled
+rather than sent. On the reading side you get `new Response(null, init)`, whose
+`.body` is `null`.
+
+The internal null-body set also lists 101 and 103, but neither is reachable
+through the fetch layer: `ResponseInit.status` must be 200–599, so
+`fetchOverDuplex` throws a `TypeError` from the `Response` constructor if a
+peer answers with one. Use the data layer (`httpFetch`) if you need to see an
+informational status.
+
+### Choosing a codec
+
+```ts
+import {
+  defaultCodec,
+  httpCodec,
+  jsonEnvelopeCodec,
+  newHttpCodec,
+  newSniffingCodec,
+} from "@statewalker/webrun-http-streams";
+
+// default: writes HTTP/1.1, accepts HTTP/1.1 or the legacy JSON envelope
+await httpFetch(call, env);
+
+// pinned
+await httpFetch(call, env, body, { codec: httpCodec });
+
+// the scheme and authority are not on the HTTP/1.1 wire; supply them here
+const codec = newHttpCodec({ scheme: "https", host: "peer.test" });
+```
+
+| `newHttpCodec` option | Default | Meaning |
+| --- | --- | --- |
+| `scheme` | `"http"` | Scheme used to rebuild an absolute url on decode. Configuration, not wire data — a peer configured `http` rebuilds an `https` url as `http`. |
+| `host` | `"localhost"` | Authority used when a url carries none. Also fills the mandatory `Host` header. |
+| `maxHeaderBytes` | `65536` | Bound on the whole head section, start line included. |
+
+`httpCodec` is `newHttpCodec()` with those defaults. `defaultCodec` — used
+whenever no `codec` option is supplied — is
+`newSniffingCodec({ write: httpCodec, accept: [httpCodec, jsonEnvelopeCodec] })`.
+
+The previous format — `<JSON.stringify(envelope)>` + newline + body bytes —
+remains available as `jsonEnvelopeCodec` (and as the raw `encodeMessage` /
+`decodeMessage` pair), and readers accept it automatically, so the two ends of
+a peer pair can be upgraded in either order. A server answers in whichever
+format read the request. Sniffing needs no handshake because 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. See ADR-0006.
+
+## Browser support
+
+Everything here is built on `Request`, `Response`, `ReadableStream`,
+`TextEncoder` and `TextDecoder`. Browsers do **not** behave uniformly, and one
+difference is large enough to change what this package can do.
+
+**Firefox does not implement `Request.prototype.body`** (checked against
+Firefox 146). `Object.getOwnPropertyDescriptor(Request.prototype, "body")` is
+`null` — the accessor is genuinely absent — and because a `ReadableStream` is
+then not a recognised `BodyInit`, `new Request(url, { body: stream })` falls
+through to the string branch and stores the literal text
+`[object ReadableStream]`.
+
+Both directions have a fallback, and both cost the same thing:
+
+- **Sending** (`fetchOverDuplex`, `newHttpClientStub`) — with no
+  `request.body` to stream from, the whole payload is buffered with
+  `request.arrayBuffer()` before it goes on the wire.
+- **Receiving** (`serveFetchOverDuplex`, `newHttpServerStub`) — the request
+  body is drained into one contiguous buffer before the `Request` handed to
+  your handler is constructed. Without this the handler would silently read the
+  string `[object ReadableStream]` and answer `200` with corrupt data.
+
+So on Firefox: **request streaming does not happen**. A 1 GiB upload from a
+Firefox page is a 1 GiB allocation, where Chromium and Node stream it chunk by
+chunk. Response streaming is unaffected — `Response.body` exists everywhere.
+
+The check is a capability probe, not a user-agent test, so it flips on its own
+the day Firefox ships request streams. Safari is untested and is the case to
+look at first if a report arrives: 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 takes the streaming
+branch here.
+
+One further divergence, on the sending side only: buffering cannot distinguish
+an absent body from an empty one. Chromium's
+`new Request(url, { method: "POST", body: "" })` yields a non-null empty
+stream, so an empty body is framed on the wire; on the Firefox path a
+zero-length `arrayBuffer()` is indistinguishable from no body and none is sent.
+Both decode to the same empty body at the far end, so only the framing differs.
+This does not arise for the stubs, whose envelope always carries a `content`
+iterable.
+
+## Errors
+
+The codec answers on the wire wherever it can, because a real HTTP peer cannot
+receive a JavaScript exception — only a response, or a connection that ends
+with no status.
+
+| Situation | On the wire | On a webrun caller |
+| --- | --- | --- |
+| Handler throws | `500 Internal Server Error`, message in the body | `httpFetch` rejects with the peer's error, stack and custom fields preserved |
+| Request cannot be parsed | `400 Bad Request`, reason in the body | `httpFetch` rejects with the parse error |
+| Transport fails | nothing — the failure is not ours to answer | the error propagates unchanged |
+
+Both error responses carry the serialized error in an `x-webrun-error` header
+(exported as `PEER_ERROR_HEADER`), which is what lets a webrun peer re-throw a
+real `Error` rather than a status code. A third party just reads a conforming
+response and ignores the header. The header value is bounded at 4096
+characters, so a very large error message is truncated rather than blowing past
+`maxHeaderBytes` at the reader.
+
+Refusals are always `HttpParseError`, whichever codec read the message, so a
+consumer can tell "the peer sent something malformed" from "the transport
+broke". **Check `err.name`, not `instanceof`** — the two cases differ:
+
+```ts
+import { httpFetch } from "@statewalker/webrun-http-streams";
+
+try {
+  await httpFetch(call, env);
+} catch (err) {
+  if ((err as Error).name === "HttpParseError") {
+    // malformed bytes — one side or an intermediary is at fault
+  } else {
+    throw err; // transport failure, or the peer handler's own error
+  }
+}
+```
+
+`instanceof HttpParseError` holds only when *this* side's decoder refused what
+the peer sent. When the peer refuses **your** request, its 400 travels back
+through the `x-webrun-error` header and is rehydrated by `deserializeError`,
+which builds a plain `Error` carrying the original `name`, `message`, `stack`
+and custom fields — not the original class. So `err.name` is
+`"HttpParseError"` in both directions, and `instanceof` is true in only one.
+The same applies to every error class crossing this boundary, including your
+own handler's `Error` subclasses.
+
+A refusal is answered in whatever format the peer was speaking, so a caller
+pinned to the legacy envelope receives its 400 as an envelope rather than as
+HTTP/1.1.
+
+`HttpError` is a separate, unrelated helper for handlers that want to raise a
+status deliberately (`HttpError.errorResourceNotFound()` and friends). It is
+not wired into the wire format: throwing one produces a 500 like any other
+exception.
+
+## Exports
+
+| Export | What it is |
+| --- | --- |
+| `httpFetch`, `httpServe` | Data layer. Types: `HttpDataHandler`, `HttpDataHandlerResult`, `HttpDataOptions`, `HttpFetchResult`. |
+| `fetchOverDuplex`, `serveFetchOverDuplex` | Fetch layer. |
+| `DuplexSiteBuilder`, `SiteHandler` | Site host over a `Connect`/`Serve` pair. |
+| `newHttpClientStub`, `newHttpServerStub` | Transport-agnostic stubs. Types: `HttpHandler`, `SerializedHttpEnvelope`, `SerializedHttpRequest`, `SerializedHttpResponse`. |
+| `defaultCodec`, `httpCodec`, `newHttpCodec`, `HttpCodecOptions` | HTTP/1.1 codec and the default sniffing codec. |
+| `jsonEnvelopeCodec`, `encodeMessage`, `decodeMessage` | Legacy JSON-envelope format. |
+| `newSniffingCodec`, `SniffingCodecOptions` | Build your own write/accept combination. |
+| `HttpParseError` | Every codec refusal. |
+| `HttpError`, `HttpErrorOptions` | Status-raising helper for handlers; not wired into the wire format. |
+| `PEER_ERROR_HEADER` | `"x-webrun-error"`. |
+| `MessageCodec`, `ByteSource`, `RequestEnvelope`, `ResponseEnvelope`, `DecodedRequest`, `DecodedResponse`, `ResponseCodecOptions` | The codec seam's types. |
+
+## Dependencies
+
+| Dependency | Kind | Why |
+| --- | --- | --- |
+| [`@statewalker/webrun-streams`](../webrun-streams) | runtime | The `Duplex` seam, chunk collectors and error serialisation. |
+
+No peer dependencies and no runtime dependencies outside the workspace. Relies
+on the platform for `Request`, `Response`, `ReadableStream`, `TextEncoder` and
+`TextDecoder`.
+
+Downstream consumers in this workspace:
+[`webrun-http-browser`](../webrun-http-browser) and
+[`webrun-rpc-http`](../webrun-rpc-http).
+
+## Scripts
+
+```sh
+pnpm test        # vitest run
+pnpm run build   # rolldown + tsc --emitDeclarationOnly
+pnpm lint        # biome check src tests
+```
 
 ## License
 
-MIT
+MIT © statewalker — see [LICENSE](../../LICENSE).

package/dist/bytes.d.ts

@@ -0,0 +1,43 @@
+import type { ByteSource } from "./message.js";
+export declare class ByteStreamError extends Error {
+    readonly name = "ByteStreamError";
+}
+export declare function toAsyncIterator(input: ByteSource): AsyncIterator<Uint8Array>;
+/**
+ * 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.
+ */
+export declare function discard(source: ByteSource | undefined): Promise<void>;
+export declare function concatChunks(parts: Uint8Array[], totalLen: number): Uint8Array;
+/**
+ * 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.
+ */
+export declare class ByteReader {
+    #private;
+    constructor(input: ByteSource);
+    /** Bytes already pulled from the source but not yet consumed. */
+    bufferedLength(): number;
+    peekByte(): Promise<number | undefined>;
+    /** Up to `max` bytes. `undefined` means end of stream. */
+    readSome(max: number): Promise<Uint8Array | undefined>;
+    /**
+     * 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.
+     */
+    readLine(maxBytes: number): Promise<Uint8Array>;
+    /** Everything not yet consumed, lazily. */
+    rest(): AsyncGenerator<Uint8Array>;
+}
+//# sourceMappingURL=bytes.d.ts.map

package/dist/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM/C,qBAAa,eAAgB,SAAQ,KAAK;IACxC,SAAkB,IAAI,qBAAqB;CAC5C;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAAC,UAAU,CAAC,CAS5E;AAED;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAS3E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CAc9E;AAED;;;;GAIG;AACH,qBAAa,UAAU;;IAKrB,YAAY,KAAK,EAAE,UAAU,EAE5B;IAED,iEAAiE;IACjE,cAAc,IAAI,MAAM,CAEvB;IAqBK,QAAQ,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAK5C;IAED,0DAA0D;IACpD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAQ3D;IAED;;;;;;;;;OASG;IACG,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAoBpD;IAED,2CAA2C;IACpC,IAAI,IAAI,cAAc,CAAC,UAAU,CAAC,CAUxC;CACF"}

package/dist/codec-default.d.ts

@@ -0,0 +1,7 @@
+import type { MessageCodec } from "./message.js";
+/**
+ * Writes HTTP/1.1; accepts HTTP/1.1 or the legacy JSON envelope. Used whenever
+ * no `codec` option is supplied.
+ */
+export declare const defaultCodec: MessageCodec;
+//# sourceMappingURL=codec-default.d.ts.map

package/dist/codec-default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-default.d.ts","sourceRoot":"","sources":["../src/codec-default.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGjD;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,YAGzB,CAAC"}

package/dist/duplex-site-builder.d.ts

@@ -1,4 +1,5 @@
 import type { Serve } from "@statewalker/webrun-streams";
+import type { MessageCodec } from "./message.js";
 /**
  * Structural alias of `SiteHandler` from `@statewalker/webrun-site-builder`.
  * Kept local so this package doesn't depend on `webrun-site-builder`.
@@ -11,7 +12,7 @@ export type SiteHandler = (request: Request) => Promise<Response>;
  * ```ts
  * import { SiteBuilder } from "@statewalker/webrun-site-builder";
  * import { DuplexSiteBuilder } from "@statewalker/webrun-http-streams";
- * import { serve } from "@statewalker/webrun-streams-port";
+ * import { serve } from "@statewalker/webrun-rpc";
  *
  * const handler = new SiteBuilder()
  *   .setEndpoint("/api/time", () => new Response(new Date().toISOString()))
@@ -27,6 +28,8 @@ export type SiteHandler = (request: Request) => Promise<Response>;
 export declare class DuplexSiteBuilder {
     #private;
     setHandler(handler: SiteHandler): this;
+    /** Pin the wire format. Defaults to HTTP/1.1 with legacy acceptance. */
+    setCodec(codec: MessageCodec): this;
     start<P>(serve: Serve<P>, params: P): Promise<() => Promise<void>>;
 }
 //# sourceMappingURL=duplex-site-builder.d.ts.map

package/dist/duplex-site-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duplex-site-builder.d.ts","sourceRoot":"","sources":["../src/duplex-site-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAGzD;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,iBAAiB;;IAG5B,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAKhC,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAUzE"}
+{"version":3,"file":"duplex-site-builder.d.ts","sourceRoot":"","sources":["../src/duplex-site-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,iBAAiB;;IAI5B,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAGrC;IAED,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAGlC;IAEK,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CASvE;CACF"}

package/dist/envelope.d.ts

@@ -1,13 +1,5 @@
-export type RequestEnvelope = {
-    url: string;
-    method: string;
-    headers: [string, string][];
-};
-export type ResponseEnvelope = {
-    status: number;
-    statusText: string;
-    headers: [string, string][];
-};
+import type { MessageCodec } from "./message.js";
+export type { RequestEnvelope, ResponseEnvelope } from "./message.js";
 /**
  * Encode an HTTP envelope plus optional body as one continuous byte stream:
  *
@@ -27,4 +19,12 @@ export declare function decodeMessage<E>(input: AsyncIterable<Uint8Array> | Iter
     envelope: E;
     body: AsyncIterable<Uint8Array>;
 }>;
+/**
+ * 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.
+ */
+export declare const jsonEnvelopeCodec: MessageCodec;
 //# sourceMappingURL=envelope.d.ts.map

package/dist/envelope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../src/envelope.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;CAC7B,CAAC;AAMF;;;;;;;;;GASG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,CAAC,EACX,IAAI,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,GACtD,cAAc,CAAC,UAAU,CAAC,CAM5B;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,GACtD,OAAO,CAAC;IAAE,QAAQ,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CAAE,CAAC,CAgD3D"}
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../src/envelope.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAIV,YAAY,EAGb,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAStE;;;;;;;;;GASG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,CAAC,EACX,IAAI,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,GACtD,cAAc,CAAC,UAAU,CAAC,CAM5B;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,GACtD,OAAO,CAAC;IAAE,QAAQ,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CAAE,CAAC,CAyD3D;AAID;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,YAS/B,CAAC"}

package/dist/fetch.d.ts

@@ -1,13 +1,14 @@
 import type { Duplex } from "@statewalker/webrun-streams";
+import { type HttpDataOptions } from "./http-data.js";
 /**
  * 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.
  */
-export declare function fetchOverDuplex(call: Duplex, request: Request): Promise<Response>;
+export declare function fetchOverDuplex(call: Duplex, request: Request, options?: HttpDataOptions): Promise<Response>;
 /**
  * Wrap a `(Request) => Promise<Response>` handler as a `Duplex` so it can be
  * registered with any `webrun-streams-*` adapter's `serve`.
  */
-export declare function serveFetchOverDuplex(handler: (request: Request) => Promise<Response>): Duplex;
+export declare function serveFetchOverDuplex(handler: (request: Request) => Promise<Response>, options?: HttpDataOptions): Duplex;
 //# sourceMappingURL=fetch.d.ts.map

package/dist/fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../src/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAgE1D;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAcvF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAsB7F"}
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../src/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAAE,KAAK,eAAe,EAAwB,MAAM,gBAAgB,CAAC;AAsF5E;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,QAAQ,CAAC,CA0EnB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAChD,OAAO,GAAE,eAAoB,GAC5B,MAAM,CAiDR"}

package/dist/http-data.d.ts

@@ -1,12 +1,18 @@
 import type { Duplex } from "@statewalker/webrun-streams";
-import { type RequestEnvelope, type ResponseEnvelope } from "./envelope.js";
+import type { ByteSource, MessageCodec, RequestEnvelope, ResponseEnvelope } from "./message.js";
+/** Carries the serialized JS error between two webrun peers. */
+export declare const PEER_ERROR_HEADER = "x-webrun-error";
+export type HttpDataOptions = {
+    /** Wire format. Defaults to `defaultCodec`: writes HTTP/1.1, accepts either. */
+    codec?: MessageCodec;
+};
 export interface HttpFetchResult {
     envelope: ResponseEnvelope;
     body: AsyncIterable<Uint8Array>;
 }
 export interface HttpDataHandlerResult {
     envelope: ResponseEnvelope;
-    body?: AsyncIterable<Uint8Array> | Iterable<Uint8Array>;
+    body?: ByteSource;
 }
 /**
  * Low-level HTTP-over-Duplex handler. Takes the request envelope plus body
@@ -25,12 +31,10 @@ export type HttpDataHandler = (env: RequestEnvelope, body: AsyncIterable<Uint8Ar
  * The call is one logical Duplex invocation; multiplexing of concurrent
  * calls is the adapter's concern (native or `emulateMux`).
  */
-export declare function httpFetch(call: Duplex, env: RequestEnvelope, body?: AsyncIterable<Uint8Array> | Iterable<Uint8Array>): Promise<HttpFetchResult>;
+export declare function httpFetch(call: Duplex, env: RequestEnvelope, body?: ByteSource, options?: HttpDataOptions): Promise<HttpFetchResult>;
 /**
  * Wrap an HTTP handler as a `Duplex` so it can be registered with any
- * `webrun-streams-*` adapter's `serve`. The duplex `split`s the input to
- * recover envelope + body, dispatches to the handler, and emits the response
- * via `encodeMessage`.
+ * `webrun-streams-*` adapter's `serve`.
  */
-export declare function httpServe(handler: HttpDataHandler): Duplex;
+export declare function httpServe(handler: HttpDataHandler, options?: HttpDataOptions): Duplex;
 //# sourceMappingURL=http-data.d.ts.map

package/dist/http-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-data.d.ts","sourceRoot":"","sources":["../src/http-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACtB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;CACzD;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAEpC;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,IAAI,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,GACtD,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAM1D"}
+{"version":3,"file":"http-data.d.ts","sourceRoot":"","sources":["../src/http-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAK1D,OAAO,KAAK,EACV,UAAU,EAEV,YAAY,EACZ,eAAe,EACf,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAEtB,gEAAgE;AAChE,eAAO,MAAM,iBAAiB,mBAAmB,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG;IAC5B,gFAAgF;IAChF,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,KAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAgGpC;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,IAAI,CAAC,EAAE,UAAU,EACjB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,eAAe,CAAC,CAM1B;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,GAAE,eAAoB,GAAG,MAAM,CAwCzF"}

package/dist/http-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-error.d.ts","sourceRoot":"","sources":["../src/http-error.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,qBAAa,SAAU,SAAQ,KAAK;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;gBAER,OAAO,GAAE,gBAAqB;IAM1C,kBAAkB,CAAC,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIlF,MAAM,IAAI;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAQnE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS;IAM3C,MAAM,CAAC,qBAAqB,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS;IAQvE,MAAM,CAAC,cAAc,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS;IAQhE,MAAM,CAAC,iBAAiB,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS;IAQnE,MAAM,CAAC,kBAAkB,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS;CAOrE"}
+{"version":3,"file":"http-error.d.ts","sourceRoot":"","sources":["../src/http-error.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,qBAAa,SAAU,SAAQ,KAAK;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,YAAY,OAAO,GAAE,gBAAqB,EAIzC;IAED,kBAAkB,CAAC,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEjF;IAED,MAAM,IAAI;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAMlE;IAED,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAI1C;IAED,MAAM,CAAC,qBAAqB,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS,CAMtE;IAED,MAAM,CAAC,cAAc,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS,CAM/D;IAED,MAAM,CAAC,iBAAiB,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS,CAMlE;IAED,MAAM,CAAC,kBAAkB,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS,CAMnE;CACF"}

package/dist/http-stubs.d.ts

@@ -19,9 +19,21 @@ export interface SerializedHttpResponse {
 }
 export interface SerializedHttpEnvelope<Options> {
     options: Options;
+    /**
+     * The body bytes. Must be *productive*: it has to yield or finish on its own,
+     * because a body neither stub is allowed to read (a GET/HEAD/OPTIONS request,
+     * a null-body-status response) is released with `discard`, and `discard` must
+     * await one `.next()` before `.return()` — a bare `.return()` is a no-op on a
+     * generator in suspended start and would leak the producer. So a `content`
+     * that blocks forever without yielding makes the stub block with it, where an
+     * earlier version returned immediately and leaked instead. Every transport in
+     * this repo satisfies this; a `content` that waits on a peer that may never
+     * send should carry its own timeout.
+     */
     content: AsyncIterable<Uint8Array>;
 }
 export type HttpHandler = (request: Request) => Response | Promise<Response>;
+export declare const NULL_BODY_STATUSES: Set<number>;
 /**
  * Returns an HTTP handler that serializes a Request, hands the envelope to
  * `send` for transport, and deserializes the reply into a Response. Used on

package/dist/http-stubs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-stubs.d.ts","sourceRoot":"","sources":["../src/http-stubs.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB,CAAC,OAAO;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CACpC;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAmB7E;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,CACJ,QAAQ,EAAE,sBAAsB,CAAC,qBAAqB,CAAC,KACpD,OAAO,CAAC,sBAAsB,CAAC,sBAAsB,CAAC,GAAG,SAAS,CAAC,GACvE,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAmC5D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,GACnB,CACD,QAAQ,EACJ,sBAAsB,CAAC,qBAAqB,CAAC,GAC7C,OAAO,CAAC,sBAAsB,CAAC,qBAAqB,CAAC,CAAC,KACvD,OAAO,CAAC,sBAAsB,CAAC,sBAAsB,CAAC,CAAC,CAyC3D"}
+{"version":3,"file":"http-stubs.d.ts","sourceRoot":"","sources":["../src/http-stubs.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB,CAAC,OAAO;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;;;;OAUG;IACH,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CACpC;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAK7E,eAAO,MAAM,kBAAkB,aAAqC,CAAC;AAsBrE;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,CACJ,QAAQ,EAAE,sBAAsB,CAAC,qBAAqB,CAAC,KACpD,OAAO,CAAC,sBAAsB,CAAC,sBAAsB,CAAC,GAAG,SAAS,CAAC,GACvE,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAmD5D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,GACnB,CACD,QAAQ,EACJ,sBAAsB,CAAC,qBAAqB,CAAC,GAC7C,OAAO,CAAC,sBAAsB,CAAC,qBAAqB,CAAC,CAAC,KACvD,OAAO,CAAC,sBAAsB,CAAC,sBAAsB,CAAC,CAAC,CA0D3D"}