@statewalker/webrun-rpc 0.5.1 → 0.8.0

package/README.md

@@ -62,7 +62,7 @@ Stream tier and adapter:
 | `serve(params: PortParams, handler)` | Registers a `Duplex` handler. Resolves an idempotent teardown that abandons live streams, then closes the mux. |
 | `PortParams` | `{ mux: PortMuxFactory; timeout?: number }`. |
 | `PortMuxFactory`, `OnPort` | `(onPort?: OnPort) => PortMux \| Promise<PortMux>`; `(port, meta?) => boolean \| undefined`, `false` rejects. |
-| `overPipe(pipe, options: OverPipeOptions)` | A factory over one pipe via `multiplexPort`. Options: `codec`, `side`, `maxPorts`, `maxMessageSize`. |
+| `overPipe(pipe, options: OverPipeOptions)` | A factory over one pipe via `multiplexPort`. Options: `codec`, `side`, `maxPorts`, `maxMessageSize`, `signal`, `window`, `frameSize`. |
 | `overPorts(factory)` | Pass-through, for a mux this package knows nothing about. |
 | `duplexOverPort(port, options?)` | A `Duplex` running one stream on `port`. |
 | `serveDuplexOverPort(port, handler, options?)` | The serving half. Returns an idempotent teardown that abandons the stream and notifies the peer. |
@@ -75,8 +75,10 @@ Port multiplexing:
 | --- | --- |
 | `multiplexPort(port, options: PortMuxOptions)` | Emulated multiplexing over one port. |
 | `transferPortMux(target, options?: TransferPortMuxOptions)` | Multiplexing with real transferred `MessagePort`s. |
-| `PortMux` | `openPort(meta?)`, `close()`, `maxMessageSize`. |
-| `PortCodec`, `PortEnvelope` | The wire seam: `post(port, envelope, transfer?)`, `read(event)`. |
+| `PortMux` | `openPort(meta?, { signal }?)`, `close(reason?)`, `ports?()`, `maxMessageSize`. |
+| `portBufferedAmount(port)`, `whenPortReady(port, below?)` | A windowed port's queued bytes, and a promise for room. See below. |
+| `PortInfo`, `OpenPortOptions` | What `ports()` reports per port (`id`, `meta`, `openedAt`, `lastActivity`); `openPort`'s options. |
+| `PortCodec`, `PortEnvelope` | The wire seam: `post(port, envelope, transfer?)`, `read(event)`, and optionally `encode(envelope)` / `decode(data)` for byte codecs (exact window sizes, frames). |
 | `structuredCodec` | Envelopes passed through unencoded. |
 | `DEFAULT_MAX_PORTS` | `1024`. |
 | `PORT_TRANSFER` | `"webrun-rpc:port-transfer"`, the `type` of the message that carries a port. |
@@ -278,8 +280,9 @@ multiplexer's port, and the RPC tier runs over a virtual port with no byte-strea
 
 ### A port sends and receives messages, nothing more
 
-`multiplexPort` has no backpressure, acknowledgements, credit or buffer ceiling. That matches
-`MessagePort` semantics; waiting strategies belong above. The one safety property it holds: **a
+Without `window`, `multiplexPort` has no backpressure, acknowledgements, credit or buffer ceiling.
+That matches `MessagePort` semantics; waiting strategies belong above, or in the opt-in window
+described below. The one safety property it always holds: **a
 message for a port with no consumer is dropped, never queued**, so a peer flooding an unaccepted
 port cannot grow memory here.
 
@@ -292,22 +295,238 @@ port cannot grow memory here.
 | `side` | `"initiator"` (default) allocates even ids, `"responder"` odd, so both ends can open concurrently with no negotiation. The two ends of one pipe must disagree. |
 | `maxPorts` | Ceiling on concurrently open ports, default `DEFAULT_MAX_PORTS` (1024). Closing a port frees its slot. It bounds the id table, never the total over time, and never delays a message. A peer `open` past the limit is answered with `close` reason `"max-ports"`. |
 | `maxMessageSize` | Largest payload a chunk may carry, if the transport has a limit. Reported to the stream tier, never enforced. See below. |
