kuilt-core/us.tractat.kuilt.core

Package-level declarations

Types

sealed interface CloseReason

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.

Direction

enum Direction : Enum<Direction>

Which direction a fault applies to.

FabricAvailability

sealed interface FabricAvailability

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.

FaultProfile

sealed interface FaultProfile

Declarative description of which faults FaultySeam should inject.

FaultyLoom

class FaultyLoom(delegate: Loom, scope: CoroutineScope, defaultProfile: FaultProfile = FaultProfile.Healthy) : Loom

A Loom wrapper that constructs FaultySeam instances.

FaultySeam

class FaultySeam(delegate: Seam, scope: CoroutineScope, initialProfile: FaultProfile = FaultProfile.Healthy) : Seam

A Seam wrapper that injects configurable faults for use in tests.

FlakyLifecycleLoom

class FlakyLifecycleLoom(delegate: Loom, scope: CoroutineScope) : Loom

A Loom wrapper that produces FlakyLifecycleSeam instances.

FlakyLifecycleSeam

class FlakyLifecycleSeam(delegate: Seam, scope: CoroutineScope) : Seam

A Seam wrapper that owns its own state and gates the contract on it, enabling lifecycle-flap scenarios in tests.

FlapSchedule

data class FlapSchedule(val seed: Long, val meanUptime: Duration, val meanDowntime: Duration, val giveUpAfter: Int)

Declarative soak driver for FlakyLifecycleSeam.drive.

InMemoryLoom

class InMemoryLoom : Loom

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.

InMemoryTag

data class InMemoryTag(val displayName: String, val peerKey: String = displayName) : Tag

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

Loom

interface Loom

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).

MuxSeam

class MuxSeam(delegate: Seam, scope: CoroutineScope)

N-way multiplexer over a Seam.

NamedMux

class NamedMux(delegate: Seam, scope: CoroutineScope)

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

Pattern

data class Pattern(val displayName: String, val maxPeers: Int = 6)

Configuration for opening a new peer session.

PeerId

@Serializable

@JvmInline

value class PeerId(val value: String)

Stable, comparable identifier for one peer within one session.

PeerNotConnected

class PeerNotConnected(val peer: PeerId) : IllegalStateException

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

PlyId

@JvmInline

value class PlyId(val value: String)

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

Rendezvous

sealed interface Rendezvous

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

ScopedCloseable

abstract class ScopedCloseable(parentScope: CoroutineScope) : AutoCloseable

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

Seam

interface Seam

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

SeamState

sealed interface SeamState

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

Swatch

class Swatch

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

Tag

interface Tag

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

Functions

checkNotUnderTestDispatcher

fun checkNotUnderTestDispatcher(scope: CoroutineScope, typeName: String, substitute: String, strict: Boolean, expectVirtualTime: Boolean)

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

runCatchingCancellable

inline fun <R> runCatchingCancellable(block: () -> R): Result<R>

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.