Struct SupervisorConfig 

pub struct SupervisorConfig { /* private fields */ }

Immutable runtime-wide settings for one supervisor.

These settings control task shutdown, subscriber draining, bounded queues, registry membership, event ingress, concurrent attempts, and user lifetimes retained for cleanup. Start with Default and change the limits needed by the application. Pass the result to Supervisor::new or Supervisor::builder.

Implementations

impl SupervisorConfig

pub const fn new() -> Self

Built-in runtime configuration available in const contexts.

pub const fn grace(&self) -> Duration

Cooperative task-stop window before logical force-abort.

Explicit removal, requested shutdown, and natural shutdown use this window. After it expires, Taskvisor commits a logical force-abort. The physical task code may remain active after that point. Zero skips the wait.

pub const fn subscriber_shutdown_timeout(&self) -> Duration

Shared deadline for draining subscriber queues.

Zero closes the queues without waiting for pending events. The deadline can drop queued events. It cannot stop a callback already running.

pub const fn max_concurrent(&self) -> Option<NonZeroUsize>

Limit for task attempts running at the same time.

None means no limit. Permit waits and retry backoff do not count. A started attempt holds its permit until its physical attempt boundary exits.

pub const fn max_registered_tasks(&self) -> Option<NonZeroUsize>

Registry membership limit.

Registered and removing tasks count until terminal cleanup removes their identity. Force-aborted work can keep consuming the limit after membership ends. During cleanup handoff, one task may temporarily consume two units.

None disables this limit. The separately configured ownership_capacity still applies.

pub const fn ownership_capacity(&self) -> Option<NonZeroUsize>

Limit for user lifetimes owned by this supervisor.

Configured subscribers and accepted tasks share this limit. Each accepted lifetime keeps one unit through queued work, physical execution, and isolated terminal destruction. Force-aborted work can remain charged after logical completion. A destructor panic permanently retires its unit from a finite limit. A finite limit below the internal cleanup-worker ceiling also lowers that ceiling.

None removes the ownership admission limit. Destructor isolation and its worker ceiling remain active. Blocked destructors can then retain an unbounded number of user values and cleanup batches.

pub const fn bus_capacity(&self) -> NonZeroUsize

Number of newest events retained by the event ingress.

The bus remains best-effort. When publishers outrun the relay, older events are replaced and loss is reported through overflow diagnostics.

pub const fn registry_queue_capacity(&self) -> NonZeroUsize

Capacity of the registry management queue.

Default direct-registry operations wait for this capacity. Operations configured with fail_fast() return RuntimeError::CommandQueueFull when no slot is available immediately.

pub const fn with_grace(self, grace: Duration) -> Self

Cooperative task-stop window before logical force-abort.

Values above 30 years are normalized to 30 years. grace always returns the effective value used by timeout logic and diagnostics.

pub const fn with_subscriber_shutdown_timeout(self, timeout: Duration) -> Self

Shared deadline for draining subscriber queues.

Zero closes the queues without waiting for pending events. The deadline does not interrupt a subscriber callback already running.

pub const fn with_max_concurrent( self, max_concurrent: Option<NonZeroUsize>, ) -> Self

Optional limit for task attempts running at the same time.

SupervisorBuilder::try_build rejects values above Tokio’s structural limit. Use try_with_max_concurrent for a raw integer. Pass None to remove the limit.

pub fn try_with_max_concurrent( self, max_concurrent: usize, ) -> Result<Self, ConfigError>

Task-attempt concurrency limit from a raw integer.

Use with_max_concurrent with None for no limit.

Errors

• ConfigError::Zero when max_concurrent is zero;
• ConfigError::TooLarge when max_concurrent exceeds Tokio’s structural limit.

pub const fn with_max_registered_tasks( self, max_registered_tasks: Option<NonZeroUsize>, ) -> Self

Optional registry membership limit.

Registered and removing tasks count until terminal cleanup finishes. Force-aborted work can keep consuming the limit after membership ends. None disables only this limit. It does not change the separate ownership_capacity setting.

Use try_with_max_registered_tasks for a raw integer.

pub fn try_with_max_registered_tasks( self, max_registered_tasks: usize, ) -> Result<Self, ConfigError>

Registry membership limit from a raw integer.

Errors

• ConfigError::Zero when max_registered_tasks is zero.

pub const fn with_ownership_capacity( self, ownership_capacity: Option<NonZeroUsize>, ) -> Self

Optional limit for user lifetimes owned by this supervisor.

Configured subscribers and accepted tasks share the limit. None disables ownership admission backpressure but keeps destructor isolation and its worker ceiling enabled. Without this limit, blocked destructors can retain an unbounded number of user values and cleanup batches. A finite limit below the internal cleanup-worker ceiling also lowers that ceiling.

Use try_with_ownership_capacity for a raw integer.

pub fn try_with_ownership_capacity( self, ownership_capacity: usize, ) -> Result<Self, ConfigError>

User-lifetime ownership limit from a raw integer.

Use with_ownership_capacity with None for no limit.

Errors

• ConfigError::Zero when ownership_capacity is zero.

pub const fn with_bus_capacity(self, bus_capacity: NonZeroUsize) -> Self

Number of newest events retained by the event ingress.

Increasing this value absorbs a larger event burst but does not make lifecycle events reliable.

SupervisorBuilder::try_build rejects values above Tokio’s structural limit.

pub fn try_with_bus_capacity( self, bus_capacity: usize, ) -> Result<Self, ConfigError>

Event-bus capacity from a raw integer.

Errors

• ConfigError::Zero when bus_capacity is zero;
• ConfigError::TooLarge when bus_capacity exceeds Tokio’s structural limit.

pub const fn with_registry_queue_capacity( self, registry_queue_capacity: NonZeroUsize, ) -> Self

Capacity of the registry management queue.

This bounds management commands waiting for the registry. It does not change the task membership or attempt-concurrency limits.

SupervisorBuilder::try_build rejects values above Tokio’s structural limit.

pub fn try_with_registry_queue_capacity( self, registry_queue_capacity: usize, ) -> Result<Self, ConfigError>

Registry management-queue capacity from a raw integer.

Errors

• ConfigError::Zero when registry_queue_capacity is zero;
• ConfigError::TooLarge when registry_queue_capacity exceeds Tokio’s structural limit.

Trait Implementations

impl Clone for SupervisorConfig

fn clone(&self) -> SupervisorConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SupervisorConfig

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

Formats the value using the given formatter.

impl Default for SupervisorConfig

fn default() -> Self

Built-in runtime configuration.

Defaults:

• graceful task shutdown: 60 seconds,
• subscriber drain: 5 seconds,
• task-attempt concurrency: unlimited,
• registered-task membership: 1024,
• owned user lifetimes: 1024,
• event bus capacity: 1024,
• registry command capacity: 1024.