Fix compare version script (#1435)

Co-authored-by: Alexandru Macocian <amacocian@microsoft.com>

.editorconfig

@@ -0,0 +1,137 @@
+[*.cs]
+
+# CA2254: Template should be a static expression
+dotnet_diagnostic.CA2254.severity = none
+csharp_indent_labels = one_less_than_current
+csharp_using_directive_placement = outside_namespace:error
+csharp_prefer_simple_using_statement = true:error
+csharp_prefer_braces = true:silent
+csharp_style_namespace_declarations = file_scoped:error
+csharp_style_prefer_method_group_conversion = true:suggestion
+csharp_style_expression_bodied_methods = false:silent
+csharp_style_expression_bodied_constructors = false:silent
+csharp_style_expression_bodied_operators = false:silent
+csharp_style_expression_bodied_properties = true:silent
+csharp_style_expression_bodied_indexers = true:silent
+csharp_style_expression_bodied_accessors = true:silent
+csharp_style_expression_bodied_lambdas = true:silent
+csharp_style_expression_bodied_local_functions = false:silent
+csharp_indent_braces = false
+insert_final_newline = true
+csharp_space_around_binary_operators = before_and_after
+csharp_style_throw_expression = true:suggestion
+csharp_style_prefer_null_check_over_type_check = true:suggestion
+csharp_prefer_simple_default_expression = true:suggestion
+csharp_style_prefer_local_over_anonymous_function = true:error
+csharp_style_prefer_index_operator = true:suggestion
+csharp_style_prefer_range_operator = true:suggestion
+csharp_style_implicit_object_creation_when_type_is_apparent = true:suggestion
+csharp_style_prefer_tuple_swap = true:suggestion
+csharp_style_inlined_variable_declaration = true:suggestion
+csharp_style_deconstructed_variable_declaration = true:error
+csharp_style_unused_value_assignment_preference = discard_variable:error
+csharp_style_unused_value_expression_statement_preference = discard_variable:silent
+csharp_prefer_static_local_function = true:suggestion
+csharp_style_allow_embedded_statements_on_same_line_experimental = true:silent
+csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true:silent
+csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false:suggestion
+csharp_style_conditional_delegate_call = true:suggestion
+csharp_style_prefer_parameter_null_checking = true:suggestion
+csharp_style_prefer_switch_expression = true:suggestion
+csharp_style_prefer_pattern_matching = true:silent
+csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
+csharp_style_prefer_not_pattern = true:suggestion
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+csharp_style_prefer_extended_property_pattern = true:suggestion
+csharp_style_var_for_built_in_types = false:silent
+csharp_style_var_when_type_is_apparent = false:silent
+csharp_style_var_elsewhere = false:silent
+csharp_style_prefer_top_level_statements = true:suggestion
+csharp_style_prefer_utf8_string_literals = true:suggestion
+csharp_style_prefer_readonly_struct = true:suggestion
+
+[*.{cs,vb}]
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = error
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = error
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = error
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+tab_width = 4
+indent_size = 4
+end_of_line = crlf
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:error
+dotnet_style_prefer_auto_properties = true:error
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
+dotnet_style_prefer_conditional_expression_over_assignment = true:silent
+dotnet_style_prefer_conditional_expression_over_return = true:silent
+dotnet_style_explicit_tuple_names = true:suggestion
+dotnet_style_prefer_inferred_tuple_names = true:suggestion
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
+dotnet_style_prefer_compound_assignment = true:suggestion
+dotnet_style_prefer_simplified_interpolation = true:suggestion
+dotnet_style_namespace_match_folder = true:suggestion
+dotnet_style_readonly_field = true:suggestion
+dotnet_style_predefined_type_for_locals_parameters_members = true:silent
+dotnet_style_predefined_type_for_member_access = true:silent
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:silent
+dotnet_style_allow_multiple_blank_lines_experimental = true:silent
+dotnet_style_allow_statement_immediately_after_block_experimental = false:suggestion
+dotnet_code_quality_unused_parameters = all:error
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:suggestion
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:suggestion
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:suggestion
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary:suggestion
+dotnet_style_qualification_for_field = true:error
+dotnet_style_qualification_for_property = true:error
+dotnet_style_qualification_for_method = true:error
+dotnet_style_qualification_for_event = true:error
+dotnet_diagnostic.CA1000.severity = error
+
+[*.vb]
+dotnet_diagnostic.CA1047.severity = error

.github/CODEOWNERS

@@ -0,0 +1 @@
+*	amacocian@yahoo.com

.github/dependabot.yml

@@ -0,0 +1,16 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "nuget"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/cd-dry-run.yml

@@ -0,0 +1,22 @@
+# This action simulates a CD pipeline without the package publishing
+# to ensure that changes don't break the real run
+name: Daybreak Dry-Run CD Pipeline
+
+on:
+  pull_request:
+    branches:
+      - master
+    paths:
+      - "Daybreak.Core/**"
+      - "Daybreak.Installer/**"
+      - "Daybreak.API/**"
+      - "Daybreak.Shared/**"
+      - "Daybreak.Windows/**"
+      - "Daybreak.Linux/**"
+
+jobs:
+  cd:
+    uses: ./.github/workflows/cd-template.yml
+    with:
+      publishRelease: false
+    secrets: inherit

.github/workflows/cd-template.yml

@@ -0,0 +1,271 @@
+# Reusable CD pipeline with optional release publishing
+name: Daybreak CD Template
+
+on:
+  workflow_call:
+    inputs:
+      publishRelease:
+        description: "Whether to create and publish the GitHub release"
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  # ───────────────────────────────────────────────────────
+  #  Stage 1 — Build the x86 Windows-only components
+  #            (Injector + API) that both platforms need.
+  # ───────────────────────────────────────────────────────
+  build-x86:
+    runs-on: windows-latest
+
+    outputs:
+      version: ${{ steps.get_version.outputs.version }}
+
+    env:
+      Configuration: Release
+      Actions_Allow_Unsecure_Commands: true
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: Get version
+        id: get_version
+        shell: pwsh
+        run: |
+          $version = (Select-String -Path Directory.Build.props -Pattern '<Version>(.*)</Version>').Matches.Groups[1].Value
+          echo "version=$version" >> $env:GITHUB_OUTPUT
+
+      - name: Install .NET
+        uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: "10.x"
+
+      - name: Publish x86 components
+        run: .\Scripts\PublishWindowsX86.ps1
+        shell: pwsh
+
+      - name: Upload x86 artifacts
+        uses: actions/upload-artifact@v6
+        with:
+          name: x86-components
+          path: |
+            Publish/Injector/
+            Publish/Api/
+          retention-days: 1
+
+  # ───────────────────────────────────────────────────────
+  #  Stage 2 — Platform builds (parallel)
+  # ───────────────────────────────────────────────────────
+  build-windows:
+    needs: build-x86
+    runs-on: windows-latest
+
+    env:
+      Configuration: Release
+      Actions_Allow_Unsecure_Commands: true
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: Install .NET
+        uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: "10.x"
+
+      - name: Setup project secrets
+        run: |
+          dotnet user-secrets --project Daybreak.Core\Daybreak.Core.csproj set AadApplicationId "${{ secrets.AadApplicationId }}"
+          dotnet user-secrets --project Daybreak.Core\Daybreak.Core.csproj set AadTenantId "${{ secrets.AadTenantId }}"
+          dotnet user-secrets --project Daybreak.Core\Daybreak.Core.csproj set ApmServiceAccount "${{ secrets.ApmServiceAccount }}"
+          dotnet user-secrets --project Daybreak.Core\Daybreak.Core.csproj set ApmServiceKey "${{ secrets.ApmServiceKey }}"
+          dotnet user-secrets --project Daybreak.Core\Daybreak.Core.csproj set ApmUri "${{ secrets.ApmUri }}"
+
+      - name: Download x86 artifacts
+        uses: actions/download-artifact@v7
+        with:
+          name: x86-components
+          path: Publish/
+
+      - name: Publish Windows x64
+        run: .\Scripts\PublishWindows.ps1
+        shell: pwsh
+
+      - name: Upload Windows build
+        uses: actions/upload-artifact@v6
+        with:
+          name: windows-build
+          path: Publish/
+          retention-days: 1
+
+  build-linux:
+    needs: build-x86
+    runs-on: ubuntu-latest
+
+    env:
+      Configuration: Release
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: Install .NET
+        uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: "10.x"
+
+      - name: Setup project secrets
+        run: |
+          dotnet user-secrets --project Daybreak.Core/Daybreak.Core.csproj set AadApplicationId "${{ secrets.AadApplicationId }}"
+          dotnet user-secrets --project Daybreak.Core/Daybreak.Core.csproj set AadTenantId "${{ secrets.AadTenantId }}"
+          dotnet user-secrets --project Daybreak.Core/Daybreak.Core.csproj set ApmServiceAccount "${{ secrets.ApmServiceAccount }}"
+          dotnet user-secrets --project Daybreak.Core/Daybreak.Core.csproj set ApmServiceKey "${{ secrets.ApmServiceKey }}"
+          dotnet user-secrets --project Daybreak.Core/Daybreak.Core.csproj set ApmUri "${{ secrets.ApmUri }}"
+
+      - name: Download x86 artifacts
+        uses: actions/download-artifact@v7
+        with:
+          name: x86-components
+          path: Publish/
+
+      - name: Publish Linux x64
+        run: pwsh ./Scripts/PublishLinux.ps1
+        shell: bash
+
+      - name: Set executable permissions
+        run: |
+          chmod +x Publish/Daybreak
+          chmod +x Publish/Daybreak.Wayland.sh
+          chmod +x Publish/Installer/Daybreak.Installer
+
+      - name: Upload Linux build
+        uses: actions/upload-artifact@v6
+        with:
+          name: linux-build
+          path: Publish/
+          retention-days: 1
+
+  # ───────────────────────────────────────────────────────
+  #  Stage 3 — Package (always)
+  # ───────────────────────────────────────────────────────
+  package:
+    needs: [build-x86, build-windows, build-linux]
+    runs-on: ubuntu-latest
+
+    env:
+      Actions_Allow_Unsecure_Commands: true
+      Version: ${{ needs.build-x86.outputs.version }}
+
+    steps:
+      # ── Windows package ──
+      - name: Download Windows build
+        uses: actions/download-artifact@v7
+        with:
+          name: windows-build
+          path: windows-publish/
+
+      - name: Clean and zip Windows build
+        run: |
+          cd windows-publish
+          find . -name '*.pdb' -delete
+          find . -name '*.dbg' -delete
+          if [ -f Installer/Daybreak.Installer.exe ]; then
+            mv Installer/Daybreak.Installer.exe Installer/Daybreak.Installer.Temp.exe
+          fi
+          cd ..
+          cd windows-publish && zip -r ../daybreakv${{ env.Version }}.zip . && cd ..
+
+      # ── Linux package ──
+      - name: Download Linux build
+        uses: actions/download-artifact@v7
+        with:
+          name: linux-build
+          path: linux-publish/
+
+      - name: Clean and zip Linux build
+        run: |
+          cd linux-publish
+          find . -name '*.pdb' -delete
+          find . -name '*.dbg' -delete
+          if [ -f Installer/Daybreak.Installer ]; then
+            chmod +x Installer/Daybreak.Installer
+            mv Installer/Daybreak.Installer Installer/Daybreak.Installer.Temp
+          fi
+          chmod +x Daybreak Daybreak.Wayland.sh
+          cd ..
+          cd linux-publish && zip -r ../daybreakv${{ env.Version }}-linux.zip . && cd ..
+
+      - name: Upload release artifacts
+        uses: actions/upload-artifact@v6
+        with:
+          name: release-zips
+          path: |
+            daybreakv${{ env.Version }}.zip
+            daybreakv${{ env.Version }}-linux.zip
+          retention-days: 7
+
+  # ───────────────────────────────────────────────────────
+  #  Stage 4 — Release (optional)
+  # ───────────────────────────────────────────────────────
+  release:
+    needs: [build-x86, package]
+    runs-on: ubuntu-latest
+    if: ${{ inputs.publishRelease }}
+
+    env:
+      Actions_Allow_Unsecure_Commands: true
+      Version: ${{ needs.build-x86.outputs.version }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: Download release artifacts
+        uses: actions/download-artifact@v7
+        with:
+          name: release-zips
+          path: release-assets/
+
+      - name: Get Latest Tag
+        id: getLatestTag
+        uses: WyriHaximus/github-action-get-previous-tag@v2
+
+      - name: Generate changelog
+        id: changelog
+        run: |
+          changeLog=$(git log --no-merges --pretty="%h - %s (%an)<br />" ${{ steps.getLatestTag.outputs.tag }}..HEAD)
+          echo "content<<EOF" >> $GITHUB_OUTPUT
+          echo "$changeLog" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+        # ── Release ──
+      - name: Create release draft
+        uses: Xotl/cool-github-releases@v1.1.10
+        with:
+          mode: update
+          tag_name: v${{ env.Version }}
+          release_name: Daybreak v${{ env.Version }}
+          assets: release-assets/daybreakv${{ env.Version }}.zip;release-assets/daybreakv${{ env.Version }}-linux.zip
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          replace_assets: true
+          body_mrkdwn: |
+            ${{ steps.changelog.outputs.content }}
+          isDraft: true
+
+      - name: Publish release
+        run: gh release edit v${{ env.Version }} --draft=false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/cd.yaml

@@ -0,0 +1,25 @@
+# This continuous delivery pipeline is triggered on pushes to master.
+# It builds the Windows x86 components (Injector + API), then builds
+# the Windows x64 and Linux x64 platform bundles in parallel, and
+# finally packages both into release zips and publishes a GitHub release.
+name: Daybreak CD Pipeline
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - "Daybreak.Core/**"
+      - "Daybreak.Installer/**"
+      - "Daybreak.API/**"
+      - "Daybreak.Shared/**"
+      - "Daybreak.Windows/**"
+      - "Daybreak.Linux/**"
+  workflow_dispatch:
+
+jobs:
+  cd:
+    uses: ./.github/workflows/cd-template.yml
+    with:
+      publishRelease: true
+    secrets: inherit

.github/workflows/ci.yaml

@@ -0,0 +1,66 @@
+# This continuous integration pipeline is triggered on pull requests to master.
+# It validates that both the Windows and Linux builds compile successfully.
+name: Daybreak CI Pipeline
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build-windows:
+    runs-on: windows-latest
+
+    env:
+      Configuration: Debug
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: Install .NET
+        uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: "10.x"
+
+      - name: Build Windows project
+        run: dotnet build Daybreak.Windows/Daybreak.Windows.csproj -c $env:Configuration
+
+      - name: Build Injector
+        run: dotnet build Daybreak.Injector/Daybreak.Injector.csproj -c $env:Configuration
+
+      - name: Build API
+        run: dotnet build Daybreak.API/Daybreak.API.csproj -c $env:Configuration
+
+      - name: Build Installer
+        run: dotnet build Daybreak.Installer/Daybreak.Installer.csproj -c $env:Configuration
+
+      - name: Run tests
+        run: dotnet test Daybreak.Tests/Daybreak.Tests.csproj -c $env:Configuration
+
+  build-linux:
+    runs-on: ubuntu-latest
+
+    env:
+      Configuration: Debug
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: Install .NET
+        uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: "10.x"
+
+      - name: Build Linux project
+        run: dotnet build Daybreak.Linux/Daybreak.Linux.csproj -c $Configuration
+
+      - name: Build Installer (linux-x64)
+        run: dotnet build Daybreak.Installer/Daybreak.Installer.csproj -c $Configuration

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,87 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  pull_request:
+    branches: [ "master" ]
+  schedule:
+    - cron: '41 12 * * 6'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: windows-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'csharp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    env:
+      Configuration: Release
+      Solution_Path: Daybreak.slnx
+      Test_Project_Path: Daybreak.Tests\Daybreak.Tests.csproj
+      Wpf_Project_Path: Daybreak.Windows\Daybreak.Windows.csproj
+      Actions_Allow_Unsecure_Commands: true
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v6
+      with:
+        fetch-depth: 0
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v5
+      with:
+        dotnet-version: '10.x'
+
+    #- name: Autobuild
+    #  uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Build Daybreak project
+      run: dotnet build Daybreak.Windows -c $env:Configuration --property:SolutionDir=$env:GITHUB_WORKSPACE
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3

.github/workflows/create-build-release-branch.yml

@@ -0,0 +1,12 @@
+# Manually trigger to create a new release branch with bumped build version
+name: Create Build Release Branch
+
+on:
+  workflow_dispatch:
+
+jobs:
+  create-release:
+    uses: ./.github/workflows/create-release-branch-template.yml
+    with:
+      versionBump: "*.*.^.0"
+    secrets: inherit

.github/workflows/create-major-release-branch.yml

@@ -0,0 +1,12 @@
+# Manually trigger to create a new release branch with bumped major version
+name: Create Major Release Branch
+
+on:
+  workflow_dispatch:
+
+jobs:
+  create-release:
+    uses: ./.github/workflows/create-release-branch-template.yml
+    with:
+      versionBump: "^.0.0.0"
+    secrets: inherit

.github/workflows/create-minor-release-branch.yml

@@ -0,0 +1,12 @@
+# Manually trigger to create a new release branch with bumped minor version
+name: Create Minor Release Branch
+
+on:
+  workflow_dispatch:
+
+jobs:
+  create-release:
+    uses: ./.github/workflows/create-release-branch-template.yml
+    with:
+      versionBump: "*.^.0.0"
+    secrets: inherit

.github/workflows/create-release-branch-template.yml

@@ -0,0 +1,66 @@
+# Reusable template for creating release branches with version bumps
+name: Create Release Branch Template
+
+on:
+  workflow_call:
+    inputs:
+      versionBump:
+        description: "Version bump command: bump-major, bump-minor, bump-build, bump-revision"
+        required: true
+        type: string
+
+jobs:
+  create-release-branch:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.RELEASE_PAT }}
+
+      - name: Configure Git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Bump version in Directory.Build.props
+        id: bump
+        uses: vers-one/dotnet-project-version-updater@v1.7
+        with:
+          file: "Directory.Build.props"
+          version: ${{ inputs.versionBump }}
+
+      - name: Check if release branch already exists
+        id: check_branch
+        run: |
+          branch_name="release/${{ steps.bump.outputs.newVersion }}"
+          if git ls-remote --heads origin "$branch_name" | grep -q "$branch_name"; then
+            echo "Branch $branch_name already exists"
+            echo "exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "Branch $branch_name does not exist"
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create release branch
+        if: steps.check_branch.outputs.exists == 'false'
+        run: |
+          new_version="${{ steps.bump.outputs.newVersion }}"
+          branch_name="release/$new_version"
+          
+          # Create new branch from master
+          git checkout -b "$branch_name"
+          
+          # Commit the version change (already updated by the action)
+          git add Directory.Build.props
+          git commit -m "Bump version to $new_version"
+          
+          # Push the new branch
+          git push origin "$branch_name"
+          
+          echo "✅ Created release branch: $branch_name with version $new_version"

.github/workflows/create-revision-release-branch.yml

