simulo-interfaces 0.24.0__tar.gz → 0.25.0__tar.gz

{simulo_interfaces-0.24.0 → simulo_interfaces-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo-interfaces
-Version: 0.24.0
+Version: 0.25.0
 Summary: Typed Python contracts for the Simulo cloud robotics SDK and managed simulation runtime.
 Author-email: Simulo Team <team@simulo.ai>
 License: BSD-3-Clause

{simulo_interfaces-0.24.0 → simulo_interfaces-0.25.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulo-interfaces"
-version = "0.24.0"
+version = "0.25.0"
 description = "Typed Python contracts for the Simulo cloud robotics SDK and managed simulation runtime."
 readme = "PYPI.md"
 requires-python = ">=3.11"

{simulo_interfaces-0.24.0 → simulo_interfaces-0.25.0}/src/simulo/interfaces/authoring/__init__.py

@@ -17,7 +17,7 @@ decision — to resolve that exact name collision), and ``light`` (``Light``,
 ``RoughTerrain``), ``primitives`` (``PrimitiveShape``, ``Cone``,
 ``Cuboid``, ``Sphere``, ``Cylinder``, ``Transform``), ``entity`` (``Entity``,
 ``AssetEntity``), and ``visual`` (``Visual``, ``VisualMarkerBase``,
-``AxesMarker``, ``SphereMarker``, ``ArrowMarker``, ``PointMarker``).
+``AxesMarker``, ``SphereMarker``, ``ArrowMarker``, ``PointMarker``, ``LineMarker``).
 Wave C4: ``record`` (``RecordConfig`` — the MCAP recording configuration;
 stdlib-only, so it classifies RELOCATE, and the backend recorder imports it
 from here), and ``world`` (``World``, ``USDWorld``): ``Terrain`` is the
@@ -84,11 +84,17 @@ and cross-references for cryptic engine-style names) — that table, not this
 docstring, is the source of truth for what lands here and when.
 """
 
+from simulo.interfaces.authoring.action_channel import ActionChannel
 from simulo.interfaces.authoring.actuator import ActuatorProtocol
 from simulo.interfaces.authoring.asset import AssetSource, URDFAsset, USDAsset
 from simulo.interfaces.authoring.checkpoint import PolicyCheckpoint
 from simulo.interfaces.authoring.entity import AssetEntity, Entity
-from simulo.interfaces.authoring.light import DistantLight, DomeLight, Light, LightConfig
+from simulo.interfaces.authoring.light import (
+    DistantLight,
+    DomeLight,
+    Light,
+    LightConfig,
+)
 from simulo.interfaces.authoring.materials import Material, SurfaceMaterial
 from simulo.interfaces.authoring.physics import (
     Collision,
@@ -107,11 +113,17 @@ from simulo.interfaces.authoring.primitives import (
     Sphere,
     Transform,
 )
-from simulo.interfaces.authoring.prop import PropProtocol, PropStateProtocol
+from simulo.interfaces.authoring.prop import PropProtocol, PropStateProtocol, VariantPropProtocol
+from simulo.interfaces.authoring.properties import (
+    ExternalForceProtocol,
+    PropPropertiesProtocol,
+    RobotPropertiesProtocol,
+    SceneGravityProtocol,
+)
 from simulo.interfaces.authoring.record import RecordConfig
 from simulo.interfaces.authoring.robot import RobotProtocol, RobotStateProtocol
 from simulo.interfaces.authoring.robot_config import ActuatorGainsConfig, ArticulationConfig, JointConfig
-from simulo.interfaces.authoring.scene import SceneGroupProtocol, SceneProtocol
+from simulo.interfaces.authoring.scene import SceneGroupProtocol, SceneProtocol, SceneVariantsProtocol
 from simulo.interfaces.authoring.sensor import CameraProtocol
 from simulo.interfaces.authoring.terrain import (
     GroundPlane,
@@ -120,9 +132,11 @@ from simulo.interfaces.authoring.terrain import (
     Terrain,
     TerrainConfig,
 )
+from simulo.interfaces.authoring.variants import ObjectVariants
 from simulo.interfaces.authoring.visual import (
     ArrowMarker,
     AxesMarker,
+    LineMarker,
     PointMarker,
     SphereMarker,
     Visual,
@@ -183,20 +197,31 @@ __all__ = [
     "SphereMarker",
     "ArrowMarker",
     "PointMarker",
+    "LineMarker",
     "Visual",
     # scene (MIRROR — the concrete classes live in the backend package)
+    "SceneGravityProtocol",
     "SceneProtocol",
     "SceneGroupProtocol",
+    "SceneVariantsProtocol",
+    # scene variants (dependency-free authoring data)
+    "ObjectVariants",
     # robot configuration (dependency-free owning definitions)
     "ActuatorGainsConfig",
     "ArticulationConfig",
     "JointConfig",
     # robot / prop / sensor / actuator (MIRROR — the concrete classes live in
     # the backend package and explicitly inherit these Protocols)
+    "ExternalForceProtocol",
+    "RobotPropertiesProtocol",
+    "PropPropertiesProtocol",
     "RobotProtocol",
     "RobotStateProtocol",
     "PropProtocol",
     "PropStateProtocol",
+    "VariantPropProtocol",
     "CameraProtocol",
     "ActuatorProtocol",
+    # action-to-joint metadata
+    "ActionChannel",
 ]

simulo_interfaces-0.25.0/src/simulo/interfaces/authoring/action_channel.py

@@ -0,0 +1,22 @@
+"""Dependency-free metadata for a policy action column."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+ActionKind = Literal["position", "velocity", "effort", "command"]
+
+
+@dataclass(frozen=True)
+class ActionChannel:
+    """One named policy action and the command it represents.
+
+    ``joint`` is ``None`` for a task-level command. Resolver code validates
+    the value against a task's action width and the engine's available joints.
+    """
+
+    name: str
+    joint: str | None
+    kind: ActionKind
+    scale: float = 1.0
+    offset: float = 0.0
+    hold_steps: int = 1

