API Index (Full)

This document lists all public types (~1000 lines) in ActualLab.Fusion NuGet packages, organized by assembly and namespace.

ActualLab.Core

ActualLab

ICanBeNone<out TSelf>, CanBeNoneExt

Strongly typed version of ICanBeNone that exposes a static None value.

IHasId<out TId>

An interface that indicates its implementor has an identifier of type TId.

IHasUuid

Similar to IHasId<TId>, but indicates the Id is universally unique.

IResult, IResult<T>

Untyped and strongly typed contracts for a computation result that contains either a value or an error.

IMutableResult, IMutableResult<T>

Untyped and strongly typed computation-result contracts whose value or error can be changed.

IRequirementTarget

A tagging interface that tags types supported by RequireExt type.

AssumeValid (struct)

A unit-type constructor parameter indicating that no validation is required.

ClosedDisposable<TState> (struct)

A lightweight disposable struct that captures state and invokes a dispose action over it.

Disposable<T> (struct)

A lightweight disposable struct wrapping a resource and its dispose action.

Generate (struct)

A unit-type constructor parameter indicating that a new identifier should be generated.

HostId (record)

Represents a unique identifier for a host, auto-generated with a machine-prefixed value.

LazySlim<TValue>

A lightweight alternative to Lazy<T> with double-check locking.

ParseOrNone (struct)

A unit-type constructor parameter indicating a parse-or-return-none semantic.

Requirement (record)

Base class for Requirement<T> that validate values and produce errors on failure.

Result (struct), Result<T> (struct), ResultExt

Untyped and strongly typed value-or-error results and their helper methods.

ServiceException

A base exception type for service-level errors.

IOption, Option<T> (struct)

Represents an optional value that can be either Some or None.

Option

Helper methods related to Option<T> type.

StaticLog

Provides globally accessible ILogger instances via a shared ILoggerFactory.

ExceptionExt

Extension methods for Exception type and its descendants.

KeyValuePairExt

Extension methods and helpers for KeyValuePair<TKey, TValue>.

RequireExt

Extension methods for applying Requirement<T> checks to values and tasks.

StringExt

Extension methods for string.

ActualLab.Api

ApiList<T>

A serializable list intended for use in API contracts.

ApiMap<TKey, TValue>

A serializable dictionary with sorted enumeration, intended for use in API contracts.

ApiSet<T>

A serializable hash set with sorted enumeration, intended for use in API contracts.

ApiArray

Factory methods for creating ApiArray<T> instances.

ApiNullable, ApiNullable8, ApiNullableExt

Factory methods for creating ApiNullable<T> instances.

ApiOption

Factory methods for creating ApiOption<T> instances.

ApiCollectionExt

Extension methods for converting collections to Api collection types.

ActualLab.Async

IWorker, WorkerBase, WorkerExt

Defines the contract for a long-running background worker that can be started and stopped.

TaskResultKind (enum)

Defines the possible result states of a task.

AsyncDisposableBase, AsyncDisposable<TState> (struct)

A template from https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/implementing-disposeasync

ProcessorBase

Base class for async processors with built-in disposal and stop token support.

SafeAsyncDisposableBase

A safer version of https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/implementing-disposeasync that ensures DisposeAsync(bool) is called just once.

TaskCompletionHandler

A pooled helper for attaching completion callbacks to tasks. Each instance caches its delegate, and instances are pooled to minimize allocations.

AsyncChain (record struct), AsyncChainExt

A named async operation that can be composed, retried, logged, and run with cancellation.

AsyncState<T>

A linked-list node representing an async state that transitions to the next value.

BatchProcessor<T, TResult>

Processes items in batches using a dynamically-scaled pool of worker tasks.

BatchProcessorWorkerPolicy (record)

Default implementation of IBatchProcessorWorkerPolicy with configurable scaling thresholds.

Temporary<T> (record struct)

Wraps a value together with a CancellationToken indicating when the value is gone.

AsyncEnumerableExt

Extension methods for IAsyncEnumerable<T>.

AsyncTaskMethodBuilderExt

Extension methods for AsyncTaskMethodBuilder<TResult> and AsyncTaskMethodBuilder.

CancellationTokenExt

Extension methods for CancellationToken.

CancellationTokenSourceExt

Extension methods for CancellationTokenSource.

ExecutionContextExt

Extension methods and helpers for ExecutionContext.

SemaphoreSlimExt

Extension methods for SemaphoreSlim.

TaskExt

Extension methods and helpers for Task and Task<TResult>.

TaskCompletionSourceExt

Extension methods for TaskCompletionSource<TResult>.

ValueTaskExt

Extension methods and helpers for ValueTask and ValueTask<TResult>.

ActualLab.Caching

IAsyncCache<in TKey, TValue>, AsyncCacheBase<TKey, TValue>

Defines the contract for an async key-value cache that supports set and remove operations.

IAsyncKeyResolver<in TKey, TValue>

Defines the contract for asynchronously resolving values by key.

AsyncKeyResolverBase<TKey, TValue>, AsyncKeyResolverExt

Base class for async key resolvers implementing IAsyncKeyResolver<TKey, TValue>.

FileSystemCacheBase<TKey, TValue>, FileSystemCache<TKey, TValue>

Base class for file system-backed caches with atomic read/write operations.

GenericInstanceFactory

Base class for factories that produce instances cached by GenericInstanceCache.

EmptyCache<TKey, TValue>

A no-op cache implementation that never stores or returns values.

MemoizingCache<TKey, TValue>

An in-memory cache backed by a ConcurrentDictionary<TKey, TValue>.

RefHolder

Holds strong references to objects to prevent garbage collection, with concurrent access support.

VoidSurrogate (record struct)

This type is used by GenericInstanceCache class to substitute void types.

GenericInstanceCache

Thread-safe cache for instances produced by GenericInstanceFactory subclasses.

CacheExt

Extension methods for IAsyncKeyResolver<TKey, TValue>.

ActualLab.Channels

ChannelCopyMode (enum)

Defines which channel state transitions to propagate when copying between channels.

ChannelPair<T>

Holds a pair of related channels, optionally with twisted (cross-wired) reader/writer connections.

CustomChannel<TWrite, TRead>

A channel composed from an explicit reader and writer pair.

CustomChannelWithId<TId, TWrite, TRead>

A CustomChannel<TWrite, TRead> with an associated identifier.

EmptyChannel<T>

A channel that is immediately completed and produces no items.

NullChannel<T>

A channel that discards all writes and never produces items on reads.

UnbufferedPushSequence<T>

An unbuffered push-based async sequence that allows a single enumerator and synchronous push.

ChannelExt

Extension methods for Channel<T> and related types.

ActualLab.Collections

IReadOnlyMutableDictionary<TKey, TValue>

A read-only view of a thread-safe mutable dictionary backed by an ImmutableDictionary<TKey, TValue>.

IReadOnlyMutableList<T>

A read-only view of a thread-safe mutable list backed by an ImmutableList<T>.

ArrayBuffer<T> (struct)

A list-like struct backed by ArrayPool<T> that typically requires zero allocations. Designed for use as a temporary buffer in enumeration scenarios.

ArrayOwner<T>

Wraps a pooled array as an IMemoryOwner<T>, returning the array to the pool on disposal.

ArrayPoolBuffer<T>

A resizable buffer backed by ArrayPool<T> that implements IBufferWriter<T> and provides list-like operations.

BinaryHeap<TPriority, TValue>

A min-heap data structure that stores priority-value pairs and supports efficient extraction of the minimum element.

FenwickTree<T>

A Fenwick tree (binary indexed tree) for efficient prefix sum queries and point updates over an array of elements.

ImmutableBimap<TFrom, TTo> (record)

An immutable bidirectional map (bimap) that maintains both forward and backward lookup dictionaries between two key types.

MutableDictionary<TKey, TValue>

Default implementation of IMutableDictionary<TKey, TValue> that wraps an ImmutableDictionary<TKey, TValue> with lock-based thread safety.

MutableList<T>

Default implementation of IMutableList<T> that wraps an ImmutableList<T> with lock-based thread safety.

MutablePropertyBag

A thread-safe mutable property bag backed by an immutable PropertyBag with atomic update operations and change notifications.

OptionSet

A thread-safe mutable set of named options. Obsolete - use MutablePropertyBag instead.

PruningCache<TKey, TValue>

A capacity-bounded cache with lock-free reads; once it grows past its capacity, a background prune evicts arbitrary entries until half of that capacity is left.

RadixHeapSet<T>

A radix heap with set semantics, providing efficient monotone priority queue operations using integer priorities. Each value can appear at most once.

RecentlySeenMap<TKey, TValue>

A capacity- and time-bounded map that evicts the oldest entries when the capacity is exceeded or entries have expired.

RefArrayPoolBuffer<T> (struct)

A ref struct version of ArrayPoolBuffer<T> that avoids heap allocations. Use Release() instead of Dispose().

RingBuffer<T> (struct)

A fixed-capacity circular buffer that supports efficient push/pull operations at both head and tail. Capacity must be a power of two minus one.

VersionSet (record)

An immutable, serializable set of scoped Version values, stored as a comma-separated string of scope=version pairs.

VersionSetExt

Extension methods for VersionSet: Where(predicate) and IntersectScopes(scopes), both returning the source instance when nothing is dropped. The latter is what keeps a peer that invents scopes from adding a cache entry per handshake.

ArrayPools

Provides static references to commonly used ArrayPool<T> instances.

ArrayExt

Extension methods for arrays.

BufferWriterExt

Extension methods for IBufferWriter<T>.

CollectionExt

Extension methods for ICollection<T>.

ConcurrentDictionaryExt

Extension methods for ConcurrentDictionary<TKey, TValue>, including lazy value initialization and atomic increment/decrement operations.

EnumerableExt

Extension methods for IEnumerable<T>.

ImmutableDictionaryExt

Extension methods for ImmutableDictionary<TKey, TValue>.

MemoryExt

Extension methods for ReadOnlyMemory<T> and Memory<T>.

PropertyBagExt

Extension methods for PropertyBag and MutablePropertyBag.

ReadOnlyListExt

Extension methods for IReadOnlyList<T>.

SpanExt

Extension methods for Span<T> and ReadOnlySpan<T>, providing unchecked read/write and variable-length integer encoding operations.

SpanLikeExt

Extension methods for span-like types (arrays, spans, immutable arrays, and read-only lists) providing safe element access.

ActualLab.Collections.Fixed

FixedArray0<T> .. FixedArray16<T> (struct)

A fixed-size inline array of N elements, stored on the stack via sequential layout.

ActualLab.Collections.Slim

IHashSetSlim<T>, HashSetSlim1<T> .. HashSetSlim4<T> (struct)

A compact hash set interface optimized for small item counts, storing items inline before falling back to a full HashSet<T>.

IRefHashSetSlim<T>, RefHashSetSlim1<T> .. RefHashSetSlim4<T> (struct)

A compact hash set interface for reference types, optimized for small item counts using reference equality before falling back to a full HashSet<T>.

ReferenceEqualityComparer<T>

An IEqualityComparer<T> that compares reference type instances by reference identity rather than value equality.

SafeHashSetSlim1<T> .. SafeHashSetSlim4<T> (struct)

A thread-safe compact IHashSetSlim<T> that stores up to N items inline before falling back to an ImmutableHashSet<T>.

Aggregator<TState, in TArg> (delegate)

A delegate that aggregates a single argument into a mutable state by reference.

ActualLab.Comparison

ByRef<T> (struct)

A wrapper that uses reference equality for comparisons instead of value equality.

HasIdEqualityComparer<T>

An equality comparer for IHasId<TId> that compares by Id.

VersionExt

Extension methods and helpers for Version.

ActualLab.Compliance

See Sanitization: Secrets in Logs.

ISanitized

Tagging interface for types whose ToString() honors Sanitization.IsActive - i.e. that render a masked form inside a Sanitization.Begin() scope. Session, User and SessionInfo implement it.

Sanitizer

