Datasets:

Larrivhan
/

NeCast-simulations

from __future__ import annotations

import gzip
import hashlib
import json
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

import pytest

from simulator.config import Config
from simulator.dataset_state import SAMPLE_GENERATOR_SCHEMA_VERSION, generation_config_state
from simulator import replacement as v1
from simulator import replacement_pool as pool


GENERATION_PLAN_SHA = "9" * 64


def _canonical(value: object) -> str:
    return hashlib.sha256(
        json.dumps(
            value,
            ensure_ascii=False,
            allow_nan=False,
            sort_keys=True,
            separators=(",", ":"),
        ).encode("utf-8")
    ).hexdigest()


def _write_json(path: Path, value: dict) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(value), encoding="utf-8")


def _file_record(path: Path) -> dict:
    return {
        "size_bytes": path.stat().st_size,
        "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
    }


def _source_plan(root: Path, *, n_samples: int, seed: int) -> dict:
    config = Config(
        preset="full_v01",
        n_samples=n_samples,
        seed=seed,
        shard_size=2,
        compute_chunk_size=1,
        out_dir=str(root),
        workers=1,
    )
    state = generation_config_state(config)
    layout = {
        "n_samples": n_samples,
        "shard_size": 2,
        "compute_chunk_size": 1,
        "n_shards": (n_samples + 1) // 2,
        "n_chunks": n_samples,
        "sample_id_rule": "sim_{global_sample_index:08d}",
        "seed_rule": "config.seed + global_sample_index * 7919",
        "partition_rule": "chunk_idx_mod_world_size",
        "array_schema_version": SAMPLE_GENERATOR_SCHEMA_VERSION,
    }
    plan = {
        "schema_version": 1,
        "kind": "dlcoalsim_generation_plan",
        "sample_generation_config": state,
        "layout": layout,
        "layout_sha256": _canonical(layout),
        "empirical_maps_sha256": hashlib.sha256(b"maps").hexdigest(),
        "empirical_ne_templates_sha256": hashlib.sha256(b"templates").hexdigest(),
        "runtime_environment_sha256": hashlib.sha256(b"runtime").hexdigest(),
    }
    plan["plan_sha256"] = _canonical(plan)
    _write_json(root / "samples" / "PLAN.json", plan)
    return plan


def _source_fragment(root: Path, plan: dict, index: int) -> None:
    shard = index // 2
    relative = f"samples/.fragments/fragment_{index:08d}.npz"
    npz = root / relative
    metadata = npz.with_suffix(".jsonl.gz")
    npz.parent.mkdir(parents=True, exist_ok=True)
    npz.write_bytes(f"source-npz-{index}".encode())
    metadata.write_bytes(f"source-meta-{index}".encode())
    receipt = {
        "schema_version": 1,
        "plan_sha256": plan["plan_sha256"],
        "result": {
            "chunk_idx": index,
            "shard_idx": shard,
            "start": index,
            "n_samples": 1,
            "fragment_path": relative,
        },
        "files": {
            "npz": _file_record(npz),
            "metadata_jsonl_gz": _file_record(metadata),
        },
    }
    receipt["receipt_sha256"] = _canonical(receipt)
    _write_json(
        root
        / "samples"
        / ".fragments"
        / f"fragment_{index:08d}.done.json",
        receipt,
    )


def _patch_generator(
    monkeypatch: pytest.MonkeyPatch,
    output: Path,
    runtime_sha256: str,
) -> list[list[str]]:
    calls: list[list[str]] = []
    monkeypatch.setattr(
        v1,
        "_runtime_probe",
        lambda root, python: {
            "simulator_file": str(root / "simulator" / "__init__.py"),
            "runtime_environment_sha256": runtime_sha256,
        },
    )

    def fake_run(
        root,
        python,
        arguments,
        *,
        module=True,
        capture_output=True,
    ):
        calls.append(list(arguments))
        if "--prepare-only" in arguments:
            _write_json(output / "samples" / "PLAN.json", {"test": True})
        return type(
            "Completed",
            (),
            {"returncode": 0, "stdout": "", "stderr": ""},
        )()

    monkeypatch.setattr(v1, "_run_generator_subprocess", fake_run)
    monkeypatch.setattr(
        v1,
        "_validate_replacement_generation_plan",
        lambda out, config, source: {
            "plan_sha256": GENERATION_PLAN_SHA,
            **dict(source),
        },
    )
    return calls


