ic_timers/runtime/

mod.rs

//! Canister-local owner and live timer execution.

use crate::{
    platform::{self, TimerHandle},
    registry::{
        CallbackAcceptance, CallbackRole, CallbackToken, OrdinaryCallback, ProviderHandle,
        ProviderHandles, RegisterError, RegistrationClaim, RegistryEffect, RegistryError,
        RegistryTransition, TimerRegistry, WatchdogCallback,
    },
    schedule::{ScheduleError, TimerCadence, TimerDirective, TimerSchedule},
    snapshot::{
        DeclarationLifetime, TimerCompletion, TimerControlFailure, TimerEpoch, TimerIdentity,
        TimerInventorySnapshot, TimerPolicy, TimerRunResult, TimerSnapshot, WatchdogRunResult,
    },
};
use std::{cell::RefCell, future::Future, rc::Rc, time::Duration};
use thiserror::Error;

thread_local! {
    static RUNTIME: RefCell<Option<TimerRegistry>> = const { RefCell::new(None) };
}

/// Failure from the canister-local timer runtime API.
#[non_exhaustive]
#[derive(Debug, Error)]
pub enum TimerError {
    /// The lifecycle owner has not initialized the volatile runtime.
    #[error("timer runtime is not initialized")]
    NotInitialized,
    /// A nested internal borrow indicates unsupported re-entrancy.
    #[error("timer runtime is already borrowed")]
    RuntimeBusy,
    /// Claiming one canonical timer identity failed.
    #[error(transparent)]
    Register(#[from] RegisterError),
    /// Cadence or deadline validation failed.
    #[error(transparent)]
    Schedule(#[from] ScheduleError),
    /// The logical registration was removed or superseded.
    #[error("timer registration is no longer authoritative")]
    RegistrationExpired,
    /// Pure checked control reached a terminal failure after effects were applied.
    #[error("timer control failed: {0:?}")]
    ControlFailure(TimerControlFailure),
    /// Canonical callback or provider-handle ownership was internally inconsistent.
    #[error("timer runtime ownership invariant failed")]
    OwnershipInvariant,
    /// A retained lifecycle claim no longer matches its canonical declaration.
    #[error("timer lifecycle reconciliation conflicts with the canonical declaration")]
    ReconciliationConflict,
}

impl From<RegistryError> for TimerError {
    fn from(value: RegistryError) -> Self {
        match value {
            RegistryError::UnknownRegistration
            | RegistryError::StaleRegistration
            | RegistryError::StaleCallback => Self::RegistrationExpired,
            RegistryError::PolicyMismatch { .. } => Self::OwnershipInvariant,
            RegistryError::Schedule(error) => Self::Schedule(error),
            RegistryError::MissingCallback | RegistryError::ProviderHandleAlreadyOwned => {
                Self::OwnershipInvariant
            }
        }
    }
}

/// Initialize the volatile canister-local runtime once for this Wasm instance.
///
/// Repeated calls are idempotent and return the original epoch. This function
/// exports no lifecycle hook; the canister's existing lifecycle owner calls it.
pub fn initialize_runtime() -> Result<TimerEpoch, TimerError> {
    let epoch = TimerEpoch::new(platform::canister_version(), platform::time_ns());
    RUNTIME.with(|runtime| {
        let mut runtime = runtime
            .try_borrow_mut()
            .map_err(|_| TimerError::RuntimeBusy)?;
        if let Some(registry) = runtime.as_ref() {
            return Ok(registry.epoch());
        }
        *runtime = Some(TimerRegistry::new(epoch));
        Ok(epoch)
    })
}

struct CallbackContext {
    token: CallbackToken,
}

impl CallbackContext {
    const fn new(token: CallbackToken) -> Self {
        Self { token }
    }

    fn claim(&self) -> RegistrationClaim {
        RegistrationClaim::from_callback(&self.token)
    }

    const fn identity(&self) -> &TimerIdentity {
        self.token.identity()
    }

    fn cancel(&self) -> Result<(), TimerError> {
        cancel_claim(&self.claim(), Some(&self.token))
    }

    fn schedule_once(&self, schedule: TimerSchedule) -> Result<(), TimerError> {
        ensure_once_claim(&self.claim(), Some(&self.token), schedule)
    }

    fn schedule_recurring(&self) -> Result<(), TimerError> {
        ensure_recurring_claim(&self.claim(), Some(&self.token))
    }

    fn schedule_watchdog_immediately(&self) -> Result<(), TimerError> {
        ensure_watchdog_immediately_claim(&self.claim(), Some(&self.token))
    }

    fn reconcile_watchdog(&self, schedule: Option<TimerSchedule>) -> Result<(), TimerError> {
        reconcile_watchdog_claim(&self.claim(), Some(&self.token), schedule)
    }

    fn reconcile_ordinary(&self, schedule: Option<TimerSchedule>) -> Result<(), TimerError> {
        reconcile_ordinary_claim(&self.claim(), Some(&self.token), schedule)
    }
}

/// Delegated control capability scoped to one exact `Once` work attempt.
///
/// Identity remains inspectable after work returns, but mutation methods then
/// return [`TimerError::RegistrationExpired`]. Retain the
/// [`OnceRegistration`] for longer-lived ownership.
pub struct OnceContext {
    inner: CallbackContext,
}

impl OnceContext {
    const fn new(token: CallbackToken) -> Self {
        Self {
            inner: CallbackContext::new(token),
        }
    }

    /// Return the logical timer identity executing this work.
    #[must_use]
    pub const fn identity(&self) -> &TimerIdentity {
        self.inner.identity()
    }

    /// Schedule a `Once` declaration while this exact work attempt is active.
    ///
    /// A context retained after its callback completes is expired and returns
    /// [`TimerError::RegistrationExpired`].
    pub fn ensure_scheduled(&self, schedule: TimerSchedule) -> Result<(), TimerError> {
        self.inner.schedule_once(schedule)
    }

    /// Reconcile the executing declaration to one exact schedule.
    ///
    /// `None` requests inactive state at normal completion. Retained callback
    /// authority remains; a remove-on-stop declaration is removed when that
    /// cancellation wins arbitration. A stored context cannot mutate the
    /// registration after its exact work attempt ends.
    pub fn reconcile_schedule(&self, schedule: Option<TimerSchedule>) -> Result<(), TimerError> {
        self.inner.reconcile_ordinary(schedule)
    }

    /// Request cancellation while this exact work attempt is active.
    ///
    /// Cancellation does not interrupt the current invocation; normal
    /// completion applies it before any callback successor is retained.
    /// A retained declaration becomes inactive. A remove-on-stop declaration
    /// is removed when cancellation wins arbitration.
    pub fn cancel(&self) -> Result<(), TimerError> {
        self.inner.cancel()
    }
}

/// Delegated control capability scoped to one exact after-completion work
/// attempt.
///
/// Mutation authority expires when the callback completes. Retain the
/// [`AfterCompletionRegistration`] for longer-lived ownership.
pub struct AfterCompletionContext {
    inner: CallbackContext,
}

impl AfterCompletionContext {
    const fn new(token: CallbackToken) -> Self {
        Self {
            inner: CallbackContext::new(token),
        }
    }

    /// Return the logical timer identity executing this work.
    #[must_use]
    pub const fn identity(&self) -> &TimerIdentity {
        self.inner.identity()
    }

    /// Request configured recurrence after this exact work attempt.
    pub fn ensure_scheduled(&self) -> Result<(), TimerError> {
        self.inner.schedule_recurring()
    }

    /// Reconcile the executing declaration to one exact schedule without
    /// changing its configured after-completion cadence.
    ///
    /// `None` requests inactive state at normal completion. A retained
    /// declaration keeps its callback authority; a remove-on-stop declaration
    /// is removed when cancellation wins arbitration. A stored context cannot
    /// mutate the registration after its exact work attempt ends.
    pub fn reconcile_schedule(&self, schedule: Option<TimerSchedule>) -> Result<(), TimerError> {
        self.inner.reconcile_ordinary(schedule)
    }

    /// Request cancellation while this exact work attempt is active.
    ///
    /// Cancellation does not interrupt the current invocation; normal
    /// completion applies it before any callback successor is retained. A
    /// retained declaration becomes inactive; a remove-on-stop declaration is
    /// removed when cancellation wins arbitration.
    pub fn cancel(&self) -> Result<(), TimerError> {
        self.inner.cancel()
    }
}

/// Delegated control capability scoped to one exact watchdog work attempt.
///
/// Mutation authority expires when the callback completes. Retain the
/// [`WatchdogRegistration`] for longer-lived ownership.
pub struct WatchdogContext {
    inner: CallbackContext,
}

impl WatchdogContext {
    const fn new(token: CallbackToken) -> Self {
        Self {
            inner: CallbackContext::new(token),
        }
    }

    /// Return the logical timer identity executing this work.
    #[must_use]
    pub const fn identity(&self) -> &TimerIdentity {
        self.inner.identity()
    }

    /// Request that the pre-armed cadence successor remain scheduled.
    ///
    /// This is idempotent unless it supersedes a nested cancellation request.
    /// It never arms an additional Watchdog successor and cannot move a
    /// pending immediate successor later.
    pub fn ensure_scheduled(&self) -> Result<(), TimerError> {
        self.inner.schedule_recurring()
    }

    /// Request that this work attempt's pre-armed successor run immediately.
    ///
    /// Repeated requests coalesce, and a cadence ensure cannot move the
    /// pending immediate deadline later. Normal completion replaces the exact
    /// cadence successor with a zero-delay scheduler callback. Consumer work
    /// still runs only in the scheduler's separately queued later message.
    pub fn ensure_scheduled_immediately(&self) -> Result<(), TimerError> {
        self.inner.schedule_watchdog_immediately()
    }

    /// Replace this attempt's successor with an exact schedule, or cancel it.
    ///
    /// Applied on normal completion; a trap preserves the committed cadence
    /// successor. The latest reconciliation wins over prior scheduling demand,
    /// but unregistration and invariant failure remain terminal.
    pub fn reconcile_schedule(&self, schedule: Option<TimerSchedule>) -> Result<(), TimerError> {
        self.inner.reconcile_watchdog(schedule)
    }

    /// Request cancellation while this exact work attempt is active.
    ///
    /// Cancellation does not interrupt the current invocation; normal
    /// completion clears the already-armed successor when cancellation wins.
    /// A retained declaration becomes inactive; a remove-on-stop declaration
    /// is removed.
    pub fn cancel(&self) -> Result<(), TimerError> {
        self.inner.cancel()
    }
}

/// Opaque non-clone claim for one registered `Once` callback.
#[must_use = "retain the registration claim so the timer remains controllable"]
pub struct OnceRegistration {
    claim: RegistrationClaim,
}

impl OnceRegistration {
    /// Return the claimed logical identity.
    #[must_use]
    pub const fn identity(&self) -> &TimerIdentity {
        self.claim.identity()
    }

    /// Return whether this exact claim currently owns an armed provider wake-up.
    ///
    /// This is a volatile observation, not durable scheduling authority or a
    /// delivery guarantee. Call [`Self::ensure_scheduled`] unconditionally when
    /// a wake-up is required rather than using this value as a scheduling guard.
    pub fn has_armed_wakeup(&self) -> Result<bool, TimerError> {
        has_armed_wakeup_claim(&self.claim)
    }

    /// Ensure one invocation is armed or retained as the running work's successor.
    pub fn ensure_scheduled(&self, schedule: TimerSchedule) -> Result<(), TimerError> {
        ensure_once_claim(&self.claim, None, schedule)
    }

    /// Reconcile to one exact desired schedule, replacing a later or earlier
    /// live deadline as necessary.
    ///
    /// `None` leaves a retained declaration inactive after any running work
    /// completes. A remove-on-stop declaration is removed and this claim
    /// expires when the transition finalizes.
    pub fn reconcile_schedule(&self, schedule: Option<TimerSchedule>) -> Result<(), TimerError> {
        reconcile_ordinary_claim(&self.claim, None, schedule)
    }

    /// Cancel the armed callback or the running work's successor.
    ///
    /// Consumer work already running is not interrupted.
    /// A retained declaration keeps callback authority. A remove-on-stop
    /// declaration and this claim expire when cancellation finalizes.
    pub fn cancel(&self) -> Result<(), TimerError> {
        cancel_claim(&self.claim, None)
    }

    /// Consume the claim and unregister its callback authority.
    ///
    /// When called from running work, removal is deferred until that invocation
    /// completes normally.
    pub fn unregister(self) -> Result<(), TimerError> {
        unregister_claim(&self.claim)
    }
}

/// Opaque non-clone claim for one callback with configured
/// after-completion recurrence.
#[must_use = "retain the registration claim so the timer remains controllable"]
pub struct AfterCompletionRegistration {
    claim: RegistrationClaim,
}

/// Opaque non-clone claim for one pre-armed watchdog callback.
#[must_use = "retain the registration claim so the timer remains controllable"]
pub struct WatchdogRegistration {
    claim: RegistrationClaim,
}

trait RegistrationClaimOwner {
    fn registration_claim(&self) -> &RegistrationClaim;
}

impl RegistrationClaimOwner for OnceRegistration {
    fn registration_claim(&self) -> &RegistrationClaim {
        &self.claim
    }
}

impl RegistrationClaimOwner for AfterCompletionRegistration {
    fn registration_claim(&self) -> &RegistrationClaim {
        &self.claim
    }
}

impl RegistrationClaimOwner for WatchdogRegistration {
    fn registration_claim(&self) -> &RegistrationClaim {
        &self.claim
    }
}

/// Desired volatile after-completion state during lifecycle reconciliation.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TimerReconcileState {
    /// Request inactive state immediately unless consumer work is running.
    Inactive,
    /// Preserve scheduling demand now or through the running work's successor.
    Scheduled,
}

/// Desired volatile watchdog state during synchronous lifecycle reconciliation.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum WatchdogReconcileState {
    /// Request inactive state immediately unless consumer work is running.
    Inactive,
    /// Preserve or arm one scheduler wake-up at the configured cadence.
    Scheduled,
    /// Preserve an earlier wake-up or arm/move one scheduler wake-up to now.
    ///
    /// The zero-delay provider callback executes as a later replicated
    /// scheduler message and does not invoke consumer work synchronously.
    ScheduledImmediately,
    /// Reconcile the scheduler to an exact absolute IC timestamp.
    ScheduledAt(u64),
}

