Microstructure/src/microstructure/m8_l2_binance.py

"""Production Binance adapter for one frozen prospective M8 L2 symbol.

The cross-symbol/session authority lives in :mod:`microstructure.m8_l2_capture`.
This module owns only the public market-data transport, bounded raw journaling,
snapshot-plus-delta reconstruction, and the exhaustive per-symbol artifact
descriptor returned across that typed boundary.  It has no authenticated or
order-entry path.
"""

from __future__ import annotations

import asyncio
import base64
import hashlib
import json
import os
import tempfile
import time
from collections import deque
from collections.abc import AsyncIterator, Callable, Iterator, Mapping
from contextlib import suppress
from dataclasses import dataclass
from pathlib import Path
from typing import Literal, Protocol, cast

import pyarrow as pa  # type: ignore[import-untyped]
from websockets.exceptions import WebSocketException

from microstructure.data.binance import (
    BinanceHTTPError,
    BinanceLiveDepthCollector,
    BinanceMetadataContractError,
    BinancePayloadError,
    BinancePublicClient,
    BinanceResponseSizeLimitError,
    CapturedDepth,
    RawDepthFrame,
    SymbolMetadata,
)
from microstructure.data.book import BookInvariantError, BookSnapshot, IncrementalBookReconstructor
from microstructure.data.quality import IncrementalQualityValidator, ValidationReport
from microstructure.data.schemas import get_schema, table_from_records
from microstructure.data.storage import write_capture_parquet, write_source_manifest
from microstructure.m8_l2_capture import (
    CapturedArtifact,
    M8L2DataFailure,
    ObservedInterval,
    SymbolCaptureResult,
)
from microstructure.m8_l2_config import M8L2CaptureLimits
from microstructure.provenance import read_json, sha256_file, utc_now_iso, write_json

_BATCH_ROWS = 1_024
_VARIABLE_RECORD_OVERHEAD_FACTOR = 8
_MAX_OBSERVED_SILENCE_NS = 5_000_000_000
_DEFAULT_RECEIVER_QUEUE_CAPACITY = 1_024
_SOURCE_URI = "wss://data-stream.binance.vision"


class _Collector(Protocol):
    url: str

    def stream(self, *, max_messages: int | None = None) -> AsyncIterator[CapturedDepth]: ...


class _Client(Protocol):
    def fetch_exchange_info(self, *, symbol: str, raw_root: Path) -> SymbolMetadata: ...

    def fetch_depth_snapshot(
        self,
        *,
        symbol: str,
        raw_root: Path,
        continuity_id: str,
        tick_size: object,
        lot_size: object,
    ) -> BookSnapshot: ...


class _DataCaptureIssue(RuntimeError):
    """Internal deterministic capture failure converted after evidence finalization."""

    def __init__(self, reason_code: str, phase: str, message: str) -> None:
        super().__init__(message)
        self.reason_code = reason_code
        self.phase = phase


class _ScheduledEndReached(RuntimeError):
    """Stop the collector before it decodes the first out-of-window frame."""


class _LocalEvidenceSystemError(RuntimeError):
    """Keep local journal/storage faults out of public-transport classification."""


async def _to_thread_joined[**P, T](
    function: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs
) -> T:
    """Make cancellation wait for a public REST worker that may still write raw bytes."""

    task = asyncio.create_task(asyncio.to_thread(function, *args, **kwargs))
    try:
        return await asyncio.shield(task)
    except asyncio.CancelledError as canceled:
        try:
            await task
        except BaseException as worker_error:
            canceled.add_note(
                f"joined REST worker also failed with {type(worker_error).__name__}: {worker_error}"
            )
        raise


@dataclass(frozen=True, slots=True)
class _PublishedJournal:
    path: Path
    sha256: str
    manifest_path: Path
    manifest_sha256: str


