chore: release version v1.66.22

CHANGELOG.md

@@ -2,6 +2,84 @@
 
 <!-- changelog -->
 
+## [v1.66.22](https://github.com/wanderer-industries/wanderer/compare/v1.66.21...v1.66.22) (2025-06-07)
+
+
+
+
+## [v1.66.21](https://github.com/wanderer-industries/wanderer/compare/v1.66.20...v1.66.21) (2025-06-07)
+
+
+
+
+### Bug Fixes:
+
+* Core: Fixed kills fetching based on env settings
+
+## [v1.66.20](https://github.com/wanderer-industries/wanderer/compare/v1.66.19...v1.66.20) (2025-06-07)
+
+
+
+
+## [v1.66.19](https://github.com/wanderer-industries/wanderer/compare/v1.66.18...v1.66.19) (2025-06-07)
+
+
+
+
+### Bug Fixes:
+
+* Core: Added check for offline characters timeouts
+
+## [v1.66.18](https://github.com/wanderer-industries/wanderer/compare/v1.66.17...v1.66.18) (2025-06-07)
+
+
+
+
+## [v1.66.17](https://github.com/wanderer-industries/wanderer/compare/v1.66.16...v1.66.17) (2025-06-07)
+
+
+
+
+### Bug Fixes:
+
+* Core: Increased tracking pause timeout for offline characters up to 10 hours
+
+## [v1.66.16](https://github.com/wanderer-industries/wanderer/compare/v1.66.15...v1.66.16) (2025-06-07)
+
+
+
+
+### Bug Fixes:
+
+* Core: Increased tracking pause timeout for offline characters up to 10 hours
+
+## [v1.66.15](https://github.com/wanderer-industries/wanderer/compare/v1.66.14...v1.66.15) (2025-06-07)
+
+
+
+
+### Bug Fixes:
+
+* Core: Added back arm docker image build
+
+## [v1.66.14](https://github.com/wanderer-industries/wanderer/compare/v1.66.13...v1.66.14) (2025-06-07)
+
+
+
+
+### Bug Fixes:
+
+* Core: fixed online updates
+
+## [v1.66.13](https://github.com/wanderer-industries/wanderer/compare/v1.66.12...v1.66.13) (2025-06-07)
+
+
+
+
+### Bug Fixes:
+
+* Core: fixed location tracking issues
+
 ## [v1.66.12](https://github.com/wanderer-industries/wanderer/compare/v1.66.11...v1.66.12) (2025-06-06)
 
 

lib/wanderer_app/character/tracker.ex

@@ -33,12 +33,16 @@ defmodule WandererApp.Character.Tracker do
           status: binary()
         }
 
-  @pause_tracking_timeout :timer.minutes(10)
-  @online_error_timeout :timer.minutes(1)
+  @pause_tracking_timeout :timer.minutes(60 * 10)
+  @offline_timeout :timer.minutes(5)
+  @online_error_timeout :timer.minutes(2)
+  @ship_error_timeout :timer.minutes(2)
+  @location_error_timeout :timer.minutes(2)
   @online_forbidden_ttl :timer.seconds(7)
   @online_limit_ttl :timer.seconds(7)
   @forbidden_ttl :timer.seconds(5)
   @limit_ttl :timer.seconds(5)
+  @location_limit_ttl :timer.seconds(1)
   @pubsub_client Application.compile_env(:wanderer_app, :pubsub_client)
 
   def new(), do: __struct__()
@@ -53,8 +57,37 @@ defmodule WandererApp.Character.Tracker do
     |> new()
   end
 
-  def check_online_errors(character_id) do
-    WandererApp.Cache.lookup!("character:#{character_id}:online_error_time")
+  def check_offline(character_id) do
+    WandererApp.Cache.lookup!("character:#{character_id}:last_online_time")
+    |> case do
+      nil ->
+        pause_tracking(character_id)
+        :ok
+
+      last_online_time ->
+        duration = DateTime.diff(DateTime.utc_now(), last_online_time, :millisecond)
+
+        if duration >= @offline_timeout do
+          pause_tracking(character_id)
+
+          :ok
+        else
+          :skip
+        end
+    end
+  end
+
+  def check_online_errors(character_id),
+    do: check_tracking_errors(character_id, "online", @online_error_timeout)
+
+  def check_ship_errors(character_id),
+    do: check_tracking_errors(character_id, "ship", @ship_error_timeout)
+
+  def check_location_errors(character_id),
+    do: check_tracking_errors(character_id, "location", @location_error_timeout)
+
+  defp check_tracking_errors(character_id, type, timeout) do
+    WandererApp.Cache.lookup!("character:#{character_id}:#{type}_error_time")
     |> case do
       nil ->
         :skip