+| `signal` | The transport's life. On abort the mux closes with `signal.reason`; an already-aborted signal gives a closed mux. See below. |
+| `window` | Per-port flow control in bytes, off when unset. See "A port with a window holds only its own bytes" below. |
+| `frameSize` | Fair framing in bytes, off when unset; needs `window`. See "Large messages take turns with small ones" below. |
+| `maxReassembledBytes` | Ceiling on what the peer's framed messages hold past their ports' windows, summed over all ports, default `DEFAULT_MAX_REASSEMBLED_BYTES` (64 MiB). Past it, or past what a port's window leaves, the port closes. See "Large messages take turns with small ones" below. |
+| `keepalive` | `{ intervalMs, misses? }`, off when unset: ping the peer and close the mux after `misses` unanswered pings from a peer that answered before. See "A port lives until its transport or its user lets go" below. |
+| `onLeak` | Development aid, off when unset: called with a port's `PortInfo` when its consumer dropped it without `close()`, and the port is freed. See "A port lives until its transport or its user lets go" below. |
+
+### A port with a window holds only its own bytes
+
+Without a window, a port has no backpressure: a slow consumer turns into unbounded memory, and
+every other port waits behind the shared queue. With `window: n`, each port this mux opens asks
+for flow control in its `open`, and the peer's mux applies it to that port in both directions.
+Each side may then have at most `n` bytes of a port's messages delivered to the other side and
+not yet consumed. What exceeds the window waits in the port's send queue:
+
+- `portBufferedAmount(port)` returns the queued bytes;
+- `whenPortReady(port, below = 0)` resolves once at most `below` bytes are queued.
+
+A sender that must not queue without bound awaits `whenPortReady` before posting more. It always
+resolves on a later task, never synchronously: a producer loop with room to spare would otherwise
+never yield, and the transport's own events (the credit that refills the window, the socket's
+writes) would never run.
+
+A message counts as consumed once every listener has returned, or, for a listener that returns a
+promise, once it settles. A consumer that takes messages from its own queue returns a promise
+that settles when it takes them. **A listener whose promise never settles keeps its port's window
+spent for good**: correct for backpressure, and visible in `mux.ports()`, whose `unconsumed`
+stays at the window (with `queued` and `outstanding` on the sending side).
+
+Credit goes back in batches: at once from a quarter of the window, else on the next task. 10,000
+small messages and their echoes take fewer than 200 credit envelopes.
+
+**What a message costs.** When both ends' codecs implement `encode` / `decode`, as `msgpackCodec`
+does, the window counts the encoded bytes, envelope included, and the message is encoded once,
+when it is posted. Each end says so in its `open` or its ack (`exact: true`); if either cannot,
+both count an estimate computed from the same value: byte length for `ArrayBuffer`s and typed
+arrays, a string's length, an object's values 4 levels deep and at most 256 of them, and at least
+64 bytes. Two ends counting different sizes would leak window on every message until the port
+wedged. A message larger than the window is sent once nothing else is outstanding.
+
+**Older peers.** A peer from before the window reads `window` in an `open` but never sends
+credit, and a codec from before it drops `credit` envelopes. So neither end holds back until the
+other has shown it reads credit: the responder acknowledges the window with a zero-byte `credit`
+before `onPort` runs (so what `onPort` posts reaches the opener after it, counted the same way on
+both ends), and the opener answers that ack with one of its own. Until then
+each end counts bytes but holds nothing back, so a port to an older peer, or over an older codec,
+keeps running without flow control, as it always did; `ports()` reports `window` only once it is
+in force. A peer's `window` that is not a positive integer is ignored.
+
+**Closing does not wait for credit.** A port closed with messages still queued sends them at once,
+then its close, regardless of the window: a peer that stopped returning credit (a listener that
+never settles) must still learn the port is closed, and nothing is kept for a port nobody holds.
+A message that has to wait in the queue is copied when posted (`structuredClone`, or encoded at
+once by a byte codec), as `postMessage` copies at once, so a caller reusing its buffer does not
+change what is sent. `listenPort` counts a request as consumed when it reaches its handler, not
+when the handler finishes, so a handler waiting on a later call on the same port does not hold
+the window that call needs. The window is off by default: 256 KiB favours latency under load, 1-4 MiB favours bulk
+throughput.
+
+### Large messages take turns with small ones
+
+All ports share one pipe, and a message leaves whole. So without more, a port sending 1 MiB holds
+the pipe for the whole megabyte, and a 64-byte message on another port waits behind it: the
+window bounds how much is in flight, not the order on the wire. With `frameSize: n`:
+
+- every windowed port's messages, and every port's `close`, wait in a per-port queue, and the
+  queues take turns, one item each, whenever the pipe has room (a port without a window posts its
+  messages at once, as without `frameSize`);
+- a message whose encoding is larger than `n` is split into `frame` envelopes of `n` bytes, which
+  the peer reassembles before delivery.
+
+A small message then waits for one frame, not for a whole large message. **It needs the pipe to
+report when it is full**: `MessageTarget`'s optional `whenDrained()` (and `bufferedAmount`), which
+`messageTargetOverStream` in `@statewalker/webrun-streams-libp2p` provides. A pipe without it,
+such as a `MessagePort`, accepts everything at once, so the queues empty in one go and only the
+frames of messages posted together interleave.
+
+It also needs `window` and byte codecs (`encode` / `decode`) on both ends. A side frames only on a
+port whose window is in force with exact sizes agreed (`exact: true` in the `open` and in its
+acknowledgement), and accepts frames only there; a frame anywhere else is dropped. An older peer,
+or one whose codec cannot decode, gets whole messages. If the pipe's `whenDrained()` rejects, the mux closes with that
+error, so the ports waiting behind it fail instead of hanging. 16-64 KiB frames cost one small envelope each (about 15 bytes with
+`msgpackCodec`).
+
+**A peer cannot make this side hold frames without limit.** Two limits apply as frames arrive:
+
+- a message begun while this side still owed the port credit (delivered or consumed bytes not yet
+  granted back) must fit what the window left, since an honest sender counts at least that much as
+  outstanding; one begun with nothing owed may be larger than the window, as a whole message may;
+- what messages larger than the window hold past it, summed across every port, is at most
+  `maxReassembledBytes` (64 MiB by default), so opening many ports does not multiply it. A partial
+  message within its window is not charged: the window bounds it already, as it bounds unframed
+  traffic, so many ports framing honest messages at once never trip the cap.
+
+A frame past either limit closes its port: the partial message is dropped, the port's close signal
+aborts with a `RangeError` ("webrun-rpc: a framed message passed what the window left …" or
+"… passed maxReassembledBytes …"), and the peer's port closes as on any peer close. On the wire
+the close carries reason `"max-reassembled-bytes"`. A port that closes with messages still queued
+sends them whole, not framed, so they never trip the window check on the way out.
+
+The cap is the receiver's: a sender with `frameSize` that frames a message more than the
+peer's `maxReassembledBytes` past the window has its port closed, where the same message sent whole would arrive.
+Set it above the largest message the peer legitimately frames; a message just past it looks like
+a closed port, not a lost message.
+
+Frames carry no sequence number. Reassembly relies on what every `MessageTarget` already
+promises: an ordered, reliable pipe. Each port's frames leave from its own queue in order, and
+other ports' frames interleave but are told apart by port id.
 
 `openPort(meta?)` allocates a port, announces it and returns the local end without waiting for the
 peer to accept. That keeps layer 1 free of round trips: messages posted before a rejection are
 dropped at the far end and the port goes inert. It is asynchronous because a natively multiplexed
 transport cannot produce a port synchronously and both must share one shape. Its guard failures
 are rejections, not synchronous throws: `RangeError: webrun-rpc: maxPorts (<n>) reached` and