def _prepare(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    *,
    name: str = "case",
    n_samples: int = 5,
    completed: int = 2,
    candidate_count: int = 5,
) -> tuple[Path, Path, dict, list[list[str]]]:
    source = tmp_path / f"{name}-source"
    source_plan = _source_plan(source, n_samples=n_samples, seed=100)
    for index in range(completed):
        _source_fragment(source, source_plan, index)
    output = tmp_path / f"{name}-pool"
    calls = _patch_generator(
        monkeypatch, output, source_plan["runtime_environment_sha256"]
    )
    generator_root = tmp_path / f"{name}-generator"
    (generator_root / "simulator").mkdir(parents=True)
    (generator_root / "simulator" / "__init__.py").write_text("")
    generator_python = tmp_path / f"{name}-python"
    generator_python.write_text("")
    plan = pool.prepare_pool(
        [source],
        target_total=n_samples,
        candidate_count=candidate_count,
        out_dir=output,
        generator_root=generator_root,
        generator_python=generator_python,
    )
    return output, source, plan, calls


def _candidate_fragment(
    output: Path,
    plan: dict,
    index: int,
    *,
    seed: int | None = None,
) -> None:
    expected = plan["candidates"][index]
    npz = output / expected["npz_path"]
    metadata = output / expected["metadata_path"]
    receipt_path = output / expected["receipt_path"]
    npz.parent.mkdir(parents=True, exist_ok=True)
    npz.write_bytes(f"candidate-npz-{index}".encode())
    with gzip.open(metadata, "wt", encoding="utf-8") as handle:
        handle.write(
            json.dumps(
                {
                    "sample_id": expected["expected_sample_id"],
                    "sample_index": index,
                    "seed": expected["seed"] if seed is None else seed,
                    # These fields must never participate in pool selection.
                    "target": [999],
                    "n_variants": 999,
                    "demography_type": "ignored",
                }
            )
            + "\n"
        )
    receipt = {
        "schema_version": 1,
        "plan_sha256": plan["generation_plan_sha256"],
        "result": {
            "chunk_idx": index,
            "shard_idx": expected["shard_index"],
            "start": index,
            "n_samples": 1,
            "fragment_path": expected["npz_path"],
        },
        "files": {
            "npz": _file_record(npz),
            "metadata_jsonl_gz": _file_record(metadata),
        },
    }
    receipt["receipt_sha256"] = _canonical(receipt)
    _write_json(receipt_path, receipt)