class _RawJournal:
    """Write exact websocket bytes before decode and retain FIFO lineage."""

    def __init__(
        self,
        *,
        root: Path,
        symbol: str,
        source_uri: str,
        scheduled_start_ns: int,
        scheduled_end_ns: int,
        max_frame_bytes: int,
        max_messages: int,
    ) -> None:
        self.root = root
        self.symbol = symbol
        self.source_uri = source_uri
        self.scheduled_start_ns = scheduled_start_ns
        self.scheduled_end_ns = scheduled_end_ns
        self.max_frame_bytes = max_frame_bytes
        self.max_messages = max_messages
        self.directory = root / "raw" / "binance_spot" / "depth_stream" / symbol
        self.directory.mkdir(parents=True, exist_ok=True)
        descriptor, name = tempfile.mkstemp(
            dir=self.directory,
            prefix=".m8-l2-",
            suffix=".ndjson.tmp",
        )
        self._temporary_path = Path(name)
        self._handle = os.fdopen(descriptor, "wb")
        self._pending: deque[tuple[str, int, int, str]] = deque()
        self.messages = 0
        self.snapshot_anchors = 0
        self.first_received_ns: int | None = None
        self.last_received_ns: int | None = None
        self.max_frame_bytes_observed = 0
        self._closed = False
        self._published: _PublishedJournal | None = None

    @property
    def evidence_path(self) -> Path:
        return self._published.path if self._published is not None else self._temporary_path

    def _write(self, payload: Mapping[str, object]) -> None:
        if self._closed:
            raise RuntimeError("cannot append to a closed raw journal")
        encoded = json.dumps(
            dict(payload), sort_keys=True, separators=(",", ":"), allow_nan=False
        ).encode("utf-8")
        self._handle.write(encoded)
        self._handle.write(b"\n")

    def append_frame(self, frame: RawDepthFrame) -> None:
        """Persist an in-window frame; the collector calls this before parsing."""

        if not (self.scheduled_start_ns <= frame.received_ts_ns < self.scheduled_end_ns):
            return
        payload_size = len(frame.payload)
        payload_sha256 = hashlib.sha256(frame.payload).hexdigest()
        self._write(
            {
                "capture_seq": frame.capture_seq,
                "continuity_id": frame.continuity_id,
                "event_kind": "websocket_frame",
                "payload_base64": base64.b64encode(frame.payload).decode("ascii"),
                "payload_bytes": payload_size,
                "payload_sha256": payload_sha256,
                "received_ts_ns": frame.received_ts_ns,
                "websocket_message_type": "text" if frame.was_text else "binary",
            }
        )
        self.messages += 1
        self.max_frame_bytes_observed = max(self.max_frame_bytes_observed, payload_size)
        if self.first_received_ns is None:
            self.first_received_ns = frame.received_ts_ns
        self.last_received_ns = frame.received_ts_ns
        self._pending.append(
            (frame.continuity_id, frame.capture_seq, frame.received_ts_ns, payload_sha256)
        )
        if payload_size > self.max_frame_bytes:
            raise _DataCaptureIssue(
                "RAW_FRAME_BYTES_EXCEEDED",
                "RAW_CAPTURE",
                f"raw frame has {payload_size} bytes; maximum is {self.max_frame_bytes}",
            )
        # The ceiling is a failure boundary, never an alternate stopping target.
        if self.messages >= self.max_messages:
            raise _DataCaptureIssue(
                "MESSAGE_SAFETY_CEILING_REACHED",
                "RAW_CAPTURE",
                f"message ceiling {self.max_messages} reached before scheduled end",
            )

    def consume_captured(self, item: CapturedDepth) -> None:
        received_ns = item.delta.received_ts_ns
        capture_seq = item.delta.capture_seq
        if received_ns is None or capture_seq is None:
            raise _DataCaptureIssue(
                "MISSING_RAW_LINEAGE",
                "NORMALIZATION",
                "captured depth delta lacks receipt time or capture sequence",
            )
        identity = (
            item.delta.continuity_id,
            capture_seq,
            received_ns,
            hashlib.sha256(item.raw_payload.encode("utf-8")).hexdigest(),
        )
        if not self._pending or self._pending[0] != identity:
            raise _DataCaptureIssue(
                "RAW_LINEAGE_MISMATCH",
                "NORMALIZATION",
                "normalized depth delta is not the next preserved raw frame",
            )
        self._pending.popleft()
        if item.delta.source_artifact_id != identity[-1]:
            raise _DataCaptureIssue(
                "RAW_LINEAGE_MISMATCH",
                "NORMALIZATION",
                "normalized depth source digest differs from preserved raw bytes",
            )

    def append_snapshot(
        self,
        snapshot: BookSnapshot,
        *,
        raw_path: Path,
        manifest_path: Path,
    ) -> None:
        self._write(
            {
                "continuity_id": snapshot.continuity_id,
                "event_kind": "rest_snapshot_anchor",
                "last_update_id": snapshot.last_update_id,
                "raw_manifest_path": raw_path.parent.joinpath(manifest_path.name)
                .relative_to(self.root)
                .as_posix(),
                "raw_manifest_sha256": sha256_file(manifest_path),
                "raw_path": raw_path.relative_to(self.root).as_posix(),
                "raw_sha256": snapshot.source_artifact_id,
                "received_ts_ns": snapshot.received_ts_ns,
                "snapshot_id": snapshot.snapshot_id,
            }
        )
        self.snapshot_anchors += 1

    def _close(self) -> None:
        if self._closed:
            return
        self._handle.flush()
        os.fsync(self._handle.fileno())
        self._handle.close()
        self._closed = True

    def publish(self, *, capture_status: str, error: BaseException | None) -> _PublishedJournal:
        if self._published is not None:
            return self._published
        self._close()
        digest = sha256_file(self._temporary_path)
        destination = self.directory / f"capture-{digest}.ndjson"
        if destination.exists():
            if sha256_file(destination) != digest:
                raise RuntimeError(f"raw journal content-address collision at {destination}")
            self._temporary_path.unlink(missing_ok=True)
        else:
            os.replace(self._temporary_path, destination)
        headers = {
            "x-local-capture-status": capture_status,
            "x-local-journal-format": "typed-base64-frames-v1",
            "x-local-message-count": str(self.messages),
            "x-local-snapshot-anchor-count": str(self.snapshot_anchors),
            "x-local-scheduled-start-ns": str(self.scheduled_start_ns),
            "x-local-scheduled-end-ns-exclusive": str(self.scheduled_end_ns),
        }
        if error is not None:
            headers["x-local-error-type"] = type(error).__name__
            headers["x-local-error"] = str(error)[:512]
        manifest_path, manifest_sha256 = write_source_manifest(
            destination,
            source="binance_spot_public_live_capture_journal",
            source_uri=self.source_uri,
            downloaded_at_utc=utc_now_iso(),
            requested_start_ns=self.scheduled_start_ns,
            requested_end_ns=self.scheduled_end_ns,
            response_headers=headers,
        )
        self._published = _PublishedJournal(
            path=destination,
            sha256=digest,
            manifest_path=manifest_path,
            manifest_sha256=manifest_sha256,
        )
        return self._published

    def close_without_publish(self) -> None:
        self._close()


