diff --git a/Cargo.lock b/Cargo.lock
index 9364f155f..39676f5a5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5065,6 +5065,7 @@ dependencies = [
 [[package]]
 name = "reaper-common-types"
 version = "0.1.0"
+source = "git+https://github.com/helgoboss/reaper-rs.git?branch=master#23268d5a322f2725e121fa73d2c1529b7c7f9655"
 dependencies = [
  "hex-literal",
  "nutype",
@@ -5075,6 +5076,7 @@ dependencies = [
 [[package]]
 name = "reaper-fluent"
 version = "0.1.0"
+source = "git+https://github.com/helgoboss/reaper-rs.git?branch=master#23268d5a322f2725e121fa73d2c1529b7c7f9655"
 dependencies = [
  "fragile",
  "reaper-low",
@@ -5085,6 +5087,7 @@ dependencies = [
 [[package]]
 name = "reaper-high"
 version = "0.1.0"
+source = "git+https://github.com/helgoboss/reaper-rs.git?branch=master#23268d5a322f2725e121fa73d2c1529b7c7f9655"
 dependencies = [
  "backtrace",
  "base64 0.13.0",
@@ -5113,6 +5116,7 @@ dependencies = [
 [[package]]
 name = "reaper-low"
 version = "0.1.0"
+source = "git+https://github.com/helgoboss/reaper-rs.git?branch=master#23268d5a322f2725e121fa73d2c1529b7c7f9655"
 dependencies = [
  "c_str_macro",
  "cc 1.0.83",
@@ -5126,6 +5130,7 @@ dependencies = [
 [[package]]
 name = "reaper-macros"
 version = "0.1.0"
+source = "git+https://github.com/helgoboss/reaper-rs.git?branch=master#23268d5a322f2725e121fa73d2c1529b7c7f9655"
 dependencies = [
  "darling 0.10.2",
  "quote",
@@ -5135,6 +5140,7 @@ dependencies = [
 [[package]]
 name = "reaper-medium"
 version = "0.1.0"
+source = "git+https://github.com/helgoboss/reaper-rs.git?branch=master#23268d5a322f2725e121fa73d2c1529b7c7f9655"
 dependencies = [
  "c_str_macro",
  "camino",
@@ -5155,6 +5161,7 @@ dependencies = [
 [[package]]
 name = "reaper-rx"
 version = "0.1.0"
+source = "git+https://github.com/helgoboss/reaper-rs.git?branch=master#23268d5a322f2725e121fa73d2c1529b7c7f9655"
 dependencies = [
  "crossbeam-channel",
  "helgoboss-midi",
@@ -5408,6 +5415,7 @@ checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"
 [[package]]
 name = "rppxml-parser"
 version = "0.1.0"
+source = "git+https://github.com/helgoboss/reaper-rs.git?branch=master#23268d5a322f2725e121fa73d2c1529b7c7f9655"
 dependencies = [
  "splitty",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 22d0db22b..057447378 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -161,15 +161,15 @@ vst = { git = "https://github.com/helgoboss/vst-rs.git", branch = "feature/param
 #vst = { path = "../vst-rs" }
 
 # This is for temporary development with local reaper-rs.
-[patch.'https://github.com/helgoboss/reaper-rs.git']
-reaper-common-types = { path = "../reaper-rs/main/common-types" }
-reaper-fluent = { path = "../reaper-rs/main/fluent" }
-reaper-high = { path = "../reaper-rs/main/high" }
-reaper-medium = { path = "../reaper-rs/main/medium" }
-reaper-macros = { path = "../reaper-rs/main/macros" }
-reaper-low = { path = "../reaper-rs/main/low" }
-reaper-rx = { path = "../reaper-rs/main/rx" }
-rppxml-parser = { path = "../reaper-rs/main/rppxml-parser" }
+#[patch.'https://github.com/helgoboss/reaper-rs.git']
+#reaper-common-types = { path = "../reaper-rs/main/common-types" }
+#reaper-fluent = { path = "../reaper-rs/main/fluent" }
+#reaper-high = { path = "../reaper-rs/main/high" }
+#reaper-medium = { path = "../reaper-rs/main/medium" }
+#reaper-macros = { path = "../reaper-rs/main/macros" }
+#reaper-low = { path = "../reaper-rs/main/low" }
+#reaper-rx = { path = "../reaper-rs/main/rx" }
+#rppxml-parser = { path = "../reaper-rs/main/rppxml-parser" }
 
 ## This is for temporary development with local egui-baseview.
 #[patch.'https://github.com/helgoboss/egui-baseview.git']
diff --git a/main/src/infrastructure/proto/generated.rs b/main/src/infrastructure/proto/generated.rs
index 73c2e6890..1cacfdb52 100644
--- a/main/src/infrastructure/proto/generated.rs
+++ b/main/src/infrastructure/proto/generated.rs
@@ -116,9 +116,7 @@ pub mod command_request {
         #[prost(message, tag = "37")]
         GetOccasionalGlobalUpdates(super::GetOccasionalGlobalUpdatesRequest),
         #[prost(message, tag = "53")]
-        GetOccasionalPlaytimeEngineUpdates(
-            super::GetOccasionalPlaytimeEngineUpdatesRequest,
-        ),
+        GetOccasionalPlaytimeEngineUpdates(super::GetOccasionalPlaytimeEngineUpdatesRequest),
         #[prost(message, tag = "40")]
         GetOccasionalInstanceUpdates(super::GetOccasionalInstanceUpdatesRequest),
         #[prost(message, tag = "25")]
@@ -282,9 +280,7 @@ pub mod event_reply {
         #[prost(message, tag = "1")]
         OccasionalGlobalUpdatesReply(super::GetOccasionalGlobalUpdatesReply),
         #[prost(message, tag = "15")]
-        OccasionalPlaytimeEngineUpdatesReply(
-            super::GetOccasionalPlaytimeEngineUpdatesReply,
-        ),
+        OccasionalPlaytimeEngineUpdatesReply(super::GetOccasionalPlaytimeEngineUpdatesReply),
         #[prost(message, tag = "13")]
         OccasionalInstanceUpdatesReply(super::GetOccasionalInstanceUpdatesReply),
         #[prost(message, tag = "14")]
@@ -1798,15 +1794,9 @@ impl TriggerInstanceAction {
             TriggerInstanceAction::ArrangementTogglePlayStop => {
                 "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_TOGGLE_PLAY_STOP"
             }
-            TriggerInstanceAction::ArrangementPlay => {
-                "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_PLAY"
-            }
-            TriggerInstanceAction::ArrangementStop => {
-                "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_STOP"
-            }
-            TriggerInstanceAction::ArrangementPause => {
-                "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_PAUSE"
-            }
+            TriggerInstanceAction::ArrangementPlay => "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_PLAY",
+            TriggerInstanceAction::ArrangementStop => "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_STOP",
+            TriggerInstanceAction::ArrangementPause => "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_PAUSE",
             TriggerInstanceAction::ArrangementStartRecording => {
                 "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_START_RECORDING"
             }
@@ -1821,9 +1811,7 @@ impl TriggerInstanceAction {
     /// Creates an enum from field names used in the ProtoBuf definition.
     pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
         match value {
-            "TRIGGER_INSTANCE_ACTION_SHOW_HELGOBOX_PLUGIN" => {
-                Some(Self::ShowHelgoboxPlugin)
-            }
+            "TRIGGER_INSTANCE_ACTION_SHOW_HELGOBOX_PLUGIN" => Some(Self::ShowHelgoboxPlugin),
             "TRIGGER_INSTANCE_ACTION_ARRANGEMENT_TOGGLE_PLAY_STOP" => {
                 Some(Self::ArrangementTogglePlayStop)
             }
@@ -2163,9 +2151,7 @@ impl TriggerTrackAction {
             TriggerTrackAction::ToggleArm => "TRIGGER_TRACK_ACTION_TOGGLE_ARM",
             TriggerTrackAction::ShowFx => "TRIGGER_TRACK_ACTION_SHOW_FX",
             TriggerTrackAction::ShowRouting => "TRIGGER_TRACK_ACTION_SHOW_ROUTING",
-            TriggerTrackAction::ToggleLearnInput => {
-                "TRIGGER_TRACK_ACTION_TOGGLE_LEARN_INPUT"
-            }
+            TriggerTrackAction::ToggleLearnInput => "TRIGGER_TRACK_ACTION_TOGGLE_LEARN_INPUT",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2218,9 +2204,7 @@ impl TriggerColumnAction {
                 "TRIGGER_COLUMN_ACTION_REMOVE_SIMPLE_MAPPING"
             }
             TriggerColumnAction::Activate => "TRIGGER_COLUMN_ACTION_ACTIVATE",
-            TriggerColumnAction::ExportToClipboard => {
-                "TRIGGER_COLUMN_ACTION_EXPORT_TO_CLIPBOARD"
-            }
+            TriggerColumnAction::ExportToClipboard => "TRIGGER_COLUMN_ACTION_EXPORT_TO_CLIPBOARD",
             TriggerColumnAction::ExportToArrangement => {
                 "TRIGGER_COLUMN_ACTION_EXPORT_TO_ARRANGEMENT"
             }
@@ -2240,14 +2224,10 @@ impl TriggerColumnAction {
             "TRIGGER_COLUMN_ACTION_TOGGLE_LEARN_SIMPLE_MAPPING" => {
                 Some(Self::ToggleLearnSimpleMapping)
             }
-            "TRIGGER_COLUMN_ACTION_REMOVE_SIMPLE_MAPPING" => {
-                Some(Self::RemoveSimpleMapping)
-            }
+            "TRIGGER_COLUMN_ACTION_REMOVE_SIMPLE_MAPPING" => Some(Self::RemoveSimpleMapping),
             "TRIGGER_COLUMN_ACTION_ACTIVATE" => Some(Self::Activate),
             "TRIGGER_COLUMN_ACTION_EXPORT_TO_CLIPBOARD" => Some(Self::ExportToClipboard),
-            "TRIGGER_COLUMN_ACTION_EXPORT_TO_ARRANGEMENT" => {
-                Some(Self::ExportToArrangement)
-            }
+            "TRIGGER_COLUMN_ACTION_EXPORT_TO_ARRANGEMENT" => Some(Self::ExportToArrangement),
             _ => None,
         }
     }
@@ -2287,16 +2267,12 @@ impl TriggerRowAction {
             TriggerRowAction::ToggleLearnSimpleMapping => {
                 "TRIGGER_ROW_ACTION_TOGGLE_LEARN_SIMPLE_MAPPING"
             }
-            TriggerRowAction::RemoveSimpleMapping => {
-                "TRIGGER_ROW_ACTION_REMOVE_SIMPLE_MAPPING"
-            }
+            TriggerRowAction::RemoveSimpleMapping => "TRIGGER_ROW_ACTION_REMOVE_SIMPLE_MAPPING",
             TriggerRowAction::BuildSceneFromPlayingSlots => {
                 "TRIGGER_ROW_ACTION_BUILD_SCENE_FROM_PLAYING_SLOTS"
             }
             TriggerRowAction::Activate => "TRIGGER_ROW_ACTION_ACTIVATE",
-            TriggerRowAction::ExportToArrangement => {
-                "TRIGGER_ROW_ACTION_EXPORT_TO_ARRANGEMENT"
-            }
+            TriggerRowAction::ExportToArrangement => "TRIGGER_ROW_ACTION_EXPORT_TO_ARRANGEMENT",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2410,28 +2386,18 @@ impl TriggerSlotAction {
             TriggerSlotAction::Copy => "TRIGGER_SLOT_ACTION_COPY",
             TriggerSlotAction::Cut => "TRIGGER_SLOT_ACTION_CUT",
             TriggerSlotAction::Paste => "TRIGGER_SLOT_ACTION_PASTE",
-            TriggerSlotAction::ImportSelectedItems => {
-                "TRIGGER_SLOT_ACTION_IMPORT_SELECTED_ITEMS"
-            }
+            TriggerSlotAction::ImportSelectedItems => "TRIGGER_SLOT_ACTION_IMPORT_SELECTED_ITEMS",
             TriggerSlotAction::Panic => "TRIGGER_SLOT_ACTION_PANIC",
-            TriggerSlotAction::CreateEmptyMidiClip => {
-                "TRIGGER_SLOT_ACTION_CREATE_EMPTY_MIDI_CLIP"
-            }
+            TriggerSlotAction::CreateEmptyMidiClip => "TRIGGER_SLOT_ACTION_CREATE_EMPTY_MIDI_CLIP",
             TriggerSlotAction::ToggleLearnSimpleMapping => {
                 "TRIGGER_SLOT_ACTION_TOGGLE_LEARN_SIMPLE_MAPPING"
             }
-            TriggerSlotAction::RemoveSimpleMapping => {
-                "TRIGGER_SLOT_ACTION_REMOVE_SIMPLE_MAPPING"
-            }
+            TriggerSlotAction::RemoveSimpleMapping => "TRIGGER_SLOT_ACTION_REMOVE_SIMPLE_MAPPING",
             TriggerSlotAction::TriggerOn => "TRIGGER_SLOT_ACTION_TRIGGER_ON",
             TriggerSlotAction::TriggerOff => "TRIGGER_SLOT_ACTION_TRIGGER_OFF",
             TriggerSlotAction::Activate => "TRIGGER_SLOT_ACTION_ACTIVATE",
-            TriggerSlotAction::ExportToClipboard => {
-                "TRIGGER_SLOT_ACTION_EXPORT_TO_CLIPBOARD"
-            }
-            TriggerSlotAction::ExportToArrangement => {
-                "TRIGGER_SLOT_ACTION_EXPORT_TO_ARRANGEMENT"
-            }
+            TriggerSlotAction::ExportToClipboard => "TRIGGER_SLOT_ACTION_EXPORT_TO_CLIPBOARD",
+            TriggerSlotAction::ExportToArrangement => "TRIGGER_SLOT_ACTION_EXPORT_TO_ARRANGEMENT",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2444,26 +2410,18 @@ impl TriggerSlotAction {
             "TRIGGER_SLOT_ACTION_COPY" => Some(Self::Copy),
             "TRIGGER_SLOT_ACTION_CUT" => Some(Self::Cut),
             "TRIGGER_SLOT_ACTION_PASTE" => Some(Self::Paste),
-            "TRIGGER_SLOT_ACTION_IMPORT_SELECTED_ITEMS" => {
-                Some(Self::ImportSelectedItems)
-            }
+            "TRIGGER_SLOT_ACTION_IMPORT_SELECTED_ITEMS" => Some(Self::ImportSelectedItems),
             "TRIGGER_SLOT_ACTION_PANIC" => Some(Self::Panic),
-            "TRIGGER_SLOT_ACTION_CREATE_EMPTY_MIDI_CLIP" => {
-                Some(Self::CreateEmptyMidiClip)
-            }
+            "TRIGGER_SLOT_ACTION_CREATE_EMPTY_MIDI_CLIP" => Some(Self::CreateEmptyMidiClip),
             "TRIGGER_SLOT_ACTION_TOGGLE_LEARN_SIMPLE_MAPPING" => {
                 Some(Self::ToggleLearnSimpleMapping)
             }
-            "TRIGGER_SLOT_ACTION_REMOVE_SIMPLE_MAPPING" => {
-                Some(Self::RemoveSimpleMapping)
-            }
+            "TRIGGER_SLOT_ACTION_REMOVE_SIMPLE_MAPPING" => Some(Self::RemoveSimpleMapping),
             "TRIGGER_SLOT_ACTION_TRIGGER_ON" => Some(Self::TriggerOn),
             "TRIGGER_SLOT_ACTION_TRIGGER_OFF" => Some(Self::TriggerOff),
             "TRIGGER_SLOT_ACTION_ACTIVATE" => Some(Self::Activate),
             "TRIGGER_SLOT_ACTION_EXPORT_TO_CLIPBOARD" => Some(Self::ExportToClipboard),
-            "TRIGGER_SLOT_ACTION_EXPORT_TO_ARRANGEMENT" => {
-                Some(Self::ExportToArrangement)
-            }
+            "TRIGGER_SLOT_ACTION_EXPORT_TO_ARRANGEMENT" => Some(Self::ExportToArrangement),
             _ => None,
         }
     }
@@ -2493,20 +2451,12 @@ impl TriggerClipAction {
             TriggerClipAction::Edit => "TRIGGER_CLIP_ACTION_EDIT",
             TriggerClipAction::Remove => "TRIGGER_CLIP_ACTION_REMOVE",
             TriggerClipAction::Promote => "TRIGGER_CLIP_ACTION_PROMOTE",
-            TriggerClipAction::OpenInMediaExplorer => {
-                "TRIGGER_CLIP_ACTION_OPEN_IN_MEDIA_EXPLORER"
-            }
+            TriggerClipAction::OpenInMediaExplorer => "TRIGGER_CLIP_ACTION_OPEN_IN_MEDIA_EXPLORER",
             TriggerClipAction::Quantize => "TRIGGER_CLIP_ACTION_QUANTIZE",
             TriggerClipAction::Unquantize => "TRIGGER_CLIP_ACTION_UNQUANTIZE",
-            TriggerClipAction::ExportToClipboard => {
-                "TRIGGER_CLIP_ACTION_EXPORT_TO_CLIPBOARD"
-            }
-            TriggerClipAction::ExportToArrangement => {
-                "TRIGGER_CLIP_ACTION_EXPORT_TO_ARRANGEMENT"
-            }
-            TriggerClipAction::ToggleMidiOverdub => {
-                "TRIGGER_CLIP_ACTION_TOGGLE_MIDI_OVERDUB"
-            }
+            TriggerClipAction::ExportToClipboard => "TRIGGER_CLIP_ACTION_EXPORT_TO_CLIPBOARD",
+            TriggerClipAction::ExportToArrangement => "TRIGGER_CLIP_ACTION_EXPORT_TO_ARRANGEMENT",
+            TriggerClipAction::ToggleMidiOverdub => "TRIGGER_CLIP_ACTION_TOGGLE_MIDI_OVERDUB",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2516,15 +2466,11 @@ impl TriggerClipAction {
             "TRIGGER_CLIP_ACTION_EDIT" => Some(Self::Edit),
             "TRIGGER_CLIP_ACTION_REMOVE" => Some(Self::Remove),
             "TRIGGER_CLIP_ACTION_PROMOTE" => Some(Self::Promote),
-            "TRIGGER_CLIP_ACTION_OPEN_IN_MEDIA_EXPLORER" => {
-                Some(Self::OpenInMediaExplorer)
-            }
+            "TRIGGER_CLIP_ACTION_OPEN_IN_MEDIA_EXPLORER" => Some(Self::OpenInMediaExplorer),
             "TRIGGER_CLIP_ACTION_QUANTIZE" => Some(Self::Quantize),
             "TRIGGER_CLIP_ACTION_UNQUANTIZE" => Some(Self::Unquantize),
             "TRIGGER_CLIP_ACTION_EXPORT_TO_CLIPBOARD" => Some(Self::ExportToClipboard),
-            "TRIGGER_CLIP_ACTION_EXPORT_TO_ARRANGEMENT" => {
-                Some(Self::ExportToArrangement)
-            }
+            "TRIGGER_CLIP_ACTION_EXPORT_TO_ARRANGEMENT" => Some(Self::ExportToArrangement),
             "TRIGGER_CLIP_ACTION_TOGGLE_MIDI_OVERDUB" => Some(Self::ToggleMidiOverdub),
             _ => None,
         }
@@ -2717,17 +2663,11 @@ impl SlotPlayState {
             SlotPlayState::Unknown => "SLOT_PLAY_STATE_UNKNOWN",
             SlotPlayState::Stopped => "SLOT_PLAY_STATE_STOPPED",
             SlotPlayState::Ignited => "SLOT_PLAY_STATE_IGNITED",
-            SlotPlayState::ScheduledForPlayStart => {
-                "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_START"
-            }
+            SlotPlayState::ScheduledForPlayStart => "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_START",
             SlotPlayState::Playing => "SLOT_PLAY_STATE_PLAYING",
             SlotPlayState::Paused => "SLOT_PLAY_STATE_PAUSED",
-            SlotPlayState::ScheduledForPlayRestart => {
-                "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_RESTART"
-            }
-            SlotPlayState::ScheduledForPlayStop => {
-                "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_STOP"
-            }
+            SlotPlayState::ScheduledForPlayRestart => "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_RESTART",
+            SlotPlayState::ScheduledForPlayStop => "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_STOP",
             SlotPlayState::ScheduledForRecordingStart => {
                 "SLOT_PLAY_STATE_SCHEDULED_FOR_RECORDING_START"
             }
@@ -2743,22 +2683,16 @@ impl SlotPlayState {
             "SLOT_PLAY_STATE_UNKNOWN" => Some(Self::Unknown),
             "SLOT_PLAY_STATE_STOPPED" => Some(Self::Stopped),
             "SLOT_PLAY_STATE_IGNITED" => Some(Self::Ignited),
-            "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_START" => {
-                Some(Self::ScheduledForPlayStart)
-            }
+            "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_START" => Some(Self::ScheduledForPlayStart),
             "SLOT_PLAY_STATE_PLAYING" => Some(Self::Playing),
             "SLOT_PLAY_STATE_PAUSED" => Some(Self::Paused),
-            "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_RESTART" => {
-                Some(Self::ScheduledForPlayRestart)
-            }
+            "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_RESTART" => Some(Self::ScheduledForPlayRestart),
             "SLOT_PLAY_STATE_SCHEDULED_FOR_PLAY_STOP" => Some(Self::ScheduledForPlayStop),
             "SLOT_PLAY_STATE_SCHEDULED_FOR_RECORDING_START" => {
                 Some(Self::ScheduledForRecordingStart)
             }
             "SLOT_PLAY_STATE_RECORDING" => Some(Self::Recording),
-            "SLOT_PLAY_STATE_SCHEDULED_FOR_RECORDING_STOP" => {
-                Some(Self::ScheduledForRecordingStop)
-            }
+            "SLOT_PLAY_STATE_SCHEDULED_FOR_RECORDING_STOP" => Some(Self::ScheduledForRecordingStop),
             _ => None,
         }
     }
@@ -2778,9 +2712,7 @@ impl MidiDeviceStatus {
     pub fn as_str_name(&self) -> &'static str {
         match self {
             MidiDeviceStatus::Disconnected => "MIDI_DEVICE_STATUS_DISCONNECTED",
-            MidiDeviceStatus::ConnectedButDisabled => {
-                "MIDI_DEVICE_STATUS_CONNECTED_BUT_DISABLED"
-            }
+            MidiDeviceStatus::ConnectedButDisabled => "MIDI_DEVICE_STATUS_CONNECTED_BUT_DISABLED",
             MidiDeviceStatus::Connected => "MIDI_DEVICE_STATUS_CONNECTED",
         }
     }
@@ -2788,9 +2720,7 @@ impl MidiDeviceStatus {
     pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
         match value {
             "MIDI_DEVICE_STATUS_DISCONNECTED" => Some(Self::Disconnected),
-            "MIDI_DEVICE_STATUS_CONNECTED_BUT_DISABLED" => {
-                Some(Self::ConnectedButDisabled)
-            }
+            "MIDI_DEVICE_STATUS_CONNECTED_BUT_DISABLED" => Some(Self::ConnectedButDisabled),
             "MIDI_DEVICE_STATUS_CONNECTED" => Some(Self::Connected),
             _ => None,
         }
@@ -2816,13 +2746,9 @@ impl ArrangementPlayState {
             ArrangementPlayState::Unknown => "ARRANGEMENT_PLAY_STATE_UNKNOWN",
             ArrangementPlayState::Stopped => "ARRANGEMENT_PLAY_STATE_STOPPED",
             ArrangementPlayState::Playing => "ARRANGEMENT_PLAY_STATE_PLAYING",
-            ArrangementPlayState::PlayingPaused => {
-                "ARRANGEMENT_PLAY_STATE_PLAYING_PAUSED"
-            }
+            ArrangementPlayState::PlayingPaused => "ARRANGEMENT_PLAY_STATE_PLAYING_PAUSED",
             ArrangementPlayState::Recording => "ARRANGEMENT_PLAY_STATE_RECORDING",
-            ArrangementPlayState::RecordingPaused => {
-                "ARRANGEMENT_PLAY_STATE_RECORDING_PAUSED"
-            }
+            ArrangementPlayState::RecordingPaused => "ARRANGEMENT_PLAY_STATE_RECORDING_PAUSED",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2881,63 +2807,39 @@ pub mod helgobox_service_server {
         async fn get_host_info(
             &self,
             request: tonic::Request<super::GetHostInfoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetHostInfoReply>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetHostInfoReply>, tonic::Status>;
         async fn prove_authenticity(
             &self,
             request: tonic::Request<super::ProveAuthenticityRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::ProveAuthenticityReply>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::ProveAuthenticityReply>, tonic::Status>;
         async fn get_app_settings(
             &self,
             request: tonic::Request<super::GetAppSettingsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetAppSettingsReply>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetAppSettingsReply>, tonic::Status>;
         /// General instance queries
         async fn get_custom_instance_data(
             &self,
             request: tonic::Request<super::GetCustomInstanceDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetCustomInstanceDataReply>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetCustomInstanceDataReply>, tonic::Status>;
         /// Playtime matrix queries
         async fn get_project_dir(
             &self,
             request: tonic::Request<super::GetProjectDirRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetProjectDirReply>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetProjectDirReply>, tonic::Status>;
         async fn get_arrangement_info(
             &self,
             request: tonic::Request<super::GetArrangementInfoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetArrangementInfoReply>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetArrangementInfoReply>, tonic::Status>;
         /// Playtime clip queries
         async fn get_clip_detail(
             &self,
             request: tonic::Request<super::GetClipDetailRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetClipDetailReply>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetClipDetailReply>, tonic::Status>;
         /// ReaLearn compartment queries
         async fn get_compartment_data(
             &self,
             request: tonic::Request<super::GetCompartmentDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetCompartmentDataReply>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<super::GetCompartmentDataReply>, tonic::Status>;
         /// General global commands
         async fn trigger_global(
             &self,
@@ -3119,12 +3021,8 @@ pub mod helgobox_service_server {
         ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
         /// Server streaming response type for the GetOccasionalGlobalUpdates method.
         type GetOccasionalGlobalUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalGlobalUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalGlobalUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         /// General global events
         async fn get_occasional_global_updates(
@@ -3140,8 +3038,7 @@ pub mod helgobox_service_server {
                     super::GetOccasionalPlaytimeEngineUpdatesReply,
                     tonic::Status,
                 >,
-            >
-            + Send
+            > + Send
             + 'static;
         /// Playtime global events
         async fn get_occasional_playtime_engine_updates(
@@ -3153,12 +3050,8 @@ pub mod helgobox_service_server {
         >;
         /// Server streaming response type for the GetOccasionalInstanceUpdates method.
         type GetOccasionalInstanceUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalInstanceUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalInstanceUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         /// General instance events
         async fn get_occasional_instance_updates(
@@ -3170,28 +3063,17 @@ pub mod helgobox_service_server {
         >;
         /// Server streaming response type for the GetOccasionalUnitUpdates method.
         type GetOccasionalUnitUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalUnitUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalUnitUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         async fn get_occasional_unit_updates(
             &self,
             request: tonic::Request<super::GetOccasionalUnitUpdatesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::GetOccasionalUnitUpdatesStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::GetOccasionalUnitUpdatesStream>, tonic::Status>;
         /// Server streaming response type for the GetOccasionalMatrixUpdates method.
         type GetOccasionalMatrixUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalMatrixUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalMatrixUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         /// Playtime matrix events
         async fn get_occasional_matrix_updates(
@@ -3203,12 +3085,8 @@ pub mod helgobox_service_server {
         >;
         /// Server streaming response type for the GetContinuousMatrixUpdates method.
         type GetContinuousMatrixUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetContinuousMatrixUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetContinuousMatrixUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         async fn get_continuous_matrix_updates(
             &self,
@@ -3219,12 +3097,8 @@ pub mod helgobox_service_server {
         >;
         /// Server streaming response type for the GetOccasionalColumnUpdates method.
         type GetOccasionalColumnUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalColumnUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalColumnUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         /// Playtime column events
         async fn get_occasional_column_updates(
@@ -3236,12 +3110,8 @@ pub mod helgobox_service_server {
         >;
         /// Server streaming response type for the GetContinuousColumnUpdates method.
         type GetContinuousColumnUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetContinuousColumnUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetContinuousColumnUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         async fn get_continuous_column_updates(
             &self,
@@ -3252,12 +3122,8 @@ pub mod helgobox_service_server {
         >;
         /// Server streaming response type for the GetOccasionalTrackUpdates method.
         type GetOccasionalTrackUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalTrackUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalTrackUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         /// Playtime track events
         async fn get_occasional_track_updates(
@@ -3269,71 +3135,43 @@ pub mod helgobox_service_server {
         >;
         /// Server streaming response type for the GetOccasionalRowUpdates method.
         type GetOccasionalRowUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalRowUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalRowUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         /// Playtime row events
         async fn get_occasional_row_updates(
             &self,
             request: tonic::Request<super::GetOccasionalRowUpdatesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::GetOccasionalRowUpdatesStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::GetOccasionalRowUpdatesStream>, tonic::Status>;
         /// Server streaming response type for the GetOccasionalSlotUpdates method.
         type GetOccasionalSlotUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalSlotUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalSlotUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         /// Playtime slot events
         async fn get_occasional_slot_updates(
             &self,
             request: tonic::Request<super::GetOccasionalSlotUpdatesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::GetOccasionalSlotUpdatesStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::GetOccasionalSlotUpdatesStream>, tonic::Status>;
         /// Server streaming response type for the GetContinuousSlotUpdates method.
         type GetContinuousSlotUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetContinuousSlotUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetContinuousSlotUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         async fn get_continuous_slot_updates(
             &self,
             request: tonic::Request<super::GetContinuousSlotUpdatesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::GetContinuousSlotUpdatesStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::GetContinuousSlotUpdatesStream>, tonic::Status>;
         /// Server streaming response type for the GetOccasionalClipUpdates method.
         type GetOccasionalClipUpdatesStream: tonic::codegen::tokio_stream::Stream<
-                Item = std::result::Result<
-                    super::GetOccasionalClipUpdatesReply,
-                    tonic::Status,
-                >,
-            >
-            + Send
+                Item = std::result::Result<super::GetOccasionalClipUpdatesReply, tonic::Status>,
+            > + Send
             + 'static;
         /// Playtime clip events
         async fn get_occasional_clip_updates(
             &self,
             request: tonic::Request<super::GetOccasionalClipUpdatesRequest>,
-        ) -> std::result::Result<
-            tonic::Response<Self::GetOccasionalClipUpdatesStream>,
-            tonic::Status,
-        >;
+        ) -> std::result::Result<tonic::Response<Self::GetOccasionalClipUpdatesStream>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct HelgoboxServiceServer<T: HelgoboxService> {
@@ -3358,10 +3196,7 @@ pub mod helgobox_service_server {
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
@@ -3417,15 +3252,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetHostInfo" => {
                     #[allow(non_camel_case_types)]
                     struct GetHostInfoSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::GetHostInfoRequest>
-                    for GetHostInfoSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::GetHostInfoRequest>
+                        for GetHostInfoSvc<T>
+                    {
                         type Response = super::GetHostInfoReply;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetHostInfoRequest>,
@@ -3463,23 +3294,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/ProveAuthenticity" => {
                     #[allow(non_camel_case_types)]
                     struct ProveAuthenticitySvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::ProveAuthenticityRequest>
-                    for ProveAuthenticitySvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::ProveAuthenticityRequest>
+                        for ProveAuthenticitySvc<T>
+                    {
                         type Response = super::ProveAuthenticityReply;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ProveAuthenticityRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::prove_authenticity(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::prove_authenticity(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3510,23 +3337,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetAppSettings" => {
                     #[allow(non_camel_case_types)]
                     struct GetAppSettingsSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::GetAppSettingsRequest>
-                    for GetAppSettingsSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::GetAppSettingsRequest>
+                        for GetAppSettingsSvc<T>
+                    {
                         type Response = super::GetAppSettingsReply;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetAppSettingsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_app_settings(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::get_app_settings(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3557,25 +3380,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetCustomInstanceData" => {
                     #[allow(non_camel_case_types)]
                     struct GetCustomInstanceDataSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::GetCustomInstanceDataRequest>
-                    for GetCustomInstanceDataSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::GetCustomInstanceDataRequest>
+                        for GetCustomInstanceDataSvc<T>
+                    {
                         type Response = super::GetCustomInstanceDataReply;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetCustomInstanceDataRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_custom_instance_data(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::get_custom_instance_data(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -3607,23 +3424,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetProjectDir" => {
                     #[allow(non_camel_case_types)]
                     struct GetProjectDirSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::GetProjectDirRequest>
-                    for GetProjectDirSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::GetProjectDirRequest>
+                        for GetProjectDirSvc<T>
+                    {
                         type Response = super::GetProjectDirReply;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetProjectDirRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_project_dir(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::get_project_dir(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3654,26 +3467,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetArrangementInfo" => {
                     #[allow(non_camel_case_types)]
                     struct GetArrangementInfoSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::GetArrangementInfoRequest>
-                    for GetArrangementInfoSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::GetArrangementInfoRequest>
+                        for GetArrangementInfoSvc<T>
+                    {
                         type Response = super::GetArrangementInfoReply;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetArrangementInfoRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_arrangement_info(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                <T as HelgoboxService>::get_arrangement_info(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3704,23 +3510,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetClipDetail" => {
                     #[allow(non_camel_case_types)]
                     struct GetClipDetailSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::GetClipDetailRequest>
-                    for GetClipDetailSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::GetClipDetailRequest>
+                        for GetClipDetailSvc<T>
+                    {
                         type Response = super::GetClipDetailReply;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetClipDetailRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_clip_detail(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::get_clip_detail(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3751,26 +3553,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetCompartmentData" => {
                     #[allow(non_camel_case_types)]
                     struct GetCompartmentDataSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::GetCompartmentDataRequest>
-                    for GetCompartmentDataSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::GetCompartmentDataRequest>
+                        for GetCompartmentDataSvc<T>
+                    {
                         type Response = super::GetCompartmentDataReply;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetCompartmentDataRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_compartment_data(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                <T as HelgoboxService>::get_compartment_data(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3801,23 +3596,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerGlobal" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerGlobalSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerGlobalRequest>
-                    for TriggerGlobalSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::TriggerGlobalRequest>
+                        for TriggerGlobalSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerGlobalRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::trigger_global(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::trigger_global(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3848,23 +3639,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetAppSettings" => {
                     #[allow(non_camel_case_types)]
                     struct SetAppSettingsSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetAppSettingsRequest>
-                    for SetAppSettingsSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetAppSettingsRequest>
+                        for SetAppSettingsSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetAppSettingsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_app_settings(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_app_settings(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3895,15 +3682,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/AddLicense" => {
                     #[allow(non_camel_case_types)]
                     struct AddLicenseSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::AddLicenseRequest>
-                    for AddLicenseSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::AddLicenseRequest>
+                        for AddLicenseSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::AddLicenseRequest>,
@@ -3941,23 +3724,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SaveController" => {
                     #[allow(non_camel_case_types)]
                     struct SaveControllerSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SaveControllerRequest>
-                    for SaveControllerSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SaveControllerRequest>
+                        for SaveControllerSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SaveControllerRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::save_controller(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::save_controller(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -3988,23 +3767,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/DeleteController" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteControllerSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::DeleteControllerRequest>
-                    for DeleteControllerSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::DeleteControllerRequest>
+                        for DeleteControllerSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::DeleteControllerRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::delete_controller(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::delete_controller(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4035,29 +3810,22 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetPlaytimeEngineSettings" => {
                     #[allow(non_camel_case_types)]
                     struct SetPlaytimeEngineSettingsSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<
-                        super::SetPlaytimeEngineSettingsRequest,
-                    > for SetPlaytimeEngineSettingsSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetPlaytimeEngineSettingsRequest>
+                        for SetPlaytimeEngineSettingsSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::SetPlaytimeEngineSettingsRequest,
-                            >,
+                            request: tonic::Request<super::SetPlaytimeEngineSettingsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::set_playtime_engine_settings(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -4088,23 +3856,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerInstance" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerInstanceSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerInstanceRequest>
-                    for TriggerInstanceSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::TriggerInstanceRequest>
+                        for TriggerInstanceSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerInstanceRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::trigger_instance(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::trigger_instance(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4135,26 +3899,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetInstanceSettings" => {
                     #[allow(non_camel_case_types)]
                     struct SetInstanceSettingsSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetInstanceSettingsRequest>
-                    for SetInstanceSettingsSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetInstanceSettingsRequest>
+                        for SetInstanceSettingsSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetInstanceSettingsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_instance_settings(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                <T as HelgoboxService>::set_instance_settings(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4185,25 +3942,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetCustomInstanceData" => {
                     #[allow(non_camel_case_types)]
                     struct SetCustomInstanceDataSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetCustomInstanceDataRequest>
-                    for SetCustomInstanceDataSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetCustomInstanceDataRequest>
+                        for SetCustomInstanceDataSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetCustomInstanceDataRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_custom_instance_data(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::set_custom_instance_data(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -4235,23 +3986,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerMatrix" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerMatrixSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerMatrixRequest>
-                    for TriggerMatrixSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::TriggerMatrixRequest>
+                        for TriggerMatrixSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerMatrixRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::trigger_matrix(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::trigger_matrix(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4282,23 +4029,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetMatrixSettings" => {
                     #[allow(non_camel_case_types)]
                     struct SetMatrixSettingsSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetMatrixSettingsRequest>
-                    for SetMatrixSettingsSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetMatrixSettingsRequest>
+                        for SetMatrixSettingsSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetMatrixSettingsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_matrix_settings(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_matrix_settings(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4329,23 +4072,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetMatrixTempo" => {
                     #[allow(non_camel_case_types)]
                     struct SetMatrixTempoSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetMatrixTempoRequest>
-                    for SetMatrixTempoSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetMatrixTempoRequest>
+                        for SetMatrixTempoSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetMatrixTempoRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_matrix_tempo(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_matrix_tempo(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4376,25 +4115,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetMatrixTimeSignature" => {
                     #[allow(non_camel_case_types)]
                     struct SetMatrixTimeSignatureSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetMatrixTimeSignatureRequest>
-                    for SetMatrixTimeSignatureSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetMatrixTimeSignatureRequest>
+                        for SetMatrixTimeSignatureSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetMatrixTimeSignatureRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_matrix_time_signature(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::set_matrix_time_signature(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -4426,26 +4159,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetMatrixPlayRate" => {
                     #[allow(non_camel_case_types)]
                     struct SetMatrixPlayRateSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetMatrixPlayRateRequest>
-                    for SetMatrixPlayRateSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetMatrixPlayRateRequest>
+                        for SetMatrixPlayRateSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetMatrixPlayRateRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_matrix_play_rate(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                <T as HelgoboxService>::set_matrix_play_rate(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4476,23 +4202,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetMatrixVolume" => {
                     #[allow(non_camel_case_types)]
                     struct SetMatrixVolumeSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetMatrixVolumeRequest>
-                    for SetMatrixVolumeSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetMatrixVolumeRequest>
+                        for SetMatrixVolumeSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetMatrixVolumeRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_matrix_volume(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_matrix_volume(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4523,23 +4245,18 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetMatrixPan" => {
                     #[allow(non_camel_case_types)]
                     struct SetMatrixPanSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetMatrixPanRequest>
-                    for SetMatrixPanSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::SetMatrixPanRequest>
+                        for SetMatrixPanSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetMatrixPanRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_matrix_pan(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_matrix_pan(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4570,23 +4287,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerColumn" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerColumnSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerColumnRequest>
-                    for TriggerColumnSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::TriggerColumnRequest>
+                        for TriggerColumnSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerColumnRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::trigger_column(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::trigger_column(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4617,23 +4330,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/InsertColumns" => {
                     #[allow(non_camel_case_types)]
                     struct InsertColumnsSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::InsertColumnsRequest>
-                    for InsertColumnsSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::InsertColumnsRequest>
+                        for InsertColumnsSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::InsertColumnsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::insert_columns(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::insert_columns(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4664,23 +4373,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetColumnSettings" => {
                     #[allow(non_camel_case_types)]
                     struct SetColumnSettingsSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetColumnSettingsRequest>
-                    for SetColumnSettingsSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetColumnSettingsRequest>
+                        for SetColumnSettingsSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetColumnSettingsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_column_settings(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_column_settings(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4711,23 +4416,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetColumnTrack" => {
                     #[allow(non_camel_case_types)]
                     struct SetColumnTrackSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetColumnTrackRequest>
-                    for SetColumnTrackSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetColumnTrackRequest>
+                        for SetColumnTrackSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetColumnTrackRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_column_track(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_column_track(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4758,15 +4459,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/DragColumn" => {
                     #[allow(non_camel_case_types)]
                     struct DragColumnSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::DragColumnRequest>
-                    for DragColumnSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::DragColumnRequest>
+                        for DragColumnSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::DragColumnRequest>,
@@ -4804,15 +4501,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerTrack" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerTrackSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerTrackRequest>
-                    for TriggerTrackSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::TriggerTrackRequest>
+                        for TriggerTrackSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerTrackRequest>,
@@ -4850,23 +4543,18 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetTrackName" => {
                     #[allow(non_camel_case_types)]
                     struct SetTrackNameSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetTrackNameRequest>
-                    for SetTrackNameSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::SetTrackNameRequest>
+                        for SetTrackNameSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetTrackNameRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_track_name(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_track_name(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4897,23 +4585,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetTrackColor" => {
                     #[allow(non_camel_case_types)]
                     struct SetTrackColorSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetTrackColorRequest>
-                    for SetTrackColorSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetTrackColorRequest>
+                        for SetTrackColorSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetTrackColorRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_track_color(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_track_color(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4944,23 +4628,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetTrackInput" => {
                     #[allow(non_camel_case_types)]
                     struct SetTrackInputSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetTrackInputRequest>
-                    for SetTrackInputSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetTrackInputRequest>
+                        for SetTrackInputSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetTrackInputRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_track_input(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_track_input(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -4991,27 +4671,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetTrackInputMonitoring" => {
                     #[allow(non_camel_case_types)]
                     struct SetTrackInputMonitoringSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetTrackInputMonitoringRequest>
-                    for SetTrackInputMonitoringSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetTrackInputMonitoringRequest>
+                        for SetTrackInputMonitoringSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::SetTrackInputMonitoringRequest,
-                            >,
+                            request: tonic::Request<super::SetTrackInputMonitoringRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_track_input_monitoring(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::set_track_input_monitoring(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -5043,23 +4715,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetTrackVolume" => {
                     #[allow(non_camel_case_types)]
                     struct SetTrackVolumeSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetTrackVolumeRequest>
-                    for SetTrackVolumeSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetTrackVolumeRequest>
+                        for SetTrackVolumeSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetTrackVolumeRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_track_volume(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_track_volume(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -5090,15 +4758,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetTrackPan" => {
                     #[allow(non_camel_case_types)]
                     struct SetTrackPanSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetTrackPanRequest>
-                    for SetTrackPanSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::SetTrackPanRequest>
+                        for SetTrackPanSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetTrackPanRequest>,
@@ -5136,15 +4800,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/OpenTrackFx" => {
                     #[allow(non_camel_case_types)]
                     struct OpenTrackFxSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::OpenTrackFxRequest>
-                    for OpenTrackFxSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::OpenTrackFxRequest>
+                        for OpenTrackFxSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::OpenTrackFxRequest>,
@@ -5182,15 +4842,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerRow" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerRowSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerRowRequest>
-                    for TriggerRowSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::TriggerRowRequest>
+                        for TriggerRowSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerRowRequest>,
@@ -5228,15 +4884,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetRowData" => {
                     #[allow(non_camel_case_types)]
                     struct SetRowDataSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetRowDataRequest>
-                    for SetRowDataSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::SetRowDataRequest>
+                        for SetRowDataSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetRowDataRequest>,
@@ -5274,15 +4926,9 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/DragRow" => {
                     #[allow(non_camel_case_types)]
                     struct DragRowSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::DragRowRequest>
-                    for DragRowSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::DragRowRequest> for DragRowSvc<T> {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::DragRowRequest>,
@@ -5320,15 +4966,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerSlot" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerSlotSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerSlotRequest>
-                    for TriggerSlotSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::TriggerSlotRequest>
+                        for TriggerSlotSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerSlotRequest>,
@@ -5366,15 +5008,9 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/DragSlot" => {
                     #[allow(non_camel_case_types)]
                     struct DragSlotSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::DragSlotRequest>
-                    for DragSlotSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::DragSlotRequest> for DragSlotSvc<T> {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::DragSlotRequest>,
@@ -5412,15 +5048,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/ImportFiles" => {
                     #[allow(non_camel_case_types)]
                     struct ImportFilesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::ImportFilesRequest>
-                    for ImportFilesSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::ImportFilesRequest>
+                        for ImportFilesSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ImportFilesRequest>,
@@ -5458,15 +5090,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerClip" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerClipSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerClipRequest>
-                    for TriggerClipSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::TriggerClipRequest>
+                        for TriggerClipSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerClipRequest>,
@@ -5504,15 +5132,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetClipName" => {
                     #[allow(non_camel_case_types)]
                     struct SetClipNameSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetClipNameRequest>
-                    for SetClipNameSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::SetClipNameRequest>
+                        for SetClipNameSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetClipNameRequest>,
@@ -5550,15 +5174,11 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetClipData" => {
                     #[allow(non_camel_case_types)]
                     struct SetClipDataSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetClipDataRequest>
-                    for SetClipDataSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::SetClipDataRequest>
+                        for SetClipDataSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetClipDataRequest>,
@@ -5596,15 +5216,9 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/DragClip" => {
                     #[allow(non_camel_case_types)]
                     struct DragClipSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::DragClipRequest>
-                    for DragClipSvc<T> {
+                    impl<T: HelgoboxService> tonic::server::UnaryService<super::DragClipRequest> for DragClipSvc<T> {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::DragClipRequest>,
@@ -5642,23 +5256,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/TriggerSequence" => {
                     #[allow(non_camel_case_types)]
                     struct TriggerSequenceSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::TriggerSequenceRequest>
-                    for TriggerSequenceSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::TriggerSequenceRequest>
+                        for TriggerSequenceSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::TriggerSequenceRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::trigger_sequence(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::trigger_sequence(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -5689,23 +5299,19 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SetSequenceInfo" => {
                     #[allow(non_camel_case_types)]
                     struct SetSequenceInfoSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<super::SetSequenceInfoRequest>
-                    for SetSequenceInfoSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SetSequenceInfoRequest>
+                        for SetSequenceInfoSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SetSequenceInfoRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::set_sequence_info(&inner, request)
-                                    .await
+                                <T as HelgoboxService>::set_sequence_info(&inner, request).await
                             };
                             Box::pin(fut)
                         }
@@ -5736,29 +5342,22 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/SaveCustomCompartmentData" => {
                     #[allow(non_camel_case_types)]
                     struct SaveCustomCompartmentDataSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::UnaryService<
-                        super::SaveCustomCompartmentDataRequest,
-                    > for SaveCustomCompartmentDataSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::UnaryService<super::SaveCustomCompartmentDataRequest>
+                        for SaveCustomCompartmentDataSvc<T>
+                    {
                         type Response = super::Empty;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::SaveCustomCompartmentDataRequest,
-                            >,
+                            request: tonic::Request<super::SaveCustomCompartmentDataRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::save_custom_compartment_data(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -5789,30 +5388,25 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetOccasionalGlobalUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetOccasionalGlobalUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalGlobalUpdatesRequest,
-                    > for GetOccasionalGlobalUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalGlobalUpdatesRequest,
+                        > for GetOccasionalGlobalUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalGlobalUpdatesReply;
                         type ResponseStream = T::GetOccasionalGlobalUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalGlobalUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalGlobalUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::get_occasional_global_updates(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -5842,20 +5436,16 @@ pub mod helgobox_service_server {
                 }
                 "/generated.HelgoboxService/GetOccasionalPlaytimeEngineUpdates" => {
                     #[allow(non_camel_case_types)]
-                    struct GetOccasionalPlaytimeEngineUpdatesSvc<T: HelgoboxService>(
-                        pub Arc<T>,
-                    );
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalPlaytimeEngineUpdatesRequest,
-                    > for GetOccasionalPlaytimeEngineUpdatesSvc<T> {
+                    struct GetOccasionalPlaytimeEngineUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalPlaytimeEngineUpdatesRequest,
+                        > for GetOccasionalPlaytimeEngineUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalPlaytimeEngineUpdatesReply;
                         type ResponseStream = T::GetOccasionalPlaytimeEngineUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
                             request: tonic::Request<
@@ -5865,10 +5455,9 @@ pub mod helgobox_service_server {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::get_occasional_playtime_engine_updates(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -5898,33 +5487,26 @@ pub mod helgobox_service_server {
                 }
                 "/generated.HelgoboxService/GetOccasionalInstanceUpdates" => {
                     #[allow(non_camel_case_types)]
-                    struct GetOccasionalInstanceUpdatesSvc<T: HelgoboxService>(
-                        pub Arc<T>,
-                    );
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalInstanceUpdatesRequest,
-                    > for GetOccasionalInstanceUpdatesSvc<T> {
+                    struct GetOccasionalInstanceUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalInstanceUpdatesRequest,
+                        > for GetOccasionalInstanceUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalInstanceUpdatesReply;
                         type ResponseStream = T::GetOccasionalInstanceUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalInstanceUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalInstanceUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::get_occasional_instance_updates(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -5955,29 +5537,22 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetOccasionalUnitUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetOccasionalUnitUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalUnitUpdatesRequest,
-                    > for GetOccasionalUnitUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalUnitUpdatesRequest,
+                        > for GetOccasionalUnitUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalUnitUpdatesReply;
                         type ResponseStream = T::GetOccasionalUnitUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalUnitUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalUnitUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_occasional_unit_updates(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::get_occasional_unit_updates(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -6009,30 +5584,25 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetOccasionalMatrixUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetOccasionalMatrixUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalMatrixUpdatesRequest,
-                    > for GetOccasionalMatrixUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalMatrixUpdatesRequest,
+                        > for GetOccasionalMatrixUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalMatrixUpdatesReply;
                         type ResponseStream = T::GetOccasionalMatrixUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalMatrixUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalMatrixUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::get_occasional_matrix_updates(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -6063,30 +5633,25 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetContinuousMatrixUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetContinuousMatrixUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetContinuousMatrixUpdatesRequest,
-                    > for GetContinuousMatrixUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetContinuousMatrixUpdatesRequest,
+                        > for GetContinuousMatrixUpdatesSvc<T>
+                    {
                         type Response = super::GetContinuousMatrixUpdatesReply;
                         type ResponseStream = T::GetContinuousMatrixUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetContinuousMatrixUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetContinuousMatrixUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::get_continuous_matrix_updates(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -6117,30 +5682,25 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetOccasionalColumnUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetOccasionalColumnUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalColumnUpdatesRequest,
-                    > for GetOccasionalColumnUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalColumnUpdatesRequest,
+                        > for GetOccasionalColumnUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalColumnUpdatesReply;
                         type ResponseStream = T::GetOccasionalColumnUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalColumnUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalColumnUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::get_occasional_column_updates(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -6171,30 +5731,25 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetContinuousColumnUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetContinuousColumnUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetContinuousColumnUpdatesRequest,
-                    > for GetContinuousColumnUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetContinuousColumnUpdatesRequest,
+                        > for GetContinuousColumnUpdatesSvc<T>
+                    {
                         type Response = super::GetContinuousColumnUpdatesReply;
                         type ResponseStream = T::GetContinuousColumnUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetContinuousColumnUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetContinuousColumnUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::get_continuous_column_updates(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -6225,30 +5780,25 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetOccasionalTrackUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetOccasionalTrackUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalTrackUpdatesRequest,
-                    > for GetOccasionalTrackUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalTrackUpdatesRequest,
+                        > for GetOccasionalTrackUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalTrackUpdatesReply;
                         type ResponseStream = T::GetOccasionalTrackUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalTrackUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalTrackUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
                                 <T as HelgoboxService>::get_occasional_track_updates(
-                                        &inner,
-                                        request,
-                                    )
-                                    .await
+                                    &inner, request,
+                                )
+                                .await
                             };
                             Box::pin(fut)
                         }
@@ -6279,29 +5829,21 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetOccasionalRowUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetOccasionalRowUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalRowUpdatesRequest,
-                    > for GetOccasionalRowUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<super::GetOccasionalRowUpdatesRequest>
+                        for GetOccasionalRowUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalRowUpdatesReply;
                         type ResponseStream = T::GetOccasionalRowUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalRowUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalRowUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_occasional_row_updates(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::get_occasional_row_updates(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -6333,29 +5875,22 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetOccasionalSlotUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetOccasionalSlotUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalSlotUpdatesRequest,
-                    > for GetOccasionalSlotUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalSlotUpdatesRequest,
+                        > for GetOccasionalSlotUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalSlotUpdatesReply;
                         type ResponseStream = T::GetOccasionalSlotUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalSlotUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalSlotUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_occasional_slot_updates(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::get_occasional_slot_updates(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -6387,29 +5922,22 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetContinuousSlotUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetContinuousSlotUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetContinuousSlotUpdatesRequest,
-                    > for GetContinuousSlotUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetContinuousSlotUpdatesRequest,
+                        > for GetContinuousSlotUpdatesSvc<T>
+                    {
                         type Response = super::GetContinuousSlotUpdatesReply;
                         type ResponseStream = T::GetContinuousSlotUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetContinuousSlotUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetContinuousSlotUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_continuous_slot_updates(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::get_continuous_slot_updates(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -6441,29 +5969,22 @@ pub mod helgobox_service_server {
                 "/generated.HelgoboxService/GetOccasionalClipUpdates" => {
                     #[allow(non_camel_case_types)]
                     struct GetOccasionalClipUpdatesSvc<T: HelgoboxService>(pub Arc<T>);
-                    impl<
-                        T: HelgoboxService,
-                    > tonic::server::ServerStreamingService<
-                        super::GetOccasionalClipUpdatesRequest,
-                    > for GetOccasionalClipUpdatesSvc<T> {
+                    impl<T: HelgoboxService>
+                        tonic::server::ServerStreamingService<
+                            super::GetOccasionalClipUpdatesRequest,
+                        > for GetOccasionalClipUpdatesSvc<T>
+                    {
                         type Response = super::GetOccasionalClipUpdatesReply;
                         type ResponseStream = T::GetOccasionalClipUpdatesStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
+                        type Future =
+                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
-                                super::GetOccasionalClipUpdatesRequest,
-                            >,
+                            request: tonic::Request<super::GetOccasionalClipUpdatesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as HelgoboxService>::get_occasional_clip_updates(
-                                        &inner,
-                                        request,
-                                    )
+                                <T as HelgoboxService>::get_occasional_clip_updates(&inner, request)
                                     .await
                             };
                             Box::pin(fut)
@@ -6492,18 +6013,14 @@ pub mod helgobox_service_server {
                     };
                     Box::pin(fut)
                 }
-                _ => {
-                    Box::pin(async move {
-                        Ok(
-                            http::Response::builder()
-                                .status(200)
-                                .header("grpc-status", "12")
-                                .header("content-type", "application/grpc")
-                                .body(empty_body())
-                                .unwrap(),
-                        )
-                    })
-                }
+                _ => Box::pin(async move {
+                    Ok(http::Response::builder()
+                        .status(200)
+                        .header("grpc-status", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
             }
         }
     }
diff --git a/playtime-clip-engine b/playtime-clip-engine
index 182feae5b..d1e35e9bb 160000
--- a/playtime-clip-engine
+++ b/playtime-clip-engine
@@ -1 +1 @@
-Subproject commit 182feae5bbc2184301237f3bb70bf0bbe81eda0a
+Subproject commit d1e35e9bb56da6744059755b4a4d15b6d8429113