// file: crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs
// version: 22

//! External public-surface proofs for the RAW transaction ingest Worker foundation.

#[test]
fn pre_003_kind_code_and_settings_are_consumable_from_crate_root() {
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE, "raw_transaction_ingest");
    let kind_result = ksp_worker_api::WorkerKindCode::new(ksp_worker_raw_transaction_ingest_lib::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE);
    assert!(kind_result.is_ok());
    let kind = match kind_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(kind.as_str(), "raw_transaction_ingest");
    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let worker_id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let settings = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings::with_defaults(network, worker_id);
    assert_eq!(settings.network().as_str(), "mainnet");
    assert_eq!(settings.worker_id().as_str(), "raw-ingest-mainnet-001");
    assert_eq!(settings.admission_queue_capacity(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY);
    assert_eq!(settings.persistence_concurrency(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY);
    assert_eq!(settings.shutdown_drain_timeout(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT);
    return;
}

#[test]
fn pre_003_invalid_network_and_worker_identity_remain_owned_by_lower_contracts() {
    let network = ksp_store_lib::RawNetworkId::new("");
    let worker_id = ksp_worker_api::WorkerId::new("invalid worker id");
    assert!(network.is_err());
    assert!(worker_id.is_err());
    let network_error = match network {
        std::result::Result::Ok(_) => return,
        std::result::Result::Err(value) => value,
    };
    assert_eq!(network_error.code(), ksp_store_lib::ERROR_CODE_RAW_MODEL_INVALID);
    let worker_error = match worker_id {
        std::result::Result::Ok(_) => return,
        std::result::Result::Err(value) => value,
    };
    assert_eq!(worker_error.code(), ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID);
    return;
}

#[test]
fn pre_003_runtime_bound_errors_are_stable_and_do_not_echo_values() {
    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let worker_id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let result = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings::new(network, worker_id, 0, 8, std::time::Duration::from_secs(5));
    assert!(result.is_err());
    let error = match result {
        std::result::Result::Ok(_) => return,
        std::result::Result::Err(value) => value,
    };
    assert_eq!(error.code(), ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_SETTINGS_INVALID);
    assert_eq!(error.message(), "invalid RAW transaction ingest Worker settings");
    assert_eq!(error.context().len(), 1);
    assert_eq!(error.context()[0].value(), "admission_queue_capacity");
    assert!(!std::format!("{error:?}").contains("raw-ingest-mainnet-001"));
    return;
}

#[test]
fn pre_004_start_handle_and_terminal_future_are_consumable_without_public_join_handle() {
    let _start: fn(
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings,
        std::sync::Arc<ksp_store_lib::Store>,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestWorker::start;
    let _request_stop: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle) -> bool =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::request_stop;
    let _wait_terminal: for<'a> fn(
        &'a ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestTerminalFuture<'a> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::wait_terminal;
    let root = include_str!("../src/lib.rs");
    assert!(!root.contains("JoinHandle"));
    assert!(!root.contains("JoinSet"));
    return;
}

#[test]
fn pre_007_store_and_content_conflict_error_codes_are_public_and_stable() {
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_CONTENT_CONFLICT.domain(), "worker_raw_transaction_ingest");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_CONTENT_CONFLICT.code(), "content_conflict");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_STORE_FAILED.domain(), "worker_raw_transaction_ingest");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_STORE_FAILED.code(), "store_failed");
    return;
}

#[test]
fn pre_008_snapshot_surface_and_common_projection_are_public_and_stable() {
    let _snapshot_source: fn(
        &ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::snapshot_source;
    let _worker_snapshot_source: fn(
        &ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::worker_snapshot_source;
    let _current: fn(
        &ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource::current;
    let _wait: for<'a> fn(
        &'a ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource,
        ksp_worker_api::WorkerSnapshotSequence,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotFuture<'a> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource::wait_for_change;
    fn require_worker_source<T: ksp_worker_api::WorkerSnapshotSource + std::marker::Send + std::marker::Sync>() {}
    require_worker_source::<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource>();
    let _state_type = std::any::type_name::<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState>();
    let _states = [
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Active,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Reconnecting,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Closing,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Closed,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSourceState::Failed,
    ];
    let _source_state = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_state;
    let _reconnect = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_reconnect_total;
    let _replay = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_replay_attempt_total;
    let _gap = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_continuity_gap_total;
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED.domain(), "worker_raw_transaction_ingest");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED.code(), "counter_exhausted");
    return;
}

#[test]
fn pre_009_source_and_drain_timeout_error_codes_are_public_and_stable() {
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_DRAIN_TIMEOUT.domain(), "worker_raw_transaction_ingest");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_DRAIN_TIMEOUT.code(), "drain_timeout");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_SOURCE_FAILED.domain(), "worker_raw_transaction_ingest");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_SOURCE_FAILED.code(), "source_failed");
    return;
}

