Crate feltdb 

FeltDB

A durable, embedded state store. Records live under a capability (the part of a key before the first :, so "orders:o-1" is record o-1 of capability orders). Every write goes through a durable log; several records can be changed in one atomic transaction; an update can be made conditional on the version you read; and a transaction can carry an identity so that a retry after an uncertain outcome is recognized instead of applied twice.

use feltdb::{AtomicMutation, FeltDb, FlowError, PayloadBinding, RecordPrecondition};
use serde_json::{json, Value};

let dir = tempfile::tempdir()?;
let path = dir.path().join("app.db");
let db = FeltDb::open(&path)?;

// Create a record only if it is absent: a second create is refused, and refused in a way a
// caller can branch on.
db.insert_if_absent("orders:o-1", json!({ "status": "pending" }))?;
assert!(matches!(
    db.insert_if_absent("orders:o-1", json!({})),
    Err(FlowError::PreconditionFailed(_))
));

// Change several records atomically, and name the transaction so a retry is safe. The payload
// hash is yours to compute: FeltDB stores it and compares it for equality.
let ship = |hash: &str| {
    db.apply_atomic_transaction_content_addressed(
        "ship-o-1",
        Some(hash),
        None,
        &[],
        &[
            AtomicMutation {
                capability: "orders".into(),
                key: "orders:o-1".into(),
                value: Some(json!({ "status": "shipped" })),
            },
            AtomicMutation {
                capability: "audit".into(),
                key: "audit:a-1".into(),
                value: Some(json!({ "order": "o-1", "event": "shipped" })),
            },
        ],
        None,
    )
};
let first = ship("sha256:payload-v1")?;
assert!(!first.duplicate);

// The same request again is recognized as the original, not applied a second time.
let retry = ship("sha256:payload-v1")?;
assert!(retry.duplicate);
assert_eq!(retry.payload_binding, Some(PayloadBinding::Verified));
assert_eq!(retry.commit_revision, first.commit_revision);

// The same id with a different payload is refused, with a typed error. Nothing is written.
assert!(matches!(
    ship("sha256:payload-v2"),
    Err(FlowError::TransactionIdPayloadMismatch { .. })
));

// Close and reopen: what was acknowledged is there.
drop(db);
let db = FeltDb::open(&path)?;
assert_eq!(db.get::<Value>("orders:o-1")?, Some(json!({ "status": "shipped" })));

What is supported

Only the items in this table are covered by the compatibility policy (docs/reference/feltdb-rust-api.md in the repository). While the version is 0.x, a breaking change to them is a minor-version bump and is recorded in the changelog; everything else may change in any release.

To	Use
open, recover, reopen	FeltDb::open, FeltDb::log_recovery, FeltDb::health
read	FeltDb::get, FeltDb::query
write unconditionally	FeltDb::insert, FeltDb::update, FeltDb::delete (all three are plain writes: see below)
create only if absent	FeltDb::insert_if_absent
update only if unchanged	FeltDb::compare_and_set_json → JsonCasResult
change several records atomically	FeltDb::apply_atomic_transaction, FeltDb::apply_atomic_transaction_guarded with AtomicMutation and RecordPrecondition → AtomicCommit
make a retry safe	FeltDb::apply_atomic_transaction_content_addressed, FeltDb::has_applied_transaction, FeltDb::applied_transaction_payload_hash, PayloadBinding
tell failures apart	FlowError and its variants, PreconditionFailure
a durable authority for several processes	the authority module (Unix)

Behavior to know before relying on it. insert, update and delete are unconditional: insert replaces an existing record, update of a missing key creates it, and delete of a missing key succeeds. A fenced write (FeltDb::compare_and_set_json, a RecordPrecondition with expected_version) treats a record that has never been through one as version 1, and a record’s __version becomes visible in its JSON after its first fenced write. A transaction refused for a failed precondition writes nothing. A transaction id committed without a payload hash can be retried (it is a duplicate, with no PayloadBinding), but retrying it with a hash is refused, because there is nothing to verify against.