Maps a raw string to the form that may be rendered. The public Apply is non-virtual and masks unconditionally, passing null through so no policy has to remember to; MaybeApply masks only while Sanitization.IsActive; the static Sanitize<T> / MaybeSanitize<T> are their [return: NotNullIfNotNull] shorthands, and Get<T> / Get(Type) hand out one cached, stateless instance per type. A custom policy overrides protected abstract string Sanitize(string value) - the same name as the static helper, deliberately, and null never reaches it. A class rather than a delegate so it can be a SanitizedString<TSanitizer> type argument.

Sanitizers

The built-in policies, each named after what it leaves visible and each passing null and "" through unchanged: Hidden (<<hidden>>), LengthHint (<<* [8-15]>>, a power-of-two bucket so the exact length never leaks), PrefixAndLengthHint (<<ab* [8-15]>>), Fingerprint (<<a1b2c3d4>> - equal values give equal output, so it's the wrong choice for anything low-entropy), SessionString (Ab3f:9644ea3b), UriQuery (per-parameter, selector-driven) and RpcRequestQuery (the deny-by-default policy for ActualLab's own RPC endpoints: OpenParameterNames verbatim, SessionParameterNames via SessionString, everything else via PrefixAndLengthHint).

SanitizedString<TSanitizer> (struct), ISanitizedString

A drop-in for a string member whose ToString() masks while Sanitization.IsActive and serializes its raw value always - converters ship for System.Text.Json, Newtonsoft.Json, MemoryPack, MessagePack and Nerdbank. ISanitizedString is the non-generic face, so a serializer or log formatter can read Value without knowing the policy.

SanitizingLogger, SanitizingLoggerFactory, SanitizingLoggerFactoryExt

An ILogger decorator that opens a Sanitization.Begin() scope around each Log(...) call, so ISanitized values mask themselves in the log and nowhere else; the factory applies it to every logger it creates - cheaper than wrapping each ILoggerProvider, and it covers providers registered later. logging.AddSanitizingLoggerFactory() registers that in DI, optionally taking a bool or a Func<IServiceProvider, bool>; factory.Sanitizing(mustSanitize) is the non-DI path (e.g. for StaticLog.Factory) and skips re-wrapping an already-wrapped factory. The scope only covers what renders inside the call, so a log argument must defer its ToString() - pass a SanitizedString<T> or an ISanitized, not the result of an eager MaybeSanitize<T>(...).

Sanitization

The ambient switch, and it is off by default: IsActive is a [ThreadStatic] false, so a masking getter - written as get => Sanitizer.MaybeSanitize<T>(field) - stays readable to serializers, which go through that same getter. Begin() turns masking on for the current thread and Suspend() turns it back off (nestable inside Begin()); both return a Scope, a readonly struct that restores the previous state on Dispose. Thread-static, so a scope does not flow across an await.

ActualLab.Concurrency

IHasTaskFactory

Indicates the implementing type exposes a TaskFactory for scheduling work.

ConcurrentPool<T>

A thread-safe object pool backed by a ConcurrentQueue<T> and a StochasticCounter for approximate size tracking.

DedicatedThreadScheduler

A TaskScheduler that executes tasks sequentially on a single dedicated thread.

StochasticCounter (struct)

A probabilistic counter that increments or decrements atomically with a configurable sampling precision, reducing contention on hot paths.

InterlockedExt

Extension methods for Interlocked providing atomic compare-and-swap patterns.

ActualLab.Conversion

IConvertibleTo<out TTarget>

An interface that indicates its implementor can be converted to type TTarget.

Converter<TSource>, ConverterProvider, ConverterExt

A Converter that knows its source type at compile time.

SourceConverterProvider<TSource>

Abstract base implementation of ISourceConverterProvider<TSource>.

BiConverter<TFrom, TTo> (record struct)

A bidirectional converter that provides both forward and backward conversion functions.

ServiceCollectionExt

Extension methods for IServiceCollection to register converters.

ServiceProviderExt

Extension methods for IServiceProvider to access converters.

ActualLab.DependencyInjection

IHasDisposeStatus

Indicates a type that exposes its disposal status.

IHasInitialize

Indicates a type that supports post-construction initialization with optional settings.

IHasServices

Indicates a type that exposes an IServiceProvider instance.

IHasWhenDisposed, HasWhenDisposedExt

Extends IHasDisposeStatus with a task that completes upon disposal.

HostedServiceSet

Manages a group of IHostedService-s as a whole allowing to start or stop all of them.

ServiceResolver

Encapsulates a service type and an optional custom resolver function for resolving services from an IServiceProvider.

ServiceConstructorAttribute

Marks a constructor as the preferred constructor for DI service activation.

TestServiceProviderTag

A marker class registered in DI containers to indicate that the service provider is used in a test environment.

ConfigurationExt

Extension methods for IConfiguration to bind and validate settings.

ServiceCollectionExt

Extension methods for IServiceCollection.

ServiceDescriptorExt

Extension methods for ServiceDescriptor.

ServiceProviderExt

Extension methods for IServiceProvider.

ServiceResolverExt

Extension methods for ServiceResolver.

ActualLab.Diagnostics

INotAnError

A marker interface for exceptions that should not be treated as errors in diagnostics and activity tracking.

Sampler (record)

A probabilistic sampler that decides whether to include or skip events based on configurable strategies (random, every-Nth, etc.).

CodeLocation

Provides methods for formatting source code locations (file, member, line) into human-readable strings for diagnostics.

ActivityExt

Extension methods for Activity to finalize activities with error status and handle disposal safely.

ActivityContextExt

Extension methods for ActivityContext to format W3C trace context headers.

ActivitySourceExt

Extension methods for ActivitySource.

AssemblyExt

Extension methods for Assembly to retrieve informational version.

DiagnosticsExt

Utility methods for sanitizing metric and diagnostics names.

LoggerExt

Extension methods for ILogger to check enabled log levels.

TypeExt

Extension methods for Type to construct diagnostics operation names.

ActualLab.Generators

ConcurrentGenerator<T>

A thread-safe Generator<T> that uses striped generation to reduce contention in concurrent scenarios.

Generator<T>

Abstract base class for value generators that produce a sequence of values.

UuidGenerator

Abstract base for generators that produce UUID strings.

GuidUuidGenerator

A UuidGenerator that produces Guid-based UUID strings.

ProxyGenerator

An incremental source generator that creates proxy classes for types implementing IRequiresAsyncProxy or IRequiresFullProxy interfaces.

ProxyTypeGenerator

Generates a proxy class for a single type declaration, producing interceptor-based method overrides and module initializer registration code.

RandomInt32Generator

A thread-safe generator that produces cryptographically random int values.

RandomInt64Generator

A thread-safe generator that produces cryptographically random long values.

RandomStringGenerator

A thread-safe generator that produces random strings from a configurable alphabet using cryptographic randomness.

SequentialInt32Generator

A thread-safe generator that produces sequentially incrementing int values.

SequentialInt64Generator

A thread-safe generator that produces sequentially incrementing long values.

TransformingGenerator<TIn, TOut>

A Generator<T> that transforms the output of another generator using a provided function.

UlidUuidGenerator

A UuidGenerator that produces ULID-based UUID strings.

ConcurrentInt32Generator

Factory for creating striped concurrent int generators that reduce contention via multiple independent sequences.

ConcurrentInt64Generator

Factory for creating striped concurrent long generators that reduce contention via multiple independent sequences.

RandomShared

Provides thread-safe access to shared random number generation, wrapping Random.Shared on .NET 6+ or a thread-local Random fallback.

ActualLab.IO

ConsoleExt

Extension methods for Console providing asynchronous console I/O.

FileExt

Helper methods for reading and writing text files with configurable encoding.

FilePathExt

Extension methods for FilePath providing file/directory enumeration and text I/O.

FileSystemWatcherExt

Extension methods for FileSystemWatcher providing reactive and async event access.

ActualLab.Locking

IAsyncLockReleaser

Defines the contract for releasing an acquired async lock.

LockReentryMode (enum)

Defines lock reentry behavior modes for async locks.

AsyncLock

A semaphore-based async lock with optional reentry detection.

AsyncLockSet<TKey>

A keyed async lock set that allows locking on individual keys with optional reentry detection.

FileLock

An IAsyncLock<TReleaser> implementation that uses a file system lock.

SimpleAsyncLock

A lightweight async lock without reentry detection support.

SemaphoreSlimExt

Extension methods for SemaphoreSlim.

ActualLab.Mathematics

PrimeSieve

A sieve of Eratosthenes implementation for computing and querying prime numbers.

Bits

Provides bit manipulation utilities such as population count, leading/trailing zero count, and power-of-2 operations.

Combinatorics

Provides combinatorial utilities including subset enumeration and combinations.

GuidExt

Extension methods for Guid providing formatting and conversion utilities.

MathExt

Extended math utilities including clamping, GCD/LCM, factorial, and arbitrary-radix number formatting/parsing.

ActualLab.Net

Connector<TConnection>

Manages a persistent connection of type TConnection with automatic reconnection and retry delay support.

RetryDelay (record struct)

Represents a computed retry delay including the delay task and when it ends.

RetryDelayLogger (record struct)

Logs retry delay events such as errors, delays, and limit exceeded conditions.

RetryDelayer, RetryDelayerExt

Default IRetryDelayer implementation with configurable delay sequences and retry limits.

ActualLab.OS

OSKind (enum)

Defines operating system kind values.

HardwareInfo

Provides cached information about the hardware, such as processor count.

OSInfo

Provides static information about the current operating system.

RuntimeInfo

Provides runtime environment information such as server/client mode and process identity.

ActualLab.Pooling

IPool<T>

Defines the contract for a pool that rents and releases resources of type T.

IResourceReleaser<in T>

Defines the contract for returning a resource of type T back to its pool.

Owned<TItem, TOwner> (struct)

Pairs an item with its disposable owner, disposing the owner on release.

ResourceLease<T> (struct)

A struct-based IResourceLease<T> that releases the resource back to the releaser on disposal.

ActualLab.Reflection

RuntimeCodegenMode (enum)

Defines runtime code generation strategy values.

MemberwiseCopier (record)

Copies property and field values from one instance to another using reflection.

MemberwiseCloner

Provides a fast delegate-based invocation of MemberwiseClone.

RuntimeCodegen

Detects and controls the runtime code generation mode (dynamic methods vs. expression trees).

TypeNameHelpers

Helpers for parsing and formatting assembly-qualified type names.

ActivatorExt

Extension methods for creating instances via cached constructor delegates, supporting both dynamic methods and expression tree codegen.

DelegateExt

Provides typed invocation-list helpers for delegates.

ExpressionExt

Extension methods for Expression providing conversion and member access helpers.

FuncExt

Provides helpers for constructing generic Action and Func<TResult> delegate types at runtime.

ILGeneratorExt

Extension methods for ILGenerator providing casting helpers.

MemberInfoExt

Extension methods for MemberInfo providing cached getter/setter delegate creation for properties and fields.

MethodInfoExt

Extension methods for MethodInfo providing attribute lookup with interface and base type inheritance.

TypeExt

Extension methods for Type providing name formatting, base type enumeration, proxy resolution, and task type detection.

ActualLab.Requirements

CustomizableRequirement (record), CustomizableRequirementBase (record)

A Requirement<T> wrapper that delegates satisfaction checks to a base requirement and uses a customizable ExceptionBuilder for errors.

FuncRequirement (record)

A requirement that uses a delegate function for its satisfaction check.

JointRequirement (record)

A composite requirement that is satisfied only when both its primary and secondary requirements are satisfied.

MustExistRequirement (record)

A requirement that checks a value is not null or default.

ExceptionBuilder (record struct)

Builds exceptions for requirement validation failures using configurable message templates and exception factories.

ActualLab.Resilience

IHasTimeout

Defines the contract for objects that have an optional timeout.

ISuperTransientException

A tagging interface for any exception that has to be "cured" by retrying the operation.

Transiency (enum), TransiencyResolver<TContext> (delegate), TransiencyExt

Defines error transiency classification values.

ChaosMaker (record)

Abstract base for chaos engineering makers that inject faults (delays, errors) into operations for resilience testing.

RetryLimitExceededException

Thrown when the maximum number of retry attempts has been exceeded.

RetryLogger (record)

Logs retry-related events such as failed attempts and retry delays.

RetryPolicy (record), RetryPolicyExt

Default IRetryPolicy implementation with configurable try count, per-try timeout, delay sequence, and transiency-based filtering.