-`Error: webrun-rpc: the multiplexer is closed`. A duplicate `open` id from the peer is ignored
-rather than replacing a live port, and a local `openPort` skips ids the peer already claimed with
-the wrong parity.
-
-`PortEnvelope` is `{ type: "open", id, meta? }`, `{ type: "message", id, payload }` or
-`{ type: "close", id, reason? }`. `structuredCodec.read` accepts only objects with a non-negative
-integer `id` and one of those three types, so other traffic on a shared port is ignored.
+`Error: webrun-rpc: the multiplexer is closed`. The `RangeError` goes on with the three commonest
+`meta.kind`s among the open ports, `open ports by kind: http: 1000, ws: 24`, so a full table names
+the consumer that filled it (`"?"` counts ports without a kind). A duplicate `open` id from the
+peer is ignored rather than replacing a live port, and a local `openPort` skips ids the peer
+already claimed with the wrong parity.
+
+`PortEnvelope` is `{ type: "open", id, meta?, window?, exact? }`, `{ type: "message", id, payload }`,
+`{ type: "close", id, reason? }`, with a window `{ type: "credit", id, bytes, exact? }`, with
+`frameSize` `{ type: "frame", id, data, last? }`, and with `keepalive` `{ type: "ping", id }` /
+`{ type: "pong", id }` (on `Number.MAX_SAFE_INTEGER`). The codecs' `read` accept only objects with a non-negative integer `id`
+and one of those seven types, so other traffic on a shared port is
+ignored.
 `structuredCodec` passes envelopes through unencoded, so `ArrayBuffer`s move zero-copy through the
 transfer list; it omits an empty transfer list because some implementations reject one.
 