Durability

An acknowledged write survives the process being killed. Whether it survives the machine losing power depends on the operating system and drive honouring a flush, and is not established. A log ending in an incomplete append is recovered by discarding that append, which was never acknowledged: FeltDb::log_recovery says so. A corrupt log, or one in a format this build does not understand, refuses to open and is left as found.

Stability tiers

• Supported: the table above.
• Experimental: agent_state, agent_transition_contract, the deterministic-contract adapters, semantic_decision and semantic_query. Public so they can be used, but they may change shape before they are stabilized.
• Not yet classified: the other public modules. They are public today and carry no promise; each is listed with the decision still needed in the repository’s Rust API audit.
• Internals: implementation, fault-injection and diagnostic modules are private unless the unstable-internals feature is enabled, and nothing behind that feature is covered by any promise.

FlowError is #[non_exhaustive]: match on its variants, always with a catch-all arm, and never on message text.

Re-exports

pub use admission::ProductionRetryPolicy;

pub use admission::RejectionReason;

pub use admission::SubmissionOutcome;

pub use analytics::AutoTuner;

pub use analytics::IndexAnalytics;

pub use analytics::IndexMetrics;

pub use analytics::PerformanceReport;

pub use analytics::QueryTrace;

pub use analytics::TuningRecommendation;

pub use causal_dependency_barrier::ApplyResult;

pub use causal_dependency_barrier::CausalDependencyBarrier;

pub use causal_dependency_barrier::OperationState;

pub use causal_dependency_barrier::PendingOperation;

pub use causal_dependency_barrier::ReceiveResult;

pub use causal_dependency_barrier::StateCounters;

pub use consistency_contract::CommutativeVerificationResult;

pub use consistency_contract::ConsensusEnforcementResult;

pub use consistency_contract::ConsensusRequirementChecker;

pub use consistency_contract::ConsistencyContractEnforcer;

pub use consistency_contract::DeterministicMergeVerificationResult;

pub use consistency_contract::NoDowngradeVerificationResult;

pub use consistency_contract::OperationApplication;

pub use convergence::CausalHistory;

pub use convergence::ConflictResolution;

pub use convergence::ConflictResolutionStrategy;

pub use convergence::MergeResult;

pub use convergence::StateVersion;

pub use convergence::VectorClock;

pub use crash_atomic_boundary::CrashAtomicExecutor;

pub use crash_atomic_boundary::CrashBoundaryPoint;

pub use crash_atomic_boundary::CrashRecoveryState;

pub use crash_atomic_boundary::InvariantCheckResult;

pub use crash_atomic_boundary::RecoveryDecision;

pub use distributed_indexing::ConsistencyLevel;

pub use distributed_indexing::ConsistencyProtocol;

pub use distributed_indexing::DistributedIndexManager;

pub use distributed_indexing::DistributedSyncStatus;

pub use distributed_indexing::IndexOperation;

pub use distributed_indexing::IndexReplicationState;

pub use distributed_indexing::IndexSyncMessage;

pub use distributed_indexing::IndexVectorClock;

pub use distributed_indexing::RemoteIndexMetadata;

pub use distributed_indexing::RemoteIndexState;

pub use distributed_indexing::ReplicationStatus;

pub use distributed_indexing::VersionConflict;

pub use distributed_transactions::DistributedTransactionExecutor;

pub use distributed_transactions::EnvelopeId;

pub use distributed_transactions::ReplicaState;

pub use distributed_transactions::ReplicationMessage;

pub use distributed_transactions::TransactionEnvelope;

pub use equality_index::EqualityIndex;

pub use equality_index::EqualityIndexStats;

pub use equality_index::IndexKey;

pub use indexing::IndexConfig;

pub use indexing::IndexManager;

pub use indexing::IndexStats;

