capture-runtime-client 0.4.1__tar.gz → 0.4.3__tar.gz

{capture_runtime_client-0.4.1 → capture_runtime_client-0.4.3}/.gitignore

@@ -1,13 +1,15 @@
-# See https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files for more about ignoring files.
-
-# compiled output
-dist
-tmp
-out-tsc
-
-# dependencies
-node_modules
-tools/local-registry/storage/
+# See https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files for more about ignoring files.
+
+# compiled output
+dist
+output/
+proofshot-artifacts/
+tmp
+out-tsc
+
+# dependencies
+node_modules
+tools/local-registry/storage/
 tools/local-registry/htpasswd
 
 # IDEs and editors

{capture_runtime_client-0.4.1 → capture_runtime_client-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: capture-runtime-client
-Version: 0.4.1
+Version: 0.4.3
 Summary: Capture Runtime HTTP, in-memory, discovery, and protocol client SDK.
 License: MIT
 Requires-Python: <3.15,>=3.12

{capture_runtime_client-0.4.1 → capture_runtime_client-0.4.3}/README.md

@@ -1,8 +1,8 @@
-# capture-runtime-client
-
-Backend-side Capture Runtime client SDK.  It owns loopback endpoint
-validation, readiness/schema-hash negotiation, authenticated HTTP and
-deterministic in-memory transports, canonical v2 request methods, SSE decoding, and
-redacted common errors. Generated Pydantic models are private SDK build input;
-consumers import them from `capture_runtime_client`, never from a generated
-contracts package.
+# capture-runtime-client
+
+Backend-side Capture Runtime client SDK.  It owns loopback endpoint
+validation, readiness/schema-hash negotiation, authenticated HTTP and
+deterministic in-memory transports, canonical v2 request methods, SSE decoding, and
+redacted common errors. Generated Pydantic models are private SDK build input;
+consumers import them from `capture_runtime_client`, never from a generated
+contracts package.

{capture_runtime_client-0.4.1 → capture_runtime_client-0.4.3}/project.json

@@ -1,25 +1,25 @@
-{
-  "name": "capture-runtime-client-python",
-  "sourceRoot": "packages/capture-runtime-client-python/src",
-  "projectType": "library",
-  "tags": ["scope:capture", "type:sdk"],
-  "targets": {
-    "test": {
-      "executor": "nx:run-commands",
-      "options": { "command": "uv run --project packages/capture-runtime-client-python pytest packages/capture-runtime-client-python/tests" }
-    },
-    "lint": {
-      "executor": "nx:run-commands",
-      "options": { "command": "uv run --project packages/capture-runtime-client-python ruff check packages/capture-runtime-client-python/src packages/capture-runtime-client-python/tests" }
-    },
-    "typecheck": {
-      "executor": "nx:run-commands",
-      "options": { "command": "uv run --project packages/capture-runtime-client-python mypy packages/capture-runtime-client-python/src" }
-    },
-    "build": {
-      "executor": "nx:run-commands",
-      "outputs": ["{projectRoot}/dist"],
-      "options": { "command": "uv build --project packages/capture-runtime-client-python" }
-    }
-  }
-}
+{
+  "name": "capture-runtime-client-python",
+  "sourceRoot": "packages/capture-runtime-client-python/src",
+  "projectType": "library",
+  "tags": ["scope:capture", "type:sdk"],
+  "targets": {
+    "test": {
+      "executor": "nx:run-commands",
+      "options": { "command": "uv run --project packages/capture-runtime-client-python pytest packages/capture-runtime-client-python/tests" }
+    },
+    "lint": {
+      "executor": "nx:run-commands",
+      "options": { "command": "uv run --project packages/capture-runtime-client-python ruff check packages/capture-runtime-client-python/src packages/capture-runtime-client-python/tests" }
+    },
+    "typecheck": {
+      "executor": "nx:run-commands",
+      "options": { "command": "uv run --project packages/capture-runtime-client-python mypy packages/capture-runtime-client-python/src" }
+    },
+    "build": {
+      "executor": "nx:run-commands",
+      "outputs": ["{projectRoot}/dist"],
+      "options": { "command": "uv build --project packages/capture-runtime-client-python" }
+    }
+  }
+}

{capture_runtime_client-0.4.1 → capture_runtime_client-0.4.3}/pyproject.toml

@@ -1,49 +1,51 @@
-[build-system]
-requires = ["hatchling>=1.27.0,<2.0.0"]
-build-backend = "hatchling.build"
-
-[project]
-name = "capture-runtime-client"
-version = "0.4.1"
-description = "Capture Runtime HTTP, in-memory, discovery, and protocol client SDK."
-readme = "README.md"
-requires-python = ">=3.12,<3.15"
-license = { text = "MIT" }
-dependencies = [
-  "httpx>=0.27.0,<1.0.0",
-  "pydantic>=2.13.4,<3.0.0",
-]
-
-[tool.capture_runtime_client]
-contract_set_sha256 = "b28366f022533192c063056bbf64cacfd09390815c65408066369dd61094e278"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/capture_runtime_client"]
-
-[tool.hatch.build.targets.wheel.force-include]
-"src/capture_runtime_client/py.typed" = "capture_runtime_client/py.typed"
-"src/capture_runtime_client/private/assets/contract-set.json" = "capture_runtime_client/private/assets/contract-set.json"
-"src/capture_runtime_client/private/assets/contract-set.sha256" = "capture_runtime_client/private/assets/contract-set.sha256"
-
-[dependency-groups]
-dev = [
-  "mypy>=1.14.0,<2.0.0",
-  "pytest>=8.3.0,<9.0.0",
-  "ruff>=0.9.0,<1.0.0",
-]
-
-[tool.pytest.ini_options]
-pythonpath = ["src"]
-testpaths = ["tests"]
-addopts = "-ra"
-
-[tool.ruff]
-line-length = 100
-target-version = "py312"
-
-[tool.ruff.lint]
-select = ["B", "E", "F", "I", "UP"]
-
-[tool.mypy]
-python_version = "3.12"
-strict = true
+[build-system]
+requires = ["hatchling>=1.27.0,<2.0.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "capture-runtime-client"
+version = "0.4.3"
+description = "Capture Runtime HTTP, in-memory, discovery, and protocol client SDK."
+readme = "README.md"
+requires-python = ">=3.12,<3.15"
+license = { text = "MIT" }
+dependencies = [
+  "httpx>=0.27.0,<1.0.0",
+  "pydantic>=2.13.4,<3.0.0",
+]
+
+[tool.capture_runtime_client]
+contract_set_sha256 = "232ef06bf547e79120df28f39303e73b0e5842beace5910a422f15dfb5e2acbc"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/capture_runtime_client"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"src/capture_runtime_client/py.typed" = "capture_runtime_client/py.typed"
+"src/capture_runtime_client/private/assets/contract-set.json" = "capture_runtime_client/private/assets/contract-set.json"
+"src/capture_runtime_client/private/assets/contract-set.sha256" = "capture_runtime_client/private/assets/contract-set.sha256"
+
+[dependency-groups]
+dev = [
+  "mypy>=1.14.0,<2.0.0",
+  "pytest>=8.3.0,<9.0.0",
+  "ruff>=0.9.0,<1.0.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+addopts = "-ra"
+# Remove tmp_path directories after every session; tests must not leave temp files.
+tmp_path_retention_policy = "failed"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["B", "E", "F", "I", "UP"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true

{capture_runtime_client-0.4.1 → capture_runtime_client-0.4.3}/src/capture_runtime_client/__init__.py

@@ -1,41 +1,41 @@
-"""Public Capture Runtime client SDK."""
-
-from .client import CaptureRuntimeClient, CaptureStreamingResult, CaptureUpload, RuntimeDiscovery
-from .contracts import *  # noqa: F401,F403
-from .contracts import __all__ as _contract_names
-from .errors import (
-    CaptureAuthenticationError,
-    CaptureCompatibilityError,
-    CaptureProtocolError,
-    CaptureRemoteError,
-    CaptureRuntimeCompatibilityError,
-    CaptureRuntimeError,
-    CaptureRuntimeProtocolError,
-    CaptureTransportError,
-)
-from .transport import (
-    HttpRuntimeTransport,
-    InMemoryRoute,
-    InMemoryRuntimeTransport,
-    validate_loopback_base_url,
-)
-
-__all__ = [
-    "CaptureRuntimeClient",
-    "CaptureAuthenticationError",
-    "CaptureCompatibilityError",
-    "CaptureProtocolError",
-    "CaptureRemoteError",
-    "CaptureTransportError",
-    "CaptureRuntimeCompatibilityError",
-    "CaptureRuntimeError",
-    "CaptureRuntimeProtocolError",
-    "CaptureStreamingResult",
-    "CaptureUpload",
-    "HttpRuntimeTransport",
-    "InMemoryRoute",
-    "InMemoryRuntimeTransport",
-    "RuntimeDiscovery",
-    "validate_loopback_base_url",
-    *_contract_names,
-]
+"""Public Capture Runtime client SDK."""
+
+from .client import CaptureRuntimeClient, CaptureStreamingResult, CaptureUpload, RuntimeDiscovery
+from .contracts import *  # noqa: F401,F403
+from .contracts import __all__ as _contract_names
+from .errors import (
+    CaptureAuthenticationError,
+    CaptureCompatibilityError,
+    CaptureProtocolError,
+    CaptureRemoteError,
+    CaptureRuntimeCompatibilityError,
+    CaptureRuntimeError,
+    CaptureRuntimeProtocolError,
+    CaptureTransportError,
+)
+from .transport import (
+    HttpRuntimeTransport,
+    InMemoryRoute,
+    InMemoryRuntimeTransport,
+    validate_loopback_base_url,
+)
+
+__all__ = [
+    "CaptureRuntimeClient",
+    "CaptureAuthenticationError",
+    "CaptureCompatibilityError",
+    "CaptureProtocolError",
+    "CaptureRemoteError",
+    "CaptureTransportError",
+    "CaptureRuntimeCompatibilityError",
+    "CaptureRuntimeError",
+    "CaptureRuntimeProtocolError",
+    "CaptureStreamingResult",
+    "CaptureUpload",
+    "HttpRuntimeTransport",
+    "InMemoryRoute",
+    "InMemoryRuntimeTransport",
+    "RuntimeDiscovery",
+    "validate_loopback_base_url",
+    *_contract_names,
+]

capture_runtime_client-0.4.3/src/capture_runtime_client/_discovery.py

@@ -0,0 +1,353 @@
+"""Private authenticated runtime discovery and contract validation."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections.abc import Callable, Collection, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from ._error_mapping import decode_response
+from .codec import decode_model
+from .contracts import (
+    CAPTURE_API_VERSION,
+    CAPTURE_DOCUMENT_SCHEMA_SHA256,
+    CAPTURE_DOCUMENT_SCHEMA_VERSION,
+    CAPTURE_RUNTIME_VERSION,
+    RuntimeReady,
+    RuntimeStreamingCapabilities,
+    StructuringMode,
+)
+from .errors import CaptureRuntimeCompatibilityError, CaptureRuntimeProtocolError
+
+RequestFn = Callable[..., httpx.Response]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeDiscovery:
+    """Authenticated compatibility evidence cached by ``CaptureRuntimeClient``."""
+
+    ready: RuntimeReady
+    streaming: RuntimeStreamingCapabilities | None
+    schema_sha256: str
+    contract_index: Mapping[str, Any]
+    contract_bundle: Mapping[str, Any]
+
+
+def handshake(request: RequestFn) -> RuntimeReady:
+    """Validate readiness using the SDK's compiled v2 compatibility identity."""
+    response = request("GET", "/v2/health/ready")
+    payload = decode_response(response)
+    if not isinstance(payload, Mapping):
+        raise CaptureRuntimeProtocolError("Capture Runtime readiness response is not an object.")
+    assert_compatible_payload(payload)
+    ready = decode_model(httpx.Response(200, json=payload), RuntimeReady)
+    assert_compatible(ready)
+    return ready
+
+
+def discover(
+    request: RequestFn,
+    *,
+    allowed_contract_set_sha256: Collection[str],
+) -> RuntimeDiscovery:
+    """Perform one authenticated, immutable contract discovery transaction."""
+    ready = handshake(request)
+    index_response = request("GET", "/meta/v2/contracts")
+    index = decode_response(index_response)
+    if not isinstance(index, Mapping):
+        raise CaptureRuntimeProtocolError("Capture Runtime contract index is not an object.")
+    validate_contract_index(index, ready)
+    href = index.get("href")
+    if not isinstance(href, str) or not href.startswith("/meta/v2/contracts/sha256/"):
+        raise CaptureRuntimeProtocolError("Capture Runtime contract index href is invalid.")
+    href_digest = href.removeprefix("/meta/v2/contracts/sha256/")
+    if not re.fullmatch(r"[0-9a-f]{64}", href_digest) or href_digest != index.get("sha256"):
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract index href digest does not match its advertised bundle hash."
+        )
+    bundle_response = request("GET", href)
+    bundle_bytes = bundle_response.content
+    digest = hashlib.sha256(bundle_bytes).hexdigest()
+    if digest not in allowed_contract_set_sha256:
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract bundle identity is not allowlisted."
+        )
+    etag = bundle_response.headers.get("etag")
+    if (
+        digest != index.get("sha256")
+        or bundle_response.headers.get("x-contract-sha256") not in {None, digest}
+        or (etag is not None and etag not in {digest, f'"{digest}"'})
+    ):
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract bundle hash is incompatible."
+        )
+    try:
+        bundle = json.loads(bundle_bytes)
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise CaptureRuntimeProtocolError(
+            "Capture Runtime contract bundle is not valid JSON."
+        ) from error
+    schema_sha256 = validate_contract_bundle(bundle, digest)
+    streaming = decode_model(
+        request("GET", "/v2/streaming/health/ready"), RuntimeStreamingCapabilities
+    )
+    return RuntimeDiscovery(
+        ready=ready,
+        streaming=streaming,
+        schema_sha256=schema_sha256,
+        contract_index=index,
+        contract_bundle=bundle,
+    )
+
+
+def assert_compatible(ready: RuntimeReady) -> None:
+    failures: list[str] = []
+    if ready.api_version != CAPTURE_API_VERSION:
+        failures.append(f"API version {ready.api_version} is unsupported")
+    if ready.capture_document_schema_version != CAPTURE_DOCUMENT_SCHEMA_VERSION:
+        failures.append("CaptureDocument schema version is unsupported")
+    if ready.runtime_version != CAPTURE_RUNTIME_VERSION:
+        failures.append(
+            f"runtime version {ready.runtime_version} is incompatible with "
+            f"{CAPTURE_RUNTIME_VERSION}"
+        )
+    structuring_modes = ready.capabilities.get("structuringModes", [])
+    if (
+        StructuringMode.HOST.value not in structuring_modes
+        and StructuringMode.RUNTIME.value not in structuring_modes
+    ):
+        failures.append("runtime exposes no structuring mode")
+    if failures:
+        raise CaptureRuntimeCompatibilityError("; ".join(failures))
+
+
+def assert_compatible_payload(payload: Mapping[str, Any]) -> None:
+    failures: list[str] = []
+    if payload.get("apiVersion") != CAPTURE_API_VERSION:
+        failures.append("API version is unsupported")
+    if payload.get("captureDocumentSchemaVersion") != CAPTURE_DOCUMENT_SCHEMA_VERSION:
+        failures.append("CaptureDocument schema version is unsupported")
+    if failures:
+        raise CaptureRuntimeCompatibilityError("; ".join(failures))
+
+
+def validate_contract_index(index: Mapping[str, Any], ready: RuntimeReady) -> None:
+    required = {
+        "catalogVersion",
+        "runtimeVersion",
+        "contractSetVersion",
+        "surfaces",
+        "sha256",
+        "href",
+    }
+    if not required.issubset(index):
+        raise CaptureRuntimeProtocolError(
+            "Capture Runtime contract index is missing required fields."
+        )
+    if index.get("catalogVersion") != "2" or index.get("contractSetVersion") != "2":
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract catalog version is unsupported."
+        )
+    if index.get("runtimeVersion") != ready.runtime_version:
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract catalog runtimeVersion is incompatible."
+        )
+    if not isinstance(index.get("sha256"), str) or not re.fullmatch(
+        r"[0-9a-f]{64}", index["sha256"]
+    ):
+        raise CaptureRuntimeProtocolError("Capture Runtime contract index hash is invalid.")
+    surfaces = index.get("surfaces")
+    if not isinstance(surfaces, list) or {
+        surface.get("id") for surface in surfaces if isinstance(surface, Mapping)
+    } != {"v2"}:
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract catalog does not expose the v2 surface."
+        )
+
+
+def validate_contract_bundle(bundle: Any, digest: str) -> str:
+    if (
+        not isinstance(bundle, Mapping)
+        or bundle.get("contractSetVersion") != "2"
+        or bundle.get("schemaDialect") != "https://json-schema.org/draft/2020-12/schema"
+    ):
+        raise CaptureRuntimeProtocolError("Capture Runtime contract bundle is invalid.")
+    for field in ("surfaces", "schemas", "operations", "problems", "invariants"):
+        if not isinstance(bundle.get(field), list):
+            raise CaptureRuntimeProtocolError(
+                f"Capture Runtime contract bundle {field} is invalid."
+            )
+    surfaces = bundle["surfaces"]
+    surface_ids = {surface.get("id") for surface in surfaces if isinstance(surface, Mapping)}
+    if surface_ids != {"v2"}:
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract bundle does not expose the v2 surface."
+        )
+    operations_value = bundle["operations"]
+    if not isinstance(operations_value, list):
+        raise CaptureRuntimeProtocolError("Capture Runtime contract bundle operations are invalid.")
+    operations: list[Any] = operations_value
+    for operation in operations:
+        if not isinstance(operation, Mapping) or not all(
+            isinstance(operation.get(field), expected)
+            for field, expected in (
+                ("path", str),
+                ("method", str),
+                ("surface", str),
+                ("body", Mapping),
+                ("requiredHeaders", list),
+                ("idempotency", Mapping),
+                ("responseStatusCodes", list),
+            )
+        ):
+            raise CaptureRuntimeProtocolError(
+                "Capture Runtime contract operation metadata is invalid."
+            )
+    operation_paths = {
+        operation.get("path") for operation in operations if isinstance(operation, Mapping)
+    }
+    required_paths = {
+        "/v2/health/ready",
+        "/v2/streaming/health/ready",
+        "/v2/runtime/requirements",
+        "/v2/runtime/installations",
+        "/v2/runtime/model-options",
+        "/v2/runtime/model-installations",
+        "/v2/captures",
+        "/v2/captures/{capture_id}/events",
+        "/v2/captures/{capture_id}/raw",
+        "/v2/captures/{capture_id}/ocr",
+        "/v2/captures/{capture_id}/result",
+        "/v2/captures/{capture_id}/structure/session",
+        "/v2/captures/{capture_id}/structure/session/batches/{batch_index}",
+    }
+    if not required_paths.issubset(operation_paths):
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract bundle does not advertise the required client surface."
+        )
+
+    def find_operation(path: str, method: str | None = None) -> Mapping[str, Any] | None:
+        return next(
+            (
+                item
+                for item in operations
+                if isinstance(item, Mapping)
+                and item.get("path") == path
+                and (method is None or item.get("method") == method)
+            ),
+            None,
+        )
+
+    upload = find_operation("/v2/captures")
+    chunk = find_operation("/v2/ingestions/{ingestion_id}/chunks/{chunk_index}")
+    events = find_operation("/v2/captures/{capture_id}/events")
+    ocr = find_operation("/v2/captures/{capture_id}/ocr", "GET")
+    session_open = find_operation("/v2/captures/{capture_id}/structure/session", "POST")
+    batch_get = find_operation(
+        "/v2/captures/{capture_id}/structure/session/batches/{batch_index}", "GET"
+    )
+    batch_submit = find_operation(
+        "/v2/captures/{capture_id}/structure/session/batches/{batch_index}", "PUT"
+    )
+    if (
+        upload is None
+        or not isinstance(upload.get("body"), Mapping)
+        or upload["body"].get("kind") not in {"json", "none"}
+        or "X-Idempotency-Key" not in upload.get("requiredHeaders", [])
+    ):
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime v2 capture metadata is incompatible."
+        )
+    if (
+        chunk is None
+        or not isinstance(chunk.get("body"), Mapping)
+        or chunk["body"].get("kind") != "binary"
+        or not all(
+            header in chunk.get("requiredHeaders", [])
+            for header in ("Content-Range", "Digest", "X-Idempotency-Key")
+        )
+    ):
+        raise CaptureRuntimeCompatibilityError("Capture Runtime v2 chunk metadata is incompatible.")
+    streaming = events.get("streaming") if events is not None else None
+    if (
+        events is None
+        or events.get("mediaType") != "text/event-stream"
+        or not isinstance(streaming, Mapping)
+        or streaming.get("kind") != "sse"
+        or streaming.get("lastEventIdHeader") != "Last-Event-ID"
+    ):
+        raise CaptureRuntimeCompatibilityError("Capture Runtime SSE metadata is incompatible.")
+    if (
+        ocr is None
+        or not isinstance(ocr.get("body"), Mapping)
+        or ocr["body"].get("kind") != "none"
+        or ocr.get("responseSchema") != "CaptureOcrProjectionV3"
+        or 200 not in ocr.get("responseStatusCodes", [])
+    ):
+        raise CaptureRuntimeCompatibilityError("Capture Runtime OCR metadata is incompatible.")
+    if (
+        session_open is None
+        or not isinstance(session_open.get("body"), Mapping)
+        or session_open["body"].get("kind") != "json"
+        or "X-Idempotency-Key" not in session_open.get("requiredHeaders", [])
+        or session_open.get("idempotency", {}).get("mode") != "required"
+        or batch_get is None
+        or not isinstance(batch_get.get("body"), Mapping)
+        or batch_get["body"].get("kind") != "none"
+        or batch_submit is None
+        or not isinstance(batch_submit.get("body"), Mapping)
+        or batch_submit["body"].get("kind") != "json"
+        or "X-Idempotency-Key" not in batch_submit.get("requiredHeaders", [])
+        or batch_submit.get("idempotency", {}).get("mode") != "required"
+    ):
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime pull-session metadata is incompatible."
+        )
+    canonical_bundle = json.dumps(
+        bundle,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode("utf-8")
+    if hashlib.sha256(canonical_bundle).hexdigest() != digest:
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime contract bundle bytes are not canonical."
+        )
+    schemas = bundle.get("schemas")
+    document = (
+        next(
+            (
+                item
+                for item in schemas
+                if isinstance(item, Mapping) and item.get("name") == "CaptureDocument"
+            ),
+            None,
+        )
+        if isinstance(schemas, list)
+        else None
+    )
+    if (
+        not isinstance(document, Mapping)
+        or document.get("schemaSha256") != CAPTURE_DOCUMENT_SCHEMA_SHA256
+    ):
+        raise CaptureRuntimeCompatibilityError(
+            "Capture Runtime document schema hash is incompatible."
+        )
+    return str(document["schemaSha256"])
+
+
+__all__ = [
+    "RuntimeDiscovery",
+    "assert_compatible",
+    "assert_compatible_payload",
+    "discover",
+    "handshake",
+    "validate_contract_bundle",
+    "validate_contract_index",
+]