+### A port lives until its transport or its user lets go
+
+A port leaves the table only when one side closes it or the mux closes. Nothing else frees it, and
+a full table refuses every new port. So both lifetimes are wired in explicitly:
+
+- **The transport.** A `MessagePort`, a terminated worker or a dead libp2p stream gives no close
+  event, so the mux cannot notice by itself. Pass `signal` and abort it from whatever does notice
+  (a worker's `exit`, a stream's `close`, a liveness lock): the mux closes with `signal.reason`,
+  every port's close signal aborts with it, and calls in flight reject at once instead of hanging.
+  `close(reason)` does the same by hand. A port opened from a close-signal listener while the mux
+  closes is refused, and a transport `close()` that rejects on this path is swallowed rather than
+  left as an unhandled rejection.
+- **The user.** `openPort(meta, { signal })` closes the port when `signal` aborts, with
+  `signal.reason` as the reason of the port's close signal; a signal already aborted rejects
+  `openPort` with its reason and opens nothing. `transferPortMux` honours the signal too. Virtual
+  ports are also disposable where the runtime defines `Symbol.dispose`, so
+  `using port = (await mux.openPort()) as MessageTarget & Disposable` closes it on scope exit. The
+  cast is needed because the declared type leaves `Symbol.dispose` out: naming it would require
+  every consumer to compile with the `esnext.disposable` lib.
+
+What aborts `signal` depends on the transport. A Node worker reports its death:
+
+```ts
+import { Worker } from "node:worker_threads";
+
+const worker = new Worker(new URL("./worker.js", import.meta.url));
+const { port1, port2 } = new MessageChannel();
+worker.postMessage({ port: port2 }, [port2]);
+const exited = new AbortController();
+worker.once("exit", (code) => exited.abort(new Error(`the worker exited (${code})`)));
+const mux = multiplexPort(port1, { codec: structuredCodec, signal: exited.signal });
+```
+
+A browser realm (a tab, an iframe, a worker) reports nothing, but the browser releases its
+[Web Locks](https://developer.mozilla.org/docs/Web/API/Web_Locks_API) when it ends. The other realm
+holds a lock for its whole life, and this side asks for the same lock, which it gets only then:
+
+```ts
+// In the other realm: a name of its own (realms of one origin share locks), and
+// "ready" only from inside the callback, once the lock is really held.
+const lock = `realm:${crypto.randomUUID()}`;
+navigator.locks.request(lock, () => {
+  port.postMessage({ ready: lock });
+  return new Promise(() => {}); // held until this realm ends
+});
+
+// Here, on that message (`{ ready }`) — asked before the lock is held, it would be granted at once:
+const gone = new AbortController();
+navigator.locks.request(message.ready, () => gone.abort(new Error("the other realm is gone")));
+const mux = multiplexPort(port, { codec: structuredCodec, signal: gone.signal });
+```
+
+Locks are per browser profile, so this works between realms of one origin, never across a
+network. In Node 24 a worker's locks are not visible to the thread that started it (the parent's
+request is granted while the worker holds the lock), so use `exit` there.
+
+**When nothing reports the death, `keepalive` probes for it.** With
+`keepalive: { intervalMs: 5000, misses: 3 }` the mux pings every 5 s, the peer answers, and
+anything the peer sends counts as an answer. After 3 pings in a row with nothing back from a peer
+that has answered before, the mux closes with `webrun-rpc: the peer did not answer 3 keepalive
+pings, 5000 ms apart`, as if `signal` had aborted. The silence it takes is between `misses ×
+intervalMs` and one interval more. That catches a realm that died with no lock to tell and one
+that froze. It cannot tell a peer whose event loop is blocked for that long from a dead one, so
+size the product above the longest pause you expect.
+
+- **What counts as silence.** Misses are pings unanswered, not time since the last message, so
+  timer jitter cannot turn a prompt answer into a miss, and `misses: 1` is usable. A tick taken
+  while this end's own pipe reports a backlog (`bufferedAmount > 0`, as `messageTargetOverStream`
+  does) is not counted: a ping stuck behind this end's own upload has not reached the peer.
+- **Who is held to it.** Every current mux answers pings, whether or not it sets `keepalive`, so
+  one end is enough, and the two ends' intervals need not match. An older peer never answers and
+  is never closed for it. Nor is a peer that dies before its first answer: wire `signal` as well
+  where the transport can report death.
+- **What it does not catch.** A peer that keeps sending but stopped consuming is alive by this
+  measure; the window (`window`) is what bounds that.
+- **Wire.** `ping` and `pong` are envelopes of their own, sent on the largest safe integer id,
+  which no port takes. An older mux whose codec passes unknown envelopes through reads them as a
+  close of that id, and so closes nothing. The bundled codecs of older versions drop them.
+
+The interval timer is `unref`'d in Node, so it never keeps a process alive. `intervalMs` must be in
+(0, 2³¹ − 1] (past that, timers fire at once) and `misses` a positive integer, or `multiplexPort`
+throws a `RangeError`.
+
+`ports()` lists what is open, with each port's `meta`, `openedAt` and `lastActivity` (the last
+message either way), for finding a consumer that never closes.
+
+**A dropped port can be reported (`onLeak`).** Weak references cannot free leaks on their own:
+the mux must deliver to every open port, and an abandoned port's listeners usually close over the
+port, so it stays reachable from the table. What they can do is catch the ports nothing else
+holds. The mux keeps only its own record of a port, never the consumer's object, so with
+`onLeak` a port its consumer dropped without `close()` is reported once the collector reclaims it
+(`onLeak(info)`, with its `meta`). What happens next depends on its listeners:
+
+- **No listener left:** nothing can reach the port again, so it is freed on both ends as a close
+  would free it. Its close signal aborts with `webrun-rpc: the port was dropped without close()`;
+  the peer's port closes as on any close (`webrun-rpc: the peer closed the port`).
+- **A listener left** (a subscription that keeps only its handler): the port is still receiving,
+  so it is reported and left open. Hold the port, or close it, to silence the report.
+
+A port whose own listener refers to it is never collected, so never reported; when the collector
+runs is up to the runtime. It is a development aid: each port costs a `FinalizationRegistry`
+entry.
+
 ### No close is observable at layer 1
 
 `MessageTarget` has no close event and a virtual port exposes no state. When a port closes, its