impl WatchdogRegistration {
    /// Return the claimed logical identity.
    #[must_use]
    pub const fn identity(&self) -> &TimerIdentity {
        self.claim.identity()
    }

    /// Return whether this exact claim currently owns an armed scheduler wake-up.
    ///
    /// The separately queued work callback is not itself a wake-up. During
    /// watchdog work this returns `true` only because the scheduler has already
    /// committed and installed the cadence successor. This is a volatile
    /// observation, not a delivery guarantee.
    pub fn has_armed_wakeup(&self) -> Result<bool, TimerError> {
        has_armed_wakeup_claim(&self.claim)
    }

    /// Synchronously ensure one watchdog scheduler wake-up is authoritative.
    ///
    /// An existing earlier immediate deadline is retained and never delayed.
    pub fn ensure_scheduled(&self) -> Result<(), TimerError> {
        ensure_recurring_claim(&self.claim, None)
    }

    /// Synchronously ensure one watchdog scheduler wake-up is due now.
    ///
    /// An inactive declaration arms one zero-delay scheduler. A later cadence
    /// deadline is replaced in place; an already earlier or equivalent
    /// deadline and repeated immediate requests coalesce. If work is already
    /// dispatched, that zero-delay work satisfies the request. If work is
    /// running, the request applies to that attempt's pre-armed successor.
    pub fn ensure_scheduled_immediately(&self) -> Result<(), TimerError> {
        ensure_watchdog_immediately_claim(&self.claim, None)
    }

