Package-level declarations

A self-healing single-active-session slot for a Loom/factory that hosts one live Seam at a time.

Reason a Seam is being closed. Designed as a forward-compatible sealed hierarchy — new variants can be added without breaking existing when exhaustiveness because the common cases are covered.

How an in-process fabric buffers frames for one receiver: a bounded capacity and an overflow strategy. There is deliberately no UNLIMITED option — unbounded delivery is the defect this type exists to make unrepresentable (#701).

Whether a Loom's underlying transport fabric can be attempted on this runtime. A fabric scoped out by target (e.g. WebRTC only present on wasmJs) is simply absent — not Unavailable. Unavailable means present-but-not-usable-now.

Thrown by a Overflow.FAIL delivery buffer when a frame arrives and the buffer is full.

In-memory implementation of Loom for use in tests and integration harnesses. All Seam instances produced by the same factory instance share a single in-memory mesh.

A Tag implementation for the in-memory transport. Since the in-memory factory does not need network discovery, this carries only the session name. The factory itself provides the mesh context.

Establishes a Seam in the role of either an existing-session joiner or a new-session opener. The factory hides discovery (mDNS, MultipeerConnectivity advertising, WebSocket URL).

The default values a Loom factory hands to the knobs that every fabric shares.

A client Loom that weaves one base fabric and serves many logical sessions as named channels over a single NamedMux — the fix for "every join opens a new socket."

N-way multiplexer over a Seam.

A server-side Loom that provides structural per-room isolation over a shared ConnectionSource.

String-keyed multiplexer over a Seam — the unbounded-namespace sibling of MuxSeam.

Overflow behaviour when a bounded delivery buffer is full. Mirrors Reactor's onBackpressure*.

Configuration for opening a new peer session.

Thrown by an addressed send whose payload exceeds the published send budget — Seam.maxPayloadBytes, or a budgeted derivative of it such as Room.maxPayloadBytes.

Stable, comparable identifier for one peer within one session.

The one place a fabric decides whether a peer-supplied identity may join its roster, and who is allowed to take it away again.

A fabric refused an identity a remote announced for itself.

Thrown by Seam.sendTo when the addressed peer is not in Seam.peers.

Stable identity of one constituent link ("ply") within a composite fabric.

An opaque, caller-verified identity for the peer on a connection — e.g. an authenticated device id or user id the host established out of band (token, TLS client cert, signed header) before admitting the peer.

A seam or connection whose transport accept carries a host-verified Principal. A fabric that can authenticate a connection (e.g. a Ktor server reading call.principal()) attaches one via a withPrincipal wrapper; admission layers read it at admit time and carry it onto the admitted peer.

An observable PeerId → Principal roster: the landing spot for host-verified identities on paths that have no admit handshake or member objects (the hosted-hub topology).

Which half of a pumpIn pump failed — and, decisively, whether the pump is still running.

Describes the role a Loom peer takes when weaving a session.

Server-side authorization policy for room membership.

Server-side hub Seam for one named room — the structural per-room isolation primitive.

Base for coordinators that launch coroutines into an owned child scope and implement AutoCloseable.

One peer's view of a multi-peer session.

Thrown by raceCollapse when the Seam collapses mid-operation — the work being raced can no longer complete because the peers it needs are gone. A collapse surfaces two distinct ways and this exception covers both:

One peer's view of whether the fabric can carry frames.

Terminal-latching holder for a seam's SeamState — the primitive that makes the "lost terminal transition" bug class unrepresentable.

The one sanctioned per-receiver inbound buffer for in-process delivery.

Opaque message moving between peers. The wire layer does not interpret the bytes; that is the consumer's job.

Game-agnostic discovery handle. mDNS service record / MPC peer / WS URL.

A transport's self-report: the roles it plays and whether its fabric is usable now (availability). Produced pre-connect by Loom.capability and live per-session by Seam.capability.

What role a transport plays. A single fabric may hold several roles at once (Apple Multipeer is WifiDirect + Bluetooth; a Network.framework fabric is Discovery + Data). Sealed so a novel fabric can add a case without editing a closed enum.

A weft is the thread woven in fresh on every pass of the shuttle across a Loom — here, a per-dial value recomputed on every Loom.weave attempt, including every reconnect. Never cached by kuilt: a fabric Loom implementation that needs fresh per-dial data invokes this itself, inside its own weave(), so the caller's C is recomputed on the first dial and on every subsequent redial.

Emits a warning (or throws, when strict is true) if scope contains a kotlinx.coroutines.test.TestDispatcher.

Mint a fresh, globally-unique PeerId for one peer.

A StateFlow view that follows this flow until latched flips to true, then reports terminal and never changes again.

Collect this flow in scope as a long-lived pump that a throw cannot kill — neither one raised in body nor one raised by the flow — reporting either through onFailure.

Run body but abort it with a SeamCollapsedException the instant this Seam collapses mid-operation — either the fabric latches SeamState.Torn (transport tear) OR the live peer set satisfies abortWhen (membership drain). Whichever of body, the tear, or the drain resolves first wins; the losers are cancelled.

Like runCatching but never swallows coroutine cancellation: a CancellationException always propagates, so a cancelled coroutine fails fast instead of being reported as a captured failure. Every other Throwable becomes Result.failure.

Bond a local-tier and a peer-tier Seam — two views of the same node onto two disjoint peer sets — into one Seam whose roster is the union of both.

The first-hop origin-spoofing rule, shared by every point that accepts a relay frame off a fabric — safety-critical wherever a relayed identity is credited.

Returns a Connection that reports principal via PrincipalAttested. When principal is null the receiver is returned unchanged — an unauthenticated connection carries no attestation and is never wrapped.