@@ -0,0 +1,20 @@
+# Automatically creates a new release branch with bumped revision
+# after a successful CD pipeline run on master
+name: Create Revision Release Branch
+
+on:
+  workflow_run:
+    workflows: ["Daybreak CD Pipeline"]
+    types:
+      - completed
+    branches:
+      - master
+
+jobs:
+  create-release:
+    # Only run if the CD pipeline succeeded
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    uses: ./.github/workflows/create-release-branch-template.yml
+    with:
+      versionBump: bump-revision
+    secrets: inherit

.github/workflows/label-merged-issues.yaml

@@ -0,0 +1,47 @@
+name: Label Merged Issues
+
+on:
+  pull_request:
+    types: [closed]
+    branches:
+      - 'release/**'
+
+jobs:
+  label-issues:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Label linked issues as merged
+        uses: actions/github-script@v8
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const prBody = context.payload.pull_request.body || '';
+            const prTitle = context.payload.pull_request.title || '';
+
+            // Match issue references like #123, fixes #123, closes #123, resolves #123
+            const issuePattern = /(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)?[\s:]*#(\d+)/gi;
+            const issueNumbers = new Set();
+
+            // Search in PR body and title
+            const textToSearch = `${prTitle} ${prBody}`;
+            let match;
+            while ((match = issuePattern.exec(textToSearch)) !== null) {
+              issueNumbers.add(parseInt(match[1]));
+            }
+
+            // Apply 'merged' label to each linked issue
+            for (const issueNumber of issueNumbers) {
+              try {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issueNumber,
+                  labels: ['merged']
+                });
+                console.log(`Added 'merged' label to issue #${issueNumber}`);
+              } catch (error) {
+                console.log(`Failed to label issue #${issueNumber}: ${error.message}`);
+              }
+            }

.github/workflows/version_check.yaml

@@ -0,0 +1,55 @@
+name: Daybreak Version Check
+
+on:
+  pull_request:
+    branches:
+      - master
+    paths:
+      - "Daybreak.Core/**"
+      - "Daybreak.Installer/**"
+      - "Daybreak.API/**"
+      - "Daybreak.Shared/**"
+      - "Daybreak.Windows/**"
+      - "Daybreak.Linux/**"
+
+jobs:
+  check_version:
+    strategy:
+      matrix:
+        targetplatform: [x64]
+
+    runs-on: ubuntu-latest
+
+    env:
+      Configuration: Release
+      Solution_Path: Daybreak.slnx
+      Actions_Allow_Unsecure_Commands: true
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Install .NET Core
+        uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: "10.x"
+
+      - name: Get Latest Tag
+        id: getLatestTag
+        uses: WyriHaximus/github-action-get-previous-tag@v2
+
+      - name: Build Daybreak project
+        run: dotnet build Daybreak.Linux -c $Configuration --property:SolutionDir=$GITHUB_WORKSPACE
+
+      - name: Get version
+        id: get_version
+        run: |
+          version=$(grep '<Version>' Directory.Build.props | sed 's/.*<Version>\(.*\)<\/Version>.*/\1/')
+          echo "version=$version" >> $GITHUB_OUTPUT
+
+      - name: Check version difference
+        run: pwsh ./Scripts/CompareVersions.ps1 -currentVersion ${{ steps.get_version.outputs.version }} -lastVersion ${{ steps.getLatestTag.outputs.tag }}
+        shell: pwsh
+

.gitignore

@@ -9,6 +9,7 @@
 *.user
 *.userosscache
 *.sln.docstates
+*.version
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
@@ -27,6 +28,7 @@ x86/
 [Aa][Rr][Mm]/
 [Aa][Rr][Mm]64/
 bld/
+build/
 [Bb]in/
 [Oo]bj/
 [Oo]ut/
@@ -360,4 +362,8 @@ MigrationBackup/
 .ionide/
 
 # Fody - auto-generated XML schema
-FodyWeavers.xsd
+FodyWeavers.xsd
+
+.idea
+
+Daybreak/wwwroot/wiki/*

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "Daybreak.wiki"]
+	path = Daybreak.wiki
+	url = https://github.com/gwdevhub/Daybreak.wiki.git

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug Daybreak.Linux",
+            "type": "dotnet",
+            "request": "launch",
+            "projectPath": "${workspaceFolder}/Daybreak.Linux/Daybreak.Linux.csproj"
+        },
+        {
+            "name": "Debug Daybreak.Windows",
+            "type": "dotnet",
+            "request": "launch",
+            "projectPath": "${workspaceFolder}/Daybreak.Windows/Daybreak.Windows.csproj"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,29 @@
+{
+  "dotnet.defaultSolution": "Daybreak.slnx",
+  "omnisharp.projectLoadTimeout": 120,
+  "csharp.semanticHighlighting.enabled": true,
+  "search.followSymlinks": false,
+  "search.exclude": {
+    "**/.git": true,
+    "**/.vs": true,
+    "**/bin": true,
+    "**/obj": true,
+    "**/node_modules": true,
+    "**/.idea": true,
+    "**/Publish": true,
+  },
+  "files.watcherExclude": {
+    "**/.git/**": true,
+    "**/.vs/**": true,
+    "**/bin/**": true,
+    "**/obj/**": true,
+    "**/node_modules/**": true,
+    "**/Publish": true,
+  },
+  "files.exclude": {
+    "**/.vs": true,
+    "**/bin": true,
+    "**/obj": true,
+    "**/Publish": true
+  }
+}

.vscode/tasks.json

@@ -0,0 +1,29 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build-linux",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/Daybreak.Linux/Daybreak.Linux.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "build-windows",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/Daybreak.Windows/Daybreak.Windows.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

Daybreak.API/Configuration/BuildInfo.cs

@@ -0,0 +1,11 @@
+namespace Daybreak.API.Configuration;
+
+public static class BuildInfo
+{
+    public const string Configuration =
+#if DEBUG
+            "Debug";
+#else
+            "Release";
+#endif
+}

Daybreak.API/Configuration/WebApplicationBuilderExtensions.cs

@@ -0,0 +1,31 @@
+namespace Daybreak.API.Configuration;
+
+public static class WebApplicationBuilderExtensions
+{
+    public static WebApplicationBuilder WithConfiguration(this WebApplicationBuilder builder)
+    {
+        var config = BuildInfo.Configuration;
+        var appSettingsStream = GetManifestResourceStream($"Daybreak.API.Configuration.appsettings.json") ?? throw new InvalidOperationException("Failed to load appsettings.json");
+        var appSettingsConfigStream = GetManifestResourceStream($"Daybreak.API.Configuration.appsettings.{config}.json") ?? throw new InvalidOperationException($"Failed to load appsettings.{config}.json");
+        builder.Configuration
+            .AddJsonStream(appSettingsStream)
+            .AddJsonStream(appSettingsConfigStream)
+            .AddEnvironmentVariables();
+
+        builder.WebHost.UseSetting(WebHostDefaults.PreventHostingStartupKey, "true");
+        return builder;
+    }
+
+    private static Stream? GetManifestResourceStream(string name)
+    {
+        var assembly = typeof(WebApplicationBuilderExtensions).Assembly;
+        var resourceName = assembly.GetManifestResourceNames()
+            .FirstOrDefault(n => n.EndsWith(name, StringComparison.OrdinalIgnoreCase));
+        if (resourceName is null)
+        {
+            return default;
+        }
+
+        return assembly.GetManifestResourceStream(resourceName);
+    }
+}

Daybreak.API/Configuration/appsettings.Debug.json

@@ -0,0 +1,2 @@
+{
+}

Daybreak.API/Configuration/appsettings.Release.Debug.json

@@ -0,0 +1,10 @@
+{
+  "Logging": {
+    "MinimumLevel": {
+      "Default": "Debug",
+      "Override": {
+        "Microsoft": "Warning"
+      }
+    }
+  }
+}

Daybreak.API/Configuration/appsettings.Release.json

@@ -0,0 +1,2 @@
+{
+}

Daybreak.API/Configuration/appsettings.json

@@ -0,0 +1,13 @@
+{
+  "Logging": {
+    "MinimumLevel": {
+      "Default": "Debug",
+      "Override": {
+        "Microsoft": "Debug"
+      }
+    }
+  },
+  "Correlation": {
+    "Header": "X-Correlation-Vector"
+  }
+}

Daybreak.API/Controllers/Rest/CharacterSelectController.cs