    /// Reconcile to one exact scheduler deadline, or cancel with `None`.
    ///
    /// Unlike ensure, this can move a wake-up later. Identical deadlines
    /// coalesce. Dispatched or running work is not postponed: reconciliation
    /// selects its successor on normal completion. Until then, the committed
    /// cadence successor remains the recovery wake-up. A subsequent recovery
    /// attempt retires the interrupted attempt's pending proposal.
    pub fn reconcile_schedule(&self, schedule: Option<TimerSchedule>) -> Result<(), TimerError> {
        reconcile_watchdog_claim(&self.claim, None, schedule)
    }

    /// Cancel the scheduler and any work callback that has not started.
    ///
    /// Consumer work already running is not interrupted; normal completion
    /// clears its pre-armed successor.
    /// A retained declaration keeps callback authority. A remove-on-stop
    /// declaration and this claim expire when cancellation finalizes.
    pub fn cancel(&self) -> Result<(), TimerError> {
        cancel_claim(&self.claim, None)
    }

    /// Consume the claim and unregister its callback authority.
    ///
    /// When called from running work, removal is deferred until that invocation
    /// completes normally.
    pub fn unregister(self) -> Result<(), TimerError> {
        unregister_claim(&self.claim)
    }
}

impl AfterCompletionRegistration {
    /// Return the claimed logical identity.
    #[must_use]
    pub const fn identity(&self) -> &TimerIdentity {
        self.claim.identity()
    }

    /// Return whether this exact claim currently owns an armed provider wake-up.
    ///
    /// A callback currently running without an installed successor returns
    /// `false`. This is a volatile observation, not durable scheduling authority
    /// or a delivery guarantee.
    pub fn has_armed_wakeup(&self) -> Result<bool, TimerError> {
        has_armed_wakeup_claim(&self.claim)
    }

    /// Ensure configured recurrence is armed or retained as the running work's
    /// successor.
    pub fn ensure_scheduled(&self) -> Result<(), TimerError> {
        ensure_recurring_claim(&self.claim, None)
    }

    /// Reconcile to one exact desired schedule without changing the configured
    /// after-completion cadence. `None` makes a retained declaration inactive
    /// after any running work completes; it removes a remove-on-stop
    /// declaration and expires this claim when the transition finalizes.
    pub fn reconcile_schedule(&self, schedule: Option<TimerSchedule>) -> Result<(), TimerError> {
        reconcile_ordinary_claim(&self.claim, None, schedule)
    }

    /// Cancel the armed callback or the running work's successor.
    ///
    /// Consumer work already running is not interrupted.
    /// A retained declaration keeps callback authority. A remove-on-stop
    /// declaration and this claim expire when cancellation finalizes.
    pub fn cancel(&self) -> Result<(), TimerError> {
        cancel_claim(&self.claim, None)
    }

    /// Consume the claim and unregister its callback authority.
    ///
    /// When called from running work, removal is deferred until that invocation
    /// completes normally.
    pub fn unregister(self) -> Result<(), TimerError> {
        unregister_claim(&self.claim)
    }
}

