All Classes and Interfaces
Class
Description
Abstract base implementation of the
Client interface, providing shared logic and lifecycle management for
both local (in-memory) and remote (WebSocket-based) Fluxzero clients.An abstract base class for converting data of type
I to type O.Base implementation for built-in
RequestResult types.Abstract base implementation of the
Serializer interface.Abstract base class for implementing
UserProviders that resolve user identities via a metadata key.Abstract base class for all WebSocket-based clients in the Fluxzero Java client.
Cache implementation backed by the common hard-reference memory-aware cache support.A
DispatchInterceptor that enables thread-local, dynamically scoped interceptors during message dispatch.Atomically adopts an application-verified staged Model document.
Adopts a staged source separately while fencing the observed legacy/public projection in the same transaction.
Deprecated, for removal: This API element is subject to removal in a future version.
Scheduled for removal in Fluxzero 3.0.
Controls when aggregate changes are committed and whether multiple commits in the same completion phase may run
concurrently.
Controls how events published from an aggregate are assigned to a message segment.
A wrapper around a stream of aggregate events, enriched with metadata such as the aggregate ID and the last known
sequence number.
Repository interface for loading, managing, and repairing aggregates in Fluxzero.
Represents the root of a legacy aggregate in a domain model.
Marks a property whose current value is an alternative identifier for an entity or independently stored model.
A composite constraint that requires all inner constraints to match.
Per-Apply control of inherited cascading assertions; local and payload assertions remain active.
A single child entity replacement within an
AnnotatedEntityHolder.A composite constraint that requires at least one inner constraint to match.
Adds optional human-readable API documentation metadata to generated API docs.
Policy for properties that are not explicitly declared by an object schema.
Generic API documentation model extracted from Fluxzero web handlers.
Adds a raw OpenAPI component to generated API documentation.
Human-authored documentation metadata associated with an API endpoint.
Describes a single extracted web API endpoint.
Excludes a package, type, handler method, parameter, field, record component, or type use from generated API
documentation.
Extracts generic API documentation metadata from Fluxzero web handlers.
Adds top-level metadata to generated API documentation.
Describes an API parameter inferred from a route path or a web parameter annotation.
Describes a full request body parameter inferred from an unannotated web handler argument.
Adds an explicit response entry to generated API documentation.
Describes an explicitly documented API response.
Container annotation for repeatable
ApiDocResponse declarations.Describes a server entry for generated API documentation.
Automatic endpoint that serves an HTML API reference page for an
ApiDocInfo scope.Browser renderer for automatically served API reference pages.
Command to publish messages to a specific log in Fluxzero (e.g., commands, events, metrics, etc.).
Metric payload used for internal monitoring and logging.
Command used to append one or more event batches to the event store.
Compact metric representation of an
AppendEvents command.A
PropertySource that loads environment-specific properties from an application-<env>.properties file
on the classpath.Metric event emitted when a Fluxzero application instance starts or begins shutting down.
Application lifecycle phases published as metrics.
Central utility for resolving configuration properties within a Fluxzero application.
A
PropertySource implementation that loads properties from an application.properties file located on
the classpath.Adds the configured application version to another correlation data provider.
Represents an event that has been applied to an aggregate along with its intended publication strategy.
Indicates that a method or constructor applies an update to an entity, or creates or deletes an entity.
Whether an apply interceptor validates its current input before transforming it.
Annotation to mark methods or fields that assert whether a command or query is legal, given the current state of an
aggregate.
Declares how a message should be associated with handler instances.
Thread-local scope for asynchronous work started from completion callbacks.
Message-scoped hook for infrastructure that wants to add context to authorization failures.
Controls whether model applies may be exposed as an automatic command handler.
Waits until one materialized graph projection has completed every root update originating at or before a committed
model state.
Waits for current Model projection progress and all pending source rewrites of the selected nodes in one collection.
A thread-safe batching queue that asynchronously flushes its content to a consumer in configurable batch sizes.
A function that consumes a batch of items and returns a future that completes when processing is done.
A batching wrapper for
HandlerRepository that delays persistence operations until the end of the current
message batch.Intercepts and decorates batch-level message handling for a
Tracker.Explicit selection-preserving wrapper; use
BatchInterceptor.preservingConsumerFilter(BatchInterceptor).Exception thrown during message batch processing to intentionally halt tracking after a specific message.
A
Constraint that filters documents based on whether a value in a specific path lies between two bounds.Allocation-bounded primitive I/O shared by compact transports and persisted messages.
Unchecked cursor for validated embedded values whose public API does not expose I/O failures.
Injects a field from a JSON request body into a handler method parameter.
A generic response containing a boolean value, typically used to indicate success/failure.
Represents a single operation in a bulk document update.
Supported bulk operation types.
Fluent builder for applying multiple updates to a single document collection.
Command to perform a batch update of documents in the search/document store.
Metric representation for monitoring or observability.
A generic cache interface for storing and managing objects identified by unique keys.
Represents an eviction from a
Cache.Indicates the cause for a cache entry eviction.
Represents an eviction event from a
Cache.Logs and publishes cache eviction events as metrics.
A wrapper around a delegate
AggregateRepository that ensures cached aggregates stay in sync with the event
log.A
TrackingClient implementation that wraps another client (typically a WebsocketTrackingClient)
and caches recent messages in memory to reduce redundant round trips to the Fluxzero Runtime.Exception used to cancel a periodic schedule from a schedule handler.
Command to cancel a previously scheduled message using its
CancelSchedule.scheduleId.Internal reconstructing event stored for models deleted through an owning
Parent relationship.Meta-annotation that indicates a method performs a revision-based type transformation.
Functional interface representing a transformation from one stream of values to another, possibly adjusting for
version compatibility or format changes.
A composite
Caster that supports registration of multiple casting strategies.Represents metadata that uniquely identifies a version of a serialized data type, along with an optional delta
indicating how the revision should change after casting.
Implementation of
Encryption using the ChaCha20-Poly1305 authenticated encryption algorithm.One fully resolved immutable model mutation outcome consumed by commit preparation.
Deserializing view for a message whose payload is split across multiple indexed messages.
Reads serialized messages from a bounded index range while recovering chunked messages.
Result of a segment claim in the tracking strategy domain.
A request to claim a message segment for consumption in client-controlled tracking mode.
Result of a
ClaimSegment request.Lightweight metric representation of a
ClaimSegmentResult, used for telemetry.Defines the low-level client contract used by
FluxzeroBuilder to construct a
Fluxzero instance.Functional interface for monitoring the dispatch of messages by a
Client.Utility class offering client-side support functions for working with Fluxzero.
Namespace of the consumer handling a framework-created message.
A
MessageStore implementation backed by a collection in an InMemorySearchStore.Fail-closed wire envelope preserving query-based mutation identity, routing and delivery guarantees.
Identifies operations which must never be interpreted by a legacy receiver.
Fail-closed wire envelope for reads requiring annotation-independent value semantics.
Collection intervals using the existing sortable encoding and per-document legacy fallback.
Explicit query profile whose range constraints compare field values independently of index annotations.
Base class for commands sent to the Fluxzero Runtime.
Gateway interface for publishing command messages in Fluxzero.
Internal state of one model commit attempt, from its loaded begin-state through ordered changes and completion.
Internal signal: no commit was submitted, but a document used during evaluation has changed.
One ordered mutation journal entry.
Atomically commits the ordered state transitions produced by one model commit.
Payload-free model commit metrics.
Result of an accepted, rebase-requested, deadline-reevaluation-requested, or conflict-rejected
CommitModels.Payload-free commit-result metrics.
Atomically validates consumed alias mappings alongside Model heads, relationship reads and document projections.
Commits SDK-computed ordinary scheduler effects together with Model state.
Commits internal Model sources and independent document projections together.
Atomically validates explicit alias selections with Model mutations and existing commit facets.
A Model commit that additionally validates relationship selections.
Common timing characteristics exposed by aggregate and independent-model commit policies.
Enumeration of supported compression algorithms used for serializing and deserializing byte data.
Conditional that only matches when a bean of the specified type is present in the application context.Conditional that only matches when a bean of the specified type is not present in the context.Conditional that only matches when the specified property is either unset or the empty string.Conditional that only matches when a specific property is set and matches a given pattern.A runtime-generated event that indicates a client has successfully connected to the Fluxzero Runtime.
Utility class for computing segment assignments using consistent hashing.
A marker message type published to the Fluxzero error gateway for error-level log entries.
A marker message type published to the Fluxzero error gateway for warning-level log entries.
Base interface for defining filter conditions (constraints) used in document search queries.
Structured validation failure exposed by the Fluxzero validation API.
Declares a
Consumer within a Fluxzero application.Lifecycle-bound projection of the effective handlers assigned to one consumer.
Configuration class that defines how a message consumer behaves during message tracking and handler invocation.
Versioned, conservative projection of an application's effective consumer blueprint.
A serialized input name, optionally limited to one revision or matching an entire package prefix.
Generic route matcher.
Controls whether handlers for a consumer are invoked in the tracker thread or offloaded to a worker thread.
Collector for container metrics from cgroups (v1 and v2).
Container metrics collected from cgroups (v1 or v2).
A constraint that matches document entries containing the specified phrase, with optional wildcard-like flexibility.
Represents an interface for filtering content before it is passed to a specified viewer.
Interface for converting
Data objects from one format or representation to another.Indicates that a request contains distinct values for a cookie that was required to be conflict-free.
Injects the value of an HTTP cookie into a handler method parameter.
Determines how
WebRequest.getCookie(String, CookieValueConflictPolicy) handles multiple cookies with the
same case-sensitive name.A
DispatchInterceptor that enriches outgoing messages with correlation metadata,
enabling full traceability across message flows within Fluxzero.Strategy interface for extracting correlation metadata from the current context.
Collector for CPU metrics using JMX.
CPU metrics for the process and system.
Command to configure to use a search collection as a searchable audit trail.
Validates that a character sequence is a credit card number according to the Luhn checksum.
Container annotation for repeatable
CreditCardNumber constraints.This provides cron support for java8 using java-time.
Resolves handler method parameters of type
User.A generic container for holding a value along with serialization metadata such as type, revision, and format.
Read-only view of a byte-array range for serializers that can consume a slice directly.
A
DispatchInterceptor and HandlerInterceptor that supports secure transmission of sensitive data
fields by removing them from the payload before dispatch and restoring them during handling.Declares one desired, one-shot deadline on a Model.
The last deadline declared by one Model category, as recorded with that Model revision.
Internal codec for SDK-owned deadline metadata in events, Model documents and snapshots.
Immutable arbitrary-precision decimal with numerical equality, independent of trailing zeros.
Reads exact decimal strings and legacy numeric JSON tokens without a floating-point intermediate.
Writes decimals exactly as strings in JSON and as numbers in the document index.
A
PropertySource decorator that transparently decrypts encrypted property values.Default implementation of the
AggregateRepository interface.Default aggregate cache facade that selects the current SDK cache implementation from Fluxzero cache properties.
Default implementation of the
CasterChain interface used for managing and applying casting operations—
typically upcasting or downcasting—on SerializedObject instances.A
SerializedObject wrapper that applies a Converter to translate data from one format to another.Represents a unique combination of serialized object
type and revision, used as a key in the
caster registry.Default implementation of the
CommandGateway interface.Default implementation of the
CorrelationDataProvider interface.Default serializer for
Document instances in the Fluxzero Runtime.Default implementation of the
Encryption interface used in Fluxzero.The
DefaultEntityHelper provides the default implementation of the EntityHelper interface.Decorates a
DeserializingMessage with an associated entity.Wraps a message and its corresponding entity for use in interception or handler invocation.
Default implementation of the
ErrorGateway interface.Default implementation of the
EventGateway interface.Default implementation of the
EventStore interface, providing mechanisms to store and retrieve events
associated with aggregate instances.Default implementation of the
Handler interface.Default implementation of the
HandlerFactory for creating message handlers based on reflection.Default implementation of
HandlerRepository, backed by a DocumentStore.Default implementation of the
IndexOperation interface.Default reflection based Jakarta Validation implementation used by the SDK.
The default implementation of the
KeyValueStore interface that provides operations for storing, retrieving,
and deleting key-value pairs using a KeyValueClient and a Serializer.Default implementation of
MemberInvoker using high-performance method handle-based invocation.A default implementation of the
MemoizingBiFunction interface that memoizes (caches) results of a
BiFunction based on a pair of input arguments.A default implementation of the
MemoizingFunction interface that provides caching functionality for computed
function results.A default implementation of the
MemoizingSupplier interface that memoizes (caches)
the result of a computation performed by a supplied Supplier.Default implementation of the
MessageScheduler interface.Default implementation of the
MetricsGateway interface.Default repository for independently stored models.
The one repository-owned carrier from prepared request through authoritative accepted result.
Receives a cache value and the boundaries that prove it current.
A layered
PropertySource implementation used as the default source for resolving application properties in a
Fluxzero application.Default implementation of the
QueryGateway interface.A default implementation of the
RepositoryProvider interface that uses a ConcurrentHashMap for each
repository.Default implementation of the
RequestHandler interface.A default implementation of the
ResponseMapper interface that simply wraps the response in a MessageDefault implementation of the
ResultGateway interface for sending response messages.Handles an asynchronous result-preparation failure and may retry the supplied publication.
Default implementation of the
SnapshotStore interface.Default implementation of a
SocketSession for managing Fluxzero WebSocket sessions.A tracker keeps reading messages until it is stopped (generally only when the application is shut down).
Default implementation of the
Tracking interface that coordinates message tracking for a specific
MessageType.A prepared handler and its effective tracking target after expansion, preserving instance-specific assignment.
Streaming strategy that allows multiple clients to concurrently consume a message stream.
Canonical SDK entry point for Fluxzero's Validation implementation.
Default implementation of
WebRequestContext for Fluxzero web request messages.Default implementation of the
WebRequestGateway interface that delegates requests to a configured
GenericGateway, or executes them through a lifecycle-managed native HTTP client when explicitly requested.Default implementation of
WebResponseMapper that converts handler return values into WebResponse objects.A base implementation of
Entity that forwards all method calls to a delegated Entity instance.An extendable
UserProvider that delegates to another UserProvider.Command to delete an entire search collection, removing all documents within it.
A bulk update operation that deletes a document from a given collection using its ID.
Command to delete a single document from the search store by its collection and ID.
Command to delete documents from the search store based on a search query.
Command to permanently delete all events associated with a specific aggregate ID.
Executes or resumes one explicit independent-model hard deletion.
Command to delete a value from the legacy key-value store by key.
Thrown to indicate that a problem occurred during the deserialization of data.
Wrapper for a
Message that supports lazy deserialization, context caching, type adaptation, and batch-level
execution utilities.A wrapper around a
SerializedObject that supports lazy deserialization of its payload.A simple implementation of
AbstractExecutorService that executes tasks directly in the calling thread without
using any worker threads.Framework event that durably replays direct
Graph.update(java.util.function.UnaryOperator) and
Graph.delete() changes.One exact model stream and its resulting serialized value.
Interceptor that disables the dispatch of outbound
MessageType.METRICS messages.A runtime-generated event that indicates a client has disconnected from the Fluxzero Runtime.
Command used to explicitly disconnect a tracker from the Fluxzero Runtime and release any claimed message segments.
Collector for disk space metrics.
Disk space metrics for monitored paths.
Metrics for an individual disk or filesystem path.
Mechanism that enables modification, monitoring, or conditional suppression of messages before they are dispatched to
local handlers or published to the Fluxzero Runtime.
Represents a structured, searchable, and indexable document within a Fluxzero collection.
Represents a typed field value within a document (e.g. text, number, boolean).
Enumerates the supported types of values that can appear in a
Document entry.Represents a navigable field access path for a
Document entry.A
HandlerDecorator that intercepts handler methods annotated with HandleDocument and synchronizes
their return values with a DocumentStore.Resolves the source, scope and document topic of a
HandleDocument handler.Internal, registration-scoped document reader.
Interface for converting domain objects to and from
SerializedDocument instances for indexing and searching.The maintained representation observed by a
HandleDocument handler.Represents aggregate statistics for a group of documents, including values for specified fields.
Statistical summary for a single document field.
Interface for storing, updating, and querying documents in the Fluxzero Runtime.
This class represents an exception that is thrown by the
DocumentStore when a document store operation
fails.Represents a single low-level document update operation to be applied to a search collection.
Declares a method that transforms an object from a newer revision to an older one.
Annotation indicating a collection of
Downcast methods grouped together for bulk registration.Indicates that a message handler method or constructor is the final usage point for protected data.
Defines a contract for encrypting and decrypting sensitive values within the system.
Represents an entity that encapsulates domain behavior and state.
Strategy interface for handling domain entity operations such as applying updates, validating state transitions, and
intercepting updates.
Marks a property (field or getter) as the unique identifier of an entity or independently stored model.
Cached structural metadata for an entity, persisted root, or type containing model handlers.
A centrally cached structural graph-projection root consumed by repository commits.
Model-aware handler descriptor.
A model value,
Entity<Model>, Graph<Model> or ordered graph collection parameter needed by a
handler.One outgoing parent relationship declared by a child model.
One resolved outgoing relationship, shared by Graph, batch, replay and commit consumers.
Cached property metadata with a compiled reader.
Aggregate-neutral persistence settings of an explicitly annotated root.
Shared immutable snapshot trigger and retention settings for Aggregate and Model roots.
Storage-neutral effects of one resolved transition.
Shared resolved policy for one Aggregate or Model transition.
Resolves handler method parameters that reference an
Entity or the entity's value.Marker for handler-selection contexts where an
Entity parameter should only be matched from message
metadata.Represents a key-value pair with a string-based identifier.
A
PropertySource that resolves property values from system environment variables.Gateway interface for reporting errors during message handling.
Functional interface for handling errors during tasks.
Handles failures during tracked message processing, optionally retrying the failed operation.
HandlerInterceptor that reports exceptions to the configured ErrorGateway.A generic error response returned when a request could not be completed successfully.
A Model has changed after the requested boundary and lacks the history required to recover its earlier head.
Represents a batch of serialized events for a specific aggregate.
A compact metric representation of an
EventBatch, used in AppendEvents.Metric.Gateway for publishing event messages to Fluxzero.
Controls whether an applied update should result in event publication.
Strategy for controlling how applied updates (typically from
@Apply methods)
are handled in terms of event storage, event publication, and model or aggregate state updates.Thrown when an event sourcing operation fails.
High-level abstraction for accessing and storing domain events in an event-sourced system.
Low-level client interface for interacting with the event store in Fluxzero.
A
Constraint that checks whether one or more paths exist in a document.Marker annotation on fields and methods that indicates that a property is to be used as facet when indexing a
document for search.
A constraint that matches documents containing a specific
FacetEntry.Represents a single facet field-value pair within a document.
Represents the count of documents matching a specific facet value.
Collector for file descriptor metrics (Unix/Linux only).
File descriptor metrics (Unix/Linux only).
Utility class for reading and writing files and classpath resources.
Declares that a method should be invoked to filter the visibility of an object for a specific
User.Interface for controlling flow regulation in a consumer.
High-level entry point for all interactions with the Fluxzero Runtime.
A
PropertySource that loads extra configuration from locations declared through
"FLUXZERO_CONFIG_LOCATIONS".Builder interface for constructing a
Fluxzero instance.Central configuration interface for a Fluxzero client instance.
Callback interface that can be implemented by Spring beans to customize the
FluxzeroBuilder
before it is used to build the main Fluxzero instance.Stable identifiers for Fluxzero SDK errors.
Human-readable Fluxzero error report with a stable error code.
Builder for
FluxzeroErrorReport.Factory methods for human-readable SDK errors.
A
BatchInterceptor that ensures the correct Fluxzero instance is bound to the current thread for
the duration of a MessageBatch.Shared low-overhead JFR events for Fluxzero batch operations across SDK and Runtime components.
One completed batch operation in the SDK or Runtime pipeline.
A Logback-compatible appender that automatically publishes warning and error-level log events to the Fluxzero
Runtime.
A
PropertySource that loads Fluxzero-specific settings from classpath resources.Wrapper bean representing a handler type discovered through Spring integration.
Spring configuration class for automatically wiring and initializing common Fluxzero components in a Spring
application context.
Programmatic configuration for the Fluxzero Jakarta Validation provider.
Jakarta Validation provider that exposes the SDK validator through the standard bootstrap API.
Indicates that a handler method, class, package, or payload should not be invoked or processed if the current user
has any of the specified roles.
Indicates that a handler method, class, package, or payload should not be invoked or processed if a user is
currently authenticated.
A
RetryingErrorHandler with no retry-count limit for eligible failures.Injects an individual form field or multipart part into a handler method parameter.
A specialized, opt-in web request consumer that forwards incoming
MessageType.WEBREQUEST messages to a locally running HTTP server.Base class for user-facing exceptions that are intended to be serialized and transferred across system boundaries
(e.g., back to a calling client or frontend application).
Low-level interface for sending
SerializedMessages to a gateway (e.g. commands, events, queries).A generic message gateway for publication of messages in Fluxzero.
Utility class for resolving generic type information in class hierarchies.
Request to retrieve all aggregate identifiers associated with a given entity ID.
Response to a
GetAggregateIds request, returning a mapping of aggregate IDs to types.Request to fetch a single document from the search store by ID and collection.
Result returned in response to a
GetDocument request.Lightweight structure for representing
GetDocumentResult in Fluxzero metrics logs.Request to fetch multiple documents from the search store by collection and their IDs.
Result returned in response to a
GetDocuments request.Lightweight structure for representing
GetDocumentsResult in Fluxzero metrics logs.Request to compute statistics on documents that match a given
SearchQuery.Response to a
GetDocumentStats request.Compact summary of the result, used for internal monitoring purposes.
A request to fetch stored events for a specific aggregate in an event-sourced system.
Response to a
GetEvents request, returning a batch of events for an aggregate.Lightweight metric representation of a
GetEventsResult used for monitoring.Request to retrieve aggregated counts for all
facet fields across documents matching the given
SearchQuery.Result returned for a
GetFacetStats request.Lightweight summary of the facet statistics result, used for internal metric tracking.
Resolves the durable targets and exact state boundary of one independent-model commit substep.
Target-free metric representation.
Durable target identities and types for one model-commit substep.
Identity-free metric representation.
Batch-loads independent model stream memberships at one namespace-wide state boundary.
Selects Model streams explicitly by primary identity or alias, without fallback between those namespaces.
Explicit identity namespaces; neither mode falls back to the other.
Model heads and stream memberships observed at one pinned
GetModelEventsResult.stateIndex.Resolves one bounded independent-model relationship graph and optionally includes the first page of every selected
model stream.
Requests freshness and backlog state for one materialized graph collection.
Temporal graph edges and one model-event page observed at the same pinned state boundary.
Retrieves the production and staged direct documents needed to verify one Model migration.
Production and staged state for an application-verified direct Model migration.
Content-free metrics representation.
Retrieves a bounded batch of staged direct Model migrations for application-level adoption.
A bounded batch of durable heads from the otherwise invisible Model-migration staging area.
Content-free metrics representation.
Requests the existing namespaces in the connected Runtime's storage environment.
A sorted, duplicate-free snapshot of existing namespaces, including inactive namespaces.
Result metric that omits namespace names.
Response to a
GetPosition request, containing the current tracked position for a specific consumer and
MessageType.Request to retrieve all aggregate relationships for a given entity ID.
Response to a
GetRelationships request, containing all known relationships for a given entity ID.Request to retrieve a scheduled message by its
GetSchedule.scheduleId.Binds canonical Model parent IDs to their committed lifetimes in this namespace.
Payload-free request summary.
Immutable namespace-local lifetime bindings for a subsequent ScheduleWithParents operation.
Response to a
GetSchedule request, containing the matching SerializedSchedule, if found.Metric payload used for internal monitoring and logging.
Request to retrieve existing regular search collections and audit trails.
Response to a
GetSearchCollections request.Compact result summary used for metrics.
Request to compute a time-based histogram over documents that match a given query.
Result of a
GetSearchHistogram request.Request to retrieve a value from the legacy key-value store.
Response to a
GetValue request, returning the value associated with the given key.A typed view of one independently stored model and its lazily available relationship context.
Optional caller-imposed graph reconstruction limits.
Decorates event and notification handlers that observe complete graph changes.
Serializes a public
Graph as its model value enriched with recursively composed child paths.Defines how a typed graph lookup resolves multiple matches for one functional identifier or alias.
The durable representation migrated by a returned
Graph in a HandleDocument handler.Replaces one canonical
Parent.pathInParent() only inside a materialized graph projection.Optional materialization of a searchable Model's complete composed Graph.
Controls whether command results and explicit Graph reindex completion wait for affected materialized Graphs.
Materialization and completion policy for the optional composed Graph document.
Adds a property derived from relationship context when a
Graph is serialized.Construction boundary for the single indexed
Graph implementation.One reachable parent identity in deterministic traversal order.
Description of one placement in a materialized graph manifest.
Internal schema-only migration of the current canonical nodes selected by an injected Graph.
Represents a group key for aggregating documents in
DocumentStats.Represents a grouped search query in the Fluxzero search framework.
Represents a delivery or completion guarantee for messages or state changes in Fluxzero.
Marks a method or constructor as a handler for command messages (
MessageType.COMMAND).Marks a method or constructor as a handler for messages from a custom message topic.
A
MessageFilter implementation that filters DeserializingMessage instances
based on a custom topic defined in the HandleCustom annotation on handler methods.Handles incoming HTTP
DELETE requests for the specified path(s).Marks a method or constructor as a handler for document messages within a search collection.
A
MessageFilter that routes DeserializingMessage instances to methods annotated with
HandleDocument, based on the message's topic.Marks a method or constructor as a handler for error messages (
MessageType.ERROR).Marks a method or constructor as an event handler for incoming messages of type
MessageType.EVENT.Handles incoming HTTP
GET requests for the specified path(s).Handles incoming HTTP
HEAD requests for the specified path(s).Meta-annotation used to declare that an annotation marks a method as a message handler for a specific
MessageType.Marks a method or constructor as a handler for internal metrics events (
MessageType.METRICS).Marks a method or constructor as a handler for notification messages (
MessageType.NOTIFICATION).Handles incoming HTTP
OPTIONS requests for the specified path(s).Handles incoming HTTP
PATCH requests for the specified path(s).Handles incoming HTTP
POST requests for the specified path(s).Handles incoming HTTP
PUT requests for the specified path(s).Marks a method or constructor as a handler for query messages (
MessageType.QUERY).Represents a container for a message handler and the mechanism to resolve a
HandlerInvoker for a given
message.Abstract base class for
Handler implementations that delegate to another handler.Shared utility for discovering and evaluating
Association definitions on handler types and handler methods.Configuration object used to define how message handler methods are selected and filtered for a given message type.
Functional interface for decorating
Handler instances that process DeserializingMessage objects.A composite decorator that merges two decorators into one.
Describes the handler method that is involved in a handling operation.
Marks a method or constructor as a handler for result messages (
MessageType.RESULT).Factory interface for creating
Handler instances that process DeserializingMessages.Represents a predicate used to determine whether a given method should be considered a valid message handler.
Provides the input for a prepared handler invocation.
Optional extension of
ParameterResolver for resolving handler parameters from a HandlerInput.Describes what a resolver decided for one handler parameter.
Utility for inspecting and constructing handler components from annotated methods.
A matcher that encapsulates metadata and resolution logic for a single handler method or constructor.
A composite
HandlerMatcher that delegates to a list of individual matchers.Intercepts individual message handling operations, enabling cross-cutting behavior around handler invocation.
Implementation of
Handler that delegates to another handler and applies a HandlerInterceptor.Remaining portion of a prepared handler interceptor chain.
Represents the remaining interceptors and handler invocation in a prepared local handling chain.
Intercepts one prepared local invocation using a lazy
HandlerInput.A handler-method-specific interceptor plan.
Merged wrapper for interceptors that explicitly support method preparation.
Represents an invocable handler method.
A
HandlerInvoker that delegates all behavior to another instance.A simple invoker backed by a
Callable, typically used for test utilities or framework-internal logic.Defines the logic to determine whether a given target object can handle a message, and how to invoke it.
A reusable, target-bound handler method.
A
HandlerMethod that delegates all behavior to another instance.Describes whether a handler method applies to a group of equivalent inputs and, when it does, how to invoke it.
A reusable plan for invoking one already selected handler method.
Selects and prepares a handler method so that the result can be reused for equivalent inputs.
The outcome of trying to prepare a handler method for repeated invocation.
Possible outcomes of preparing a handler method.
Interface for registering and invoking local message handlers.
Combines two
HandlerRegistry instances into one.A no-op handler registry that performs no registration or dispatch.
Repository interface for storing and retrieving
@Stateful handler instances.Marks a method or constructor as a handler for scheduled messages (
MessageType.SCHEDULE).Handles a WebSocket connection close event.
Handles a WebSocket handshake request, invoked when a client first attempts to connect using a specialised
GET request.Handles an incoming WebSocket message.
Handles the opening of a WebSocket connection (after handshake).
Handles a
PONG WebSocket frame, typically sent in response to a PING.Handles incoming HTTP
TRACE requests for the specified path(s).Marks a method or meta-annotation as a handler for incoming web requests (
MessageType.WEBREQUEST).Marks a method as a handler for
MessageType.WEBRESPONSE messages.A request to check whether a document exists in a given collection.
Represents an object, typically a message used for invocation, that has an associated
Entity.Interface for exposing a string-based representation of an object's identifier.
Base interface for gateways that support registering local message handlers.
Interface for objects that expose a backing
Message instance.Interface for components that expose a
MessageStore.Marker interface for objects that carry associated
Metadata.Marker interface for wrapper objects that retain a reference to their originating source.
Injects an HTTP request header into a handler method parameter.
A combined snapshot of host metrics collected at a specific point in time.
Orchestrates periodic collection and publication of host metrics.
Configuration for host metrics collection.
HTTP origin identity without credentials, path, query or fragment.
Defines constants for standard and extended HTTP request methods used by Fluxzero's web handling system.
Enumerates supported HTTP protocol versions for web requests and responses handled through the Fluxzero Runtime.
Object that represents the identifier of a specific entity.
Reads scalar concrete IDs and discriminated polymorphic IDs.
Writes concrete ID properties as scalars and polymorphic properties with a recoverable type discriminator.
Strategy interface for generating unique identifiers used throughout the Fluxzero Runtime.
Owns the shared default inherited by
IdentityProvider.Automatically discovered Jackson support for otherwise ambiguous ID properties.
Metric event published when a tracked message matched a handler but was deliberately skipped before invocation.
Thrown to indicate that a command was rejected due to business logic violations.
Immutable representation of an
AggregateRoot, extending ImmutableEntity with additional metadata for
event sourcing.Keeps the pre-unification builder method descriptors for compiled Aggregate consumers.
Immutable implementation of the
Entity interface, representing a snapshot of a domain entity.Source-visible superclass for Lombok's generated persisted-root builders.
Immutable entity wrapper for one independently stored model revision.
Shared immutable revision state of persisted Aggregate and Model roots.
Source-visible builder owner shared by Aggregate and Model roots.
A bulk update operation that indexes (inserts or replaces) a document in the store.
A bulk update operation that indexes a document only if it does not already exist in the store.
Command used to index a collection of
SerializedDocument instances in the search store.Builder-style interface for indexing documents into the
DocumentStore.Use 48 bits of the current time in milliseconds since epoch as the base of the index.
An implementation of the
EventStoreClient interface that provides an in-memory event storage solution.Applies direct model documents and due snapshots, returning their local-handler publication for execution after
the materialized state and graph-projection fences have advanced.
Writes current materialized graph documents, returning their local-handler publication for execution after the
graph-projection fence has advanced.
An in-memory implementation of the
KeyValueClient interface.An in-memory implementation of the
MessageStore interface for storing SerializedMessages without
external persistence.An in-memory implementation of a scheduling store that allows the scheduling, retrieval, and management of scheduled
messages.
In-memory implementation of the
SearchClient, intended for local testing and development.Resolves the exact current-document collection for model IDs.
Resolves explicitly placed current child edges for root models.
Resolves target model IDs from related matches at the current relationship boundary.
An in-memory implementation of the
TaskScheduler interface, enabling scheduling and execution of tasks in a
virtualized time environment.Resolves handler method parameters by simply injecting the input if the parameter type is assignable from the input
type.
Indicates that a method should intercept and potentially transform an update before it is applied to an entity.
Interface responsible for converting a domain object into a
SerializedDocument for indexing, and vice
versa—deserializing a byte[] representation into the original object type.Tracks the lifecycle and identity of a single message handler invocation.
Tracking's invocation-local ownership of a deferred result.
A
ContentFilter implementation that uses Jackson to filter content dynamically for a specific User.Custom Jackson serializer that attempts to invoke a
FilterContent handler method during serialization.Implementation of
Inverter that uses Jackson to invert an Object into a SerializedDocument and back
into a JsonNode.Optional read-only input capability for entries decoded from the exact backing document bytes.
A concrete
Serializer implementation based on Jackson.Base class for
PropertySource implementations backed by a Properties object.Low-level Fluxzero websocket connector backed by the JDK
HttpClient websocket implementation.Jetty listener that adapts a physical websocket connection to the proxy websocket endpoint contract.
Jetty listener that adapts a physical WebSocket connection to the test server endpoint contract.
Embedded Jetty router for the test server's WebSocket endpoints and health check.
A
ParameterResolver that converts the message payload to the parameter's declared type
if that type is assignable to JsonNode.Marker interface for all low-level request and response types in the Fluxzero protocol.
Utility class for JSON serialization, deserialization, and file-based JSON resource loading.
Collector for JVM class loading metrics using JMX.
JVM class loading metrics.
Collector for JVM garbage collection metrics using JMX.
JVM garbage collection metrics for all available GC collectors.
Metrics for an individual garbage collector.
Collector for JVM memory metrics using JMX.
JVM memory metrics including heap, non-heap, and individual memory pool statistics.
Metrics for an individual JVM memory pool.
Collector for JVM thread metrics using JMX.
JVM thread metrics including counts and state distribution.
JwtVerifier provides functionality to verify the cryptographic signature of a JSON Web Token (JWT) and validate its
claims.
Represents the claims contained in a decoded JWT (JSON Web Token).
Optional extension for dynamic parameter resolvers whose applicability can be safely reused for messages with the
same low-cardinality key.
Cached outcome of evaluating one resolver for one handler parameter.
Represents a service to store and retrieve a piece of serialized data by key.
Represents a single key-value entry in the legacy key-value store.
A simple interface for storing, retrieving, and removing key-value pairs.
Thrown when a key-value store operation fails.
Provides utilities for bridging Java reflection with Kotlin reflection.
A lazily-loaded implementation of
AggregateRoot that defers deserialization and event application until the
entity value is explicitly accessed.A lazily initialized identifier that serializes as a plain string.
Marker interface for value objects that should be treated as leaves during reflective traversal.
Validates that a character sequence length is between
Length.min() and Length.max(), inclusive.Container annotation for repeatable
Length constraints.An in-memory
Client implementation used for local development, testing, or isolated environments where no
connection to the Fluxzero Runtime is required.Describes the message characteristics that remain constant for a prepared local-dispatch policy.
Separates simulated tracking from actual local eligibility without creating a second handler or target instance.
A handler registry implementation intended for local testing and development that registers handlers for document
updates in a specific collection.
A client implementation for managing and storing events in an in-memory event store.
Holds the state of one payload-first local handler invocation.
Marks a message handler method, class, or package as a **local handler**—one that is invoked immediately in the
publishing thread rather than asynchronously through tracking.
Gives Fluxzero handling extensions access to a local invocation whose full message is created only when needed.
In-memory implementation of
HandlerRegistry that manages and dispatches local message handlers — i.e.,
handlers that are invoked directly in the publishing thread without involving the Fluxzero Runtime.Result of trying to handle a message locally.
Restricts messages with the annotated payload type to local handlers.
Thrown when no local handler accepts a local-only request.
A client implementation for managing scheduling operations using an in-memory schedule store.
Configuration for the local HTTP server used to handle
WebRequest messages outside of Fluxzero's own
web handling framework.In-memory implementation of the
TrackingClient and GatewayClient interfaces, designed for
local-only or test-time usage.The default
ErrorHandler implementation used by Fluxzero consumers.A constraint that supports search-as-you-type functionality by matching terms or phrases that start with a given
input string.
A
BatchInterceptor specialization that transforms a MessageBatch before it is passed to the
consumer for processing.A constraint that matches indexed document values based on text equality or normalized phrase matching.
Builds one canonical, projection-only replacement for an upcast materialized model graph.
One compare-and-replace operation against the manifest of the handled graph document.
Injects a typed materialized model graph into
HandleDocument methods.Indicates that the annotated field or getter represents a nested entity or collection of entities within an
aggregate, independently stored model, or stateful handler.
Abstraction for invoking a
Member (e.g.Instance-bound memoization store used by
Fluxzero for lightweight caching of values.A
BiFunction that memoizes (caches) its results based on a pair of input arguments.A
Function that memoizes (caches) its results by key.A
Supplier that memoizes (caches) the result of a single computation.A hard-reference, weighted cache with LRU eviction and optional key ordering.
Unit represented by a cache weight.
Describes an entry removed from an
MemoryAwareCacheSupport.Determines whether caches should proactively shed entries.
Represents a unit of communication within the Fluxzero Runtime, wrapping a payload and its metadata.
Represents a batch of messages retrieved from the message store for a specific segment range.
Compact summary of a
MessageBatch, used for logging and performance tracking.Message-scoped log description used by infrastructure that can describe a message more clearly than its payload type.
Defines a predicate that determines whether a given message is applicable to a handler method.
A functional interface for formatting
DeserializingMessage instances into human-readable strings.Coordinates maintenance operations that span the message log, tracking positions and active trackers.
Internal, bounds-checked MessagePack I/O for Fluxzero's existing storage and transport schemas.
A reusable, zero-copy reader of one heap-array range.
A reusable heap-array writer.
Resolves handler method parameters of type
DeserializingMessage.A
DispatchInterceptor that assigns a routing segment to messages prior to dispatch.Interface for scheduling deferred or periodic execution of messages in the Fluxzero Runtime.
A low-level store for serialized messages.
Result of scanning a message store for a tracking batch.
Enumerates the types of messages recognized and routed by the Fluxzero Runtime.
Represents immutable metadata associated with a Message in the Fluxzero Runtime.
Builder for compact metadata whose keys and values are already strings.
Resolves handler method parameters of type
Metadata.Validates method invocation arguments right before a handler method is invoked.
Interface for collecting a specific type of metric.
Gateway interface for publishing metrics messages in Fluxzero.
Indicates that a handler configured with
MissingProtectedDataPolicy.FAIL received a message for which one or
more protected values are no longer available.Determines how a handler responds when a message references protected data that is no longer available.
Marks an independently identified and stored domain model.
An alias mapping observed while selecting a mutation target.
Optional repository capability for resolving a typed ancestor from relationship identities before loading model
values.
The pinned relationship collections and Model types examined without materializing intermediate values.
One message-batch-local model scope for read-your-writes, exact dependencies and commit release.
Frozen batch overlay.
One model identity changed by a durable model-commit substep.
Owns storage-neutral Model commit description, head assignment and accepted-result construction.
Signals that one alias would identify two different models.
Final alias replacements and their requested owners in commit order.
Batch-loads current children for deleted parent IDs.
One fully assigned commit.
Storage-neutral work known before assignment.
Store head values needed to assign the next transition.
Receives assigned heads so a store can build only its own persistence representation.
Constructs a compact store-specific head from the values assigned by this owner.
The desired parent set for one child after a relationship-changing target.
Relationship changes and final parent deletions applied at one state index.
Mutable ordering state for one atomic assignment batch.
Allows already-prepared, independent model commits to enter the websocket queue as one batch.
Request-owned context for completing model commits in the transport result batch that contains them.
Completes aligned model results and their request-owned contexts as one unit.
Current runtime positions for one model identity involved in a rejected model commit.
A Model mutation cannot commit because its state conflicted with another mutation.
Identifies a document that could no longer be reconstructed at the mutation's pinned read boundary.
Owns generic model-commit conflict detection and conflict-policy outcomes.
Registration and dispatch facade for independent-model handlers.
Controls when an automatic independent-model commit starts and when its completion is awaited.
One ordered original event and all model targets affected by it.
Persistence and lifecycle effects of one original event on one independently stored model.
Resulting stream/head metadata for one committed target model.
Structural validation for the independent-model wire protocol.
Compact websocket representation for the common one-event, one-target model commit.
Runtime behavior when a commit-scoped model changed after the commit's
readStateIndex.Decides what the SDK should do after the runtime has rejected and rolled back a model commit.
Immutable conflict context supplied after runtime rollback.
Resolver outcome.
SDK-computed ordinary scheduler effects included in a Model commit.
Required scope of an explicit independent-model hard deletion.
Bounded dry-run result for one explicit independent-model hard deletion.
Completed result of an idempotent independent-model hard deletion.
Explicit dev/CI inspection of a bounded first page of Model streams or a Graph.
Bounds one inspection; no automatic pagination or further Graph expansion occurs.
One sampled stream.
One observed representation, before structural upcasting.
A bounded observation, not an application compatibility verdict.
Optional current-source or independent public-projection consequence of one Model target transition.
Binds serialized Model state to its durable document fence without certifying ordinary search writes.
Customer-facing errors for SDK-provided Model checks.
Byte-range view containing one persisted model-event block.
Lightweight membership of one shared event payload in one model stream.
Reserved metadata keys identifying events emitted by an independent-model commit.
Expands the persisted blocks in a canonical model-event page into its logical payloads and stream memberships.
One original serialized event payload shared by every returned target membership at this state index.
One persisted global-event block transported without runtime-side decompression or re-encoding.
Head and ordered event memberships for one requested model.
One bounded model-stream read inside
GetModelEvents.Compact websocket representation for model-stream reads.
Optional bounds for composing current independent-model documents into the documents returned by a search.
Hidden structural description carried by a composed independent-model graph document.
One concrete placement in pre-order.
Applies graph-view constraints, sorting, field selection and pagination after live graph composition.
Deterministically composes direct current model documents using explicit relationship paths.
One temporal child-to-parent edge selected for a model graph.
Small durable root notification.
Projection-local replacement for a canonical relationship path.
Durable definition of a logical Graph update stream, optionally storing its complete composition.
One independently evolvable direct-document schema participating in a materialized Graph.
Current progress of one asynchronous materialized graph projection.
Optional repository capability for metadata-only Graph navigation.
Optional head evidence carried by a lazy entity supplier, without allocating a separate metadata wrapper per
node.
One resolved identity and lazy value at a shared boundary; absent identities must not be resolved again.
One head with optional local class knowledge and a lazy, exact-boundary authoritative value.
Coherent metadata for the requested direct relationship collections, including empty ones.
A source value together with the exact relationship boundary established while reading it.
Discovers independent models and self-applying model command types within Spring component-scan boundaries.
Coordination head observed for one model at the response boundary.
Identity policy for repository Graph resolution; normalization and alias lookup are independent choices.
Central resolver for stable logical Model names.
Defines one durable representation of a
Model.One current, state, commit or event boundary shared by every Model read.
Actionable Model read failure.
Safe structural context; null means unavailable, not absent data.
The observed cause category.
The operation being attempted when the failure was observed.
Sole executor for the immutable handler and target knowledge in
MutationPlan.Current-state relationship constraint for independent model documents.
Relationship direction as observed from returned target documents.
Desired outgoing relationship from a changed child model to one parent.
Validates ordered relationship changes against a current parent graph without loading unrelated descendants.
Complete desired parent-ID set for one changed child.
Batch-loads current parents for child IDs.
One historically visible relationship boundary.
Signals that the proposed relationship boundary could not be proven acyclic.
Shared graph, ancestor, lineage and relationship-query policies for every Model store.
Mutable commit-scoped view of relationships that own the child lifecycle.
Storage-independent view of one temporal child-to-parent relationship interval.
State selected for a read and whether it came from the requested selector rather than an allowed fallback.
A relationship selection observed at the commit's read boundary, including a selection that returned no edges.
Direction relative to the observed Model.
Shared breadth-first traversal mechanics for temporal model relationships.
Traversal bounds and the failure messages associated with exceeding them.
Supplies the relationships for one breadth-first frontier without requiring materialization.
Ordered traversal result, including edges only when an edge mapper was supplied.
Repository for loading independently stored
models.Root wrapper for an independently persisted
Model revision.Preserves a Model's exact text-search summary across stores that expose only a tokenized search index.
Optional serialized snapshot consequence of one model target transition.
Internal schema-only return guard for handlers explicitly selecting a maintained Model source.
A document-backed current Model value verified against a durable head at
ModelState.stateIndex().Encodes opaque model state indices as fixed-width text that retains signed-long ordering.
Decoder for the v7 packed Model membership transport format.
One independently addressable stored model membership.
Indexes
@Model declarations independently of serialization aliases or handler registration.SDK-local provider for independent Model indexing.
Resolves application-scoped logical Model names in both directions.
Compile-time Model discovery, independent of optional serialized type-name aliases.
Resulting target heads of one committed model-commit substep.
Durable change represented by a
ModelUpdate.Compact websocket representation for model commits and model-event reads.
A mutable, stateful
AggregateRoot implementation that allows in-place updates and applies events
with commit support for persisting the state and synchronizing it with the Fluxzero Runtime.A mutable view on a nested entity within a
ModifiableAggregateRoot.Represents a resource or component that can be monitored.
Command to move a single document to another collection.
Command to move matching documents to a collection.
The MurmurHash3 algorithm was created by Austin Appleby and placed in the public domain.
A specialized
Handler that maintains and mutates an internal delegate instance.Registered and compiled knowledge for one reachable model mutation payload.
Required state access for one resolved model.
Dependency and its planned access, resolved through temporal parent relations.
Compiles immutable definition data with application-specific parameter resolvers.
Runtime-selected write target among already loaded candidates.
Resolved direct targets, deferred writes and ancestor dependencies.
One direct model load required by the selected handlers.
Precompiled target-ID readers for one payload type.
A
Cache implementation that wraps a delegate cache and applies a transformation to each key (ID) before
delegating operations to the underlying cache.Read-only namespace discovery within one Test Server instance.
The NamespaceSelector class is responsible for determining and decoding a namespace value from an HTTP web request.
Operational outcome of one native outbound
WebRequest.Safe transport-failure classification used instead of exception details.
A
Constraint implementation that matches all documents and imposes no filtering conditions.A no-op implementation of the
Encryption interface that performs no actual encryption or decryption.A read-only, inert
Entity wrapper used exclusively during the loading phase of aggregate state.A no-op implementation of the
FlowRegulator interface that never requests a pause.A no-operation
PropertySource implementation that never returns any property values.A
SnapshotStore implementation that is used when snapshotting is explicitly disabled, such as when
snapshotPeriod <= 0 is configured on an aggregate via Aggregate.A
SnapshotTrigger implementation that never triggers snapshot creation.A constraint that negates the result of another constraint.
This annotation allows a message handler or payload to be invoked even if the current user is not authenticated.
A custom Jackson module that configures deserialization behavior to treat null collections as empty collections.
Utility class for common object handling, memoization, concurrency, stream processing, and error handling.
Automatic endpoint that serves the generated OpenAPI document for an
ApiDocInfo scope.Global options for rendering an
ApiDocCatalog as an OpenAPI document.Generates an OpenAPI document from Fluxzero web handler annotations during Java compilation.
Renders a generic
ApiDocCatalog as an OpenAPI JSON document.Declares the relative order in which Fluxzero applies interceptors and decorators.
Registry for accessing method parameter names at runtime in environments where Java reflection does not retain them
(e.g.
Mechanism to resolve method parameters in message handler methods (e.g. those annotated with
HandleEvent,
HandleCommand, etc.).Wrapper around a resolved parameter value in a web request.
On a Model, registers a directed Graph relationship whose property contains one parent ID or a collection of parent IDs.
Declares a path prefix that contributes to the final URI of a web handler.
Abstract base class for constraints that apply to specific paths in a
Document.Injects a path variable from the URI into a handler method parameter.
A
MessageFilter used to restrict message handling based on the payload type.Resolves handler method parameters by injecting the message payload.
Declares a message (typically a
Schedule) or its handler method as part of a periodic schedule.A
SnapshotTrigger that triggers snapshot creation at fixed intervals based on the aggregate's sequence number.Shared revision contract for an independently persisted Aggregate or Model root.
Creates a bounded, non-mutating hard-deletion plan.
Represents the tracking state of a consumer, i.e. the last known indexes of consumed messages per segment.
Interface for storing and retrieving
Position objects representing the last processed message indexes
per segment for a given consumer.Applies a
DispatchInterceptor to local dispatch without requiring Fluxzero to create a complete message
before handler selection.Optional extension for
parameter resolvers that can prepare a resolver function for a
specific message in one step.Represents a source of configuration properties.
Marks a field or type within a message payload as containing sensitive information that should be protected.
Configuration for embedding the Fluxzero proxy without relying on process-global properties.
Metric emitted when the proxy disconnects a websocket session because outgoing frames are not draining.
Runs a published-event Aggregate-to-Model migration in an isolated Fluxzero application context.
Builder for one isolated published-event Model migration application.
A
Constraint that parses a human-friendly query string into a structured tree of constraints.Gateway interface for dispatching queries and receiving responses in Fluxzero.
Injects an HTTP query parameter into a handler method parameter.
Validates that a numeric value is between
Range.min() and Range.max(), inclusive.Container annotation for repeatable
Range constraints.Command to read a batch of messages from the Fluxzero Runtime for a given consumer and tracker.
Request to fetch a batch of messages from a given log starting from a given index.
Result for a
ReadFromIndex request.Metric representation of a
ReadFromIndexResult, used for internal monitoring and analytics.Result returned in response to a
Read request for a batch of messages.Compact representation of the
ReadResult used for monitoring.Thrown when a message publication chain exceeds the configured maximum depth.
Prevents runaway recursive publication loops by carrying a publication depth in message metadata.
Redirect policy for outbound
WebRequest execution through the direct native client or proxy.Utility class for high-performance reflection-based operations across the Fluxzero Runtime.
Lazily computed reflection metadata for a single Java type.
Mutable holder for a previously resolved user that may be refreshed while handling a message.
Optional extension for refreshing an already resolved
User.Idempotently registers an asynchronous materialized model-graph projection.
Annotation to register a class or package for inclusion in the
TypeRegistry.Represents a handle for a cancellable registration, such as a subscription, listener, or callback.
Refreshes one canonical source at an unchanged authoritative Model head.
Payload-free reindex measurements.
Describes a relationship between an entity and the aggregate that contains or owns it.
Command to repair or re-index the relationships for an existing aggregate.
Provides access to a singleton-style repository for a given class type.
Base class for requests sent to the Fluxzero Runtime.
Marker interface for request messages (e.g., commands or queries) that expect a response of a specific type.
Annotation processor that validates whether handler methods annotated with
HandleCommand, HandleQuery
or HandleCustom correctly match the response type declared by a Request payload.Represents a batch of requests to be sent to the Fluxzero Runtime in a single network round-trip.
Adapts typed graph handler results to an explicitly JSON-shaped
Request response contract.Handles the lifecycle of request/response interactions in a Fluxzero client.
Marker interface for responses to
Request objects (including commands and queries).Declares role-based access control for message handlers or payload types.
Indicates that a handler or message requires the presence of an authenticated user.
Command to forcibly reset the tracked position for a given consumer and message type.
A strategy interface for converting arbitrary response objects into
Message instances.Represents a batch of results returned from the Fluxzero Runtime in response to a
RequestBatch.Gateway interface for sending result messages in response to a command or query.
Request whose durable handler needs to distinguish an initial send from a transport retry.
Configuration for retry behavior when executing a task using
TimingUtils.retryOnFailure(Runnable, Duration).An
ErrorHandler implementation that retries failed operations a configurable number of times, with optional
propagation or suppression of unrecoverable errors.Determines when configured outbound HTTP retries are safe to execute.
Represents the current status of a retry operation.
Specifies the revision number of a persistable object, such as a message payload, document, or model snapshot.
Conditionally replaces one materialized model-graph document after application-level schema migration.
Persists a schema-only rewrite of an internal Model source without advancing the Model's head or history.
Annotation used to identify the routing key of a message, which in turn is used to compute the message segment using
consistent hashing.
Metric event emitted when a Fluxzero Runtime changes lifecycle phase.
Runtime lifecycle phases that are published as metrics.
Command to schedule a batch of messages for future delivery.
Represents a scheduled message to be delivered at a specific future time.
Lightweight metric representation of this
Schedule command, used for monitoring purposes.Best-effort metric emitted after an owned schedule was removed following parent deletion.
Wrapper for a serialized command message scheduled for deferred execution.
Internal handler responsible for executing scheduled commands when they are due.
Represents a unique identifier for a schedule, consisting of a type and an id.
Exception thrown by a
MessageScheduler when scheduling a message fails.Schedules messages owned by existing, committed Models in the same namespace.
Payload-free operation summary.
A lower-level client interface for scheduling and cancelling deferred messages (i.e., schedules) in Fluxzero.
Intercepts scheduled messages to handle periodic scheduling logic.
Resolves the Maven version of the Fluxzero Java SDK from build metadata packaged with the artifact.
Fluent interface for building and executing document search queries in Fluxzero.
Indicates that instances of the annotated type should be indexed for search within Fluxzero.
Low-level interface for interacting with a search and indexing service in Fluxzero.
Describes an existing search collection and its storage type.
Supported search collection types.
Request used to perform a search over documents indexed in the Fluxzero search store.
The result of a
SearchDocuments request.Lightweight metric representation used for logging search result metadata.
Marker annotation that indicates that a property is to be ignored when indexing a document for text search.
Sparse field exclusions for text search, encoded as ordinary internal document metadata.
Represents a histogram over a time range, typically returned by
GetSearchHistogramResult.Represents a single result returned by a
Search query.Marker annotation that indicates that a property is to be included when indexing a document for search.
Searches current independent model documents subject to bounded relationship constraints.
Searches independent model documents and composes their current child graph into every returned root document.
Represents configuration options extracted from the
@Searchable annotation on a domain type.A query for filtering documents in one or more search collections.
Builder class for constructing instances of
SearchQuery.Per-node search configuration, independent of activation through
Model.searchable().Utility class for search-related functionality such as term normalization, path transformation, glob pattern
matching, and primitive value extraction.
Explicit minimum or maximum selection for range filters and ordering.
A
MessageFilter that restricts handler invocation based on segment membership, using routing keys.Represents an index value for a contiguous range of segments.
Thrown to indicate that a problem occurred during the serialization of an object.
Represents a serialized form of a search document stored in a Fluxzero collection.
A serialized message value.
Decodes the shared binary or legacy MessagePack representations used by the Fluxzero event store.
Represents a scheduled message to be delivered at a specific
SerializedSchedule.timestamp.Metric representation of the
SerializedSchedule for tracking/monitoring.Mechanism to serialize and deserialize objects to and from
byte[] representations.Minimal server-side WebSocket session contract used by the in-memory Fluxzero test server.
Declares a static file handler that serves files from a resource or file system location at the specified web
path(s).
Exception thrown when a
Request fails and an ErrorResult is returned by
the Fluxzero Runtime.Utility class for constructing internal service endpoint paths used to route messages to the Fluxzero Runtime.
Utility class for constructing fully qualified service endpoint URLs for various Fluxzero Runtime features
based on the client's configuration.
A thread-safe pool of reusable
WebsocketSession objects, supporting concurrent access and routing.Command to set or update the retention period for a message log in the Fluxzero Runtime.
A functional, non-persistent
Entity wrapper that enables safe state mutation and validation without producing
side effects such as event publication or snapshot creation.An
ErrorHandler implementation that suppresses all processing errors and allows message tracking to
continue.A simple in-memory implementation of the
PropertySource interface backed by a Map.Interface for managing snapshots of aggregates in an event-sourced system.
Functional interface used to determine whether a new snapshot should be created for an aggregate.
Declares a WebSocket endpoint that represents a single active client session.
Controls periodic keep-alive pings to detect inactive sessions.
A specialized
Handler that manages lifecycle events and message dispatching for WebSocket endpoints annotated
with SocketEndpoint.A stateful wrapper around a WebSocket endpoint instance, managing per-session behavior and message handling.
Spring
BeanDefinitionRegistryPostProcessor that detects
SocketEndpoint types within the application's component-scan scope and registers them as
FluxzeroPrototype definitions for use in Fluxzero.A wrapper representing a serialized request sent over a WebSocket session.
Represents a response to a
SocketRequest sent over a WebSocket session.Represents a WebSocket session that allows sending messages, requests, pings, and handling session lifecycle actions.
Cache implementation using key-level synchronized access and soft references for value storage.Marker annotation on fields and getters that indicates that a property is to be used for sorting and filtering.
Represents a sortable entry in a
Document for use in search
operations.Resolves handler method parameters annotated with
Autowired from the Spring application context.A registry interface for registering Spring-based handler components with e.g.: a
TestFixture.A
PropertySource implementation that delegates property lookups to a Spring Environment.A
BatchInterceptor that stalls batch processing until a minimum desired batch size is reached or a timeout occurs.Declares that a class is a stateful message handler — i.e., one whose state is persisted and which can receive
messages via
Association.A
Handler implementation for classes annotated with Stateful, responsible for resolving and invoking
stateful handler instances based on Association metadata.Spring
BeanDefinitionRegistryPostProcessor that detects
Stateful handler types within the application's component-scan scope and registers them as
FluxzeroPrototype definitions for use in Fluxzero.Serves static resources with streamed bodies and content-based validators for the selected representation.
Command sent to the Fluxzero Runtime to update the tracked position for a specific consumer and segment range.
Stores a key-value pair only if the specified key does not already exist in the key-value store.
Lightweight metric representation for logging or monitoring.
Legacy API: This command stores key-value pairs in the legacy key-value store mechanism.
Lightweight metric representation of this command.
Deprecated.
Use
StoreValues instead.Metric representation of the deprecated store call.
Exposes the mapped contents of a
Stream as an InputStream without buffering the full stream in
memory.A generic response containing a string value.
A Jackson module that customizes the deserialization of strings.
A functional interface representing a resource with substitutable properties.
A
PropertySource implementation that reads configuration properties from the JVM system properties.Adds the platform task identity to another correlation data provider.
Interface for in-memory scheduling of tasks in a way that supports deterministic testing and virtualized time.
Exception indicating a technical or unexpected failure within the application.
Lightweight observation hook for embedded test-server users.
Shared, opt-in context for thread-local values that belong to the same logical request.
A reusable context-switching scope created by
ThreadLocalContext.openActivation().A reusable snapshot of the context that was active when
ThreadLocalContext.capture() was called.BiConsumer-like interface whose ThrowingBiConsumer.accept(Object, Object) method may throw a
checked Exception.Variant of
BiFunction whose ThrowingBiFunction.apply(Object, Object) method is allowed to
throw a checked Exception.Functional counterpart to
Consumer that allows the ThrowingConsumer.accept(Object) method to
throw a checked Exception.An
ErrorHandler implementation that forcefully halts message tracking by throwing any encountered errors.Runnable-like interface whose
ThrowingRunnable.run() method is allowed to throw a checked Exception.Utility for running tasks with a maximum execution duration.
Annotation to be placed on requests (i.e. queries and commands).
Utility class for measuring execution time and retrying operations with configurable backoff and error handling.
A
Tracker represents an active consumer of messages for a particular ConsumerConfiguration.Represents the client-side tracking context during message consumption in Fluxzero.
An active segment reservation transferred between elected Runtime instances.
Represents the current set of
Trackers that are connected for a specific consumer.The Tracking interface provides a mechanism to start and manage the tracking of messages by a given set of handlers.
Low-level client interface for tracking and consuming messages from a message log.
Exception thrown during message tracking in Fluxzero.
A
TrackingStrategy defines how a Tracker consumes messages from a message log or distributed segment
space.Compact websocket representation for message publication and tracking.
Compact binary websocket representation for message publication and tracking.
Long-polls committed independent-model updates after a client-controlled state cursor.
One bounded page of model-commit updates returned by
TrackModelUpdates.Indicates that a message payload class can handle itself as a message handler.
Spring
BeanDefinitionRegistryPostProcessor that detects classes
annotated with TrackSelf
and registers them as FluxzeroPrototype beans for use by Fluxzero.Injects the **triggering message** that caused the current message to be published or handled.
Resolves parameters annotated with
Trigger by loading the original trigger message that caused the current
handler method to execute.Command to truncate a message log and its associated tracking positions.
Abstract base class for
ParameterResolvers that resolve parameters based on type matching.Metadata-only local type lookup.
Result of an identifier lookup, independent of payload/replay compatibility.
Interface for resolving registered types by alias or simplified name.
Thrown to signal that the user is not authenticated.
Thrown when an authenticated user attempts to access a resource or perform an action for which they lack the required
permissions.
Validates that an array or iterable value does not contain duplicate elements.
Container annotation for repeatable
UniqueElements constraints.A serialized identifier remains unknown after upcasting; preserves the DeserializationException contract.
Defines the strategy for handling unknown or unresolvable types during deserialization.
Declares a method that transforms serialized data from one revision to the next during deserialization.
Annotation indicating a collection of
Upcast methods grouped together for bulk registration.Command to inform the Fluxzero Runtime about changes in entity-aggregate relationships.
Collector for JVM uptime metrics using JMX.
JVM uptime metrics.
Validates that a character sequence can be parsed as a URL and optionally matches URL components.
Container annotation for repeatable
URL constraints.Represents an authenticated or system-level user identity within the Fluxzero Runtime.
Resolves parameters of type
User, typically representing the current user in a request context.Service interface for managing
User identities in Fluxzero.Validates that a character sequence is a canonical UUID string.
Container annotation for repeatable
UUID constraints.Default implementation of
IdentityProvider that generates random UUIDs.Specifies validation groups to apply when validating the annotated class.
A
HandlerInterceptor that validates the payload of messages before they are handled.Indicates that a request (typically a command or query) contains one or more field-level violations that prevent
further processing.
String-only validation failure summary for serialized validation responses.
Utility class providing common validation and authorization routines for message payloads such as commands, queries,
and web requests.
Strategy interface for validating message payloads and other objects prior to handler invocation.
Selects the enclosing interval or an explicit extremum of a document field.
A generic response indicating successful completion of a request without returning any payload.
Represents a single
multipart/form-data part.Specialized
HandlerMatcher that routes DeserializingMessages of type MessageType.WEBREQUEST
to matching handler methods based on annotated URI patterns, HTTP methods, and optional origins.Meta-annotation for parameter annotations used to inject values from an HTTP request.
Annotation processor that generates parameter name metadata for web request handler methods annotated with
@QueryParam, @PathParam, @HeaderParam, @CookieParam, @FormParam, or
@BodyParam.Internal configuration holder used to expand the URI and method mappings of a web request handler method.
Enumerates the sources of parameter values in an HTTP or WebSocket request.
Resolves method parameters in web handler methods based on meta-annotations derived from
WebParam.Represents a pattern used to match incoming
WebRequests to handler methods.Resolves a method parameter from the payload of a
WebRequest.Represents a web request message within the Fluxzero Runtime.
Fluent builder for
WebRequest.Interface representing a context for handling web requests.
Gateway for sending outbound web requests via Fluxzero's proxy mechanism or the SDK's native HTTP client.
Producer-side projection of web addressing onto the generic message route field.
Configuration settings for a
WebRequest sent via the WebRequestGateway.Represents a response to a
WebRequest in the Fluxzero Runtime.Fluent builder for
WebResponse.A
DispatchInterceptor that applies GZIP compression to outgoing WebResponse messages based on request
headers and response size.Specialized implementation of the
ResultGateway interface for sending web response messages.Specialization of
ResponseMapper for mapping responses to WebResponse messages.Utility methods for exchanging Fluxzero websocket client capabilities through handshake headers.
A
Client implementation that connects to the Fluxzero Runtime using WebSocket connections.Configuration class for creating a
WebSocketClient.Configuration for a tracking client assigned to a specific
MessageType.WebSocket close information used by the low-level Fluxzero runtime clients.
Connection settings for the low-level runtime websocket connector.
Creates low-level websocket sessions for Fluxzero runtime clients.
Utility methods for mapping Fluxzero test-server WebSocket endpoints onto the embedded Jetty transport.
Callback contract for low-level Fluxzero runtime websocket sessions.
Low-level receive timing captured before dispatching to the Fluxzero endpoint.
WebSocket-based implementation of the
EventStoreClient, enabling interaction with the Fluxzero Runtime's event
store via a persistent WebSocket connection.A
GatewayClient implementation that sends serialized messages to the Fluxzero Runtime over a WebSocket
connection.Decorator that adds WebSocket session support to handler classes and enables parameter injection for
SocketSession.WebSocket-based implementation of the
KeyValueClient interface for interacting with the Fluxzero Runtime.Optional compact representation for a protocol-specific websocket payload.
A
DispatchInterceptor that modifies outgoing WebResponse messages in response to WebSocket-based
WebRequests.WebSocket-based implementation of the
SchedulingClient interface that communicates with the Fluxzero Runtime.WebSocket-based implementation of the
SearchClient that connects to the Fluxzero Runtime.Minimal websocket session contract needed by the Fluxzero runtime clients.
WebSocket-based implementation of the
TrackingClient that connects to the Fluxzero Runtime.Encodes and decodes Fluxzero websocket transport payloads after format negotiation and before compression.
Factory and built-in implementations for Fluxzero websocket transport codecs.
Wire formats supported by the Fluxzero websocket transport.
Utility methods for working with web request and response data, including cookies, headers, and handler annotations.