RetryPolicyTimeoutException

Thrown when a single retry attempt exceeds its configured timeout.

RetryRequiredException

A super-transient exception indicating that a retry is required unconditionally.

TerminalException

Base exception class for terminal errors that indicate unrecoverable failure.

TransientException

Base exception class for transient errors that may succeed on retry.

ExceptionFilter (delegate), ExceptionFilterExt

A delegate that determines whether an exception matches a given transiency filter.

ExceptionFilters

Provides common ExceptionFilter instances for transient, non-transient, terminal, and unconditional matching.

TransiencyResolvers

Abstract base class for TransiencyResolver-s.

ExceptionExt

Extension methods for Exception related to resilience and service provider disposal detection.

ServiceCollectionExt

Extension methods for IServiceCollection to register TransiencyResolver<TContext> instances.

ServiceProviderExt

Extension methods for IServiceProvider to resolve TransiencyResolver instances.

TransiencyResolverExt

Extension methods for TransiencyResolver.

ActualLab.Scalability

HashRing<T>

A consistent hash ring that maps hash values to a sorted ring of nodes.

ShardMap<TNode>

Maps a fixed number of shards to a set of nodes using a configurable ShardMapBuilder.

ShardMapBuilder (abstract record)

Builds shard-to-node index maps using a selectable sharding strategy.

ActualLab.Serialization

IHasToStringProducingJson

Indicates that type's ToString() can be deserialized with System.Text.Json / JSON.NET deserializers.

IProjectingByteSerializer<T>

A serializer that allows projection of parts from source on reads.

DataFormat (enum)

Defines whether data is stored as raw bytes or as text.

SerializerKind (enum), SerializerKindExt

Defines the available serializer implementations.

IBox, Box<T> (record), Box

A read-only boxed value, its serializable immutable implementation, and factory methods.

ByteSerialized<T>

A wrapper that auto-serializes its Value to a byte array on access via IByteSerializer.

JsonString

A string wrapper representing a raw JSON value with proper serialization support.

LegacyTypeDecoratingTextSerializer

A legacy variant of TypeDecoratingTextSerializer that uses list-format type decoration.

MemoryPackByteSerializer<T>

A typed MemoryPackByteSerializer that serializes values of type T.

MemoryPackSerialized<T>

A ByteSerialized<T> variant that uses MemoryPackByteSerializer for serialization.

MessagePackByteSerializer<T>

A typed MessagePackByteSerializer that serializes values of type T.

MessagePackSerialized<T>

A ByteSerialized<T> variant that uses MessagePackByteSerializer for serialization.

IMutableBox, MutableBox<T>, MutableBox

A mutable boxed value, its serializable implementation, and factory methods.

NewtonsoftJsonSerialized<T>

A TextSerialized<T> variant that uses NewtonsoftJsonSerializer for serialization.

NewtonsoftJsonSerializer

An ITextSerializer implementation backed by Newtonsoft.Json (JSON.NET).

RemoteException

Represents an exception that was serialized from a remote service and reconstructed from ExceptionInfo.

SystemJsonSerialized<T>

A TextSerialized<T> variant that uses SystemJsonSerializer for serialization.

SystemJsonSerializer

An ITextSerializer implementation backed by System.Text.Json.

TextSerialized<T>

A wrapper that auto-serializes its Value to a string on access via ITextSerializer.

TypeDecoratingByteSerializer

An IByteSerializer decorator that prefixes serialized data with type information.

TypeDecoratingMemoryPackSerialized<T>

A ByteSerialized<T> variant that uses type-decorating MemoryPack serialization.

TypeDecoratingMessagePackSerialized<T>

A ByteSerialized<T> variant that uses type-decorating MessagePack serialization.

TypeDecoratingNewtonsoftJsonSerialized<T>

A TextSerialized<T> variant that uses type-decorating Newtonsoft.Json serialization.

TypeDecoratingSystemJsonSerialized<T>

A TextSerialized<T> variant that uses type-decorating System.Text.Json serialization.

TypeDecoratingTextSerializer

An ITextSerializer decorator that prefixes serialized data with type information.

ByteSerializer<T>, ByteSerializerExt

Provides static access to the default typed IByteSerializer<T> and factory methods.

TextSerializer<T>, TextSerializerExt

Provides static access to the default typed ITextSerializer<T> and factory methods.

TypeDecoratingUniSerialized

Factory methods for TypeDecoratingUniSerialized<T>.

UniSerialized

Factory methods for UniSerialized<T>.

ExceptionInfoExt

Extension methods for converting Exception to ExceptionInfo.

ActualLab.Text

ListFormat (struct)

Defines a list format with a delimiter and escape character for serializing and parsing lists of strings.

ListFormatter (struct)

A ref struct that formats a sequence of strings into a delimited list using ListFormat.

ListParser (struct)

A ref struct that parses a delimited string into individual items using ListFormat.

ReflectionFormatProvider

An IFormatProvider that resolves format placeholders by reflecting on the argument's properties.

StringAsSymbolMemoryPackFormatterAttribute

Attribute that applies StringAsSymbolMemoryPackFormatter to a string field or property for MemoryPack serialization.

Base64UrlEncoder

Encodes and decodes byte data using the URL-safe Base64 variant (RFC 4648).

JsonFormatter

Provides a simple helper for formatting objects as pretty-printed JSON strings.

ByteSpanExt

Extension methods for byte spans providing hex string conversion and XxHash3 hashing.

ByteStringExt

Extension methods for converting byte arrays and memory to ByteString.

CharSpanExt

Extension methods for computing XxHash3 hashes over character spans.

DecoderExt

Extension methods for Decoder.

EncoderExt

Extension methods for Encoder.

EncodingExt

Provides commonly used Encoding instances.

StringExt

Extension methods for string providing hashing and suffix trimming.

StringBuilderExt

Provides thread-local pooling for StringBuilder instances via Acquire/Release pattern.

ActualLab.Time

IGenericTimeoutHandler

Defines a handler that is invoked when a timeout fires.

MomentClock

Abstract base class for clocks that produce Moment timestamps and support time conversion and delay operations.

CoarseSystemClock

A MomentClock that returns a periodically updated time value via CoarseClockHelper, trading precision for lower read overhead.

ConcurrentFixedTimerSet<TItem>, ConcurrentFixedTimerSetOptions (record)

A concurrent, sharded version of FixedTimerSet<TItem> that reduces lock contention by distributing items across multiple internal timer sets.

ConcurrentTimerSet<TTimer>, ConcurrentTimerSetOptions (record)

A concurrent, sharded version of TimerSet<TTimer> that reduces lock contention by distributing timers across multiple internal timer sets.

CpuClock

A MomentClock based on a high-resolution Stopwatch, providing monotonically increasing timestamps that do not drift with system clock adjustments.

FixedTimerSet<TItem>, FixedTimerSetOptions (record)

Similar to TimerSet<TTimer>, but the fire interval is the same for every added item. Internally uses a FIFO queue of (dueAt, item) pairs.

GenericTimeoutSlot (record struct)

Pairs an IGenericTimeoutHandler with an argument for use in timer sets.

MomentClockSet

A set of related MomentClock instances (system, CPU, server, coarse) used as a single dependency for services that need multiple clock types.

RetryDelaySeq (record)

Defines a retry delay sequence with support for fixed and exponential backoff strategies, including configurable jitter spread.

ServerClock

A MomentClock that applies a configurable offset to a base clock, typically used to approximate server time from the client.

SystemClock

A MomentClock that returns the current UTC time via UtcNow.

TickSource

Provides a shared, coalesced timer tick that multiple consumers can await, reducing the number of individual timers.

TimerSet<TTimer>, TimerSetOptions (record)

A priority-based timer set backed by a radix heap, supporting add, update, and remove operations with quantized time resolution.

Intervals

Factory methods for creating fixed and exponential delay sequences.

Timeouts

Provides shared, application-wide ConcurrentTimerSet<TTimer> instances for keep-alive and generic timeout management.

ClockExt

Extension methods for MomentClock providing delay, timer, and interval operations.

DateTimeExt

Extension methods for DateTime providing Moment conversion and default kind assignment.

DateTimeOffsetExt

Extension methods for DateTimeOffset providing Moment conversion.

MomentExt

Extension methods for Moment providing null/default conversions and clock-based time conversion.

ServiceProviderExt

Extension methods for IServiceProvider to resolve MomentClockSet.

TimeSpanExt

Extension methods for TimeSpan providing clamping, random jitter, and human-readable short string formatting, plus the timeout convention: Infinite (= TimeSpan.MaxValue) is the only "never", zero always means "instantly", and AsTimeout() is the single validating converter.

ActualLab.Time.Testing

TestClock, TestClockSettings

A MomentClock for testing that supports time offsetting, scaling, and on-the-fly settings changes with proper delay recalculation.

UnusableClock

A MomentClock that throws on every operation, used as a placeholder when no real clock should be used.

ActualLab.Versioning

IHasVersion<out TVersion>

Indicates that the implementing type exposes a version property.

KeyConflictStrategy (enum)

Defines strategies for handling key conflicts during entity insertion.

VersionGenerator<TVersion>

Abstract base class for generating new versions from the current Version.

VersionMismatchException

Exception thrown when a version does not match the expected version.

KeyConflictResolver<TEntity> (delegate)

A delegate that resolves a key conflict between a new entity and an existing one.

VersionChecker

Provides helpers to check whether a version matches an expected version.

LongExt

Extension methods for formatting long and ulong values as compact base-32 version strings.

ServiceProviderExt

Extension methods for IServiceProvider to resolve versioning services.

ClockBasedVersionGenerator

A VersionGenerator<long> that generates monotonically increasing long versions based on MomentClock ticks.

CpuTimestampBasedVersionGenerator

A VersionGenerator<long> that generates monotonically increasing long versions based on CpuTimestamp ticks.

ActualLab.Trimming

CodeKeeper

Static utility that preserves types, metadata, and generic native code needed through reflection or dynamic dispatch in trimmed and NativeAOT applications.

ActualLab.Interception

ActualLab.Interception

INotifyInitialized

Defines a callback invoked when a proxy is fully initialized.

IProxy, ProxyExt

Represents a proxy object that can have an Interceptor assigned to it.

IRequiresAsyncProxy, RequiresAsyncProxyExt

A tagging interface indicating that the implementing type requires an async proxy.

IRequiresFullProxy

A tagging interface indicating that the implementing type requires a full proxy supporting both sync and async method interception.

ArgumentListReader

Abstract visitor for reading items from an ArgumentList.

ArgumentListWriter

Abstract visitor for writing items into an ArgumentList.

Interceptor, InterceptorExt

Base class for method interceptors that handle proxy method calls and dispatch them to typed or untyped handlers.

ArgumentList (record), ArgumentList0 .. ArgumentList10 (record)

An immutable list of arguments for an intercepted method call, supporting typed access, serialization, and dynamic invoker generation.

ArgumentListG1<T0> .. ArgumentListG10<T0, T1, T2, T3> (record)

A generic ArgumentList with N arguments.

ArgumentListS1 .. ArgumentListS10 (record)

A non-generic (simple) ArgumentList with N arguments stored as objects.

ArgumentListType

Describes the type structure of an ArgumentList, including item types, generic/simple partitioning, and a factory for creating instances.

Invocation (struct), InvocationExt

Describes a single intercepted method invocation, including the proxy, method, arguments, and the delegate to the original implementation.

MethodDef

Describes an intercepted method, including its return type, parameters, async method detection, and invoker delegates.

ProxyIgnoreAttribute

Marks a method to be ignored by the proxy interceptor.

Proxies

Provides methods for creating proxy instances and resolving generated proxy types for IRequiresAsyncProxy base types.

ServiceCollectionExt

Extension methods for IServiceCollection to register typed factories.

ServiceProviderExt

Extension methods for IServiceProvider related to proxy activation.

ActualLab.Interception.Interceptors

SchedulingInterceptor

An interceptor that schedules async method invocations via a TaskFactory resolved from the proxy instance.

ScopedServiceInterceptor

An interceptor that resolves a scoped service for each method call and invokes the method on that scoped instance.

TypedFactoryInterceptor