/// Register one asynchronous `Once` callback without scheduling it.
pub fn register_once<F, Fut>(
    identity: TimerIdentity,
    lifetime: DeclarationLifetime,
    callback: F,
) -> Result<OnceRegistration, TimerError>
where
    F: FnMut(OnceContext) -> Fut + 'static,
    Fut: Future<Output = TimerRunResult> + 'static,
{
    let callback = erase_ordinary_callback(callback, OnceContext::new);
    let claim = with_registry_mut(|registry| {
        registry
            .register_once_with_callback(identity, lifetime, callback)
            .map_err(TimerError::from)
    })?;
    Ok(OnceRegistration { claim })
}

/// Register one asynchronous callback with configured after-completion recurrence.
pub fn register_after_completion<F, Fut>(
    identity: TimerIdentity,
    cadence: TimerCadence,
    lifetime: DeclarationLifetime,
    callback: F,
) -> Result<AfterCompletionRegistration, TimerError>
where
    F: FnMut(AfterCompletionContext) -> Fut + 'static,
    Fut: Future<Output = TimerRunResult> + 'static,
{
    let callback = erase_ordinary_callback(callback, AfterCompletionContext::new);
    let claim = with_registry_mut(|registry| {
        registry
            .register_after_completion_with_callback(identity, cadence, lifetime, callback)
            .map_err(TimerError::from)
    })?;
    Ok(AfterCompletionRegistration { claim })
}

/// Register one synchronous pre-armed watchdog callback without scheduling it.
///
/// The callback cannot be async: it runs only in the work message after a
/// separate scheduler message has armed the next cadence successor. Its
/// `WatchdogDecision` retains the cadence successor, replaces it with a
/// deadline of now or an exact timestamp, or clears it.
pub fn register_watchdog<F>(
    identity: TimerIdentity,
    cadence: TimerCadence,
    lifetime: DeclarationLifetime,
    callback: F,
) -> Result<WatchdogRegistration, TimerError>
where
    F: FnMut(WatchdogContext) -> WatchdogRunResult + 'static,
{
    let mut callback = callback;
    let callback: WatchdogCallback = Rc::new(RefCell::new(Box::new(move |token| {
        callback(WatchdogContext::new(token))
    })));
    let claim = with_registry_mut(|registry| {
        registry
            .register_watchdog_with_callback(identity, cadence, lifetime, callback)
            .map_err(TimerError::from)
    })?;
    Ok(WatchdogRegistration { claim })
}

/// Reconstruct or reconcile one `Once` declaration synchronously.
///
/// `Some(schedule)` is authoritative and may move an existing deadline in
/// either direction. `None` retains an inactive declaration in the canonical
/// inventory, including on a fresh heap. Lifecycle reconciliation always owns
/// a [`DeclarationLifetime::Retained`] declaration; transient
/// `RemoveWhenStopped` callbacks use [`register_once`] directly.
pub fn reconcile_once<F, Fut>(
    registration: &mut Option<OnceRegistration>,
    identity: &TimerIdentity,
    desired: Option<TimerSchedule>,
    callback: F,
) -> Result<(), TimerError>
where
    F: FnMut(OnceContext) -> Fut + 'static,
    Fut: Future<Output = TimerRunResult> + 'static,
{
    let registration = reconcile_registration(registration, identity, TimerPolicy::Once, || {
        register_once(identity.clone(), DeclarationLifetime::Retained, callback)
    })?;
    registration.reconcile_schedule(desired)
}

/// Reconstruct or reconcile one after-completion declaration synchronously.
///
/// The consumer owns `registration` in volatile state. A fresh Wasm heap has
/// `None`, so this function installs callback authority before reconciling it
/// active or inactive. A repeated call reuses the exact claim and does not
/// replace its callback. The installed declaration is always retained;
/// transient `RemoveWhenStopped` recurrence uses
/// [`register_after_completion`] directly.
pub fn reconcile_after_completion<F, Fut>(
    registration: &mut Option<AfterCompletionRegistration>,
    identity: &TimerIdentity,
    cadence: TimerCadence,
    desired: TimerReconcileState,
    callback: F,
) -> Result<(), TimerError>
where
    F: FnMut(AfterCompletionContext) -> Fut + 'static,
    Fut: Future<Output = TimerRunResult> + 'static,
{
    let registration = reconcile_registration(
        registration,
        identity,
        TimerPolicy::AfterCompletion { cadence },
        || {
            register_after_completion(
                identity.clone(),
                cadence,
                DeclarationLifetime::Retained,
                callback,
            )
        },
    )?;
    match desired {
        TimerReconcileState::Inactive => registration.cancel(),
        TimerReconcileState::Scheduled => registration.ensure_scheduled(),
    }
}

/// Reconstruct or reconcile one watchdog declaration synchronously.
///
/// Durable readiness remains consumer-owned. Fresh inactive authority still
/// installs an observable retained declaration. `ScheduledImmediately` arms
/// its first scheduler at deadline now without synchronous consumer work.
/// `ScheduledAt` reconciles an exact deadline, including moving it later.
/// This helper owns no lifecycle export and persists no policy, generation,
/// provider handle, or callback.
/// Transient `RemoveWhenStopped` watchdogs use [`register_watchdog`] directly.
pub fn reconcile_watchdog<F>(
    registration: &mut Option<WatchdogRegistration>,
    identity: &TimerIdentity,
    cadence: TimerCadence,
    desired: WatchdogReconcileState,
    callback: F,
) -> Result<(), TimerError>
where
    F: FnMut(WatchdogContext) -> WatchdogRunResult + 'static,
{
    let registration = reconcile_registration(
        registration,
        identity,
        TimerPolicy::Watchdog { cadence },
        || {
            register_watchdog(
                identity.clone(),
                cadence,
                DeclarationLifetime::Retained,
                callback,
            )
        },
    )?;
    match desired {
        WatchdogReconcileState::Inactive => registration.cancel(),
        WatchdogReconcileState::Scheduled => registration.ensure_scheduled(),
        WatchdogReconcileState::ScheduledImmediately => registration.ensure_scheduled_immediately(),
        WatchdogReconcileState::ScheduledAt(deadline_ns) => {
            registration.reconcile_schedule(Some(TimerSchedule::At(deadline_ns)))
        }
    }
}

fn reconcile_registration<'a, Registration>(
    registration: &'a mut Option<Registration>,
    identity: &TimerIdentity,
    policy: TimerPolicy,
    register: impl FnOnce() -> Result<Registration, TimerError>,
) -> Result<&'a Registration, TimerError>
where
    Registration: RegistrationClaimOwner,
{
    if registration.is_none() {
        *registration = Some(register()?);
    }
    let registration = registration
        .as_ref()
        .ok_or(TimerError::ReconciliationConflict)?;
    verify_declaration(registration.registration_claim(), identity, policy)?;
    Ok(registration)
}