class _ArrowSpool:
    """Bounded record buffer backed by an Arrow IPC stream on disk."""

    def __init__(
        self,
        *,
        root: Path,
        schema_name: str,
        max_batch_bytes: int,
        on_batch: Callable[[pa.RecordBatch], None] | None = None,
    ) -> None:
        self.schema_name = schema_name
        self.max_batch_bytes = max_batch_bytes
        self.path = root / f"{schema_name}.arrow"
        self._handle = self.path.open("wb")
        self._writer = pa.ipc.new_stream(self._handle, get_schema(schema_name))
        self._on_batch = on_batch
        self._records: list[Mapping[str, object]] = []
        self._estimated_bytes = 0
        self.rows = 0
        self.max_batch_bytes_observed = 0
        self._closed = False

    def append(self, record: Mapping[str, object], *, estimated_bytes: int) -> None:
        if self._closed:
            raise RuntimeError("cannot append to a closed Arrow spool")
        if estimated_bytes < 1:
            raise RuntimeError("Arrow record estimate must be positive")
        if estimated_bytes > self.max_batch_bytes:
            raise _DataCaptureIssue(
                "ARROW_BATCH_BYTES_EXCEEDED",
                "NORMALIZATION",
                f"one {self.schema_name} record estimate exceeds the Arrow batch ceiling",
            )
        if self._records and self._estimated_bytes + estimated_bytes > self.max_batch_bytes:
            self._flush()
        self._records.append(record)
        self._estimated_bytes += estimated_bytes
        if len(self._records) >= _BATCH_ROWS:
            self._flush()

    def _flush(self) -> None:
        if not self._records:
            return
        table = table_from_records(self.schema_name, self._records)
        batches = table.to_batches(max_chunksize=_BATCH_ROWS)
        if len(batches) != 1:
            raise RuntimeError(f"failed to build one bounded {self.schema_name} Arrow batch")
        batch = batches[0]
        observed_bytes = max(self._estimated_bytes, batch.nbytes)
        self.max_batch_bytes_observed = max(self.max_batch_bytes_observed, observed_bytes)
        if observed_bytes > self.max_batch_bytes:
            raise _DataCaptureIssue(
                "ARROW_BATCH_BYTES_EXCEEDED",
                "NORMALIZATION",
                f"{self.schema_name} Arrow batch exceeds {self.max_batch_bytes} bytes",
            )
        if self._on_batch is not None:
            self._on_batch(batch)
        self._writer.write_batch(batch)
        self.rows += batch.num_rows
        self._records.clear()
        self._estimated_bytes = 0

    def close(self) -> None:
        if self._closed:
            return
        self._flush()
        self._writer.close()
        self._handle.flush()
        os.fsync(self._handle.fileno())
        self._handle.close()
        self._closed = True

    def iter_batches(self) -> Iterator[pa.RecordBatch]:
        if not self._closed:
            raise RuntimeError("Arrow spool must be closed before reading")
        with self.path.open("rb") as handle:
            for batch in pa.ipc.open_stream(handle):
                if batch.num_rows > _BATCH_ROWS or batch.nbytes > self.max_batch_bytes:
                    raise RuntimeError(f"persisted {self.schema_name} batch exceeds its bound")
                yield batch


class _ObservedIntervals:
    """Track only receipt spans confirmed by consecutive OBSERVED states."""

    def __init__(self) -> None:
        self._continuity_id: str | None = None
        self._previous_ns: int | None = None
        self._active_start_ns: int | None = None
        self._active_end_ns: int | None = None
        self._intervals: list[ObservedInterval] = []

    def _finish_active(self) -> None:
        if (
            self._continuity_id is not None
            and self._active_start_ns is not None
            and self._active_end_ns is not None
            and self._active_end_ns > self._active_start_ns
        ):
            self._intervals.append(
                ObservedInterval(
                    continuity_id=self._continuity_id,
                    start_received_ns=self._active_start_ns,
                    end_received_ns_exclusive=self._active_end_ns,
                )
            )
        self._active_start_ns = None
        self._active_end_ns = None

    def break_continuity(self) -> None:
        self._finish_active()
        self._continuity_id = None
        self._previous_ns = None

    def excluded(self, continuity_id: str) -> None:
        if self._continuity_id == continuity_id:
            self._finish_active()
        else:
            self._finish_active()
            self._continuity_id = continuity_id
        self._previous_ns = None

    def observed(self, continuity_id: str, received_ns: int) -> None:
        if self._continuity_id != continuity_id:
            self.break_continuity()
            self._continuity_id = continuity_id
        previous = self._previous_ns
        if (
            previous is not None
            and received_ns > previous
            and received_ns - previous <= _MAX_OBSERVED_SILENCE_NS
        ):
            if self._active_start_ns is None:
                self._active_start_ns = previous
            self._active_end_ns = received_ns + 1
        else:
            self._finish_active()
        self._previous_ns = received_ns

    def finish(self) -> tuple[ObservedInterval, ...]:
        self._finish_active()
        return tuple(self._intervals)


def _snapshot_files(root: Path, snapshot: BookSnapshot) -> tuple[Path, Path]:
    directory = root / "raw" / "binance_spot" / "depth_snapshots" / snapshot.symbol
    raw_path = directory / f"{snapshot.source_artifact_id}.json"
    if raw_path.is_symlink() or not raw_path.is_file():
        raise RuntimeError("snapshot raw response is not a regular preserved artifact")
    if sha256_file(raw_path) != snapshot.source_artifact_id:
        raise RuntimeError("snapshot raw response digest does not match its source identity")
    candidates: list[tuple[Path, Mapping[str, object]]] = []
    for path in directory.glob(f"{raw_path.name}.manifest-*.json"):
        payload = read_json(path)
        checksum = payload.get("checksum") if isinstance(payload, dict) else None
        if (
            isinstance(payload, dict)
            and payload.get("path") == raw_path.name
            and isinstance(checksum, dict)
            and checksum.get("value") == snapshot.source_artifact_id
        ):
            candidates.append((path, payload))
    if len(candidates) == 1:
        return raw_path, candidates[0][0]
    seconds, nanoseconds = divmod(snapshot.received_ts_ns, 1_000_000_000)
    expected_downloaded = (
        time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(seconds)) + f".{nanoseconds:09d}Z"
    )
    current = [
        path
        for path, payload in candidates
        if payload.get("downloaded_at_utc") == expected_downloaded
    ]
    if len(current) != 1:
        raise RuntimeError(
            "snapshot does not have one source manifest bound to its receipt timestamp"
        )
    return raw_path, current[0]