An interceptor that resolves service instances via dependency injection, enabling typed factory interfaces to create objects through ActivatorUtilities.

ActualLab.Interception.Trimming

ArgumentListCodeKeeper

Retains ArgumentList-related code needed for .NET trimming scenarios.

ProxyCodeKeeper

Retains proxy-related code and metadata needed for .NET trimming scenarios.

ActualLab.Rpc

ActualLab.Rpc

IBackendService

This interface indicates that a certain service is available only on backend.

IRpcMiddleware

Defines a middleware that can intercept and transform inbound RPC call processing.

IRpcService, RpcServiceBuilder

Marker interface for services that can be invoked via RPC.

RpcLocalExecutionMode (enum), RpcLocalExecutionModeExt

Local execution mode for Distributed RPC service methods. Non-distributed RPC servers (services exposed via RPC) don't use call routing and ignore the value of this enum.

RpcMethodKind (enum)

Defines the kind of an RPC method (system, query, command, or other).

RpcPeerConnectionKind (enum), RpcPeerConnectionKindExt

Defines the kind of connection used by an RPC peer (remote, loopback, local, or none).

RpcPeerStopMode (enum), RpcPeerStopModeExt

Defines how inbound calls are handled when an RPC peer is stopping.

RpcTimeoutKind (enum)

Identifies which timeout an RpcTimeoutException reports.

RpcDelayedCallAction (enum), RpcDelayedCallActionExt

Flags controlling how delayed outbound RPC calls are handled.

RpcRemoteExecutionMode (enum)

Controls outbound RPC call behavior for connection waiting, reconnection, and resending.

RpcServiceMode (enum), RpcServiceModeExt

Defines how an RPC service is registered and accessed (local, server, client, or distributed).

RpcSystemMethodKind (enum), RpcSystemMethodKindExt

Defines the kind of a system RPC method (Ok, Error, Cancel, streaming, etc.).

RpcClient

Abstract base class responsible for establishing RPC connections to remote peers.

RpcPeer, RpcPeerOptions (record)

Abstract base class representing one side of an RPC communication channel, managing connection state, message serialization, and call tracking.

LegacyName (record), LegacyNameAttribute

Represents a legacy name mapping with a maximum version, used for backward-compatible RPC resolution.

LegacyNames

An ordered collection of LegacyName entries, indexed by version for backward compatibility.

RpcCallTimeouts (record)

Defines the connect, run and delay timeouts of an outbound RPC call, plus its cache fallback delay.

RpcCallType (record)

Identifies an RPC call type and its corresponding inbound/outbound call implementation types.

RpcCallTypeIds

Defines well-known numeric identifiers for regular and compute RPC call types.

RpcClientPeer

Represents the client side of an RPC peer connection, handling reconnection logic.

RpcClientPeerReconnectDelayer

Controls reconnection delay strategy for RpcClientPeer instances.

RpcConfiguration

Holds the set of registered RPC service builders and default service mode. Frozen after RpcHub construction to prevent further modification.

RpcConnection

Wraps an RpcTransport and associated properties for a single RPC connection.

RpcException

Base exception type for RPC-related errors.

RpcSerializationFormatException

Thrown when a client requests an RPC serialization format that the server does not support.

RpcHub

Central hub that manages RPC peers, services, and configuration for the RPC infrastructure.

RpcLimits (record)

Defines timeout and periodic limits for RPC connections, keep-alive, and object lifecycle.

RpcMethodAttribute, RpcMethodResolver

Configures RPC method properties such as name, timeouts, delayed-call handling, and local and remote execution modes.

RpcMethodDef

Describes a single RPC method, including its name, kind, serialization, timeouts, and call pipeline.

RpcMethodRef (struct)

A serializable RPC method reference identified by its UTF-8 full name and hash code.

RpcOptionDefaults

The only purpose of this class struct is to offer extension point for extensions in other parts of Fusion applying overrides to different RpcXxxOptions.Default.

RpcRef, RpcRefExt

A stable reference to a logical RPC peer target, encapsulating its address, connection kind, versioning info, and the current RpcRoute generation.

RpcReconnectFailedException

Thrown when an RPC peer permanently fails to reconnect to the remote host.

RpcTimeoutException

Thrown when one of the RPC timeouts expires; TimeoutKind tells which one.

RpcRerouteException

Exception indicating that an RPC call must be re-routed to a different peer.

RpcRoute

A single route generation of an RpcRef: carries the resolved target info for this generation and signals when a route change (reroute) occurs. A static route (RpcRoute.NewStatic) belongs to a ref that never reroutes.

RpcSerializationFormat, RpcSerializationFormatResolver (record)

Defines a named RPC serialization format with its argument and message serializer factories. The resolver's ClientDeniedFormatKeys lists the formats a client may not pin via ?f=… — njson5 and njson5np by default.

RpcSerializableAttribute

Configures RPC-specific serialization behavior, including treating annotated abstract types and interfaces as non-polymorphic.

RpcServerPeer

Represents the server side of an RPC peer connection, waiting for incoming connections.

RpcServiceDef

Describes a registered RPC service, including its type, mode, methods, and server/client instances.

RpcServiceRegistry

Registry of all RPC service definitions, supporting lookup by type, name, and method resolution.

RpcStream<T>

Typed RPC stream that supports serialization, remote enumeration, and batched delivery of items.

RpcStreamNotFoundException

Thrown when an RPC stream cannot be found or has been disconnected.

RpcResourceLimitExceededException

Thrown when an inbound message, frame, header, method ref or per-peer object/call count exceeds its RpcLimits ceiling. An ITransientException, so a retry policy treats it as retryable.

RpcDiagnosticsOptions (record)

Configuration options for RPC diagnostics, including call tracing and logging factories.

RpcInboundCallOptions (record)

Configuration options for processing inbound RPC calls on a peer.

RpcOutboundCallOptions (record)

Configuration options for outbound RPC calls, including timeouts, routing, hashing, and delayed-call handling.

RpcRegistryOptions (record)

Configuration options for the RpcServiceRegistry, including service and method factories.

RpcServiceBuilderSettings (record)

Base settings class for customizing RpcServiceBuilder behavior.

RpcBuilder (struct)

Fluent builder for registering and configuring RPC services in a DI container.

RpcFrameDelayer (delegate)

Delegate that introduces a delay between RPC frames to allow batching of small messages.

RpcCallTypes

Registry of RpcCallType instances, mapping call type IDs to their definitions.

RpcDefaults

Provides default API and backend scope names, versions, and peer version sets used by the RPC framework.

RpcFrameDelayerFactories

Provides factory functions that create RpcFrameDelayer instances for various delay strategies.

RpcFrameDelayers

Provides static methods for creating RpcFrameDelayer implementations (yield, tick, delay).

RpcInboundMiddlewarePriority

Well-known priority constants for ordering IRpcMiddleware instances in the pipeline.

ServiceCollectionExt

Extension methods for IServiceCollection to register RPC services.

ServiceProviderExt

Extension methods for IServiceProvider to resolve RPC services.

ActualLab.Rpc.Caching

RpcCacheInfoCaptureMode (enum)

Defines what cache-related information to capture during an RPC call.

RpcCacheEntry

Represents a cached RPC call result, pairing a RpcCacheKey with its RpcCacheValue.

RpcCacheInfoCapture

Captures cache key and value information during outbound RPC calls for cache invalidation and reuse.

RpcCacheKey

A composite key for RPC cache lookups, consisting of a method name and serialized argument data.

RpcCacheValue (record)

Represents a cached RPC response value containing serialized data and an optional content hash.

ActualLab.Rpc.Clients

RpcAlternatingClient

An RpcClient that alternates remote connection attempts between its inner clients.

RpcHttpClient, RpcHttpClientOptions (record)

An RpcClient implementation that establishes full-duplex HTTP/2 connections, with options for URL resolution and transport setup.

RpcWebSocketClient, RpcWebSocketClientOptions (record)

An RpcClient implementation that establishes connections via WebSockets.

ActualLab.Rpc.Diagnostics

RpcCallTracer

Abstract base class for creating inbound and outbound call traces for an RPC method.

RpcInboundCallTrace

Abstract base class representing a trace for an inbound RPC call with an associated activity.

RpcOutboundCallTrace

Abstract base class representing a trace for an outbound RPC call with an associated activity.

RpcCallLogger

Logs inbound and outbound RPC calls at a configurable log level with optional filtering.

RpcCallSummary (record struct)

Captures the result kind and duration of a completed RPC call for metrics recording.

RpcDefaultCallTracer

Default RpcCallTracer that produces OpenTelemetry activities and records call metrics.

RpcDefaultInboundCallTrace

Default inbound call trace that finalizes the activity and records call metrics on completion.

RpcDefaultOutboundCallTrace

Default outbound call trace that finalizes the activity on completion.

RpcActivityInjector

Injects and extracts W3C trace context into/from RPC message headers for distributed tracing.

RpcInstruments

Provides shared OpenTelemetry activity sources, meters, and counters for the RPC framework.

ActualLab.Rpc.Infrastructure

IRpcObject, RpcObjectExt

Represents an RPC object that can be reconnected or disconnected across peers.

IRpcPolymorphicArgumentHandler

Validates inbound RPC calls that have polymorphic arguments.

IRpcSharedObject

An IRpcObject that is shared with a remote peer and supports keep-alive tracking.

IRpcSystemService

Marker interface for system-level RPC services used internally by the RPC framework.

RpcObjectKind (enum)

Defines whether an RPC object is local or remote.

RpcObjectId (record struct)

Uniquely identifies a shared or remote RPC object by host ID and local ID.

RpcPeerChangeKind (enum)

Defines the kind of change detected in a remote peer during handshake comparison.

RpcRoutingMode (enum)

Defines how an RPC call is routed to a peer (outbound, inbound, or pre-routed).

RpcCall, RpcCallHandler

Base class for all RPC call instances, holding the method definition and call identifier.

RpcCallTracker<TRpcCall>

Base class for tracking active RPC calls (inbound or outbound) on a peer.

RpcObjectTracker

Base class for tracking RPC objects (shared or remote) associated with a peer.

RpcServiceBase

Base class for RPC services that provides access to the DI container and RpcHub.

RpcTransport

Base class for RPC transports that handle message serialization and sending.

RpcFrameBasedTransport

Base class for transports that batch outbound RPC messages into frames.

RpcHandshake (record)

Serializable handshake data exchanged between RPC peers during connection establishment.

RpcInboundCall<TResult>

Typed RpcInboundCall that sends the result as TResult.

RpcInboundCallTracker

Tracks active inbound RPC calls on a peer.

RpcInboundContext

Encapsulates the context for processing an inbound RPC message on a peer.

RpcInboundInvalidCallTypeCall<TResult>

Represents an inbound RPC call that failed because its call type ID does not match the expected type.

RpcInboundMessage

A deserialized inbound RPC message containing call type, method reference, arguments, and headers.

RpcInboundNotFoundCall<TResult>

Represents an inbound RPC call whose target service or method could not be found.

RpcInterceptor

Interceptor that routes method invocations to remote RPC peers or local targets based on routing mode.

RpcOutboundCall<TResult>

Typed RpcOutboundCall that creates a result source for TResult.

RpcOutboundCallSetup

Thread-local setup for the next outbound RPC call, controlling peer, routing, and cache capture.

RpcOutboundCallTracker

Tracks active outbound RPC calls on a peer, handling timeouts, reconnection, and abort.

RpcOutboundContext

Encapsulates the context for sending an outbound RPC call, including headers, routing, and caching.

RpcOutboundMessage

An outbound RPC message ready for serialization, containing method, arguments, and headers.

RpcPeerConnectionStateKind (enum)

Identifies disconnected, connecting, connected, and terminal RPC peer connection states.

RpcPeerConnectionState (record)

Snapshot of an RPC peer's lifecycle state, handshake, transport, error, and connection-transition tasks.

RpcRemoteObjectTracker

Tracks remote IRpcObject instances using weak references, with periodic keep-alive signaling.

RpcSharedObjectTracker

Tracks locally shared IRpcSharedObject instances with keep-alive timeout and automatic disposal.

RpcSharedStream<T>

Typed server-side shared stream that reads from a local source and delivers items to the remote consumer.

RpcSimpleChannelTransport