fn verify_declaration(
    claim: &RegistrationClaim,
    identity: &TimerIdentity,
    policy: TimerPolicy,
) -> Result<(), TimerError> {
    if claim.identity() != identity {
        return Err(TimerError::ReconciliationConflict);
    }
    with_registry(|registry| {
        registry
            .declaration_matches(claim, policy, DeclarationLifetime::Retained)
            .map_err(TimerError::from)?
            .then_some(())
            .ok_or(TimerError::ReconciliationConflict)
    })
}

/// Return one coherent inert snapshot by identity.
pub fn timer_snapshot(identity: &TimerIdentity) -> Result<Option<TimerSnapshot>, TimerError> {
    with_registry(|registry| Ok(registry.snapshot(identity)))
}

/// Return one atomic bounded inventory with its volatile runtime epoch.
///
/// Timer snapshots are ordered deterministically by identity. An initialized
/// empty registry still returns its epoch and an empty timer slice.
pub fn timer_inventory() -> Result<TimerInventorySnapshot, TimerError> {
    with_registry(|registry| Ok(registry.inventory()))
}

/// Return functional expected-failure state by identity without a full inventory.
pub fn consecutive_expected_failures(identity: &TimerIdentity) -> Result<Option<u64>, TimerError> {
    with_registry(|registry| Ok(registry.consecutive_expected_failures(identity)))
}

fn has_armed_wakeup_claim(claim: &RegistrationClaim) -> Result<bool, TimerError> {
    with_registry(|registry| registry.has_armed_wakeup(claim).map_err(TimerError::from))
}

fn erase_ordinary_callback<Context: 'static, F, Fut>(
    mut callback: F,
    context: fn(CallbackToken) -> Context,
) -> OrdinaryCallback
where
    F: FnMut(Context) -> Fut + 'static,
    Fut: Future<Output = TimerRunResult> + 'static,
{
    Rc::new(RefCell::new(Box::new(move |token| {
        Box::pin(callback(context(token)))
    })))
}

fn apply_claim_transition(
    claim: &RegistrationClaim,
    context: Option<&CallbackToken>,
    operation: impl FnOnce(&mut TimerRegistry) -> Result<RegistryTransition, RegistryError>,
) -> Result<(), TimerError> {
    let transition = with_registry_mut(|registry| {
        validate_context(registry, context)?;
        operation(registry).map_err(TimerError::from)
    })?;
    finish_claim_transition(claim, transition, ProviderHandles::default())
}

fn ensure_once_claim(
    claim: &RegistrationClaim,
    context: Option<&CallbackToken>,
    schedule: TimerSchedule,
) -> Result<(), TimerError> {
    apply_claim_transition(claim, context, |registry| {
        registry.ensure_once(claim, platform::time_ns(), schedule)
    })
}

fn reconcile_ordinary_claim(
    claim: &RegistrationClaim,
    context: Option<&CallbackToken>,
    schedule: Option<TimerSchedule>,
) -> Result<(), TimerError> {
    if schedule.is_none() {
        let (handles, transition) = with_registry_mut(|registry| {
            validate_context(registry, context)?;
            registry
                .validate_ordinary_claim(claim)
                .map_err(TimerError::from)?;
            let handles = registry
                .take_provider_handles_for_claim(claim)
                .map_err(TimerError::from)?;
            let transition = registry
                .reconcile_ordinary(claim, platform::time_ns(), None)
                .map_err(TimerError::from);
            Ok((handles, transition))
        })?;
        return finish_detached_claim_transition(claim, handles, transition);
    }
    apply_claim_transition(claim, context, |registry| {
        registry.reconcile_ordinary(claim, platform::time_ns(), schedule)
    })
}

fn ensure_recurring_claim(
    claim: &RegistrationClaim,
    context: Option<&CallbackToken>,
) -> Result<(), TimerError> {
    apply_claim_transition(claim, context, |registry| {
        registry.ensure_recurring(claim, platform::time_ns())
    })
}

fn ensure_watchdog_immediately_claim(
    claim: &RegistrationClaim,
    context: Option<&CallbackToken>,
) -> Result<(), TimerError> {
    apply_claim_transition(claim, context, |registry| {
        registry.ensure_watchdog_immediately(claim, platform::time_ns())
    })
}

fn reconcile_watchdog_claim(
    claim: &RegistrationClaim,
    context: Option<&CallbackToken>,
    schedule: Option<TimerSchedule>,
) -> Result<(), TimerError> {
    if schedule.is_none() {
        return apply_detached_claim_transition(claim, context, |registry| {
            registry.reconcile_watchdog_schedule(claim, platform::time_ns(), None)
        });
    }
    apply_claim_transition(claim, context, |registry| {
        registry.reconcile_watchdog_schedule(claim, platform::time_ns(), schedule)
    })
}

fn cancel_claim(
    claim: &RegistrationClaim,
    context: Option<&CallbackToken>,
) -> Result<(), TimerError> {
    apply_detached_claim_transition(claim, context, |registry| registry.cancel(claim))
}

fn validate_context(
    registry: &TimerRegistry,
    context: Option<&CallbackToken>,
) -> Result<(), TimerError> {
    context.map_or(Ok(()), |token| {
        registry
            .validate_running_context(token)
            .map_err(TimerError::from)
    })
}

fn unregister_claim(claim: &RegistrationClaim) -> Result<(), TimerError> {
    apply_detached_claim_transition(claim, None, |registry| registry.unregister(claim))
}

fn apply_detached_claim_transition(
    claim: &RegistrationClaim,
    context: Option<&CallbackToken>,
    operation: impl FnOnce(&mut TimerRegistry) -> Result<RegistryTransition, RegistryError>,
) -> Result<(), TimerError> {
    let (handles, transition) = with_registry_mut(|registry| {
        validate_context(registry, context)?;
        let handles = registry
            .take_provider_handles_for_claim(claim)
            .map_err(TimerError::from)?;
        let transition = operation(registry).map_err(TimerError::from);
        Ok((handles, transition))
    })?;
    finish_detached_claim_transition(claim, handles, transition)
}

