Struct InMemoryStore 

pub struct InMemoryStore { /* private fields */ }

Correct non-durable crate::EventStore implementation for tests and backend equivalence.

Implementations

impl InMemoryStore

pub fn write_raw_assistant_session( &self, session_id: &str, bytes: Vec<u8>, ) -> Result<(), StoreError>

Write assistant-session backend bytes directly for persistence conformance testing (poisoned-row listing behaviour), bypassing the entity codec.

Errors

StoreError::Serialization when session_id is empty or whitespace.

impl InMemoryStore

pub fn write_raw_worker_deployment( &self, name: &str, bytes: Vec<u8>, ) -> Result<(), StoreError>

Write backend bytes directly for persistence conformance testing.

This deliberately bypasses the entity codec so the shared suite can pin poisoned-row listing, replacement, and deletion behavior on every backend.

Errors

Returns StoreError::Serialization when name is empty or whitespace.

pub fn write_raw_workloop( &self, loop_id: &str, bytes: Vec<u8>, ) -> Result<(), StoreError>

Write workloop backend bytes directly for persistence conformance testing (poisoned-row listing behavior), bypassing the entity codec.

Errors

Returns StoreError::Serialization when loop_id is empty.

Trait Implementations

impl AssistantSessionStore for InMemoryStore

fn put_assistant_session<'life0, 'async_trait>( &'life0 self, record: AssistantSessionRecord, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create or replace a session’s record.

fn get_assistant_session<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 AssistantSessionId, ) -> Pin<Box<dyn Future<Output = Result<Option<AssistantSessionRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up one session by id.

fn list_assistant_sessions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AssistantSessionListing, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List decodable sessions and report every undecodable row, ordered by created_at then session id.

fn append_assistant_transcript_event<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 AssistantSessionId, recorded_at: DateTime<Utc>, payload: Payload, ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Append one event to a session’s transcript, returning the index the store assigned it.

fn assistant_transcript_head<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 AssistantSessionId, ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The next index the store would assign this session — equivalently, how many events its transcript holds.

fn put_assistant_default_harness<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, subject: &'life1 str, harness: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Remember the harness subject last opened a session on.

fn assistant_default_harness<'life0, 'life1, 'async_trait>( &'life0 self, subject: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The harness subject last opened a session on, or None before any.

fn assistant_transcript<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 AssistantSessionId, after: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssistantTranscriptEvent>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

A session’s transcript in index order, excluding every event at or below after.

impl Debug for InMemoryStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for InMemoryStore

fn default() -> InMemoryStore

Returns the “default value” for a type.

impl NamespaceStore for InMemoryStore

fn register_namespace<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, origin: NamespaceOrigin, ) -> Pin<Box<dyn Future<Output = Result<MintOutcome, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Idempotent minted-on-use upsert.

fn put_namespace<'life0, 'async_trait>( &'life0 self, record: NamespaceRecord, ) -> Pin<Box<dyn Future<Output = Result<MintOutcome, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Explicit upsert (POST /namespaces).

fn list_namespaces<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<NamespaceRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the live durable set, ascending by created_at (ties broken by name).

fn get_namespace<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<NamespaceRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Looks up a single namespace by name.

fn set_namespace_placement<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, placement: NamespacePlacement, ) -> Pin<Box<dyn Future<Output = Result<Option<()>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Idempotent quorum-CAS update of an existing namespace’s placement directive (Control-Plane Phase 2, P2-P2).

fn deprecate_namespace<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Transitions a namespace from NamespaceState::Active to NamespaceState::Deprecated (deprecate-before-delete).

impl PackageStore for InMemoryStore