@@ -395,6 +614,12 @@ caller without one does not.
 An abort unwinds a producing handler through `iter.return()`, not by throwing into it. A handler's
 `catch` never sees the abort reason; only `finally` runs. Put cleanup in `finally`.
 
+`serve` forwards that `return()` to the handler's output at once, even while the handler is still
+working on its first chunk, with or without `maxMessageSize` (whose chunker would queue it too). Its own tracking wrapper would otherwise queue it behind that pending
+`next()`, as any async generator does. A handler that wraps its output to watch for `return()`
+therefore sees the abandonment when it happens, not when it next yields:
+`@statewalker/webrun-http-streams` aborts the served `Request.signal` that way.
+
 ### `transferPortMux` moves real ports
 
 Each `openPort` creates a `MessageChannel`, posts `{ type: PORT_TRANSFER, meta }` with one end in

package/dist/connect-serve.d.ts

@@ -1,6 +1,6 @@
 import type { Connect, Serve } from "@statewalker/webrun-streams";
 import type { MessageTarget } from "./message-target.js";
-import type { PortCodec, PortMux } from "./port-types.js";
+import type { PortCodec, PortMux, PortMuxOptions } from "./port-types.js";
 /** What a mux calls when the peer opens a port. `false` rejects it. */
 export type OnPort = (port: MessageTarget, meta?: unknown) => boolean | undefined;
 /**
@@ -80,6 +80,21 @@ export interface OverPipeOptions {
      * transport's real ceiling — see `PortMuxOptions.maxMessageSize`.
      */
     maxMessageSize?: number;
