transport-io 0.0.1 → 0.1.0

package/README.md

@@ -1,4 +1,9 @@
-# transport-io
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/transport-io/transport-io/main/assets/brand/transport-io-lockup-bone.svg">
+    <img alt="transport-io" src="https://raw.githubusercontent.com/transport-io/transport-io/main/assets/brand/transport-io-lockup-ink.svg" width="340">
+  </picture>
+</p>
 
 Real-time apps over WebTransport. Socket.IO's shape, on a transport with multiple streams
 and datagrams, without Socket.IO's mistakes.
@@ -7,13 +12,15 @@ Framing, length prefixes, buffer accumulation, stream lifecycle and backpressure
 hidden. Reliability is not: an event declares `stream` or `datagram` in the contract, and
 "this message may be dropped" is a property of your data that lives in the type system.
 
-**Full documentation, and the limitations you should read before installing, are in the
-[repository README](https://github.com/v0id-user/transport-io#readme).** The short version:
+**Read [KNOWN-ISSUES.md](https://github.com/transport-io/transport-io/blob/main/KNOWN-ISSUES.md)
+before you start.** It is what this library refuses to do and will not change, plus the one
+measured defect. Full documentation is in the
+[repository README](https://github.com/transport-io/transport-io#readme). The short version:
 
-- **WebTransport only.** No WebSocket fallback, deliberately — a fallback would silently
+- **WebTransport only.** No WebSocket fallback, deliberately - a fallback would silently
   make the datagram lane reliable and ordered, which is a lie about your data.
 - **Chrome and Firefox.** Safari cannot talk to a quiche-backed server and is unsupported.
-- **The server needs a separate native install**, and its Linux prebuild needs glibc 2.38 —
+- **The server needs a separate native install**, and its Linux prebuild needs glibc 2.38 -
   no default Node `-slim` image has it, and Alpine has no prebuild at all.
 - **Each `call()` leaks ~5.95 KB of server memory**, upstream in the QUIC binding, not in
   this library. `emit` and datagrams are flat.
@@ -23,6 +30,6 @@ hidden. Reliability is not: an event declares `stream` or `datagram` in the cont
 npm install transport-io
 ```
 
-A git install does not work — the repository root is a private monorepo package.
+A git install does not work - the repository root is a private monorepo package.
 
 MIT © #V0ID

package/dist/adapter.d.ts

@@ -5,7 +5,7 @@
  * Rules core obeys (D40): every method is async even in memory, frames cross as bytes and
  * never as live objects, `PeerId` is a stable cross-process string, no node assumes it
  * knows a room's full membership, a frame for a room with no local members is dropped
- * silently rather than erroring, and any method may reject — core degrades rather than
+ * silently rather than erroring, and any method may reject - core degrades rather than
  * crashing.
  */
 export type PeerId = string;

package/dist/client.d.ts

@@ -2,7 +2,7 @@
  * Client surface.
  *
  * Constructible without I/O: nothing here touches `window` or `WebTransport` at module
- * scope, so importing this on a server — which Next.js will do — is safe. Feature
+ * scope, so importing this on a server - which Next.js will do - is safe. Feature
  * detection happens inside connect().
  */
 import { type AnyMap, type CallableOf, type Contract } from './contract.ts';

package/dist/client.js

@@ -2,7 +2,7 @@
  * Client surface.
  *
  * Constructible without I/O: nothing here touches `window` or `WebTransport` at module
- * scope, so importing this on a server — which Next.js will do — is safe. Feature
+ * scope, so importing this on a server - which Next.js will do - is safe. Feature
  * detection happens inside connect().
  */
 import { buildEventTable } from './contract.js';

package/dist/codec.js

@@ -1,4 +1,4 @@
-/** JSON over UTF-8. PROTOCOL.md §5.3 — codec 0x01, the only one this version speaks. */
+/** JSON over UTF-8. PROTOCOL.md §5.3 - codec 0x01, the only one this version speaks. */
 import { TransportError } from './errors.js';
 const encoder = new TextEncoder();
 const decoder = new TextDecoder('utf-8', { fatal: true });

package/dist/contract.d.ts

@@ -12,7 +12,7 @@ export type Schema = StandardSchemaV1;
  * property checking against a *union* admits any property present on any member, so
  * `{ lane: 'datagram', payload, returns }` compiled happily, `CallableOf` admitted it, and
  * `call()` served it over a bidirectional stream. A contract that says "may be dropped"
- * produced a guaranteed ordered message with the type system agreeing — a direct violation
+ * produced a guaranteed ordered message with the type system agreeing - a direct violation
  * of D1, the first decision this project made.
  */
 export type EventDef = {
@@ -30,7 +30,7 @@ export type Contract = Readonly<Record<string, EventDef>>;
 export type Infer<S extends StandardTypedV1> = StandardTypedV1.InferOutput<S>;
 /**
  * The plain payload/returns map every public signature is written against, so that no
- * method hover ever has to print a validator's internal types. See D57 — declaring
+ * method hover ever has to print a validator's internal types. See D57 - declaring
  * `interface AppMap extends MapOf<typeof contract> {}` is what keeps hover at 126
  * characters instead of 303.
  */
@@ -68,7 +68,7 @@ export interface EventTable {
     wire(): readonly [string, number, Lane][];
 }
 /**
- * PROTOCOL.md §5.4 — the first four bytes of SHA-256 of the event name, big-endian.
+ * PROTOCOL.md §5.4 - the first four bytes of SHA-256 of the event name, big-endian.
  *
  * Async because `crypto.subtle` is, and because writing SHA-256 by hand would mean typing
  * its round constants from memory, which is the one thing D58 forbids. Both `connect()`

package/dist/contract.js

@@ -14,7 +14,7 @@ export function type$() {
     };
 }
 /**
- * PROTOCOL.md §5.4 — the first four bytes of SHA-256 of the event name, big-endian.
+ * PROTOCOL.md §5.4 - the first four bytes of SHA-256 of the event name, big-endian.
  *
  * Async because `crypto.subtle` is, and because writing SHA-256 by hand would mean typing
  * its round constants from memory, which is the one thing D58 forbids. Both `connect()`

package/dist/datagram.js

@@ -1,4 +1,4 @@
-/** Datagram header. PROTOCOL.md §7.1 — codec, event id, origin, sequence, then payload. */
+/** Datagram header. PROTOCOL.md §7.1 - codec, event id, origin, sequence, then payload. */
 import { TransportError } from './errors.js';
 import { Codec, DATAGRAM_CONSERVATIVE_FLOOR, DATAGRAM_HEADER_BYTES, EVENT_ID_NOT_APPLICABLE, } from './protocol.js';
 /**

package/dist/errors.js

@@ -2,7 +2,7 @@ export class TransportError extends Error {
     code;
     remedy;
     constructor(code, message, remedy) {
-        super(`${code}: ${message} — ${remedy}`);
+        super(`${code}: ${message} - ${remedy}`);
         this.name = 'TransportError';
         this.code = code;
         this.remedy = remedy;

package/dist/framer.d.ts

@@ -5,12 +5,12 @@ export interface Frame {
     readonly eventId: number;
     readonly payload: Uint8Array;
 }
-/** §5.1 — the cap is per frame type: a call is the documented home for a large payload. */
+/** §5.1 - the cap is per frame type: a call is the documented home for a large payload. */
 export declare function maxPayloadFor(type: FrameType): number;
 export declare function encodeFrame(frame: Frame): Uint8Array;
 /**
- * Incremental decoder. Feed it whatever the transport hands you — a fragment, several
- * frames, or a frame split across many reads — and it yields whole frames only.
+ * Incremental decoder. Feed it whatever the transport hands you - a fragment, several
+ * frames, or a frame split across many reads - and it yields whole frames only.
  */
 export declare class FrameDecoder {
     #private;

package/dist/framer.js

@@ -3,14 +3,14 @@
  *
  * QUIC streams are byte streams and do not preserve write boundaries. Measured on the
  * reference transport, 51 writes arrived as 217 reads, and the large write fragmented
- * while the small ones happened to survive — which is the worst case, because naive
+ * while the small ones happened to survive - which is the worst case, because naive
  * boundary-trusting code passes in development and fails under load. The length prefix
  * is the only thing that recovers frame boundaries, and nobody using this library should
  * ever have to think about it.
  */
 import { TransportError } from './errors.js';
 import { Codec, FrameType, isFrameType, LENGTH_PREFIX_BYTES, MAX_CALL_PAYLOAD_BYTES, MAX_EMIT_PAYLOAD_BYTES, MIN_LENGTH, STREAM_HEADER_BYTES, } from './protocol.js';
-/** §5.1 — the cap is per frame type: a call is the documented home for a large payload. */
+/** §5.1 - the cap is per frame type: a call is the documented home for a large payload. */
 export function maxPayloadFor(type) {
     return type === FrameType.CALL_REQUEST || type === FrameType.CALL_RESPONSE
         ? MAX_CALL_PAYLOAD_BYTES
@@ -36,8 +36,8 @@ export function encodeFrame(frame) {
     return out;
 }
 /**
- * Incremental decoder. Feed it whatever the transport hands you — a fragment, several
- * frames, or a frame split across many reads — and it yields whole frames only.
+ * Incremental decoder. Feed it whatever the transport hands you - a fragment, several
+ * frames, or a frame split across many reads - and it yields whole frames only.
  */
 export class FrameDecoder {
     #buf = new Uint8Array(0);
@@ -63,8 +63,8 @@ export class FrameDecoder {
             }
             const payloadLength = length - STREAM_HEADER_BYTES;
             // §5.3 gives calls 16 MiB and everything else 1 MiB. This enforced the call cap for
-            // every frame type, so a peer could declare 16 MiB on the emit lane — sixteen times
-            // its documented cap — and the decoder would buffer toward it.
+            // every frame type, so a peer could declare 16 MiB on the emit lane - sixteen times
+            // its documented cap - and the decoder would buffer toward it.
             //
             // The type byte is at offset 4, so it is readable as soon as five bytes are, which is
             // before any payload has to be held. Until then the universal cap applies, which

package/dist/handshake.d.ts

@@ -1,5 +1,5 @@
 /**
- * Handshake. PROTOCOL.md §4 — frame 0 of the emit stream.
+ * Handshake. PROTOCOL.md §4 - frame 0 of the emit stream.
  *
  * Being frame 0 of a stream that already exists is what removes the early-traffic race:
  * in-order delivery within a stream means nothing can arrive before it. There is no

package/dist/handshake.js

@@ -1,5 +1,5 @@
 /**
- * Handshake. PROTOCOL.md §4 — frame 0 of the emit stream.
+ * Handshake. PROTOCOL.md §4 - frame 0 of the emit stream.
  *
  * Being frame 0 of a stream that already exists is what removes the early-traffic race:
  * in-order delivery within a stream means nothing can arrive before it. There is no

package/dist/hub.d.ts

@@ -26,7 +26,7 @@ export declare class Hub {
      * Teardown runs to completion whatever the bus does.
      *
      * `broadcast` already wrapped its adapter call; this did not, so a rejection on the
-     * first room threw straight out of the loop — rooms 2..N kept their `Member` record,
+     * first room threw straight out of the loop - rooms 2..N kept their `Member` record,
      * each holding a live Session, and `#peerRooms.delete(id)` never ran. Nothing retries,
      * because `conn.closed` resolves exactly once. A later `to(room).emit()` then fanned
      * frames into a session that was already gone.

package/dist/hub.js

@@ -13,7 +13,7 @@ export class Hub {
         this.#adapter = adapter;
         this.#table = table;
         // A node receiving its own publish back is normal, so core dedupes by origin node
-        // rather than relying on the adapter to suppress it — and dedupes against the
+        // rather than relying on the adapter to suppress it - and dedupes against the
         // *adapter's* id, which is the one stamped into the envelope. It used to compare
         // against the Server's separate `nodeId`, so any deployment where those differed
         // delivered every local broadcast twice, in silence.
@@ -30,7 +30,7 @@ export class Hub {
         // the emit path's swallowing catch, so nothing surfaced, and the teardown that would
         // have removed it had already run.
         if (session.disposed) {
-            throw new TransportError('WT_SESSION_CLOSED', `peer ${id} disconnected before it could join '${room}'`, 'Check the peer is still connected after any await, or ignore this — it is routine.');
+            throw new TransportError('WT_SESSION_CLOSED', `peer ${id} disconnected before it could join '${room}'`, 'Check the peer is still connected after any await, or ignore this - it is routine.');
         }
         let members = this.#rooms.get(room);
         if (members === undefined) {
@@ -40,7 +40,7 @@ export class Hub {
         // The bus first, local state second. Mutating before the await left a rejected join
         // half-applied: the hub fanned broadcasts to a peer the bus had no record of, and the
         // client was never notified it had joined. For a room whose join is gated on
-        // authorization, that is traffic reaching someone who was refused — permanently,
+        // authorization, that is traffic reaching someone who was refused - permanently,
         // because nothing rolls it back and nothing retries.
         await this.#adapter.join(room, id);
         members.set(id, { id, session });
@@ -69,7 +69,7 @@ export class Hub {
      * Teardown runs to completion whatever the bus does.
      *
      * `broadcast` already wrapped its adapter call; this did not, so a rejection on the
-     * first room threw straight out of the loop — rooms 2..N kept their `Member` record,
+     * first room threw straight out of the loop - rooms 2..N kept their `Member` record,
      * each holding a live Session, and `#peerRooms.delete(id)` never ran. Nothing retries,
      * because `conn.closed` resolves exactly once. A later `to(room).emit()` then fanned
      * frames into a session that was already gone.

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export type { SessionStats } from './session.ts';
  * `isolatedDeclarations` forbids inferring it from an import and a version that drifts from
  * its manifest is a lie in the one place a user checks first.
  *
- * `changeset version` moves the manifest, so this moves in the same commit — which the test
+ * `changeset version` moves the manifest, so this moves in the same commit - which the test
  * enforces rather than trusting anyone to remember.
  */
 export declare const VERSION: string;

package/dist/index.js

@@ -11,8 +11,8 @@ export { createServer, Server, } from './server.js';
  * `isolatedDeclarations` forbids inferring it from an import and a version that drifts from
  * its manifest is a lie in the one place a user checks first.
  *
- * `changeset version` moves the manifest, so this moves in the same commit — which the test
+ * `changeset version` moves the manifest, so this moves in the same commit - which the test
  * enforces rather than trusting anyone to remember.
  */
-export const VERSION = '0.0.1';
+export const VERSION = '0.1.0';
 //# sourceMappingURL=index.js.map

package/dist/origin.d.ts

@@ -3,7 +3,7 @@ export declare class OriginAllocator {
     /**
      * `counterSpace` exists so the exhaustion branch can be reached in a test. Exhausting the
      * real space means 4,194,304 allocations, which is why §7.3's "MUST refuse new sessions"
-     * went unproven — and an unreachable branch in an allocator is exactly the kind of code
+     * went unproven - and an unreachable branch in an allocator is exactly the kind of code
      * that is wrong the first time it runs. Production never passes it.
      */
     constructor(hostOrdinal?: number, quarantineMs?: number, counterSpace?: number);

package/dist/origin.js

@@ -5,8 +5,8 @@
  * where a collision is close to undebuggable, since two peers would share a sequence space
  * and each would silently discard the other's datagrams as stale.
  *
- * Quarantined, not retired: never reusing turns the counter into a clock — 2^22 values at
- * 100 sessions per second exhausts in under twelve hours — so a busy host would stop
+ * Quarantined, not retired: never reusing turns the counter into a clock - 2^22 values at
+ * 100 sessions per second exhausts in under twelve hours - so a busy host would stop
  * accepting sessions and need a restart.
  */
 import { TransportError } from './errors.js';
@@ -23,7 +23,7 @@ export class OriginAllocator {
     /**
      * `counterSpace` exists so the exhaustion branch can be reached in a test. Exhausting the
      * real space means 4,194,304 allocations, which is why §7.3's "MUST refuse new sessions"
-     * went unproven — and an unreachable branch in an allocator is exactly the kind of code
+     * went unproven - and an unreachable branch in an allocator is exactly the kind of code
      * that is wrong the first time it runs. Production never passes it.
      */
     constructor(hostOrdinal = 0, quarantineMs = ORIGIN_QUARANTINE_MS, counterSpace = COUNTER_SPACE) {

package/dist/protocol.d.ts

@@ -5,7 +5,7 @@
  * these values, so a document and an implementation cannot drift. Change one and the
  * build fails until you change the other.
  */
-/** PROTOCOL.md §4.2 — Stage 0 requires exact equality and refuses otherwise. */
+/** PROTOCOL.md §4.2 - Stage 0 requires exact equality and refuses otherwise. */
 export declare const PROTOCOL_VERSION = 0;
 /** PROTOCOL.md §5.2 */
 export declare const FrameType: {
@@ -24,9 +24,9 @@ export declare const Codec: {
     readonly JSON: 1;
 };
 export type Codec = (typeof Codec)[keyof typeof Codec];
-/** PROTOCOL.md §5.4 — used by frames whose meaning comes from the stream, not the table. */
+/** PROTOCOL.md §5.4 - used by frames whose meaning comes from the stream, not the table. */
 export declare const EVENT_ID_NOT_APPLICABLE = 0;
-/** PROTOCOL.md §5.1 — stream frame field budget. */
+/** PROTOCOL.md §5.1 - stream frame field budget. */
 export declare const LENGTH_PREFIX_BYTES = 4;
 export declare const STREAM_HEADER_BYTES = 8;
 export declare const STREAM_FRAME_OVERHEAD_BYTES: number;
@@ -34,31 +34,31 @@ export declare const STREAM_FRAME_OVERHEAD_BYTES: number;
 export declare const MIN_LENGTH: number;
 export declare const MAX_EMIT_PAYLOAD_BYTES = 1048576;
 export declare const MAX_CALL_PAYLOAD_BYTES = 16777216;
-/** PROTOCOL.md §7.2 — datagram field budget. */
+/** PROTOCOL.md §7.2 - datagram field budget. */
 export declare const DATAGRAM_HEADER_BYTES = 13;
-/** PROTOCOL.md §7.4 — used only when the transport reports nothing usable. */
+/** PROTOCOL.md §7.4 - used only when the transport reports nothing usable. */
 export declare const DATAGRAM_CONSERVATIVE_FLOOR = 1024;
 export declare const DATAGRAM_CONSERVATIVE_PAYLOAD_MAX: number;
-/** PROTOCOL.md §9 — per-peer bounds. Numbers, not adjectives. */
+/** PROTOCOL.md §9 - per-peer bounds. Numbers, not adjectives. */
 export declare const DATAGRAM_QUEUE_MAX = 64;
 export declare const EMIT_QUEUE_MAX = 256;
-/** PROTOCOL.md §10.1 code 9 — a rejected open resets that stream, never the session. */
+/** PROTOCOL.md §10.1 code 9 - a rejected open resets that stream, never the session. */
 export declare const MAX_CONCURRENT_CALL_STREAMS = 256;
 /** Checked at dequeue, not enqueue: overflow handles a burst, TTL handles a stall. */
 export declare const DATAGRAM_TTL_MS = 150;
-/** PROTOCOL.md §7.3 — a receiver discards (origin, event) sequence state after this idle. */
+/** PROTOCOL.md §7.3 - a receiver discards (origin, event) sequence state after this idle. */
 export declare const SEQUENCE_STATE_RETENTION_MS = 60000;
-/** PROTOCOL.md §7.3 — a released Origin waits this long before returning to the pool. */
+/** PROTOCOL.md §7.3 - a released Origin waits this long before returning to the pool. */
 export declare const ORIGIN_QUARANTINE_MS = 120000;
-/** PROTOCOL.md §7.3 — a departed host's ordinal waits this long before reallocation. */
+/** PROTOCOL.md §7.3 - a departed host's ordinal waits this long before reallocation. */
 export declare const HOST_ORDINAL_QUARANTINE_MS = 300000;
-/** PROTOCOL.md §7.3 — stated ceiling on concurrent session hosts. */
+/** PROTOCOL.md §7.3 - stated ceiling on concurrent session hosts. */
 export declare const MAX_SESSION_HOSTS = 1024;
 /** PROTOCOL.md §4.1 */
 export declare const HANDSHAKE_DEADLINE_MS = 5000;
 /** PROTOCOL.md §10.2 */
 export declare const CLOSE_REASON_MAX_BYTES = 1024;
-/** PROTOCOL.md §10.1 — one byte, because the browser API clamps stream codes to an octet. */
+/** PROTOCOL.md §10.1 - one byte, because the browser API clamps stream codes to an octet. */
 export declare const ResetCode: {
     readonly WT_NO_ERROR: 0;
     readonly WT_ABORTED: 1;

package/dist/protocol.js

@@ -5,7 +5,7 @@
  * these values, so a document and an implementation cannot drift. Change one and the
  * build fails until you change the other.
  */
-/** PROTOCOL.md §4.2 — Stage 0 requires exact equality and refuses otherwise. */
+/** PROTOCOL.md §4.2 - Stage 0 requires exact equality and refuses otherwise. */
 export const PROTOCOL_VERSION = 0;
 /** PROTOCOL.md §5.2 */
 export const FrameType = {
@@ -23,9 +23,9 @@ export function isFrameType(v) {
 }
 /** PROTOCOL.md §5.3. `0x00` is permanently reserved so a zero-filled buffer cannot parse. */
 export const Codec = { JSON: 0x01 };
-/** PROTOCOL.md §5.4 — used by frames whose meaning comes from the stream, not the table. */
+/** PROTOCOL.md §5.4 - used by frames whose meaning comes from the stream, not the table. */
 export const EVENT_ID_NOT_APPLICABLE = 0x00000000;
-/** PROTOCOL.md §5.1 — stream frame field budget. */
+/** PROTOCOL.md §5.1 - stream frame field budget. */
 export const LENGTH_PREFIX_BYTES = 4;
 export const STREAM_HEADER_BYTES = 8;
 export const STREAM_FRAME_OVERHEAD_BYTES = LENGTH_PREFIX_BYTES + STREAM_HEADER_BYTES;
@@ -33,31 +33,31 @@ export const STREAM_FRAME_OVERHEAD_BYTES = LENGTH_PREFIX_BYTES + STREAM_HEADER_B
 export const MIN_LENGTH = STREAM_HEADER_BYTES + 1;
 export const MAX_EMIT_PAYLOAD_BYTES = 1_048_576;
 export const MAX_CALL_PAYLOAD_BYTES = 16_777_216;
-/** PROTOCOL.md §7.2 — datagram field budget. */
+/** PROTOCOL.md §7.2 - datagram field budget. */
 export const DATAGRAM_HEADER_BYTES = 13;
-/** PROTOCOL.md §7.4 — used only when the transport reports nothing usable. */
+/** PROTOCOL.md §7.4 - used only when the transport reports nothing usable. */
 export const DATAGRAM_CONSERVATIVE_FLOOR = 1024;
 export const DATAGRAM_CONSERVATIVE_PAYLOAD_MAX = DATAGRAM_CONSERVATIVE_FLOOR - DATAGRAM_HEADER_BYTES;
-/** PROTOCOL.md §9 — per-peer bounds. Numbers, not adjectives. */
+/** PROTOCOL.md §9 - per-peer bounds. Numbers, not adjectives. */
 export const DATAGRAM_QUEUE_MAX = 64;
 export const EMIT_QUEUE_MAX = 256;
-/** PROTOCOL.md §10.1 code 9 — a rejected open resets that stream, never the session. */
+/** PROTOCOL.md §10.1 code 9 - a rejected open resets that stream, never the session. */
 export const MAX_CONCURRENT_CALL_STREAMS = 256;
 /** Checked at dequeue, not enqueue: overflow handles a burst, TTL handles a stall. */
 export const DATAGRAM_TTL_MS = 150;
-/** PROTOCOL.md §7.3 — a receiver discards (origin, event) sequence state after this idle. */
+/** PROTOCOL.md §7.3 - a receiver discards (origin, event) sequence state after this idle. */
 export const SEQUENCE_STATE_RETENTION_MS = 60_000;
-/** PROTOCOL.md §7.3 — a released Origin waits this long before returning to the pool. */
+/** PROTOCOL.md §7.3 - a released Origin waits this long before returning to the pool. */
 export const ORIGIN_QUARANTINE_MS = 120_000;
-/** PROTOCOL.md §7.3 — a departed host's ordinal waits this long before reallocation. */
+/** PROTOCOL.md §7.3 - a departed host's ordinal waits this long before reallocation. */
 export const HOST_ORDINAL_QUARANTINE_MS = 300_000;
-/** PROTOCOL.md §7.3 — stated ceiling on concurrent session hosts. */
+/** PROTOCOL.md §7.3 - stated ceiling on concurrent session hosts. */
 export const MAX_SESSION_HOSTS = 1024;
 /** PROTOCOL.md §4.1 */
 export const HANDSHAKE_DEADLINE_MS = 5000;
 /** PROTOCOL.md §10.2 */
 export const CLOSE_REASON_MAX_BYTES = 1024;
-/** PROTOCOL.md §10.1 — one byte, because the browser API clamps stream codes to an octet. */
+/** PROTOCOL.md §10.1 - one byte, because the browser API clamps stream codes to an octet. */
 export const ResetCode = {
     WT_NO_ERROR: 0,
     WT_ABORTED: 1,

package/dist/queue.d.ts

@@ -7,7 +7,7 @@ export interface QueueStats {
  * Datagram lane: bounded ring, drop OLDEST on overflow, TTL checked at DEQUEUE.
  *
  * The two axes are different problems. Drop-oldest handles a burst. It does nothing for a
- * peer that stalls two seconds and resumes — the ring never overflows, so a backlog of
+ * peer that stalls two seconds and resumes - the ring never overflows, so a backlog of
  * stale positions is delivered and the application renders history, which is worse than
  * delivering nothing. TTL at dequeue is what fixes that, and the two causes are counted
  * separately so an operator can tell a slow consumer from a slow network.
@@ -35,7 +35,7 @@ export declare class EmitQueue<T> {
     push(item: T): void;
     /**
      * The head, left in place. An item leaves this queue only when its write has actually
-     * completed — `shift()` on hand-off would make depth a measure of nothing, which is
+     * completed - `shift()` on hand-off would make depth a measure of nothing, which is
      * precisely how the bound came to be unreachable.
      */
     peek(): T | undefined;

package/dist/queue.js

@@ -1,5 +1,5 @@
 /**
- * Backpressure. PROTOCOL.md §9 — three lanes, three answers, because they make different
+ * Backpressure. PROTOCOL.md §9 - three lanes, three answers, because they make different
  * promises.
  *
  * The transport swallows its own "blocked" indication along with "too big", so a refused
@@ -11,7 +11,7 @@ import { DATAGRAM_QUEUE_MAX, DATAGRAM_TTL_MS, EMIT_QUEUE_MAX } from './protocol.
  * Datagram lane: bounded ring, drop OLDEST on overflow, TTL checked at DEQUEUE.
  *
  * The two axes are different problems. Drop-oldest handles a burst. It does nothing for a
- * peer that stalls two seconds and resumes — the ring never overflows, so a backlog of
+ * peer that stalls two seconds and resumes - the ring never overflows, so a backlog of
  * stale positions is delivered and the application renders history, which is worse than
  * delivering nothing. TTL at dequeue is what fixes that, and the two causes are counted
  * separately so an operator can tell a slow consumer from a slow network.
@@ -78,7 +78,7 @@ export class EmitQueue {
     }
     /**
      * The head, left in place. An item leaves this queue only when its write has actually
-     * completed — `shift()` on hand-off would make depth a measure of nothing, which is
+     * completed - `shift()` on hand-off would make depth a measure of nothing, which is
      * precisely how the bound came to be unreachable.
      */
     peek() {

package/dist/server.js

@@ -42,7 +42,7 @@ export class Server {
             // Sweeping current peers rather than the ones present at registration: a session
             // accepted in between picked the handler up from `#callHandlers`, so it has to be
             // revoked too. Deleting from the map alone left every already-connected peer still
-            // being answered — revoking a privileged responder did nothing for anyone connected.
+            // being answered - revoking a privileged responder did nothing for anyone connected.
             for (const { session } of this.#peers.values())
                 session.unhandle(event);
         };
@@ -95,7 +95,7 @@ export class Server {
         })
             // Teardown is the last thing that runs for this peer; there is no caller left to
             // hand a rejection to. Without this it was an unhandled rejection, which ends the
-            // process under Node's default — the opposite of what ADR/0005 and D40 promise.
+            // process under Node's default - the opposite of what ADR/0005 and D40 promise.
             .catch(() => undefined);
         await session.start();
         for (const cb of this.#onPeer)

package/dist/session.d.ts

@@ -50,7 +50,7 @@ export declare class Session {
      * identifiers, no pending map, and a stalled call blocks nothing else.
      *
      * There is no default timeout. A dead peer is detected by the QUIC idle timeout, which
-     * closes the session and rejects every pending call — the case a timeout is usually
+     * closes the session and rejects every pending call - the case a timeout is usually
      * reached for is already handled. Pass `AbortSignal.timeout(ms)` for a slow but live
      * responder.
      */
@@ -69,8 +69,8 @@ export declare class Session {
      * The only door out of a session, and every internal path now uses it.
      *
      * Guarding this method alone was not enough: four call sites reached `#conn.close()`
-     * directly — the handshake deadline, the peer-too-slow bound, an emit write failure and a
-     * protocol error on the read loop — so the guard covered the one path that already had
+     * directly - the handshake deadline, the peer-too-slow bound, an emit write failure and a
+     * protocol error on the read loop - so the guard covered the one path that already had
      * the fewest duplicates. A soak still produced 619,422 `close sent twice` complaints from
      * quiche after the first fix, which is what a partial guard looks like from the outside.
      */
@@ -78,13 +78,13 @@ export declare class Session {
     /**
      * Idempotent, and wired to `conn.closed` in `start()` so it cannot be forgotten.
      *
-     * It was forgotten. `clearInterval` appeared in exactly one place — `close()` — and
+     * It was forgotten. `clearInterval` appeared in exactly one place - `close()` - and
      * neither teardown path called it: the server's `conn.closed` continuation freed the
      * origin and removed the peer, and the client's patched a snapshot. Whichever side did
      * not *initiate* the close kept a live interval whose callback closes over `this`,
      * retaining the Session, its Connection, the frame decoder, both queues, the sequence
      * gate and every handler set. At 100 sessions a second that is 360,000 unreclaimable
-     * Sessions an hour, and `unref()` does nothing about it — it stops a timer holding the
+     * Sessions an hour, and `unref()` does nothing about it - it stops a timer holding the
      * event loop open, not holding memory.
      */
     dispose(): void;

package/dist/session.js

@@ -1,6 +1,6 @@
 /**
  * One side of a session. Both the server's view of a peer and the client's view of the
- * server are this class — the handshake is symmetric, and so is everything after it.
+ * server are this class - the handshake is symmetric, and so is everything after it.
  */
 import { decodePayload, encodePayload, validate } from './codec.js';
 import { decodeDatagram, encodeDatagram, SequenceGate } from './datagram.js';
@@ -26,7 +26,7 @@ function closeCodeFor(e) {
 }
 /**
  * §10.2 caps the reason at 1024 **bytes**. Slicing to 1024 characters overshoots by up to
- * threefold on non-ASCII — and event names, which appear in mismatch messages, are the
+ * threefold on non-ASCII - and event names, which appear in mismatch messages, are the
  * user's own domain language. Truncated on a code-point boundary so the result is never
  * a broken surrogate pair.
  */
@@ -95,7 +95,7 @@ export class Session {
             this.#handshakeReject = rej;
         });
         // `ready` is rejected from the emit-stream read loop, which can reach a refusal before
-        // start() has got as far as awaiting it — the peer's handshake is frame 0 and may be
+        // start() has got as far as awaiting it - the peer's handshake is frame 0 and may be
         // decoded during our own `openEmitStream()`. An unobserved rejection terminates a Node
         // server by default, so it is observed here. start() still surfaces it to its caller.
         void this.ready.catch(() => undefined);
@@ -114,7 +114,7 @@ export class Session {
          * Armed before the stream is opened, and raced against every await that follows.
          *
          * It used to be armed *after* `openEmitStream()` and after our own handshake write, so
-         * if either never settled — precisely the stalled-peer case this deadline exists for —
+         * if either never settled - precisely the stalled-peer case this deadline exists for -
          * no timer was ever armed and `connect()` hung for ever. Racing `ready` instead would
          * not work: a peer whose handshake arrives before we have opened our own stream
          * resolves `ready` early, and the race would fire on success.
@@ -229,7 +229,7 @@ export class Session {
      * identifiers, no pending map, and a stalled call blocks nothing else.
      *
      * There is no default timeout. A dead peer is detected by the QUIC idle timeout, which
-     * closes the session and rejects every pending call — the case a timeout is usually
+     * closes the session and rejects every pending call - the case a timeout is usually
      * reached for is already handled. Pass `AbortSignal.timeout(ms)` for a slow but live
      * responder.
      */
@@ -241,7 +241,7 @@ export class Session {
         // An already-aborted signal must not open a stream just to tear it down.
         // §11: a peer that has detected its counterpart is gone MUST NOT reuse a stream from
         // that session. Opening a new one on a dead session is the same mistake wearing a
-        // different hat — the transport may even accept it, and the call then hangs.
+        // different hat - the transport may even accept it, and the call then hangs.
         if (this.#disposed) {
             throw new TransportError('WT_SESSION_CLOSED', 'the session is closed, so no call stream can be opened on it', 'Reconnect. A reconnect is a new session and does not restore room membership (D4).');
         }
@@ -249,7 +249,7 @@ export class Session {
             throw abortToTransportError(opts.signal.reason);
         // An event that declares no `returns` has no response to wait for. The type system
         // already excludes it from `CallableOf`; this is the same refusal for a caller that
-        // reached the wire without the types — and it names the actual problem instead of
+        // reached the wire without the types - and it names the actual problem instead of
         // travelling to the responder to come back as "no handler registered", which is a
         // different fault with a different remedy.
         if (entry.lane === 'stream' && entry.def.returns === undefined) {
@@ -268,7 +268,7 @@ export class Session {
         catch (e) {
             // D18 removes the default call timeout on the grounds that `AbortSignal.timeout(ms)`
             // is the documented substitute, so aborting is the most-documented failure this
-            // library has — and it rejected with a raw DOMException carrying no code and no
+            // library has - and it rejected with a raw DOMException carrying no code and no
             // remedy, which the error helper printed in API.md reports as 'unknown'.
             // Read through a call so narrowing from the pre-check above does not apply: the
             // signal can abort at any point during the call, which is the whole reason it exists.
@@ -285,7 +285,7 @@ export class Session {
     /**
      * The cap is a receiver-side refusal or it is nothing. `call()` declining to open a
      * 257th stream protects the peer from us; it does nothing about a peer that opens 10,000
-     * — a Go implementation written from PROTOCOL.md, or a browser calling
+     * - a Go implementation written from PROTOCOL.md, or a browser calling
      * `createBidirectionalStream()` directly. That is the case §10.1 code 9 exists for.
      *
      * Refused before the request is read, deliberately: the cost this bound exists to bound
@@ -336,15 +336,15 @@ export class Session {
      * The only door out of a session, and every internal path now uses it.
      *
      * Guarding this method alone was not enough: four call sites reached `#conn.close()`
-     * directly — the handshake deadline, the peer-too-slow bound, an emit write failure and a
-     * protocol error on the read loop — so the guard covered the one path that already had
+     * directly - the handshake deadline, the peer-too-slow bound, an emit write failure and a
+     * protocol error on the read loop - so the guard covered the one path that already had
      * the fewest duplicates. A soak still produced 619,422 `close sent twice` complaints from
      * quiche after the first fix, which is what a partial guard looks like from the outside.
      */
     close(code, reason) {
         // Idempotent in both halves. `dispose()` already was; `conn.close()` was not, so a
-        // second close — a client disconnecting while the server is tearing the same session
-        // down, which is ordinary — reached the transport twice. quiche logs
+        // second close - a client disconnecting while the server is tearing the same session
+        // down, which is ordinary - reached the transport twice. quiche logs
         // "WebTransportHttp3 close sent twice" and refuses it, which is a protocol-level
         // complaint we were generating and then ignoring.
         if (this.#disposed)
@@ -355,13 +355,13 @@ export class Session {
     /**
      * Idempotent, and wired to `conn.closed` in `start()` so it cannot be forgotten.
      *
-     * It was forgotten. `clearInterval` appeared in exactly one place — `close()` — and
+     * It was forgotten. `clearInterval` appeared in exactly one place - `close()` - and
      * neither teardown path called it: the server's `conn.closed` continuation freed the
      * origin and removed the peer, and the client's patched a snapshot. Whichever side did
      * not *initiate* the close kept a live interval whose callback closes over `this`,
      * retaining the Session, its Connection, the frame decoder, both queues, the sequence
      * gate and every handler set. At 100 sessions a second that is 360,000 unreclaimable
-     * Sessions an hour, and `unref()` does nothing about it — it stops a timer holding the
+     * Sessions an hour, and `unref()` does nothing about it - it stops a timer holding the
      * event loop open, not holding memory.
      */
     dispose() {
@@ -449,7 +449,7 @@ export class Session {
             return;
         }
         // The request is fully read at this point, so nothing is watching the stream any
-        // more — which is why an abort never reached the handler. The initiator's abort
+        // more - which is why an abort never reached the handler. The initiator's abort
         // resets its send side AND cancels its read side, and that STOP_SENDING surfaces here
         // as a rejection on our writer. Watch it, or `ctx.signal` is decoration.
         void writer.closed.catch(() => controller.abort());
@@ -534,7 +534,7 @@ export class Session {
      * same turn as the push and appended each frame to an unbounded promise chain, so depth
      * returned to zero after every push and `EmitQueue`'s bound could never be reached from
      * a Session. The backlog did not go away, it went somewhere that could not disconnect
-     * anyone — and whose `.catch(() => undefined)` discarded every write failure on the lane
+     * anyone - and whose `.catch(() => undefined)` discarded every write failure on the lane
      * that advertises reliable ordered delivery.
      *
      * Nothing flushes before the handshake, so frame 0 keeps its position by construction

package/dist/transport/browser.js

@@ -1,7 +1,7 @@
 /**
  * The browser Connection, over the platform's own `WebTransport`.
  *
- * Nothing here is imported at module scope — `WebTransport` is read inside connect() —
+ * Nothing here is imported at module scope - `WebTransport` is read inside connect() -
  * so importing this on a server, which Next.js will do, is safe. There is no native
  * addon and no binding, which is why this file is not `*.node.ts`.
  */

package/dist/transport/fails.node.js

@@ -158,7 +158,7 @@ export async function connectHttp3(opts) {
     // The binding loads its native transport through a dynamic import and throws
     // `Lib quiche loading attempt did not end` if a client is constructed before it
     // settles. A process that also runs a server never sees this, because the server
-    // awaits the same promise on the way up — which is exactly why it went unnoticed
+    // awaits the same promise on the way up - which is exactly why it went unnoticed
     // until a client ran on its own.
     await quicheLoaded;
     const wt = new WebTransport(opts.url, {
@@ -168,7 +168,7 @@ export async function connectHttp3(opts) {
         requireUnreliable: true,
     });
     // `closed` rejects independently of `ready`. If the handshake fails, nothing has
-    // attached to it yet and Node sees an unhandled rejection — which terminates a server
+    // attached to it yet and Node sees an unhandled rejection - which terminates a server
     // by default. Claim it before awaiting `ready`; FailsConnection re-reads the same
     // settled promise, so nothing is lost.
     const closedGuard = wt.closed.catch(() => undefined);

package/dist/transport/moq.node.js

@@ -68,7 +68,7 @@ function toReadable(recv) {
             }
         },
         cancel(reason) {
-            // STOP_SENDING with an explicit code — no message-string parsing needed here.
+            // STOP_SENDING with an explicit code - no message-string parsing needed here.
             void recv.stop(codeOf(reason)).catch(() => undefined);
         },
     });

package/dist/transport/parity-suite.d.ts

@@ -11,7 +11,7 @@ export interface UnderTest {
      *
      * `false` is a real capability gap, not a preference. moq surfaces STOP_SENDING only on
      * the next write, and a long-running handler never makes one, so the handler is not
-     * told to stop. The caller still rejects either way — the work just keeps running.
+     * told to stop. The caller still rejects either way - the work just keeps running.
      */
     readonly propagatesAbortToHandler: boolean;
     readonly name: string;
@@ -30,7 +30,7 @@ export interface UnderTest {
 /**
  * One transport per process, deliberately.
  *
- * Running both bindings' servers concurrently in a single process hangs — verified: each
+ * Running both bindings' servers concurrently in a single process hangs - verified: each
  * works alone and both can bind, but sessions on both at once deadlock. That is a
  * property of running two native QUIC stacks side by side, not of transport-io, and no
  * deployment would do it. Splitting by process is also better isolation.

package/dist/transport/parity-suite.js

@@ -23,7 +23,7 @@ const contract = defineContract({
     slow: { lane: 'stream', payload: type$(), returns: type$() },
 });
 // Random high ports. A fixed port makes this suite fail for a reason that has nothing to
-// do with the code — an orphan from a previous killed run still holding the socket, which
+// do with the code - an orphan from a previous killed run still holding the socket, which
 // cost an hour to diagnose once already.
 const dir = mkdtempSync(join(tmpdir(), 'parity-'));
 execFileSync('openssl', [
@@ -59,7 +59,7 @@ const settle = async (ms = 400) => {
 /**
  * One transport per process, deliberately.
  *
- * Running both bindings' servers concurrently in a single process hangs — verified: each
+ * Running both bindings' servers concurrently in a single process hangs - verified: each
  * works alone and both can bind, but sessions on both at once deadlock. That is a
  * property of running two native QUIC stacks side by side, not of transport-io, and no
  * deployment would do it. Splitting by process is also better isolation.

package/dist/transport/types.d.ts

@@ -1,5 +1,5 @@
 /**
- * The transport seam. Internal — not exported from the package (D21).
+ * The transport seam. Internal - not exported from the package (D21).
  *
  * It exists so the reference transport's defects stay in one place: it silently swallows
  * oversized and blocked datagrams, its error type omits the specification's
@@ -25,7 +25,7 @@ export interface Connection {
     /** A property of the path, not a constant. Queried at send time, never cached. */
     maxDatagramSize(): number;
     /**
-     * `undefined` where the runtime does not implement the attribute — which includes the
+     * `undefined` where the runtime does not implement the attribute - which includes the
      * dominant browser. Treated as "unknown, allowed"; only an explicit 'reliable-only' is
      * refused. See D10.
      */

package/dist/transport/unreliable.d.ts

@@ -3,7 +3,7 @@
  * reordering, duplicating and delayed, on command.
  *
  * Test-only. The plain loopback delivers datagrams reliably and in order, which is
- * convenient and a lie — every guarantee the datagram lane deliberately does not make
+ * convenient and a lie - every guarantee the datagram lane deliberately does not make
  * goes unexercised against it. This exists so loss, reordering and duplication are forced
  * deliberately rather than waited for.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transport-io",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Real-time apps over WebTransport. Two lanes, one contract, no fallback.",
   "license": "MIT",
   "type": "module",
@@ -49,7 +49,7 @@
   "author": "#V0ID <hey@v0id.me>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/v0id-user/transport-io.git",
+    "url": "git+https://github.com/transport-io/transport-io.git",
     "directory": "packages/core"
   }
 }