x4d-devkit 0.45.0rc1__tar.gz → 0.46.0rc2__tar.gz

{x4d_devkit-0.45.0rc1/x4d_devkit.egg-info → x4d_devkit-0.46.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.45.0rc1
+Version: 0.46.0rc2
 Summary: Official X-4D external SDK and CLI for datasets, platform APIs, training bridges, and automation
 Author: windzu
 License-Expression: Apache-2.0

{x4d_devkit-0.45.0rc1 → x4d_devkit-0.46.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "x4d-devkit"
-version = "0.45.0rc1"
+version = "0.46.0rc2"
 description = "Official X-4D external SDK and CLI for datasets, platform APIs, training bridges, and automation"
 readme = "README.md"
 license = "Apache-2.0"

{x4d_devkit-0.45.0rc1 → x4d_devkit-0.46.0rc2}/tests/test_clean_basemap.py

@@ -5,7 +5,6 @@ import pytest
 import zstandard
 
 from tests.semantic_scene_contract_fixtures import current_semantic_scene_component
-from x4d_devkit.annotation_contract import build_clip_annotations
 from x4d_devkit.clean_basemap import (
     CLEAN_BASEMAP_CONTRACT_VERSION,
     CLEAN_BASEMAP_INPUT_FIELDS,
@@ -22,15 +21,12 @@ from x4d_devkit.clean_basemap import (
     encode_clean_basemap_decisions,
     encode_clean_basemap_mapping,
     parse_clean_basemap_manifest,
-    validate_clean_basemap_annotation,
     validate_clean_basemap_native_binding,
     validate_clean_basemap_resource,
-    compute_clean_basemap_preannotation_revision,
 )
 from x4d_devkit.semantic_scene_contract import (
-    compute_annotation_dependency_revisions,
     decode_scene_geometry,
-    encode_scene_geometry,
+    empty_semantic_scene_instance_index,
     sha256_bytes,
 )
 
@@ -39,72 +35,42 @@ def fixture():
     native = current_semantic_scene_component()
     scene = clean_basemap_scene_source(native["scene_index"])
     first = scene["chunks"][0]
-    geometry = decode_scene_geometry(
-        native["scene_geometry_payloads"][first["geometry"]],
-        point_count=3,
-        expected_payload_sha256=first["geometry_sha256"],
-        expected_raw_sha256=first["geometry_raw_sha256"],
-    )
-    xyz = np.vstack([geometry.xyz, [9.5, 0, 0]]).astype(np.float32)
-    rgb = np.vstack([geometry.rgb, [100, 110, 120]]).astype(np.uint8)
-    encoded = encode_scene_geometry(xyz, rgb)
+    payload = native["scene_geometry_payloads"][first["geometry"]]
     descriptor = {
-        "path": f"generated/reconstruction/clean_basemap/geometry/{encoded.payload_sha256[7:]}.spc.zst",
-        "sha256": encoded.payload_sha256,
-        "raw_sha256": encoded.raw_sha256,
-        "size_bytes": len(encoded.payload),
+        "path": f"generated/reconstruction/clean_basemap/geometry/{first['geometry_sha256'][7:]}.spc.zst",
+        "sha256": first["geometry_sha256"],
+        "raw_sha256": first["geometry_raw_sha256"],
+        "size_bytes": len(payload),
     }
-    decisions = [1, 0, 0, 2, 17]
+    decisions = [1, 0, 3, 18, 33]
     source_hash = "sha256:" + "a" * 64
     decision_payload = encode_clean_basemap_decisions(
         asset_sha256=source_hash, decisions=decisions
     )
     mapping = encode_clean_basemap_mapping(
-        geometry_raw_sha256=encoded.raw_sha256,
-        sweep_indices=[0, 0, 0, 0],
-        raw_point_ordinals=[0, 1, 2, 3],
-        timestamps_ns=[100, 100, 100, 100],
-        owner_source_indices=[0, 0, 0, 1],
-        owner_point_ordinals=[0, 1, 2, 0],
-        decisions=decisions[:4],
+        geometry_raw_sha256=first["geometry_raw_sha256"],
+        sweep_indices=[0, 0, 0],
+        raw_point_ordinals=[0, 1, 2],
+        timestamps_ns=[100, 100, 100],
+        decisions=decisions[:3],
     )
-    instance_sources = [
-        {
-            key: row[key]
-            for key in (
-                "instance_token",
-                "point_count",
-                "geometry",
-                "geometry_sha256",
-                "geometry_raw_sha256",
-            )
-        }
-        | {"motion": "static"}
-        for row in native["instance_index"]["instances"]
-    ]
     profile = {
-        "algorithm": {"id": "clean_static_basemap", "version": "1.0.0"},
+        "algorithm": {"id": "clean_static_basemap", "version": "0.6.0"},
         "voxel_size_m": 0.03,
         "min_range_m": 2.0,
         "max_range_m": 60.0,
         "lidar_channels": ["scanner-a"],
         "unknown_policy": "retain",
         "point_deskew": True,
-        "foreground_policy": "joint_temporal_box_ground_v1",
+        "foreground_policy": "model_motion_ground_v1",
         "occlusion_policy": "original_observations",
         "policies": {
             name: {"id": name, "version": "1.0.0", "parameters": {}}
-            for name in ("geometry", "ground", "motion", "rgb")
+            for name in ("geometry", "ground", "rgb")
         },
     }
     inputs = {key: "sha256:" + "b" * 64 for key in CLEAN_BASEMAP_INPUT_FIELDS}
-    inputs["preannotation_revision"] = compute_clean_basemap_preannotation_revision(
-        None
-    )
-    dependencies = compute_annotation_dependency_revisions(native["annotation"])
-    for key in inputs:
-        if key in dependencies:
-            inputs[key] = dependencies[key]
+    bounds = [first["bounds_min_m"], first["bounds_max_m"]]
     manifest = {
         "contract_version": CLEAN_BASEMAP_CONTRACT_VERSION,
         "clip_id": native["annotation"]["clip_id"],
@@ -114,27 +80,25 @@ def fixture():
             inputs, profile
         ),
         "input_identity": inputs,
-        "preannotation_evidence": None,
         "profile": profile,
-        "point_count": 4,
-        "bounds": [xyz.min(0).tolist(), xyz.max(0).tolist()],
+        "point_count": 3,
+        "bounds": bounds,
         "scene_source": scene,
-        "instance_sources": instance_sources,
         "sweep_sources": [
             {
                 "sample_data_token": "sweep-0",
                 "channel": "scanner-a",
                 "point_count": 5,
                 "asset_sha256": source_hash,
-                "time_bounds": [{"sec": 0, "nanosec": 100}, {"sec": 0, "nanosec": 100}],
+                "time_bounds": [{"sec": 0, "nanosec": 100}] * 2,
                 "decisions": decision_payload.descriptor("decisions"),
             }
         ],
         "chunks": [
             {
                 "ordinal": 0,
-                "point_count": 4,
-                "bounds": [xyz.min(0).tolist(), xyz.max(0).tolist()],
+                "point_count": 3,
+                "bounds": bounds,
                 "geometry": descriptor,
                 "mapping": mapping.descriptor("mapping"),
             }
@@ -147,10 +111,10 @@ def fixture():
         },
     }
     manifest["basemap_revision"] = compute_clean_basemap_revision(manifest)
-    assets = dict(native["scene_geometry_payloads"], **native["instance_payloads"])
+    assets = dict(native["scene_geometry_payloads"])
     assets.update(
         {
-            descriptor["path"]: encoded.payload,
+            descriptor["path"]: payload,
             mapping.descriptor("mapping")["path"]: mapping.payload,
             decision_payload.descriptor("decisions")["path"]: decision_payload.payload,
         }
@@ -158,19 +122,22 @@ def fixture():
     return manifest, assets, native
 
 
-def validate(manifest, assets):
+def original_points(manifest, assets):
     geometry = manifest["chunks"][0]["geometry"]
-    original_xyz = decode_scene_geometry(
+    return decode_scene_geometry(
         assets[geometry["path"]],
-        point_count=4,
+        point_count=3,
         expected_payload_sha256=geometry["sha256"],
         expected_raw_sha256=geometry["raw_sha256"],
     ).xyz
+
+
+def validate(manifest, assets):
+    original = original_points(manifest, assets)
     return validate_clean_basemap_resource(
         manifest,
         read_asset=assets.__getitem__,
-        observation_to_world=lambda sweep, ordinals, times: original_xyz[ordinals],
-        instance_to_world=lambda token, times, xyz: xyz + [10, 0, 0],
+        observation_to_world=lambda sweep, ordinals, times: original[ordinals],
     )
 
 
@@ -180,52 +147,56 @@ def remap(manifest, assets, **overrides):
         assets[chunk["mapping"]["path"]],
         descriptor=chunk["mapping"],
         geometry_raw_sha256=chunk["geometry"]["raw_sha256"],
-        point_count=chunk["point_count"],
+        point_count=3,
     )
     arguments = {
         "sweep_indices": mapping["sweep_index"],
         "raw_point_ordinals": mapping["raw_point_ordinal"],
         "timestamps_ns": mapping["timestamp_ns"],
-        "owner_source_indices": mapping["owner_source_index"],
-        "owner_point_ordinals": mapping["owner_point_ordinal"],
         "decisions": mapping["decision"],
     }
-    payload = encode_clean_basemap_mapping(
+    encoded = encode_clean_basemap_mapping(
         geometry_raw_sha256=chunk["geometry"]["raw_sha256"], **(arguments | overrides)
     )
-    chunk["mapping"] = payload.descriptor("mapping")
-    assets[chunk["mapping"]["path"]] = payload.payload
+    chunk["mapping"] = encoded.descriptor("mapping")
+    assets[chunk["mapping"]["path"]] = encoded.payload
     manifest["basemap_revision"] = compute_clean_basemap_revision(manifest)
 
 
-def test_complete_geometry_native_ownership_and_original_observation_roundtrip():
+def test_complete_scene_and_exact_original_observation_roundtrip():
     manifest, assets, native = fixture()
     parsed = validate(manifest, assets)
     assert parsed.to_dict() == manifest
-    validate_clean_basemap_annotation(parsed, native["annotation"])
     validate_clean_basemap_native_binding(
         parsed,
         scene_index=native["scene_index"],
-        instance_index=native["instance_index"],
+        instance_index=empty_semantic_scene_instance_index(),
+    )
+    assert set(parsed.data["input_identity"]) == {
+        "samples_revision",
+        "sweeps_revision",
+        "calibration_revision",
+        "pose_revision",
+    }
+    assert (
+        "instance_sources" not in parsed.data
+        and "preannotation_evidence" not in parsed.data
     )
-    manifest["chunks"][0]["point_count"] = 9
-    assert parsed.data["chunks"][0]["point_count"] == 4
+    assert "owner_source_index" not in MAPPING_DTYPE.names
+    manifest["point_count"] = 9
+    assert parsed.data["point_count"] == 3
     with pytest.raises(TypeError):
         parsed.data["profile"]["voxel_size_m"] = 1
 
 
 @pytest.mark.parametrize(
-    "overrides, message",
+    "overrides,message",
     [
-        ({"sweep_indices": [1, 0, 0, 0]}, "source index"),
-        ({"raw_point_ordinals": [5, 1, 2, 3]}, "original point ordinal"),
-        ({"raw_point_ordinals": [0, 0, 2, 3]}, "duplicate original observation"),
-        ({"raw_point_ordinals": [0, 1, 2, 4]}, "decision"),
-        ({"timestamps_ns": [101, 100, 100, 100]}, "exact point time"),
-        ({"owner_source_indices": [9, 0, 0, 1]}, "source index"),
-        ({"owner_point_ordinals": [0, 1, 3, 0]}, "native point ordinal"),
-        ({"owner_point_ordinals": [0, 1, 1, 0]}, "duplicate native scene"),
-        ({"owner_source_indices": [0, 0, 1, 1]}, "instance correspondence"),
+        ({"sweep_indices": [1, 0, 0]}, "source index"),
+        ({"raw_point_ordinals": [5, 1, 2]}, "original point ordinal"),
+        ({"raw_point_ordinals": [0, 0, 2]}, "duplicate original observation"),
+        ({"raw_point_ordinals": [0, 1, 3]}, "decision"),
+        ({"timestamps_ns": [101, 100, 100]}, "exact point time"),
     ],
 )
 def test_valid_hash_cannot_hide_wrong_addresses_or_removed_sources(overrides, message):
@@ -235,77 +206,65 @@ def test_valid_hash_cannot_hide_wrong_addresses_or_removed_sources(overrides, me
         validate(manifest, assets)
 
 
-def test_dynamic_instance_support_is_not_static_display_evidence():
-    manifest, assets, _ = fixture()
-    manifest["instance_sources"][0]["motion"] = "dynamic"
-    manifest["basemap_revision"] = compute_clean_basemap_revision(manifest)
-    with pytest.raises(ValueError, match="dynamic instance"):
-        validate(manifest, assets)
-
-
-@pytest.mark.parametrize("result", [np.zeros((2, 3)), np.full((1, 3), np.nan)])
-def test_instance_transform_rejects_incomplete_or_nonfinite_results(result):
+@pytest.mark.parametrize("kind", ["fabricated", "incomplete", "nonfinite"])
+def test_original_observation_projection_is_required(kind):
     manifest, assets, _ = fixture()
-    descriptor = manifest["chunks"][0]["geometry"]
-    original_xyz = decode_scene_geometry(
-        assets[descriptor["path"]],
-        point_count=4,
-        expected_payload_sha256=descriptor["sha256"],
-        expected_raw_sha256=descriptor["raw_sha256"],
-    ).xyz
-    with pytest.raises(ValueError, match="pinned time-aligned track"):
+    result = {
+        "fabricated": np.full((3, 3), 999.0),
+        "incomplete": np.zeros((2, 3)),
+        "nonfinite": np.full((3, 3), np.nan),
+    }[kind]
+    with pytest.raises(
+        ValueError, match="original observations|incomplete or nonfinite"
+    ):
         validate_clean_basemap_resource(
             manifest,
             read_asset=assets.__getitem__,
-            observation_to_world=lambda sweep, ordinals, times: original_xyz[ordinals],
-            instance_to_world=lambda token, times, xyz: result,
+            observation_to_world=lambda *args: result,
         )
 
 
-def test_native_geometry_agreement_cannot_hide_fabricated_original_observations():
-    manifest, assets, _ = fixture()
-    with pytest.raises(ValueError, match="differs from its original observations"):
-        validate_clean_basemap_resource(
-            manifest,
-            read_asset=assets.__getitem__,
-            observation_to_world=lambda sweep, ordinals, times: np.full(
-                (len(ordinals), 3), 999.0
-            ),
-            instance_to_world=lambda token, times, xyz: xyz + [10, 0, 0],
-        )
+def test_native_payload_is_verified_even_with_correct_manifest_binding():
+    manifest, assets, native = fixture()
+    assets[native["scene_index"]["chunks"][0]["geometry"]] = b"tampered native geometry"
+    with pytest.raises(ValueError, match="byte-exact"):
+        validate(manifest, assets)
 
 
-def test_model_removal_is_accounted_and_cannot_be_mapped():
-    manifest, assets, _ = fixture()
-    sweep = manifest["sweep_sources"][0]
-    carrier = encode_clean_basemap_decisions(
-        asset_sha256=sweep["asset_sha256"], decisions=[1, 0, 0, 2, REMOVE_MODEL_DYNAMIC]
+@pytest.mark.parametrize("key", sorted(CLEAN_BASEMAP_INPUT_FIELDS))
+def test_actual_source_or_pose_change_changes_dependency(key):
+    manifest, _, _ = fixture()
+    inputs = dict(manifest["input_identity"], **{key: "sha256:" + "f" * 64})
+    assert (
+        compute_clean_basemap_dependency_identity(inputs, manifest["profile"])
+        != manifest["dependency_identity"]
     )
-    sweep["decisions"] = carrier.descriptor("decisions")
-    assets[sweep["decisions"]["path"]] = carrier.payload
-    manifest["diagnostics"]["decision_counts"].update({"17": 0, "18": 1})
-    manifest["basemap_revision"] = compute_clean_basemap_revision(manifest)
-    validate(manifest, assets)
-    remap(manifest, assets, raw_point_ordinals=[0, 1, 2, 4])
+
+
+@pytest.mark.parametrize("code", [2, 16, 17])
+def test_retired_box_and_geometry_decisions_are_rejected(code):
     with pytest.raises(ValueError, match="decision"):
-        validate(manifest, assets)
+        encode_clean_basemap_decisions(
+            asset_sha256="sha256:" + "a" * 64, decisions=[code]
+        )
 
 
 def test_previous_contract_and_decision_bytes_are_rejected():
     manifest, _, _ = fixture()
-    manifest["contract_version"] = "x4d-clean-static-basemap-v1"
+    manifest["contract_version"] = "x4d-clean-static-basemap-v3"
     with pytest.raises(ValueError, match="contract"):
         parse_clean_basemap_manifest(manifest)
     carrier = encode_clean_basemap_decisions(
         asset_sha256="sha256:" + "a" * 64, decisions=[REMOVE_MODEL_DYNAMIC]
     )
     raw = zstandard.ZstdDecompressor().decompress(carrier.payload)
-    old = zstandard.ZstdCompressor().compress(b"X4DCBD1\0" + raw[8:])
+    old_raw = b"X4DCBD2\0" + raw[8:]
+    old = zstandard.ZstdCompressor().compress(old_raw)
     descriptor = carrier.descriptor("decisions")
     descriptor.update(
         path=f"generated/reconstruction/clean_basemap/decisions/{sha256_bytes(old)[7:]}.zst",
         sha256=sha256_bytes(old),
-        raw_sha256=sha256_bytes(b"X4DCBD1\0" + raw[8:]),
+        raw_sha256=sha256_bytes(old_raw),
         size_bytes=len(old),
     )
     with pytest.raises(ValueError, match="bound to different"):
@@ -315,29 +274,23 @@ def test_previous_contract_and_decision_bytes_are_rejected():
 
 
 @pytest.mark.parametrize("family", ["decisions", "mapping"])
-def test_every_byte_in_the_last_record_obeys_its_exact_decision_domain(family):
-    count = 4096
-    anchor = "sha256:" + "a" * 64
+def test_every_byte_in_last_record_obeys_exact_decision_domain(family):
+    count, anchor = 4096, "sha256:" + "a" * 64
     if family == "decisions":
         carrier = encode_clean_basemap_decisions(
             asset_sha256=anchor, decisions=np.full(count, KEEP_GROUND)
         )
-        domain = DECISION_CODES
-        decode = decode_clean_basemap_decisions
-        arguments = dict(asset_sha256=anchor, point_count=count)
-        byte_offset = -1
+        domain, decode = DECISION_CODES, decode_clean_basemap_decisions
+        arguments, byte_offset = dict(asset_sha256=anchor, point_count=count), -1
     else:
         carrier = encode_clean_basemap_mapping(
             geometry_raw_sha256=anchor,
             sweep_indices=np.zeros(count, dtype=np.uint32),
             raw_point_ordinals=np.arange(count),
             timestamps_ns=np.full(count, 100),
-            owner_source_indices=np.zeros(count, dtype=np.uint32),
-            owner_point_ordinals=np.arange(count),
             decisions=np.full(count, KEEP_GROUND),
         )
-        domain = KEEP_CODES
-        decode = decode_clean_basemap_mapping
+        domain, decode = KEEP_CODES, decode_clean_basemap_mapping
         arguments = dict(geometry_raw_sha256=anchor, point_count=count)
         byte_offset = -MAPPING_DTYPE.itemsize + MAPPING_DTYPE.fields["decision"][1]
     raw = bytearray(zstandard.ZstdDecompressor().decompress(carrier.payload))
@@ -353,87 +306,30 @@ def test_every_byte_in_the_last_record_obeys_its_exact_decision_domain(family):
         )
         if code in domain:
             values = decode(payload, descriptor=descriptor, **arguments)
-            decisions = values if family == "decisions" else values["decision"]
-            assert decisions[-1] == code
-            assert np.all(decisions[:-1] == KEEP_GROUND)
+            assert (values if family == "decisions" else values["decision"])[-1] == code
         else:
-            message = "decision" if family == "decisions" else "mapping records"
-            with pytest.raises(ValueError, match=message):
+            with pytest.raises(ValueError):
                 decode(payload, descriptor=descriptor, **arguments)
 
 
-def test_pose_coverage_rejections_are_accounted_and_cannot_be_mapped():
-    manifest, assets, _ = fixture()
-    sweep = manifest["sweep_sources"][0]
-    carrier = encode_clean_basemap_decisions(
-        asset_sha256=sweep["asset_sha256"], decisions=[1, 0, 0, 2, 34]
-    )
-    sweep["decisions"] = carrier.descriptor("decisions")
-    assets[sweep["decisions"]["path"]] = carrier.payload
-    manifest["diagnostics"]["decision_counts"].update({"17": 0, "34": 1})
-    manifest["basemap_revision"] = compute_clean_basemap_revision(manifest)
-    assert decode_clean_basemap_decisions(
-        carrier.payload,
-        descriptor=sweep["decisions"],
-        asset_sha256=sweep["asset_sha256"],
-        point_count=5,
-    ).tolist() == [1, 0, 0, 2, 34]
-    validate(manifest, assets)
-    remap(manifest, assets, raw_point_ordinals=[0, 1, 2, 4])
-    with pytest.raises(ValueError, match="decision"):
-        validate(manifest, assets)
-
-
-def test_auto_track_regrouping_invalidates_temporal_ownership():
-    _, _, native = fixture()
-    original = compute_annotation_dependency_revisions(native["annotation"])
-    rows = copy.deepcopy(native["annotation"]["annotations"])
-    rows[0]["instance_token"] = "regrouped-track"
-    edited = build_clip_annotations(
-        native["annotation"]["clip_id"],
-        native["annotation"]["annotation_frame_id"],
-        rows,
-    )
-    assert (
-        compute_annotation_dependency_revisions(edited)["scene_ownership_revision"]
-        != original["scene_ownership_revision"]
-    )
-
-
-def test_native_label_edit_keeps_geometry_binding_but_motion_or_source_edit_does_not():
-    manifest, _, native = fixture()
-    edited = copy.deepcopy(native["annotation"]["annotations"])
-    edited[0]["motion"] = "dynamic"
-    annotation = build_clip_annotations(
-        native["annotation"]["clip_id"],
-        native["annotation"]["annotation_frame_id"],
-        edited,
-    ).to_dict()
-    with pytest.raises(ValueError, match="dependencies"):
-        validate_clean_basemap_annotation(manifest, annotation)
-    scene = copy.deepcopy(native["scene_index"])
-    scene["chunks"][0]["semantic_histogram"] = [{"code": 0, "count": 3}]
-    # Existing native parsing enforces the independent label revision too.
-    from x4d_devkit.semantic_scene_contract import compute_scene_semantics_revision
-
-    scene["scene_semantics_revision"] = compute_scene_semantics_revision(scene)
-    assert clean_basemap_scene_source(scene) == manifest["scene_source"]
-
-
 @pytest.mark.parametrize(
     "edit",
     [
         lambda m: m.update(extra=True),
         lambda m: m.update(point_count=True),
-        lambda m: m["input_identity"].update(legacy="sha256:" + "f" * 64),
+        lambda m: m["input_identity"].update(
+            scene_ownership_revision="sha256:" + "f" * 64
+        ),
+        lambda m: m.update(instance_sources=[]),
+        lambda m: m.update(preannotation_evidence=None),
         lambda m: m["chunks"][0]["geometry"].update(path="../other.spc.zst"),
         lambda m: m["chunks"][0].update(ordinal=1),
         lambda m: m["chunks"].append(copy.deepcopy(m["chunks"][0])),
         lambda m: m["diagnostics"]["decision_counts"].update({"17": 0}),
-        lambda m: m["instance_sources"].reverse(),
         lambda m: m["sweep_sources"].append(copy.deepcopy(m["sweep_sources"][0])),
         lambda m: m["profile"].update(unknown_policy="delete"),
         lambda m: m["profile"].update(point_deskew=False),
+        lambda m: m["profile"]["policies"].update(motion={}),
     ],
 )
 def test_manifest_rejects_partial_unknown_and_noncanonical_shapes(edit):
@@ -444,6 +340,16 @@ def test_manifest_rejects_partial_unknown_and_noncanonical_shapes(edit):
         parse_clean_basemap_manifest(manifest)
 
 
+def test_native_label_edit_keeps_geometry_binding():
+    manifest, _, native = fixture()
+    scene = copy.deepcopy(native["scene_index"])
+    scene["chunks"][0]["semantic_histogram"] = [{"code": 0, "count": 3}]
+    from x4d_devkit.semantic_scene_contract import compute_scene_semantics_revision
+
+    scene["scene_semantics_revision"] = compute_scene_semantics_revision(scene)
+    assert clean_basemap_scene_source(scene) == manifest["scene_source"]
+
+
 def test_decoder_rejects_cross_geometry_reserved_bytes_and_extra_frames():
     manifest, assets, _ = fixture()
     chunk = manifest["chunks"][0]
@@ -453,33 +359,36 @@ def test_decoder_rejects_cross_geometry_reserved_bytes_and_extra_frames():
             payload,
             descriptor=chunk["mapping"],
             geometry_raw_sha256="sha256:" + "f" * 64,
-            point_count=4,
+            point_count=3,
         )
     raw = bytearray(zstandard.ZstdDecompressor().decompress(payload))
     raw[44 + MAPPING_DTYPE.fields["reserved"][1]] = 1
     malformed = zstandard.ZstdCompressor().compress(raw)
     for body in (malformed, payload + payload):
-        descriptor = {
-            "path": f"generated/reconstruction/clean_basemap/mapping/{sha256_bytes(body)[7:]}.zst",
-            "sha256": sha256_bytes(body),
-            "raw_sha256": sha256_bytes(bytes(raw)),
-            "size_bytes": len(body),
-        }
+        descriptor = dict(
+            path=f"generated/reconstruction/clean_basemap/mapping/{sha256_bytes(body)[7:]}.zst",
+            sha256=sha256_bytes(body),
+            raw_sha256=sha256_bytes(bytes(raw)),
+            size_bytes=len(body),
+        )
         with pytest.raises(ValueError):
             decode_clean_basemap_mapping(
                 body,
                 descriptor=descriptor,
                 geometry_raw_sha256=chunk["geometry"]["raw_sha256"],
-                point_count=4,
+                point_count=3,
             )
 
 
-def test_mapping_encoder_rejects_float_negative_and_removed_observations():
+@pytest.mark.parametrize(
+    "changes",
+    [
+        {"raw_point_ordinals": [-1, 1, 2]},
+        {"timestamps_ns": [100.0] * 3},
+        {"decisions": [KEEP_GROUND, 0, 18]},
+    ],
+)
+def test_mapping_encoder_rejects_float_negative_and_removed_observations(changes):
     manifest, assets, _ = fixture()
-    for changes in (
-        {"raw_point_ordinals": [-1, 1, 2, 3]},
-        {"timestamps_ns": [100.0] * 4},
-        {"decisions": [KEEP_GROUND, 0, 0, 17]},
-    ):
-        with pytest.raises(ValueError):
-            remap(manifest, assets, **changes)
+    with pytest.raises(ValueError):
+        remap(manifest, assets, **changes)

{x4d_devkit-0.45.0rc1 → x4d_devkit-0.46.0rc2}/tests/test_clean_basemap_client.py

@@ -67,12 +67,12 @@ def test_typed_client_uses_scoped_routes_and_verified_geometry():
         geometry = client.reconstruction.fetch_clean_basemap_geometry(
             current, chunk_ordinal=0
         )
-        assert geometry.xyz.shape == (4, 3)
-        assert np.array_equal(geometry.rgb[-1], [100, 110, 120])
+        assert geometry.xyz.shape == (3, 3)
+        assert np.array_equal(geometry.rgb[-1], [70, 80, 90])
         mapping = client.reconstruction.fetch_clean_basemap_mapping(
             current, chunk_ordinal=0
         )
-        assert mapping["owner_source_index"].tolist() == [0, 0, 0, 1]
+        assert mapping["raw_point_ordinal"].tolist() == [0, 1, 2]
         cancelled = client.reconstruction.cancel_clean_basemap_task(
             project_id=7, task_id="task-0"
         )

{x4d_devkit-0.45.0rc1 → x4d_devkit-0.46.0rc2}/tests/test_sdk_api.py

@@ -11,7 +11,7 @@ from x4d_devkit.eval.matching import MetricData
 
 
 def test_package_version_is_current_release():
-    assert x4d_devkit.__version__ == "0.45.0rc1"
+    assert x4d_devkit.__version__ == "0.46.0rc2"
 
 
 def test_loader_exposes_and_enforces_only_current_schema(tmp_path):