def _verify_metadata_files(root: Path, metadata: SymbolMetadata) -> None:
    for label, path in (
        ("exchange metadata raw response", metadata.source_path),
        ("exchange metadata source manifest", metadata.source_manifest_path),
    ):
        if path.is_symlink() or not path.is_file():
            raise RuntimeError(f"{label} is not a regular file")
        try:
            path.resolve().relative_to(root.resolve())
        except ValueError as error:
            raise RuntimeError(f"{label} escapes the single-symbol capture stage") from error
    if sha256_file(metadata.source_path) != metadata.source_artifact_id:
        raise RuntimeError("exchange metadata digest differs from its raw response")
    manifest = read_json(metadata.source_manifest_path)
    checksum = manifest.get("checksum") if isinstance(manifest, dict) else None
    if not (
        isinstance(manifest, dict)
        and manifest.get("path") == metadata.source_path.name
        and isinstance(checksum, dict)
        and checksum.get("value") == metadata.source_artifact_id
    ):
        raise RuntimeError("exchange metadata source manifest is not bound to its raw response")


def _artifact_kind(path: Path, root: Path) -> str:
    relative = path.relative_to(root).as_posix()
    name = path.name
    if "/depth_stream/" in f"/{relative}" and name.endswith(".ndjson"):
        return "raw_journal"
    if "/depth_stream/" in f"/{relative}" and ".ndjson.manifest-" in name:
        return "raw_journal_manifest"
    if "/depth_snapshots/" in f"/{relative}" and ".json.manifest-" in name:
        return "raw_snapshot_manifest"
    if "/depth_snapshots/" in f"/{relative}" and name.endswith(".json"):
        return "raw_snapshot"
    if "/exchange_info/" in f"/{relative}" and ".json.manifest-" in name:
        return "raw_metadata_manifest"
    if "/exchange_info/" in f"/{relative}" and name.endswith(".json"):
        return "raw_metadata"
    if relative.startswith("normalized/") and name.endswith(".parquet"):
        return "normalized_data"
    if relative.startswith("normalized/") and name.endswith(".json"):
        return "normalized_manifest"
    if relative.startswith("quality/") and name.endswith(".summary.json"):
        return "capture_summary"
    if relative.startswith("quality/") and name.endswith(".json"):
        return "quality_report"
    return "partial_evidence"


def _artifacts(root: Path) -> tuple[CapturedArtifact, ...]:
    result: list[CapturedArtifact] = []
    for path in sorted(root.rglob("*"), key=lambda item: item.as_posix()):
        relative_parts = path.relative_to(root).parts
        if relative_parts and relative_parts[0].startswith(".arrow-spool-"):
            continue
        if path.is_symlink():
            raise RuntimeError(f"symbol evidence contains a symlink: {path}")
        if path.is_file():
            result.append(
                CapturedArtifact(
                    path=path,
                    kind=_artifact_kind(path, root),
                    sha256=sha256_file(path),
                )
            )
    return tuple(result)


def _classify_binance_data_error(error: BaseException) -> _DataCaptureIssue | None:
    if isinstance(error, UnicodeDecodeError):
        return _DataCaptureIssue("RAW_UTF8_DECODE_FAILED", "NORMALIZATION", str(error))
    if isinstance(error, BinanceHTTPError):
        if error.status_code in {404, 410} and not error.retry_exhausted:
            return _DataCaptureIssue("DECLARED_OBJECT_UNAVAILABLE", "PUBLIC_METADATA", str(error))
        return _DataCaptureIssue("PUBLIC_TRANSPORT_UNAVAILABLE", "PUBLIC_METADATA", str(error))
    if isinstance(error, (BinanceMetadataContractError, BinanceResponseSizeLimitError)):
        return _DataCaptureIssue("PUBLIC_PAYLOAD_CONTRACT_FAILED", "PUBLIC_METADATA", str(error))
    if isinstance(error, BinancePayloadError) and not error.transient:
        return _DataCaptureIssue("PUBLIC_PAYLOAD_CONTRACT_FAILED", "NORMALIZATION", str(error))
    if isinstance(error, BookInvariantError):
        return _DataCaptureIssue("BOOK_INVARIANT_FAILED", "RECONSTRUCTION", str(error))
    return None


@dataclass(slots=True)
class _CaptureState:
    current_continuity_id: str | None = None
    reconstructor: IncrementalBookReconstructor | None = None
    continuity_epochs: int = 0
    reconstruction_status: Literal["LIVE", "GAPPED", "INVALID", "NOT_STARTED"] = "NOT_STARTED"
    excluded_rows: int = 0
    sequence_gaps: int = 0
    stale_rows: int = 0
    max_queue_depth: int = 0
    max_queue_estimated_bytes: int = 0