#[test]
fn v0_3_12_pre_002_runtime_resource_types_are_consumable_without_client_escape_hatch() {
    let _source_new: fn(
        ksp_onchain_transport_lib::YellowstoneGrpcChannel,
        ksp_onchain_transport_lib::YellowstoneSubscribeRequest,
        ksp_onchain_transport_lib::HttpTransportPool,
        ksp_onchain_transport_lib::HttpRoleName,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestYellowstoneSource> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestYellowstoneSource::new;
    let _resources_new: fn(
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestYellowstoneSource,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::new;
    let _start_with_resources: fn(
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings,
        std::sync::Arc<ksp_store_lib::Store>,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestWorker::start_with_runtime_resources;
    let source = include_str!("../src/runtime_resources.rs");
    for forbidden in [
        "pub fn channel(",
        "pub fn http_pool(",
        "pub fn subscribe_request(",
        "pub fn hydration_role(",
        "pub fn enqueue(",
        "pub fn send(",
        "pub fn inner(",
    ] {
        assert!(!source.contains(forbidden), "runtime-resource implementation escape hatch present: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_13_pre_002_multi_source_runtime_resource_surface_is_bounded_and_source_neutral() {
    let _source_count: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources) -> usize =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::source_count;
    let _push_yellowstone: fn(
        &mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestYellowstoneSource,
    ) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_yellowstone_source;
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::MAX_RAW_TRANSACTION_INGEST_LIVE_SOURCES, 32);
    let root = include_str!("../src/lib.rs");
    assert!(!root.contains("RawTransactionIngestLiveSource"));
    assert!(!root.contains("source_key"));
    return;
}

#[test]
fn v0_3_13_pre_003_standard_logs_runtime_resource_surface_is_typed_and_transport_owned() {
    let _source_new: fn(
        ksp_onchain_transport_lib::WsEndpointSettings,
        ksp_onchain_transport_lib::SolanaLogsSubscribeFilter,
        ksp_onchain_transport_lib::SolanaCommitment,
        ksp_onchain_transport_lib::HttpTransportPool,
        ksp_onchain_transport_lib::HttpRoleName,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardLogsSource> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardLogsSource::new;
    let _resources_from_logs: fn(
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardLogsSource,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::from_standard_logs_source;
    let _push_logs: fn(
        &mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardLogsSource,
    ) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_standard_logs_source;
    let root = include_str!("../src/lib.rs");
    let resources = include_str!("../src/runtime_resources.rs");
    assert!(root.contains("RawTransactionIngestStandardLogsSource"));
    for forbidden in ["pub fn ws_endpoint(", "pub fn filter(", "pub fn http_pool(", "pub fn source_key("] {
        assert!(!resources.contains(forbidden), "standard logs source implementation escape hatch present: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_13_pre_005_helius_transaction_runtime_resource_surface_is_typed_and_transport_owned() {
    let _source_new: fn(
        ksp_onchain_transport_lib::WsEndpointSettings,
        ksp_onchain_transport_lib::HeliusTransactionSubscribeFilter,
        ksp_onchain_transport_lib::SolanaCommitment,
        ksp_onchain_transport_lib::HttpTransportPool,
        ksp_onchain_transport_lib::HttpRoleName,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHeliusTransactionSource> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHeliusTransactionSource::new;
    let _resources_from_helius: fn(
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHeliusTransactionSource,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::from_helius_transaction_source;
    let _push_helius: fn(
        &mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHeliusTransactionSource,
    ) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_helius_transaction_source;
    let root = include_str!("../src/lib.rs");
    let resources = include_str!("../src/runtime_resources.rs");
    assert!(root.contains("RawTransactionIngestHeliusTransactionSource"));
    for forbidden in ["pub fn ws_endpoint(", "pub fn filter(", "pub fn http_pool(", "pub fn source_key("] {
        assert!(!resources.contains(forbidden), "Helius transaction source implementation escape hatch present: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_13_pre_004_standard_block_runtime_resource_surface_is_typed_and_transport_owned() {
    let _source_new: fn(
        ksp_onchain_transport_lib::WsEndpointSettings,
        ksp_onchain_transport_lib::SolanaBlockSubscribeFilter,
        ksp_onchain_transport_lib::SolanaCommitment,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardBlockSource> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardBlockSource::new;
    let _resources_from_block: fn(
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardBlockSource,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::from_standard_block_source;
    let _push_block: fn(
        &mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestStandardBlockSource,
    ) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_standard_block_source;
    let root = include_str!("../src/lib.rs");
    let resources = include_str!("../src/runtime_resources.rs");
    assert!(root.contains("RawTransactionIngestStandardBlockSource"));
    for forbidden in ["pub fn ws_endpoint(", "pub fn filter(", "pub fn source_key("] {
        assert!(!resources.contains(forbidden), "standard block source implementation escape hatch present: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_13_pre_006_http_block_polling_runtime_resource_surface_is_bounded_and_transport_owned() {
    let _source_new: fn(
        ksp_onchain_transport_lib::HttpTransportPool,
        ksp_onchain_transport_lib::HttpRoleName,
        ksp_onchain_transport_lib::SolanaCommitment,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource::new;
    let _source_new_with_limits: fn(
        ksp_onchain_transport_lib::HttpTransportPool,
        ksp_onchain_transport_lib::HttpRoleName,
        ksp_onchain_transport_lib::SolanaCommitment,
        std::time::Duration,
        u16,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource::new_with_limits;
    let _resources_from_polling: fn(
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::from_http_block_polling_source;
    let _push_polling: fn(
        &mut ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources,
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHttpBlockPollingSource,
    ) -> ksp_core_lib::Result<()> = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestRuntimeResources::try_push_http_block_polling_source;
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_HTTP_POLL_INTERVAL, std::time::Duration::from_secs(1));
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_HTTP_POLL_MAX_BLOCKS_PER_CYCLE, 128);
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::MIN_RAW_TRANSACTION_INGEST_HTTP_POLL_INTERVAL, std::time::Duration::from_millis(100));
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::MAX_RAW_TRANSACTION_INGEST_HTTP_POLL_INTERVAL, std::time::Duration::from_secs(30));
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::MIN_RAW_TRANSACTION_INGEST_HTTP_POLL_MAX_BLOCKS_PER_CYCLE, 1);
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::MAX_RAW_TRANSACTION_INGEST_HTTP_POLL_MAX_BLOCKS_PER_CYCLE, 1024);
    let resources = include_str!("../src/runtime_resources.rs");
    for forbidden in ["pub fn http_pool(", "pub fn polling_role(", "pub fn source_key(", "pub fn profile_fingerprint("] {
        assert!(!resources.contains(forbidden), "HTTP polling source implementation escape hatch present: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_12_pre_007_processing_frontier_snapshot_getters_are_public_and_processing_only() {
    let _hydration_pending: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> usize =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::hydration_pending;
    let _processing_frontier_slot: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> std::option::Option<u64> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::processing_frontier_slot;
    let _oldest_pending_slot: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> std::option::Option<u64> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::oldest_pending_slot;
    let root = include_str!("../src/lib.rs");
    for forbidden in ["ReplayInfo", "from_slot", "repair", "backfill"] {
        assert!(!root.contains(forbidden), "pre.007 public root overclaims continuity/replay: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_13_pre_007_source_inventory_and_logical_keys_remain_private() {
    let root = include_str!("../src/lib.rs");
    for forbidden in ["RawTransactionIngestSourceInventory", "RawTransactionIngestSourceInventoryPublisher", "RawTransactionIngestLiveSource", "source_key"] {
        assert!(!root.contains(forbidden), "pre.007 private multi-source implementation leaked through crate root: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_13_pre_008_convergence_cache_registry_and_source_keys_remain_private() {
    let root = include_str!("../src/lib.rs");
    for forbidden in [
        "pub use self::persistence::RawTransactionIngestPersistenceConvergence",
        "pub use self::persistence::persist_raw_transaction_ingest_converged_acquisition",
        "RawTransactionIngestGlobalHydrationRegistry",
        "RawTransactionIngestHydrationKey",
        "source_key",
    ] {
        assert!(!root.contains(forbidden), "pre.008 convergence implementation leaked through public crate root: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_13_pre_009_fairness_budgets_semaphore_and_canonical_state_remain_private() {
    let root = include_str!("../src/lib.rs");
    for private_name in [
        "RawTransactionIngestCanonicalState",
        "RawTransactionIngestGlobalHydrationRegistry",
        "RawTransactionIngestHydrationLeaderGuard",
        "validate_hydration_fairness_capacity",
        "hydration_pending_limit",
        "hydration_in_flight_limit",
    ] {
        assert!(!root.contains(&std::format!("pub use self::runtime_resources::{private_name}")));
        assert!(!root.contains(&std::format!("pub use self::persistence::{private_name}")));
    }
    return;
}

#[test]
fn v0_3_13_pre_010_multi_source_snapshot_counts_are_public_and_source_neutral() {
    let _source_total: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> usize =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_total;
    let _source_active: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> usize =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_active;
    let _source_reconnecting: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> usize =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_reconnecting;
    let _source_failed: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot) -> usize =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot::source_failed;
    let root = include_str!("../src/lib.rs");
    for forbidden in ["SourceHealthByKey", "SourceSnapshotByKey", "provider_health", "endpoint_health"] {
        assert!(!root.contains(forbidden), "pre.010 public root leaked source-specific health material: {forbidden}");
    }
    return;
}

#[test]
fn v0_3_13_pre_011_race_hardening_adds_no_public_runtime_or_source_identity_surface() {
    let root = include_str!("../src/lib.rs");
    for forbidden in [
        "pub use self::runtime_resources::RawTransactionIngestSourceInventory",
        "pub use self::runtime_resources::RawTransactionIngestSourceInventoryPublisher",
        "pub use self::runtime_resources::RawTransactionIngestGlobalHydrationRegistry",
        "pub use self::runtime_resources::RawTransactionIngestHydrationLeaderGuard",
        "publish_and_remove",
        "source.inventory_key_mismatch",
    ] {
        assert!(!root.contains(forbidden), "pre.011 private race-hardening implementation leaked publicly: {forbidden}");
    }
    assert_eq!(
        ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED,
        ksp_core_lib::ErrorCode::new("worker_raw_transaction_ingest", "counter_exhausted")
    );
    assert_eq!(
        ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_DRAIN_TIMEOUT,
        ksp_core_lib::ErrorCode::new("worker_raw_transaction_ingest", "drain_timeout")
    );
    return;
}

#[test]
fn v0_3_13_pre_012_completeness_closure_adds_no_public_implementation_surface() {
    let root = include_str!("../src/lib.rs");
    assert!(!root.contains("pub mod "));
    for forbidden in [
        "pub use self::runtime_resources::RawTransactionIngestLiveSource",
        "pub use self::runtime_resources::RawTransactionIngestSourceInventory",
        "pub use self::runtime_resources::RawTransactionIngestGlobalHydrationRegistry",
        "pub use self::persistence::RawTransactionIngestCanonicalState",
        "pub use self::persistence::RawTransactionIngestPersistenceConvergence",
    ] {
        assert!(!root.contains(forbidden), "pre.012 private implementation leaked through public root: {forbidden}");
    }
    let cross_layer = include_str!("cross_layer_completeness.rs");
    assert!(cross_layer.contains("v0_3_13_pre_012_all_five_live_source_families_share_one_worker_common_raw_store_pipeline"));
    assert!(cross_layer.contains("v0_3_13_pre_012_legacy_v0_v1_is_proven_from_transport_through_worker_common_raw_to_store"));
    return;
}