+    /** The pipe's life: aborting it closes the mux. See `PortMuxOptions.signal`. */
+    signal?: AbortSignal;
+    /** Experimental per-port flow control in bytes — see `PortMuxOptions.window`. */
+    window?: number;
+    /** Fair framing in bytes — see `PortMuxOptions.frameSize`. */
+    frameSize?: number;
+    /** Ceiling on a message reassembled from frames — see `PortMuxOptions.maxReassembledBytes`. */
+    maxReassembledBytes?: number;
+    /** Liveness of the peer by ping/pong — see `PortMuxOptions.keepalive`. */
+    keepalive?: {
+        intervalMs: number;
+        misses?: number;
+    };
+    /** Development aid: report ports dropped without `close()` — see `PortMuxOptions.onLeak`. */
+    onLeak?: PortMuxOptions["onLeak"];
 }
 /**
  * Ports over ONE PIPE OF BYTES — a `MessagePort`, a worker, a WebSocket.

package/dist/connect-serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect-serve.d.ts","sourceRoot":"","sources":["../src/connect-serve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAU,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAM1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAW1D,uEAAuE;AACvE,MAAM,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,GAAG,SAAS,CAAC;AAElF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE7E,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;OAUG;IACH,GAAG,EAAE,cAAc,CAAC;IACpB;;;yEAGqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,UAAU,CAyCvC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,UAAU,CAqDnC,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,mFAAmF;IACnF,KAAK,EAAE,SAAS,CAAC;IACjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;IACjC,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc,CAEtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAEjE"}
+{"version":3,"file":"connect-serve.d.ts","sourceRoot":"","sources":["../src/connect-serve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAU,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAM1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAW1E,uEAAuE;AACvE,MAAM,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,GAAG,SAAS,CAAC;AAElF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE7E,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;OAUG;IACH,GAAG,EAAE,cAAc,CAAC;IACpB;;;yEAGqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,UAAU,CAyCvC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,UAAU,CA8DnC,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,mFAAmF;IACnF,KAAK,EAAE,SAAS,CAAC;IACjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;IACjC,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+FAA+F;IAC/F,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,0EAA0E;IAC1E,SAAS,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACpD,6FAA6F;IAC7F,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;CACnC;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc,CAEtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAEjE"}

package/dist/index.d.ts

@@ -10,8 +10,9 @@ export * from "./io-send.js";
 export * from "./listen-bidi.js";
 export * from "./listen-port.js";
 export * from "./message-target.js";
-export { DEFAULT_MAX_PORTS, MUX_CLOSED_MESSAGE, multiplexPort } from "./multiplex-port.js";
-export type { PortCodec, PortEnvelope, PortMux, PortMuxOptions } from "./port-types.js";
+export { DEFAULT_MAX_PORTS, DEFAULT_MAX_REASSEMBLED_BYTES, MUX_CLOSED_MESSAGE, multiplexPort, } from "./multiplex-port.js";
+export { type PortSendState, portBufferedAmount, whenPortReady } from "./port-credit.js";
+export type { OpenPortOptions, PortCodec, PortEnvelope, PortInfo, PortMux, PortMuxOptions, } from "./port-types.js";
 export * from "./recieve.js";
 export * from "./send.js";
 export { structuredCodec } from "./structured-codec.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EACL,OAAO,EACP,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,QAAQ,EACR,SAAS,EACT,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,GACN,MAAM,oBAAoB,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC3F,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxF,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EACL,OAAO,EACP,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,QAAQ,EACR,SAAS,EACT,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,GACN,MAAM,oBAAoB,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EACL,iBAAiB,EACjB,6BAA6B,EAC7B,kBAAkB,EAClB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,aAAa,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACzF,YAAY,EACV,eAAe,EACf,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,cAAc,wBAAwB,CAAC"}