pub use indexing::IndexType;

pub use multi_node_convergence::ConvergenceAggregation;

pub use multi_node_convergence::ConvergenceResult;

pub use multi_node_convergence::MultiNodeConvergenceSimulator;

pub use multi_node_convergence::NodeExecutionResult;

pub use operation_algebra::ConflictType;

pub use operation_algebra::ConvergenceSemantic;

pub use operation_algebra::OperationAlgebra;

pub use operation_algebra::OperationAlgebraRegistry;

pub use operation_log::MemoryOperationLog;

pub use operation_log::OperationLogEntry;

pub use partition_reconciliation::DeterminismCheckResult;

pub use partition_reconciliation::PartitionDeterminismChecker;

pub use partition_reconciliation::PartitionTrace;

pub use partition_reconciliation::PartitionedReplica;

pub use partition_reconciliation::ReconciliationResult;

pub use partition_reconciliation::ReplicaPartition;

pub use semantic_decision::authorize_context;

pub use semantic_decision::configured_decision_runtime;

pub use semantic_decision::decide_record;

pub use semantic_decision::decision_cache_key;

pub use semantic_decision::deterministic_request_key;

pub use semantic_decision::reuse_record_judgment;

pub use semantic_decision::execute_decision_batch;

pub use semantic_decision::execute_decision_transport;

pub use semantic_decision::execute_inline_decision_transport;

pub use semantic_decision::jev;

pub use semantic_decision::run_choice_diagnostics;

pub use semantic_decision::run_decision_benchmark;

pub use semantic_decision::validate_decision_definition;

pub use semantic_decision::validate_decision_result;

pub use semantic_decision::BinaryDecisionResult;

pub use semantic_decision::ChoiceDecisionResult;

pub use semantic_decision::ChoiceDiagnosticsReport;

pub use semantic_decision::ChoiceExpansionObservation;

pub use semantic_decision::ChoicePermutationObservation;

pub use semantic_decision::DecisionAuthorizationConfig;

pub use semantic_decision::DecisionAuthorizationDecision;

pub use semantic_decision::DecisionAuthorizationGate;

pub use semantic_decision::DecisionBatch;

pub use semantic_decision::DecisionBatchDecision;

pub use semantic_decision::DecisionBatchEvaluation;

pub use semantic_decision::DecisionBenchmarkCase;

pub use semantic_decision::DecisionBenchmarkReport;

pub use semantic_decision::DecisionContextPacket;

pub use semantic_decision::DecisionDefinition;

pub use semantic_decision::DecisionError;

pub use semantic_decision::DecisionEvaluation;

pub use semantic_decision::DecisionEvidence;

pub use semantic_decision::DecisionEvidenceField;

pub use semantic_decision::DecisionExecutionMethod;

pub use semantic_decision::DecisionJudgmentRecord;

pub use semantic_decision::DecisionKind;

pub use semantic_decision::DecisionOptions;

pub use semantic_decision::DecisionPrincipal;

pub use semantic_decision::DecisionProvenance;

pub use semantic_decision::DecisionRecordRef;

pub use semantic_decision::DecisionRequest;

pub use semantic_decision::DecisionResult;

pub use semantic_decision::DecisionRuntime;

pub use semantic_decision::DecisionRuntimeCapabilities;

pub use semantic_decision::DecisionRuntimeMetadata;

pub use semantic_decision::DecisionStateReference;

pub use semantic_decision::DecisionStatus;

pub use semantic_decision::DecisionTransportAuthorization;

pub use semantic_decision::DecisionTransportExecutionRequest;

pub use semantic_decision::DecisionTransportExecutionResponse;

pub use semantic_decision::DecisionTransportRuntime;

pub use semantic_decision::DeterministicDecisionRuntime;

pub use semantic_decision::ScoreDecisionResult;

pub use semantic_decision::WeightedOption;

pub use semantic_decision::DEFAULT_DECISION_COLLECTION;