fn finish_detached_claim_transition(
    claim: &RegistrationClaim,
    handles: ProviderHandles,
    transition: Result<RegistryTransition, TimerError>,
) -> Result<(), TimerError> {
    match transition {
        Ok(transition) => finish_claim_transition(claim, transition, handles),
        Err(error) => match restore_provider_handles(handles) {
            Ok(()) => Err(error),
            Err(restoration_error) => retire_failed_claim(claim, restoration_error),
        },
    }
}

fn finish_claim_transition(
    claim: &RegistrationClaim,
    transition: RegistryTransition,
    handles: ProviderHandles,
) -> Result<(), TimerError> {
    match finish_transition(transition, handles) {
        result @ (Ok(()) | Err(TimerError::ControlFailure(_))) => result,
        Err(error) => retire_failed_claim(claim, error),
    }
}

fn retire_failed_claim(claim: &RegistrationClaim, error: TimerError) -> Result<(), TimerError> {
    match fail_claim_provider_binding(claim) {
        Ok(()) | Err(TimerError::RegistrationExpired) => Err(error),
        Err(cleanup_error) => Err(cleanup_error),
    }
}

fn finish_transition(
    transition: RegistryTransition,
    handles: ProviderHandles,
) -> Result<(), TimerError> {
    let failure = transition.failure();
    let effect = transition.into_effect();
    apply_effect(&effect, handles)?;
    failure.map_or(Ok(()), |failure| Err(TimerError::ControlFailure(failure)))
}

fn apply_effect(effect: &RegistryEffect, mut handles: ProviderHandles) -> Result<(), TimerError> {
    if !effect.has_valid_shape() {
        clear_provider_handles(handles);
        return Err(TimerError::OwnershipInvariant);
    }
    match effect {
        RegistryEffect::None => restore_provider_handles(handles),
        RegistryEffect::ArmWakeup { token, arm, .. } => {
            if arm.replaces_existing() {
                let replaced = take_detached_or_owned_handle(handles.take_wakeup(), |registry| {
                    registry.take_wakeup_handle(token.identity())
                })?;
                if let Some(replaced) = replaced {
                    clear_provider_handle(replaced);
                }
            }
            restore_provider_handles(handles)?;
            arm_wakeup(effect)
        }
        RegistryEffect::ClearCallbacks {
            identity,
            handles: selected,
        } => {
            if selected.includes_wakeup() {
                let wakeup = take_detached_or_owned_handle(handles.take_wakeup(), |registry| {
                    registry.take_wakeup_handle(identity)
                })?;
                if let Some(wakeup) = wakeup {
                    clear_provider_handle(wakeup);
                }
            }
            if selected.includes_work() {
                let work = take_detached_or_owned_handle(handles.take_work(), |registry| {
                    registry.take_work_handle(identity)
                })?;
                if let Some(work) = work {
                    clear_provider_handle(work);
                }
            }
            restore_provider_handles(handles)
        }
        RegistryEffect::DispatchWatchdog { successor, .. } => {
            if let Some(wakeup) = handles.take_wakeup() {
                clear_provider_handle(wakeup);
            }
            let replaced_work = take_detached_or_owned_handle(handles.take_work(), |registry| {
                registry.take_work_handle(successor.identity())
            })?;
            if let Some(replaced_work) = replaced_work {
                clear_provider_handle(replaced_work);
            }
            dispatch_watchdog_effect(effect)
        }
    }
}

fn take_detached_or_owned_handle(
    detached: Option<ProviderHandle>,
    take_owned: impl FnOnce(&mut TimerRegistry) -> Option<ProviderHandle>,
) -> Result<Option<ProviderHandle>, TimerError> {
    detached.map_or_else(
        || with_registry_mut(|registry| Ok(take_owned(registry))),
        |handle| Ok(Some(handle)),
    )
}

fn arm_wakeup(effect: &RegistryEffect) -> Result<(), TimerError> {
    let RegistryEffect::ArmWakeup {
        token, delay_ns, ..
    } = effect
    else {
        return Err(TimerError::OwnershipInvariant);
    };
    let task_token = token.clone();
    let handle = platform::set_timer(Duration::from_nanos(*delay_ns), async move {
        dispatch_wakeup(task_token).await;
    });
    if let Err((error, handle)) = install_provider_handle(token, handle) {
        platform::clear_timer(handle);
        return Err(error);
    }
    if let Err(error) = confirm_effect(effect) {
        let handle = with_registry_mut(|registry| {
            registry
                .take_wakeup_handle(token.identity())
                .ok_or(TimerError::OwnershipInvariant)
        })?;
        clear_provider_handle(handle);
        return Err(error);
    }
    Ok(())
}

fn dispatch_watchdog_effect(effect: &RegistryEffect) -> Result<(), TimerError> {
    let RegistryEffect::DispatchWatchdog {
        successor,
        successor_delay_ns,
        work,
        ..
    } = effect
    else {
        return Err(TimerError::OwnershipInvariant);
    };
    let successor_token = successor.clone();
    let successor_handle =
        platform::set_timer(Duration::from_nanos(*successor_delay_ns), async move {
            dispatch_watchdog_scheduler(&successor_token);
        });
    if let Err((error, handle)) = install_provider_handle(successor, successor_handle) {
        platform::clear_timer(handle);
        return Err(error);
    }

    let work_token = work.clone();
    let work_handle = platform::set_timer(Duration::ZERO, async move {
        dispatch_watchdog_work(&work_token);
    });
    if let Err((error, handle)) = install_provider_handle(work, work_handle) {
        platform::clear_timer(handle);
        clear_entry_provider_handles(successor.identity())?;
        return Err(error);
    }
    if let Err(error) = confirm_effect(effect) {
        clear_entry_provider_handles(successor.identity())?;
        return Err(error);
    }
    Ok(())
}

fn install_provider_handle(
    token: &CallbackToken,
    handle: TimerHandle,
) -> Result<(), (TimerError, TimerHandle)> {
    #[cfg(test)]
    if take_provider_install_fault() {
        return Err((TimerError::OwnershipInvariant, handle));
    }
    RUNTIME.with(|runtime| {
        let Ok(mut runtime) = runtime.try_borrow_mut() else {
            return Err((TimerError::RuntimeBusy, handle));
        };
        let Some(registry) = runtime.as_mut() else {
            return Err((TimerError::NotInitialized, handle));
        };
        match registry.install_provider_handle(token, handle) {
            Ok(()) => Ok(()),
            Err((error, handle)) => Err((TimerError::from(error), handle)),
        }
    })
}