def test_k3_c5_freezes_out_of_order_prefix_and_late_is_immutable(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    output, _, plan, _ = _prepare(tmp_path, monkeypatch)
    assert plan["required_k"] == 3
    assert plan["candidate_count"] == 5
    assert plan["candidate_config"]["n_samples"] == 5
    assert plan["candidate_config"]["compute_chunk_size"] == 1
    assert plan["candidate_config"]["workers"] == 1
    assert plan["candidate_groups"]["primary"]["candidate_indices"] == [0, 1, 2]
    assert plan["candidate_groups"]["standby"]["candidate_indices"] == [3, 4]

    for index in (4, 1, 3):
        _candidate_fragment(output, plan, index)
        result = pool.register_candidate(output, index)
    assert result["selection_frozen"] is True

    selection_path = output / pool.SELECTION_NAME
    before = selection_path.read_bytes()
    selection = json.loads(before)
    assert selection["selected_candidate_indices"] == [4, 1, 3]
    assert selection["registration_cutoff_ordinal"] == 3
    assert [item["registration_ordinal"] for item in selection["selected_candidates"]] == [
        1,
        2,
        3,
    ]
    assert selection["runtime_censoring"]["applied"] is True
    assert (
        selection["selection_rule"]["target_variant_demography_fields_read"]
        is False
    )
    for item in selection["selected_candidates"]:
        for key in ("receipt", "npz", "metadata_jsonl_gz"):
            source_record = item["source_artifacts"][key]
            sealed_record = item["sealed_artifacts"][key]
            assert sealed_record["size_bytes"] == source_record["size_bytes"]
            assert sealed_record["sha256"] == source_record["sha256"]
            assert (output / sealed_record["path"]).samefile(
                output / source_record["path"]
            )

    _candidate_fragment(output, plan, 0)
    assert pool.register_candidate(output, 0)["status"] == "selection_frozen"
    assert pool.register_candidate(output, 4)["status"] == "already_selected"
    assert selection_path.read_bytes() == before
    assert pool.pool_status(output)["selected_candidate_indices"] == [4, 1, 3]


def test_concurrent_registration_has_one_unique_k_prefix(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    output, _, plan, _ = _prepare(tmp_path, monkeypatch, name="concurrent")
    for index in range(5):
        _candidate_fragment(output, plan, index)

    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(
            executor.map(lambda index: pool.register_candidate(output, index), range(5))
        )
    assert all(result["status"] in {"registered", "selection_frozen"} for result in results)
    selection = json.loads((output / pool.SELECTION_NAME).read_text())
    selected = selection["selected_candidate_indices"]
    assert len(selected) == 3
    assert len(set(selected)) == 3
    assert sorted(
        item["registration_ordinal"]
        for item in selection["selected_candidates"]
    ) == [1, 2, 3]
    registry_before = (output / pool.REGISTRY_NAME).read_bytes()
    pool.register_candidate(output, selected[0])
    assert (output / pool.REGISTRY_NAME).read_bytes() == registry_before


@pytest.mark.parametrize("failure", ["receipt", "payload", "seed"])
def test_bad_receipt_hash_or_seed_fails_before_registration(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    failure: str,
) -> None:
    output, _, plan, _ = _prepare(
        tmp_path, monkeypatch, name=f"bad-{failure}"
    )
    _candidate_fragment(output, plan, 0)
    expected = plan["candidates"][0]
    if failure == "receipt":
        receipt_path = output / expected["receipt_path"]
        receipt = json.loads(receipt_path.read_text())
        receipt["result"]["start"] = 1
        _write_json(receipt_path, receipt)
    elif failure == "payload":
        (output / expected["npz_path"]).write_bytes(b"tampered")
    else:
        _candidate_fragment(output, plan, 0, seed=expected["seed"] + 1)

    with pytest.raises(pool.ReplacementPoolError):
        pool.register_candidate(output, 0)
    assert not (output / pool.SELECTION_NAME).exists()
    assert pool.pool_status(output)["registered_count"] == 0


def test_less_than_k_does_not_publish_and_missing_candidate_does_not_block(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    output, _, plan, _ = _prepare(tmp_path, monkeypatch, name="missing")
    for index in (1, 2):
        _candidate_fragment(output, plan, index)
        pool.register_candidate(output, index)
    status = pool.pool_status(output)
    assert status["registered_count"] == 2
    assert status["remaining_to_freeze"] == 1
    assert not (output / pool.SELECTION_NAME).exists()

    # Candidate zero never produces a receipt. Candidate three is enough to
    # freeze the exact K=3 prefix without waiting for it.
    _candidate_fragment(output, plan, 3)
    pool.register_candidate(output, 3)
    assert pool.pool_status(output)["selected_candidate_indices"] == [1, 2, 3]
    assert not (output / plan["candidates"][0]["receipt_path"]).exists()


def test_selected_payload_tamper_is_detected_through_sealed_hardlink(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    output, _, plan, _ = _prepare(tmp_path, monkeypatch, name="tamper")
    for index in (0, 1, 2):
        _candidate_fragment(output, plan, index)
        pool.register_candidate(output, index)
    (output / plan["candidates"][1]["npz_path"]).write_bytes(b"changed")
    with pytest.raises(pool.ReplacementPoolError, match="sealed artifact"):
        pool.pool_status(output)


def test_generate_requires_one_rank_per_candidate(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    output, _, plan, calls = _prepare(tmp_path, monkeypatch, name="generate")
    with pytest.raises(pool.ReplacementPoolError, match="world_size"):
        pool.generate_candidate(output, rank=0, world_size=4)
    result = pool.generate_candidate(output, rank=4, world_size=5)
    assert result["candidate_index"] == 4
    assert result["seed"] == plan["candidates"][4]["seed"]
    assert calls[-1][-5:] == [
        "--generate-only",
        "--rank",
        "4",
        "--world-size",
        "5",
    ]


def test_k_zero_is_an_empty_frozen_noop(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    output, _, plan, calls = _prepare(
        tmp_path,
        monkeypatch,
        name="zero",
        n_samples=2,
        completed=2,
        candidate_count=0,
    )
    assert plan["required_k"] == 0
    assert plan["candidate_config"] is None
    assert not any("--prepare-only" in call for call in calls)
    selection = json.loads((output / pool.SELECTION_NAME).read_text())
    assert selection["selected_candidates"] == []
    assert selection["runtime_censoring"]["applied"] is False
    assert pool.generate_candidate(output) == {
        "no_op": True,
        "required_k": 0,
        "candidate_count": 0,
    }
    status = pool.pool_status(output)
    assert status["status"] == "complete"
    assert status["no_op"] is True

	from __future__ import annotations

	import gzip
	import hashlib
	import json
	from concurrent.futures import ThreadPoolExecutor
	from pathlib import Path

	import pytest

	from simulator.config import Config
	from simulator.dataset_state import SAMPLE_GENERATOR_SCHEMA_VERSION, generation_config_state
	from simulator import replacement as v1
	from simulator import replacement_pool as pool


	GENERATION_PLAN_SHA = "9" * 64


	def _canonical(value: object) -> str:
	return hashlib.sha256(
	json.dumps(
	value,
	ensure_ascii=False,
	allow_nan=False,
	sort_keys=True,
	separators=(",", ":"),
	).encode("utf-8")
	).hexdigest()


	def _write_json(path: Path, value: dict) -> None:
	path.parent.mkdir(parents=True, exist_ok=True)
	path.write_text(json.dumps(value), encoding="utf-8")


	def _file_record(path: Path) -> dict:
	return {
	"size_bytes": path.stat().st_size,
	"sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
	}


	def _source_plan(root: Path, *, n_samples: int, seed: int) -> dict:
	config = Config(
	preset="full_v01",
	n_samples=n_samples,
	seed=seed,
	shard_size=2,
	compute_chunk_size=1,
	out_dir=str(root),
	workers=1,
	)
	state = generation_config_state(config)
	layout = {
	"n_samples": n_samples,
	"shard_size": 2,
	"compute_chunk_size": 1,
	"n_shards": (n_samples + 1) // 2,
	"n_chunks": n_samples,
	"sample_id_rule": "sim_{global_sample_index:08d}",
	"seed_rule": "config.seed + global_sample_index * 7919",
	"partition_rule": "chunk_idx_mod_world_size",
	"array_schema_version": SAMPLE_GENERATOR_SCHEMA_VERSION,
	}
	plan = {
	"schema_version": 1,
	"kind": "dlcoalsim_generation_plan",
	"sample_generation_config": state,
	"layout": layout,
	"layout_sha256": _canonical(layout),
	"empirical_maps_sha256": hashlib.sha256(b"maps").hexdigest(),
	"empirical_ne_templates_sha256": hashlib.sha256(b"templates").hexdigest(),
	"runtime_environment_sha256": hashlib.sha256(b"runtime").hexdigest(),
	}
	plan["plan_sha256"] = _canonical(plan)
	_write_json(root / "samples" / "PLAN.json", plan)
	return plan


	def _source_fragment(root: Path, plan: dict, index: int) -> None:
	shard = index // 2
	relative = f"samples/.fragments/fragment_{index:08d}.npz"
	npz = root / relative
	metadata = npz.with_suffix(".jsonl.gz")
	npz.parent.mkdir(parents=True, exist_ok=True)
	npz.write_bytes(f"source-npz-{index}".encode())
	metadata.write_bytes(f"source-meta-{index}".encode())
	receipt = {
	"schema_version": 1,
	"plan_sha256": plan["plan_sha256"],
	"result": {
	"chunk_idx": index,
	"shard_idx": shard,
	"start": index,
	"n_samples": 1,
	"fragment_path": relative,
	},
	"files": {
	"npz": _file_record(npz),
	"metadata_jsonl_gz": _file_record(metadata),
	},
	}
	receipt["receipt_sha256"] = _canonical(receipt)
	_write_json(
	root
	/ "samples"
	/ ".fragments"
	/ f"fragment_{index:08d}.done.json",
	receipt,
	)


	def _patch_generator(
	monkeypatch: pytest.MonkeyPatch,
	output: Path,
	runtime_sha256: str,
	) -> list[list[str]]:
	calls: list[list[str]] = []
	monkeypatch.setattr(
	v1,
	"_runtime_probe",
	lambda root, python: {
	"simulator_file": str(root / "simulator" / "__init__.py"),
	"runtime_environment_sha256": runtime_sha256,
	},
	)

	def fake_run(
	root,
	python,
	arguments,
	*,
	module=True,
	capture_output=True,
	):
	calls.append(list(arguments))
	if "--prepare-only" in arguments:
	_write_json(output / "samples" / "PLAN.json", {"test": True})
	return type(
	"Completed",
	(),
	{"returncode": 0, "stdout": "", "stderr": ""},
	)()

	monkeypatch.setattr(v1, "_run_generator_subprocess", fake_run)
	monkeypatch.setattr(
	v1,
	"_validate_replacement_generation_plan",
	lambda out, config, source: {
	"plan_sha256": GENERATION_PLAN_SHA,
	**dict(source),
	},
	)
	return calls


	def _prepare(
	tmp_path: Path,
	monkeypatch: pytest.MonkeyPatch,
	*,
	name: str = "case",
	n_samples: int = 5,
	completed: int = 2,
	candidate_count: int = 5,
	) -> tuple[Path, Path, dict, list[list[str]]]:
	source = tmp_path / f"{name}-source"
	source_plan = _source_plan(source, n_samples=n_samples, seed=100)
	for index in range(completed):
	_source_fragment(source, source_plan, index)
	output = tmp_path / f"{name}-pool"
	calls = _patch_generator(
	monkeypatch, output, source_plan["runtime_environment_sha256"]
	)
	generator_root = tmp_path / f"{name}-generator"
	(generator_root / "simulator").mkdir(parents=True)
	(generator_root / "simulator" / "__init__.py").write_text("")
	generator_python = tmp_path / f"{name}-python"
	generator_python.write_text("")
	plan = pool.prepare_pool(
	[source],
	target_total=n_samples,
	candidate_count=candidate_count,
	out_dir=output,
	generator_root=generator_root,
	generator_python=generator_python,
	)
	return output, source, plan, calls


	def _candidate_fragment(
	output: Path,
	plan: dict,
	index: int,
	*,
	seed: int \| None = None,
	) -> None:
	expected = plan["candidates"][index]
	npz = output / expected["npz_path"]
	metadata = output / expected["metadata_path"]
	receipt_path = output / expected["receipt_path"]
	npz.parent.mkdir(parents=True, exist_ok=True)
	npz.write_bytes(f"candidate-npz-{index}".encode())
	with gzip.open(metadata, "wt", encoding="utf-8") as handle:
	handle.write(
	json.dumps(
	{
	"sample_id": expected["expected_sample_id"],
	"sample_index": index,
	"seed": expected["seed"] if seed is None else seed,
	# These fields must never participate in pool selection.
	"target": [999],
	"n_variants": 999,
	"demography_type": "ignored",
	}
	)
	+ "\n"
	)
	receipt = {
	"schema_version": 1,
	"plan_sha256": plan["generation_plan_sha256"],
	"result": {
	"chunk_idx": index,
	"shard_idx": expected["shard_index"],
	"start": index,
	"n_samples": 1,
	"fragment_path": expected["npz_path"],
	},
	"files": {
	"npz": _file_record(npz),
	"metadata_jsonl_gz": _file_record(metadata),
	},
	}
	receipt["receipt_sha256"] = _canonical(receipt)
	_write_json(receipt_path, receipt)


	def test_k3_c5_freezes_out_of_order_prefix_and_late_is_immutable(
	tmp_path: Path, monkeypatch: pytest.MonkeyPatch
	) -> None:
	output, _, plan, _ = _prepare(tmp_path, monkeypatch)
	assert plan["required_k"] == 3
	assert plan["candidate_count"] == 5
	assert plan["candidate_config"]["n_samples"] == 5
	assert plan["candidate_config"]["compute_chunk_size"] == 1
	assert plan["candidate_config"]["workers"] == 1
	assert plan["candidate_groups"]["primary"]["candidate_indices"] == [0, 1, 2]
	assert plan["candidate_groups"]["standby"]["candidate_indices"] == [3, 4]

	for index in (4, 1, 3):
	_candidate_fragment(output, plan, index)
	result = pool.register_candidate(output, index)
	assert result["selection_frozen"] is True

	selection_path = output / pool.SELECTION_NAME
	before = selection_path.read_bytes()
	selection = json.loads(before)
	assert selection["selected_candidate_indices"] == [4, 1, 3]
	assert selection["registration_cutoff_ordinal"] == 3
	assert [item["registration_ordinal"] for item in selection["selected_candidates"]] == [
	1,
	2,
	3,
	]
	assert selection["runtime_censoring"]["applied"] is True
	assert (
	selection["selection_rule"]["target_variant_demography_fields_read"]
	is False
	)
	for item in selection["selected_candidates"]:
	for key in ("receipt", "npz", "metadata_jsonl_gz"):
	source_record = item["source_artifacts"][key]
	sealed_record = item["sealed_artifacts"][key]
	assert sealed_record["size_bytes"] == source_record["size_bytes"]
	assert sealed_record["sha256"] == source_record["sha256"]
	assert (output / sealed_record["path"]).samefile(
	output / source_record["path"]
	)

	_candidate_fragment(output, plan, 0)
	assert pool.register_candidate(output, 0)["status"] == "selection_frozen"
	assert pool.register_candidate(output, 4)["status"] == "already_selected"
	assert selection_path.read_bytes() == before
	assert pool.pool_status(output)["selected_candidate_indices"] == [4, 1, 3]


	def test_concurrent_registration_has_one_unique_k_prefix(
	tmp_path: Path, monkeypatch: pytest.MonkeyPatch
	) -> None:
	output, _, plan, _ = _prepare(tmp_path, monkeypatch, name="concurrent")
	for index in range(5):
	_candidate_fragment(output, plan, index)

	with ThreadPoolExecutor(max_workers=5) as executor:
	results = list(
	executor.map(lambda index: pool.register_candidate(output, index), range(5))
	)
	assert all(result["status"] in {"registered", "selection_frozen"} for result in results)
	selection = json.loads((output / pool.SELECTION_NAME).read_text())
	selected = selection["selected_candidate_indices"]
	assert len(selected) == 3
	assert len(set(selected)) == 3
	assert sorted(
	item["registration_ordinal"]
	for item in selection["selected_candidates"]
	) == [1, 2, 3]
	registry_before = (output / pool.REGISTRY_NAME).read_bytes()
	pool.register_candidate(output, selected[0])
	assert (output / pool.REGISTRY_NAME).read_bytes() == registry_before


	@pytest.mark.parametrize("failure", ["receipt", "payload", "seed"])
	def test_bad_receipt_hash_or_seed_fails_before_registration(
	tmp_path: Path,
	monkeypatch: pytest.MonkeyPatch,
	failure: str,
	) -> None:
	output, _, plan, _ = _prepare(
	tmp_path, monkeypatch, name=f"bad-{failure}"
	)
	_candidate_fragment(output, plan, 0)
	expected = plan["candidates"][0]
	if failure == "receipt":
	receipt_path = output / expected["receipt_path"]
	receipt = json.loads(receipt_path.read_text())
	receipt["result"]["start"] = 1
	_write_json(receipt_path, receipt)
	elif failure == "payload":
	(output / expected["npz_path"]).write_bytes(b"tampered")
	else:
	_candidate_fragment(output, plan, 0, seed=expected["seed"] + 1)

	with pytest.raises(pool.ReplacementPoolError):
	pool.register_candidate(output, 0)
	assert not (output / pool.SELECTION_NAME).exists()
	assert pool.pool_status(output)["registered_count"] == 0


	def test_less_than_k_does_not_publish_and_missing_candidate_does_not_block(
	tmp_path: Path, monkeypatch: pytest.MonkeyPatch
	) -> None:
	output, _, plan, _ = _prepare(tmp_path, monkeypatch, name="missing")
	for index in (1, 2):
	_candidate_fragment(output, plan, index)
	pool.register_candidate(output, index)
	status = pool.pool_status(output)
	assert status["registered_count"] == 2
	assert status["remaining_to_freeze"] == 1
	assert not (output / pool.SELECTION_NAME).exists()

	# Candidate zero never produces a receipt. Candidate three is enough to
	# freeze the exact K=3 prefix without waiting for it.
	_candidate_fragment(output, plan, 3)
	pool.register_candidate(output, 3)
	assert pool.pool_status(output)["selected_candidate_indices"] == [1, 2, 3]
	assert not (output / plan["candidates"][0]["receipt_path"]).exists()


	def test_selected_payload_tamper_is_detected_through_sealed_hardlink(
	tmp_path: Path, monkeypatch: pytest.MonkeyPatch
	) -> None:
	output, _, plan, _ = _prepare(tmp_path, monkeypatch, name="tamper")
	for index in (0, 1, 2):
	_candidate_fragment(output, plan, index)
	pool.register_candidate(output, index)
	(output / plan["candidates"][1]["npz_path"]).write_bytes(b"changed")
	with pytest.raises(pool.ReplacementPoolError, match="sealed artifact"):
	pool.pool_status(output)


	def test_generate_requires_one_rank_per_candidate(
	tmp_path: Path, monkeypatch: pytest.MonkeyPatch
	) -> None:
	output, _, plan, calls = _prepare(tmp_path, monkeypatch, name="generate")
	with pytest.raises(pool.ReplacementPoolError, match="world_size"):
	pool.generate_candidate(output, rank=0, world_size=4)
	result = pool.generate_candidate(output, rank=4, world_size=5)
	assert result["candidate_index"] == 4
	assert result["seed"] == plan["candidates"][4]["seed"]
	assert calls[-1][-5:] == [
	"--generate-only",
	"--rank",
	"4",
	"--world-size",
	"5",
	]


	def test_k_zero_is_an_empty_frozen_noop(
	tmp_path: Path, monkeypatch: pytest.MonkeyPatch
	) -> None:
	output, _, plan, calls = _prepare(
	tmp_path,
	monkeypatch,
	name="zero",
	n_samples=2,
	completed=2,
	candidate_count=0,
	)
	assert plan["required_k"] == 0
	assert plan["candidate_config"] is None
	assert not any("--prepare-only" in call for call in calls)
	selection = json.loads((output / pool.SELECTION_NAME).read_text())
	assert selection["selected_candidates"] == []
	assert selection["runtime_censoring"]["applied"] is False
	assert pool.generate_candidate(output) == {
	"no_op": True,
	"required_k": 0,
	"candidate_count": 0,
	}
	status = pool.pool_status(output)
	assert status["status"] == "complete"
	assert status["no_op"] is True