extends SceneTree const ProjectorType = preload("res://scripts/world/facility_infrastructure_projector.gd") const AdapterType = preload("res://scripts/world/route_subslot_path_adapter.gd") const SpatialType = preload("res://scripts/world/spatial_subslot_service.gd") const PathType = preload("res://scripts/world/path_service.gd") const WorldType = preload("res://scripts/world/world_service.gd") const FacilityDefinitionType = preload("res://scripts/data/facility_definition.gd") const CommandResultType = preload("res://scripts/core/command_result.gd") const GUEST_CORRIDOR = preload("res://data/facilities/guest_corridor.tres") const SERVICE_CORRIDOR = preload("res://data/facilities/service_corridor.tres") const STAFF_DOOR = preload("res://data/facilities/staff_door.tres") const GUEST_ELEVATOR = preload("res://data/facilities/guest_elevator.tres") const SERVICE_ELEVATOR = preload("res://data/facilities/service_elevator.tres") class ControlledPathService: extends PathService var fail_next_rebuild_after_mutation := false var fail_next_connector_after_mutation := false var fail_next_remove_after_mutation := false var reject_restore := false var reenter_next_connector := false var tamper_projector_next_connector := false var projector: Variant = null var reentry_result: Variant = null func rebuild_graph(passable_cells: Variant) -> bool: var should_fail := fail_next_rebuild_after_mutation fail_next_rebuild_after_mutation = false var result := super.rebuild_graph(passable_cells) if should_fail: last_error = "Injected graph rebuild failure after mutation." return false return result func configure_connector( connector_id: StringName, from_cell: Vector3i, to_cell: Vector3i, cost := DEFAULT_CONNECTOR_COST, bidirectional := true, access_id: StringName = &"", enabled := true, options: Dictionary = {} ) -> bool: var should_fail := fail_next_connector_after_mutation fail_next_connector_after_mutation = false var should_reenter := reenter_next_connector reenter_next_connector = false var should_tamper := tamper_projector_next_connector tamper_projector_next_connector = false var result := super.configure_connector( connector_id, from_cell, to_cell, cost, bidirectional, access_id, enabled, options ) if should_reenter and projector != null: reentry_result = projector.unproject_facility(&"nested_unproject", &"facility_nested") if should_tamper and projector != null: projector.projection_revision += 100 if should_fail: last_error = "Injected connector failure after mutation." return false return result func remove_connector(connector_id: StringName) -> bool: var should_fail := fail_next_remove_after_mutation fail_next_remove_after_mutation = false var result := super.remove_connector(connector_id) if should_fail: last_error = "Injected connector removal failure after mutation." return false return result func restore_snapshot(snapshot: Dictionary) -> bool: if reject_restore: last_error = "Injected Path snapshot restore rejection." return false return super.restore_snapshot(snapshot) var _checks := 0 var _failures := 0 func _initialize() -> void: call_deferred("_run") func _run() -> void: print("S1: completed-facility infrastructure projection") _test_corridors_and_primary_world_coexistence() _test_staff_door_access_and_stable_ids() _test_project_unproject_replay_and_defensive_queries() _test_vertical_topology_projects_without_walk_bypass() _test_definition_and_instance_crosslink_validation() _test_project_and_unproject_failures_roll_back_exactly() _test_callback_reentry_tamper_and_quarantine_recovery() _test_strict_snapshot_round_trip_and_atomic_rejection() _test_configuration_and_stale_dependency_boundaries() _test_validation_cache_detects_changes() if _failures == 0: print("PASS: %d checks" % _checks) else: push_error("FAIL: %d of %d checks failed" % [_failures, _checks]) quit(_failures) func _test_corridors_and_primary_world_coexistence() -> void: var front_start := Vector3i(0, 0, PathType.FRONT) var front_mid := Vector3i(1, 0, PathType.FRONT) var front_goal := Vector3i(2, 0, PathType.FRONT) var back_start := Vector3i(0, 2, PathType.BACK) var back_mid := Vector3i(1, 2, PathType.BACK) var back_goal := Vector3i(2, 2, PathType.BACK) var context := _context([front_start, front_goal, back_start, back_goal]) var world := WorldType.new() world.reset({&"min_x": -2, &"max_x": 4, &"min_y": -2, &"max_y": 4}) _expect(world.occupy(&"facility_00000001", [front_mid], &"facility"), "completed facility occupies the primary World slot") var guest_instance := _instance(GUEST_CORRIDOR, &"facility_00000001", front_mid, 10, &"construction_00000001") var guest_result = context.projector.project_facility(&"project_guest", GUEST_CORRIDOR, guest_instance) _expect(guest_result.is_success(), "guest corridor projects through the atomic boundary") _expect(context.path.find_path(front_start, front_goal) == [front_start, front_mid, front_goal], "guest corridor makes the real FRONT Path reachable") _expect(world.get_occupant(front_mid) == &"facility_00000001", "ROUTE subslot projection preserves primary World occupancy") var guest_projection: Dictionary = context.projector.get_projection(&"facility_00000001") _expect(guest_projection[&"layer"] == PathType.FRONT and not guest_projection[&"staff_only"], "guest corridor metadata preserves FRONT guest meaning") var service_instance := _instance(SERVICE_CORRIDOR, &"facility_00000002", back_mid, 11, &"construction_00000002") var service_result = context.projector.project_facility(&"project_service", SERVICE_CORRIDOR, service_instance) _expect(service_result.is_success(), "service corridor projects through the same boundary") _expect(context.path.find_path(back_start, back_goal) == [back_start, back_mid, back_goal], "service corridor makes the real BACK Path reachable") _expect(context.path.find_path(back_start, back_goal, [PathType.FRONT]).is_empty(), "FRONT-only guest profile cannot use the staff-only BACK corridor") var service_projection: Dictionary = context.projector.get_projection(&"facility_00000002") _expect(service_projection[&"layer"] == PathType.BACK and service_projection[&"staff_only"], "service corridor retains explicit staff-only semantics") _expect(context.path.find_path(front_start, back_goal, [PathType.FRONT, PathType.BACK]).is_empty(), "FRONT and BACK remain separated without a staff door") _expect(context.projector.projection_revision == 2, "corridor projections advance one deterministic revision each") _expect(context.projector.validate_invariants()[&"ok"], "corridor route/entity/cell crosslinks are valid") func _test_staff_door_access_and_stable_ids() -> void: var front := Vector3i(5, 0, PathType.FRONT) var back := Vector3i(5, 0, PathType.BACK) var context := _context([front]) var instance := _instance(STAFF_DOOR, &"facility_00000003", back, 20, &"construction_00000003") var result = context.projector.project_facility(&"project_staff_door", STAFF_DOOR, instance) _expect(result.is_success(), "staff door projects its BACK endpoint and connector atomically") var projection: Dictionary = context.projector.get_projection(&"facility_00000003") _expect(projection[&"route_entity_id"] == &"infra.route:facility_00000003", "staff door route entity ID is stable") _expect(projection[&"connector_id"] == &"infra.connector:facility_00000003", "staff door connector ID is stable") _expect(context.source.get_entity_cells(projection[&"route_entity_id"]) == [back], "staff door owns exactly its BACK ROUTE endpoint") var connector: Dictionary = context.path.get_connector(projection[&"connector_id"]) _expect(connector[&"from"] == front and connector[&"to"] == back, "connector joins the same coordinate across FRONT/BACK") _expect(connector[&"cost"] == 120 and connector[&"bidirectional"] and connector[&"access_id"] == &"staff", "connector is bidirectional, cost 120, and staff-gated") _expect(context.path.find_path(front, back, [PathType.FRONT, PathType.BACK], []).is_empty(), "guest access cannot traverse the staff door") _expect(context.path.last_no_route_reason != context.path.ROUTE_OK, "guest denial reports a real no-route reason rather than fake reachability") _expect(context.path.find_path(front, back, [PathType.FRONT, PathType.BACK], [&"staff"]) == [front, back], "staff connector access traverses the real door") _expect(context.path.last_path_cost == 120, "staff door route report uses the exact specification cost") _expect(context.path.calculate_path_cost([front, back], [&"staff"]) == 120, "explicit Path cost calculation preserves staff-door cost 120") _expect(context.projector.validate_invariants()[&"ok"], "staff-door connector and route crosslinks are exact") func _test_project_unproject_replay_and_defensive_queries() -> void: var cell := Vector3i(1, 4, PathType.FRONT) var context := _context([]) var instance := _instance(GUEST_CORRIDOR, &"facility_00000004", cell, 30, &"construction_00000004") var first = context.projector.project_facility(&"idem_project", GUEST_CORRIDOR, instance) var after_projector: Dictionary = context.projector.create_snapshot() var after_source: Dictionary = context.source.create_snapshot() var after_adapter: Dictionary = context.adapter.create_snapshot() var after_path: Dictionary = context.path.create_snapshot() var replay = context.projector.project_facility(&"idem_project", GUEST_CORRIDOR, instance) _expect(first.is_success() and replay.is_success() and replay.is_replay, "same project request and fingerprint replays") _expect(replay.details == first.details, "project replay preserves exact result details") _expect(context.projector.create_snapshot() == after_projector, "project replay does not advance projector state") _expect(context.source.create_snapshot() == after_source and context.adapter.create_snapshot() == after_adapter and context.path.create_snapshot() == after_path, "project replay leaves all three dependencies exact") var changed_instance := instance.duplicate(true) changed_instance[&"completed_at"] = 31 var conflict = context.projector.project_facility(&"idem_project", GUEST_CORRIDOR, changed_instance) _expect(conflict.code == CommandResultType.Code.DUPLICATE_IDEMPOTENCY_KEY, "same request ID with changed completed input conflicts") var duplicate = context.projector.project_facility(&"another_project", GUEST_CORRIDOR, instance) _expect(duplicate.code == CommandResultType.Code.DUPLICATE_COMMAND_ID, "another request cannot double-project one facility") var returned: Dictionary = context.projector.get_projection(&"facility_00000004") returned[&"cells"].clear() var ids: Array[StringName] = context.projector.get_projection_ids() ids.clear() var status: Dictionary = context.projector.get_status() status[&"projection_count"] = 99 _expect(context.projector.get_projection(&"facility_00000004")[&"cells"] == [cell], "projection query is a defensive deep copy") _expect(context.projector.get_projection_ids() == [&"facility_00000004"], "projection ID query is defensive and lexical") _expect(context.projector.get_status()[&"projection_count"] == 1, "status query is defensive") var removed = context.projector.unproject_facility(&"idem_remove", &"facility_00000004") _expect(removed.is_success(), "facility infrastructure unprojects atomically") _expect(not context.source.has_entity(&"infra.route:facility_00000004") and not context.path.has_cell(cell), "unproject removes the route from both source and real Path") var removed_snapshot: Dictionary = context.projector.create_snapshot() var remove_replay = context.projector.unproject_facility(&"idem_remove", &"facility_00000004") _expect(remove_replay.is_success() and remove_replay.is_replay, "same unproject request replays after the entity is gone") _expect(context.projector.create_snapshot() == removed_snapshot, "unproject replay is mutation-free") var remove_conflict = context.projector.unproject_facility(&"idem_remove", &"facility_other") _expect(remove_conflict.code == CommandResultType.Code.DUPLICATE_IDEMPOTENCY_KEY, "unproject request conflict is rejected") _expect(context.projector.projection_revision == 2, "project and unproject each advance exactly once") func _test_vertical_topology_projects_without_walk_bypass() -> void: var context := _context([Vector3i(0, 0, PathType.FRONT)]) var guest_instance := _instance(GUEST_ELEVATOR, &"facility_00000005", Vector3i(4, 4, PathType.FRONT), 40, &"construction_00000005") var guest = context.projector.project_facility(&"guest_elevator", GUEST_ELEVATOR, guest_instance) _expect(guest.is_success(), "guest elevator projects completed shaft topology") var service_instance := _instance(SERVICE_ELEVATOR, &"facility_00000006", Vector3i(8, 4, PathType.BACK), 41, &"construction_00000006") var service = context.projector.project_facility(&"service_elevator", SERVICE_ELEVATOR, service_instance) _expect(service.is_success(), "service elevator projects completed shaft topology") _expect(context.path.find_path(Vector3i(4, 4, 0), Vector3i(4, 5, 0)).is_empty(), "guest shaft cannot be climbed without its separately owned cabin connector") _expect(context.path.find_path(Vector3i(8, 4, 1), Vector3i(8, 5, 1)).is_empty(), "service shaft cannot be climbed by ordinary walk edges") _expect(context.path.get_vertical_walk_blockers().size() == 2 and context.projector.validate_invariants()[&"ok"], "both completed elevator footprints retain authoritative owned shaft restrictions") func _test_definition_and_instance_crosslink_validation() -> void: var context := _context([]) var base_instance := _instance(GUEST_CORRIDOR, &"facility_00000007", Vector3i(0, 6, PathType.FRONT), 50, &"construction_00000007") var before := _all_snapshots(context) var wrong_layer: FacilityDefinition = GUEST_CORRIDOR.duplicate(true) wrong_layer.layer = FacilityDefinitionType.ViewLayer.BACK _expect(not context.projector.project_facility(&"bad_definition_layer", wrong_layer, base_instance).is_success(), "definition layer mismatch is rejected") var wrong_tags: FacilityDefinition = GUEST_CORRIDOR.duplicate(true) wrong_tags.tags = [&"corridor", &"movement", &"route_subslot", &"schema_facility_proxy"] _expect(not context.projector.project_facility(&"bad_definition_tags", wrong_tags, base_instance).is_success(), "definition tag mismatch is rejected") var wrong_pass: FacilityDefinition = GUEST_CORRIDOR.duplicate(true) wrong_pass.pass_through = false _expect(not context.projector.project_facility(&"bad_definition_pass", wrong_pass, base_instance).is_success(), "definition pass-through mismatch is rejected") var unknown: FacilityDefinition = GUEST_CORRIDOR.duplicate(true) unknown.id = &"unknown_proxy" _expect(not context.projector.project_facility(&"unknown_definition", unknown, base_instance).is_success(), "unknown proxy definition is rejected") var extra := base_instance.duplicate(true) extra[&"extra"] = true _expect(not context.projector.project_facility(&"instance_extra", GUEST_CORRIDOR, extra).is_success(), "completed instance with an extra field is rejected") var wrong_definition := base_instance.duplicate(true) wrong_definition[&"definition_id"] = &"service_corridor" _expect(not context.projector.project_facility(&"instance_definition", GUEST_CORRIDOR, wrong_definition).is_success(), "instance-to-definition ID mismatch is rejected") var wrong_state := base_instance.duplicate(true) wrong_state[&"state"] = &"PLANNED" _expect(not context.projector.project_facility(&"instance_state", GUEST_CORRIDOR, wrong_state).is_success(), "non-ACTIVE completed instance is rejected") var wrong_layer_instance := base_instance.duplicate(true) wrong_layer_instance[&"layer"] = PathType.BACK _expect(not context.projector.project_facility(&"instance_layer", GUEST_CORRIDOR, wrong_layer_instance).is_success(), "instance layer crosslink mismatch is rejected") var wrong_cells := base_instance.duplicate(true) wrong_cells[&"occupied_cells"] = [Vector3i(1, 6, PathType.FRONT)] _expect(not context.projector.project_facility(&"instance_cells", GUEST_CORRIDOR, wrong_cells).is_success(), "instance cells outside its definition footprint are rejected") var duplicate_cells := base_instance.duplicate(true) duplicate_cells[&"occupied_cells"] = [base_instance[&"origin"], base_instance[&"origin"]] _expect(not context.projector.project_facility(&"instance_duplicate_cells", GUEST_CORRIDOR, duplicate_cells).is_success(), "duplicate instance cells are rejected") var float_cost := base_instance.duplicate(true) float_cost[&"construction_cost"] = {&"gold": 20.0} _expect(not context.projector.project_facility(&"instance_cost_type", GUEST_CORRIDOR, float_cost).is_success(), "non-integer construction cost is rejected") var negative_cost := base_instance.duplicate(true) negative_cost[&"construction_cost"] = {&"gold": -1} _expect(not context.projector.project_facility(&"instance_cost_negative", GUEST_CORRIDOR, negative_cost).is_success(), "negative construction cost is rejected") var bad_request = context.projector.project_facility(4, GUEST_CORRIDOR, base_instance) _expect(bad_request.code == CommandResultType.Code.INVALID_PAYLOAD, "numeric request ID is rejected rather than coerced") _expect(_all_snapshots(context) == before, "all definition/instance validation failures preserve every service exactly") func _test_project_and_unproject_failures_roll_back_exactly() -> void: var path := ControlledPathService.new() var context := _context([Vector3i(0, 8, PathType.FRONT)], path) path.projector = context.projector var guest := _instance(GUEST_CORRIDOR, &"facility_00000008", Vector3i(1, 8, PathType.FRONT), 60, &"construction_00000008") var before := _all_snapshots(context) path.fail_next_rebuild_after_mutation = true var route_failure = context.projector.project_facility(&"retry_route_failure", GUEST_CORRIDOR, guest) _assert_exact_rollback(context, before, route_failure, "route adapter Path rebuild failure") _expect(context.projector.project_facility(&"retry_route_failure", GUEST_CORRIDOR, guest).is_success(), "failed project request can retry after exact rollback") var door := _instance(STAFF_DOOR, &"facility_00000009", Vector3i(3, 8, PathType.BACK), 61, &"construction_00000009") before = _all_snapshots(context) path.fail_next_connector_after_mutation = true var connector_failure = context.projector.project_facility(&"retry_connector_failure", STAFF_DOOR, door) _assert_exact_rollback(context, before, connector_failure, "staff connector apply failure") _expect(not context.source.has_entity(&"infra.route:facility_00000009") and not context.path.has_connector(&"infra.connector:facility_00000009"), "failed staff-door projection leaves neither route nor connector") _expect(context.projector.project_facility(&"retry_connector_failure", STAFF_DOOR, door).is_success(), "failed staff-door request retries after exact rollback") before = _all_snapshots(context) path.fail_next_remove_after_mutation = true var remove_failure = context.projector.unproject_facility(&"retry_remove_failure", &"facility_00000009") _assert_exact_rollback(context, before, remove_failure, "staff connector removal failure") _expect(context.source.has_entity(&"infra.route:facility_00000009") and context.path.has_connector(&"infra.connector:facility_00000009"), "failed unproject restores route and connector") _expect(context.projector.unproject_facility(&"retry_remove_failure", &"facility_00000009").is_success(), "failed unproject request retries after exact rollback") path.projector = null func _test_callback_reentry_tamper_and_quarantine_recovery() -> void: var path := ControlledPathService.new() var front := Vector3i(5, 10, PathType.FRONT) var context := _context([front], path) path.projector = context.projector var first_door := _instance(STAFF_DOOR, &"facility_00000010", Vector3i(5, 10, PathType.BACK), 70, &"construction_00000010") path.reenter_next_connector = true var outer = context.projector.project_facility(&"outer_reentry", STAFF_DOOR, first_door) _expect(outer.is_success(), "outer staff-door transaction commits when callback only attempts reentry") _expect(path.reentry_result != null and path.reentry_result.code == CommandResultType.Code.TRANSACTION_CLOSED, "Path callback reentry is rejected") _expect(context.projector.projection_revision == 1, "reentry cannot advance a nested projector revision") var second_door := _instance(STAFF_DOOR, &"facility_00000011", Vector3i(7, 10, PathType.BACK), 71, &"construction_00000011") var before := _all_snapshots(context) path.tamper_projector_next_connector = true var tampered = context.projector.project_facility(&"callback_tamper", STAFF_DOOR, second_door) _assert_exact_rollback(context, before, tampered, "Path callback projector tamper") _expect(context.projector.projection_revision == 1 and not context.projector.has_projection(&"facility_00000011"), "callback tamper cannot leak owned metadata") var recovery := _all_snapshots(context) path.fail_next_connector_after_mutation = true path.reject_restore = true var uncertain_door := _instance(STAFF_DOOR, &"facility_00000012", Vector3i(9, 10, PathType.BACK), 72, &"construction_00000012") var uncertain = context.projector.project_facility(&"uncertain_project", STAFF_DOOR, uncertain_door) _expect(not uncertain.is_success() and not uncertain.details[&"rollback_ok"], "uncertain dependency rollback reports its uncertainty") _expect(context.projector.is_quarantined() and context.projector.get_quarantine_reason() == context.projector.QUARANTINE_TRANSACTION_ROLLBACK, "uncertain rollback quarantines the projector") _expect(context.projector.project_facility(&"blocked_quarantine", GUEST_CORRIDOR, _instance(GUEST_CORRIDOR, &"facility_00000013", Vector3i(11, 10, 0), 73, &"construction_00000013")).code == CommandResultType.Code.TRANSACTION_CLOSED, "quarantine blocks further projection") path.reject_restore = false _expect(context.source.restore_snapshot(recovery.source), "quarantine recovery restores the Spatial snapshot") _restore_path_for_test(context.path, recovery.path_cells, recovery.path) _expect(context.adapter.restore_snapshot(recovery.adapter), "quarantine recovery restores the Route adapter snapshot") _expect(context.projector.restore_snapshot(recovery.projector), "matching projector snapshot clears quarantine") _expect(not context.projector.is_quarantined() and context.projector.validate_invariants()[&"ok"], "recovered projector returns to a valid available state") path.projector = null func _test_strict_snapshot_round_trip_and_atomic_rejection() -> void: var base := [ Vector3i(0, 12, PathType.FRONT), Vector3i(4, 12, PathType.FRONT), ] var context := _context(base) var guest := _instance(GUEST_CORRIDOR, &"facility_00000020", Vector3i(1, 12, 0), 80, &"construction_00000020") var door := _instance(STAFF_DOOR, &"facility_00000021", Vector3i(3, 12, 1), 81, &"construction_00000021") context.projector.project_facility(&"z_project", GUEST_CORRIDOR, guest) context.projector.project_facility(&"a_project", STAFF_DOOR, door) context.projector.unproject_facility(&"m_unproject", &"facility_00000020") var snapshot: Dictionary = context.projector.create_snapshot() _expect(snapshot[&"projections"].map(func(row: Dictionary) -> String: return row[&"instance_id"]) == ["facility_00000021"], "snapshot stores only current projections in lexical order") _expect(snapshot[&"processed_requests"].map(func(row: Dictionary) -> String: return row[&"request_id"]) == ["a_project", "m_unproject", "z_project"], "snapshot history is lexical independently of revision order") _expect(snapshot[&"projection_revision"] == 3, "snapshot preserves contiguous successful revision history") var restored_source := SpatialType.new() var restored_path := PathType.new() var restored_adapter := AdapterType.new() _expect(restored_adapter.configure(restored_source, restored_path, base), "round-trip target adapter configures empty dependencies") var restored_projector := ProjectorType.new() _expect(restored_projector.configure(restored_adapter, restored_source, restored_path), "round-trip target projector configures before dependency restore") _expect(restored_source.restore_snapshot(context.source.create_snapshot()), "round-trip target restores Spatial state") _restore_path_for_test(restored_path, _path_cells(context.path), context.path.create_snapshot()) _expect(restored_adapter.restore_snapshot(context.adapter.create_snapshot()), "round-trip target restores Route adapter state") _expect(restored_projector.restore_snapshot(snapshot), "strict current projector snapshot restores against matching dependencies") _expect(restored_projector.create_snapshot() == snapshot, "projector snapshot round trip is exact") _expect(restored_projector.validate_invariants()[&"ok"], "restored history/projection/dependency crosslinks validate") var replay_source: Dictionary = restored_source.create_snapshot() var replay_adapter: Dictionary = restored_adapter.create_snapshot() var replay_path: Dictionary = restored_path.create_snapshot() var restored_replay = restored_projector.project_facility(&"a_project", STAFF_DOOR, door) _expect(restored_replay.is_success() and restored_replay.is_replay, "restored project history replays with the same canonical input") _expect(restored_projector.create_snapshot() == snapshot and restored_source.create_snapshot() == replay_source and restored_adapter.create_snapshot() == replay_adapter and restored_path.create_snapshot() == replay_path, "restored replay leaves metadata and dependencies unchanged") var restored_context := { &"source": restored_source, &"path": restored_path, &"adapter": restored_adapter, &"projector": restored_projector, } var before := _all_snapshots(restored_context) var wrong_version: Dictionary = snapshot.duplicate(true) wrong_version[&"schema_version"] = 2 _atomic_snapshot_reject(restored_context, wrong_version, before, "unknown snapshot version") var version_type: Dictionary = snapshot.duplicate(true) version_type[&"schema_version"] = "1" _atomic_snapshot_reject(restored_context, version_type, before, "string snapshot version") var unknown_field: Dictionary = snapshot.duplicate(true) unknown_field[&"extra"] = true _atomic_snapshot_reject(restored_context, unknown_field, before, "unknown root field") var revision_type: Dictionary = snapshot.duplicate(true) revision_type[&"projection_revision"] = 3.0 _atomic_snapshot_reject(restored_context, revision_type, before, "floating projection revision") var projection_order: Dictionary = snapshot.duplicate(true) projection_order[&"projections"].append(projection_order[&"projections"][0].duplicate(true)) _atomic_snapshot_reject(restored_context, projection_order, before, "duplicate projection order") var request_order: Dictionary = snapshot.duplicate(true) request_order[&"processed_requests"].reverse() _atomic_snapshot_reject(restored_context, request_order, before, "unordered request history") var fingerprint: Dictionary = snapshot.duplicate(true) fingerprint[&"processed_requests"][0][&"fingerprint"] = "0".repeat(64) _atomic_snapshot_reject(restored_context, fingerprint, before, "tampered request fingerprint") var result_projection: Dictionary = snapshot.duplicate(true) result_projection[&"processed_requests"][0][&"details"][&"projection"][&"staff_only"] = false _atomic_snapshot_reject(restored_context, result_projection, before, "tampered result projection semantics") var history_revision: Dictionary = snapshot.duplicate(true) history_revision[&"processed_requests"][0][&"details"][&"projection_revision"] = 3 _atomic_snapshot_reject(restored_context, history_revision, before, "duplicate history revision") var final_crosslink: Dictionary = snapshot.duplicate(true) final_crosslink[&"projections"].clear() _atomic_snapshot_reject(restored_context, final_crosslink, before, "history-to-current projection mismatch") var record_fingerprint: Dictionary = snapshot.duplicate(true) record_fingerprint[&"projections"][0][&"record_fingerprint"] = "bad" _atomic_snapshot_reject(restored_context, record_fingerprint, before, "tampered projection record fingerprint") var extra_projection_field: Dictionary = snapshot.duplicate(true) extra_projection_field[&"projections"][0][&"extra"] = true _atomic_snapshot_reject(restored_context, extra_projection_field, before, "unknown projection field") var deep: Dictionary = snapshot.duplicate(true) var deep_value: Variant = [] for _index: int in range(restored_projector.MAX_SNAPSHOT_DEPTH + 2): deep_value = [deep_value] deep[&"processed_requests"] = deep_value _atomic_snapshot_reject(restored_context, deep, before, "excessive snapshot depth") var connector_id := &"infra.connector:facility_00000021" var connector_before := restored_path.get_connector(connector_id) _expect(restored_path.configure_connector(connector_id, connector_before[&"from"], connector_before[&"to"], 2, true, &"staff"), "test can introduce a live connector crosslink mismatch") var stale_owned_before := restored_projector.create_snapshot() var dependencies_before_restore := { &"source": restored_source.create_snapshot(), &"adapter": restored_adapter.create_snapshot(), &"path": restored_path.create_snapshot(), } _expect(not restored_projector.restore_snapshot(snapshot), "valid metadata snapshot rejects a mismatched live staff connector") _expect(restored_projector.create_snapshot() == stale_owned_before, "live-crosslink rejection is projector-atomic") _expect(restored_source.create_snapshot() == dependencies_before_restore.source and restored_adapter.create_snapshot() == dependencies_before_restore.adapter and restored_path.create_snapshot() == dependencies_before_restore.path, "live-crosslink rejection preserves all dependency snapshots") func _test_configuration_and_stale_dependency_boundaries() -> void: var source_a := SpatialType.new() var source_b := SpatialType.new() var path_a := PathType.new() var path_b := PathType.new() var adapter := AdapterType.new() adapter.configure(source_a, path_a, []) var projector := ProjectorType.new() _expect(not projector.configure(adapter, source_b, path_a), "configuration rejects a different Spatial instance with equal state") _expect(not projector.configure(adapter, source_a, path_b), "configuration rejects a different Path instance with equal state") _expect(projector.configure(adapter, source_a, path_a), "configuration accepts the exact adapter binding") _expect(not projector.configure(adapter, source_a, path_a), "configured projector rejects reconfiguration") var context := _context([]) var instance := _instance(GUEST_CORRIDOR, &"facility_00000030", Vector3i(1, 14, 0), 90, &"construction_00000030") context.projector.project_facility(&"stale_project", GUEST_CORRIDOR, instance) var before := _all_snapshots(context) _expect(context.source.place(&"external_route", context.source.CATEGORY_ROUTE, [Vector3i(2, 14, 0)]).is_success(), "external ROUTE mutation can stale the lower adapter") var source_after_external: Dictionary = context.source.create_snapshot() var blocked = context.projector.unproject_facility(&"blocked_stale", &"facility_00000030") _expect(blocked.code == CommandResultType.Code.TRANSACTION_CLOSED, "stale dependencies block projector mutation") _expect(context.projector.create_snapshot() == before.projector and context.adapter.create_snapshot() == before.adapter and context.path.create_snapshot() == before.path, "stale rejection preserves projector, adapter, and Path state") _expect(context.source.create_snapshot() == source_after_external, "stale rejection does not undo an external source mutation") _expect(context.projector.is_projection_stale(), "projector exposes stale dependency status") var collision_source := SpatialType.new() var collision_path := PathType.new() var collision_adapter := AdapterType.new() collision_adapter.configure(collision_source, collision_path, []) collision_adapter.place_route(&"preexisting_managed", &"infra.route:foreign", [Vector3i(4, 14, 0)]) var collision_projector := ProjectorType.new() _expect(not collision_projector.configure(collision_adapter, collision_source, collision_path), "configuration rejects an untracked managed-ID namespace collision") func _test_validation_cache_detects_changes() -> void: var start := Vector3i(0, 0, PathType.FRONT) var middle := Vector3i(1, 0, PathType.FRONT) var goal := Vector3i(2, 0, PathType.FRONT) var context := _context([start, goal]) var instance := _instance(GUEST_CORRIDOR, &"facility_cache", middle, 10, &"construction_cache") _expect(context.projector.project_facility(&"project_cache", GUEST_CORRIDOR, instance).is_success(), "cache fixture projects corridor") _expect(context.projector.validate_invariants()[&"ok"], "initial complete validation succeeds") _expect(context.projector.validate_invariants()[&"ok"], "unchanged validation succeeds") var before: Dictionary = context.projector.create_snapshot() var exported: Dictionary = context.projector.create_snapshot() exported[&"projections"][0][&"cells"].clear() _expect(context.projector.validate_invariants()[&"ok"] and context.projector.create_snapshot() == before, "exported containers cannot alter validation cache or live state") var records: Dictionary = context.projector.get("_projections") var fingerprint: String = records[&"facility_cache"][&"record_fingerprint"] records[&"facility_cache"][&"record_fingerprint"] = "invalid" _expect(not context.projector.validate_invariants()[&"ok"], "warm cache detects changed projection content at unchanged revision") records[&"facility_cache"][&"record_fingerprint"] = fingerprint _expect(context.projector.validate_invariants()[&"ok"], "repaired owned state validates") var requests: Dictionary = context.projector.get("_processed_requests") var request_fingerprint: String = requests[&"project_cache"][&"fingerprint"] requests[&"project_cache"][&"fingerprint"] = "invalid" _expect(not context.projector.validate_invariants()[&"ok"], "warm cache detects changed request history") requests[&"project_cache"][&"fingerprint"] = request_fingerprint var path_snapshot: Dictionary = context.path.create_snapshot() _expect(context.path.rebuild_graph([start, goal]), "inject live path change without projector mutation") _expect(not context.projector.validate_invariants()[&"ok"], "unchanged owned snapshot still validates live dependencies") _expect(context.path.rebuild_graph([start, middle, goal]) and context.path.restore_snapshot(path_snapshot), "restore valid live graph and traffic snapshot") _expect(context.projector.validate_invariants()[&"ok"], "repaired dependencies validate against warm cache") _expect(context.projector.unproject_facility(&"unproject_cache", &"facility_cache").is_success(), "new history after cache warm can unproject") _expect(context.projector.validate_invariants()[&"ok"], "new history receives full validation") func _context(base_cells: Array, custom_path: Variant = null) -> Dictionary: var source := SpatialType.new() var path: PathService = custom_path if custom_path != null else PathType.new() var adapter := AdapterType.new() _expect(adapter.configure(source, path, base_cells), "test context configures Route adapter") var projector := ProjectorType.new() _expect(projector.configure(adapter, source, path), "test context configures Facility projector") return { &"source": source, &"path": path, &"adapter": adapter, &"projector": projector, } func _instance( definition: FacilityDefinition, instance_id: StringName, origin: Vector3i, completed_at: int, source_job_id: StringName, rotation: int = 0 ) -> Dictionary: var dimensions := definition.footprint if rotation in [90, 270]: dimensions = Vector2i(definition.footprint.y, definition.footprint.x) var cells: Array[Vector3i] = [] for y_offset: int in range(dimensions.y): for x_offset: int in range(dimensions.x): cells.append(origin + Vector3i(x_offset, y_offset, 0)) return { &"instance_id": instance_id, &"definition_id": definition.id, &"origin": origin, &"rotation": rotation, &"layer": definition.layer, &"occupied_cells": cells, &"construction_cost": definition.construction_cost.duplicate(true), &"source_job_id": source_job_id, &"state": &"ACTIVE", &"completed_at": completed_at, } func _all_snapshots(context: Dictionary) -> Dictionary: return { &"projector": context.projector.create_snapshot(), &"source": context.source.create_snapshot(), &"adapter": context.adapter.create_snapshot(), &"path": context.path.create_snapshot(), &"path_cells": _path_cells(context.path), } func _path_cells(path: PathService) -> Array[Vector3i]: var result: Array[Vector3i] = [] for row: Variant in path.create_snapshot().get(&"cell_traffic", []): if row is Dictionary and row.get(&"cell", null) is Vector3i: result.append(row[&"cell"]) result.sort_custom(func(left: Vector3i, right: Vector3i) -> bool: if left.y != right.y: return left.y < right.y if left.x != right.x: return left.x < right.x return left.z < right.z ) return result func _restore_path_for_test(path: PathService, cells: Array, snapshot: Dictionary) -> void: path.rebuild_graph(cells) path.restore_snapshot(snapshot) path.rebuild_graph(cells) func _assert_exact_rollback( context: Dictionary, before: Dictionary, result: CommandResult, label: String ) -> void: _expect(not result.is_success() and bool(result.details.get(&"rollback_ok", false)), "%s reports exact rollback" % label) _expect(context.projector.create_snapshot() == before.projector, "%s restores exact projector snapshot" % label) _expect(context.source.create_snapshot() == before.source, "%s restores exact Spatial snapshot" % label) _expect(context.adapter.create_snapshot() == before.adapter, "%s restores exact Route adapter snapshot" % label) _expect(context.path.create_snapshot() == before.path, "%s restores exact Path snapshot" % label) func _atomic_snapshot_reject( context: Dictionary, candidate: Dictionary, before: Dictionary, label: String ) -> void: _expect(not context.projector.restore_snapshot(candidate), "%s is rejected" % label) _expect(context.projector.create_snapshot() == before.projector, "%s rejection is projector-atomic" % label) _expect(context.source.create_snapshot() == before.source and context.adapter.create_snapshot() == before.adapter and context.path.create_snapshot() == before.path, "%s rejection leaves every dependency untouched" % label) func _expect(condition: bool, label: String) -> void: _checks += 1 if condition: print(" ✓ %s" % label) return _failures += 1 push_error(" ✗ %s" % label)