pub use semantic_query::compose_semantic_page;

pub use semantic_query::semantic_clause_hash;

pub use semantic_query::semantic_definition_hash;

pub use semantic_query::validate_semantic_clause;

pub use semantic_query::SemanticAnnotation;

pub use semantic_query::SemanticCandidate;

pub use semantic_query::SemanticOrderDirection;

pub use semantic_query::SemanticPage;

pub use semantic_query::SemanticQueryClause;

pub use semantic_query::SemanticQueryError;

pub use semantic_query::SemanticQueryFilter;

pub use semantic_query::SemanticQueryMode;

pub use semantic_query::SemanticQueryOrder;

pub use semantic_query::SemanticStageSummary;

pub use semantic_query::SemanticUnevaluated;

pub use semantic_query::SemanticUnevaluatedReason;

pub use semantic_query::MAX_SEMANTIC_CANDIDATES;

pub use sharding::HotspotAlert;

pub use sharding::RebalanceOperation;

pub use sharding::ShardDistributionSummary;

pub use sharding::ShardId;

pub use sharding::ShardKey;

pub use sharding::ShardManager;

pub use sharding::ShardMetrics;

pub use sharding::ShardRange;

pub use sharding::ShardingStrategy;

pub use state_conflict_contract::classify_states;

pub use state_conflict_contract::StateConflictInput;

pub use state_conflict_contract::StateConflictOutput;

pub use state_conflict_contract::STATE_CONFLICT_CONTRACT_ID;

pub use state_conflict_contract::STATE_CONFLICT_CONTRACT_VERSION;

pub use state_diff_contract::diff_states;

pub use state_diff_contract::StateDiffInput;

pub use state_diff_contract::StateDiffOutput;

pub use state_diff_contract::STATE_DIFF_CONTRACT_ID;

pub use state_diff_contract::STATE_DIFF_CONTRACT_VERSION;

pub use state_facade::FeltDBStateSystem;

pub use state_hash::CanonicalState;

pub use state_hash::StateHash;

pub use state_model::apply_reconciliation_plan;

pub use state_model::path_relation;

pub use state_model::paths_overlap;

pub use state_model::reconcile;

pub use state_model::resolve_path;

pub use state_model::ChangeKind;

pub use state_model::ConflictClass;

pub use state_model::ConflictClassification;

pub use state_model::GarbageCollectionError;

pub use state_model::GarbageCollectionReport;

pub use state_model::MaterializationError;

pub use state_model::MaterializationProjection;

pub use state_model::PathComponent;

pub use state_model::PathConflict;

pub use state_model::PathRelation;

pub use state_model::ReconciliationPlan;

pub use state_model::RefError;

pub use state_model::Relationship;

pub use state_model::SemanticChange;

pub use state_model::SemanticDiff;

pub use state_model::StateId;

pub use state_model::StateObject;

pub use state_model::StateReconciliationResult;

pub use state_model::StateRef;

pub use state_model::StateRevision;

pub use state_model::StateStore;

pub use state_model::StateTopology;

pub use state_model::STATE_MODEL_VERSION;

pub use state_transition_store::MemoryStateTransitionStore;

pub use state_transition_store::StateTransitionRecord;

pub use state_trigger::StateTrigger;

pub use state_trigger::StateTriggerChangeKind;

pub use state_trigger::StateTriggerError;

pub use state_trigger::StateTriggerPredicate;

pub use state_trigger::StateTriggerStore;

pub use state_trigger::TriggeredWorkload;

pub use submission::SubmissionManager;

pub use submission::SubmissionMetrics;

pub use transaction_api::TransactionManager;

pub use transaction_api::TxError;

pub use transaction_api::TxResult;

pub use transactions::CommitId;

pub use transactions::CommitValidator;

pub use transactions::ConsistencyContract;

pub use transactions::OperationCommand;

pub use transactions::OperationId;