@@ -0,0 +1,51 @@
+using System.Core.Extensions;
+using Daybreak.API.Interop.GuildWars;
+using Daybreak.API.Services;
+using Daybreak.Shared.Models.Api;
+using Microsoft.AspNetCore.Mvc;
+using Net.Sdk.Web;
+
+namespace Daybreak.API.Controllers.Rest;
+
+[GenerateController("api/v1/rest/character-select")]
+[Tags("Character Select")]
+public sealed class CharacterSelectController(
+    CharacterSelectService characterSelectService)
+{
+    private readonly CharacterSelectService characterSelectService = characterSelectService.ThrowIfNull();
+
+    [GenerateGet]
+    [EndpointName("GetCharacterSelectInformation")]
+    [EndpointSummary("Get Character Select Information")]
+    [EndpointDescription("Get the character select information for the current player. Returns a serialized CharacterSelectInformation object")]
+    [ProducesResponseType<CharacterSelectInformation>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetCharacterSelectInformation(
+        CancellationToken cancellationToken)
+    {
+        var characterSelectInfo = await this.characterSelectService.GetCharacterSelectInformation(cancellationToken);
+        return characterSelectInfo is null ?
+            Results.StatusCode(StatusCodes.Status503ServiceUnavailable) :
+            Results.Ok(characterSelectInfo);
+    }
+
+    [GeneratePost("{identifier}")]
+    [EndpointName("ChangeCharacter")]
+    [EndpointSummary("Change Character by identifier")]
+    [EndpointDescription("Logs out from the current character and tries to log in with the desired character. Identifier can be either uuid or character name")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> ChangeCharacter(
+        [FromRoute] string identifier,
+        CancellationToken cancellationToken)
+    {
+        var isUuid = Uuid.TryParse(identifier, out _);
+        var result = isUuid
+            ? await this.characterSelectService.ChangeCharacterByUuid(identifier, cancellationToken)
+            : await this.characterSelectService.ChangeCharacterByName(identifier, cancellationToken);
+        return result ?
+            Results.Ok() :
+            Results.StatusCode(StatusCodes.Status500InternalServerError);
+    }
+}

Daybreak.API/Controllers/Rest/InventoryController.cs

@@ -0,0 +1,28 @@
+using Daybreak.API.Services;
+using Daybreak.Shared.Models.Api;
+using Microsoft.AspNetCore.Mvc;
+using Net.Sdk.Web;
+
+namespace Daybreak.API.Controllers.Rest;
+
+[GenerateController("api/v1/rest/inventory")]
+[Tags("Inventory")]
+public sealed class InventoryController(
+    InventoryService inventoryService)
+{
+    private readonly InventoryService inventoryService = inventoryService;
+
+    [GenerateGet]
+    [EndpointName("GetInventory")]
+    [EndpointSummary("Get Inventory information")]
+    [EndpointDescription("Get the inventory of the current player. Returns a serialized InventoryInformation object")]
+    [ProducesResponseType<InventoryInformation>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetInventory(CancellationToken cancellationToken)
+    {
+        var inventoryInformation = await this.inventoryService.GetInventoryInformation(cancellationToken);
+        return inventoryInformation is null ?
+            Results.StatusCode(StatusCodes.Status503ServiceUnavailable) :
+            Results.Ok(inventoryInformation);
+    }
+}

Daybreak.API/Controllers/Rest/LoginController.cs

@@ -0,0 +1,30 @@
+using System.Core.Extensions;
+using Daybreak.API.Services;
+using Daybreak.Shared.Models.Api;
+using Microsoft.AspNetCore.Mvc;
+using Net.Sdk.Web;
+
+namespace Daybreak.API.Controllers.Rest;
+
+[GenerateController("api/v1/rest/login")]
+[Tags("Login")]
+public sealed class LoginController(
+    LoginService loginService)
+{
+    private readonly LoginService loginService = loginService.ThrowIfNull();
+
+    [GenerateGet]
+    [EndpointName("GetLoginInfo")]
+    [EndpointSummary("Get Login Information")]
+    [EndpointDescription("Get the current login information. Returns a serialized LoginInfo object")]
+    [ProducesResponseType<LoginInfo>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetLoginInfo(
+        CancellationToken cancellationToken)
+    {
+        var loginInfo = await this.loginService.GetLoginInformation(cancellationToken);
+        return loginInfo is null ?
+            Results.StatusCode(StatusCodes.Status503ServiceUnavailable) :
+            Results.Ok(loginInfo);
+    }
+}

Daybreak.API/Controllers/Rest/MainPlayerController.cs

@@ -0,0 +1,114 @@
+using System.Core.Extensions;
+using Daybreak.API.Services;
+using Daybreak.Shared.Models.Api;
+using Microsoft.AspNetCore.Mvc;
+using Net.Sdk.Web;
+
+namespace Daybreak.API.Controllers.Rest;
+
+[GenerateController("api/v1/rest/main-player")]
+[Tags("Main Player")]
+public sealed class MainPlayerController(
+    MainPlayerService mainPlayerService,
+    ILogger<MainPlayerController> logger)
+{
+    private readonly MainPlayerService mainPlayerService = mainPlayerService.ThrowIfNull();
+    private readonly ILogger<MainPlayerController> logger = logger.ThrowIfNull();
+
+    [GenerateGet("state")]
+    [EndpointName("GetMainPlayerState")]
+    [EndpointSummary("Get the current MainPlayerState")]
+    [EndpointDescription("Get the current MainPlayerState. Returns a json serialized MainPlayerState object. You can use the websocket endpoint to subscribe to MainPlayerState updates on each game thread proc")]
+    [ProducesResponseType<MainPlayerState>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetMainPlayerState(CancellationToken cancellationToken)
+    {
+        var mainPlayerState = await this.mainPlayerService.GetMainPlayerState(cancellationToken);
+        return mainPlayerState is not null ? Results.Ok(mainPlayerState) : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+
+    [GenerateGet("quest-log")]
+    [EndpointName("GetQuestLog")]
+    [EndpointSummary("Get the current Quest Log")]
+    [EndpointDescription("Get the current Quest Log. Returns a json serialized QuestLogInformation object")]
+    [ProducesResponseType<QuestLogInformation>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetQuestLog(CancellationToken cancellationToken)
+    {
+        var questLog = await this.mainPlayerService.GetQuestLog(cancellationToken);
+        return questLog is not null ? Results.Ok(questLog) : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+
+    [GenerateGet("info")]
+    [EndpointName("GetMainPlayerInformation")]
+    [EndpointSummary("Get the current MainPlayerInformation")]
+    [EndpointDescription("Get the current MainPlayerInformation. Returns a json serialized MainPlayerInformation object")]
+    [ProducesResponseType<MainPlayerInformation>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetMainPlayerInformation(CancellationToken cancellationToken)
+    {
+        var mainPlayerInformation = await this.mainPlayerService.GetMainPlayerInformation(cancellationToken);
+        return mainPlayerInformation is not null ? Results.Ok(mainPlayerInformation) : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+
+    [GenerateGet("build")]
+    [EndpointName("GetMainPlayerBuild")]
+    [EndpointSummary("Get the current build")]
+    [EndpointDescription("Get the current build. Returns a json serialized BuildEntry object")]
+    [ProducesResponseType<BuildEntry>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetMainPlayerBuild(CancellationToken cancellationToken)
+    {
+        var build = await this.mainPlayerService.GetCurrentBuild(cancellationToken);
+        return build is not null ? Results.Ok(build) : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+
+    [GeneratePost("build")]
+    [EndpointName("SetMainPlayerBuild")]
+    [EndpointSummary("Set the current build")]
+    [EndpointDescription("Set the current build. Returns 200 is the operation has succeeded")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> SetMainPlayerBuild([FromQuery(Name = "code")] string? code, CancellationToken cancellationToken)
+    {
+        var result = await this.mainPlayerService.SetCurrentBuild(code ?? string.Empty, cancellationToken);
+        return result ? Results.Ok() : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+
+    [GenerateGet("instance-info")]
+    [EndpointName("GetMainPlayerInstanceInfo")]
+    [EndpointSummary("Get the current instance info")]
+    [EndpointDescription("Get the current instance info. Returns a json serialized MainPlayerInstanceInfo object")]
+    [ProducesResponseType<InstanceInfo>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetMainPlayerInstanceInfo(CancellationToken cancellationToken)
+    {
+        var instanceInfo = await this.mainPlayerService.GetMainPlayerInstance(cancellationToken);
+        return instanceInfo is not null ? Results.Ok(instanceInfo) : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+
+    [GenerateGet("title")]
+    [EndpointName("GetMainPlayerTitleInfo")]
+    [EndpointSummary("Get the current title info")]
+    [EndpointDescription("Get the current title info. Returns a json serialized TitleInfo object")]
+    [ProducesResponseType<TitleInfo>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetMainPlayerTitleInfo(CancellationToken cancellationToken)
+    {
+        var titleInfo = await this.mainPlayerService.GetTitleInfo(cancellationToken);
+        return titleInfo is not null ? Results.Ok(titleInfo) : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+
+    [GenerateGet("build-context")]
+    [EndpointName("GetMainPlayerBuildContext")]
+    [EndpointSummary("Get the current build context")]
+    [EndpointDescription("Get the current build context. Returns a json serialized MainPlayerBuildContext object")]
+    [ProducesResponseType<BuildEntry>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetMainPlayerBuildContext(CancellationToken cancellationToken)
+    {
+        var context = await this.mainPlayerService.GetMainPlayerBuildContext(cancellationToken);
+        return context is not null ? Results.Ok(context) : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+}

Daybreak.API/Controllers/Rest/PartyController.cs

@@ -0,0 +1,38 @@
+using Daybreak.API.Services;
+using Daybreak.Shared.Models.Api;
+using Microsoft.AspNetCore.Mvc;
+using Net.Sdk.Web;
+
+namespace Daybreak.API.Controllers.Rest;
+
+[GenerateController("api/v1/rest/party")]
+[Tags("Party")]
+public sealed class PartyController(PartyService partyService)
+{
+    private readonly PartyService partyService = partyService;
+
+    [GenerateGet("loadout")]
+    [EndpointName("GetPartyLoadout")]
+    [EndpointSummary("Get the current party loadout")]
+    [EndpointDescription("Get the current party loadout. Returns a json serialized PartyLoadout object")]
+    [ProducesResponseType<PartyLoadout>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> GetPartyLoadout(
+        CancellationToken cancellationToken)
+    {
+        var partyLoadout = await this.partyService.GetPartyLoadout(cancellationToken);
+        return partyLoadout is not null ? Results.Ok(partyLoadout) : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+
+    [GeneratePost("loadout")]
+    [EndpointName("SetPartyLoadout")]
+    [EndpointSummary("Set the current party loadout")]
+    [EndpointDescription("Set the current party loadout")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+    public async Task<IResult> SetPartyLoadout([FromBody] PartyLoadout partyLoadout, CancellationToken cancellationToken)
+    {
+        var result = await this.partyService.SetPartyLoadout(partyLoadout, cancellationToken);
+        return result ? Results.Ok() : Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+    }
+}

Daybreak.API/Controllers/WebSocket/MainPlayer/MainPlayerStateRoute.cs

@@ -0,0 +1,67 @@
+using System.Buffers;
+using System.Core.Extensions;
+using System.Extensions.Core;
+using System.Net.WebSockets;
+using Daybreak.API.Models;
+using Daybreak.API.Services;
+using Daybreak.API.WebSockets;
+using Daybreak.Shared.Models.Api;
+
+namespace Daybreak.API.Controllers.WebSocket.MainPlayer;
+
+public sealed class MainPlayerStateRoute(
+    MainPlayerService mainPlayerStateService,
+    ChatService chatService,
+    ILogger<MainPlayerStateRoute> logger)
+        : UpdateWebSocketRoute
+{
+    private const int DefaultFrequency = 1000;
+
+    private readonly MainPlayerService mainPlayerStateService = mainPlayerStateService.ThrowIfNull();
+    private readonly ChatService chatService = chatService.ThrowIfNull();
+    private readonly ILogger<MainPlayerStateRoute> logger = logger.ThrowIfNull();
+
+    private CallbackRegistration? mainPlayerStateRegistration;
+
+    protected override int BufferSize => 256;
+
+    public override Task ExecuteAsync(WebSocketMessageType type, ReadOnlySequence<byte> data, CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+
+    public override async Task SocketAccepted(CancellationToken cancellationToken)
+    {
+        var scopedLogger = this.logger.CreateScopedLogger();
+        if (!int.TryParse(this.Context?.Request.Query["f"].FirstOrDefault(), out var freq))
+        {
+            freq = DefaultFrequency;
+        }
+
+        var freqTimeSpan = TimeSpan.FromMilliseconds(freq);
+        scopedLogger.LogInformation("WebSocket accepted {id} with frequency {frequency}", this.Context?.Connection.Id ?? string.Empty, freqTimeSpan);
+
+        this.mainPlayerStateRegistration = this.mainPlayerStateService.RegisterMainStateConsumer(freqTimeSpan, this.SendUpdate);
+
+        await this.chatService.AddMessageAsync(
+            message: $"{nameof(MainPlayerState)} subscriber added: {this.Context?.Connection.RemoteIpAddress?.ToString()}:{this.Context?.Connection.RemotePort} with frequency {freq}ms",
+            sender: "Daybreak.API",
+            channel: Channel.Whisper,
+            cancellationToken: cancellationToken);
+    }
+
+    public override async Task SocketClosed()
+    {
+        var scopedLogger = this.logger.CreateScopedLogger();
+
+        this.mainPlayerStateRegistration?.Dispose();
+        this.mainPlayerStateRegistration = default;
+
+        scopedLogger.LogInformation("WebSocket closed {id}", this.Context?.Connection.Id ?? string.Empty);
+        await this.chatService.AddMessageAsync(
+            message: $"{nameof(MainPlayerState)} subscriber removed: {this.Context?.Connection.RemoteIpAddress?.ToString()}:{this.Context?.Connection.RemotePort}",
+            sender: "Daybreak.API",
+            channel: Channel.Whisper,
+            cancellationToken: CancellationToken.None);
+    }
+}

Daybreak.API/Converters/PointerValueConverter.cs

@@ -0,0 +1,19 @@
+using Daybreak.API.Interop;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Daybreak.API.Converters;
+
+public sealed class PointerValueConverter : JsonConverter<PointerValue>
+{
+    public override PointerValue Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var s = reader.GetString() ?? throw new JsonException("Expected string");
+        return PointerValue.Parse(s);
+    }
+
+    public override void Write(Utf8JsonWriter writer, PointerValue value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}

Daybreak.API/Daybreak.API.csproj

@@ -0,0 +1,83 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>$(TargetFrameworkVersionWindows)</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <OutputType>Library</OutputType>
+    <RuntimeIdentifier Condition="'$(RuntimeIdentifier)' == ''">win-x86</RuntimeIdentifier>
+    <StripSymbols>true</StripSymbols>
+    <InteropExports>true</InteropExports>
+    <EnableRequestDelegateGenerator>true</EnableRequestDelegateGenerator>
+    
+    <PublishAot>true</PublishAot>
+    <SelfContained>true</SelfContained>
+
+    <AspNetCoreHostingModel>OutOfProcess</AspNetCoreHostingModel>
+    <UseAppHost>false</UseAppHost>
+    <EnableIISSupport>false</EnableIISSupport>
+    <InvariantGlobalization>true</InvariantGlobalization>
+    <AllowMissingPrunePackageData>true</AllowMissingPrunePackageData>
+    <Platforms>x86</Platforms>
+    
+    <!-- Prevent static web asset conflicts -->
+    <StaticWebAssetProjectMode>Default</StaticWebAssetProjectMode>
+    <GenerateStaticWebAssetsManifest>false</GenerateStaticWebAssetsManifest>
+    <ResolveStaticWebAssetsInputsDependsOn>RemoveDuplicateStaticWebAssets;$(ResolveStaticWebAssetsInputsDependsOn)</ResolveStaticWebAssetsInputsDependsOn>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
+    <DebugType>none</DebugType>
+    <DebugSymbols>false</DebugSymbols>
+  </PropertyGroup>
+
+  <!-- Remove duplicate static web assets coming from referenced projects -->
+  <Target Name="RemoveDuplicateStaticWebAssets" BeforeTargets="ResolveStaticWebAssetsInputs;GenerateStaticWebAssetsManifest">
+    <ItemGroup>
+      <!-- Remove all blazor webview static assets since this is a Web API project, not a Blazor Hybrid app -->
+      <StaticWebAsset Remove="@(StaticWebAsset)" 
+                      Condition="$([System.String]::new('%(RelativePath)').Contains('blazor.modules')) Or $([System.String]::new('%(RelativePath)').Contains('blazor.webview'))" />
+    </ItemGroup>
+  </Target>
+
+  <PropertyGroup>
+    <!--Ignore trim warnings. NativeAOT support is still experimental so it should be tested with a Publish build generated from Daybreak build-->
+    <NoWarn>IL2104</NoWarn>
+    <NoWarn>IL3053</NoWarn>
+    <!--MinHook.NET does not contain sources for .NET, only .Net Framework. This has no impact on the functionality of the project-->
+    <NoWarn>NU1701</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="Configuration\appsettings.Debug.json" />
+    <EmbeddedResource Include="Configuration\appsettings.json" />
+    <EmbeddedResource Include="Configuration\appsettings.Release.json" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <RdXmlFile Include="rd.xml" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" />
+    <PackageReference Include="MinHook.NET" />
+    <PackageReference Include="Net.Sdk.Web.Extensions" />
+    <PackageReference Include="Net.Sdk.Web.Extensions.SourceGenerators" />
+    <PackageReference Include="PeNet" />
+    <PackageReference Include="Serilog" />
+    <PackageReference Include="Serilog.Extensions.Logging" />
+    <PackageReference Include="Serilog.Settings.Configuration" />
+    <PackageReference Include="Serilog.Sinks.Console" />
+    <PackageReference Include="Serilog.Sinks.File" />
+    <PackageReference Include="Swashbuckle.AspNetCore" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Swagger" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" />
+    <PackageReference Include="SystemExtensions.NetStandard.Generators" PrivateAssets="all" />
+    <PackageReference Include="ZLinq" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Daybreak.Shared\Daybreak.Shared.csproj" />
+  </ItemGroup>
+</Project>

Daybreak.API/EntryPoint.cs

@@ -0,0 +1,176 @@
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Extensions.Core;
+using System.Net.NetworkInformation;
+using System.Runtime.InteropServices;
+using Daybreak.API.Configuration;
+using Daybreak.API.Extensions;
+using Daybreak.API.Health;
+using Daybreak.API.Hosting;
+using Daybreak.API.Logging;
+using Daybreak.API.Serialization;
+using Daybreak.API.Services;
+using Daybreak.API.Swagger;
+using Daybreak.API.WebSockets;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Net.Sdk.Web;
+
+namespace Daybreak.API;
+
+public class EntryPoint
+{
+    private const int StartPort = 5080;
+    private static readonly TimeSpan InitializationTimeout = TimeSpan.FromSeconds(5);
+    private static readonly CancellationTokenSource CancellationTokenSource = new();
+
+    [UnmanagedCallersOnly(EntryPoint = "ThreadInit"), STAThread]
+    [RequiresUnreferencedCode("The handler uses a static method that gets referenced, so there's no unreferenced code to worry about")]
+    [RequiresDynamicCode("The handler uses a static method, so there's no dynamic code to worry about")]
+    [SuppressMessage("Trimming", "IL2123:The use of 'RequiresUnreferencedCodeAttribute' on entry points is disallowed since the method will be called from outside the visible app.", Justification = "<Pending>")]
+    [SuppressMessage("AOT", "IL3057:The use of 'RequiresDynamicCodeAttribute' on entry points is disallowed since the method will be called from outside the visible app.", Justification = "<Pending>")]
+    public static int ThreadInit(IntPtr _, int __)
+    {
+        Environment.SetEnvironmentVariable("ASPNETCORE_HOSTINGSTARTUPASSEMBLIES", null, EnvironmentVariableTarget.Process);
+        Environment.SetEnvironmentVariable("ASPNETCORE_PREVENTHOSTINGSTARTUP", "true", EnvironmentVariableTarget.Process);
+#if DEBUG
+        ConsoleExtensions.AllocateAnsiConsole();
+#endif
+        var port = FindAvailablePort(StartPort);
+        var app = CreateApplication(port);
+        var runTask = Task.Run(() => StartServer(app), CancellationTokenSource.Token);
+        var scopedLogger = app.Services.GetRequiredService<ILogger<EntryPoint>>().CreateScopedLogger();
+        var healthCheck = app.Services.GetRequiredService<HealthCheckService>();
+        var sw = Stopwatch.StartNew();
+        var healthy = false;
+        while (sw.Elapsed < InitializationTimeout)
+        {
+            var status = Task.Run(() => healthCheck.CheckHealthAsync()).Result;
+            scopedLogger.LogWarning("HealthCheck status: {status} in {duration}. Report: {report}", status.Status, status.TotalDuration, string.Join("\n", status.Entries.Select(e => $"{e.Key}: {e.Value.Status}")));
+            if (status.Status is HealthStatus.Healthy)
+            {
+                healthy = true;
+                break;
+            }
+            else
+            {
+                Thread.Sleep(100);
+            }
+        }
+
+        if (healthy)
+        {
+            scopedLogger.LogInformation("Daybreak API is healthy on port {port}. Initialization succeeded in {duration}", port, sw.Elapsed);
+            return port;
+        }
+        else
+        {
+            scopedLogger.LogError("Daybreak API failed to initialize in {duration}", sw.Elapsed);
+            CancellationTokenSource.Cancel();
+            return -1;
+        }
+    }
+
+    [RequiresUnreferencedCode("The handler uses a static method that gets referenced, so there's no unreferenced code to worry about")]
+    [RequiresDynamicCode("The handler uses a static method, so there's no dynamic code to worry about")]
+    private static WebApplication CreateApplication(int port)
+    {
+        var builder = WebApplication.CreateBuilder()
+                .WithConfiguration()
+                .WithHosting(port)
+                .WithSwagger()
+                .WithSerializationContext()
+                .WithLogging()
+                .WithDaybreakServices()
+                .WithWebSocketRoutes()
+                .WithRoutes()
+                .WithHealthChecks();
+
+        builder.Services.AddOpenApi();
+
+        // Add CORS policy - allow localhost and trusted community sites
+        builder.Services.AddCors(options =>
+        {
+            options.AddDefaultPolicy(policy =>
+            {
+                policy.SetIsOriginAllowed(origin =>
+                    {
+                        if (Uri.TryCreate(origin, UriKind.Absolute, out var uri))
+                        {
+                            // Always allow localhost
+                            if (uri.Host is "localhost" or "127.0.0.1")
+                            {
+                                return true;
+                            }
+
+                            // Allow known Guild Wars community sites
+                            return uri.Host.EndsWith("guildwars.app", StringComparison.OrdinalIgnoreCase)
+                                || uri.Host.EndsWith("gwmarket.net", StringComparison.OrdinalIgnoreCase);
+                        }
+
+                        return false;
+                    })
+                    .AllowAnyHeader()
+                    .AllowAnyMethod()
+                    .AllowCredentials();
+            });
+        });
+
+        var app = builder.Build();
+
+        app.UseCors();
+        app.UseWebSockets(new WebSocketOptions { KeepAliveInterval = TimeSpan.FromSeconds(30) });
+
+        return app
+            .UseHealthChecks()
+            .UseLogging()
+            .UseRoutes()
+            .UseWebSocketRoutes()
+            .UseSwaggerWithUI();
+
+    }
+
+    private static async Task StartServer(WebApplication app)
+    {
+        try
+        {
+            await app.RunAsync();
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine(ex);
+        }
+    }
+
+    private static int FindAvailablePort(int startPort)
+    {
+        var port = startPort;
+        while (!IsPortAvailable(port))
+        {
+            port++;
+            if (port > 65535 || port < 0)
+            {
+                return -1;
+            }
+        }
+
+        return port;
+    }
+
+    private static bool IsPortAvailable(int port)
+    {
+        var ipProperties = IPGlobalProperties.GetIPGlobalProperties();
+        var tcpListeners = ipProperties.GetActiveTcpListeners();
+        if (tcpListeners.Any(endpoint => endpoint.Port == port))
+        {
+            return false;
+        }
+
+        var tcpConnections = ipProperties.GetActiveTcpConnections();
+        if (tcpConnections.Any(conn => conn.LocalEndPoint.Port == port))
+        {
+            return false;
+        }
+
+        return true;
+    }
+}

Daybreak.API/Extensions/AttributeContextExtensions.cs

@@ -0,0 +1,17 @@
+using Daybreak.API.Interop.GuildWars;
+using Daybreak.Shared.Models.Api;
+using ZLinq;
+
+namespace Daybreak.API.Extensions;
+
+public static class AttributeContextExtensions
+{
+    public static List<AttributeEntry> GetAttributeEntryList(this AttributeContext[] attributes)
+    {
+        return attributes
+                .AsValueEnumerable()
+                .Take(45) // There are only 45 maximum attributes in game
+                .Where(a => a.LevelBase > 0 && a.Level >= a.LevelBase) // Select only attributes with points in them
+                .Select(a => new AttributeEntry(a.Id, a.LevelBase, a.Level)).ToList();
+    }
+}

Daybreak.API/Extensions/ConsoleExtensions.cs

@@ -0,0 +1,19 @@
+namespace Daybreak.API.Extensions;
+
+public static class ConsoleExtensions
+{
+    public static void AllocateAnsiConsole()
+    {
+        NativeMethods.AllocConsole();
+        var handle = NativeMethods.GetStdHandle(NativeMethods.STD_OUTPUT_HANDLE);
+        if (!NativeMethods.GetConsoleMode(handle, out var mode))
+        {
+            Console.WriteLine("Failed to get console mode");
+        }
+
+        if (!NativeMethods.SetConsoleMode(handle, mode | NativeMethods.ENABLE_VIRTUAL_TERMINAL_PROCESSING | NativeMethods.ENABLE_PROCESSED_OUTPUT))
+        {
+            Console.WriteLine("Failed to enable virtual terminal processing");
+        }
+    }
+}

Daybreak.API/Extensions/GameContextExtensions.cs

@@ -0,0 +1,101 @@
+using Daybreak.API.Interop.GuildWars;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Daybreak.API.Extensions;
+
+public static unsafe class GameContextExtensions
+{
+    public static bool TryGetPlayerId(
+        this WrappedPointer<GameContext> gameContext,
+        [NotNullWhen(true)] out uint? playerId)
+    {
+        playerId = 0;
+        if (gameContext.IsNull ||
+            gameContext.Pointer->WorldContext is null ||
+            gameContext.Pointer->WorldContext->PlayerControlledChar is null)
+        {
+            return false;
+        }
+
+        playerId = gameContext.Pointer->WorldContext->PlayerControlledChar->AgentId;
+        return true;
+    }
+
+    public static bool TryGetBuildContext(
+        this WrappedPointer<GameContext> gameContext,
+        [NotNullWhen(true)] out GuildWarsArray<SkillbarContext>? skillbars,
+        [NotNullWhen(true)] out GuildWarsArray<PartyAttribute>? attributes,
+        [NotNullWhen(true)] out GuildWarsArray<ProfessionsContext>? professions,
+        [NotNullWhen(true)] out GuildWarsArray<uint>? unlockedSkills)
+    {
+        skillbars = default;
+        attributes = default;
+        professions = default;
+        unlockedSkills = default;
+        if (gameContext.IsNull ||
+            gameContext.Pointer->WorldContext is null)
+        {
+            return false;
+        }
+
+        skillbars = gameContext.Pointer->WorldContext->Skillbars;
+        attributes = gameContext.Pointer->WorldContext->Attributes;
+        professions = gameContext.Pointer->WorldContext->Professions;
+        unlockedSkills = gameContext.Pointer->WorldContext->UnlockedCharacterSkills;
+        return true;
+    }
+
+    public static bool TryGetPlayerParty(
+        this WrappedPointer<GameContext> gameContext,
+        [NotNullWhen(true)] out uint? partyId,
+        [NotNullWhen(true)] out GuildWarsArray<PlayerPartyMember>? players,
+        [NotNullWhen(true)] out GuildWarsArray<HeroPartyMember>? heroes,
+        [NotNullWhen(true)] out GuildWarsArray<HenchmanPartyMember>? henchmen)
+    {
+        partyId = default;
+        players = default;
+        heroes = default;
+        henchmen = default;
+        if (gameContext.IsNull ||
+            gameContext.Pointer->PartyContext is null)
+        {
+            return false;
+        }
+
+        partyId = gameContext.Pointer->PartyContext->PlayerParty->PartyId;
+        players = gameContext.Pointer->PartyContext->PlayerParty->Players;
+        heroes = gameContext.Pointer->PartyContext->PlayerParty->Heroes;
+        henchmen = gameContext.Pointer->PartyContext->PlayerParty->Henchmen;
+        return true;
+    }
+
+    public static bool TryGetHeroFlags(
+        this WrappedPointer<GameContext> gameContext,
+        [NotNullWhen(true)]out GuildWarsArray<HeroFlag>? heroFlags)
+    {
+        heroFlags = default;
+        if (gameContext.IsNull ||
+            gameContext.Pointer->WorldContext is null)
+        {
+            return false;
+        }
+
+        heroFlags = gameContext.Pointer->WorldContext->HeroFlags;
+        return true;
+    }
+
+    public static bool TryGetAccountContext(
+        this WrappedPointer<GameContext> gameContext,
+        out WrappedPointer<AccountGameContext> accountContext)
+    {
+        accountContext = default;
+        if (gameContext.IsNull ||
+            gameContext.Pointer->AccountContext is null)
+        {
+            return false;
+        }
+
+        accountContext = gameContext.Pointer->AccountContext;
+        return true;
+    }
+}

Daybreak.API/Health/AddressHealthCheck.cs

@@ -0,0 +1,31 @@
+using Daybreak.API.Serialization;
+using Daybreak.API.Services.Interop;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using System.Text.Json;
+using ZLinq;
+
+namespace Daybreak.API.Health;
+
+public sealed class AddressHealthCheck(IEnumerable<IAddressHealthService> addressHealthServices)
+    : IHealthCheck
+{
+    private readonly IEnumerable<IAddressHealthService> addressHealthServices = addressHealthServices;
+
+    public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+    {
+        var states = this.addressHealthServices.AsValueEnumerable().SelectMany(addressService => addressService.GetAddressStates());
+        var healthy = !states.Any(s => s.Address == 0x0);
+        using var statesArray = states.ToArrayPool();
+        var serialized = JsonSerializer.SerializeToElement(statesArray.ArraySegment, ApiJsonSerializerContext.Default.ArraySegmentAddressState);
+        var meta = new Dictionary<string, object>
+        {
+            ["Count"] = statesArray.Size,
+            ["Invalid"] = states.Count(s => s.Address == 0x0),
+            ["States"] = serialized,
+        };
+
+        return Task.FromResult(healthy
+            ? HealthCheckResult.Healthy("Addresses are initialized", meta)
+            : HealthCheckResult.Unhealthy("Addresses are not initialized", data: meta));
+    }
+}

Daybreak.API/Health/HooksHealthCheck.cs

@@ -0,0 +1,31 @@
+using Daybreak.API.Serialization;
+using Daybreak.API.Services.Interop;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using System.Text.Json;
+using ZLinq;
+
+namespace Daybreak.API.Health;
+
+public sealed class HooksHealthCheck(IEnumerable<IHookHealthService> hookHealthServices)
+    : IHealthCheck
+{
+    private readonly IEnumerable<IHookHealthService> hookHealthServices = hookHealthServices;
+
+    public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+    {
+        var states = this.hookHealthServices.AsValueEnumerable().SelectMany(hookService => hookService.GetHookStates());
+        var healthy = !states.Any(s => !s.Hooked);
+        var statesArray = states.ToArrayPool();
+        var serialized = JsonSerializer.SerializeToElement(statesArray.ArraySegment, ApiJsonSerializerContext.Default.ArraySegmentHookState);
+        var meta = new Dictionary<string, object>
+        {
+            ["Count"] = statesArray.Size,
+            ["Unhooked"] = states.Count(s => !s.Hooked),
+            ["States"] = serialized,
+        };
+
+        return Task.FromResult(healthy
+            ? HealthCheckResult.Healthy("Hooks are initialized", meta)
+            : HealthCheckResult.Unhealthy("Hooks are not initialized", data: meta));
+    }
+}

Daybreak.API/Health/WebApplicationBuilderExtensions.cs

@@ -0,0 +1,12 @@
+namespace Daybreak.API.Health;
+
+public static class WebApplicationBuilderExtensions
+{
+    public static WebApplicationBuilder WithHealthChecks(this WebApplicationBuilder builder)
+    {
+        builder.Services.AddHealthChecks()
+            .AddCheck<HooksHealthCheck>(nameof(HooksHealthCheck))
+            .AddCheck<AddressHealthCheck>(nameof(AddressHealthCheck));
+        return builder;
+    }
+}

Daybreak.API/Health/WebApplicationExtensions.cs

@@ -0,0 +1,48 @@
+using Daybreak.API.Models;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using ZLinq;
+
+namespace Daybreak.API.Health;
+
+public static class WebApplicationExtensions
+{
+    [RequiresUnreferencedCode("The handler uses a static method that gets referenced, so there's no unreferenced code to worry about")]
+    [RequiresDynamicCode("The handler uses a static method, so there's no dynamic code to worry about")]
+    public static WebApplication UseHealthChecks(this WebApplication app)
+    {
+        app.MapGet("/api/v1/rest/health", static async (HealthCheckService healthCheckService, CancellationToken cancellationToken) =>
+        {
+            var report = await healthCheckService.CheckHealthAsync(cancellationToken);
+
+            var response = new HealthCheckResponse
+            {
+                ProcessId = Environment.ProcessId,
+                Status = report.Status,
+                TotalDuration = report.TotalDuration,
+                Entries = report.Entries.ToDictionary(
+                    e => e.Key,
+                    e => new HealthCheckEntryResponse
+                    {
+                        Status = e.Value.Status,
+                        Description = e.Value.Description ?? string.Empty,
+                        Tags = [.. e.Value.Tags],
+                        Data = e.Value.Data
+                            .Where(kvp => kvp.Value is JsonElement je)
+                            .ToDictionary(kvp => kvp.Key,
+                                kvp => (JsonElement)kvp.Value)
+                    })
+            };
+
+            return Results.Json(response);
+        })
+        .WithName("Health")
+        .WithSummary("Service health")
+        .WithDescription($"Current health status of the service. Returns a serialized object of type {nameof(HealthCheckResponse)}")
+        .WithTags("Service")
+        .Produces<HealthCheckResponse>(StatusCodes.Status200OK)
+        .WithOpenApi();
+        return app;
+    }
+}

Daybreak.API/Hosting/WebApplicationBuilderExtensions.cs

@@ -0,0 +1,11 @@
+namespace Daybreak.API.Hosting;
+
+public static class WebApplicationBuilderExtensions
+{
+    public static WebApplicationBuilder WithHosting(this WebApplicationBuilder builder, int port)
+    {
+        builder.WebHost.ConfigureKestrel(o => o.ListenAnyIP(port));
+
+        return builder;
+    }
+}

Daybreak.API/Interop/FixedArrays.cs

@@ -0,0 +1,23 @@
+#pragma warning disable CS0436 // Type conflicts with imported type
+using System.Extensions;
+
+[assembly: GenerateFixedArray<uint>(Size = 4)]
+[assembly: GenerateFixedArray<char>(Size = 0x14)]
+[assembly: GenerateFixedArray<char>(Size = 0x40)]
+[assembly: GenerateFixedArray<byte>(Size = 0x18)]
+[assembly: GenerateFixedArray<char>(Size = 256)]
+[assembly: GenerateFixedArray<char>(Size = 32)]
+[assembly: GenerateFixedArray<char>(Size = 5)]
+[assembly: GenerateFixedArray<char>(Size = 8)]
+[assembly: GenerateFixedArray<byte>(Size = 56)]
+[assembly: GenerateFixedArray<uint>(Size = 17)]
+[assembly: GenerateFixedArray<uint>(Size = 12)]
+[assembly: GenerateFixedArray<uint>(Size = 13)]
+[assembly: GenerateFixedArray<uint>(Size = 8)]
+#pragma warning restore CS0436 // Type conflicts with imported type
+
+namespace Daybreak.API.Interop;
+
+public static class FixedArrays
+{
+}

Daybreak.API/Interop/GWAddressCache.cs

@@ -0,0 +1,26 @@
+using System.Core.Extensions;
+
+namespace Daybreak.API.Interop;
+
+public sealed class GWAddressCache(Func<nuint> provider)
+{
+    private readonly Func<nuint> provider = provider.ThrowIfNull();
+    private nuint? cachedAddress;
+
+    public nuint? GetAddress()
+    {
+        if (this.cachedAddress.HasValue)
+        {
+            return this.cachedAddress.Value;
+        }
+
+        var addr = this.provider();
+        if (addr is 0x0)
+        {
+            return null;
+        }
+
+        this.cachedAddress = addr;
+        return addr;
+    }
+}

Daybreak.API/Interop/GWDelegateCache.cs

@@ -0,0 +1,19 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop;
+
+public sealed class GWDelegateCache<TDelegate>(GWAddressCache cache)
+    where TDelegate : Delegate
+{
+    public GWAddressCache Cache { get; } = cache;
+
+    public TDelegate? GetDelegate()
+    {
+        if (this.Cache.GetAddress() is not nuint address)
+        {
+            return default;
+        }
+
+        return Marshal.GetDelegateForFunctionPointer<TDelegate>((nint)address);
+    }
+}

Daybreak.API/Interop/GWFastCall.cs

@@ -0,0 +1,312 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop;
+
+public abstract class GWFastCall(GWAddressCache target)
+{
+    public readonly struct Void { }
+
+    public GWAddressCache Cache { get; } = target;
+    public abstract void Initialize();
+
+    /// <summary>
+    /// Builds a thunk for __fastcall with 1 parameter (ECX only).
+    /// </summary>
+    protected unsafe static nint BuildFastCallThunk1(nuint target)
+    {
+        if (target is 0)
+        {
+            return 0;
+        }
+
+        var code = stackalloc byte[10]
+        {
+            0x58,                      // pop eax               (ret)
+            0x59,                      // pop ecx               (arg1)
+            0x50,                      // push eax              (ret)
+            0xB8, 0, 0, 0, 0,          // mov  eax, TARGET
+            0xFF, 0xE0                 // jmp  eax
+        };                             // 10 bytes total
+
+        const int TARGET_OFFSET = 4;
+        Unsafe.WriteUnaligned(ref code[TARGET_OFFSET], (uint)target);
+
+        var mem = NativeMethods.VirtualAlloc(0, 10, NativeMethods.MEM_COMMIT | NativeMethods.MEM_RESERVE, NativeMethods.PAGE_EXECUTE_READWRITE);
+        if (mem is 0)
+        {
+            throw new Win32Exception(Marshal.GetLastWin32Error(), "VirtualAlloc");
+        }
+
+        Buffer.MemoryCopy(code, (void*)mem, 10, 10);
+        return mem;
+    }
+
+    /// <summary>
+    /// Builds a thunk for __fastcall with 2+ parameters (ECX and EDX).
+    /// </summary>
+    protected unsafe static nint BuildFastCallThunk2(nuint target)
+    {
+        if (target is 0)
+        {
+            return 0;
+        }
+
+        var code = stackalloc byte[11]
+        {
+            0x58,                      // pop eax               (ret)
+            0x59,                      // pop ecx               (ctx)
+            0x5A,                      // pop edx               (edxVal)
+            0x50,                      // push eax              (ret)
+            0xB8,0,0,0,0,              // mov  eax, TARGET
+            0xFF,0xE0                  // jmp  eax
+        };                             // 11 bytes total
+
+        const int TARGET_OFFSET = 5;
+        Unsafe.WriteUnaligned(ref code[TARGET_OFFSET], (uint)target);
+
+        var mem = NativeMethods.VirtualAlloc(0, 11, NativeMethods.MEM_COMMIT | NativeMethods.MEM_RESERVE, NativeMethods.PAGE_EXECUTE_READWRITE);
+        if (mem is 0)
+        {
+            throw new Win32Exception(Marshal.GetLastWin32Error(), "VirtualAlloc");
+        }
+
+        Buffer.MemoryCopy(code, (void*)mem, 11, 11);
+        return mem;
+    }
+}
+
+public unsafe sealed class GWFastCall<T1, T2>(GWAddressCache target) : GWFastCall(target)
+{
+    private delegate* unmanaged[Stdcall]<T1, T2> func = null;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public unsafe T2? Invoke(T1 t1)
+    {
+        if (this.func is null)
+        {
+            this.Initialize();
+        }
+
+        if (this.func is not null)
+        {
+            if (typeof(T2) == typeof(Void))
+            {
+                ((delegate* unmanaged[Stdcall]<T1, void>)this.func)(t1);
+                return default;
+            }
+
+            return this.func(t1);
+        }
+
+        return default;
+    }
+
+    public override void Initialize()
+    {
+        if (this.Cache.GetAddress() is not nuint addr ||
+            addr is 0)
+        {
+            return;
+        }
+
+        var call = BuildFastCallThunk1(addr);
+        this.func = (delegate* unmanaged[Stdcall]<T1, T2>)call;
+    }
+}
+
+public unsafe sealed class GWFastCall<T1, T2, T3>(GWAddressCache target) : GWFastCall(target)
+{
+    private delegate* unmanaged[Stdcall]<T1, T2, T3> func = null;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public unsafe T3? Invoke(T1 t1, T2 t2)
+    {
+        if (this.func is null)
+        {
+            this.Initialize();
+        }
+
+        if (this.func is not null)
+        {
+            if (typeof(T3) == typeof(Void))
+            {
+                ((delegate* unmanaged[Stdcall]<T1, T2, void>)this.func)(t1, t2);
+                return default;
+            }
+
+            return this.func(t1, t2);
+        }
+
+        return default;
+    }
+
+    public override void Initialize()
+    {
+        if (this.Cache.GetAddress() is not nuint addr ||
+            addr is 0)
+        {
+            return;
+        }
+
+        var call = BuildFastCallThunk2(addr);
+        this.func = (delegate* unmanaged[Stdcall]<T1, T2, T3>)call;
+    }
+}
+
+public unsafe sealed class GWFastCall<T1, T2, T3, T4>(GWAddressCache target) : GWFastCall(target)
+{
+    private delegate* unmanaged[Stdcall]<T1, T2, T3, T4> func = null;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public unsafe T4? Invoke(T1 t1, T2 t2, T3 t3)
+    {
+        if (this.func is null)
+        {
+            this.Initialize();
+        }
+
+        if (this.func is not null)
+        {
+            if (typeof(T4) == typeof(Void))
+            {
+                ((delegate* unmanaged[Stdcall]<T1, T2, T3, void>)this.func)(t1, t2, t3);
+                return default;
+            }
+
+            return this.func(t1, t2, t3);
+        }
+
+        return default;
+    }
+
+    public override void Initialize()
+    {
+        if (this.Cache.GetAddress() is not nuint addr ||
+            addr is 0)
+        {
+            return;
+        }
+
+        var call = BuildFastCallThunk2(addr);
+        this.func = (delegate* unmanaged[Stdcall]<T1, T2, T3, T4>)call;
+    }
+}
+
+public unsafe sealed class GWFastCall<T1, T2, T3, T4, T5>(GWAddressCache target) : GWFastCall(target)
+{
+    private delegate* unmanaged[Stdcall]<T1, T2, T3, T4, T5> func = null;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public unsafe T5? Invoke(T1 t1, T2 t2, T3 t3, T4 t4)
+    {
+        if (this.func is null)
+        {
+            this.Initialize();
+        }
+
+        if (this.func is not null)
+        {
+            if (typeof(T5) == typeof(Void))
+            {
+                ((delegate* unmanaged[Stdcall]<T1, T2, T3, T4, void>)this.func)(t1, t2, t3, t4);
+                return default;
+            }
+
+            return this.func(t1, t2, t3, t4);
+        }
+
+        return default;
+    }
+
+    public override void Initialize()
+    {
+        if (this.Cache.GetAddress() is not nuint addr ||
+            addr is 0)
+        {
+            return;
+        }
+
+        var call = BuildFastCallThunk2(addr);
+        this.func = (delegate* unmanaged[Stdcall]<T1, T2, T3, T4, T5>)call;
+    }
+}
+
+public unsafe sealed class GWFastCall<T1, T2, T3, T4, T5, T6>(GWAddressCache target) : GWFastCall(target)
+{
+    private delegate* unmanaged[Stdcall]<T1, T2, T3, T4, T5, T6> func = null;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public unsafe T6? Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
+    {
+        if (this.func is null)
+        {
+            this.Initialize();
+        }
+
+        if (this.func is not null)
+        {
+            if (typeof(T6) == typeof(Void))
+            {
+                ((delegate* unmanaged[Stdcall]<T1, T2, T3, T4, T5, void>)this.func)(t1, t2, t3, t4, t5);
+                return default;
+            }
+
+            return this.func(t1, t2, t3, t4, t5);
+        }
+
+        return default;
+    }
+
+    public override void Initialize()
+    {
+        if (this.Cache.GetAddress() is not nuint addr ||
+            addr is 0)
+        {
+            return;
+        }
+
+        var call = BuildFastCallThunk2(addr);
+        this.func = (delegate* unmanaged[Stdcall]<T1, T2, T3, T4, T5, T6>)call;
+    }
+}
+
+public unsafe sealed class GWFastCall<T1, T2, T3, T4, T5, T6, T7>(GWAddressCache target) : GWFastCall(target)
+{
+    private delegate* unmanaged[Stdcall]<T1, T2, T3, T4, T5, T6, T7> func = null;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public unsafe T7? Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+    {
+        if (this.func is null)
+        {
+            this.Initialize();
+        }
+
+        if (this.func is not null)
+        {
+            if (typeof(T7) == typeof(Void))
+            {
+                ((delegate* unmanaged[Stdcall]<T1, T2, T3, T4, T5, T6, void>)this.func)(t1, t2, t3, t4, t5, t6);
+                return default;
+            }
+
+            return this.func(t1, t2, t3, t4, t5, t6);
+        }
+
+        return default;
+    }
+
+    public override void Initialize()
+    {
+        if (this.Cache.GetAddress() is not nuint addr ||
+            addr is 0)
+        {
+            return;
+        }
+
+        var call = BuildFastCallThunk2(addr);
+        this.func = (delegate* unmanaged[Stdcall]<T1, T2, T3, T4, T5, T6, T7>)call;
+    }
+}

Daybreak.API/Interop/GWHook.cs

@@ -0,0 +1,122 @@
+using System.Runtime.InteropServices;
+using MinHook;
+
+namespace Daybreak.API.Interop;
+
+/// <summary>
+/// A thin convenience wrapper around MinHook that
+/// resolves the target address lazily through <see cref="GWAddressCache"/>
+/// unwraps an existing “CALL/JMP rel32” stub so we patch the real code
+/// exposes <see cref="Original"/> so your detour can chain
+/// </summary>
+public sealed class GWHook<T>(
+    GWAddressCache funcAddress,
+    T detour,
+    bool bypassPreviousHooks = false) : IHook<T>
+    where T : Delegate
+{
+    private readonly bool bypassPreviousHooks = bypassPreviousHooks;
+    private readonly GWAddressCache addressCache = funcAddress ?? throw new ArgumentNullException(nameof(funcAddress));
+    private readonly T detour = detour ?? throw new ArgumentNullException(nameof(detour));
+    private readonly SemaphoreSlim semaphore = new(1, 1);
+
+    private T? cont;          // trampoline returned by MinHook
+    private HookEngine? engine;
+
+    /// <summary>Delegate that calls the next hook / real function.</summary>
+    public T Continue => this.cont ??
+        throw new InvalidOperationException("Hook not initialised – call EnsureInitialized() first.");
+
+    public bool Hooked { get; private set; } = false;
+    public nuint TargetAddress { get; private set; }
+    public nuint ContinueAddress { get; private set; }
+    public nuint DetourAddress { get; private set; }
+
+    /// <summary>Installs the hook exactly once (thread-safe).</summary>
+    public bool EnsureInitialized()
+    {
+        if (this.Hooked)
+        {
+            return true;
+        }
+
+        this.semaphore.Wait();
+        try
+        {
+            if (this.Hooked)
+            {
+                return true;
+            }
+
+            var addr = this.addressCache.GetAddress();
+            if (addr.HasValue is false ||
+                addr.Value is 0)
+            {
+                return false;
+            }
+
+            var target = this.bypassPreviousHooks
+                ? UnwrapNearBranch(addr.Value)
+                : addr.Value;
+            if (target is 0)
+            {
+                return false;
+            }
+
+            this.engine = new HookEngine();
+            this.cont = this.engine.CreateHook((nint)target, this.detour);
+            this.engine.EnableHooks();
+            this.TargetAddress = target;
+            this.ContinueAddress = (nuint)this.cont.Method.MethodHandle.GetFunctionPointer();
+            this.DetourAddress = (nuint)this.detour.Method.MethodHandle.GetFunctionPointer();
+            this.Hooked = true;
+            return true;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+        finally
+        {
+            this.semaphore.Release();
+        }
+    }
+
+    public void Dispose()
+    {
+        this.semaphore.Wait();
+        try
+        {
+            if (!this.Hooked ||
+                this.engine is null)
+            {
+                return;
+            }
+
+            this.engine.DisableHooks();
+            this.engine.Dispose();
+
+            this.cont = null;
+            this.Hooked = false;
+        }
+        finally
+        {
+            this.semaphore.Release();
+        }
+    }
+
+    /// <summary>
+    /// Follows a <c>CALL rel32</c> (<c>E8</c>) **or** <c>JMP rel32</c> (<c>E9</c>)
+    /// trampoline that may have been planted by a previous hook.
+    /// </summary>
+    private static unsafe nuint UnwrapNearBranch(nuint addr)
+    {
+        byte op = Marshal.ReadByte((IntPtr)addr);
+        if (op != 0xE8 && op != 0xE9)           // not CALL/JMP rel32
+            return addr;
+
+        int rel = Marshal.ReadInt32((IntPtr)(addr + 1));
+        long dst = (long)addr + 5 + rel;        // 5-byte instruction
+        return (nuint)dst;
+    }
+}

Daybreak.API/Interop/GuildWars/AccountGameContext.cs

@@ -0,0 +1,26 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0xC)]
+public readonly struct AccountUnlockedCount
+{
+    [FieldOffset(0x0000)]
+    public readonly uint Id;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x138)]
+public readonly struct AccountGameContext
+{
+    [FieldOffset(0x0000)]
+    public readonly GuildWarsArray<AccountUnlockedCount> AccountUnlockedCounts;
+
+    [FieldOffset(0x00b4)]
+    public readonly GuildWarsArray<uint> UnlockedPvpHeroes;
+
+    [FieldOffset(0x0124)]
+    public readonly GuildWarsArray<uint> UnlockedAccountSkills;
+
+    [FieldOffset(0x0134)]
+    public readonly uint AccountFlags;
+}

Daybreak.API/Interop/GuildWars/AccountInfoContext.cs

@@ -0,0 +1,15 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0x1C)]
+public readonly unsafe struct AccountInfoContext
+{
+    public readonly char* AccountName;
+    public readonly uint Wins;
+    public readonly uint Losses;
+    public readonly uint Rating;
+    public readonly uint QualifierPoints;
+    public readonly uint Rank;
+    public readonly uint TournamentRewardPoints;
+}

Daybreak.API/Interop/GuildWars/Agent.cs

@@ -0,0 +1,246 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[Flags]
+public enum AgentType : uint
+{
+    Living = 0xDB,
+    Gadget = 0x200,
+    Item   = 0x400
+}
+
+[Flags]
+public enum AgentModelType : ushort
+{
+    NPC    = 0x2000,
+    Player = 0x3000
+}
+
+[Flags]
+public enum LivingAgentState : uint
+{
+    None = 0,
+    InCombatStance              = 0x000001,
+    HasQuest                    = 0x000002,
+    Dead                        = 0x000008,
+    Female                      = 0x000200,
+    HasBossGlow                 = 0x000400,
+    HidingCape                  = 0x001000,
+    CanBeViewedInPartyWindow    = 0x020000,
+    SpawnedSpirit               = 0x040000,
+    BeingObservedOrPlayer       = 0x400000
+}
+
+public enum LivingAgentAllegiance : byte
+{
+    Ally_NonAttackable = 0x1,
+    Neutral = 0x2,
+    Enemy = 0x3,
+    Spirit_Pet = 0x4,
+    Minion = 0x5,
+    Npc_Minipet = 0x6
+};
+
+
+[Flags]
+public enum LivingAgentEffects : uint
+{
+    None            = 0,
+    Bleeding        = 0x0001,
+    Conditioned     = 0x0002,
+    Crippled1       = 0x0008, // Part of the Crippled check
+    Crippled        = 0x000A, // Combined flag for crippled (0x0008 | 0x0002)
+    Dead            = 0x0010,
+    DeepWound       = 0x0020,
+    Poisoned        = 0x0040,
+    Enchanted       = 0x0080,
+    DegenHexed      = 0x0400,
+    Hexed           = 0x0800,
+    WeaponSpelled   = 0x8000
+}
+
+public enum LivingAgentModelState : ushort
+{
+    // Idle states
+    Idle1 = 64,
+    Idle2 = 68,
+    Idle3 = 100,
+
+    // Casting states
+    Casting1 = 65,
+    Casting2 = 581,
+
+    // Moving states
+    Moving1 = 12,
+    Moving2 = 76,
+    Moving3 = 204,
+
+    // Attacking states
+    Attacking1 = 96,
+    Attacking2 = 1088,
+    Attacking3 = 1120,
+
+    // Other states
+    KnockedDown = 1104
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct AgentEffects
+{
+    public readonly uint AgentId;
+    public readonly GuildWarsArray<Buff> Buffs;
+    public readonly GuildWarsArray<Effect> Effects;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct AgentGameContext
+{
+    [FieldOffset(0x01AC)]
+    public readonly uint InstanceTimer;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 196)]
+public readonly struct AgentContext
+{
+    [FieldOffset(0x0014)]
+    public readonly uint AgentInstanceTimer;
+
+    [FieldOffset(0x002C)]
+    public readonly uint AgentId;
+
+    [FieldOffset(0x0074)]
+    public readonly GamePos Pos;
+
+    [FieldOffset(0x009C)]
+    public readonly AgentType Type;
+
+    [FieldOffset(0x00A0)]
+    public readonly Vector2 Velocity;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 212)]
+public readonly struct AgentItemContext
+{
+    [FieldOffset(0x00C4)]
+    public readonly uint OwnerId;
+
+    [FieldOffset(0x00C8)]
+    public readonly uint ItemId;
+
+    [FieldOffset(0x00D0)]
+    public readonly uint ExtraType;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 228)]
+public readonly struct AgentGadgetContext
+{
+    [FieldOffset(0x00CC)]
+    public readonly uint ExtraType;
+
+    [FieldOffset(0x00D0)]
+    public readonly uint GadgetId;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x1C0)]
+public readonly unsafe struct AgentLivingContext
+{
+    [FieldOffset(0x00C4)]
+    public readonly uint OwnerId;
+
+    [FieldOffset(0x00F4)]
+    public readonly ushort AgentType; // All non-player have an identifier. Two of the same mob have the same identifier;
+
+    [FieldOffset(0x00F6)]
+    public readonly AgentModelType AgentModelType;
+
+    [FieldOffset(0x0108)]
+    public readonly TagInfo* Tags;
+
+    [FieldOffset(0x010E)]
+    public readonly byte Primary;
+
+    [FieldOffset(0x010F)]
+    public readonly byte Secondary;
+
+    [FieldOffset(0x0110)]
+    public readonly byte Level;
+
+    [FieldOffset(0x0111)]
+    public readonly byte TeamId;
+
+    [FieldOffset(0x0118)]
+    public readonly float EnergyRegen;
+
+    [FieldOffset(0x0120)]
+    public readonly float Energy;
+
+    [FieldOffset(0x0124)]
+    public readonly uint MaxEnergy;
+
+    [FieldOffset(0x012C)]
+    public readonly float HealthRegen;
+
+    [FieldOffset(0x0134)]
+    public readonly float Health;
+
+    [FieldOffset(0x0138)]
+    public readonly uint MaxHealth;
+
+    [FieldOffset(0x013C)]
+    public readonly uint Effects;
+
+    [FieldOffset(0x0158)]
+    public readonly LivingAgentModelState ModelState;
+
+    [FieldOffset(0x015C)]
+    public readonly LivingAgentState State;
+
+    [FieldOffset(0x0184)]
+    public readonly uint LoginNumber;
+
+    [FieldOffset(0x01B5)]
+    public readonly LivingAgentAllegiance Allegiance;
+
+    public readonly bool IsAlive => (!this.State.HasFlag(LivingAgentState.Dead)) && this.Health > 0f;
+
+    public readonly bool IsPlayer => this.LoginNumber is not 0;
+
+    public readonly bool IsNpc => this.LoginNumber is 0;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 52)]
+public readonly struct MapAgentContext
+{
+    [FieldOffset(0x0000)]
+    public readonly float CurrentEnergy;
+
+    [FieldOffset(0x0004)]
+    public readonly float MaxEnergy;
+
+    [FieldOffset(0x0008)]
+    public readonly float EnergyRegen;
+
+    [FieldOffset(0x000C)]
+    public readonly uint SkillTimestamp;
+
+    [FieldOffset(0x0020)]
+    public readonly float CurrentHealth;
+
+    [FieldOffset(0x0024)]
+    public readonly float MaxHealth;
+
+    [FieldOffset(0x0028)]
+    public readonly float HealthRegen;
+
+    [FieldOffset(0x0030)]
+    public readonly LivingAgentEffects Effects;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x38)]
+public readonly unsafe struct AgentInfo
+{
+    [FieldOffset(0x0034)]
+    public readonly char* NameEncoded;
+}

Daybreak.API/Interop/GuildWars/Attribute.cs

@@ -0,0 +1,93 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct AttributeContext
+{
+    public readonly uint Id;
+    public readonly uint LevelBase;
+    public readonly uint Level;
+    public readonly uint DecrementPoints;
+    public readonly uint IncrementPoints;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct AttributeInfo
+{
+    public readonly uint ProfessionId;
+    public readonly uint AttributeId;
+    public readonly uint NameId;
+    public readonly uint DescriptionId;
+    public readonly uint IsPve;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct PartyAttribute
+{
+    public readonly uint AgentId;
+    public readonly AttributeContext Attribute0;
+    public readonly AttributeContext Attribute1;
+    public readonly AttributeContext Attribute2;
+    public readonly AttributeContext Attribute3;
+    public readonly AttributeContext Attribute4;
+    public readonly AttributeContext Attribute5;
+    public readonly AttributeContext Attribute6;
+    public readonly AttributeContext Attribute7;
+    public readonly AttributeContext Attribute8;
+    public readonly AttributeContext Attribute9;
+    public readonly AttributeContext Attribute10;
+    public readonly AttributeContext Attribute11;
+    public readonly AttributeContext Attribute12;
+    public readonly AttributeContext Attribute13;
+    public readonly AttributeContext Attribute14;
+    public readonly AttributeContext Attribute15;
+    public readonly AttributeContext Attribute16;
+    public readonly AttributeContext Attribute17;
+    public readonly AttributeContext Attribute18;
+    public readonly AttributeContext Attribute19;
+    public readonly AttributeContext Attribute20;
+    public readonly AttributeContext Attribute21;
+    public readonly AttributeContext Attribute22;
+    public readonly AttributeContext Attribute23;
+    public readonly AttributeContext Attribute24;
+    public readonly AttributeContext Attribute25;
+    public readonly AttributeContext Attribute26;
+    public readonly AttributeContext Attribute27;
+    public readonly AttributeContext Attribute28;
+    public readonly AttributeContext Attribute29;
+    public readonly AttributeContext Attribute30;
+    public readonly AttributeContext Attribute31;
+    public readonly AttributeContext Attribute32;
+    public readonly AttributeContext Attribute33;
+    public readonly AttributeContext Attribute34;
+    public readonly AttributeContext Attribute35;
+    public readonly AttributeContext Attribute36;
+    public readonly AttributeContext Attribute37;
+    public readonly AttributeContext Attribute38;
+    public readonly AttributeContext Attribute39;
+    public readonly AttributeContext Attribute40;
+    public readonly AttributeContext Attribute41;
+    public readonly AttributeContext Attribute42;
+    public readonly AttributeContext Attribute43;
+    public readonly AttributeContext Attribute44;
+    public readonly AttributeContext Attribute45;
+    public readonly AttributeContext Attribute46;
+    public readonly AttributeContext Attribute47;
+    public readonly AttributeContext Attribute48;
+    public readonly AttributeContext Attribute49;
+    public readonly AttributeContext Attribute50;
+    public readonly AttributeContext Attribute51;
+    public readonly AttributeContext Attribute52;
+    public readonly AttributeContext Attribute53;
+
+    public readonly AttributeContext[] Attributes =>
+    [
+        this.Attribute0, this.Attribute1, this.Attribute2, this.Attribute3, this.Attribute4, this.Attribute5, this.Attribute6, this.Attribute7, this.Attribute8, this.Attribute9,
+        this.Attribute10, this.Attribute11, this.Attribute12, this.Attribute13, this.Attribute14, this.Attribute15, this.Attribute16, this.Attribute17, this.Attribute18, this.Attribute19,
+        this.Attribute20, this.Attribute21, this.Attribute22, this.Attribute23, this.Attribute24, this.Attribute25, this.Attribute26, this.Attribute27, this.Attribute28, this.Attribute29,
+        this.Attribute30, this.Attribute31, this.Attribute32, this.Attribute33, this.Attribute34, this.Attribute35, this.Attribute36, this.Attribute37, this.Attribute38, this.Attribute39,
+        this.Attribute40, this.Attribute41, this.Attribute42, this.Attribute43, this.Attribute44, this.Attribute45, this.Attribute46, this.Attribute47, this.Attribute48, this.Attribute49,
+        this.Attribute50, this.Attribute51, this.Attribute52, this.Attribute53
+    ];
+}

Daybreak.API/Interop/GuildWars/Bag.cs

@@ -0,0 +1,30 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum BagType
+{
+    None,
+    Inventory,
+    Equipped,
+    NotCollected,
+    Storage,
+    MaterialsStorage
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly unsafe struct Bag
+{
+    [FieldOffset(0x0000)]
+    public readonly BagType Type;
+    [FieldOffset(0x0004)]
+    public readonly uint Index;
+    [FieldOffset(0x000C)]
+    public readonly uint ContainerItem;
+    [FieldOffset(0x0010)]
+    public readonly uint ItemsCount;
+    [FieldOffset(0x0014)]
+    public readonly Bag* Bags;
+    [FieldOffset(0x0018)]
+    public readonly GuildWarsArray<WrappedPointer<Item>> Items;
+}

Daybreak.API/Interop/GuildWars/Behavior.cs

@@ -0,0 +1,8 @@
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum Behavior
+{
+    Fight,
+    Guard,
+    AvoidCombat
+}

Daybreak.API/Interop/GuildWars/CharContext.cs

@@ -0,0 +1,50 @@
+using System.Extensions;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct CharContext
+{
+    [FieldOffset(0x0064)]
+    public readonly Uuid PlayerUuid;
+
+    [FieldOffset(0x0074)]
+    public readonly Array20Char PlayerName;
+
+    [FieldOffset(0x0198)]
+    public readonly uint MapId;
+
+    [FieldOffset(0x019C)]
+    public readonly uint IsExporable;
+
+    [FieldOffset(0x01A0)]
+    public readonly Array24Byte Host;
+
+    [FieldOffset(0x01B8)]
+    public readonly uint PlayerId;
+
+    [FieldOffset(0x0220)]
+    public readonly uint DistrictNumber;
+
+    [FieldOffset(0x0224)]
+    public readonly Language Language;
+
+    [FieldOffset(0x0228)]
+    public readonly uint ObserveMapId;
+
+    [FieldOffset(0x022C)]
+    public readonly uint CurrentMapId;
+
+    [FieldOffset(0x0230)]
+    public readonly uint ObserveMapType;
+
+    [FieldOffset(0x0234)]
+    public readonly uint CurrentMapType;
+
+    [FieldOffset(0x02A4)]
+    public readonly uint PlayerNumber;
+
+    [FieldOffset(0x03B8)]
+    public readonly Array64Char PlayerEmail;
+}

Daybreak.API/Interop/GuildWars/CharInfoContext.cs

@@ -0,0 +1,22 @@
+using System.Extensions;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct CharInfoContext
+{
+    [FieldOffset(0x0008)]
+    public readonly Uuid Uuid;
+    [FieldOffset(0x0018)]
+    public readonly Array20Char Name;
+    [FieldOffset(0x0040)]
+    public readonly Array17Uint Props;
+
+    public readonly uint MapId => (this.Props[0] >> 16) & 0xFFFF;
+    public readonly uint Primary => (this.Props[2] >> 20) & 0xF;
+    public readonly uint Secondary => (this.Props[7] >> 10) & 0xF;
+    public readonly uint Campaign => this.Props[7] & 0xF;
+    public readonly uint Level => (this.Props[7] >> 4) & 0x3F;
+    public readonly bool IsPvp => ((this.Props[7] >> 9) & 0x1) == 0x1;
+}

Daybreak.API/Interop/GuildWars/District.cs

@@ -0,0 +1,19 @@
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum District
+{
+    Current,
+    International,
+    American,
+    EuropeEnglish,
+    EuropeFrench,
+    EuropeGerman,
+    EuropeItalian,
+    EuropeSpanish,
+    EuropePolish,
+    EuropeRussian,
+    AsiaKorean,
+    AsiaChinese,
+    AsiaJapanese,
+    Unknown = 0xff
+}

Daybreak.API/Interop/GuildWars/Frame.cs

@@ -0,0 +1,89 @@
+using Daybreak.API.Models;
+using System.Extensions;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+// Very incomplete. GWCA contains a much better definition
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x1AC)]
+public readonly struct Frame
+{
+    [FieldOffset(0x0008)]
+    public readonly uint FrameLayout;
+
+    [FieldOffset(0x0018)]
+    public readonly uint VisibilityFlags;
+
+    [FieldOffset(0x0020)]
+    public readonly uint Type;
+
+    [FieldOffset(0x0024)]
+    public readonly uint TemplateType;
+
+    [FieldOffset(0x00A8)]
+    public readonly GuildWarsArray<FrameInteractionCallback> FrameCallbacks;
+
+    [FieldOffset(0x00b8)]
+    public readonly uint ChildOffsetId;
+
+    [FieldOffset(0x00bc)]
+    public readonly uint FrameId;
+
+    [FieldOffset(0x0128)]
+    public readonly FrameRelation Relation;
+
+    [FieldOffset(0x018C)]
+    public readonly uint FrameState;
+
+    public bool IsCreated => (this.FrameState & 0x4) != 0;
+    public bool IsHidden => (this.FrameState & 0x200) != 0;
+    public bool IsVisible => !this.IsHidden;
+    public bool IsDIsabled => (this.FrameState & 0x10) != 0;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x1C)]
+public readonly unsafe struct FrameRelation
+{
+    [FieldOffset(0x0000)]
+    public readonly FrameRelation* Parent;
+
+    [FieldOffset(0x000C)]
+    public readonly uint FrameHashId;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly unsafe struct InteractionMessage
+{
+    public readonly uint FrameId;
+    public readonly UIMessage MessageId;
+    public readonly void** WParam;
+}
+
+public unsafe delegate void UIInteractionCallback(InteractionMessage* message, void* wParam, void* lParam);
+
+[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0xC)]
+public unsafe readonly struct FrameInteractionCallback
+{
+    public readonly void* Callback; // UIInteractionCallback
+    public readonly void* UiCtl_Context;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly unsafe struct CharSelectorContext
+{
+    [FieldOffset(0x0000)]
+    public readonly uint Vtable;
+
+    [FieldOffset(0x0004)]
+    public readonly uint FrameId;
+
+    [FieldOffset(0x0008)]
+    public readonly GuildWarsArray<WrappedPointer<CharSelectorChar>> Chars;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct CharSelectorChar
+{
+    [FieldOffset(0x0020)]
+    public readonly Array20Char Name;
+}

Daybreak.API/Interop/GuildWars/GameContext.cs

@@ -0,0 +1,34 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly unsafe struct GameContext
+{
+    [FieldOffset(0x0008)]
+    public readonly AgentGameContext* AgentGameContext;
+
+    [FieldOffset(0x0014)]
+    public readonly MapContext* MapContext;
+
+    [FieldOffset(0x0018)]
+    public readonly TextParserContext* TextParserContext;
+
+    [FieldOffset(0x0028)]
+    public readonly AccountGameContext* AccountContext;
+
+    [FieldOffset(0x002C)]
+    public readonly WorldContext* WorldContext;
+
+    [FieldOffset(0x003C)]
+    public readonly GuildContext* GuildContext;
+
+    [FieldOffset(0x0040)]
+    public readonly ItemContext* ItemContext;
+
+    [FieldOffset(0x0044)]
+    public readonly CharContext* CharContext;
+
+    [FieldOffset(0x004C)]
+    public readonly PartyContext* PartyContext;
+}

Daybreak.API/Interop/GuildWars/GamePos.cs

@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct GamePos
+{
+    public readonly float X;
+    public readonly float Y;
+    public readonly uint Plane;
+}

Daybreak.API/Interop/GuildWars/Guild.cs

@@ -0,0 +1,110 @@
+using System.Extensions;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly unsafe struct GuildContext
+{
+    [FieldOffset(0x0034)]
+    public readonly Array20Char PlayerName;
+
+    [FieldOffset(0x0060)]
+    public readonly uint PlayerBuildIndex;
+
+    [FieldOffset(0x0078)]
+    public readonly Array256Char Announcement;
+
+    [FieldOffset(0x0287)]
+    public readonly Array20Char AnnouncementAuthor;
+
+    [FieldOffset(0x02A0)]
+    public readonly uint PlayerGuildRank;
+
+    [FieldOffset(0x02A8)]
+    public readonly GuildWarsArray<TownAlliance> FactionOutpostGuilds;
+
+    [FieldOffset(0x02B8)]
+    public readonly uint KurzickTownCount;
+
+    [FieldOffset(0x02BC)]
+    public readonly uint LuxonTownCount;
+    
+    [FieldOffset(0x02F8)]
+    public readonly GuildWarsArray<WrappedPointer<Guild>> Guilds;
+
+    [FieldOffset(0x0358)]
+    public readonly GuildWarsArray<WrappedPointer<GuildPlayer>> PlayerRoster;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct TownAlliance
+{
+    public readonly uint Rank;
+    public readonly uint Allegiance;
+    public readonly uint Faction;
+    public readonly Array32Char Name;
+    public readonly Array5Char Tag;
+    public readonly CapeDesign Cape;
+    public readonly uint MapId;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct CapeDesign
+{
+    public readonly uint CapeBgColor;
+    public readonly uint CapeDetailColor;
+    public readonly uint CapeEmblemColor;
+    public readonly uint CapeShape;
+    public readonly uint CapeDetail;
+    public readonly uint CapeEmblem;
+    public readonly uint CapeTrim;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x174)]
+public readonly unsafe struct GuildPlayer
+{
+    [FieldOffset(0x0004)]
+    public readonly char* NamePtr;
+    [FieldOffset(0x0008)]
+    public readonly Array20Char InvitedName;
+    [FieldOffset(0x0030)]
+    public readonly Array20Char CurrentName;
+    [FieldOffset(0x0050)]
+    public readonly Array20Char InviterName;
+    [FieldOffset(0x0080)]
+    public readonly uint InviteTime;
+    [FieldOffset(0x0084)]
+    public readonly Array20Char PromoterName;
+    [FieldOffset(0x00DC)]
+    public readonly uint Offline;
+    [FieldOffset(0x00E0)]
+    public readonly uint MemberType;
+    [FieldOffset(0x00E4)]
+    public readonly uint Status;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0xAC)]
+public readonly struct Guild
+{
+    [FieldOffset(0x0024)]
+    public readonly uint Index;
+    [FieldOffset(0x0028)]
+    public readonly uint Rank;
+    [FieldOffset(0x002C)]
+    public readonly uint Features;
+    [FieldOffset(0x0030)]
+    public readonly Array32Char Name;
+    [FieldOffset(0x0070)]
+    public readonly uint Rating;
+    [FieldOffset(0x0074)]
+    public readonly uint Faction;
+    [FieldOffset(0x0078)]
+    public readonly uint FactionPoints;
+    [FieldOffset(0x007C)]
+    public readonly uint QualifierPoints;
+    [FieldOffset(0x0080)]
+    public readonly Array8Char Tag;
+    [FieldOffset(0x0090)]
+    public readonly CapeDesign Cape;
+}

Daybreak.API/Interop/GuildWars/GuildWarsArray.cs

@@ -0,0 +1,62 @@
+using System.Collections;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly unsafe struct GuildWarsArray<T> : IEnumerable<T>
+    where T : unmanaged
+{
+    public readonly T* Buffer;
+    public readonly uint Capacity;
+    public readonly uint Size;
+    public readonly uint Param;
+
+    public T this[int index]
+    {
+        get
+        {
+            ArgumentOutOfRangeException.ThrowIfNegative(index);
+            ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual((uint)index, this.Size);
+            return this.Buffer[index];
+        }
+    }
+
+    public Enumerator GetEnumerator() => new(this.Buffer, this.Size);
+
+    IEnumerator<T> IEnumerable<T>.GetEnumerator() => this.GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
+
+    public unsafe struct Enumerator : IEnumerator, IEnumerator<T>
+    {
+        private readonly T* buffer;
+        private readonly uint size;
+        private int index;
+
+        internal Enumerator(T* buffer, uint size)
+        {
+            this.buffer = buffer;
+            this.size = size;
+            this.index = -1;
+        }
+
+        public bool MoveNext()
+        {
+            int next = this.index + 1;
+            if (next >= this.size)
+            {
+                return false;
+            }
+
+            this.index = next;
+            return true;
+        }
+
+        public T Current => this.buffer[this.index];
+        object IEnumerator.Current => this.Current;
+
+        public void Reset() => this.index = -1;
+        public readonly void Dispose() { }
+    }
+}

Daybreak.API/Interop/GuildWars/Hero.cs

@@ -0,0 +1,43 @@
+using System.Extensions;
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x24)]
+public readonly struct HeroFlag
+{
+    [FieldOffset(0x0000)]
+    public readonly uint HeroId;
+    [FieldOffset(0x0004)]
+    public readonly uint AgentId;
+    [FieldOffset(0x0008)]
+    public readonly uint Level;
+    [FieldOffset(0x000C)]
+    public readonly Behavior Behavior;
+    [FieldOffset(0x0010)]
+    public readonly Vector2 Flag;
+    [FieldOffset(0x0020)]
+    public readonly uint LockedTargetId;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x78)]
+public readonly struct HeroInfo
+{
+    [FieldOffset(0x0000)]
+    public readonly uint HeroId;
+    [FieldOffset(0x0004)]
+    public readonly uint AgentId;
+    [FieldOffset(0x0008)]
+    public readonly uint Level;
+    [FieldOffset(0x000C)]
+    public readonly Profession Primary;
+    [FieldOffset(0x0010)]
+    public readonly Profession Secondary;
+    [FieldOffset(0x0014)]
+    public readonly uint HeroFileId;
+    [FieldOffset(0x0018)]
+    public readonly uint ModelFileId;
+    [FieldOffset(0x0050)]
+    public readonly Array20Char Name;
+}

Daybreak.API/Interop/GuildWars/InstanceInfo.cs

@@ -0,0 +1,29 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum InstanceType
+{
+    Outpost,
+    Explorable,
+    Loading
+};
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly unsafe struct InstanceInfoContext
+{
+    [FieldOffset(0x0004)]
+    public readonly InstanceType InstanceType;
+    [FieldOffset(0x0008)]
+    public readonly AreaInfo* CurrentMapInfo;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct AreaInfo
+{
+    public readonly uint Campaign;
+    public readonly uint Continent;
+    public readonly uint Region;
+    public readonly uint RegionType;
+    public readonly uint Flags;
+}

Daybreak.API/Interop/GuildWars/Inventory.cs

@@ -0,0 +1,58 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly unsafe struct Inventory
+{
+    public readonly Bag* UnusedBag;
+    public readonly Bag* Backpack;
+    public readonly Bag* BeltPouch;
+    public readonly Bag* Bag1;
+    public readonly Bag* Bag2;
+    public readonly Bag* EquipmentPack;
+    public readonly Bag* MaterialStorage;
+    public readonly Bag* UnclaimedItems;
+    public readonly Bag* Storage1;
+    public readonly Bag* Storage2;
+    public readonly Bag* Storage3;
+    public readonly Bag* Storage4;
+    public readonly Bag* Storage5;
+    public readonly Bag* Storage6;
+    public readonly Bag* Storage7;
+    public readonly Bag* Storage8;
+    public readonly Bag* Storage9;
+    public readonly Bag* Storage10;
+    public readonly Bag* Storage11;
+    public readonly Bag* Storage12;
+    public readonly Bag* Storage13;
+    public readonly Bag* Storage14;
+    public readonly Bag* EquippedItems;
+    public readonly Item* Bundle;
+    public readonly uint StoragePanesUnlocked;
+
+    public readonly Bag*[] Bags => [
+        this.Backpack,
+        this.BeltPouch,
+        this.Bag1,
+        this.Bag2,
+        this.EquipmentPack,
+        this.MaterialStorage,
+        this.UnclaimedItems,
+        this.Storage1,
+        this.Storage2,
+        this.Storage3,
+        this.Storage4,
+        this.Storage5,
+        this.Storage6,
+        this.Storage7,
+        this.Storage8,
+        this.Storage9,
+        this.Storage10,
+        this.Storage11,
+        this.Storage12,
+        this.Storage13,
+        this.Storage14,
+        this.EquippedItems
+    ];
+}

Daybreak.API/Interop/GuildWars/Item.cs

@@ -0,0 +1,127 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum ItemType : byte
+{
+    Salvage,
+    Axe = 2,
+    Bag,
+    Boots,
+    Bow,
+    Bundle,
+    Chestpiece,
+    Rune_Mod,
+    Usable,
+    Dye,
+    Materials_Zcoins,
+    Offhand,
+    Gloves,
+    Hammer = 15,
+    Headpiece,
+    CC_Shards,
+    Key,
+    Leggings,
+    Gold_Coin,
+    Quest_Item,
+    Wand,
+    Shield = 24,
+    Staff = 26,
+    Sword,
+    Kit = 29,
+    Trophy,
+    Scroll,
+    Daggers,
+    Present,
+    Minipet,
+    Scythe,
+    Spear,
+    Storybook = 43,
+    Costume,
+    Costume_Headpiece,
+    Unknown = 0xff
+};
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct ItemModifier(uint mod)
+{
+    public static readonly ItemModifier Zero = new();
+
+    public readonly uint Mod = mod;
+
+    public uint Identifier => this.Mod >> 16;
+    public uint Arg1 => (this.Mod & 0x0000FF00) >> 8;
+    public uint Arg2 => this.Mod & 0x000000FF;
+    public uint Arg => this.Mod & 0x0000FFFF;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly unsafe struct Item
+{
+    [FieldOffset(0x0000)]
+    public readonly uint ItemId;
+
+    [FieldOffset(0x0004)]
+    public readonly uint AgentId;
+
+    [FieldOffset(0x0008)]
+    public readonly Bag* BagEquipped;
+
+    [FieldOffset(0x000C)]
+    public readonly Bag* Bag;
+
+    [FieldOffset(0x0010)]
+    public readonly ItemModifier* Modifiers;
+
+    [FieldOffset(0x0014)]
+    public readonly uint ModifiersCount;
+
+    [FieldOffset(0x001C)]
+    public readonly uint ModelFileId;
+
+    [FieldOffset(0x0020)]
+    public readonly ItemType Type;
+
+    [FieldOffset(0x0024)]
+    public readonly ushort Value;
+
+    [FieldOffset(0x0028)]
+    public readonly uint Interaction;
+
+    [FieldOffset(0x002C)]
+    public readonly uint ModelId;
+
+    [FieldOffset(0x0030)]
+    public readonly char* InfoString;
+
+    [FieldOffset(0x0034)]
+    public readonly char* NameEncoded;
+
+    [FieldOffset(0x0038)]
+    public readonly char* CompleteNameEncoded;
+
+    [FieldOffset(0x003C)]
+    public readonly char* SingleItemName;
+
+    [FieldOffset(0x0048)]
+    public readonly ushort ItemFormula;
+
+    [FieldOffset(0x004A)]
+    public readonly byte IsMaterialSalvageable;
+
+    [FieldOffset(0x004C)]
+    public readonly ushort Quantity;
+
+    [FieldOffset(0x004E)]
+    public readonly byte Equipped;
+
+    [FieldOffset(0x004F)]
+    public readonly byte Profession;
+
+    [FieldOffset(0x0050)]
+    public readonly uint Slot;
+
+    public readonly bool Stackable => (this.Interaction & 0x80000) != 0;
+
+    public readonly bool Inscribable => (this.Interaction & 0x08000000) != 0;
+}

Daybreak.API/Interop/GuildWars/ItemContext.cs

@@ -0,0 +1,16 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct ItemContext
+{
+    [FieldOffset(0x0024)]
+    public readonly GuildWarsArray<WrappedPointer<Bag>> Bags;
+
+    [FieldOffset(0x00B8)]
+    public readonly GuildWarsArray<WrappedPointer<Item>> Items;
+
+    [FieldOffset(0x00F8)]
+    public readonly WrappedPointer<Inventory> Inventory;
+}

Daybreak.API/Interop/GuildWars/Language.cs

@@ -0,0 +1,17 @@
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum Language
+{
+    English,
+    Korean,
+    French,
+    German,
+    Italian,
+    Spanish,
+    TraditionalChinese,
+    Japanese = 8,
+    Polish,
+    Russian,
+    BorkBorkBork = 17,
+    Unknown = 0xff
+}

Daybreak.API/Interop/GuildWars/MapContext.cs

@@ -0,0 +1,8 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct MapContext
+{
+}

Daybreak.API/Interop/GuildWars/Npc.cs

@@ -0,0 +1,61 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit)]
+public readonly unsafe struct NpcContext
+{
+    [FieldOffset(0x0000)]
+    public readonly uint ModelId;
+
+    [FieldOffset(0x000C)]
+    public readonly uint Sex;
+
+    [FieldOffset(0x0010)]
+    public readonly NpcFlags Flags;
+
+    [FieldOffset(0x0014)]
+    public readonly uint Primary;
+
+    [FieldOffset(0x001C)]
+    public readonly byte DefaultLevel;
+
+    [FieldOffset(0x0020)]
+    public readonly char* EncName;
+
+    [FieldOffset(0x0028)]
+    public readonly int FilesCount;
+
+    [FieldOffset(0x002C)]
+    public readonly int FilesCapacity;
+
+    [Flags]
+    public enum NpcFlags : uint
+    {
+        None = 0x0000,
+        Henchman = 0x0010,
+        Hero = 0x0020,
+        Spirit = 0x4000,
+        Minion = 0x0100,
+        Pet = 0x000D
+    }
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly unsafe struct PetContext
+{
+    public readonly uint AgentId;
+    public readonly uint OwnerAgentId;
+    public readonly char* PetName;
+    public readonly uint ModelFileId1;
+    public readonly uint ModelFileId2;
+    public readonly Behavior Behavior;
+    public readonly uint LockedTargetId;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct ControlledMinion
+{
+    public readonly uint AgentId;
+    public readonly uint MinionCount;
+}

Daybreak.API/Interop/GuildWars/Party.cs

@@ -0,0 +1,124 @@
+using System.Extensions;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[Flags]
+public enum PlayerPartyMemberState : uint
+{
+    None = 0,
+    Connected = 1,
+    Ticked = 2
+}
+
+public enum PartySearchType
+{
+    PartySearchType_Hunting = 0,
+    PartySearchType_Mission = 1,
+    PartySearchType_Quest = 2,
+    PartySearchType_Trade = 3,
+    PartySearchType_Guild = 4,
+};
+
+[Flags]
+public enum PartyFlags : uint
+{
+    None = 0,
+    HardMode = 0x10,  // Bit 4
+    Defeated = 0x20,  // Bit 5
+    PartyLeader = 0x80   // Bit 7 (0x7th position)
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0xC)]
+public readonly unsafe struct PartyMoraleContext
+{
+    [FieldOffset(0x000C)]
+    public readonly PartyMemberMoraleInfo* MoraleInfo;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct PartyMemberMoraleInfo
+{
+    [FieldOffset(0x0000)]
+    public readonly uint AgentId;
+    [FieldOffset(0x0014)]
+    public readonly uint Morale;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x58)]
+public readonly unsafe struct PartyContext
+{
+    [FieldOffset(0x0014)]
+    public readonly PartyFlags Flags;
+    [FieldOffset(0x0040)]
+    public readonly GuildWarsArray<WrappedPointer<PartyInfo>> Parties;
+    [FieldOffset(0x0054)]
+    public readonly PartyInfo* PlayerParty;
+    [FieldOffset(0x00C0)]
+    public readonly GuildWarsArray<WrappedPointer<PartySearch>> PartySearches;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0xC)]
+public readonly struct PlayerPartyMember
+{
+    public readonly uint LogingNumber;
+    public readonly uint CalledTargetId;
+    public readonly PlayerPartyMemberState State;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x18)]
+public readonly struct HeroPartyMember
+{
+    [FieldOffset(0x0000)]
+    public readonly uint AgentId;
+    [FieldOffset(0x0004)]
+    public readonly uint OwnerPlayerId;
+    [FieldOffset(0x0008)]
+    public readonly uint HeroId;
+    [FieldOffset(0x0014)]
+    public readonly uint Level;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x34)]
+public readonly struct HenchmanPartyMember
+{
+    [FieldOffset(0x0000)]
+    public readonly uint AgentId;
+    [FieldOffset(0x002C)]
+    public readonly Profession Profession;
+    [FieldOffset(0x0030)]
+    public readonly uint Level;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x84)]
+public readonly struct PartyInfo
+{
+    [FieldOffset(0x0000)]
+    public readonly uint PartyId;
+    [FieldOffset(0x0004)]
+    public readonly GuildWarsArray<PlayerPartyMember> Players;
+    [FieldOffset(0x0014)]
+    public readonly GuildWarsArray<HenchmanPartyMember> Henchmen;
+    [FieldOffset(0x0024)]
+    public readonly GuildWarsArray<HeroPartyMember> Heroes;
+    [FieldOffset(0x0034)]
+    public readonly GuildWarsArray<uint> Others;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct PartySearch
+{
+    public readonly uint PartySearchId;
+    public readonly PartySearchType PartySearchType;
+    public readonly uint HardMode;
+    public readonly uint District;
+    public readonly uint Language;
+    public readonly uint PartySize;
+    public readonly uint HeroCount;
+    public readonly Array32Char Message;
+    public readonly Array20Char PartyLeader;
+    public readonly Profession Primary;
+    public readonly Profession Secondary;
+    public readonly uint Level;
+    public readonly uint Timestamp;
+}

Daybreak.API/Interop/GuildWars/PartySearchWindowContext.cs

@@ -0,0 +1,20 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x34)]
+public unsafe struct PartySearchWindowContext
+{
+    [FieldOffset(0x0000)]
+    public uint* Vtable;
+    [FieldOffset(0x0004)]
+    public uint FrameId;
+    [FieldOffset(0x0020)]
+    public uint SelectedPartySearchId;
+    [FieldOffset(0x0024)]
+    public uint SelectedHeroId;
+    [FieldOffset(0x0028)]
+    public uint SelectedHenchmanId;
+    [FieldOffset(0x002C)]
+    public uint CurrentTab;
+}

Daybreak.API/Interop/GuildWars/PlayerContext.cs

@@ -0,0 +1,47 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[Flags]
+public enum PlayerContextFlags : uint
+{
+    None = 0,
+    PvP = 0x800
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x50)]
+public readonly unsafe struct PlayerContext
+{
+    [FieldOffset(0x0000)]
+    public readonly int AgentId;
+
+    [FieldOffset(0x0014)]
+    public readonly PlayerContextFlags Flags;
+
+    [FieldOffset(0x0018)]
+    public readonly uint PrimaryProfession;
+
+    [FieldOffset(0x001C)]
+    public readonly uint SecondaryProfession;
+
+    [FieldOffset(0x0024)]
+    public readonly char* NameEncoded;
+
+    [FieldOffset(0x0028)]
+    public readonly char* Name;
+
+    [FieldOffset(0x002C)]
+    public readonly uint PartyLeaderPlayerNumber;
+
+    [FieldOffset(0x0030)]
+    public readonly uint ActiveTitleTier;
+
+    [FieldOffset(0x0034)]
+    public readonly uint ReforgedOrDhuumsFlags;
+
+    [FieldOffset(0x0038)]
+    public readonly uint PlayerNumber;
+
+    [FieldOffset(0x003C)]
+    public readonly uint PartySize;
+}

Daybreak.API/Interop/GuildWars/PlayerControlledCharContext.cs

@@ -0,0 +1,10 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct PlayerControlledCharContext
+{
+    [FieldOffset(0x0014)]
+    public readonly uint AgentId;
+}

Daybreak.API/Interop/GuildWars/PreGameContext.cs

@@ -0,0 +1,24 @@
+using System.Extensions;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct PreGameContext
+{
+    [FieldOffset(0x0000)]
+    public readonly uint FrameId;
+
+    [FieldOffset(0x0124)]
+    public readonly uint ChosenCharacterIndex;
+
+    [FieldOffset(0x0148)]
+    public readonly GuildWarsArray<LoginCharacterContext> LoginCharacters;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly struct LoginCharacterContext
+{
+    [FieldOffset(0x0004)]
+    public readonly Array20Char CharacterName;
+}

Daybreak.API/Interop/GuildWars/Preferences.cs

@@ -0,0 +1,40 @@
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum EnumPreference : uint
+{
+    CharSortOrder = 0,
+    AntiAliasing = 1,
+    Reflections = 2,
+    ShaderQuality = 3,
+    ShadowQuality = 4,
+    TerrainQuality = 5,
+    InterfaceSize = 6,
+    FrameLimiter = 7,
+    Count = 8
+}
+
+public enum CharSortOrder : uint
+{
+    None = 0,
+    Alphabetize = 1,
+    PvPRP = 2
+}
+
+public enum NumberPreference : uint
+{
+    AutoTournPartySort = 0,
+    ChatState = 1,
+    Count = 0x2b
+}
+
+public enum FlagPreference : uint
+{
+}
+
+public enum StringPreference : uint
+{
+    Unk1 = 0,
+    Unk2 = 1,
+    LastCharacterName = 2,
+    Count = 3
+}

Daybreak.API/Interop/GuildWars/Profession.cs

@@ -0,0 +1,47 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum Profession : uint
+{
+    None,
+    Warrior,
+    Ranger,
+    Monk,
+    Necromancer,
+    Mesmer,
+    Elementalist,
+    Assassin,
+    Ritualist,
+    Paragon,
+    Dervish
+}
+
+public enum ProfessionByte : byte
+{
+    None,
+    Warrior,
+    Ranger,
+    Monk,
+    Necromancer,
+    Mesmer,
+    Elementalist,
+    Assassin,
+    Ritualist,
+    Paragon,
+    Dervish
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0x0014)]
+public readonly struct ProfessionsContext
+{
+    public readonly uint AgentId;
+    public readonly Profession CurrentPrimary;
+    public readonly Profession CurrentSecondary;
+    public readonly uint UnlockedProfessionsFlags;
+
+    public bool ProfessionUnlocked(int professionId)
+    {
+        return (this.UnlockedProfessionsFlags & (1U << professionId)) != 0;
+    }
+}

Daybreak.API/Interop/GuildWars/Quest.cs

@@ -0,0 +1,25 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x0034)]
+public readonly struct QuestContext
+{
+    [FieldOffset(0x0000)]
+    public readonly uint QuestId;
+
+    [FieldOffset(0x0014)]
+    public readonly uint MapFrom;
+
+    [FieldOffset(0x0018)]
+    public readonly Vector3 Marker;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0xC)]
+public readonly unsafe struct MissionObjectiveContext
+{
+    public readonly uint ObjectiveId;
+    public readonly char* EncodedString;
+    public readonly uint Type;
+}

Daybreak.API/Interop/GuildWars/ServerRegion.cs

@@ -0,0 +1,12 @@
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum ServerRegion
+{
+    International = -2,
+    America = 0,
+    Korea,
+    Europe,
+    China,
+    Japan,
+    Unknown = 0xff
+}

Daybreak.API/Interop/GuildWars/Skill.cs

@@ -0,0 +1,58 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct SkillContext
+{
+    public readonly uint Adrenaline1;
+    public readonly uint Adrenaline2;
+    public readonly uint Recharge;
+    public readonly uint Id;
+    public readonly uint Event;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0xBC)]
+public readonly struct SkillbarContext
+{
+    public readonly uint AgentId;
+    public readonly SkillContext Skill0;
+    public readonly SkillContext Skill1;
+    public readonly SkillContext Skill2;
+    public readonly SkillContext Skill3;
+    public readonly SkillContext Skill4;
+    public readonly SkillContext Skill5;
+    public readonly SkillContext Skill6;
+    public readonly SkillContext Skill7;
+    public readonly uint Disabled;
+    public readonly uint Casting;
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x10)]
+public readonly struct Buff
+{
+    [FieldOffset(0x0000)]
+    public readonly uint SkillId;
+    [FieldOffset(0x0008)]
+    public readonly uint BuffId;
+    [FieldOffset(0x000C)]
+    public readonly uint TargetAgentId;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0x18)]
+public readonly struct Effect
+{
+    public readonly uint SkillId;
+    public readonly uint AttributeLevel;
+    public readonly uint EffectId;
+    public readonly uint AgentId;
+    public readonly float Duration;
+    public readonly uint Timestamp;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct DupeSkill
+{
+    public readonly uint SkillId;
+    public readonly uint Count;
+}

Daybreak.API/Interop/GuildWars/SkillTemplate.cs

@@ -0,0 +1,13 @@
+using System.Extensions;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+public readonly struct SkillTemplate(uint primary, uint secondary, uint attributeCount, Array12Uint attributeIds, Array12Uint attributeValues, Array8Uint skills)
+{
+    public readonly uint Primary = primary;
+    public readonly uint Secondary = secondary;
+    public readonly uint AttributesCount = attributeCount;
+    public readonly Array12Uint AttributeIds = attributeIds;
+    public readonly Array12Uint AttributeValues = attributeValues;
+    public readonly Array8Uint Skills = skills;
+}

Daybreak.API/Interop/GuildWars/TagInfo.cs

@@ -0,0 +1,12 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct TagInfo
+{
+    public readonly ushort GuildId;
+    public readonly byte Primary;
+    public readonly byte Secondary;
+    public readonly ushort Level;
+}

Daybreak.API/Interop/GuildWars/TextParserContext.cs

@@ -0,0 +1,10 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public struct TextParserContext
+{
+    [FieldOffset(0x01D0)]
+    public Language Language;
+}

Daybreak.API/Interop/GuildWars/Title.cs

@@ -0,0 +1,48 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[Flags]
+public enum TitleProps : uint
+{
+    None = 0,
+    PercentageBased = 1,
+    HasTiers = 2
+    // Note: The HasTiers check uses (props & 3) == 2, which means bit 1 is set but bit 0 is not
+}
+
+[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 0x2C)]
+public readonly struct TitleContext
+{
+    [FieldOffset(0x0000)]
+    public readonly TitleProps Props;
+    [FieldOffset(0x0004)]
+    public readonly uint CurrentPoints;
+    [FieldOffset(0x0008)]
+    public readonly uint CurrentTitleTierIndex;
+    [FieldOffset(0x000C)]
+    public readonly uint PointsNeededForCurrentRank;
+    [FieldOffset(0x0014)]
+    public readonly uint NextTitleTierIndex;
+    [FieldOffset(0x0018)]
+    public readonly uint PointsNeededForNextRank;
+    [FieldOffset(0x001C)]
+    public readonly uint MaxTitleRank;
+    [FieldOffset(0x0020)]
+    public readonly uint MaxTitleTierIndex;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0xC)]
+public readonly unsafe struct TitleTier
+{
+    public readonly TitleProps Props;
+    public readonly uint TierNumber;
+    public readonly char* TierNameEncoded;
+}
+
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public readonly struct TitleClientData
+{
+    public readonly uint TitleId;
+    public readonly uint NameId;
+}

Daybreak.API/Interop/GuildWars/UIAction.cs

@@ -0,0 +1,183 @@
+namespace Daybreak.API.Interop.GuildWars;
+
+public enum UIAction : uint
+{
+    None = 0,
+    Screenshot = 0xAE,
+
+    // Panels
+    CloseAllPanels = 0x85,
+    ToggleInventoryWindow = 0x8B,
+    OpenScoreChart = 0xBD,
+    OpenTemplateManager = 0xD3,
+    OpenSaveEquipmentTemplate = 0xD4,
+    OpenSaveSkillTemplate = 0xD5,
+    OpenParty = 0xBF,
+    OpenGuild = 0xBA,
+    OpenFriends = 0xB9,
+    ToggleAllBags = 0xB8,
+    OpenMissionMap = 0xB6,
+    OpenBag2 = 0xB5,
+    OpenBag1 = 0xB4,
+    OpenBelt = 0xB3,
+    OpenBackpack = 0xB2,
+    OpenSkillsAndAttributes = 0x8F,
+    OpenQuestLog = 0x8E,
+    OpenWorldMap = 0x8C,
+    OpenOptions = 0x8D,
+    OpenHero = 0x8A,
+
+    // Weapon sets
+    CycleEquipment = 0x86,
+    ActivateWeaponSet1 = 0x81,
+    ActivateWeaponSet2,
+    ActivateWeaponSet3,
+    ActivateWeaponSet4,
+
+    DropItem = 0xCD, // drops bundle item >> flags, ashes, etc
+
+    // Chat
+    CharReply = 0xBE,
+    OpenChat = 0xA1,
+    OpenAlliance = 0x88,
+
+    ReverseCamera = 0x90,
+    StrafeLeft = 0x91,
+    StrafeRight = 0x92,
+    TurnLeft = 0xA2,
+    TurnRight = 0xA3,
+    MoveBackward = 0xAC,
+    MoveForward = 0xAD,
+    CancelAction = 0xAF,
+    Interact = 0x80,
+    ReverseDirection = 0xB1,
+    Autorun = 0xB7,
+    Follow = 0xCC,
+
+    // Targeting
+    TargetPartyMember1 = 0x96,
+    TargetPartyMember2,
+    TargetPartyMember3,
+    TargetPartyMember4,
+    TargetPartyMember5,
+    TargetPartyMember6,
+    TargetPartyMember7,
+    TargetPartyMember8,
+    TargetPartyMember9 = 0xC6,
+    TargetPartyMember10,
+    TargetPartyMember11,
+    TargetPartyMember12,
+
+    TargetNearestItem = 0xC3,
+    TargetNextItem = 0xC4,
+    TargetPreviousItem = 0xC5,
+    TargetPartyMemberNext = 0xCA,
+    TargetPartyMemberPrevious = 0xCB,
+    TargetAllyNearest = 0xBC,
+    ClearTarget = 0xE3,
+    TargetSelf = 0xA0, // also 0x96
+    TargetPriorityTarget = 0x9F,
+    TargetNearestEnemy = 0x93,
+    TargetNextEnemy = 0x95,
+    TargetPreviousEnemy = 0x9E,
+
+    ShowOthers = 0x89,
+    ShowTargets = 0x94,
+
+    CameraZoomIn = 0xCE,
+    CameraZoomOut = 0xCF,
+
+    // Party/Hero commands
+    ClearPartyCommands = 0xDB,
+    CommandParty = 0xD6,
+    CommandHero1,
+    CommandHero2,
+    CommandHero3,
+    CommandHero4 = 0x102,
+    CommandHero5,
+    CommandHero6,
+    CommandHero7,
+
+    OpenHero1PetCommander = 0xE0,
+    OpenHero2PetCommander,
+    OpenHero3PetCommander,
+    OpenHero4PetCommander = 0xFE,
+    OpenHero5PetCommander,
+    OpenHero6PetCommander,
+    OpenHero7PetCommander,
+    OpenHeroCommander1 = 0xDC,
+    OpenHeroCommander2,
+    OpenHeroCommander3,
+    OpenPetCommander,
+    OpenHeroCommander4 = 0x126,
+    OpenHeroCommander5,
+    OpenHeroCommander6,
+    OpenHeroCommander7,
+
+    Hero1Skill1 = 0xE5,
+    Hero1Skill2,
+    Hero1Skill3,
+    Hero1Skill4,
+    Hero1Skill5,
+    Hero1Skill6,
+    Hero1Skill7,
+    Hero1Skill8,
+    Hero2Skill1,
+    Hero2Skill2,
+    Hero2Skill3,
+    Hero2Skill4,
+    Hero2Skill5,
+    Hero2Skill6,
+    Hero2Skill7,
+    Hero2Skill8,
+    Hero3Skill1,
+    Hero3Skill2,
+    Hero3Skill3,
+    Hero3Skill4,
+    Hero3Skill5,
+    Hero3Skill6,
+    Hero3Skill7,
+    Hero3Skill8,
+    Hero4Skill1 = 0x106,
+    Hero4Skill2,
+    Hero4Skill3,
+    Hero4Skill4,
+    Hero4Skill5,
+    Hero4Skill6,
+    Hero4Skill7,
+    Hero4Skill8,
+    Hero5Skill1,
+    Hero5Skill2,
+    Hero5Skill3,
+    Hero5Skill4,
+    Hero5Skill5,
+    Hero5Skill6,
+    Hero5Skill7,
+    Hero5Skill8,
+    Hero6Skill1,
+    Hero6Skill2,
+    Hero6Skill3,
+    Hero6Skill4,
+    Hero6Skill5,
+    Hero6Skill6,
+    Hero6Skill7,
+    Hero6Skill8,
+    Hero7Skill1,
+    Hero7Skill2,
+    Hero7Skill3,
+    Hero7Skill4,
+    Hero7Skill5,
+    Hero7Skill6,
+    Hero7Skill7,
+    Hero7Skill8,
+
+    // Skills
+    UseSkill1 = 0xA4,
+    UseSkill2,
+    UseSkill3,
+    UseSkill4,
+    UseSkill5,
+    UseSkill6,
+    UseSkill7,
+    UseSkill8
+};

Daybreak.API/Interop/GuildWars/Uuid.cs

@@ -0,0 +1,108 @@
+using System.Globalization;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+public readonly struct Uuid(
+    uint timeLow,
+    ushort timeMid,
+    ushort timeHighAndVersion,
+    byte clockSqHi,
+    byte clockSqLow,
+    byte node0,
+    byte node1,
+    byte node2,
+    byte node3,
+    byte node4,
+    byte node5) : IEquatable<Uuid>
+{
+    public const uint NodeLength = 6;
+
+    public readonly uint TimeLow = timeLow;
+    public readonly ushort TimeMid = timeMid;
+    public readonly ushort TimeHighAndVersion = timeHighAndVersion;
+    public readonly byte ClockSqHiAndRes = clockSqHi;
+    public readonly byte ClockSqLow = clockSqLow;
+    public readonly byte Node0 = node0;
+    public readonly byte Node1 = node1;
+    public readonly byte Node2 = node2;
+    public readonly byte Node3 = node3;
+    public readonly byte Node4 = node4;
+    public readonly byte Node5 = node5;
+
+    public bool Equals(Uuid other)
+    {
+        return this.TimeLow == other.TimeLow &&
+            this.TimeMid == other.TimeMid &&
+            this.TimeHighAndVersion == other.TimeHighAndVersion &&
+            this.ClockSqHiAndRes == other.ClockSqHiAndRes &&
+            this.ClockSqLow == other.ClockSqLow &&
+            this.Node0 == other.Node0 &&
+            this.Node1 == other.Node1 &&
+            this.Node2 == other.Node2 &&
+            this.Node3 == other.Node3 &&
+            this.Node4 == other.Node4 &&
+            this.Node5 == other.Node5;
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is Uuid uuid && this.Equals(uuid);
+    }
+
+    public static bool operator ==(Uuid left, Uuid right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Uuid left, Uuid right)
+    {
+        return !(left == right);
+    }
+
+    public static bool TryParse(string uuidString, out Uuid uuid)
+    {
+        if (uuidString.Length != 36)
+        {
+            uuid = default;
+            return false;
+        }
+
+        var parts = uuidString.Split('-');
+        if (parts.Length != 5)
+        {
+            uuid = default;
+            return false;
+        }
+
+        if (!uint.TryParse(parts[0], NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var timeLow) ||
+            !ushort.TryParse(parts[1], NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var timeMid) ||
+            !ushort.TryParse(parts[2], NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var timeHighAndVersion) ||
+            !byte.TryParse(parts[3].AsSpan(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var clockSqHi) ||
+            !byte.TryParse(parts[3].AsSpan(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var clockSqLow) ||
+            !byte.TryParse(parts[4].AsSpan(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var node0) ||
+            !byte.TryParse(parts[4].AsSpan(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var node1) ||
+            !byte.TryParse(parts[4].AsSpan(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var node2) ||
+            !byte.TryParse(parts[4].AsSpan(6, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var node3) ||
+            !byte.TryParse(parts[4].AsSpan(8, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var node4) ||
+            !byte.TryParse(parts[4].AsSpan(10, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var node5))
+        {
+            uuid = default;
+            return false;
+        }
+
+        uuid = new Uuid(timeLow, timeMid, timeHighAndVersion, clockSqHi, clockSqLow, node0, node1, node2, node3, node4, node5);
+        return true;
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine<uint, ushort, ushort, byte, byte, byte[]>(this.TimeLow, this.TimeMid, this.TimeHighAndVersion, this.ClockSqHiAndRes, this.ClockSqLow, [this.Node0, this.Node1, this.Node2, this.Node3, this.Node4, this.Node5]);
+    }
+
+    public override string ToString()
+    {
+        return $"{this.TimeLow:X8}-{this.TimeMid:X4}-{this.TimeHighAndVersion:X4}-{this.ClockSqHiAndRes:X2}{this.ClockSqLow:X2}-{this.Node0:X2}{this.Node1:X2}{this.Node2:X2}{this.Node3:X2}{this.Node4:X2}{this.Node5:X2}";
+    }
+
+    public readonly static Uuid Zero = new(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}

Daybreak.API/Interop/GuildWars/WorldContext.cs

@@ -0,0 +1,173 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop.GuildWars;
+
+[StructLayout(LayoutKind.Explicit, Pack = 1)]
+public readonly unsafe struct WorldContext
+{
+    [FieldOffset(0x0000)]
+    public readonly AccountInfoContext* AccountInfo;
+
+    [FieldOffset(0x0024)]
+    public readonly GuildWarsArray<uint> MerchItems;
+
+    [FieldOffset(0x0034)]
+    public readonly GuildWarsArray<uint> MerchItems2;
+
+    [FieldOffset(0x007C)]
+    public readonly GuildWarsArray<MapAgentContext> MapAgents;
+
+    [FieldOffset(0x009C)]
+    public readonly Vector3 AllFlag;
+
+    [FieldOffset(0x00AC)]
+    public readonly GuildWarsArray<PartyAttribute> Attributes;
+
+    [FieldOffset(0x0508)]
+    public readonly GuildWarsArray<AgentEffects> PartyEffects;
+
+    [FieldOffset(0x0528)]
+    public readonly uint ActiveQuestId;
+
+    [FieldOffset(0x052C)]
+    public readonly GuildWarsArray<QuestContext> QuestLog;
+
+    [FieldOffset(0x0564)]
+    public readonly GuildWarsArray<MissionObjectiveContext> MissionObjectives;
+
+    [FieldOffset(0x0574)]
+    public readonly GuildWarsArray<uint> HenchmenAgentIds;
+
+    [FieldOffset(0x0584)]
+    public readonly GuildWarsArray<HeroFlag> HeroFlags;
+
+    [FieldOffset(0x0594)]
+    public readonly GuildWarsArray<HeroInfo> HeroInfos;
+
+    [FieldOffset(0x05A4)]
+    public readonly GuildWarsArray<nuint> CartographedAreas;
+
+    [FieldOffset(0x05BC)]
+    public readonly GuildWarsArray<ControlledMinion> ControlledMinions;
+
+    [FieldOffset(0x05CC)]
+    public readonly GuildWarsArray<uint> MissionsCompleted;
+
+    [FieldOffset(0x05DC)]
+    public readonly GuildWarsArray<uint> MissionsBonus;
+
+    [FieldOffset(0x05EC)]
+    public readonly GuildWarsArray<uint> MissionsCompletedHardMode;
+
+    [FieldOffset(0x05FC)]
+    public readonly GuildWarsArray<uint> MissionsBonusHardMode;
+
+    [FieldOffset(0x060C)]
+    public readonly GuildWarsArray<uint> UnlockedMap;
+
+    [FieldOffset(0x062C)]
+    public readonly GuildWarsArray<PartyMoraleContext> PartyMorale;
+
+    [FieldOffset(0x067C)]
+    public readonly uint PlayerNumber;
+
+    [FieldOffset(0x0680)]
+    public readonly PlayerControlledCharContext* PlayerControlledChar;
+
+    [FieldOffset(0x0684)]
+    public readonly uint HardModeUnlocked;
+
+    [FieldOffset(0x06AC)]
+    public readonly GuildWarsArray<PetContext> Pets;
+
+    [FieldOffset(0x06BC)]
+    public readonly GuildWarsArray<ProfessionsContext> Professions;
+
+    [FieldOffset(0x06F0)]
+    public readonly GuildWarsArray<SkillbarContext> Skillbars;
+
+    [FieldOffset(0x0700)]
+    public readonly GuildWarsArray<uint> LearnableCharacterSkills;
+
+    [FieldOffset(0x0710)]
+    public readonly GuildWarsArray<uint> UnlockedCharacterSkills;
+
+    [FieldOffset(0x0720)]
+    public readonly GuildWarsArray<DupeSkill> DupeSkills;
+
+    [FieldOffset(0x0740)]
+    public readonly uint Experience;
+
+    [FieldOffset(0x0748)]
+    public readonly uint CurrentKurzick;
+
+    [FieldOffset(0x0750)]
+    public readonly uint TotalKurzick;
+
+    [FieldOffset(0x0758)]
+    public readonly uint CurrentLuxon;
+
+    [FieldOffset(0x0760)]
+    public readonly uint TotalLuxon;
+
+    [FieldOffset(0x0768)]
+    public readonly uint CurrentImperial;
+
+    [FieldOffset(0x0770)]
+    public readonly uint TotalImperial;
+
+    [FieldOffset(0x0788)]
+    public readonly uint Level;
+
+    [FieldOffset(0x0790)]
+    public readonly uint Morale;
+
+    [FieldOffset(0x0798)]
+    public readonly uint CurrentBalthazar;
+
+    [FieldOffset(0x07A0)]
+    public readonly uint TotalBalthazar;
+
+    [FieldOffset(0x07A8)]
+    public readonly uint CurrentSkillPoints;
+
+    [FieldOffset(0x07B0)]
+    public readonly uint TotalSkillPoints;
+
+    [FieldOffset(0x07B8)]
+    public readonly uint MaxKurzick;
+
+    [FieldOffset(0x07BC)]
+    public readonly uint MaxLuxon;
+
+    [FieldOffset(0x07C0)]
+    public readonly uint MaxBalthazar;
+
+    [FieldOffset(0x07C4)]
+    public readonly uint MaxImperial;
+
+    [FieldOffset(0x07CC)]
+    public readonly GuildWarsArray<AgentInfo> AgentInfos;
+
+    [FieldOffset(0x07FC)]
+    public readonly GuildWarsArray<NpcContext> Npcs;
+
+    [FieldOffset(0x080C)]
+    public readonly GuildWarsArray<PlayerContext> Players;
+
+    [FieldOffset(0x081C)]
+    public readonly GuildWarsArray<TitleContext> Titles;
+
+    [FieldOffset(0x082C)]
+    public readonly GuildWarsArray<TitleTier> TitleTiers;
+
+    [FieldOffset(0x083C)]
+    public readonly GuildWarsArray<uint> VanquishedAreas;
+
+    [FieldOffset(0x084C)]
+    public readonly uint FoesKilled;
+
+    [FieldOffset(0x0850)]
+    public readonly uint FoesToKill;
+}

Daybreak.API/Interop/GuildWars/WrappedPointer.cs

@@ -0,0 +1,37 @@
+namespace Daybreak.API.Interop.GuildWars;
+
+public readonly unsafe struct WrappedPointer<T>(T* pointer)
+    where T : unmanaged
+{
+    public readonly T* Pointer = pointer;
+
+    public bool IsNull => this.Pointer is null;
+
+    public static implicit operator WrappedPointer<T>(T* pointer) => new(pointer);
+
+    public static implicit operator T*(WrappedPointer<T> wrappedPointer) => wrappedPointer.Pointer;
+
+    public static bool operator ==(T* left, WrappedPointer<T> right) => left == right.Pointer;
+
+    public static bool operator !=(T* left, WrappedPointer<T> right) => left != right.Pointer;
+
+    public static bool operator ==(WrappedPointer<T> left, T* right) => left.Pointer == right;
+
+    public static bool operator !=(WrappedPointer<T> left, T* right) => left.Pointer != right;
+
+    public static bool operator ==(WrappedPointer<T> left, WrappedPointer<T> right) => left.Pointer == right.Pointer;
+
+    public static bool operator !=(WrappedPointer<T> left, WrappedPointer<T> right) => left.Pointer != right.Pointer;
+
+    public override int GetHashCode() => this.Pointer is null ? 0 : this.Pointer->GetHashCode();
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is WrappedPointer<T> wrappedPointer)
+        {
+            return this.Pointer == wrappedPointer.Pointer;
+        }
+
+        return false;
+    }
+}

Daybreak.API/Interop/IHook.cs

@@ -0,0 +1,9 @@
+namespace Daybreak.API.Interop;
+
+public interface IHook<T>
+    : IDisposable where T : Delegate
+{
+    public T Continue { get; }
+
+    public nuint ContinueAddress { get; }
+}

Daybreak.API/Interop/ManagedFrame.cs

@@ -0,0 +1,19 @@
+using Daybreak.API.Interop.GuildWars;
+
+namespace Daybreak.API.Interop;
+
+public readonly struct ManagedFrame(
+    WrappedPointer<Frame> frame,
+    Action closeFrame) : IDisposable
+{
+    private readonly Action closeFrame = closeFrame;
+
+    public static ManagedFrame Null => new(null, () => { });
+
+    public readonly WrappedPointer<Frame> Frame = frame;
+
+    public void Dispose()
+    {
+        this.closeFrame();
+    }
+}

Daybreak.API/Interop/MemoryPackExtensions.cs

@@ -0,0 +1,31 @@
+using MemoryPack;
+using System.Buffers;
+
+namespace Daybreak.API.Interop;
+
+public static class MemoryPackExtensions
+{
+    /// <summary>Serialize <paramref name="value"/> into <paramref name="destination"/>.</summary>
+    /// <returns>Number of bytes written.</returns>
+    public static int SerializeToSpan<T>(T value, Span<byte> destination)
+    {
+        var dummy = DummyBufferWriter.Instance;
+
+        using var state = MemoryPackWriterOptionalStatePool.Rent(null);
+
+        var writer = new MemoryPackWriter<DummyBufferWriter>(ref dummy, destination, state);
+
+        writer.WriteValue(value);
+        writer.Flush();
+
+        return writer.WrittenCount;
+    }
+
+    private sealed class DummyBufferWriter : IBufferWriter<byte>
+    {
+        public static readonly DummyBufferWriter Instance = new();
+        public void Advance(int count) { /* ignore – we never overflow destination */ }
+        public Memory<byte> GetMemory(int sizeHint = 0) => throw new NotSupportedException();
+        public Span<byte> GetSpan(int sizeHint = 0) => throw new NotSupportedException();
+    }
+}

Daybreak.API/Interop/PointerValue.cs

@@ -0,0 +1,78 @@
+using Daybreak.API.Converters;
+using System.Text.Json.Serialization;
+
+namespace Daybreak.API.Interop;
+
+[JsonConverter(typeof(PointerValueConverter))]
+public readonly struct PointerValue(nuint address) : IEquatable<PointerValue>, IEquatable<nuint>, IEquatable<nint>
+{
+    public readonly nuint Address = address;
+
+    public bool Equals(PointerValue other)
+    {
+        return this.Address.Equals(other.Address);
+    }
+
+    public bool Equals(nuint other)
+    {
+        return this.Address.Equals(other);
+    }
+
+    public bool Equals(nint other)
+    {
+        return this.Address.Equals((nuint)other);
+    }
+
+    public override string ToString()
+    {
+        return $"0x{this.Address:X8}";
+    }
+
+    public override bool Equals(object? obj) => obj is PointerValue value && this.Equals(value);
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(this.Address);
+    }
+
+    public static bool operator ==(PointerValue left, PointerValue right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(PointerValue left, PointerValue right)
+    {
+        return !(left == right);
+    }
+
+    public static implicit operator PointerValue(nuint address)
+    {
+        return new PointerValue(address);
+    }
+
+    public static implicit operator PointerValue(nint address)
+    {
+        return new PointerValue((nuint)address);
+    }
+
+    public static implicit operator PointerValue(int address)
+    {
+        return new PointerValue((nuint)address);
+    }
+
+    public static implicit operator PointerValue(uint address)
+    {
+        return new PointerValue(address);
+    }
+
+    public static PointerValue Parse(string s)
+    {
+        if (s.StartsWith("0x", StringComparison.InvariantCultureIgnoreCase)
+            && nuint.TryParse(s.AsSpan(2), System.Globalization.NumberStyles.HexNumber, null, out var v))
+        {
+            return new PointerValue(v);
+        }
+
+        throw new FormatException($"Invalid pointer format: {s}");
+    }
+}

Daybreak.API/Interop/UnmanagedStruct.cs

@@ -0,0 +1,22 @@
+using System.Runtime.InteropServices;
+
+namespace Daybreak.API.Interop;
+
+public sealed class UnmanagedStruct<T> : IDisposable
+    where T : struct
+{
+    public nint Address { get; private set; }
+
+    public UnmanagedStruct(T value)
+    {
+        this.Address = Marshal.AllocHGlobal(Marshal.SizeOf<T>());
+        Marshal.StructureToPtr(value, this.Address, false);
+    }
+
+    public void Dispose()
+    {
+        Marshal.DestroyStructure<T>(this.Address);
+        Marshal.FreeHGlobal(this.Address);
+        this.Address = 0x0;
+    }
+}

Daybreak.API/Logging/LoggingEnrichmentMiddleware.cs

@@ -0,0 +1,29 @@
+using Microsoft.CorrelationVector;
+using Microsoft.Extensions.Options;
+using Net.Sdk.Web;
+using Net.Sdk.Web.Options;
+using Serilog.Context;
+
+namespace Daybreak.API.Logging;
+
+public sealed class LoggingEnrichmentMiddleware(IOptions<CorrelationVectorOptions> options)
+    : IMiddleware
+{
+    private readonly CorrelationVectorOptions options = options.Value;
+
+    public Task InvokeAsync(HttpContext context, RequestDelegate next)
+    {
+        if (!context.Request.Headers.TryGetValue(this.options.Header, out var value) ||
+            value.FirstOrDefault() is not string cvString ||
+            CorrelationVector.Parse(cvString) is not CorrelationVector cv)
+        {
+            cv = new CorrelationVector();
+        }
+
+        cv = CorrelationVector.Extend(cv.ToString());
+        context.SetCorrelationVector(cv);
+        LogContext.PushProperty("CorrelationVector", cv);
+        HeaderDictionaryExtensions.Append(context.Response.Headers, this.options.Header, context.GetCorrelationVector().ToString());
+        return next(context);
+    }
+}

Daybreak.API/Logging/WebApplicationBuilderExtensions.cs

@@ -0,0 +1,36 @@
+using Serilog.Settings.Configuration;
+using Serilog.Sinks.SystemConsole.Themes;
+using Serilog;
+using Net.Sdk.Web.Options;
+
+namespace Daybreak.API.Logging;
+
+public static class WebApplicationBuilderExtensions
+{
+    public static WebApplicationBuilder WithLogging(this WebApplicationBuilder builder)
+    {
+        builder.Logging.ClearProviders();
+        builder.Logging.AddSerilog(new LoggerConfiguration()
+            .ReadFrom.Configuration(builder.Configuration, new ConfigurationReaderOptions
+            {
+                SectionName = "Logging"
+            })
+            .Enrich.FromLogContext()
+            .WriteTo.Console(
+                outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss}] {Level:u4}: [{SourceContext}] [{CorrelationVector}] {NewLine}{Message:lj}{NewLine}{Exception}",
+                theme: AnsiConsoleTheme.Sixteen)
+            .WriteTo.File(
+                outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss}] {Level:u4}: [{SourceContext}] [{CorrelationVector}] {NewLine}{Message:lj}{NewLine}{Exception}",
+                path: "Daybreak.API.log",
+                rollingInterval: RollingInterval.Day,
+                rollOnFileSizeLimit: true,
+                fileSizeLimitBytes: 50 * 1024 * 1024,
+                retainedFileCountLimit: 1,
+                shared: true)
+            .CreateLogger());
+        builder.Services.AddScoped<LoggingEnrichmentMiddleware>();
+        builder.Services.AddOptions<CorrelationVectorOptions>()
+            .Bind(builder.Configuration.GetSection("Correlation"));
+        return builder;
+    }
+}

Daybreak.API/Logging/WebApplicationExtensions.cs

@@ -0,0 +1,10 @@
+namespace Daybreak.API.Logging;
+
+public static class WebApplicationExtensions
+{
+    public static WebApplication UseLogging(this WebApplication app)
+    {
+        app.UseMiddleware<LoggingEnrichmentMiddleware>();
+        return app;
+    }
+}

Daybreak.API/Models/AddressState.cs

@@ -0,0 +1,9 @@
+using Daybreak.API.Interop;
+
+namespace Daybreak.API.Models;
+
+public sealed class AddressState
+{
+    public required string Name { get; init; }
+    public required PointerValue Address { get; init; }
+}

Daybreak.API/Models/AsyncRefreshCache.cs

@@ -0,0 +1,38 @@
+using System.Core.Extensions;
+using System.Extensions;
+
+namespace Daybreak.API.Models;
+
+public sealed class AsyncRefreshCache<T>(TimeSpan refreshRate, Func<CancellationToken, ValueTask<T>> refreshFunc)
+{
+    private readonly Func<CancellationToken, ValueTask<T>> refreshFunc = refreshFunc.ThrowIfNull();
+    
+    private readonly SemaphoreSlim semaphoreSlim = new(1);
+    
+    private T? cache;
+    private DateTime lastUpdateDateTime = DateTime.MinValue;
+    private TimeSpan refreshRate = refreshRate;
+
+    public async ValueTask<T> GetAsync(CancellationToken cancellationToken)
+    {
+        if (this.cache is not null && DateTime.UtcNow - this.lastUpdateDateTime < this.refreshRate)
+        {
+            return this.cache;
+        }
+
+        using var ctx = await this.semaphoreSlim.Acquire(cancellationToken);
+        if (DateTime.UtcNow - this.lastUpdateDateTime > this.refreshRate ||
+            this.cache is null)
+        {
+            this.lastUpdateDateTime = DateTime.UtcNow;
+            this.cache = await this.refreshFunc(cancellationToken);
+        }
+
+        return this.cache;
+    }
+
+    public void UpdateRefreshRate(TimeSpan newRefreshRate)
+    {
+        this.refreshRate = newRefreshRate;
+    }
+}

Daybreak.API/Models/ByteConsumerEntry.cs

@@ -0,0 +1,23 @@
+using System.Core.Extensions;
+
+namespace Daybreak.API.Models;
+
+public sealed class ByteConsumerEntry(
+    Guid id, TimeSpan freq, Action<ReadOnlySpan<byte>> handler)
+{
+    private readonly Action<ReadOnlySpan<byte>> handler = handler.ThrowIfNull();
+
+    private DateTime lastConsume = DateTime.MinValue;
+
+    public Guid Id { get; } = id;
+    public TimeSpan Frequency { get; } = freq;
+
+    public void TryConsume(DateTime currentTime, ReadOnlySpan<byte> value)
+    {
+        if (currentTime - this.lastConsume >= this.Frequency)
+        {
+            this.handler(value);
+            this.lastConsume = currentTime;
+        }
+    }
+}

Daybreak.API/Models/CallbackRegistration.cs

@@ -0,0 +1,14 @@
+using System.Core.Extensions;
+
+namespace Daybreak.API.Models;
+
+public sealed class CallbackRegistration(Guid uid, Action onDispose) : IDisposable
+{
+    private readonly Guid uid = uid;
+    private readonly Action onDispose = onDispose.ThrowIfNull();
+
+    public void Dispose()
+    {
+        this.onDispose();
+    }
+}