{simulo_interfaces-0.24.0 → simulo_interfaces-0.25.0}/src/simulo/interfaces/authoring/prop.py

@@ -214,3 +214,21 @@ class PropProtocol(Protocol):
                 environment.
         """
         ...
+
+
+@runtime_checkable
+class VariantPropProtocol(PropProtocol, Protocol):
+    """The opt-in prop surface for a scene item with per-copy variants.
+
+    :class:`PropProtocol` remains the legacy-compatible pose contract. A task
+    that chooses scene variants depends on this narrower capability instead.
+    """
+
+    @property
+    def variant_index(self) -> TensorLike:
+        """Active option index for every environment copy, shape ``(num_envs,)``."""
+        ...
+
+    def set_variant(self, index: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Switch selected copies to an option index. Supported for pool variants."""
+        ...

simulo_interfaces-0.25.0/src/simulo/interfaces/authoring/properties.py

@@ -0,0 +1,92 @@
+"""Optional per-copy physics capabilities, independent of the base authoring protocols.
+
+Backends opt into each capability they implement. The frozen legacy backend
+continues to satisfy RobotProtocol, PropProtocol and SceneProtocol without them.
+K is the number of selected copies; B, S and J are body, shape and joint counts.
+"""
+
+from typing import Optional, Protocol, runtime_checkable
+
+from simulo.interfaces.runtime.tensors import TensorLike
+
+
+@runtime_checkable
+class RobotPropertiesProtocol(Protocol):
+    """Per-copy articulation properties supported by the engine backend."""
+
+    def set_mass(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set link mass, shape ``(K, B)``, for selected copies."""
+        ...
+
+    def set_center_of_mass(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set link centres of mass in body frames, shape ``(K, B, 3)``."""
+        ...
+
+    def set_friction(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set shape friction, shape ``(K, S)``, for selected copies."""
+        ...
+
+    def set_restitution(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set shape restitution, shape ``(K, S)``, for selected copies."""
+        ...
+
+    def set_joint_gains(
+        self,
+        stiffness: TensorLike,
+        damping: TensorLike,
+        env_ids: Optional[TensorLike] = ...,
+    ) -> None:
+        """Set joint stiffness and damping, each shape ``(K, J)``."""
+        ...
+
+    def set_joint_armature(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set output-side joint armature, shape ``(K, J)``, for selected copies."""
+        ...
+
+
+@runtime_checkable
+class PropPropertiesProtocol(Protocol):
+    """Per-copy rigid-prop properties supported by the engine backend."""
+
+    def set_mass(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set the prop body mass, shape ``(K, 1)``, for selected copies."""
+        ...
+
+    def set_center_of_mass(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set the prop centre of mass in its body frame, shape ``(K, 1, 3)``."""
+        ...
+
+    def set_friction(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set prop-shape friction, shape ``(K, S)``, for selected copies."""
+        ...
+
+    def set_restitution(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set prop-shape restitution, shape ``(K, S)``, for selected copies."""
+        ...
+
+    def set_scale(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set primitive-shape scale, shape ``(K, S, 3)``, for selected copies."""
+        ...
+
+
+@runtime_checkable
+class ExternalForceProtocol(Protocol):
+    """World-frame forces and torques for selected copies of an entity."""
+
+    def apply_external_force(
+        self,
+        forces: TensorLike,
+        torques: TensorLike,
+        env_ids: Optional[TensorLike] = ...,
+    ) -> None:
+        """Apply forces and torques, each shape ``(K, B, 3)``; props have B=1."""
+        ...
+
+
+@runtime_checkable
+class SceneGravityProtocol(Protocol):
+    """Per-copy gravity supported by the engine backend."""
+
+    def set_gravity(self, values: TensorLike, env_ids: Optional[TensorLike] = ...) -> None:
+        """Set world-frame gravity, shape ``(K, 3)``, for selected copies."""
+        ...

{simulo_interfaces-0.24.0 → simulo_interfaces-0.25.0}/src/simulo/interfaces/authoring/scene.py

@@ -34,6 +34,7 @@ Two deliberate scoping notes, so they are not mistaken for drift:
 
 from typing import Any, Dict, List, Optional, Protocol, runtime_checkable
 
+from simulo.interfaces.authoring.variants import ObjectVariants
 from simulo.interfaces.runtime.tensors import TensorLike
 
 
@@ -156,3 +157,24 @@ class SceneProtocol(Protocol):
         authoring code does not need to call it directly.
         """
         ...
+
+
+@runtime_checkable
+class SceneVariantsProtocol(SceneProtocol, Protocol):
+    """The opt-in scene surface that can author different prop objects per copy.
+
+    The baseline :class:`SceneProtocol` intentionally keeps its legacy
+    ``add`` signature. A task that uses ``variants=`` declares this narrower
+    capability, so frozen legacy scene implementations remain valid baseline
+    scenes without claiming they can build variants.
+    """
+
+    def add(
+        self,
+        item: Any,
+        at: str = ...,
+        per_environment: bool = ...,
+        variants: ObjectVariants | None = ...,
+    ) -> None:
+        """Add a prop with opt-in per-copy object variants."""
+        ...

{simulo_interfaces-0.24.0 → simulo_interfaces-0.25.0}/src/simulo/interfaces/authoring/terrain.py

@@ -15,6 +15,7 @@ a factory floor — is a :class:`~simulo.interfaces.authoring.world.World`
 (``World.usd(...)``).
 """
 
+import math
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -38,6 +39,25 @@ class GroundPlane(TerrainConfig):
     """
 
     size: float = 100.0
+    friction: Optional[float] = None
+    contact_stiffness: Optional[float] = None
+    contact_damping: Optional[float] = None
+    contact_gap: Optional[float] = None
+
+    def __post_init__(self) -> None:
+        for name in ("friction", "contact_stiffness", "contact_damping", "contact_gap"):
+            value = getattr(self, name)
+            if value is None:
+                continue
+            if (
+                isinstance(value, bool)
+                or not isinstance(value, (int, float))
+                or not math.isfinite(value)
+                or value < 0
+                or (name in ("contact_stiffness", "contact_damping") and value == 0)
+            ):
+                bound = "positive" if name in ("contact_stiffness", "contact_damping") else "nonnegative"
+                raise ValueError(f"{name} must be a finite {bound} number")
 
 
 @dataclass
@@ -62,6 +82,11 @@ class SubTerrainConfig:
             Defaults to 1.0, which uses the whole grid for this single
             sub-terrain.
         params: Type-specific parameters (e.g., height, step_height, etc.)
+        material: Visual material: "default", "concrete", "dirt", or "none".
+            "default" uses concrete for discrete obstacles, slopes, and waves;
+            dirt for stairs and random rough terrain (including holes); and
+            white for flat terrain. "none" explicitly selects white. This
+            setting does not change collision geometry or physical friction.
 
     Example:
         ```python
@@ -77,6 +102,11 @@ class SubTerrainConfig:
     type: str
     proportion: float = 1.0
     params: Dict[str, Any] = field(default_factory=dict)
+    material: str = "default"
+
+    def __post_init__(self) -> None:
+        if self.material not in ("default", "concrete", "dirt", "none"):
+            raise ValueError("material must be one of: default, concrete, dirt, none")
 
 
 @dataclass
@@ -215,6 +245,11 @@ class Terrain:
         name: str = "groundPlane",
         pose: Optional[Pose] = None,
         size: float = 100.0,
+        *,
+        friction: Optional[float] = None,
+        contact_stiffness: Optional[float] = None,
+        contact_damping: Optional[float] = None,
+        contact_gap: Optional[float] = None,
     ) -> GroundPlane:
         """Create a ground plane (infinite flat surface).
 
@@ -225,6 +260,10 @@ class Terrain:
             name: Terrain name
             pose: Pose in space
             size: Visual size (actual collision is infinite)
+            friction: Contact friction coefficient, or the backend default
+            contact_stiffness: Normal contact stiffness in N/m, or the backend default
+            contact_damping: Normal contact damping in N s/m, or the backend default
+            contact_gap: Additional contact detection gap in meters, or the backend default
 
         Returns:
             GroundPlane instance
@@ -233,6 +272,10 @@ class Terrain:
             name=name,
             pose=pose or Pose.identity(),
             size=size,
+            friction=friction,
+            contact_stiffness=contact_stiffness,
+            contact_damping=contact_damping,
+            contact_gap=contact_gap,
         )
 
     @staticmethod

simulo_interfaces-0.25.0/src/simulo/interfaces/authoring/variants.py

@@ -0,0 +1,48 @@
+"""Dependency-free authoring data for opt-in per-copy scene variants."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Literal, Sequence
+
+from simulo.interfaces.authoring.asset import AssetSource
+from simulo.interfaces.authoring.pose import Pose
+from simulo.interfaces.authoring.primitives import PrimitiveShape
+
+
+@dataclass(frozen=True)
+class ObjectVariants:
+    """The objects one authored prop can represent across environment copies.
+
+    ``groups`` assigns each option to a contiguous group of copies. ``pool``
+    builds every option in each copy so a task can switch the active object at
+    reset. The engine validates geometry-dependent parking distances at build.
+    """
+
+    options: Sequence[PrimitiveShape | AssetSource]
+    mode: Literal["groups", "pool"] = "groups"
+    parking_origin: Pose | None = None
+    parking_spacing: float | None = None
+
+    def __post_init__(self) -> None:
+        options = tuple(self.options)
+        if not 2 <= len(options) <= 8:
+            raise ValueError("ObjectVariants.options must contain between 2 and 8 options")
+        if not all(isinstance(option, (PrimitiveShape, AssetSource)) for option in options):
+            raise TypeError("ObjectVariants.options must contain PrimitiveShape or AssetSource values")
+        if self.mode not in {"groups", "pool"}:
+            raise ValueError("ObjectVariants.mode must be 'groups' or 'pool'")
+        if self.mode != "pool" and (self.parking_origin is not None or self.parking_spacing is not None):
+            raise ValueError("parking_origin and parking_spacing are supported only for pool variants")
+        if self.parking_spacing is not None:
+            if (
+                isinstance(self.parking_spacing, bool)
+                or not math.isfinite(self.parking_spacing)
+                or self.parking_spacing <= 0
+            ):
+                raise ValueError("parking_spacing must be a finite positive number")
+        object.__setattr__(self, "options", options)
+
+
+__all__ = ["ObjectVariants"]

{simulo_interfaces-0.24.0 → simulo_interfaces-0.25.0}/src/simulo/interfaces/authoring/visual.py

@@ -53,7 +53,9 @@ class VisualMarkerBase:
         """Update marker pose(s).
 
         Args:
-            position: Position(s) as (3,) or (num_instances, 3) tensor/array
+            position: Position(s) as (3,) or (num_instances, 3) tensor/array.
+                On the engine, pass float32 tensors on the simulation device;
+                other inputs may allocate or synchronize the host.
             quaternion: Optional quaternion(s) as (4,) or (num_instances, 4)
                        in wxyz format. If None, uses identity rotation.
         """
@@ -143,6 +145,57 @@ class PointMarker(VisualMarkerBase):
     color: Color = (1.0, 1.0, 0.0)  # Yellow by default
 
 
+@dataclass
+class LineMarker(VisualMarkerBase):
+    """Line or polyline marker for paths and trails.
+
+    Draws a line strip through ``points``. The number of points is fixed when
+    the marker is created; ``set_points`` moves them. Unlike the pose
+    markers a line has no pose, so ``set_pose`` raises.
+
+    Attributes:
+        points: Initial polyline as a ``(P, 3)`` sequence or array, at least
+            two points, in world coordinates. Every scene copy starts with
+            these points.
+        width: Line width in meters
+        color: Line color as RGB or RGBA tuple
+    """
+
+    points: Any = None
+    width: float = 0.01
+    color: Color = (0.0, 0.8, 1.0)  # Cyan by default
+    _num_points: int = field(default=0, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        if self.points is None or len(self.points) < 2:
+            raise ValueError("LineMarker needs at least two points")
+        self._num_points = int(len(self.points))
+
+    @property
+    def num_points(self) -> int:
+        """Number of points on the line, fixed at creation."""
+        return self._num_points
+
+    def set_points(self, points: Any) -> None:
+        """Move the line's points.
+
+        Args:
+            points: ``(num_points, 3)`` to give every scene copy the same line,
+                or ``(num_envs, num_points, 3)`` for one line per copy, in
+                world coordinates. Pass float32 tensors on the simulation
+                device; other inputs (lists, CPU or float64 tensors) may
+                allocate or synchronize the host.
+        """
+        if self._backend_handle is None:
+            return
+
+        self._backend_handle.set_points(points)
+
+    def set_pose(self, position: Any, quaternion: Optional[Any] = None) -> None:
+        """Always raises: a line has points, not a pose. Use ``set_points``."""
+        raise TypeError("LineMarker has no pose; use set_points")
+
+
 class Visual:
     """Factory for creating visual markers.
 
@@ -164,6 +217,7 @@ class Visual:
         - sphere: Sphere marker for points/targets
         - arrow: Directional arrow for forces/velocities
         - point: Simple point marker (lightweight)
+    - line: Line or polyline through points, for paths and trails
     """
 
     @staticmethod
@@ -300,3 +354,38 @@ class Visual:
             color=color,
             num_instances=num_instances,
         )
+
+    @staticmethod
+    def line(
+        name: str,
+        points: Any,
+        width: float = 0.01,
+        color: Color = (0.0, 0.8, 1.0),
+        num_instances: int = 1,
+    ) -> LineMarker:
+        """Create a line or polyline marker.
+
+        Args:
+            name: Unique marker name
+            points: Initial ``(P, 3)`` points, at least two, in world coordinates
+            width: Line width in meters
+            color: RGB or RGBA color tuple
+            num_instances: Number of instances for multi-env
+
+        Returns:
+            LineMarker instance
+
+        Example:
+            ```python
+            path = simulo.Visual.line("planned_path", points=waypoints, width=0.02)
+            scene.add(path)
+            path.set_points(new_waypoints)  # same number of points
+            ```
+        """
+        return LineMarker(
+            name=name,
+            points=points,
+            width=width,
+            color=color,
+            num_instances=num_instances,
+        )

{simulo_interfaces-0.24.0 → simulo_interfaces-0.25.0}/src/simulo/interfaces/platform/__init__.py

@@ -68,8 +68,19 @@ from simulo.interfaces.platform.asset_catalog import (
     parse_asset_ref,
 )
 from simulo.interfaces.platform.callbacks import JobCallbackProtocol
-from simulo.interfaces.platform.debug import DebugSessionProtocol, ReplaySessionProtocol, VisualizationSessionProtocol
-from simulo.interfaces.platform.domain import Checkpoint, Job, Package, Project, Resource, Tag
+from simulo.interfaces.platform.debug import (
+    DebugSessionProtocol,
+    ReplaySessionProtocol,
+    VisualizationSessionProtocol,
+)
+from simulo.interfaces.platform.domain import (
+    Checkpoint,
+    Job,
+    Package,
+    Project,
+    Resource,
+    Tag,
+)
 from simulo.interfaces.platform.enums import (
     INPUT_CHECKPOINT_JOB_TYPES,
     INPUT_CHECKPOINT_REQUIRED_JOB_TYPES,
@@ -85,6 +96,8 @@ from simulo.interfaces.platform.evaluation import (
     EPISODES_CSV_CHECK_PREFIX,
     EPISODES_CSV_COLUMNS_AFTER_CHECKS,
     EPISODES_CSV_COLUMNS_BEFORE_CHECKS,
+    EPISODES_CSV_FIRST_FAILURE_AT_S_PREFIX,
+    EPISODES_CSV_FIRST_FAILURE_STEP_PREFIX,
     EVALUATION_ACTIONS,
     EVALUATION_REPORT_SCHEMA_VERSION,
     MAX_CHECK_NAME_CHARS,
@@ -241,14 +254,28 @@ from simulo.interfaces.platform.outputs import (
     tier0_declarations,
 )
 from simulo.interfaces.platform.preview import (
+    ENGINE_SETUP_SCHEMA_VERSION,
+    LIMITS_REPORT_SCHEMA_VERSION,
     PREVIEW_CHECKS,
     PREVIEW_REPORT_SCHEMA_VERSION,
+    PREVIEW_REPORT_SCHEMA_VERSION_V2,
+    PREVIEW_REPORT_SCHEMA_VERSIONS,
     PREVIEW_SELECTABLE_CHECKS,
+    EngineMotorSpec,
+    EngineSetupMotorSpec,
+    EngineSetupReport,
+    EngineSetupScope,
+    EngineSetupValue,
+    LimitsReport,
+    LimitsReportComparisonRating,
+    LimitsReportJoint,
     PreviewCheck,
     PreviewOwner,
     PreviewReport,
+    PreviewReportAny,
     PreviewReportRow,
     PreviewReportStage,
+    PreviewReportV2,
     PreviewRowStatus,
     PreviewStageStatus,
     PreviewVerdict,
@@ -290,6 +317,7 @@ from simulo.interfaces.platform.submit import (
     JOB_RECORDING_DOWNLOAD_ROUTE_TEMPLATE,
     JOB_RECORDINGS_ROUTE_TEMPLATE,
     JOB_TYPE_MISMATCH_CODE,
+    LIVE_VIEW_UNAVAILABLE_WARNING_CODE,
     MAX_COMPLETE_MESSAGE_CHARS,
     MAX_COMPLETE_REASON_CODE_CHARS,
     MAX_LOG_CHUNK_BYTES,
@@ -472,6 +500,7 @@ __all__ = [
     "MAX_RESULT_BYTES",
     "MAX_COMPLETE_MESSAGE_CHARS",
     "MAX_COMPLETE_REASON_CODE_CHARS",
+    "LIVE_VIEW_UNAVAILABLE_WARNING_CODE",
     "MAX_WORKER_RETIREMENT_DETAIL_CHARS",
     "CHECKPOINT_KINDS",
     "RESERVED_RUNTIME_ENV_KEYS",
@@ -615,6 +644,10 @@ __all__ = [
     # preview report wire contract — schema version, check names, and the
     # row/stage/report shapes the preview job returns
     "PREVIEW_REPORT_SCHEMA_VERSION",
+    "PREVIEW_REPORT_SCHEMA_VERSION_V2",
+    "PREVIEW_REPORT_SCHEMA_VERSIONS",
+    "ENGINE_SETUP_SCHEMA_VERSION",
+    "LIMITS_REPORT_SCHEMA_VERSION",
     "PREVIEW_CHECKS",
     "PREVIEW_SELECTABLE_CHECKS",
     "PreviewCheck",
@@ -625,6 +658,16 @@ __all__ = [
     "PreviewReportRow",
     "PreviewReportStage",
     "PreviewReport",
+    "PreviewReportV2",
+    "PreviewReportAny",
+    "EngineSetupScope",
+    "EngineMotorSpec",
+    "EngineSetupValue",
+    "EngineSetupMotorSpec",
+    "EngineSetupReport",
+    "LimitsReportComparisonRating",
+    "LimitsReportJoint",
+    "LimitsReport",
     # evaluation report wire contract — schema version, how an episode ended,
     # the bounds that keep the report under the result cap, the report shapes,
     # the replay trace filming reads, and episodes.csv
@@ -669,6 +712,8 @@ __all__ = [
     "EPISODES_CSV_COLUMNS_BEFORE_CHECKS",
     "EPISODES_CSV_CHECK_PREFIX",
     "EPISODES_CSV_COLUMNS_AFTER_CHECKS",
+    "EPISODES_CSV_FIRST_FAILURE_STEP_PREFIX",
+    "EPISODES_CSV_FIRST_FAILURE_AT_S_PREFIX",
     "episodes_csv_columns",
     # protocols
     "RuntimeProtocol",