pub use transactions::StateDependency;

pub use transactions::StateTransition;

pub use transactions::TransactionExecutor;

pub use transactions::TransitionResult;

pub use trigger_contract::canonical_input_bytes;

pub use trigger_contract::canonical_output_bytes;

pub use trigger_contract::evaluate_canonical;

pub use trigger_contract::evaluate_trigger;

pub use trigger_contract::ContractChange;

pub use trigger_contract::ContractChangeKind;

pub use trigger_contract::ContractErrorBody;

pub use trigger_contract::ContractErrorCode;

pub use trigger_contract::ContractPredicate;

pub use trigger_contract::ContractRuntime;

pub use trigger_contract::ContractTrigger;

pub use trigger_contract::MatchOutcome;

pub use trigger_contract::MatchReason;

pub use trigger_contract::TriggerMatchInput;

pub use trigger_contract::TriggerMatchOutput;

pub use trigger_contract::TRIGGER_MATCH_CONTRACT_ID;

pub use trigger_contract::TRIGGER_MATCH_CONTRACT_VERSION;

pub use versioned_object_substrate::DurableObjectStore;

pub use versioned_object_substrate::DurableRef;

pub use versioned_object_substrate::LocalObjectStore;

pub use versioned_object_substrate::Reachability;

pub use versioned_object_substrate::S3CompatibleBucket;

pub use versioned_object_substrate::S3CompatibleObjectStore;

pub use versioned_object_substrate::SubstrateError;

pub use versioned_object_substrate::VersionedObjectSubstrate;

Modules

admission

agent_state

Durable agent state: the production implementation of crate::agent_transition_contract.

agent_transition_contract

The deterministic contract behind durable agent-state transitions.

analytics

application

application_runtime

authority

One logical durable authority across embedded and local multi-process use.

authority_failover

Authority Failover Protocol

authorization

Canonical resource authorization and portable signed grants.

capabilities

causal_dependency_barrier

consistency_contract

convergence

crash_atomic_boundary

distributed_indexing

distributed_transactions

durability_guarantees

durable_dedup_set

durable_operation_log

durable_sync

equality_index

A deterministic equality index over authoritative collection state.

indexing

metrics

multi_node_convergence

multi_operation_transaction

Multi-Operation Atomicity (Production Gate P1)

observability

operation_algebra

operation_log

partition_reconciliation

policy_evaluation

Runtime policy enforcement for FlowSpec policies.

production_api

query_performance

replica_acknowledgements

Durable replica acknowledgements.

replica_membership

Durable replica membership.

replication_manager

replication_protocol

semantic_decision

semantic_query

Semantic query composition over a bounded candidate page.

sharding

state_conflict_contract

The deterministic contract behind FeltDB’s conflict classification.

state_contract

Query Execution Contract

state_diff_contract

The deterministic contract behind FeltDB’s semantic state diff.

state_facade

Canonical FeltDB State Subsystem Public API Facade

state_hash

state_model

Proven FeltDB State Model

state_transition_store

state_trigger

Durable evaluation of committed state changes into workloads.

submission

sync_contract

FeltDB Sync v1: transport-neutral operation synchronization semantics.

tcp_transport

transaction_api

transactions

trigger_contract

The deterministic contract behind state-trigger matching.

versioned_object_substrate

worker_mesh

Worker and mesh semantics. Compute is replaceable; durable workload state is authority.

workload

Durable workload authority. Workers execute; this state machine decides.

Structs

AcquisitionDeduplicator

In-flight acquisition tracking for deduplication

AcquisitionMetadata

Metadata tracking how content was acquired from the distributed fabric This metadata is NOT canonical application state - it’s purely informational

AcquisitionResult

Result of content acquisition attempt

AtomicCommit

AtomicMutation

AtomicPrecondition

BackupProblem

Why a backup artifact was rejected.

BackupVerification

What a backup artifact contains, established by reading it.