@@ -62,34 +95,8 @@ defmodule WandererApp.Character.Tracker do
       error_time ->
         duration = DateTime.diff(DateTime.utc_now(), error_time, :millisecond)
 
-        if duration >= @online_error_timeout do
-          WandererApp.Cache.delete("character:#{character_id}:online_forbidden")
-          WandererApp.Cache.delete("character:#{character_id}:online_error_time")
-          WandererApp.Character.update_character(character_id, %{online: false})
-
-          WandererApp.Character.update_character_state(character_id, %{
-            is_online: false
-          })
-
-          WandererApp.Cache.put(
-            "character:#{character_id}:tracking_paused",
-            true,
-            ttl: @pause_tracking_timeout
-          )
-
-          {:ok, %{solar_system_id: solar_system_id}} =
-            WandererApp.Character.get_character(character_id)
-
-          {:ok, %{active_maps: active_maps}} =
-            WandererApp.Character.get_character_state(character_id)
-
-          active_maps
-          |> Enum.each(fn map_id ->
-            WandererApp.Cache.put(
-              "map:#{map_id}:character:#{character_id}:start_solar_system_id",
-              solar_system_id
-            )
-          end)
+        if duration >= timeout do
+          pause_tracking(character_id)
 
           :ok
         else
@@ -98,6 +105,40 @@ defmodule WandererApp.Character.Tracker do
     end
   end
 
+  defp pause_tracking(character_id) do
+    WandererApp.Cache.delete("character:#{character_id}:online_forbidden")
+    WandererApp.Cache.delete("character:#{character_id}:online_error_time")
+    WandererApp.Cache.delete("character:#{character_id}:ship_error_time")
+    WandererApp.Cache.delete("character:#{character_id}:location_error_time")
+    WandererApp.Character.update_character(character_id, %{online: false})
+
+    WandererApp.Character.update_character_state(character_id, %{
+      is_online: false
+    })
+
+    Logger.warning("[CharacterTracker] paused for #{character_id}")
+
+    WandererApp.Cache.put(
+      "character:#{character_id}:tracking_paused",
+      true,
+      ttl: @pause_tracking_timeout
+    )
+
+    {:ok, %{solar_system_id: solar_system_id}} =
+      WandererApp.Character.get_character(character_id)
+
+    {:ok, %{active_maps: active_maps}} =
+      WandererApp.Character.get_character_state(character_id)
+
+    active_maps
+    |> Enum.each(fn map_id ->
+      WandererApp.Cache.put(
+        "map:#{map_id}:character:#{character_id}:start_solar_system_id",
+        solar_system_id
+      )
+    end)
+  end
+
   def update_settings(character_id, track_settings) do
     {:ok, character_state} = WandererApp.Character.get_character_state(character_id)
 
@@ -134,18 +175,19 @@ defmodule WandererApp.Character.Tracker do
               {:ok, online} ->
                 online = get_online(online)
 
-                WandererApp.Cache.delete("character:#{character_id}:online_forbidden")
-
-                if is_nil(
-                     WandererApp.Cache.lookup!("character:#{character_id}:online_error_time")
-                   ) do
+                if online.online == true do
                   WandererApp.Cache.insert(
-                    "character:#{character_id}:online_error_time",
+                    "character:#{character_id}:last_online_time",
                     DateTime.utc_now()
                   )
+                else
+                  WandererApp.Cache.delete("character:#{character_id}:last_online_time")
                 end
 
-                # WandererApp.Cache.delete("character:#{character_id}:online_error_time")
+                WandererApp.Cache.delete("character:#{character_id}:online_forbidden")
+                WandererApp.Cache.delete("character:#{character_id}:online_error_time")
+                WandererApp.Cache.delete("character:#{character_id}:ship_error_time")
+                WandererApp.Cache.delete("character:#{character_id}:location_error_time")
                 WandererApp.Cache.delete("character:#{character_id}:info_forbidden")
                 WandererApp.Cache.delete("character:#{character_id}:ship_forbidden")
                 WandererApp.Cache.delete("character:#{character_id}:location_forbidden")