fn put_package<'life0, 'async_trait>( &'life0 self, record: PackageRecord, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Persists record and atomically points the type’s route at it.

fn put_package_with_routes<'life0, 'life1, 'async_trait>( &'life0 self, record: PackageRecord, route_workflow_types: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persists record and atomically points every member workflow type at its content hash.

fn list_packages<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PackageRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists every persisted package in ascending deployed_at order (ties broken by (workflow_type, content_hash) text order), so startup reload re-applies deploys deterministically.

fn delete_package<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, workflow_type: &'life1 str, content_hash: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Deletes the persisted archive for (workflow_type, content_hash).

fn put_package_route<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, workflow_type: &'life1 str, content_hash: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Upserts the route pointer for workflow_type to content_hash.

fn list_package_routes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PackageRouteRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists every persisted route pointer in workflow_type text order.

impl ReadableEventStore for InMemoryStore

fn read_history<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Event>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads the complete event history for workflow_id in ascending sequence order.

fn read_history_from<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, from_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<Event>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads the event history for workflow_id restricted to events with sequence number greater than or equal to from_seq, in ascending sequence order.

fn read_run_chain<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<Vec<RunSummary>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads the concrete run chain for workflow_id in continuation order.

fn list_workflow_ids<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowId>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists every workflow identifier that has at least one event in history.

fn stream_heads<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<StreamHead>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists every workflow’s event stream with the seq of its last event — the stream-side half of the handshake that lets a boot trust a visibility row instead of opening the history behind it (crate::visibility::head).

fn list_active<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowId>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists workflow identifiers whose projected status is exactly WorkflowStatus::Running.

fn list_paused<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowId>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists workflow identifiers whose projected status is exactly WorkflowStatus::Paused.

fn query<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 WorkflowFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkflowSummary>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns workflow summaries matching filter.

fn schedule_timer<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, timer_id: &'life2 TimerId, fire_at: DateTime<Utc>, armed_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Persists a durable timer for workflow_id that is due at fire_at.

fn retire_timer<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, timer_id: &'life2 TimerId, fire_at: DateTime<Utc>, armed_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<TimerRetirement, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Removes the durable timer row for (workflow_id, timer_id) — but only while the row still carries exactly the (fire_at, armed_seq) identity of the arming being retired.

fn expired_timers<'life0, 'async_trait>( &'life0 self, as_of: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<Vec<TimerEntry>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns durable timers whose fire_at is less than or equal to as_of.

fn set_owned_shards(&self, shards: Option<&[usize]>)

Restrict every per-workflow enumeration (active workflows, timers, outbox rows) to the named set of distribution shards this node owns, or restore the own-all-shards default when shards is None.

fn acquire_owned_shards(&self, shards: &[usize]) -> Result<(), StoreError>

Acquire-and-serve ownership of each named distribution shard BEFORE the boot path recovers or enumerates over them, so the node is the fenced owner and its replicated state is union-merged locally first.

fn acquire_owned_shard(&self, shard: usize) -> Result<(), StoreError>

Acquire-and-serve ownership of a SINGLE distribution shard — the per-shard primitive Self::acquire_owned_shards is a loop over, exposed so the failover path can drive a per-shard abort seam: a clean election loss on one shard (StoreError::NotOwner) drops only that shard rather than failing the whole adoption batch (ADR-021 clean-partial).

fn is_current_owner(&self, shard: usize) -> bool

Whether this node currently holds LIVE serve-authority for shard — it won the per-shard election THIS process lifetime and has not been deposed in-process.

fn extend_owned_shards(&self, shards: &[usize])

Add shards to this node’s owned-enumeration scope, UNIONING them with the shards it already owns rather than replacing the set.

fn publish_shard_owner(&self, shard: usize) -> Result<(), StoreError>

Publish THIS node as the current owner of shard in the cluster’s shard-owner directory, so other nodes’ request-routing edges resolve shard to this node (SS-3).

impl VisibilityStore for InMemoryStore

fn list_workflows<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 WorkflowListRequest, ) -> Pin<Box<dyn Future<Output = Result<VisibilityPage, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The reference fold: every row is a candidate and paginate does the rest. Linear in the namespace by design — this store exists to define the answer, not to serve it at scale.

fn record_visibility<'life0, 'async_trait>( &'life0 self, record: VisibilityRecord, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Upserts THE row for record.workflow_id, replacing any previous generation’s row and moving it under its new sort keys atomically. The replace is part of the write, not a separate pass: after this returns, the workflow has exactly one row and it is this one.

fn get_visibility<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<Option<VisibilityRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reads the workflow’s row, or None when it has no row yet.

fn remove_visibility<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = Result<bool, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Removes the row for workflow_id IF it belongs to run_id, and any row a store written before the one-row collapse still holds for that (workflow_id, run_id) pair. Returns whether anything was removed.

impl WorkerDeploymentStore for InMemoryStore

fn put_worker_deployment<'life0, 'async_trait>( &'life0 self, record: WorkerDeployment, ) -> Pin<Box<dyn Future<Output = Result<WorkerDeploymentPutResult, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create or replace a deployment record, returning the exact persisted value.

fn get_worker_deployment<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<WorkerDeployment>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up one deployment by name.

fn list_worker_deployments<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WorkerDeploymentListing, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List decodable deployments and report every undecodable key, with both sets ordered by primary-key name.

fn set_desired_state<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, desired: DesiredState, ) -> Pin<Box<dyn Future<Output = Result<Option<WorkerDeployment>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set desired state on an existing record, returning None when absent.

fn delete_worker_deployment<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<WorkerDeploymentDeleteOutcome, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically remove a row by key without requiring it to decode.

impl WorkloopStore for InMemoryStore

fn put_workloop<'life0, 'async_trait>( &'life0 self, record: WorkloopRecord, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create or replace a loop’s registration record.

fn get_workloop<'life0, 'life1, 'async_trait>( &'life0 self, loop_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<Option<WorkloopRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up one loop by id.

fn list_workloops<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WorkloopListing, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List decodable loops and report every undecodable row, both ordered by loop id text.

fn due_workloops<'life0, 'async_trait>( &'life0 self, as_of: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkloopRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loops whose next_check_at is Some and at or before as_of — the sweeper’s work set. A sleeping loop with a future (or absent) check instant never appears, which is what makes a thousand sleeping loops cost the sweeper nothing. Undecodable rows are excluded here (they surface via WorkloopStore::list_workloops, never silently in the hot path).

fn remove_workloop<'life0, 'life1, 'async_trait>( &'life0 self, loop_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<bool, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a loop’s registration (retirement). Returns whether a row existed. Invariant current-state records are NOT removed: the current record survives indefinitely by declaration (R8.1).

fn put_invariant_record<'life0, 'async_trait>( &'life0 self, record: InvariantStateRecord, prune_before: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Install record as the invariant’s current record — rotating any prior current into the generation list — and prune prior generations recorded before prune_before, in ONE read-modify-write. Returns how many prior generations the prune removed. The current record is never pruned; it survives indefinitely by declaration (R8.1).

fn current_invariant_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, loop_id: &'life1 WorkflowId, invariant: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<InvariantStateRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The invariant’s current record, if one was ever produced.

fn invariant_record_generations<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, loop_id: &'life1 WorkflowId, invariant: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<InvariantStateRecord>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The invariant’s prior generations within retention, oldest first.

impl WritableEventStore for InMemoryStore

fn append<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _token: WriteToken, workflow_id: &'life1 WorkflowId, events: &'life2 [Event], expected_seq: u64, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically appends events to workflow_id when the stored history head equals expected_seq.

fn append_with_outbox<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, token: WriteToken, workflow_id: &'life1 WorkflowId, events: &'life2 [Event], expected_seq: u64, outbox_rows: &'life3 [OutboxRow], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Appends events and the durable-outbox outbox_rows for workflow_id under the same expected-head sequence guard as Self::append, as one fan-out write.

fn rearm_outbox_pending<'life0, 'life1, 'async_trait>( &'life0 self, rows: &'life1 [OutboxRow], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns the outbox rows for rows’ dispatch_keys to Pending, re-staging them for the out-of-band dispatcher.

fn settle_outbox_row_cancelled<'life0, 'life1, 'async_trait>( &'life0 self, dispatch_key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Idempotently settles one outbox row to cancelled when this writer is backed by an outbox.

fn settle_workflow_outbox_rows_cancelled<'life0, 'life1, 'async_trait>( &'life0 self, workflow_id: &'life1 WorkflowId, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Idempotently settles EVERY live (crate::OutboxStatus::Pending or crate::OutboxStatus::Claimed) outbox row of workflow_id to crate::OutboxStatus::Cancelled, returning the settled dispatch_keys (#253).