reality 0.1.0__tar.gz

reality-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,78 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: Publish the current package version to PyPI
+        required: true
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install --upgrade pip
+      - run: python -m pip install -e ".[dev,physics]"
+      - run: ruff format --check .
+      - run: ruff check .
+      # Run the strict static check once on the oldest supported interpreter.
+      # Runtime and packaging checks still run across the complete 3.11–3.13 matrix.
+      - name: Type check (mypy)
+        if: matrix.python-version == '3.11'
+        run: python -m mypy --no-incremental --follow-imports=skip --config-file pyproject.toml src/reality
+      - run: pytest
+      - run: python -m build
+      - run: python -m venv .release-venv
+      - run: .release-venv/bin/python -m pip install dist/*.whl
+      - run: .release-venv/bin/python -c "import reality; print(reality.__name__)"
+
+  cuda:
+    # Enable only after configuring a self-hosted NVIDIA runner with this repository
+    # variable. The CPU job above remains the required portable release gate.
+    if: ${{ vars.REALITY_CUDA_RUNNER == 'true' }}
+    runs-on: [self-hosted, linux, x64, gpu]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: python -m pip install --upgrade pip
+      - run: python -m pip install -e ".[dev,gpu]"
+      - run: python -m pytest tests/test_gpu.py -q
+      - run: python tools/futures_audit.py --full --output FUTURES_AUDIT.md
+
+  publish:
+    name: Publish to PyPI
+    if: github.event_name == 'workflow_dispatch' && inputs.publish || startsWith(github.ref, 'refs/tags/v')
+    needs: test
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: python -m pip install --upgrade build
+      - run: python -m build
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

reality-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.venv/
+build/
+dist/
+*.egg-info/
+navigation.svg
+.warp-cache/

reality-0.1.0/API_DESIGN.md

@@ -0,0 +1,169 @@
+# API design
+
+## Stable surface
+
+```python
+import reality
+
+world = reality.load("room.glb")
+object_ = world.object("Chair")
+result = world.distance("Chair", "Table")
+```
+
+`World.object()` accepts an object id, a unique name, or a registered `WorldObject`. Duplicate names are permitted but require lookup by id.
+
+`WorldObject` exposes `name`, `id`, `transform`, `position`, `rotation`, `scale`, `bounds`, and `mesh`. Bounds are world-space AABBs; `local_bounds` retains the geometry before applying its transform. Rotations are XYZ Euler angles in radians.
+
+All predicate methods accept two object references. `near` additionally accepts `within`, defaulting to `1.0` in `World.units`. `distance` returns `PredicateResult[float]`; the remaining methods return `PredicateResult[bool]`.
+
+## Graph and visibility
+
+```python
+visibility = world.visible("Television", from_="Sofa")
+assert visibility.value
+print(visibility.visibility_fraction)
+print([object_.name for object_ in visibility.occluding_objects])
+
+for edge in world.relationships("Cup"):
+    print(edge.source.name, edge.type.value, edge.target.name)
+```
+
+`RelationshipType` includes `near`, `above`, `below`, `inside`, `contains`, `intersects`, `touching`, and `visible_from`. Graph construction records true deterministic spatial relationships. A successful `visible()` query additionally records a directed `visible_from` relationship from target to viewer.
+
+Moving an object is explicit: `world.move("Chair", x=1.0)` or `world.update_transform("Chair", transform)`. Those methods only invalidate and refresh graph edges incident to the changed object.
+
+## Result contract
+
+`PredicateResult` has `value`, `measurement`, `units`, `reason`, `evidence`, and `objects`. `distance` is an alias for `measurement`, making this ergonomic:
+
+```python
+result = world.distance("Chair", "Table")
+assert result.value == result.distance
+```
+
+Evidence always includes the world-space bounds involved. The immutable mapping prevents a caller accidentally altering an already-returned result.
+
+For a visibility result, evidence additionally contains `visibility_fraction`, `occluding_objects`, and `sample_count`; the first two are surfaced as convenience properties.
+
+## Snapshots, branches, and consequences
+
+```python
+before = world.snapshot()
+future = world.branch()
+future.move("Shelf", x=1.0)
+future.rotate("Shelf", z=0.25)
+future.scale("Shelf", x=1.1)
+
+report = future.consequences()
+for consequence in report:
+    print(consequence)
+
+payload = report.to_dict()
+json_text = report.to_json()
+```
+
+`move` and `rotate` are additive; `scale` is multiplicative. Each call records an ordered, UTC-timestamped change with old/new transforms and the supplied parameters. An unchanged object returned by a branch is the same immutable `WorldObject` instance as in the snapshot. A changed object is a new value object that retains the same opaque mesh reference.
+
+`world.compare(branch_a, branch_b)` compares sibling branches. It rejects branches from another world lineage.
+
+## Agents and navigation
+
+```python
+person = world.agent(
+    name="Person",
+    position=(0.0, 0.0, 0.0),
+    height=1.75,
+    radius=0.30,
+    step_height=0.15,
+)
+
+path = person.path_to("Exit")
+reachability = world.reachable("Person", "Exit")
+passage = person.can_pass("Door")
+clearance = person.clearance_to("Exit")
+```
+
+`PathResult` contains `reachable`, path `points`, `distance`, `minimum_clearance`, `narrowest_point`, `blocked_by`, `reason`, and evidence. Path minimum clearance is free space from the agent body to the nearest inflated obstacle. `ReachabilityResult` adds required diameter and estimated available corridor width. Passage checks compare agent diameter and height with the opening AABB. Results expose `value` aliases where predicate-style use is convenient.
+
+Agent category names have no behavioral meaning. Only dimensions and optional movement constraints affect navigation.
+
+## Articulation
+
+`World.articulate`, `can_open`, `can_extend`, and the `ArticulatedObject` handle return a
+`MotionResult` with requested/maximum motion, blockers, units, reason, samples, and
+evidence. Configuration is explicit, deterministic metadata. `reality.load` reads the
+same schema from a `.reality.json` sidecar, glTF/GLB `extras.reality`, or an explicit
+`metadata=` mapping. The schema supports `units`, `objects.<name>.articulation`, and
+`objects.<name>.physics`; malformed or unknown fields raise `SceneMetadataError` rather
+than being guessed or ignored. The object reference must resolve to a unique loaded
+object. Later metadata sources override earlier articulation/physics fields; `units`
+labels coordinates and never triggers implicit rescaling.
+
+## Physics
+
+`PhysicalProperties` describes mass, static/dynamic state, box collision shape,
+friction, restitution, and center-of-mass offset. `simulate`, `drop`, `push`, `contacts`,
+and `stable` return backend-neutral typed results. Simulation-observed consequences are
+labeled separately from direct and downstream deterministic consequences. MuJoCo uses
+oriented boxes built from local bounds and maps dynamic position and orientation back
+to `Transform`. It caches immutable compiled topology per world/backend and creates a
+fresh simulation state for every call, preserving branch isolation. Performance timing
+and cache reuse are reported in `SimulationResult.evidence`.
+
+## Branch batches
+
+`World.branches(count)` returns a `BranchBatch`; `randomize("Object.position", ...)`
+stores compact translation deltas and `evaluate(predicates=("collision",))` runs the CPU
+reference batch. CUDA selection is capability-checked and never silently falls back.
+
+`World.futures(count)` returns the named `Futures` form for large alternate-world search:
+
+```python
+from reality.predicates import collision, distance, maximize, no_collision
+
+futures = world.futures(10_000).randomize_position(
+    "Table", x=(-1.0, 1.0), y=(-0.5, 0.5), z=(0.0, 0.0), seed=7
+)
+evaluation = futures.evaluate([collision("Table", "Chair"), distance("Table", "Chair")])
+ranked = evaluation.rank(
+    constraints=[no_collision("Table", "Chair")],
+    objectives=[maximize(distance("Table", "Chair"))],
+)
+candidate = ranked.best(1)[0]
+branch = candidate.materialize()
+```
+
+`PredicateSpec` values are typed and reusable. `where()` applies hard `Condition`
+constraints; `rank()` applies weighted `Objective` values; candidates stay compact until
+`materialize()` or `consequences()` is called. `collision` and `distance` use world AABBs,
+and batch `visibility` is a deterministic AABB ray experiment. Batched rotations/scales
+are accepted and retained for future kernels, but currently raise `NotImplementedError`
+when evaluated with non-default values. `BatchEvaluation.to_dict()` and
+`RankedFutures.to_dict()` provide machine-readable summaries.
+
+## Exact exploration
+
+`World.explore()` is a convenience layer over `Futures`; it does not introduce a second
+optimizer or different predicate semantics.
+
+```python
+result = world.explore(
+    possibilities=100_000,
+    changes=[reality.position("Shelf", x=(-1.0, 1.0))],
+    constraints=[no_collision("Shelf", "Door")],
+    objectives=[maximize(distance("Shelf", "Door"))],
+    seed=42,
+    best=10,
+)
+```
+
+`PositionSearchChange` declares inclusive coordinate ranges. Candidate sampling is
+deterministic for a seed, constraints are exact hard filters, and objective ties are
+broken by candidate index. `ExplorationResult` exposes backend, counts, scores, compact
+deltas, predicate evidence, `best()`, `to_dict()`, and `to_json()`. Returned candidates
+remain lazy `FutureCandidate` values until `materialize()` is called.
+
+`backend="auto"` selects CUDA only after the accelerator capability check succeeds;
+`backend="cpu"` forces the NumPy reference path. CUDA evaluates the same documented
+AABB semantics as CPU. Any future learned prioritizer is experimental, opt-in, and may
+only order candidates before exact validation; it never changes valid/invalid results.

reality-0.1.0/ARCHITECTURE.md

@@ -0,0 +1,118 @@
+# Architecture
+
+```
+public API: reality.load, World, WorldObject, Transform, Bounds, PredicateResult
+                              |
+                      backend-neutral core
+                              |
+                       RealityGraph (edges reference WorldObjects)
+                              |
+              snapshots -> branch delta/graph overlay -> consequences
+                              |
+                  Trimesh loader adapter (today)
+```
+
+`_models.py` contains immutable data/value objects. `World` owns lookup indexes and evaluates spatial predicates using the world-space axis-aligned bounds of its objects. `_loaders.py` is the only module that imports Trimesh; it turns a Trimesh scene graph into `WorldObject` instances while retaining the source mesh as an opaque reference.
+
+This split means a future USD, Omniverse, renderer, or physics adapter can produce the same core objects without changing application code. Exact mesh queries should arrive as explicitly named capabilities rather than silently changing the existing AABB semantics.
+
+The Z axis is vertical for `above` and `below`. The default coordinate unit is metres (`m`), configurable when constructing a `World`.
+
+## Reality Graph and updates
+
+`World.graph` is a `RealityGraph` built from known deterministic spatial facts. `Relationship` stores references to the already-loaded `WorldObject` instances, never copied mesh data. `world.relationships("Cup")` returns all incident graph edges.
+
+The graph indexes each edge by both object ids. `World.update_transform()` and `World.move()` invalidate only edges incident to the changed object, then recompute that object against the rest of the scene. Relationships entirely between unaffected objects stay in place. Visibility edges are query-driven and are invalidated with either involved object; they are deliberately not eagerly recomputed.
+
+Visibility casts rays from the viewer AABB centre to the target centre and corners, treating all other world AABBs as occluders. It returns the visible sample fraction and the objects that blocked at least one ray. This is deterministic but conservative/approximate compared with future mesh-exact visibility.
+
+## Snapshots and persistent branches
+
+`World.snapshot()` returns an immutable `WorldSnapshot`. Its object tuple, lookup indexes, relationships, and known visibility results are stable views. Because `WorldObject`, transforms, and bounds are immutable, snapshots safely retain references to existing objects and opaque mesh data instead of copying geometry.
+
+`World.branch()` creates a `WorldBranch` over a cached snapshot. The branch maintains:
+
+- an object-id-to-replacement delta for changed objects;
+- an ordered `ChangeSet` containing `MoveObject`, `RotateObject`, and `ScaleObject` records;
+- a `RealityGraph` overlay that points at snapshot edges and stores only recalculated edges;
+- `GraphUpdateStats` for predicates present before changes, invalidated, recalculated, and reused.
+
+On a transform change, only pairs involving the changed object are recalculated. Base graph edges between unchanged objects remain the same Python objects. Known visibility queries are recalculated because any moved object may become or cease to be an occluder; such a result is classified as downstream when neither visibility endpoint moved.
+
+Branches use the exact snapshot they were created from, so later mutations to the source `World` cannot alter an existing branch.
+
+## Consequence comparison
+
+`WorldBranch.consequences()` compares its current state with its base snapshot. It evaluates distance and existing graph predicates only across the union of changed-object dependency frontiers, then compares known visibility results. `World.compare(a, b)` applies the same engine to two sibling branches.
+
+`ConsequenceSet` contains typed `Consequence` records plus the branch `ChangeSet` and recomputation instrumentation. `to_dict()` and `to_json()` intentionally serialize object identity and geometric evidence without attempting to serialize backend mesh instances.
+
+## Navigation backend
+
+The initial navigation backend is deliberately replaceable and CPU-only. Each query projects relevant world AABBs onto an XY occupancy grid, expands obstacles by the querying agent’s radius, and runs deterministic 8-connected A*. Z is up; the agent position’s Z value is its foot/ground elevation. Geometry blocks movement when it overlaps the volume between step height and agent height.
+
+The grid covers the start/target rectangle plus `World.navigation_margin` (2 m by default), at `World.navigation_resolution` (0.25 m by default). The target object is treated as a destination marker and excluded from obstacles. This finite query envelope is an explicit assumption: callers needing larger detours should increase the margin.
+
+`max_slope` is retained in the agent model and evidence, but the current projected grid is flat and does not yet evaluate terrain slope. `can_pass()` interprets an opening object’s largest horizontal AABB extent as aperture width and its Z extent as aperture height.
+
+Navigation queries are lazy and cached by agent/target id. Their `reachable_by`, `unreachable_by`, and `blocks_path_of` edges are stored in the Reality Graph only after a query. Any object move invalidates known navigation queries because any object may become an obstacle; only those known queries are recalculated. Branch consequence analysis compares their reachability and minimum-clearance results as downstream state.
+
+`PathResult.export_debug()` writes a standalone SVG: green is query-local walkable space, red rectangles are radius-inflated obstacle regions, the blue polyline is the path, and a dashed line indicates a blocked direct route.
+
+## Articulation and replaceable physics
+
+`_metadata.py` validates the portable, explicit Reality metadata schema. `_loaders.py`
+collects glTF/GLB `extras.reality`, an optional `.reality.json` sidecar, and caller
+metadata in that precedence order. It applies validated articulation and physical
+properties after geometry loading. This keeps mesh import backend-neutral and avoids
+inventing physical semantics from names or topology.
+
+`_articulation.py` stores explicit revolute/prismatic joints. It samples swept
+world-AABBs at 1 degree or 0.01 m by default and binary-refines the first collision to
+0.01 degree or 0.0001 m. Conservative AABBs can produce mesh-shape false positives;
+features thinner than a sampling interval can be missed. Known motion queries are lazy
+graph dependencies and are recalculated after relevant geometry changes.
+
+`backends/base.py` defines Reality's narrow `PhysicsBackend` protocol.
+`backends/mujoco.py` is the CPU reference: explicit properties become headless MuJoCo
+oriented box rigid bodies, including transform rotation and center-of-mass offsets.
+Compiled topology is cached in the world-local backend; every run creates new MuJoCo
+state and initializes dynamic body poses, so cached models never share branch state.
+When a solve changes several bodies, `RealityGraph.refresh_objects()` updates their
+combined dependency frontier once instead of recalculating changed/changed pairs and
+lazy query invalidation per body. Current limitations include box-only collision shapes,
+a z=0 plane, no simulated joints, and no literal restitution-to-MuJoCo mapping.
+
+## Batched branch memory layout and CUDA boundary
+
+`_batch.py` keeps one shared snapshot, immutable base bounds, and one dense
+`branch_count x 3` float64 translation array per changed object. It never builds a
+complete `World` per alternative. `World.futures()` is the large-search spelling;
+`World.branches()` remains compatible with the earlier API. Future candidates are lazy
+views and selected candidates alone materialize copy-on-write `WorldBranch` instances.
+Vectorized CPU collision, AABB distance, and deterministic bounding-volume visibility
+are implemented, with typed predicate specifications, constraints, and ranking.
+`_warp_ops.py` adds custom Warp kernels for branch/object transforms, AABB overlap, AABB
+distance, and centre-to-centre AABB visibility, each with a separate NumPy oracle and
+explicit CUDA synchronization. `_accelerators.py` probes optional Warp lazily. CUDA is
+considered validated only after launches and CPU/GPU parity tests succeed on that host;
+the audit reports `PARTIAL` when CUDA is absent rather than inferring a result. The
+visibility kernel deliberately has the same conservative AABB semantics as the CPU
+batch path—it is not triangle-mesh ray tracing. Graph and explanation logic remains
+CPU-resident by design.
+
+## Exact search and optional learning
+
+`_explore.py` composes the existing compact `Futures` representation: it samples one
+deterministic delta matrix per declared change, invokes typed predicates in a batch,
+applies exact conditions, ranks stable objective scores, and returns lazy candidates.
+No candidate branch or mesh copy exists until a selected `FutureCandidate` is
+materialized. GPU predicate arrays currently transfer per evaluation; immutable scene
+arrays are not yet retained across independent calls, and ranking/filter reduction stays
+on CPU so its evidence remains inspectable. Those are measured limitations, not hidden
+fallbacks.
+
+`reality.experimental` contains an optional scikit-learn prioritizer. Dataset generation
+uses Reality's exact results as ground truth. The predictor can only propose a candidate
+order; downstream code must run `Futures.evaluate()`/`World.explore()` exact validation
+before accepting a result.

reality-0.1.0/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes are documented here. This project follows Semantic Versioning from
+its first public release.
+
+## 0.1.0 — Unreleased
+
+- Deterministic world loading and AABB spatial predicates.
+- Reality Graph, visibility evidence, snapshots, copy-on-write branches, and consequences.
+- Navigation, articulation, metadata ingestion, and optional CPU MuJoCo simulation.
+- Compact Futures plus `World.explore()` exact layout search.
+- Optional Warp kernels with CPU-oracle validation and optional learned candidate prioritization.
+
+## Release policy
+
+Public APIs documented in `API_DESIGN.md` are additive within the 0.1 series. Geometry and
+visibility semantics remain explicit: AABB predicates never silently become mesh-exact.

reality-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,24 @@
+# Contributing
+
+Thanks for improving `reality`. This project uses Python 3.11+ and a `src/` layout.
+
+## Setup
+
+```bash
+git clone https://github.com/reality-python/reality.git
+cd reality
+python -m pip install -e ".[dev]"
+```
+
+Before opening a pull request, run:
+
+```bash
+ruff format --check .
+ruff check .
+python -m mypy src/reality
+pytest
+```
+
+Keep public APIs typed and documented. Add focused tests for changes in geometric semantics, including result measurements and evidence. Preserve the backend-neutral public model: imports of a backend belong in an adapter, not `World` or the value objects.
+
+By contributing, you agree that contributions are provided under the Apache-2.0 license.

reality-0.1.0/FUTURES_AUDIT.md

@@ -0,0 +1,56 @@
+# Futures audit
+
+Status: **PARTIAL**
+
+This report was generated by `python tools/futures_audit.py --full --output FUTURES_AUDIT.md`.
+
+## Reproducibility
+
+- Revision: `e15e0dc390792784295ce0de8fc89c766119f1fa`
+- Python: `3.11.9`
+- Platform: `Windows-10-10.0.26200-SP0`
+- Scene objects: `1000`
+- Futures: `10000`
+- CUDA: `CUDA driver/device is unavailable.`
+
+## GPU Validation
+
+- CUDA available: `False`
+- CUDA device: `unavailable`
+- Custom Warp kernels tested: `none`
+- CPU/GPU parity status: **NOT_RUN**
+- GPU test count/pass count: `0` / `0`
+- GPU execution actually used: `False`
+
+CUDA validation could not be performed: CUDA driver/device is unavailable.
+
+## Compact state evidence
+
+- Shared snapshot: `True`
+- Measured NumPy delta bytes: `240000`
+- Logical float64 delta payload: `240000`
+- 10k evaluation seconds: `0.659171`
+- Candidates without collision: `10000`
+
+## Scaling
+
+| futures | creation seconds | distance seconds | delta bytes |
+|---:|---:|---:|---:|
+| 100 | 0.001881 | 0.000137 | 2400 |
+| 1000 | 0.001212 | 0.000225 | 24000 |
+| 10000 | 0.001903 | 0.002073 | 240000 |
+| 50000 | 0.002214 | 0.010108 | 1200000 |
+| 100000 | 0.005615 | 0.030814 | 2400000 |
+
+## CPU/GPU boundary
+
+Visibility is a deterministic AABB bounding-volume experiment, not exact mesh occlusion.
+
+Future GPU work should keep immutable bounds resident, batch ray and broad-phase kernels, and
+perform filtering/ranking reductions before transferring selected candidates to Python.
+
+## Limitations
+
+- CUDA validation could not be performed: CUDA driver/device is unavailable.
+- Visibility uses deterministic AABB ray tests, not exact triangle-mesh rays.
+- Batched rotation and scale are stored but predicate evaluation is not implemented yet.

reality-0.1.0/FUTURES_RESULTS.json

@@ -0,0 +1,92 @@
+{
+  "status": "PARTIAL",
+  "revision": "e15e0dc390792784295ce0de8fc89c766119f1fa",
+  "python": "3.11.9",
+  "platform": "Windows-10-10.0.26200-SP0",
+  "cuda": {
+    "installed": true,
+    "version": "1.17.0",
+    "cuda_available": false,
+    "devices": [
+      "cpu"
+    ],
+    "reason": "CUDA driver/device is unavailable."
+  },
+  "gpu_validation": {
+    "cuda_available": false,
+    "device": null,
+    "custom_warp_kernels_tested": [],
+    "kernel_parity_count": 0,
+    "kernel_parity_pass_count": 0,
+    "gpu_test_count": 0,
+    "gpu_pass_count": 0,
+    "cpu_gpu_parity": "NOT_RUN",
+    "gpu_execution_used": false,
+    "failures": [],
+    "pytest": {
+      "status": "NOT_RUN",
+      "count": 0,
+      "passed": 0,
+      "failed": 0,
+      "skipped": 0
+    }
+  },
+  "scene_objects": 1000,
+  "futures": 10000,
+  "delta_bytes": 240000,
+  "logical_delta_bytes": 240000,
+  "evaluation_seconds": 0.6591709999920567,
+  "selected_without_collision": 10000,
+  "shared_snapshot": true,
+  "predicates": [
+    "collision",
+    "distance",
+    "visibility"
+  ],
+  "visibility_is_bounding_volume": true,
+  "limitations": [
+    "CUDA validation could not be performed: CUDA driver/device is unavailable.",
+    "Visibility uses deterministic AABB ray tests, not exact triangle-mesh rays.",
+    "Batched rotation and scale are stored but predicate evaluation is not implemented yet."
+  ],
+  "gpu_acceleration_next": [
+    "Keep AABB centers/extents resident on GPU across many candidate batches.",
+    "Move visibility ray batches and broad-phase pair culling to Warp kernels.",
+    "Add GPU reduction kernels for filtering and ranking to reduce host transfers."
+  ],
+  "scaling": [
+    {
+      "futures": 100,
+      "creation_seconds": 0.0018807000014930964,
+      "distance_seconds": 0.00013670000771526247,
+      "delta_bytes": 2400
+    },
+    {
+      "futures": 1000,
+      "creation_seconds": 0.0012117000005673617,
+      "distance_seconds": 0.00022480000916402787,
+      "delta_bytes": 24000
+    },
+    {
+      "futures": 10000,
+      "creation_seconds": 0.0019033999997191131,
+      "distance_seconds": 0.0020733999990625307,
+      "delta_bytes": 240000
+    },
+    {
+      "futures": 50000,
+      "creation_seconds": 0.002214100008131936,
+      "distance_seconds": 0.010108400005265139,
+      "delta_bytes": 1200000
+    },
+    {
+      "futures": 100000,
+      "creation_seconds": 0.005615399990347214,
+      "distance_seconds": 0.030813899997156113,
+      "delta_bytes": 2400000
+    }
+  ],
+  "cpu_distance_oracle": [
+    1.0
+  ]
+}