fn confirm_effect(effect: &RegistryEffect) -> Result<(), TimerError> {
    #[cfg(test)]
    if take_provider_confirmation_fault() {
        return Err(TimerError::OwnershipInvariant);
    }
    with_registry_mut(|registry| {
        registry
            .confirm_effect_applied(effect)
            .map_err(TimerError::from)
    })
}

fn restore_provider_handles(mut handles: ProviderHandles) -> Result<(), TimerError> {
    // Every detached linear capability must be restored or cleared even when
    // restoring an earlier handle fails.
    let wakeup_failure = handles
        .take_wakeup()
        .and_then(|handle| restore_provider_handle(handle).err());
    let work_failure = handles
        .take_work()
        .and_then(|handle| restore_provider_handle(handle).err());
    wakeup_failure.or(work_failure).map_or(Ok(()), Err)
}

fn restore_provider_handle(handle: ProviderHandle) -> Result<(), TimerError> {
    let (token, handle) = handle.into_parts();
    match install_provider_handle(&token, handle) {
        Ok(()) => Ok(()),
        Err((error, handle)) => {
            platform::clear_timer(handle);
            Err(error)
        }
    }
}

fn clear_provider_handle(handle: ProviderHandle) {
    let (_, handle) = handle.into_parts();
    platform::clear_timer(handle);
}

fn clear_provider_handles(mut handles: ProviderHandles) {
    if let Some(wakeup) = handles.take_wakeup() {
        clear_provider_handle(wakeup);
    }
    if let Some(work) = handles.take_work() {
        clear_provider_handle(work);
    }
}

fn clear_entry_provider_handles(identity: &TimerIdentity) -> Result<(), TimerError> {
    let handles = with_registry_mut(|registry| {
        Ok(ProviderHandles::from_parts(
            registry.take_wakeup_handle(identity),
            registry.take_work_handle(identity),
        ))
    })?;
    clear_provider_handles(handles);
    Ok(())
}

#[allow(clippy::future_not_send)] // IC callbacks and canister-local state are single-threaded.
async fn dispatch_wakeup(token: CallbackToken) {
    match token.role() {
        CallbackRole::OrdinaryWork => dispatch_ordinary(token).await,
        CallbackRole::WatchdogScheduler => dispatch_watchdog_scheduler(&token),
        CallbackRole::WatchdogWork => {}
    }
}

#[allow(clippy::future_not_send)] // IC callbacks and canister-local state are single-threaded.
async fn dispatch_ordinary(token: CallbackToken) {
    let measurement = CallbackMeasurementStart::capture();
    let accepted = with_registry_mut(|registry| {
        registry.consume_provider_handle(&token);
        Ok(registry.begin_ordinary(&token))
    });
    match accepted {
        Ok(CallbackAcceptance::Accepted) => {}
        Ok(CallbackAcceptance::Stale) => return,
        Err(error) => trap_callback_failure("ordinary callback acceptance", &error),
    }

    let callback = match with_registry(|registry| {
        registry.ordinary_callback(&token).map_err(TimerError::from)
    }) {
        Ok(callback) => callback,
        Err(TimerError::OwnershipInvariant) => {
            fail_ordinary_dispatch(&token);
            return;
        }
        Err(error) => trap_callback_failure("ordinary callback lookup", &error),
    };
    let future = {
        let Ok(mut callback) = callback.try_borrow_mut() else {
            fail_ordinary_dispatch(&token);
            return;
        };
        callback(token.clone())
    };
    let result = future.await;
    let transition = with_registry_mut(|registry| {
        registry
            .complete_ordinary(&token, platform::time_ns(), result)
            .map_err(TimerError::from)
    });
    let transition = transition
        .unwrap_or_else(|error| trap_callback_failure("ordinary callback completion", &error));
    finish_callback_transition(&token, transition, ProviderHandles::default());
    record_callback_measurements(&token, measurement.finish());
}

fn fail_ordinary_dispatch(token: &CallbackToken) {
    let transition = with_registry_mut(|registry| {
        registry
            .complete_ordinary(
                token,
                platform::time_ns(),
                TimerRunResult::new(TimerCompletion::invariant_failure(0), TimerDirective::Stop),
            )
            .map_err(TimerError::from)
    });
    let transition = transition.unwrap_or_else(|error| {
        trap_callback_failure("ordinary invariant-failure completion", &error)
    });
    finish_callback_transition(token, transition, ProviderHandles::default());
}

fn dispatch_watchdog_scheduler(token: &CallbackToken) {
    let measurement = CallbackMeasurementStart::capture();
    let transition = with_registry_mut(|registry| {
        registry.consume_provider_handle(token);
        Ok(registry.begin_watchdog_scheduler(token, platform::time_ns()))
    });
    let transition = transition
        .unwrap_or_else(|error| trap_callback_failure("watchdog scheduler transition", &error));
    let accepted = !matches!(transition.effect(), RegistryEffect::None);
    finish_callback_transition(token, transition, ProviderHandles::default());
    if accepted {
        record_callback_measurements(token, measurement.finish());
    }
}

fn dispatch_watchdog_work(token: &CallbackToken) {
    let measurement = CallbackMeasurementStart::capture();
    let accepted = with_registry_mut(|registry| {
        registry.consume_provider_handle(token);
        Ok(registry.begin_watchdog_work(token))
    });
    match accepted {
        Ok(CallbackAcceptance::Accepted) => {}
        Ok(CallbackAcceptance::Stale) => return,
        Err(error) => trap_callback_failure("watchdog work acceptance", &error),
    }

    let callback =
        match with_registry(|registry| registry.watchdog_callback(token).map_err(TimerError::from))
        {
            Ok(callback) => callback,
            Err(error) => trap_callback_failure("watchdog callback lookup", &error),
        };
    let result = {
        let Ok(mut callback) = callback.try_borrow_mut() else {
            trap_callback_failure(
                "watchdog callback ownership",
                &TimerError::OwnershipInvariant,
            );
        };
        callback(token.clone())
    };
    finish_watchdog_dispatch(token, result);
    record_callback_measurements(token, measurement.finish());
}