An RpcTransport backed by simple in-memory channels, used for loopback connections.

RpcPipeTransport

An RpcFrameBasedTransport that sends and receives length-prefixed RPC frames over a PipeReader and PipeWriter.

RpcStreamTransport

An RpcFrameBasedTransport that sends and receives length-prefixed RPC frames over a pair of streams.

RpcSystemCallSender

Sends system-level RPC calls (handshake, ok, error, stream control) to a peer's transport.

RpcSystemCalls

Implements IRpcSystemCalls to handle system-level RPC messages on the receiving side.

RpcPolymorphicArgumentHandlerIsValidCallFunc (delegate)

Delegate for validating inbound calls with polymorphic arguments.

RpcTransportSendHandler (delegate)

Delegate invoked by RpcTransport after message serialization to handle send completion or failure.

RpcCallStage

Defines well-known RPC call completion stage constants and a registry for custom stages.

RpcSendHandlers

Provides built-in RpcTransportSendHandler implementations for common send completion scenarios.

WellKnownRpcHeaders

Defines well-known RpcHeaderKey constants for hash, version, and tracing headers.

RpcHeadersExt

Extension methods for working with arrays of RpcHeader.

ActualLab.Rpc.Middlewares

RpcArgumentNullabilityValidator (record)

An IRpcMiddleware that validates non-nullable reference-type arguments on inbound RPC calls.

RpcInboundCallDelayer (record)

An IRpcMiddleware that introduces a configurable random delay before processing inbound RPC calls.

RpcMiddlewareContext<T>

Carries the IRpcMiddleware pipeline state for a specific RpcMethodDef.

RpcMiddlewareOutput<T> (record struct)

Pairs an IRpcMiddleware with its resulting invoker delegate in the middleware pipeline.

RpcRouteValidator (record)

An IRpcMiddleware that validates inbound call routing for distributed and client-only services.

ActualLab.Rpc.Serialization

IRequiresItemSize

Marker interface for message serializers that require item size to be included in the serialized output.

ArgumentListSerializer

Base class for serializers that encode and decode RPC method argument lists.

RpcByteMessageSerializer

Base class for binary RpcMessageSerializer implementations with shared size limits.

RpcMessageSerializer

Base class for serializers that read and write complete RPC messages including headers and arguments.

RpcTextMessageSerializer

Base class for text-based RpcMessageSerializer implementations with shared size limits.

NullValue

This type is used to serialize null values for polymorphic arguments. You shouldn't use it anywhere directly.

RpcFrameCodec

Serializes batches of RPC messages into frame buffers and parses messages back out of them.

ByteArgumentListSerializerV4

V4 binary ArgumentListSerializer that supports polymorphic argument serialization.

RpcByteMessageSerializerV4, RpcByteMessageSerializerV5

V4 binary message serializer using LVar-encoded argument data length prefix.

RpcByteMessageSerializerV4Compact

Compact variant of RpcByteMessageSerializerV4 that transmits method references as hash codes only.

RpcByteMessageSerializerV5Compact

Compact variant of RpcByteMessageSerializerV5 that transmits method references as hash codes only.

TextArgumentListSerializerV4

V4 text-based ArgumentListSerializer that uses a unit-separator delimiter between arguments.

TextArgumentListSerializerV4NP

A non-polymorphic variant of TextArgumentListSerializerV4 that rejects polymorphic serialization.

RpcTextMessageSerializerV3

V3 JSON-based text message serializer that uses JsonRpcMessage for the message envelope.

RpcMessageSerializerReadFunc (delegate)

Delegate that reads an RpcInboundMessage from serialized byte data.

RpcMessageSerializerWriteFunc (delegate)

Delegate that writes an RpcOutboundMessage into a byte buffer.

ActualLab.Rpc.Testing

RpcTestClient, RpcTestClientOptions (record)

An RpcClient implementation that creates in-memory channel-based connections for testing.

RpcTestConnection

Manages a paired client-server in-memory connection for RPC testing with connect/disconnect/reconnect support.

RpcBuilderExt

Extension methods for RpcBuilder that register RpcTestClient for in-memory testing.

ActualLab.Rpc.WebSockets

RpcWebSocketTransport

An RpcTransport implementation that sends and receives RPC messages over a WebSocket connection.

RpcWebSocketCloseCode

Defines well-known application-specific WebSocket close codes used by the RPC framework.

WebSocketOwner

Owns a WebSocket and its associated HttpMessageHandler, disposing both on cleanup.

WebSocketExt

Extension methods for WebSocket providing cross-platform send and receive overloads.

ActualLab.Rpc.Trimming

RpcProxyCodeKeeperExtension

Retains RPC proxy and serialization code that would otherwise be trimmed by the .NET IL linker.

ActualLab.Rpc.Server

ActualLab.Rpc.Server

RpcHttpServer

Server-side handler that accepts incoming full-duplex HTTP/2 connections and establishes RPC peer connections for ASP.NET Core hosts.

RpcHttpServerOptions (record)

Configuration options for RpcHttpServer, including request paths, backend exposure, and connection parameters.

RpcHttpServerBuilder (struct)

Builder for configuring RpcHttpServer and its options.

RpcHttpServerRefFactory (delegate)

Creates an RpcRef for an HTTP server connection from its HTTP context and backend flag.

RpcHttpServerDefaultDelegates

Provides default delegate implementations for RpcHttpServer.

RpcWebSocketServer, RpcWebSocketServerOptions (record), RpcWebSocketServerBuilder (struct)

Server-side handler that accepts incoming WebSocket connections and establishes RPC peer connections for ASP.NET Core hosts.

RpcWebSocketServerRefFactory (delegate)

Delegate that creates an RpcRef for a WebSocket server connection based on the HttpContext and backend flag.

RpcWebSocketServerDefaultDelegates

Provides default delegate implementations for RpcWebSocketServer, including the peer reference factory.

RpcWebSocketServerOriginValidator (delegate)

Decides whether a WebSocket upgrade request may be accepted, based on its Origin header.

RpcWebSocketServerOriginValidators

Ready-made origin validators: AllowAll (the default), SameOrigin, and Allow(origins).

AssemblyExt

Extension methods for Assembly to discover Web API controller types.

EndpointRouteBuilderExt

Extension methods for IEndpointRouteBuilder to map RPC WebSocket and full-duplex HTTP endpoints.

HttpConfigurationExt

Extension methods for HttpConfiguration to configure dependency resolution using IServiceCollection.

RpcBuilderExt

Extension methods for RpcBuilder to add RPC WebSocket and full-duplex HTTP support.

ServiceCollectionExt

Extension methods for IServiceCollection to register Web API controllers as transient services.

ServiceProviderExt

Extension methods for IServiceProvider to create IDependencyResolver instances for Web API.

ActualLab.CommandR

ActualLab.CommandR

ICommand<TResult>, ICommandHandler<in TCommand>, CommandExt

A command that produces a result of type TResult.

ICommandService, CommandServiceExt

A tagging interface for command service proxy types.

ICommander, CommanderBuilder (struct), CommanderExt

The main entry point for executing commands through the handler pipeline.

IEventCommand

Represents an event command that can be dispatched to multiple handler chains identified by ChainId.

CommandContext<TResult>, CommandContextExt

A strongly-typed CommandContext for commands producing TResult.

CommandExecutionState (record struct)

Tracks the current position within a CommandHandlerChain during command execution.

ServiceCollectionExt

Extension methods for IServiceCollection to register the commander.

ServiceProviderExt

Extension methods for IServiceProvider to resolve commander services.

ActualLab.CommandR.Commands

IBackendCommand<TResult>

A generic variant of IBackendCommand that produces a typed result.

IDelegatingCommand<TResult>

A generic variant of IDelegatingCommand that produces a typed result.

IOutermostCommand

A tagging interface that ensures the command always run as the outermost one.

IPreparedCommand

A command that must be prepared before execution.

ISystemCommand

A tagging interface for any command that is triggered as a consequence of another command, i.e., for "second-order" commands.

LocalCommand (record)

Base record for local commands that execute inline via a delegate.

ActualLab.CommandR.Configuration

CommandHandlerFilter

Defines the contract for filtering which command handlers are used for a given command type.

CommandHandler (record)

Base record for command handler descriptors that participate in the execution pipeline.

CommandFilterAttribute

Marks a method as a command filter handler (a handler with IsFilter set to true).

CommandHandlerAttribute, CommandHandlerResolver

Marks a method as a command handler, optionally specifying priority and filter mode.

CommandHandlerChain

An ordered chain of CommandHandler instances (filters and a final handler) that form the execution pipeline for a command.

CommandHandlerRegistry

A registry of all registered CommandHandler instances, resolved from the DI container at construction time.

CommandHandlerSet

Holds all resolved CommandHandlerChain instances for a specific command type, supporting both regular commands and event commands with multiple chains.

FuncCommandHandlerFilter

A CommandHandlerFilter backed by a delegate function.

InterfaceCommandHandler (record)

A CommandHandler that invokes a command via the ICommandHandler<TCommand> interface on a resolved service.

MethodCommandHandler (record)

A CommandHandler that invokes a command by calling a specific method on a resolved service instance.

CommandHandlerResolverExt

Extension methods for CommandHandlerResolver.

ActualLab.CommandR.Diagnostics

CommandTracer

A command filter that creates OpenTelemetry Activity instances for command execution and logs errors.

CommanderInstruments

Provides OpenTelemetry instrumentation primitives for the commander pipeline.

ActualLab.CommandR.Interception

CommandHandlerMethodDef

A MethodDef specialized for intercepted command handler methods, validating that the method signature conforms to expected patterns.

CommandServiceInterceptor

An Interceptor that guards command service proxy calls, ensuring they are invoked only within an active CommandContext.

ActualLab.CommandR.Operations

IOperationCompletionListener

A listener that is notified when an operation completes, enabling side-effect processing such as invalidation.

IOperationEventSource

Defines the contract for objects that can produce an OperationEvent.

IOperationScope, OperationScopeExt

Defines the contract for an operation scope that manages the lifecycle of an Operation within a command pipeline.

Operation

Represents a recorded operation (a completed command execution) with its invalidations, events, and metadata. InvalidationCalls is the ImmutableList<ServiceCall> it carries - AddInvalidationCall, AddInvalidationCalls, RemoveInvalidationCall and RemoveInvalidationCalls maintain it, as AddEvent, RemoveEvent and RemoveEvents do for Events.

OperationCompletion (record)

A command carrying an operation's ServiceCalls to whichever host applies them, and so the recovery carrier for an operation whose origin host didn't finish applying them itself. Its Command is never executed - it's there so the host application can route the event and identify it in an audit.

OperationCompletionHandler

Executes the ServiceCalls an Operation carries, on whichever host applies it. Registered via CommanderBuilder.AddOperationCompletionHandler; this one can't invalidate by itself, and AddFusion() replaces it with FusionOperationCompletionHandler, which can.

OperationEvent

Represents an event recorded during an Operation, typically used for eventual consistency and at-least-once event delivery.

OperationStoreMode (enum)

What an Operation's committed row is, and thus who reads it back: None (nobody - the row exists solely to verify the commit), Operation (the operation log, which every host reads and processes), or Event (the event log, whose entry exactly one host claims).

ServiceCall (record)

A recorded call to a service method: everything needed to reproduce it on this or another host. Deferred invalidation records what it invalidates as these.

ServiceTypeResolver

Maps a service implementation type to the type it's registered as in the container, and back - TryResolveServiceType and TryResolveImplementationType.

ActualLab.CommandR.Rpc

RpcCommandHandler

A command filter that routes commands to remote RpcPeer instances or executes them locally, with automatic rerouting on topology changes.

RpcInboundCommandHandler (record)

An RPC middleware that routes inbound RPC calls for commands through the ICommander pipeline instead of direct method invocation.

ActualLab.CommandR.Trimming

CommanderProxyCodeKeeperExtension

Retains commander proxy-related code needed for .NET trimming scenarios.

ActualLab.Fusion

ActualLab.Fusion

IComputeService, ComputeServiceExt

A tagging interface for Fusion compute service proxy types.

IComputedStateOptions

Configuration options for IComputedState.

IComputedState, IComputedState<T>, ComputedState, ComputedState<T>

