nextest.toml

# nextest configuration — `cargo nextest run` reads this file.
# See https://nexte.st/docs/configuration/

[profile.default]
# Most mkit tests are sub-second; anything above 60 s is almost
# certainly a hang. Slow-test warnings fire at 10 s.
slow-timeout = { period = "10s", terminate-after = 6 }
# Don't retry on local runs — bugs should be reproducible, not papered
# over. CI overrides this in the `ci` profile below.
retries = 0
# Stop at the first failure when developing locally; CI overrides to
# surface the full failure surface.
fail-fast = true

[profile.ci]
# Surface every failure in one run on CI so we don't iterate through
# them one push at a time.
fail-fast = false
# Transient flakes in CI (network, fs latency) get one retry. A real
# bug fails twice; flakes succeed on the retry and are reported.
retries = 2
# Same slow-test envelope as default; CI machines vary so cap higher.
slow-timeout = { period = "30s", terminate-after = 4 }

[profile.ci.junit]
# Emit JUnit XML alongside the human-readable output so GitHub Actions
# can render failure annotations inline on PR diffs.
path = "junit.xml"

# The verification probe drives 500- and 3,000-file before/after packs and
# an extraction control. It exceeded 60 s on a loaded host; retain every
# fixture and assertion with a bounded envelope for this new probe alone.
[[profile.default.overrides]]
filter = 'package(mkit-server) and test(=indexed::job_tests::extraction_tests::verification_probe::verification_pipeline_round_probe)'
threads-required = "num-test-threads"
slow-timeout = { period = "180s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'package(mkit-server) and test(=indexed::job_tests::extraction_tests::verification_probe::verification_pipeline_round_probe)'
threads-required = "num-test-threads"
slow-timeout = { period = "180s", terminate-after = 1 }

# The 3,000-object scheduled latency comparison drives over 9,000 modeled
# alarm slices in its one-step baseline. Keep the full regression in both
# profiles with a ceiling that covers the measured ~235 s debug run.
[[profile.default.overrides]]
filter = 'package(mkit-server) and test(=chained_extract_steps_do_not_slow_large_packs_at_50ms)'
threads-required = "num-test-threads"
slow-timeout = { period = "600s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'package(mkit-server) and test(=chained_extract_steps_do_not_slow_large_packs_at_50ms)'
threads-required = "num-test-threads"
slow-timeout = { period = "600s", terminate-after = 1 }

# These extraction fixtures cross the 64 MiB multipart threshold, a raw
# read-window boundary, three lost-reply boundaries, or fifty cold delta
# reconstructions. Each has exceeded 60 s under parallel load. Keep the full
# fixtures and assertions in both execution modes, reserve the run's threads,
# and give only these exact tests the existing five-minute slow-test ceiling.
[[profile.default.overrides]]
filter = '''
package(mkit-server) and (
    test(=indexed::extract_tests::large_objects_use_parts_from_sixty_four_mebibytes)
    or test(=indexed::job_tests::extraction_tests::geometry_tests::compressed_exact_blob_crossing_read_window_matches_inline_and_preservation)
    or test(=indexed::job_tests::extraction_tests::multipart_lost_replies_at_begin_part_and_completion_resume_same_session)
    or test(=indexed::job_tests::fifty_in_pack_deltas_keep_cold_slice_progress_and_call_budget)
)
'''
threads-required = "num-test-threads"
slow-timeout = { period = "300s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = '''
package(mkit-server) and (
    test(=indexed::extract_tests::large_objects_use_parts_from_sixty_four_mebibytes)
    or test(=indexed::job_tests::extraction_tests::geometry_tests::compressed_exact_blob_crossing_read_window_matches_inline_and_preservation)
    or test(=indexed::job_tests::extraction_tests::multipart_lost_replies_at_begin_part_and_completion_resume_same_session)
    or test(=indexed::job_tests::fifty_in_pack_deltas_keep_cold_slice_progress_and_call_budget)
)
'''
threads-required = "num-test-threads"
slow-timeout = { period = "300s", terminate-after = 1 }

# The fused-chunk walk call table decodes 150 MiB of staged fixture in the
# unoptimized build: ~371 s measured alone. CPU-bound, not a hang — reserve
# the run's threads and keep the ceiling near 2.5x the measurement.
[[profile.default.overrides]]
filter = 'package(mkit-server) and test(=indexed::job_tests::extraction_tests::budget_tests::staged_chunks_fuse_their_reads_at_150_mib)'
threads-required = "num-test-threads"
slow-timeout = { period = "450s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'package(mkit-server) and test(=indexed::job_tests::extraction_tests::budget_tests::staged_chunks_fuse_their_reads_at_150_mib)'
threads-required = "num-test-threads"
slow-timeout = { period = "450s", terminate-after = 1 }

# The 64-chunk fused call table decodes ~17 MiB of staged fixture twice
# (PREFLIGHT and UPLOAD): ~18 s alone in the unoptimized build, but the
# suite's own parallelism pushed it past the default 60 s kill. CPU-bound,
# not a hang — same 120 s envelope as the fused-walk regressions below.
[[profile.default.overrides]]
filter = 'package(mkit-server) and test(=indexed::job_tests::extraction_tests::budget_tests::staged_chunks_fuse_into_one_remote_round_per_chunk)'
slow-timeout = { period = "120s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'package(mkit-server) and test(=indexed::job_tests::extraction_tests::budget_tests::staged_chunks_fuse_into_one_remote_round_per_chunk)'
slow-timeout = { period = "120s", terminate-after = 1 }

# The fused-walk crash/loss/block regressions drive two or more full
# extractions of a multi-chunk fixture; under MKIT_TEST_EXTRACT_CHAIN=1 each
# chunk is its own slice, so a loaded shared machine pushes them past the
# default 60s kill. None hangs — the same 2x ceiling as the other loaded
# debug-build suites.
[[profile.default.overrides]]
filter = 'package(mkit-server) and test(/indexed::job_tests::extraction_tests::budget_tests::a_(crash_between_fused_chunks|lost_part_reply_in_a_fused_slice|pack_block_mid_fused_slice|pack_block_at_a_fused_part_boundary|fused_walk_slice_protects_once|lost_source_lease_before_the_part_upload)/)'
slow-timeout = { period = "120s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'package(mkit-server) and test(/indexed::job_tests::extraction_tests::budget_tests::a_(crash_between_fused_chunks|lost_part_reply_in_a_fused_slice|pack_block_mid_fused_slice|pack_block_at_a_fused_part_boundary|fused_walk_slice_protects_once|lost_source_lease_before_the_part_upload)/)'
slow-timeout = { period = "120s", terminate-after = 1 }

# The bounded PR run of the stateful suite (tests/state_machine.rs, 32 cases)
# is ~12s locally, but it spawns the `mkit` binary per op, so a slow/loaded
# (especially macOS) runner could drift toward the default 60s / ci 120s kill
# envelope and spuriously fail. It is NOT a hang — give just this test a
# generous per-test ceiling in the PR profiles. The nightly deep run uses the
# `state-machine` profile instead.
[[profile.default.overrides]]
filter = 'test(=stateful_invariants)'
slow-timeout = { period = "300s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'test(=stateful_invariants)'
slow-timeout = { period = "300s", terminate-after = 1 }

# This preservation progress regression restores the checkpoint on every
# eight-row page across 51 dense member lookups (up to 26,112 ticks). Its
# measured debug run takes 62s; retain the full continuation/hash assertions
# and run this exact test alone with a bounded allowance under machine load.
[[profile.default.overrides]]
filter = 'package(mkit-server) and test(=takedown::source::tests::dense_external_fifty_hops_complete_and_final_decode_rechecks_membership)'
threads-required = "num-test-threads"
slow-timeout = { period = "300s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'package(mkit-server) and test(=takedown::source::tests::dense_external_fifty_hops_complete_and_final_decode_rechecks_membership)'
threads-required = "num-test-threads"
slow-timeout = { period = "300s", terminate-after = 1 }

# The fault-injection suites reconstruct many on-disk crash images and
# spawn N concurrent mutators, so each spawns the binary a lot. Deterministic,
# not hangs — give the crash-recovery and lock-contention binaries the same
# generous per-test ceiling so a slow/loaded (especially macOS) runner can't
# kill them under the default 60s / ci 120s envelope.
[[profile.default.overrides]]
filter = 'binary(crash_recovery) or binary(lock_contention)'
slow-timeout = { period = "300s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'binary(crash_recovery) or binary(lock_contention)'
slow-timeout = { period = "300s", terminate-after = 1 }

# branch_rename_commit_race races a real rename against a real concurrent
# commit and asserts the outcome. It runs with no other test beside it.
# The sweep is one pass of 12 rounds and the calibration delay is capped,
# so a loaded start cannot inflate the sleeps into the old 150s kill.
# The ceiling stays above a loaded serialized run; it is not a hang.
[[profile.default.overrides]]
filter = 'binary(branch_rename_commit_race)'
threads-required = "num-test-threads"
slow-timeout = { period = "150s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'binary(branch_rename_commit_race)'
threads-required = "num-test-threads"
slow-timeout = { period = "150s", terminate-after = 1 }

# 80,000-row SQLite backup. Wall time is 2.5s alone and 12s beside other
# tests (-j4); the 5s check is opt-in (MKIT_BACKUP_TIMING). Run it with no
# other test beside it so that check, and the always-on ceiling, see the
# backup's own cost.
[[profile.default.overrides]]
filter = 'test(=backup::tests::sqlite_eighty_thousand_small_rows_at_cap_under_five_seconds)'
threads-required = "num-test-threads"
slow-timeout = { period = "180s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'test(=backup::tests::sqlite_eighty_thousand_small_rows_at_cap_under_five_seconds)'
threads-required = "num-test-threads"
slow-timeout = { period = "180s", terminate-after = 1 }

# The 10,000-object inspection fixture repeatedly copies a growing in-memory
# partition during verification. It passed in 41s on Linux but exceeded the
# default 60s ceiling under load. Reserve this run's threads and allow three
# minutes in both profiles, retaining the full object set and assertions.
[[profile.default.overrides]]
filter = 'package(mkit-server) and test(=pipeline::tests::indexed::inspection::exactly_ten_thousand_distinct_file_objects_are_inspected_and_accepted)'
threads-required = "num-test-threads"
slow-timeout = { period = "60s", terminate-after = 3 }

[[profile.ci.overrides]]
filter = 'package(mkit-server) and test(=pipeline::tests::indexed::inspection::exactly_ten_thousand_distinct_file_objects_are_inspected_and_accepted)'
threads-required = "num-test-threads"
slow-timeout = { period = "60s", terminate-after = 3 }

# The six-group reuse proof completes 42 real 256-member lookup jobs. It takes
# 47-53s alone but exceeded 60s in the suite on the shared machine. Retain all
# 10,752 lookup assertions, reserve this run's threads and use CI's 120s ceiling.
[[profile.default.overrides]]
filter = 'test(=indexed::job_tests::scheduled_reclaim_tests::completed_groups_with_full_member_lists_remain_claimable)'
threads-required = "num-test-threads"
slow-timeout = { period = "30s", terminate-after = 4 }

[[profile.ci.overrides]]
filter = 'test(=indexed::job_tests::scheduled_reclaim_tests::completed_groups_with_full_member_lists_remain_claimable)'
threads-required = "num-test-threads"
slow-timeout = { period = "30s", terminate-after = 4 }

# CPU-bound debug-build tests that the suite's own parallelism pushes past
# the default 60s. Named one by one: each took 40s or more in a full
# `cargo nextest run --workspace --all-features` in WP-M0-20's quiet-machine
# runs (10-core M1 Pro, nothing else building), measured under a 600s
# ceiling on this branch and on `main`; every other test in these modules
# keeps the 60s (ci: 120s) hang detection.
#   history::ancestry, the 4 scrub/full-walk tests      20-23s alone; 117-123s
#                                                       in the suite (TIMEOUT)
#   history::ancestry, the other scrub tests            40-64s in the suite
#   scrub_age_boundary_is_exclusive                     two 600-leaf publishes; >60s alone under load
#   refs::tests::cas_{match,delete_vs_match}_* races    44-73s in the suite
#   batch_write_hash_equals_store_write_hash            8s alone; 88-90s (TIMEOUT)
#   write_parts_equals_concatenated_write               38-48s in the suite
#   mkit-cli verify_new_object_signatures_mixed_*       11.5s alone; 56-60s (TIMEOUT)
#   pack::window generated_valid_and_mutated_packs_agree  ~48s alone (pack-ruzstd); 60s under -j 4 (TIMEOUT)
#   pack delta_bomb_is_rejected_before_any_delta_is_applied  50-60s alone (pack-ruzstd)
# None hangs: each walks, hashes or verifies a large fixture in an
# unoptimized build and is starved of CPU by the other test threads. They
# get 300s, about 2.4x the worst measured. That margin was calibrated on an
# M1 Pro, not on the CI machines.
[[profile.default.overrides]]
filter = '''
package(mkit-core) and (
    test(=history::ancestry::tests::corruption_outside_the_current_window_is_caught_within_a_bounded_number_of_publishes)
    or test(=history::ancestry::tests::fast_forward_scrubs_a_bounded_window_not_the_whole_prefix)
    or test(=history::ancestry::tests::full_walk_fallback_still_verifies_the_spliced_prefix)
    or test(=history::ancestry::tests::missing_scrub_state_forces_a_full_walk_instead_of_trusting_nothing)
    or test(=history::ancestry::tests::scrub_lap_completion_forces_a_full_walk_but_keeps_the_generation)
    or test(=history::ancestry::tests::scrub_state_from_a_superseded_generation_is_discarded_not_misapplied)
    or test(=history::ancestry::tests::stale_scrub_state_forces_a_full_walk_regardless_of_cursor_position)
    or test(=history::ancestry::tests::scrub_age_boundary_is_exclusive)
    or test(=refs::tests::cas_delete_vs_match_advance_race_never_lets_both_win_or_loses_the_advance)
    or test(=refs::tests::cas_match_race_never_loses_an_update_across_uncoordinated_callers)
    or test(=batch::tests::batch_write_hash_equals_store_write_hash)
    or test(=batch::tests::write_parts_equals_concatenated_write)
    or test(=pack::window::tests::generated_valid_and_mutated_packs_agree)
    or test(=pack::tests::delta_bomb_is_rejected_before_any_delta_is_applied)
)
or (package(mkit-cli) and test(=remote_dispatch::packmap::tests::verify_new_object_signatures_mixed_with_unsigned_object_kinds))
'''
slow-timeout = { period = "60s", terminate-after = 5 }

[[profile.ci.overrides]]
filter = '''
package(mkit-core) and (
    test(=history::ancestry::tests::corruption_outside_the_current_window_is_caught_within_a_bounded_number_of_publishes)
    or test(=history::ancestry::tests::fast_forward_scrubs_a_bounded_window_not_the_whole_prefix)
    or test(=history::ancestry::tests::full_walk_fallback_still_verifies_the_spliced_prefix)
    or test(=history::ancestry::tests::missing_scrub_state_forces_a_full_walk_instead_of_trusting_nothing)
    or test(=history::ancestry::tests::scrub_lap_completion_forces_a_full_walk_but_keeps_the_generation)
    or test(=history::ancestry::tests::scrub_state_from_a_superseded_generation_is_discarded_not_misapplied)
    or test(=history::ancestry::tests::stale_scrub_state_forces_a_full_walk_regardless_of_cursor_position)
    or test(=history::ancestry::tests::scrub_age_boundary_is_exclusive)
    or test(=refs::tests::cas_delete_vs_match_advance_race_never_lets_both_win_or_loses_the_advance)
    or test(=refs::tests::cas_match_race_never_loses_an_update_across_uncoordinated_callers)
    or test(=batch::tests::batch_write_hash_equals_store_write_hash)
    or test(=batch::tests::write_parts_equals_concatenated_write)
    or test(=pack::window::tests::generated_valid_and_mutated_packs_agree)
    or test(=pack::tests::delta_bomb_is_rejected_before_any_delta_is_applied)
)
or (package(mkit-cli) and test(=remote_dispatch::packmap::tests::verify_new_object_signatures_mixed_with_unsigned_object_kinds))
'''
slow-timeout = { period = "60s", terminate-after = 5 }

# The storage suite over the `.mkit`-layout stores makes every write durable
# (fsync the file, rename, fsync the directory): a few cases apply 1,000-2,000
# single-key batches, ~40s each on a loaded macOS runner (F_FULLFSYNC). Not
# hangs; the same generous ceiling as the other real-I/O suites.
[[profile.default.overrides]]
filter = 'binary(fs_backends)'
slow-timeout = { period = "150s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'binary(fs_backends)'
slow-timeout = { period = "150s", terminate-after = 1 }

# The wire suite's growth case waits out replay expiry plus the server's
# prune grace on the real clock (~80s; so do its store mutants):
# pruning never follows the test-faults clock skew. The host ticket case
# waits this interval twice (~160s) to settle before calibration and prune
# after loading tickets. Not a hang.
[[profile.default.overrides]]
filter = '(binary(baseline_pipeline_memory) and (test(=pipeline_auth_v2_test_faults) or test(/_fails_growth$/))) or test(=timer_and_ticket_pruning_wire_cases_run_against_the_host) or test(=native_replay_and_quota_pruning)'
slow-timeout = { period = "180s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = '(binary(baseline_pipeline_memory) and (test(=pipeline_auth_v2_test_faults) or test(/_fails_growth$/))) or test(=timer_and_ticket_pruning_wire_cases_run_against_the_host) or test(=native_replay_and_quota_pruning)'
slow-timeout = { period = "180s", terminate-after = 1 }

# This pack residency regression expands several 128 MiB delta targets.
# Its debug CPU work takes about 26 s alone, so allow shared-machine load
# without classifying the bounded decode as a hang.
[[profile.default.overrides]]
filter = 'test(=pack::tests::compressed_delta_bomb_releases_targets_and_checks_cap_before_allocation)'
slow-timeout = { period = "300s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'test(=pack::tests::compressed_delta_bomb_releases_targets_and_checks_cap_before_allocation)'
slow-timeout = { period = "300s", terminate-after = 1 }

# The unchanged async wire fixture hashes 720 entries across three raw windows.
# Its new native debug host takes about 77 seconds. Keep both hold settings,
# the full fixture and the wire case's 240-poll window; reserve the test threads.
[[profile.default.overrides]]
filter = 'binary(=test_host_migrations) and (test(=native_async_verification) or test(=native_async_verification_with_hold))'
threads-required = "num-test-threads"
slow-timeout = { period = "240s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'binary(=test_host_migrations) and (test(=native_async_verification) or test(=native_async_verification_with_hold))'
threads-required = "num-test-threads"
slow-timeout = { period = "240s", terminate-after = 1 }

# The unchanged 10,000-ref HTTP listing has its own test window so broad
# Single-profile cases do not consume that window first. Reserve threads;
# retain each profile's existing timeout instead of extending the deadline.
[[profile.default.overrides]]
filter = 'binary(=test_host_migrations) and test(=native_single_large_listing)'
threads-required = "num-test-threads"

[[profile.ci.overrides]]
filter = 'binary(=test_host_migrations) and test(=native_single_large_listing)'
threads-required = "num-test-threads"

# Memory-bounding tests. multipart_bounded_heap / multipart_buffered_heap
# (mkit-server-conformance's fs and memory binaries) meter the allocator
# over a window and assert a peak.
# They failed under parallel load and passed alone (#1210, #1212, #1218), so
# the group runs one at a time across the whole run. The meter stays
# process-global (the store work runs on runtime threads, so it can't be
# narrowed to the test's own thread); serialization is the fix, no test change.
[test-groups]
heap-bounds = { max-threads = 1 }

[[profile.default.overrides]]
filter = 'test(/multipart_(bounded|buffered)_heap$/) | test(=corrupt_zstd_frames_bound_heap) | test(=scheduled_ruzstd_slice_retains_at_most_48_mib_requested_heap) | binary(=takedown_acquisition_bounds)'
test-group = 'heap-bounds'

[[profile.ci.overrides]]
filter = 'test(/multipart_(bounded|buffered)_heap$/) | test(=corrupt_zstd_frames_bound_heap) | test(=scheduled_ruzstd_slice_retains_at_most_48_mib_requested_heap) | binary(=takedown_acquisition_bounds)'
test-group = 'heap-bounds'

[profile.ignored-lane]
# #505 PR 5/5: a handful of irreducibly-real tests (subprocess sleeps,
# real localhost TCP, the ~5s worktree-lock wait, a real `ssh` connect
# attempt to 127.0.0.1:22) were quarantined behind `#[ignore]` instead
# of determinized. This profile is the single source of truth for
# which quarantined tests the serial ignored-only CI lane runs — both
# rust.yml and cloudbuild/ci.yaml invoke
# `cargo nextest run --profile ignored-lane --run-ignored ignored-only`
# instead of duplicating this test-name filter inline in two YAML files.
#
# Scoped by an explicit test-name filter rather than a blanket
# `--run-ignored ignored-only`: this workspace also has PRE-EXISTING
# `#[ignore]`d tests (native-keystore backends gated on
# MKIT_RUN_NATIVE_KEYSTORE_TESTS, the real-ssh e2e suite gated on
# MKIT_SSH_E2E_REAL) that are NOT provisioned on CI runners. The
# keystore tests in particular panic outright when their gate is unset
# (`assert!(!require_backend, ...)` in mkit-keystore's native_list.rs)
# rather than skipping quietly, so a blanket ignored-only run would
# fail regardless of MKIT_TEST_STRICT. Naming exactly the tests this
# PR quarantined keeps the lane green regardless of what other
# `#[ignore]`d tests exist.
#
default-filter = 'test(/hang_before_stdout_times_out_and_reaps_child|fills_stderr_before_stdout_does_not_deadlock|valid_response_then_never_exits_is_bounded|open_accepts_syntactically_valid_mkit_ssh_url|second_mutating_command_blocks_on_worktree_lock|list_refs_round_trip_over_real_tcp|post_handshake_idle_timeout_drops_silent_peer|wait_child_timeout_kills_stalled_child|list_refs_retries_past_dropped_connection_via_reconnect|ssh_clone_retries_past_a_dropped_first_connection|large_mixed_pack_decodes_under_production_resident_cap|listing_over_32_mib_pages_under_d34|continuation_pages_complete_long_changing_histories_without_cursor_walk|decode_inventory_3000_objects_at_50ms/)'
# Run serially so the quarantined tests' real timers/sockets don't
# contend with each other; only localhost networking is needed, which
# every CI runner (Linux + macOS) provides.
test-threads = 1

# Real uploads build 201/302 changing commits, then validate 200 page/latency
# cases. Alone, the debug test used 13.10s CPU and 14.17s wall; the parallel
# Cloud Build lane exceeded 60s. Keep every assertion, run it serially here,
# and retain a bounded ceiling for loaded runners. The default 40-commit
# case uses the same assertions over four/six pages in every configuration.
[[profile.ignored-lane.overrides]]
filter = 'package(mkit-server) and test(=pipeline::tests::http_objects::history_tests::continuation_tests::continuation_pages_complete_long_changing_histories_without_cursor_walk)'
slow-timeout = { period = "300s", terminate-after = 1 }

# The pack residency regression decodes more than 200 MiB on the wire and
# verifies all stored objects. Its measured debug run exceeds 30 seconds,
# so run it serially with a bounded ceiling for slower shared-machine runs.
[[profile.ignored-lane.overrides]]
filter = 'test(=pack::tests::large_mixed_pack_decodes_under_production_resident_cap)'
slow-timeout = { period = "300s", terminate-after = 1 }

# The admitted maximum-wire chain includes roughly five million legal empty
# zstd blocks. Pure-Rust admission plus acquisition takes ~42 s locally;
# allow shared-machine headroom while retaining all heap/canonical assertions.
[[profile.default.overrides]]
filter = 'test(=scheduled_bounds_fifty_hops_with_maximum_wire_frame)'
slow-timeout = { period = "120s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = 'test(=scheduled_bounds_fifty_hops_with_maximum_wire_frame)'
slow-timeout = { period = "120s", terminate-after = 1 }

[profile.state-machine]
# Nightly deep run of the stateful invariant suite
# (tests/state_machine.rs). It drives the real `mkit` binary through
# hundreds of randomly-generated op sequences (PROPTEST_CASES=512), so a
# single test legitimately runs for many minutes — far past the default
# 60s / ci 120s slow-test kill envelope. Give it a generous ceiling
# rather than treating the long runtime as a hang. (The bounded PR run on
# the default/ci profiles gets its own, smaller, per-test override above.)
slow-timeout = { period = "1200s", terminate-after = 1 }
retries = 0
fail-fast = false

# The memory-host 75,000-ref listing creates its refs over real HTTP
# and drains D34 timers to index them: minutes, not a hang.
[[profile.ignored-lane.overrides]]
filter = 'test(=listing_over_32_mib_pages_under_d34)'
slow-timeout = { period = "1800s", terminate-after = 1 }

# Full Decode and subsequent verification over 3,000 objects at modeled 50 ms I/O.
[[profile.ignored-lane.overrides]]
filter = 'binary(=inventory_stage_guard) and test(=decode_inventory_3000_objects_at_50ms)'
slow-timeout = { period = "300s", terminate-after = 1 }

# These new regressions exercise the full 128 MiB listing budget, including
# real loopback HTTP. Reserve the run's threads to avoid overlapping their
# large fixtures with other suites.
[[profile.default.overrides]]
filter = '(package(mkit-client) or package(mkit-sync) or package(mkit-transport-connect)) and test(shared_listing_adversaries)'
threads-required = "num-test-threads"
slow-timeout = { period = "300s", terminate-after = 1 }

[[profile.ci.overrides]]
filter = '(package(mkit-client) or package(mkit-sync) or package(mkit-transport-connect)) and test(shared_listing_adversaries)'
threads-required = "num-test-threads"
slow-timeout = { period = "300s", terminate-after = 1 }