@@ -196,15 +238,6 @@ defmodule WandererApp.Character.Tracker do
                   ttl: reset_timeout
                 )
 
-                if is_nil(
-                     WandererApp.Cache.lookup!("character:#{character_id}:online_error_time")
-                   ) do
-                  WandererApp.Cache.insert(
-                    "character:#{character_id}:online_error_time",
-                    DateTime.utc_now()
-                  )
-                end
-
                 {:error, :skipped}
 
               {:error, error} ->
@@ -239,11 +272,16 @@ defmodule WandererApp.Character.Tracker do
 
   def update_online(_), do: {:error, :skipped}
 
-  defp get_reset_timeout(%{"x-esi-error-limit-reset" => [reset_seconds]})
+  defp get_reset_timeout(_headers, _default_timeout \\ @limit_ttl)
+
+  defp get_reset_timeout(
+         %{"x-esi-error-limit-remain" => ["0"], "x-esi-error-limit-reset" => [reset_seconds]},
+         _default_timeout
+       )
        when is_binary(reset_seconds),
        do: :timer.seconds((reset_seconds |> String.to_integer()) + 1)
 
-  defp get_reset_timeout(_headers), do: @limit_ttl
+  defp get_reset_timeout(_headers, default_timeout), do: default_timeout
 
   def update_info(character_id) do
     (WandererApp.Cache.has_key?("character:#{character_id}:online_forbidden") ||
@@ -346,6 +384,13 @@ defmodule WandererApp.Character.Tracker do
                   ttl: @forbidden_ttl
                 )
 
+                if is_nil(WandererApp.Cache.lookup!("character:#{character_id}:ship_error_time")) do
+                  WandererApp.Cache.insert(
+                    "character:#{character_id}:ship_error_time",
+                    DateTime.utc_now()
+                  )
+                end
+
                 {:error, error}
 
               {:error, :error_limited, headers} ->
@@ -370,6 +415,13 @@ defmodule WandererApp.Character.Tracker do
                   ttl: @forbidden_ttl
                 )
 
+                if is_nil(WandererApp.Cache.lookup!("character:#{character_id}:ship_error_time")) do
+                  WandererApp.Cache.insert(
+                    "character:#{character_id}:ship_error_time",
+                    DateTime.utc_now()
+                  )
+                end
+
                 {:error, error}
 
               _ ->
@@ -381,6 +433,13 @@ defmodule WandererApp.Character.Tracker do
                   ttl: @forbidden_ttl
                 )
 
+                if is_nil(WandererApp.Cache.lookup!("character:#{character_id}:ship_error_time")) do
+                  WandererApp.Cache.insert(
+                    "character:#{character_id}:ship_error_time",
+                    DateTime.utc_now()
+                  )
+                end
+
                 {:error, :skipped}
             end
         end
@@ -403,8 +462,7 @@ defmodule WandererApp.Character.Tracker do
       ) do
     case WandererApp.Character.get_character(character_id) do
       {:ok, %{eve_id: eve_id, access_token: access_token}} when not is_nil(access_token) ->