class BinanceM8L2Capture:
    """Callable production implementation of the frozen ``CaptureOne`` protocol."""

    def __init__(
        self,
        *,
        client_factory: Callable[[], _Client] | None = None,
        collector_factory: Callable[..., _Collector] | None = None,
        clock_ns: Callable[[], int] = time.time_ns,
        receiver_queue_capacity: int = _DEFAULT_RECEIVER_QUEUE_CAPACITY,
    ) -> None:
        if receiver_queue_capacity < 1:
            raise ValueError("receiver_queue_capacity must be positive")
        self._client_factory = client_factory or cast(Callable[[], _Client], BinancePublicClient)
        self._collector_factory = collector_factory or cast(
            Callable[..., _Collector], BinanceLiveDepthCollector
        )
        self._clock_ns = clock_ns
        self._receiver_queue_capacity = receiver_queue_capacity

    async def __call__(
        self,
        *,
        symbol: str,
        scheduled_start_ns: int,
        scheduled_end_ns: int,
        stage_root: Path,
        limits: M8L2CaptureLimits,
        session_id: str,
    ) -> SymbolCaptureResult:
        if scheduled_end_ns <= scheduled_start_ns:
            raise ValueError("scheduled_end_ns must be after scheduled_start_ns")
        if limits.max_messages_per_symbol < 1:
            raise ValueError("message ceiling must be positive")
        if limits.max_raw_frame_bytes < 1 or limits.max_arrow_batch_bytes < 1:
            raise ValueError("capture byte ceilings must be positive")
        normalized_symbol = symbol.upper()
        if normalized_symbol not in {"BTCUSDT", "ETHUSDT"}:
            raise ValueError(f"unsupported frozen L2 symbol: {symbol}")
        stage = stage_root.resolve()
        stage.mkdir(parents=True, exist_ok=True)
        if any(stage.iterdir()):
            raise RuntimeError("single-symbol capture stage must start empty")
        capture_id = f"{normalized_symbol.lower()}-{session_id[:20]}"
        queue_capacity = min(
            self._receiver_queue_capacity,
            limits.max_messages_per_symbol,
        )
        queue_byte_budget = limits.max_arrow_batch_bytes
        journal = _RawJournal(
            root=stage,
            symbol=normalized_symbol,
            source_uri=_SOURCE_URI,
            scheduled_start_ns=scheduled_start_ns,
            scheduled_end_ns=scheduled_end_ns,
            max_frame_bytes=limits.max_raw_frame_bytes,
            max_messages=limits.max_messages_per_symbol,
        )
        state = _CaptureState()
        interval_tracker = _ObservedIntervals()
        client = self._client_factory()
        receiver_task: asyncio.Task[None] | None = None
        capture_error: BaseException | None = None
        completion_reason = "capture_failed"
        metadata: SymbolMetadata | None = None
        raw_evidence: _PublishedJournal | None = None
        validation_reports: tuple[ValidationReport, ValidationReport] | None = None

        with tempfile.TemporaryDirectory(dir=stage, prefix=".arrow-spool-") as spool_name:
            spool_root = Path(spool_name)
            delta_validator = IncrementalQualityValidator(
                "depth_deltas", row_chunk_size=_BATCH_ROWS
            )
            observation_validator = IncrementalQualityValidator(
                "book_observations", row_chunk_size=_BATCH_ROWS
            )
            validators_finished = False
            spools = {
                "book_snapshots": _ArrowSpool(
                    root=spool_root,
                    schema_name="book_snapshots",
                    max_batch_bytes=limits.max_arrow_batch_bytes,
                ),
                "depth_deltas": _ArrowSpool(
                    root=spool_root,
                    schema_name="depth_deltas",
                    max_batch_bytes=limits.max_arrow_batch_bytes,
                    on_batch=delta_validator.update,
                ),
                "book_observations": _ArrowSpool(
                    root=spool_root,
                    schema_name="book_observations",
                    max_batch_bytes=limits.max_arrow_batch_bytes,
                    on_batch=observation_validator.update,
                ),
                "sequence_gaps": _ArrowSpool(
                    root=spool_root,
                    schema_name="sequence_gaps",
                    max_batch_bytes=limits.max_arrow_batch_bytes,
                ),
            }
            try:
                if self._clock_ns() >= scheduled_end_ns:
                    raise _DataCaptureIssue(
                        "MISSED_WINDOW", "CAPTURE_START", "scheduled capture window already ended"
                    )
                try:
                    metadata = await _to_thread_joined(
                        client.fetch_exchange_info,
                        symbol=normalized_symbol,
                        raw_root=stage / "raw",
                    )
                except BaseException as error:
                    classified = _classify_binance_data_error(error)
                    if classified is not None:
                        raise classified from error
                    raise
                _verify_metadata_files(stage, metadata)
                if metadata.symbol != normalized_symbol or metadata.venue != "binance_spot":
                    raise _DataCaptureIssue(
                        "METADATA_IDENTITY_MISMATCH",
                        "PUBLIC_METADATA",
                        "exchange metadata venue/symbol differs from the requested feed",
                    )
                if metadata.status != "TRADING":
                    raise _DataCaptureIssue(
                        "SYMBOL_NOT_TRADING",
                        "PUBLIC_METADATA",
                        f"{normalized_symbol} exchange status is {metadata.status!r}",
                    )
                if self._clock_ns() >= scheduled_end_ns:
                    raise _DataCaptureIssue(
                        "METADATA_EXHAUSTED_WINDOW",
                        "PUBLIC_METADATA",
                        "metadata acquisition consumed the scheduled capture window",
                    )

                def preserve_in_window_frame(frame: RawDepthFrame) -> None:
                    if frame.received_ts_ns >= scheduled_end_ns:
                        raise _ScheduledEndReached
                    try:
                        journal.append_frame(frame)
                    except (_DataCaptureIssue, _ScheduledEndReached):
                        raise
                    except OSError as error:
                        raise _LocalEvidenceSystemError("local raw-journal write failed") from error

                collector = self._collector_factory(
                    symbols=(normalized_symbol,),
                    tick_size=metadata.tick_size,
                    lot_size=metadata.lot_size,
                    on_raw_frame=preserve_in_window_frame,
                )
                journal.source_uri = collector.url
                queue: asyncio.Queue[tuple[CapturedDepth, int]] = asyncio.Queue(
                    maxsize=queue_capacity
                )
                queue_condition = asyncio.Condition()
                queued_estimated_bytes = 0

                async def receive() -> None:
                    nonlocal queued_estimated_bytes
                    iterator = collector.stream(max_messages=None).__aiter__()
                    try:
                        while True:
                            remaining_ns = scheduled_end_ns - self._clock_ns()
                            if remaining_ns <= 0:
                                return
                            try:
                                item = await asyncio.wait_for(
                                    anext(iterator),
                                    timeout=remaining_ns / 1_000_000_000,
                                )
                            except _ScheduledEndReached:
                                return
                            except TimeoutError:
                                # Re-read absolute wall time.  Suspend/resume or a
                                # wall-clock adjustment must not turn this into a
                                # relative-duration completion.
                                continue
                            except PermissionError:
                                raise
                            except (OSError, WebSocketException) as error:
                                raise _DataCaptureIssue(
                                    "PUBLIC_STREAM_UNAVAILABLE",
                                    "RAW_CAPTURE",
                                    "public websocket transport was exhausted during the "
                                    "declared frozen window",
                                ) from error
                            except StopAsyncIteration:
                                if self._clock_ns() < scheduled_end_ns:
                                    raise _DataCaptureIssue(
                                        "STREAM_ENDED_EARLY",
                                        "RAW_CAPTURE",
                                        "public depth stream ended before scheduled UTC end",
                                    ) from None
                                return
                            received_ns = item.delta.received_ts_ns
                            if received_ns is None:
                                raise _DataCaptureIssue(
                                    "MISSING_RAW_LINEAGE",
                                    "NORMALIZATION",
                                    "captured message lacks local receipt time",
                                )
                            if received_ns < scheduled_start_ns:
                                continue
                            if received_ns >= scheduled_end_ns:
                                return
                            journal.consume_captured(item)
                            raw_size = len(item.raw_payload.encode("utf-8"))
                            item_estimated_bytes = max(
                                4_096, raw_size * _VARIABLE_RECORD_OVERHEAD_FACTOR
                            )
                            if item_estimated_bytes > queue_byte_budget:
                                raise _DataCaptureIssue(
                                    "RECEIVER_QUEUE_ITEM_BYTES_EXCEEDED",
                                    "RAW_CAPTURE",
                                    "one parsed frame exceeds the bounded receiver queue budget",
                                )
                            async with queue_condition:
                                while (
                                    queued_estimated_bytes + item_estimated_bytes
                                    > queue_byte_budget
                                    or queue.full()
                                ):
                                    remaining_ns = scheduled_end_ns - self._clock_ns()
                                    if remaining_ns <= 0:
                                        raise _DataCaptureIssue(
                                            "PROCESSING_BACKLOG_AT_END",
                                            "RAW_CAPTURE",
                                            "bounded receiver queue remained full at scheduled end",
                                        )
                                    try:
                                        await asyncio.wait_for(
                                            queue_condition.wait(),
                                            timeout=remaining_ns / 1_000_000_000,
                                        )
                                    except TimeoutError:
                                        raise _DataCaptureIssue(
                                            "PROCESSING_BACKLOG_AT_END",
                                            "RAW_CAPTURE",
                                            "bounded receiver queue remained full at scheduled end",
                                        ) from None
                                queue.put_nowait((item, item_estimated_bytes))
                                queued_estimated_bytes += item_estimated_bytes
                            state.max_queue_depth = max(state.max_queue_depth, queue.qsize())
                            state.max_queue_estimated_bytes = max(
                                state.max_queue_estimated_bytes, queued_estimated_bytes
                            )
                    finally:
                        closer = getattr(iterator, "aclose", None)
                        if callable(closer):
                            with suppress(BaseException):
                                await closer()

                receiver_task = asyncio.create_task(
                    receive(), name=f"m8-l2-receiver-{normalized_symbol}"
                )

                async def release_item(queued: tuple[CapturedDepth, int]) -> CapturedDepth:
                    nonlocal queued_estimated_bytes
                    item, estimated_bytes = queued
                    async with queue_condition:
                        queued_estimated_bytes -= estimated_bytes
                        if queued_estimated_bytes < 0:  # pragma: no cover - accounting invariant
                            raise RuntimeError("receiver queue byte accounting became negative")
                        queue_condition.notify_all()
                    return item

                async def next_item() -> CapturedDepth | None:
                    if not queue.empty():
                        return await release_item(queue.get_nowait())
                    if receiver_task is None:  # pragma: no cover - construction invariant
                        raise RuntimeError("receiver task was not initialized")
                    if receiver_task.done():
                        await receiver_task
                        return None
                    get_task = asyncio.create_task(queue.get())
                    done, _ = await asyncio.wait(
                        {get_task, receiver_task}, return_when=asyncio.FIRST_COMPLETED
                    )
                    if get_task in done:
                        return await release_item(get_task.result())
                    get_task.cancel()
                    with suppress(asyncio.CancelledError):
                        await get_task
                    if not queue.empty():
                        return await release_item(queue.get_nowait())
                    await receiver_task
                    return None

                while True:
                    item = await next_item()
                    if item is None:
                        break
                    delta = item.delta
                    received_ns = delta.received_ts_ns
                    if received_ns is None:  # pragma: no cover - receiver checks
                        raise RuntimeError("processed delta has no receipt timestamp")
                    if delta.continuity_id != state.current_continuity_id:
                        interval_tracker.break_continuity()
                        try:
                            snapshot = await _to_thread_joined(
                                client.fetch_depth_snapshot,
                                symbol=normalized_symbol,
                                raw_root=stage / "raw",
                                continuity_id=delta.continuity_id,
                                tick_size=metadata.tick_size,
                                lot_size=metadata.lot_size,
                            )
                        except BaseException as error:
                            classified = _classify_binance_data_error(error)
                            if classified is not None:
                                classified.phase = "SNAPSHOT_ANCHOR"
                                raise classified from error
                            raise
                        if not (scheduled_start_ns <= snapshot.received_ts_ns < scheduled_end_ns):
                            raise _DataCaptureIssue(
                                "SNAPSHOT_OUTSIDE_WINDOW",
                                "SNAPSHOT_ANCHOR",
                                "continuity snapshot was not received inside the frozen window",
                            )
                        raw_snapshot, snapshot_manifest = _snapshot_files(stage, snapshot)
                        journal.append_snapshot(
                            snapshot,
                            raw_path=raw_snapshot,
                            manifest_path=snapshot_manifest,
                        )
                        spools["book_snapshots"].append(
                            snapshot.to_record(),
                            estimated_bytes=max(
                                4_096, 128 * (len(snapshot.bids) + len(snapshot.asks))
                            ),
                        )
                        state.reconstructor = IncrementalBookReconstructor(snapshot)
                        state.current_continuity_id = delta.continuity_id
                        state.continuity_epochs += 1
                        state.reconstruction_status = "LIVE"

                    reconstructor = state.reconstructor
                    if reconstructor is None:  # pragma: no cover - guarded above
                        raise RuntimeError("continuity has no snapshot reconstructor")
                    raw_bytes = len(item.raw_payload.encode("utf-8"))
                    spools["depth_deltas"].append(
                        delta.to_record(),
                        estimated_bytes=max(4_096, raw_bytes * _VARIABLE_RECORD_OVERHEAD_FACTOR),
                    )
                    try:
                        step = reconstructor.update(delta)
                    except BaseException as error:
                        classified = _classify_binance_data_error(error)
                        if classified is not None:
                            raise classified from error
                        raise
                    if step.observation is not None:
                        spools["book_observations"].append(step.observation, estimated_bytes=4_096)
                    else:
                        state.excluded_rows += 1
                    if step.gap is not None:
                        spools["sequence_gaps"].append(step.gap.to_record(), estimated_bytes=2_048)
                        state.sequence_gaps += 1
                    if step.outcome == "OBSERVED":
                        if step.observation is None:  # pragma: no cover - outcome invariant
                            raise RuntimeError("OBSERVED step lacks its book observation")
                        available_ns = step.observation["available_ts_ns"]
                        if isinstance(available_ns, bool) or not isinstance(available_ns, int):
                            raise RuntimeError(
                                "OBSERVED book availability timestamp is not an integer"
                            )
                        interval_tracker.observed(
                            delta.continuity_id,
                            available_ns,
                        )
                    else:
                        interval_tracker.excluded(delta.continuity_id)
                    if step.outcome == "STALE":
                        state.stale_rows += 1
                    state.reconstruction_status = reconstructor.status
                    if step.outcome in {"GAP", "INVALID", "EXCLUDED_AFTER_TERMINAL"}:
                        raise _DataCaptureIssue(
                            "SEQUENCE_CONTINUITY_FAILED",
                            "RECONSTRUCTION",
                            f"{normalized_symbol} reconstruction outcome was {step.outcome}",
                        )

                if journal.messages == 0:
                    raise _DataCaptureIssue(
                        "NO_IN_WINDOW_MESSAGES",
                        "RAW_CAPTURE",
                        "scheduled window contained no accepted depth frames",
                    )
                if self._clock_ns() < scheduled_end_ns:
                    raise _DataCaptureIssue(
                        "SCHEDULED_END_NOT_REACHED",
                        "RAW_CAPTURE",
                        "capture transport stopped before the absolute scheduled UTC end",
                    )
                completion_reason = "scheduled_end_reached"
            except BaseException as error:
                capture_error = _classify_binance_data_error(error) or error
            finally:
                if receiver_task is not None and not receiver_task.done():
                    receiver_task.cancel()
                    with suppress(BaseException):
                        await receiver_task

            finalization_error: BaseException | None = None
            try:
                for spool in spools.values():
                    spool.close()
                validation_reports = (
                    delta_validator.finish(),
                    observation_validator.finish(),
                )
                validators_finished = True
                raw_evidence = journal.publish(
                    capture_status=(
                        "raw_capture_complete" if capture_error is None else "incomplete_capture"
                    ),
                    error=capture_error,
                )
                normalized_root = stage / "normalized" / "captures" / capture_id
                time_columns = {
                    "book_snapshots": "received_ts_ns",
                    "depth_deltas": "event_ts_ns",
                    "book_observations": "event_ts_ns",
                    "sequence_gaps": "detected_ts_ns",
                }
                dataset_manifests: dict[str, dict[str, object]] = {}
                for schema_name, spool in spools.items():
                    stored = write_capture_parquet(
                        spool.iter_batches(),
                        root=normalized_root,
                        dataset=schema_name,
                        schema_name=schema_name,
                        venue="binance_spot",
                        symbol=normalized_symbol,
                        capture_id=capture_id,
                        source="binance_spot_public_live_capture_journal",
                        source_uri=str(raw_evidence.path.relative_to(stage)),
                        source_checksum_sha256=raw_evidence.sha256,
                        requested_start_ns=scheduled_start_ns,
                        requested_end_ns=scheduled_end_ns,
                        time_column=time_columns[schema_name],
                        max_input_batch_rows=_BATCH_ROWS,
                    )
                    if stored.rows != spool.rows:
                        raise RuntimeError(
                            f"stored {schema_name} rows differ from its verified Arrow spool"
                        )
                    dataset_manifests[schema_name] = {
                        "data_path": (
                            str(stored.data_path.relative_to(stage))
                            if stored.data_path is not None
                            else None
                        ),
                        "data_sha256": stored.data_sha256,
                        "manifest_path": str(stored.manifest_path.relative_to(stage)),
                        "manifest_sha256": stored.manifest_sha256,
                        "rows": stored.rows,
                    }

                quality_root = stage / "quality"
                quality_root.mkdir(parents=True, exist_ok=True)
                quality_paths: dict[str, str] = {}
                for report in validation_reports:
                    report_path = quality_root / f"{report.dataset}.validation.json"
                    report.write_json(report_path)
                    quality_paths[report.dataset] = report_path.relative_to(stage).as_posix()
                intervals = interval_tracker.finish()
                quality_errors = sum(item.error_count for item in validation_reports)
                quality_warnings = sum(item.warning_count for item in validation_reports)
                summary_path = quality_root / "capture.summary.json"
                inventory_without_summary = _artifacts(stage)
                summary_payload: dict[str, object] = {
                    "schema_version": "m8-binance-l2-symbol-capture-v1",
                    "generated_at_utc": utc_now_iso(),
                    "capture_id": capture_id,
                    "symbol": normalized_symbol,
                    "capture_status": "COMPLETE" if capture_error is None else "FAILED",
                    "completion_reason": completion_reason,
                    "failure_reason_code": (
                        capture_error.reason_code
                        if isinstance(capture_error, _DataCaptureIssue)
                        else None
                    ),
                    "failure_phase": (
                        capture_error.phase
                        if isinstance(capture_error, _DataCaptureIssue)
                        else None
                    ),
                    "failure_type": (
                        type(capture_error).__name__ if capture_error is not None else None
                    ),
                    "failure_message": (
                        str(capture_error)[:2048] if capture_error is not None else None
                    ),
                    "scheduled_range_ns": {
                        "start": scheduled_start_ns,
                        "end_exclusive": scheduled_end_ns,
                    },
                    "messages": journal.messages,
                    "first_raw_received_ns": journal.first_received_ns,
                    "last_raw_received_ns": journal.last_received_ns,
                    "normalized_rows": spools["depth_deltas"].rows,
                    "reconstructed_rows": spools["book_observations"].rows,
                    "excluded_rows": spools["depth_deltas"].rows - spools["book_observations"].rows,
                    "continuity_epochs": state.continuity_epochs,
                    "snapshot_anchors": journal.snapshot_anchors,
                    "sequence_gaps": spools["sequence_gaps"].rows,
                    "stale_rows": state.stale_rows,
                    "reconstruction_status": state.reconstruction_status,
                    "quality_errors": quality_errors,
                    "quality_warnings": quality_warnings,
                    "quality_reports": quality_paths,
                    "valid_observed_intervals": [item.to_dict() for item in intervals],
                    "raw_journal": raw_evidence.path.relative_to(stage).as_posix(),
                    "raw_journal_sha256": raw_evidence.sha256,
                    "raw_journal_manifest": raw_evidence.manifest_path.relative_to(
                        stage
                    ).as_posix(),
                    "raw_journal_manifest_sha256": raw_evidence.manifest_sha256,
                    "normalized_dataset_manifests": dataset_manifests,
                    "artifact_inventory_without_summary": [
                        {
                            "path": item.path.relative_to(stage).as_posix(),
                            "kind": item.kind,
                            "sha256": item.sha256,
                            "bytes": item.path.stat().st_size,
                        }
                        for item in inventory_without_summary
                    ],
                    "receiver_queue_capacity": queue_capacity,
                    "receiver_queue_estimated_byte_budget": queue_byte_budget,
                    "max_receiver_queue_depth": state.max_queue_depth,
                    "max_receiver_queue_estimated_bytes": state.max_queue_estimated_bytes,
                    "max_raw_frame_bytes_observed": journal.max_frame_bytes_observed,
                    "max_arrow_batch_bytes_observed": max(
                        spool.max_batch_bytes_observed for spool in spools.values()
                    ),
                    "live_trading": False,
                    "policy": (
                        "raw websocket bytes precede parsing; snapshots are fresh per continuity; "
                        "only consecutive OBSERVED receipts with no >5s silence form coverage"
                    ),
                }
                write_json(summary_path, summary_payload)
            except BaseException as error:
                finalization_error = error
            finally:
                if not validators_finished:
                    delta_validator.close()
                    observation_validator.close()
                if raw_evidence is None:
                    with suppress(BaseException):
                        raw_evidence = journal.publish(
                            capture_status="finalization_failure", error=finalization_error
                        )
                journal.close_without_publish()

            if finalization_error is not None:
                if capture_error is not None:
                    finalization_error.add_note(
                        f"capture also failed with {type(capture_error).__name__}: {capture_error}"
                    )
                raise finalization_error

            if validation_reports is None or raw_evidence is None:
                raise RuntimeError("capture finalization omitted required evidence")
            intervals = interval_tracker.finish()
            quality_errors = sum(item.error_count for item in validation_reports)
            quality_warnings = sum(item.warning_count for item in validation_reports)
            result = SymbolCaptureResult(
                symbol=normalized_symbol,
                capture_id=capture_id,
                status="FAILED" if capture_error is not None else "COMPLETE",
                completion_reason=completion_reason,
                reconstruction_status=state.reconstruction_status,
                messages=journal.messages,
                normalized_rows=spools["depth_deltas"].rows,
                reconstructed_rows=spools["book_observations"].rows,
                excluded_rows=spools["depth_deltas"].rows - spools["book_observations"].rows,
                continuity_epochs=state.continuity_epochs,
                snapshot_anchors=journal.snapshot_anchors,
                sequence_gaps=spools["sequence_gaps"].rows,
                quality_errors=quality_errors,
                quality_warnings=quality_warnings,
                max_raw_frame_bytes_observed=journal.max_frame_bytes_observed,
                max_arrow_batch_bytes_observed=max(
                    spool.max_batch_bytes_observed for spool in spools.values()
                ),
                first_raw_received_ns=journal.first_received_ns,
                last_raw_received_ns=journal.last_received_ns,
                valid_observed_intervals=intervals,
                artifacts=_artifacts(stage),
                failure_reason_code=(
                    capture_error.reason_code
                    if isinstance(capture_error, _DataCaptureIssue)
                    else None
                ),
                failure_phase=(
                    capture_error.phase if isinstance(capture_error, _DataCaptureIssue) else None
                ),
            )
            if capture_error is None:
                return result
            if isinstance(capture_error, _DataCaptureIssue):
                raise M8L2DataFailure(
                    capture_error.reason_code,
                    phase=capture_error.phase,
                    message=str(capture_error),
                    partial_result=result,
                ) from capture_error
            raise capture_error


__all__ = ["BinanceM8L2Capture"]