fn finish_watchdog_dispatch(token: &CallbackToken, result: WatchdogRunResult) {
    let claim = RegistrationClaim::from_callback(token);
    // Unlike synchronous public control, an unexpected callback-completion
    // failure must trap. IC message rollback restores these temporarily
    // detached heap capabilities while the previously committed successor
    // remains armed by the scheduler message.
    let completed = with_registry_mut(|registry| {
        let handles = registry
            .take_provider_handles_for_claim(&claim)
            .map_err(TimerError::from)?;
        #[cfg(test)]
        {
            if take_watchdog_completion_fault() {
                return Err(TimerError::OwnershipInvariant);
            }
        }
        let transition = registry
            .complete_watchdog_work(token, platform::time_ns(), result)
            .map_err(TimerError::from)?;
        Ok((transition, handles))
    });
    let (transition, handles) =
        completed.unwrap_or_else(|error| trap_callback_failure("watchdog work completion", &error));
    finish_callback_transition(token, transition, handles);
}

fn finish_callback_transition(
    token: &CallbackToken,
    transition: RegistryTransition,
    handles: ProviderHandles,
) {
    match finish_transition(transition, handles) {
        Ok(()) | Err(TimerError::ControlFailure(_)) => {}
        Err(
            error @ (TimerError::NotInitialized
            | TimerError::RuntimeBusy
            | TimerError::Register(_)
            | TimerError::Schedule(_)
            | TimerError::RegistrationExpired
            | TimerError::OwnershipInvariant
            | TimerError::ReconciliationConflict),
        ) => {
            if token.role() == CallbackRole::WatchdogWork {
                trap_callback_failure("watchdog provider-handle completion", &error);
            }
            fail_provider_binding(token).unwrap_or_else(|binding_error| {
                trap_callback_failure("provider-binding failure cleanup", &binding_error)
            });
        }
    }
}

fn fail_provider_binding(token: &CallbackToken) -> Result<(), TimerError> {
    let claim = RegistrationClaim::from_callback(token);
    fail_claim_provider_binding(&claim)
}

fn fail_claim_provider_binding(claim: &RegistrationClaim) -> Result<(), TimerError> {
    let failed = with_registry_mut(|registry| {
        registry
            .fail_registration(claim, TimerControlFailure::ProviderBindingFailed)
            .map_err(TimerError::from)
    });
    clear_provider_handles(failed?);
    Ok(())
}

#[derive(Clone, Copy)]
struct CallbackMeasurementStart {
    instructions_before: u64,
    memory_start: platform::MemoryPages,
}

impl CallbackMeasurementStart {
    fn capture() -> Self {
        // Keep page observation outside the established instruction interval.
        let memory_start = platform::memory_pages();
        let instructions_before = platform::instruction_counter();
        Self {
            instructions_before,
            memory_start,
        }
    }

    fn finish(self) -> CallbackMeasurement {
        // Close the instruction interval before taking its paired end extent.
        let instructions = platform::instruction_counter().saturating_sub(self.instructions_before);
        let memory_end = platform::memory_pages();
        CallbackMeasurement {
            instructions,
            memory_start: self.memory_start,
            memory_end,
        }
    }
}

#[derive(Clone, Copy)]
struct CallbackMeasurement {
    instructions: u64,
    memory_start: platform::MemoryPages,
    memory_end: platform::MemoryPages,
}

fn record_callback_measurements(token: &CallbackToken, measurement: CallbackMeasurement) {
    with_registry_mut(|registry| {
        registry
            .record_callback_measurements(
                token,
                measurement.instructions,
                measurement.memory_start,
                measurement.memory_end,
            )
            .map_err(TimerError::from)
    })
    .unwrap_or_else(|error| trap_callback_failure("callback measurement accounting", &error));
}

fn trap_callback_failure(context: &str, error: &TimerError) -> ! {
    platform::trap(&format!("ic-timers {context} failed: {error}"))
}

fn with_registry<T>(
    operation: impl FnOnce(&TimerRegistry) -> Result<T, TimerError>,
) -> Result<T, TimerError> {
    RUNTIME.with(|runtime| {
        let runtime = runtime.try_borrow().map_err(|_| TimerError::RuntimeBusy)?;
        let registry = runtime.as_ref().ok_or(TimerError::NotInitialized)?;
        operation(registry)
    })
}

fn with_registry_mut<T>(
    operation: impl FnOnce(&mut TimerRegistry) -> Result<T, TimerError>,
) -> Result<T, TimerError> {
    RUNTIME.with(|runtime| {
        let mut runtime = runtime
            .try_borrow_mut()
            .map_err(|_| TimerError::RuntimeBusy)?;
        let registry = runtime.as_mut().ok_or(TimerError::NotInitialized)?;
        operation(registry)
    })
}

#[cfg(test)]
fn reset_for_test(now_ns: u64, canister_version: u64) {
    platform::reset(now_ns, canister_version);
    WATCHDOG_COMPLETION_FAULT.with(|fault| fault.set(false));
    PROVIDER_INSTALL_FAULT_AFTER.with(|fault| fault.set(None));
    PROVIDER_CONFIRMATION_FAULT.with(|fault| fault.set(false));
    RUNTIME.with(|runtime| {
        *runtime.borrow_mut() = None;
    });
}

#[cfg(test)]
thread_local! {
    static WATCHDOG_COMPLETION_FAULT: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
    static PROVIDER_INSTALL_FAULT_AFTER: std::cell::Cell<Option<u64>> = const { std::cell::Cell::new(None) };
    static PROVIDER_CONFIRMATION_FAULT: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}

#[cfg(test)]
fn inject_watchdog_completion_fault() {
    WATCHDOG_COMPLETION_FAULT.with(|fault| fault.set(true));
}

#[cfg(test)]
fn take_watchdog_completion_fault() -> bool {
    WATCHDOG_COMPLETION_FAULT.with(|fault| fault.replace(false))
}

#[cfg(test)]
fn inject_provider_install_fault() {
    inject_provider_install_fault_after(0);
}

#[cfg(test)]
fn inject_provider_install_fault_after(successful_installs: u64) {
    PROVIDER_INSTALL_FAULT_AFTER.with(|fault| fault.set(Some(successful_installs)));
}

#[cfg(test)]
fn take_provider_install_fault() -> bool {
    PROVIDER_INSTALL_FAULT_AFTER.with(|fault| match fault.get() {
        Some(0) => {
            fault.set(None);
            true
        }
        Some(remaining) => {
            fault.set(Some(remaining - 1));
            false
        }
        None => false,
    })
}

#[cfg(test)]
fn inject_provider_confirmation_fault() {
    PROVIDER_CONFIRMATION_FAULT.with(|fault| fault.set(true));
}

#[cfg(test)]
fn take_provider_confirmation_fault() -> bool {
    PROVIDER_CONFIRMATION_FAULT.with(|fault| fault.replace(false))
}

#[cfg(test)]
mod tests;