-        (WandererApp.Cache.has_key?("character:#{character_id}:online_forbidden") ||
-           WandererApp.Cache.has_key?("character:#{character_id}:location_forbidden") ||
+        (WandererApp.Cache.has_key?("character:#{character_id}:location_forbidden") ||
            WandererApp.Cache.has_key?("character:#{character_id}:tracking_paused"))
         |> case do
           true ->
@@ -424,21 +482,24 @@ defmodule WandererApp.Character.Tracker do
               {:error, error} when error in [:forbidden, :not_found, :timeout] ->
                 Logger.warning("#{__MODULE__} failed to update_location: #{inspect(error)}")
 
-                WandererApp.Cache.put(
-                  "character:#{character_id}:location_forbidden",
-                  true,
-                  ttl: @forbidden_ttl
-                )
+                if is_nil(
+                     WandererApp.Cache.lookup!("character:#{character_id}:location_error_time")
+                   ) do
+                  WandererApp.Cache.insert(
+                    "character:#{character_id}:location_error_time",
+                    DateTime.utc_now()
+                  )
+                end
 
-                {:error, error}
+                {:error, :skipped}
 
               {:error, :error_limited, headers} ->
-                reset_timeout = get_reset_timeout(headers)
-
                 Logger.warning(
                   "#{__MODULE__} failed to update_location: #{inspect(:error_limited)}"
                 )
 
+                reset_timeout = get_reset_timeout(headers, @location_limit_ttl)
+
                 WandererApp.Cache.put(
                   "character:#{character_id}:location_forbidden",
                   true,
@@ -450,22 +511,28 @@ defmodule WandererApp.Character.Tracker do
               {:error, error} ->
                 Logger.error("#{__MODULE__} failed to update_location: #{inspect(error)}")
 
-                WandererApp.Cache.put(
-                  "character:#{character_id}:location_forbidden",
-                  true,
-                  ttl: @forbidden_ttl
-                )
+                if is_nil(
+                     WandererApp.Cache.lookup!("character:#{character_id}:location_error_time")
+                   ) do
+                  WandererApp.Cache.insert(
+                    "character:#{character_id}:location_error_time",
+                    DateTime.utc_now()
+                  )
+                end
 
-                {:error, error}
+                {:error, :skipped}
 
               _ ->
                 Logger.error("#{__MODULE__} failed to update_location: wrong response")
 
-                WandererApp.Cache.put(
-                  "character:#{character_id}:location_forbidden",
-                  true,
-                  ttl: @forbidden_ttl
-                )
+                if is_nil(
+                     WandererApp.Cache.lookup!("character:#{character_id}:location_error_time")
+                   ) do
+                  WandererApp.Cache.insert(
+                    "character:#{character_id}:location_error_time",
+                    DateTime.utc_now()
+                  )
+                end
 
                 {:error, :skipped}
             end

lib/wanderer_app/character/tracker_manager_impl.ex

@@ -120,6 +120,12 @@ defmodule WandererApp.Character.TrackerManager.Impl do
         WandererApp.Character.Tracker.update_settings(character_id, track_settings)
 
       WandererApp.Cache.delete("character:#{character_id}:tracking_paused")
+
+      WandererApp.Cache.insert(
+        "character:#{character_id}:last_online_time",
+        DateTime.utc_now()
+      )
+
       WandererApp.Character.update_character_state(character_id, character_state)
     else
       WandererApp.Cache.insert_or_update(

lib/wanderer_app/character/tracker_pool.ex

@@ -16,9 +16,12 @@ defmodule WandererApp.Character.TrackerPool do
   @registry :tracker_pool_registry
   @unique_registry :unique_tracker_pool_registry
 
-  @update_location_interval :timer.seconds(2)
+  @update_location_interval :timer.seconds(1)
   @update_online_interval :timer.seconds(5)
-  @check_online_errors_interval :timer.seconds(30)
+  @check_offline_characters_interval :timer.minutes(2)
+  @check_online_errors_interval :timer.minutes(1)
+  @check_ship_errors_interval :timer.minutes(1)
+  @check_location_errors_interval :timer.minutes(1)
   @update_ship_interval :timer.seconds(2)
   @update_info_interval :timer.minutes(1)
   @update_wallet_interval :timer.minutes(1)
@@ -116,7 +119,10 @@ defmodule WandererApp.Character.TrackerPool do
     )
 
     Process.send_after(self(), :update_online, 100)
-    Process.send_after(self(), :check_online_errors, @check_online_errors_interval)
+    Process.send_after(self(), :check_online_errors, :timer.seconds(60))
+    Process.send_after(self(), :check_ship_errors, :timer.seconds(90))
+    Process.send_after(self(), :check_location_errors, :timer.seconds(120))
+    Process.send_after(self(), :check_offline_characters, @check_offline_characters_interval)
     Process.send_after(self(), :update_location, 300)
     Process.send_after(self(), :update_ship, 500)
     Process.send_after(self(), :update_info, 1500)
@@ -203,6 +209,46 @@ defmodule WandererApp.Character.TrackerPool do
     {:noreply, state}
   end
 
+  def handle_info(
+        :check_offline_characters,
+        %{
+          characters: characters
+        } =
+          state
+      ) do
+    Process.send_after(self(), :check_offline_characters, @check_offline_characters_interval)
+
+    try do
+      characters
+      |> Task.async_stream(
+        fn character_id ->
+          WandererApp.TaskWrapper.start_link(
+            WandererApp.Character.Tracker,
+            :check_offline,
+            [
+              character_id
+            ]
+          )
+        end,
+        timeout: :timer.seconds(15),
+        max_concurrency: System.schedulers_online(),
+        on_timeout: :kill_task
+      )
+      |> Enum.each(fn
+        {:ok, _result} -> :ok
+        {:error, reason} -> @logger.error("Error in check_offline: #{inspect(reason)}")
+      end)
+    rescue
+      e ->
+        Logger.error("""
+        [Tracker Pool] check_offline => exception: #{Exception.message(e)}
+        #{Exception.format_stacktrace(__STACKTRACE__)}
+        """)
+    end
+
+    {:noreply, state}
+  end
+
   def handle_info(
         :check_online_errors,
         %{
@@ -243,6 +289,86 @@ defmodule WandererApp.Character.TrackerPool do
     {:noreply, state}
   end
 
+  def handle_info(
+        :check_ship_errors,
+        %{
+          characters: characters
+        } =
+          state
+      ) do
+    Process.send_after(self(), :check_ship_errors, @check_ship_errors_interval)
+
+    try do
+      characters
+      |> Task.async_stream(
+        fn character_id ->
+          WandererApp.TaskWrapper.start_link(
+            WandererApp.Character.Tracker,
+            :check_ship_errors,
+            [
+              character_id
+            ]
+          )
+        end,
+        timeout: :timer.seconds(15),
+        max_concurrency: System.schedulers_online(),
+        on_timeout: :kill_task
+      )
+      |> Enum.each(fn
+        {:ok, _result} -> :ok
+        {:error, reason} -> @logger.error("Error in check_ship_errors: #{inspect(reason)}")
+      end)
+    rescue
+      e ->
+        Logger.error("""
+        [Tracker Pool] check_ship_errors => exception: #{Exception.message(e)}
+        #{Exception.format_stacktrace(__STACKTRACE__)}
+        """)
+    end
+
+    {:noreply, state}
+  end
+
+  def handle_info(
+        :check_location_errors,
+        %{
+          characters: characters
+        } =
+          state
+      ) do
+    Process.send_after(self(), :check_location_errors, @check_location_errors_interval)
+
+    try do
+      characters
+      |> Task.async_stream(
+        fn character_id ->
+          WandererApp.TaskWrapper.start_link(
+            WandererApp.Character.Tracker,
+            :check_location_errors,
+            [
+              character_id
+            ]
+          )
+        end,
+        timeout: :timer.seconds(15),
+        max_concurrency: System.schedulers_online(),
+        on_timeout: :kill_task
+      )
+      |> Enum.each(fn
+        {:ok, _result} -> :ok
+        {:error, reason} -> @logger.error("Error in check_location_errors: #{inspect(reason)}")
+      end)
+    rescue
+      e ->
+        Logger.error("""
+        [Tracker Pool] check_location_errors => exception: #{Exception.message(e)}
+        #{Exception.format_stacktrace(__STACKTRACE__)}
+        """)
+    end
+
+    {:noreply, state}
+  end
+
   def handle_info(
         :update_location,
         %{

lib/wanderer_app/character/tracker_pool_dynamic_supervisor.ex

@@ -7,7 +7,7 @@ defmodule WandererApp.Character.TrackerPoolDynamicSupervisor do
   @cache :tracked_characters
   @registry :tracker_pool_registry
   @unique_registry :unique_tracker_pool_registry
-  @tracker_pool_limit 100
+  @tracker_pool_limit 50
 
   @name __MODULE__
 

lib/wanderer_app/zkb/zkills_provider/fetcher.ex

@@ -62,62 +62,68 @@ defmodule WandererApp.Zkb.KillsProvider.Fetcher do
   Returns `{:ok, kills, updated_state}` on success, or `{:error, reason, updated_state}`.
   """
   def fetch_kills_for_system(system_id, since_hours, state, opts \\ []) do
-    limit = Keyword.get(opts, :limit, nil)
-    force? = Keyword.get(opts, :force, false)
+    zkill_preload_disabled = WandererApp.Env.zkill_preload_disabled?()
 
-    log_prefix = "[Fetcher] fetch_kills_for_system => system=#{system_id}"
+    if not zkill_preload_disabled do
+      limit = Keyword.get(opts, :limit, nil)
+      force? = Keyword.get(opts, :force, false)
 
-    # Check the "recently fetched" cache if not forced
-    if not force? and KillsCache.recently_fetched?(system_id) do
-      cached_kills = KillsCache.fetch_cached_kills(system_id)
-      final = maybe_take(cached_kills, limit)
+      log_prefix = "[Fetcher] fetch_kills_for_system => system=#{system_id}"
 
-      Logger.debug(fn ->
-        "#{log_prefix}, recently_fetched?=true => returning #{length(final)} cached kills"
-      end)
+      # Check the "recently fetched" cache if not forced
+      if not force? and KillsCache.recently_fetched?(system_id) do
+        cached_kills = KillsCache.fetch_cached_kills(system_id)
+        final = maybe_take(cached_kills, limit)
 
-      {:ok, final, state}
-    else
-      Logger.debug(fn ->
-        "#{log_prefix}, hours=#{since_hours}, limit=#{inspect(limit)}, force=#{force?}"
-      end)
+        Logger.debug(fn ->
+          "#{log_prefix}, recently_fetched?=true => returning #{length(final)} cached kills"
+        end)
 
-      cutoff_dt = hours_ago(since_hours)
+        {:ok, final, state}
+      else
+        Logger.debug(fn ->
+          "#{log_prefix}, hours=#{since_hours}, limit=#{inspect(limit)}, force=#{force?}"
+        end)
 
-      result =
-        retry with:
-                exponential_backoff(300)
-                |> randomize()
-                |> cap(5_000)
-                |> expiry(120_000) do
-          case do_multi_page_fetch(system_id, cutoff_dt, 1, 0, limit, state) do
-            {:ok, new_st, total_fetched} ->
-              # Mark system as fully fetched (to prevent repeated calls).
-              KillsCache.put_full_fetched_timestamp(system_id)
-              final_kills = KillsCache.fetch_cached_kills(system_id) |> maybe_take(limit)
+        cutoff_dt = hours_ago(since_hours)
 
-              Logger.debug(fn ->
-                "#{log_prefix}, total_fetched=#{total_fetched}, final_cached=#{length(final_kills)}, calls_count=#{new_st.calls_count}"
-              end)
+        result =
+          retry with:
+                  exponential_backoff(300)
+                  |> randomize()
+                  |> cap(5_000)
+                  |> expiry(120_000) do
+            case do_multi_page_fetch(system_id, cutoff_dt, 1, 0, limit, state) do
+              {:ok, new_st, total_fetched} ->
+                # Mark system as fully fetched (to prevent repeated calls).
+                KillsCache.put_full_fetched_timestamp(system_id)
+                final_kills = KillsCache.fetch_cached_kills(system_id) |> maybe_take(limit)
 
-              {:ok, final_kills, new_st}
+                Logger.debug(fn ->
+                  "#{log_prefix}, total_fetched=#{total_fetched}, final_cached=#{length(final_kills)}, calls_count=#{new_st.calls_count}"
+                end)
 
-            {:error, :rate_limited, _new_st} ->
-              raise ":rate_limited"
+                {:ok, final_kills, new_st}
 
-            {:error, reason, _new_st} ->
-              raise "#{log_prefix}, reason=#{inspect(reason)}"
+              {:error, :rate_limited, _new_st} ->
+                raise ":rate_limited"
+
+              {:error, reason, _new_st} ->
+                raise "#{log_prefix}, reason=#{inspect(reason)}"
+            end
           end
+
+        case result do
+          {:ok, kills, new_st} ->
+            {:ok, kills, new_st}
+
+          error ->
+            Logger.error("#{log_prefix}, EXHAUSTED => error=#{inspect(error)}")
+            {:error, error, state}
         end
-
-      case result do
-        {:ok, kills, new_st} ->
-          {:ok, kills, new_st}
-
-        error ->
-          Logger.error("#{log_prefix}, EXHAUSTED => error=#{inspect(error)}")
-          {:error, error, state}
       end
+    else
+      raise ":kills_disabled"
     end
   rescue
     e ->

mix.exs

@@ -3,7 +3,7 @@ defmodule WandererApp.MixProject do
 
   @source_url "https://github.com/wanderer-industries/wanderer"
 
-  @version "1.66.12"
+  @version "1.66.22"
 
   def project do
     [