A state that automatically recomputes its value on invalidation using a configurable update delay.

IMutableStateOptions

Configuration options for IMutableState.

IMutableState, IMutableState<T>, MutableState, MutableState<T>

A state that supports explicit value mutation, synchronously updating and invalidating its computed value on each change.

ISessionCommand<TResult>, SessionCommandExt

A strongly-typed ISessionCommand that returns a result of type TResult.

IStateOptions<T>, StateOptions<T> (record)

Strongly typed state options with an initial output of type T.

IState, IState<T>, State

A reactive state backed by a Computed value that raises events on invalidation and update.

StateFactory, StateExt

Factory and extension methods for Fusion state objects.

CallOptions (enum)

Defines flags controlling how a compute method call is performed.

ConsistencyState (enum), ConsistencyStateExt

Defines the consistency state of a Computed instance.

InvalidationSourceFormat (enum)

Defines formatting options for displaying InvalidationSource values.

InvalidationTrackingMode (enum)

Defines how much detail is retained when tracking invalidation sources.

RemoteComputedCacheMode (enum)

Defines caching behavior for remote computed values: Cache, NoCache, or ReturnDefault (every lookup "hits" the method's default result, and nothing is read or written).

StateEventKind (enum)

Defines the kinds of lifecycle events raised by a State.

ComputeFunction, ComputeFunctionExt

Base class for functions that produce Computed instances with lock-based concurrency control.

IComputed, Computed, Computed<T>, ComputedExt

The core Fusion abstraction: a cached computation result with consistency tracking, dependencies, and automatic invalidation propagation.

ComputedOptions (record)

Configuration options controlling computed-value caching, invalidation delays, and consolidation.

ComputedInput

Represents the input (arguments) of a compute function, serving as the key for looking up Computed instances in the ComputedRegistry.

ComputedSynchronizer

Provides synchronization logic for Computed instances, ensuring remote computed values are synchronized before use.

ComputeContext

Tracks the current compute call context, including call options and captured computed instances.

ComputeMethodAttribute

Marks a method as a Fusion compute method, enabling automatic caching and invalidation of its Computed output.

ComputedRegistry

A global registry that stores and manages all Computed instances using weak references, with automatic pruning of collected entries.

ComputedSource<T>, ComputedSourceExt

A strongly-typed ComputedSource that produces Computed<T> values.

IConsolidatingComputed, ConsolidatingComputed<T>

A Computed that implements IsConsolidating behavior.

DefaultSessionFactory

Provides factory methods that create SessionFactory delegates producing Session instances with random string identifiers.

FixedDelayer (record)

An IUpdateDelayer with a fixed update delay and configurable retry delays.

InvalidationSource (struct)

Describes the source (origin) of a Computed invalidation, which can be a code location, a string label, or a reference to another Computed.

RemoteComputeMethodAttribute

Marks a method as a remote compute method, extending ComputeMethodAttribute with remote computed caching configuration.

RpcDisabledException

Exception thrown when an RPC call is attempted inside an invalidation block.

Session, SessionResolver, SessionFactory (delegate), SessionExt

Represents an authenticated user session identified by a unique string Id. ToString() is redacted to {4-char Id prefix}:{Hash}; Sha256Hash exposes a strong digest of the Id.

StateBoundComputed<T>

A Computed<T> produced by and bound to a State, notifying the state on invalidation.

StateSnapshot

An immutable snapshot of a State's lifecycle, capturing the current Computed, update count, error count, and retry count.

UpdateDelayer (record)

An IUpdateDelayer that integrates with UIActionTracker to provide instant updates during user interactions.

ComputedCancellationReprocessingOptions (record)

Configuration for reprocessing compute method calls that fail due to cancellation.

FusionBuilder (struct)

A builder for registering Fusion services, compute services, and related infrastructure in an IServiceCollection.

FusionRpcServiceBuilder

A Fusion-specific RpcServiceBuilder that adds compute service proxy creation and command handler registration support.

SessionValidator (delegate)

A delegate that determines whether a Session is valid.

ComputedVersion

Generates globally unique, monotonically increasing version numbers for Computed instances using thread-local counters.

FusionDefaultDelegates

Provides default delegate instances used by Fusion infrastructure.

Invalidation

Provides static helpers to check whether invalidation is active, to begin invalidation scopes, and to defer invalidation blocks.

DeferredInvalidationMode (enum)

Describes how far a command handler's deferred invalidation reaches: Local, Replicated, Distributed. The mode of an operation comes from the first handler that defers a block; handlers that defer nothing have no say, and two that disagree are an error. There is no "unset" member and no app-wide default.

DeferredInvalidationModeAttribute

Declares the DeferredInvalidationMode of a single [CommandHandler] method, or of every command handler declared by a service type - its implementation class or the interface it's registered as.

DeferredInvalidationModeResolver

Resolves the DeferredInvalidationMode of a command handler: its method's attribute, then the attribute of the implementation the container maps its service type to, then of the method's declaring type. There is no fallback: an undeclared mode throws.

DeferredInvalidationContext

Collector of deferred invalidation blocks, all sharing its mode. Its Scope activates it and closes it; what happens to the blocks afterwards is up to whoever opened that scope.

DeferredInvalidationContextExt

The two things one can do with a closed DeferredInvalidationContext's blocks: Apply runs them under an invalidation pass, CollectInvalidationCalls captures the ServiceCalls they'd make without running them.

StateCategories

A cache-backed helper for building state category strings from type names and suffixes.

ServiceCollectionExt

Extension methods for IServiceCollection to register Fusion services.

ServiceProviderExt

Extension methods for IServiceProvider to access Fusion services.

StateFactoryExt

Extension methods for StateFactory.

ActualLab.Fusion.Blazor

IHasCircuitHub

Indicates that the implementing type has access to a CircuitHub instance.

IStatefulComponent<T>, StatefulComponentBase<T>

Defines a Blazor component that owns a typed IState<T> instance.

ComputedStateComponentOptions (enum), ComputedStateComponent<T>

Defines option flags for ComputedStateComponent controlling recomputation, rendering, and dispatch behavior.

ParameterComparisonMode (enum), ParameterComparisonModeExt

Defines the parameter comparison strategy for Blazor Fusion components.

CircuitHubComponentBase

Base class for Blazor components that access CircuitHub and its commonly used services (session, state factory, UICommander, etc.).

ComputedRenderStateComponent<TState>

A computed state component that tracks render state snapshots to avoid redundant re-renders when the state has not changed.

FusionComponentBase, FusionComponentAttribute

Base Blazor component with custom parameter comparison and event handling to reduce unnecessary re-renders.

MixedStateComponent<T, TMutableState>

A computed state component that also manages a MutableState<T>, automatically recomputing when the mutable state changes.

ParameterComparer, ParameterComparerAttribute, ParameterComparerProvider

Base class for custom Blazor component parameter comparers used to determine whether a component should re-render.

ByIdAndVersionParameterComparer<TId, TVersion>

A ParameterComparer that compares parameters by both Id and Version.

ByIdParameterComparer<TId>

A ParameterComparer that compares parameters by their Id.

ByNoneParameterComparer

A ParameterComparer that always considers parameters equal (never triggers re-render).

ByRefParameterComparer

A ParameterComparer that compares parameters by reference equality.

ByUuidAndVersionParameterComparer<TVersion>

A ParameterComparer that compares parameters by both Uuid and Version.

ByUuidParameterComparer

A ParameterComparer that compares parameters by their Uuid.

ByValueParameterComparer

A ParameterComparer that compares parameters using Equals(object, object).

ByVersionParameterComparer<TVersion>

A ParameterComparer that compares parameters by their Version.

CircuitHub

CircuitHub is a scoped service caching a set of most frequently used Blazor & Fusion services. In addition to that, it enables access to Blazor Dispatcher and provides information about the current RenderMode.

ComponentFor

Renders a "dynamically bound" component.

ComponentInfo

Cached metadata about a Blazor component type, including its parameters and their associated comparers for custom change detection.

ComponentParameterInfo

Stores metadata about a single Blazor component parameter, including its property info, comparer, and cascading parameter details.

DefaultParameterComparer

Default parameter comparer that uses known immutable type detection and value equality, mirroring Blazor's built-in change detection logic.

JSRuntimeInfo

Provides information about the current JS runtime, including whether it is remote (Blazor Server) and whether prerendering is in progress.

RenderModeHelper

Provides helpers for querying and switching the current Blazor render mode.

RenderModeDef (record)

Defines a Blazor render mode (e.g., Server, WASM, Auto) with its key and display title.

FusionBlazorBuilder (struct)

Builder for configuring Fusion Blazor integration services such as CircuitHub, UICommander, and JS runtime info.

ComponentExt

Low-level extension methods for ComponentBase providing access to internal Blazor fields (render handle, initialization state) and dispatcher operations.

ComputedStateComponentOptionsExt

Extension methods for ComputedStateComponentOptions.

FusionBuilderExt

Extension methods for FusionBuilder to add Blazor integration.

ActualLab.Fusion.Client

IRemoteComputed, RemoteComputed<T>, RemoteComputedExt

A computed value produced by a remote RPC call that tracks synchronization state with the server.

ActualLab.Fusion.Client.Caching

FlushingRemoteComputedCache

A RemoteComputedCache that batches write operations and flushes them periodically for better performance.

RemoteComputedCache

Abstract base class for remote computed caches that handle serialization and version-based cache invalidation.

InMemoryRemoteComputedCache

An in-memory implementation of FlushingRemoteComputedCache.

SharedRemoteComputedCache

An IRemoteComputedCache wrapper that delegates to a shared singleton RemoteComputedCache instance.

ActualLab.Fusion.Client.Interception

RemoteComputeMethodFunction, RemoteComputeMethodFunction<T>

Handles remote RPC compute method calls with caching, synchronization, and rerouting support.

RemoteComputeServiceInterceptor

An interceptor for remote compute services that delegates calls to either the local compute method handler or the RPC interceptor.

ActualLab.Fusion.Diagnostics

FusionMonitor

A background worker that monitors ComputedRegistry access and registration statistics, periodically logging them for diagnostics.

FusionInstruments

Provides shared ActivitySource and Meter instances for Fusion diagnostics.

ActualLab.Fusion.Extensions

IFusionTime

A compute service that provides auto-invalidating time-related computed values.

IKeyValueStore, KeyValueStoreExt

A shard-aware key-value store service with compute method support for invalidation. It's an IBackendService, so it's reachable only from a backend peer — frontend clients go through ISandboxedKeyValueStore.

ISandboxedKeyValueStore, SandboxedKeyValueStoreExt

A session-scoped key-value store that enforces key prefix constraints based on the current session and user.

RpcPeerStateKind (enum)

Defines the high-level connection state kinds for an RPC peer.

SortDirection (enum)

Defines sort direction values for ordered queries.

KeyValueStore_Remove (record)

Backend command to remove one or more keys from the IKeyValueStore.

KeyValueStore_Set (record)

Backend command to set one or more key-value entries in the IKeyValueStore.

PageRef<TKey> (record)

A typed cursor-based pagination reference with a count and an optional "after" key.

RpcPeerRawConnectedState (record)

Represents the connected state of an RPC peer.

RpcPeerRawDisconnectedState (record)

Represents the disconnected state of an RPC peer, including reconnection timing.

RpcPeerRawState (record)

Represents the raw connection state of an RPC peer.

RpcPeerState (record)

A user-friendly representation of an RPC peer's connection state.

RpcPeerStateMonitor

A background worker that monitors RPC peer connection state changes and exposes the current state via computed properties.

SandboxedKeyValueStore_Remove (record)

Command to remove one or more keys from the ISandboxedKeyValueStore.

SandboxedKeyValueStore_Set (record)

Command to set one or more key-value entries in the ISandboxedKeyValueStore.

EnumerableExt

Extension methods for IEnumerable<T> supporting ordering and pagination.

FusionBuilderExt

Extension methods for FusionBuilder.

QueryableExt

Extension methods for IQueryable<T> supporting ordering and pagination.

ActualLab.Fusion.Interception

IComputedMethodComputed

A tagging interface for Computed instances produced by compute methods.

ComputeMethodComputed<T>

A Computed<T> produced by a compute method interception, which auto-registers and unregisters itself in ComputedRegistry.

ComputeMethodDef

Describes a compute method, including its ComputedOptions and optional consolidation configuration.

ComputeMethodFunction<T>

A strongly-typed ComputeMethodFunction that creates ComputeMethodComputed<T> instances.

ComputeMethodInput

A ComputedInput representing the arguments of an intercepted compute method call.

ComputeServiceInterceptor

An interceptor that routes compute method calls through ComputeMethodFunction to produce cached Computed values.

ComputedOptionsProvider

Resolves ComputedOptions for compute methods, adjusting cache settings based on the availability of IRemoteComputedCache.

ConsolidatingComputeMethodFunction<T>

A strongly-typed ConsolidatingComputeMethodFunction that creates ConsolidatingComputed<T> instances.

ActualLab.Fusion.Operations

Completion<TCommand> (record)

Default implementation of ICompletion<TCommand> carrying the completed operation.

DeferredInvalidationHelper

The Operations Framework side of deferred invalidation: SetInvalidationsAndStoreMode freezes an operation's recorded ServiceCalls at commit time and resolves what its committed row must be.

IOperationCompletionNotifier, OperationCompletionNotifier

Notifies registered operation-completion listeners, deduplicating operations by UUID before dispatch.

ActualLab.Fusion.Operations.Internal

InvalidationGuard

A command filter at priority 999,999,000 that rejects any command about to run while an invalidation pass is active. Deferred invalidation never replays a command handler, so such a command would otherwise mutate without an operation, events or invalidations.

ActualLab.Fusion.Operations.Reprocessing

IOperationReprocessor, OperationReprocessor, OperationReprocessorExt

Reprocesses commands that failed with a reprocessable transient error. The implementation must be a transient service.

ActualLab.Fusion.Rpc

RpcComputeMethodDef

An RpcMethodDef for compute methods, carrying ComputedOptions and using the Fusion-specific RPC call type.

RpcComputeServiceDef

An RpcServiceDef for IComputeService types, providing access to ComputedOptionsProvider.

RpcInboundComputeCallHandler

An RPC middleware that wraps inbound compute method calls in a ComputeContext to capture the resulting Computed instance.

RpcOptionsExt

Extension methods for RpcOptionDefaults.

RpcRegistryOptionsExt

Extension methods for RpcRegistryOptions that apply Fusion-specific overrides.

ActualLab.Fusion.Testing

ComputedTest

Test helpers that repeatedly evaluate an assertion inside a ComputedSource<T> until it passes or a timeout is reached.

ActualLab.Fusion.Trimming

FusionProxyCodeKeeperExtension

A code keeper extension that prevents the .NET trimmer from removing Fusion-specific proxy types, computed functions, and RPC call types.

ActualLab.Fusion.UI

UIAction<TResult>

A strongly-typed UIAction that produces a UIActionResult<T> upon completion.

UIActionFailureTracker

Tracks failed UIAction results, deduplicating recent errors of the same type and message.

UIActionResult<T>

A strongly-typed IUIActionResult carrying the result of a UIAction<TResult>.

UIActionTracker

Tracks running and completed UIAction instances, enabling UpdateDelayer to provide instant updates during user interactions.

UICommander

A command executor for UI layers that wraps each command in a tracked UIAction and registers it with the UIActionTracker.

ServiceProviderExt

Extension methods for IServiceProvider to resolve UI-related Fusion services.

ActualLab.Fusion.Server

ActualLab.Fusion.Server

DefaultDependencyResolver

An IDependencyResolver implementation that delegates to an IServiceProvider for Web API dependency injection.

JsonifyErrorsAttribute

An MVC exception filter that serializes exceptions as JSON error responses.

TextMediaTypeFormatter

A MediaTypeFormatter that handles plain text (text/plain) content for Web API endpoints.

UseDefaultSessionAttribute

A Web API action filter that replaces default sessions in ISessionCommand arguments with the resolved session.

FusionMvcWebServerBuilder (struct)

Builder for configuring Fusion MVC web server services including custom model binder providers and controller registration.

FusionWebServerBuilder (struct)

Builder for configuring Fusion web server services including RPC, session middleware, and render mode endpoints.

ApplicationBuilderExt

Extension methods for IApplicationBuilder to configure Fusion middleware.

EndpointRouteBuilderExt

Extension methods for IEndpointRouteBuilder to map Fusion render mode endpoints.

FusionBuilderExt

Extension methods for FusionBuilder to add Fusion web server services.

HttpActionContextExt

Extension methods for HttpActionContext to access per-request item storage in .NET Framework Web API.

HttpContextExt

Extension methods for IDependencyScope and HttpActionContext to simplify service resolution in Web API.

ServiceCollectionExt

Extension methods for IServiceCollection to register Fusion server services.

ActualLab.Fusion.Server.Controllers

RenderModeController

MVC controller that handles Blazor render mode selection via cookie.

ActualLab.Fusion.Server.Endpoints

RenderModeEndpoint

Endpoint handler that manages Blazor render mode persistence via cookies and returns redirect results.

RedirectUrlHelper

Validates and normalizes the redirect URLs Fusion's server endpoints accept (returnUrl, redirectTo). Check accepts or rejects; Normalize reduces an accepted URL to a relative one, falling back to a caller-supplied URL when it's rejected. AllowedHosts and MustStripHost are init-only, and the registered instance is replaceable via FusionWebServerBuilder.DefaultRedirectUrlHelperFactory. Replaces the RedirectUrlChecker delegate.

ActualLab.Fusion.Server.Middlewares

SessionMiddleware

ASP.NET Core middleware that resolves or creates a Session from cookies and makes it available via ISessionResolver.

HttpContextExtractors

Provides factory methods for creating HttpContext-based value extractors used to derive session tags or identifiers from incoming requests.

ActualLab.Fusion.Server.Rpc

RpcDefaultSessionReplacer (record)

RPC middleware that replaces default sessions in inbound calls with the session bound to the current SessionBoundRpcConnection.

SessionBoundRpcConnection

An RpcConnection that carries an associated Session, enabling server-side session resolution for inbound RPC calls.

RpcOptionsExt

Extension methods for RpcOptionDefaults to apply Fusion server overrides.

RpcPeerOptionsExt

Extension methods for RpcPeerOptions to apply Fusion server overrides, including session-bound connection factory support.

ActualLab.Fusion.EntityFramework

ActualLab.Fusion.EntityFramework

IHasShard

Defines the contract for objects that are associated with a specific database shard.

DbContextBase, DbContextBuilder<TDbContext> (struct), DbContextExt

This type solves a single problem: currently EF Core 6.0 doesn't properly dispose pooled DbContexts rendering them unusable after disposal. Details: https://github.com/dotnet/efcore/issues/26202

DbEntityConverter<TDbContext, TDbEntity, TModel>

Abstract base for IDbEntityConverter<TDbEntity, TModel> implementations that provides default ToEntity and ToModel conversion logic.

DbProcessorBase<TDbContext>

Abstract base for database processors scoped to a specific TDbContext, with lazy access to DbHub<TDbContext>.

DbServiceBase<TDbContext>

Abstract base for database services scoped to a specific TDbContext, with lazy access to DbHub<TDbContext> and common infrastructure.

DbShardWorkerBase<TDbContext>

Abstract base for shard-aware database workers that automatically spawn per-shard tasks when new shards become available.

DbWorkerBase<TDbContext>

Abstract base for long-running database workers scoped to a specific TDbContext, with access to DbHub<TDbContext>.

DbCustomHint (record)

A DbHint containing a custom SQL hint string passed directly to the formatter.

DbEntityResolver<TDbContext, TKey, TDbEntity>

This type queues (when needed) & batches calls to Get with BatchProcessor<TIn, TOut> to reduce the rate of underlying DB queries.

DbHint (record)

Base record for database query hints that influence SQL generation (e.g., locking).

DbHub<TDbContext>

Typed IDbHub implementation for a specific TDbContext, providing DbContext creation with execution strategy suspension and operation scope integration.

DbLockingHint (record)

A DbHint representing row-level locking modes (e.g., Share, Update).

DbShardResolver<TDbContext>, DbShard

Default IDbShardResolver<TDbContext> that resolves shards from Session, IHasShard, and ISessionCommand objects.

DbShardRegistry<TContext>

Default IDbShardRegistry<TContext> implementation that maintains shard sets, tracks used shards, and computes event processor shards.

DbWaitHint (record)

A DbHint representing lock wait behavior (e.g., NoWait, SkipLocked).

ShardDbContextFactory<TDbContext>, ShardDbContextBuilder<TDbContext> (struct)

Default IShardDbContextFactory<TDbContext> implementation that caches per-shard IDbContextFactory<TDbContext> instances built by a ShardDbContextFactoryBuilder<TDbContext>.

DbOperationsBuilder<TDbContext> (struct)

A builder for configuring database operation services such as operation scopes, log readers, log trimmers, and completion listeners for a specific DbContext.

DbIsolationLevelSelector<TDbContext> (delegate)

A delegate that selects the IsolationLevel for a given CommandContext scoped to a specific DbContext type.

ShardDbContextFactoryBuilder<TDbContext> (delegate)

A delegate that builds an IDbContextFactory<TDbContext> for a given shard.

DbHintSet

Provides commonly used DbHint arrays for query locking and wait behavior.

DbKey

Helper for composing composite primary key values for Entity Framework lookups.

ActivityExt

Extension methods for Activity to add shard-related tags.

DbContextOptionsBuilderExt

Extension methods for DbContextOptionsBuilder to register an IDbHintFormatter implementation.

DbEntityResolverExt

Extension methods for IDbEntityResolver<TKey, TDbEntity> providing single-shard shortcuts and batch entity retrieval helpers.

DbSetExt

Extension methods for DbSet<TEntity> providing query hint application and row-level locking shortcuts.

FusionBuilderExt

Extension methods for FusionBuilder to register global DbIsolationLevelSelector instances.

IsolationLevelExt

Extension methods for IsolationLevel providing combinators such as Or and Max.

ServiceCollectionExt

Extension methods for IServiceCollection to register DbContextBuilder<TDbContext> services and transient DbContext factories.

ServiceProviderExt

Extension methods for IServiceProvider to resolve common Fusion EntityFramework services such as DbHub<TDbContext> and entity resolvers.

ActualLab.Fusion.EntityFramework.LogProcessing

IDbLogReader

Defines the contract for a service that reads and processes database log entries.

IDbEventLogEntry

Extends IDbLogEntry with a DelayUntil timestamp for timed event log entries.

IDbIndexedLogEntry

Extends IDbLogEntry with a sequential index for ordered log entries such as operation logs.

IDbLogEntry

Defines the contract for a database log entry with UUID, version, state, and timestamp.

IDbLogTrimmer, DbLogTrimmerOptions (record)

Defines the contract for a service that trims old database log entries.

DbLogKind (enum), DbLogKindExt

Defines the kind of database log: operation log or event log.

LogEntryState (enum)

Defines processing state values for database log entries.

DbEventLogReader<TDbContext, TDbEntry, TOptions>, DbEventLogReaderOptions (record)

Abstract base for reading and processing event log entries from the database, using exclusive row locking to ensure each event is processed exactly once.

DbEventLogTrimmer<TDbContext, TDbEntry, TOptions>

Abstract base for periodically trimming old event log entries from the database based on MaxEntryAge.

DbLogReader<TDbContext, TDbKey, TDbEntry, TOptions>, DbLogReaderOptions (record)

Abstract base for shard-aware database log readers that process entries in batches, handle reprocessing on failures, and coordinate with IDbLogWatcher<TDbContext, TDbEntry>.

DbLogWatcher<TDbContext, TDbEntry>

Abstract base for IDbLogWatcher<TDbContext, TDbEntry> implementations that manage per-shard watchers to detect log changes.

DbOperationLogReader<TDbContext, TDbEntry, TOptions>, DbOperationLogReaderOptions (record)

Abstract base for reading and processing indexed operation log entries from the database, tracking the next expected index per shard.

DbOperationLogTrimmer<TDbContext, TDbEntry, TOptions>

Abstract base for periodically trimming old indexed operation log entries from the database based on MaxEntryAge.

FakeDbLogWatcher<TDbContext, TDbEntry>

A no-op IDbLogWatcher<TDbContext, TDbEntry> placeholder that logs a warning about missing watcher configuration. Change notifications rely on periodic polling.

FileSystemDbLogWatcher<TDbContext, TDbEntry>, FileSystemDbLogWatcherOptions<TDbContext> (record)

An IDbLogWatcher<TDbContext, TDbEntry> that uses file system watchers to detect log changes via tracker files on disk.

LocalDbLogWatcher<TDbContext, TDbEntry>

A local (in-process) IDbLogWatcher<TDbContext, TDbEntry> that immediately notifies watchers on the same host without inter-process communication.

LogEntryNotFoundException

The exception thrown when a requested log entry is not found in the database.

ActualLab.Fusion.EntityFramework.Operations

DbShardWatcher

Watches a single database shard for changes and exposes a WhenChanged task that completes when the shard's log is updated.

DbEvent

Entity Framework entity representing a persisted operation event in the "_Events" table, supporting delayed processing and state tracking.

DbEventProcessor<TDbContext>

Processes OperationEvent instances stored as DbEvent entries, dispatching command events via the ICommander.

DbLogEntrySerializer

How the _Operations and _Events tables serialize their payloads. Every payload has a text and a binary column; Format is a DataFormat and decides which one new rows use (Bytes, i.e. MessagePack, by default), and a read takes whichever one carries the payload. TextSerializer and ByteSerializer are set independently of Format. DI-registered and replaceable; the static Default is what a log entry serializing itself outside DI falls back to.

DbLogEntryModelBuilderExt

ModelBuilder.IgnoreUnusedOperationsFrameworkColumns() maps away the payload columns the current Format doesn't write, leaving one column per payload. It trades the migration-free format switch for the leaner schema.

DbOperation

Entity Framework entity representing a persisted operation in the "_Operations" table, used for cross-host operation log replication and invalidation.

DbOperationCompletionListener<TDbContext>

Listens for locally completed operations and notifies log watchers to trigger remote invalidation and event processing.

DbOperationFailedException

The exception thrown when a database operation fails during commit or processing.

DbOperationScope, DbOperationScope<TDbContext>, DbOperationScopeProvider

Database-backed operation scopes that manage transactions, operation/event persistence, and commit verification.

ActualLab.Fusion.EntityFramework.Operations.LogProcessing

DbEventLogReader<TDbContext>

Reads and processes DbEvent log entries, dispatching them through DbEventProcessor<TDbContext>.

DbEventLogTrimmer<TDbContext>

Trims processed and discarded DbEvent entries that exceed the configured maximum age.

DbOperationLogReader<TDbContext>

Reads and processes DbOperation log entries, notifying remote hosts about completed operations for cache invalidation.

DbOperationLogTrimmer<TDbContext>

Trims old DbOperation log entries that exceed the configured maximum age.

Microsoft.EntityFrameworkCore

IDbContextFactory<out TContext>

Defines a factory for creating DbContext instances. A service of this type is registered in the dependency injection container by the AddDbContextPool methods.

IndexAttribute

Fake IndexAttribute is used only to keep models the same for all targets.

RelationalDatabaseFacadeExtensions

Provides methods to set the underlying DbConnection on a DatabaseFacade via reflection (NETSTANDARD2_0 compatibility shim).

Microsoft.Extensions.DependencyInjection

EntityFrameworkServiceCollectionExtensions

Extension methods for setting up Entity Framework related services in an IServiceCollection.

ActualLab.Fusion.EntityFramework.Npgsql

ActualLab.Fusion.EntityFramework.Npgsql

NpgsqlDbLogWatcher<TDbContext, TDbEntry>, NpgsqlDbLogWatcherOptions<TDbContext> (record)

An IDbLogWatcher<TDbContext, TDbEntry> that uses PostgreSQL LISTEN/NOTIFY to detect database log changes across hosts.

DbContextOptionsBuilderExt

Extension methods for DbContextOptionsBuilder to register the PostgreSQL-specific NpgsqlDbHintFormatter.

DbOperationsBuilderExt

Extension methods for DbOperationsBuilder<TDbContext> to register the PostgreSQL LISTEN/NOTIFY-based operation log watcher.

ActualLab.Fusion.EntityFramework.Redis

ActualLab.Fusion.EntityFramework.Redis

RedisDbLogWatcher<TDbContext, TDbEntry>, RedisDbLogWatcherOptions<TDbContext> (record)

An IDbLogWatcher<TDbContext, TDbEntry> that uses Redis pub/sub to detect database log changes across hosts.

DbContextBuilderExt

Extension methods for DbContextBuilder<TDbContext> to register Redis database connections for use with Fusion EntityFramework services.

DbOperationsBuilderExt

Extension methods for DbOperationsBuilder<TDbContext> to register the Redis pub/sub-based operation log watcher.

ActualLab.Fusion.Blazor.Authentication

ActualLab.Fusion.Blazor.Authentication

AuthState, AuthStateProvider

Extends AuthenticationState with Fusion's User model and forced sign-out status.

ChangeAuthStateUICommand

A UI command representing an authentication state change, used to track auth state transitions via the UI action tracker.

ClientAuthHelper

Client-side helper for performing sign-in, sign-out, and session management operations via JavaScript interop and the IAuth service.

FusionBlazorBuilderExt

Extension methods for FusionBlazorBuilder to add Blazor authentication and presence reporting services.

ActualLab.Fusion.Ext.Contracts

ActualLab.Fusion.Authentication

IAuth

The primary authentication service contract, providing sign-out, user editing, presence updates, and session/user query methods.

IAuthBackend

Backend authentication service contract for sign-in, session setup, and session options management.

AuthBackend_SetupSession (record)

Backend command to set up or update session metadata (IP address, user agent, options).

AuthBackend_SignIn (record)

Backend command to sign in a user with the specified identity.

Auth_EditUser (record)

Command to edit the current user's profile (e.g., name) within a session.

Auth_SignOut (record)

Command to sign out a session, optionally kicking other user sessions.

PresenceReporter

A background worker that periodically reports user presence via UpdatePresence.

ServerAuthHelper

Server-side helper that synchronizes ASP.NET Core authentication state with Fusion's IAuth service on each HTTP request.

SessionAuthInfo (record)

Stores authentication-related information for a session, including the authenticated identity, user ID, and forced sign-out status.

SessionInfo (record)

Stores detailed information about a user session, including version, timestamps, IP address, user agent, and additional options.

User (record), UserExt

Represents an authenticated or guest user with claims, identities, and version tracking.

AuthBackend_SetSessionOptions (record)

Backend command to set session options for the specified session.

DbAuthServiceBuilder<TDbContext, TDbSessionInfo, TDbUser, TDbUserId> (struct)

Builder for configuring database-backed authentication services, including repositories, entity converters, and session trimmer.

EndpointRouteBuilderAuthExt

Extension methods for IEndpointRouteBuilder to map Fusion authentication endpoints.

FusionBuilderExt

Extension methods for FusionBuilder to register authentication client services.

FusionMvcWebServerBuilderExt

Extension methods for FusionMvcWebServerBuilder to register MVC-based authentication controllers.

FusionWebServerBuilderExt

Extension methods for FusionWebServerBuilder to register authentication endpoints and server auth helpers.

HttpContextExt

Extension methods for HttpContext to retrieve authentication schemes and remote IP addresses.

ActualLab.Fusion.Ext.Services

ActualLab.Fusion.Authentication.Controllers

AuthController

MVC controller that handles sign-in and sign-out HTTP requests by delegating to AuthEndpoints.

ActualLab.Fusion.Authentication.Endpoints

AuthEndpoints

Handles sign-in and sign-out HTTP requests using ASP.NET Core authentication.

ActualLab.Fusion.Authentication.Services

DbAuthService<TDbContext>

Abstract base class for database-backed authentication services, defining the IAuth and IAuthBackend contract methods.

DbSessionInfoTrimmer<TDbContext>, DbSessionInfoTrimmer<TDbContext, TDbSessionInfo, TDbUserId>

Background workers that periodically trim expired session records.

DbSessionInfo<TDbUserId>

Entity Framework entity representing a session record in the database, including authentication state and metadata.

DbSessionInfoConverter<TDbContext, TDbSessionInfo, TDbUserId>

Converts between DbSessionInfo<TDbUserId> entities and SessionInfo models.

IDbSessionInfoRepo<TDbContext, TDbSessionInfo, TDbUserId>, DbSessionInfoRepo<TDbContext, TDbSessionInfo, TDbUserId>

Repository contract and default implementation for session-info CRUD and expired-session trimming.

DbUser<TDbUserId>

Entity Framework entity representing a user record in the database, with claims and identity associations.

DbUserConverter<TDbContext, TDbUser, TDbUserId>

Converts between DbUser<TDbUserId> entities and User models.

DbUserIdHandler<TDbUserId>

Default implementation of IDbUserIdHandler<TDbUserId> using converters for parsing and formatting user IDs.

DbUserIdentity<TDbUserId>

Entity Framework entity representing a user identity record in the database.

DbUserRepo

Default database repository for user entities, supporting CRUD and lookup by identity.

InMemoryAuthService

In-memory implementation of IAuth and IAuthBackend for testing and client-side scenarios.

DbAuthIsolationLevelSelector

Selects the database isolation level for authentication-related commands.

ActualLab.Fusion.Extensions.Services

DbKeyValue

Entity Framework entity representing a key-value pair with optional expiration.

DbKeyValueStore

Database-backed implementation of IKeyValueStore using Entity Framework Core.

DbKeyValueTrimmer

A background worker that periodically removes expired key-value entries from the database.

InMemoryKeyValueStore

An in-memory implementation of IKeyValueStore suitable for client-side use cases and testing.

SandboxedKeyValueStore<TContext>

Implementation of ISandboxedKeyValueStore that delegates to IKeyValueStore with session- and user-scoped key constraints.

ActualLab.Serialization.NerdbankMessagePack

ActualLab.Serialization

NerdbankMessagePackByteSerializer, NerdbankMessagePackByteSerializer<T>

An IByteSerializer implementation backed by Nerdbank.MessagePack with custom converters for Fusion types.

NerdbankMessagePackSerialized<T>

A ByteSerialized<T> variant that uses NerdbankMessagePackByteSerializer for serialization.

TypeDecoratingNerdbankMessagePackSerialized<T>

A ByteSerialized<T> variant that uses type-decorating Nerdbank.MessagePack serialization.

RpcNerdbankSerializationFormat

Registers nmsgpack6/nmsgpack6c RPC serialization formats backed by Nerdbank.MessagePack. Call Register() at startup to enable.

ActualLab.Redis

ActualLab.Redis

RedisSubBase

Abstract base class for Redis pub/sub subscribers, managing subscription lifecycle, timeout handling, and message dispatch.

RedisActionSub<T>

A Redis subscriber that deserializes messages to T and invokes a callback action for each received message.

RedisChannelSub<T>

A Redis subscriber that deserializes messages to T and writes them to a Channel<T> for asynchronous consumption.

RedisComponent<T>

Lazily resolves and caches a Redis component of type T (such as IDatabase or ISubscriber) from a RedisConnector, automatically reconnecting when needed.

RedisConnector

Manages a resilient connection to Redis with automatic reconnection, configurable retry delays, and a watchdog that detects disconnections.

RedisDb<TContext>, RedisDbExt

A typed RedisDb scoped by TContext for multi-context dependency injection.

RedisHash

Provides operations on a Redis hash data structure, including get, set, remove, increment, and clear.

RedisPub<T>

Publishes typed T messages to a Redis pub/sub channel using an IByteSerializer<T>.

RedisQueue<T>

A Redis-backed FIFO queue for typed T items with pub/sub-based enqueue notifications and serialization support.

RedisSequenceSet<TScope>

A typed RedisSequenceSet scoped by TScope for multi-context dependency injection.

RedisStreamer<T>

Provides streaming read/write operations over a Redis Stream for typed T items, with pub/sub-based change notifications.

RedisTaskSub<T>

A Redis subscriber that deserializes messages to T and exposes the next received message as an awaitable Task<T>.

ServiceCollectionExt

Extension methods for IServiceCollection to register RedisDb and RedisConnector services.