Capability

CapabilityAccessModel

Access model for capability security

CapabilityCheckpoint

Checkpoint for capability progress tracking

CapabilityContext

Context passed to capability operations

CapabilityExecutionContext

Context for executing a capability (local or remote)

CapabilityExecutionResult

Result of a capability execution with full provenance

CapabilityId

Unique capability identifier

CapabilityLocationRegistry

Capability location registry - tracks where capabilities are available

CapabilityMetadata

Capability metadata and configuration

CapabilityOperationResult

Result of processing an operation through a capability

CapabilityQuery

Query structure for capability queries

CapabilityQueryResult

Result of a capability query

CapabilityRef

Reference to a capability with namespace and version Canonical form: flow://capability/namespace:name@version

CapabilityRegistry

Capability registry - tracks all capabilities

CapabilityRequirements

Requirements for a capability to execute

CapabilityResolver

Resolver for capabilities - routes to appropriate provider

CapabilityRouter

State-aware capability routing engine

ChangeEvent

An event representing a change to the database (insert or update of a record).

ChangeLog

A change log that tracks pending operations for synchronization

CheckpointData

Data structure for checkpoints

CompactionPolicy

When a compaction should actually rewrite the durable log.

Conflict

Represents a conflict between local and remote operations

ConflictDetector

Conflict detector for identifying conflicts between operations

ContentAcquisitionManager

Manager for acquiring content from distributed peers

ContentAddressableStore

A content addressable store that tracks where content lives

ContentIdentity

Content identity based on hash

ContentRange

A range of content available on a peer

ContentRequest

Request for content from a remote peer

ContentResponse

Response containing acquired content

CronSchedule

A cron schedule definition

CronScheduler

Cron scheduler - manages all cron schedules

DatabaseHealth

What this database knows about itself, as facts rather than labels.

DatabaseSnapshot

DerivedStateProvenance

Provenance information for derived state

DerivedValue

Wrapper for derived state to ensure it’s properly marked

DistributedCapabilityAdvertisement

Advertises a capability at a specific peer with its requirements

DistributedReferenceResolver

Reference resolution with fallback to peer acquisition

DurabilityFailure

A write that did not become durable, and what is known about its outcome.

Execution

A durable execution record

ExecutionClaim

A claim on an execution

ExecutionClaimer

Execution claim tracker for single-owner semantics

ExecutionQueue

Execution queue - tracks all executions

ExecutionRef

Reference to an execution result with provenance

ExecutionResultPublisher

Result publication tracker

FeltDb

FileStorage

File-based storage backend for native file operations

FlowRef

A stable reference primitive for distributed FeltDB fabric

FormatIncompatibility

Why a durable database cannot be opened, and what to do about it.

LiveCapabilitySubscription

A capability-scoped subscription to a live query that streams updates for records within a specific capability.

LiveQuerySubscription

A subscription to a live query that streams updates whenever matching records change.

LogCorruption

Where durable corruption was found, and what is wrong with it.

MaterializationHandler

Handler for materializing acquired content

MemoryStorage

In-memory storage backend for testing

Operation

A durable operation that can be appended to the log

PeerAdvertisement

Advertisement of what a peer provides

PeerId

Peer identifier in the distributed fabric

PeerRegistry

A registry of peers in the distributed fabric

PeerState

State of a peer’s synchronization

PeerStateVersion

State version tracking for a peer

ProjectionDistribution

Projection distribution - tracks where projections are hosted

ReadBasis

A read set and what the authority held for it at one moment.

ReadCondition

ReadPredicate

ReadRecord

ReadSet

State a decision was read from: records by identity, and equality predicates over a collection (every record of collection whose fields equal these values, including records that do not exist yet).

RecordPrecondition

What must be true of one record for a transaction to commit.

ResolutionMetadata

Metadata about a resolved reference

ResolutionResult

Result of content resolution with metadata

RetryPolicy

Retry policy for executions

StateRequirement

Represents a required state for a capability to execute

StoredRow

SyncState

Overall sync state and metrics

TransactionAttribution

Who committed a transaction, and what it touched.

Trigger

A trigger that maps operations to capability executions

TriggerFilter

Filter condition for triggers

TriggerRegistry

Trigger registry - manages all triggers

WorkflowCronTrigger

Workflow cron trigger - creates workflow instances from cron schedule

WorkflowGraph

Workflow graph definition - durable DAG structure

WorkflowInstance

Runtime state for a workflow instance

WorkflowIntegration

Workflow integration manager

WorkflowNode

Workflow graph node - represents a capability to execute

WorkflowOperationEntry

An emitted workflow operation with metadata

WorkflowProvenance

Workflow provenance - tracks why an object exists through workflow execution

WorkflowRef

Reference to a workflow - addressable object in the fabric

WorkflowRuntime

Workflow runtime - manages workflow execution and state

WorkflowStepRef

Reference to a step within a workflow

WorkflowTrigger

Workflow trigger - creates workflow instances from events

Enums

AcquisitionPolicy

Policy for acquiring content from the distributed fabric

BlockedReason

Reason a workflow step is blocked

CapabilityLifecycleState

Lifecycle states for a capability

CapabilityRole

The roles a capability can fulfill

CompactionOutcome

What a policy-driven compaction did.

ContentTransferError

Error types for content acquisition

DurabilityFailureKind

Why a write did not become durable.

DurabilityMode

How far a single-record write is pushed before it returns.

DurableFormat

What format a durable database is in.

ExecutionStatus

Execution status enumeration

FlowError

Why an operation failed.

FormatCompatibility

The result of examining a durable database without opening it.

JsonCasResult

LogRecovery

What replaying the durable log had to do to succeed.

MutationOrder

Mutation ordering specification for FeltDB This defines the order in which mutation side effects occur

OperationSource

Source of an operation - tracks where it originated

OperationType

Types of mutations that become durable operations

PayloadBinding

What a duplicate transaction id was checked against.

PreconditionFailure

Which predicate failed, and what the authority actually holds.

ReadLayout

Where a read set’s logical collections and ids live in storage.

RouteDecision

Route decision for capability execution

StorageHealth

What is actually known about this database’s durable storage.

SyncMessage

Sync protocol messages for peer-to-peer synchronization

TransactionStatus

WorkflowOperation

Workflow lifecycle event - becomes a durable operation

WorkflowState

State of a workflow

WorkflowStepState

State of a workflow step in the durable execution model

WriteAvailability

Whether a database can accept writes, as this process knows it.

Constants

BACKUP_VERSION

The backup artifact format this build writes and understands.

DEFAULT_MUTATION_ORDER

The default mutation ordering for FeltDB We choose PersistFirst to ensure durability guarantees

DURABLE_FORMAT_VERSION

The durable format this build writes and understands.

READ_BASIS_PREFIX

Token prefix for read bases this authority issues.

READ_SET_LIMIT

Largest number of records plus predicates one read set may name.

STANDALONE_OPERATION_WINDOW

How many of its newest operations a standalone store (one no peer has ever acknowledged) keeps in its operation log. See ChangeLog::prune_standalone and docs/reference/storage-growth.md.

Traits

DerivedState

Marker trait for values that represent derived state This should be implemented by capability-generated state

FlowCapability

Trait for implementing capabilities This is the core contract for extending FeltDB with specialized behavior

ReactiveCollectionIntegration

Reactive collection integration This trait allows acquired content to participate in reactive collections

ReferenceResolver

Trait for resolving FlowRefs to actual objects

Storage

Trait defining the storage abstraction for FeltDB.

Functions

inspect_durable_format

Read the log, separating a torn tail from real corruption.

open

verify_backup

Read and check a backup artifact without opening it as a database.

Type Aliases

Result