Test: add a failing test for big int

Core: move MultiServer.py and CommonClient.py to orjson
2026-05-27 16:40:05 -07:00 · 2025-08-03 10:54:17 +02:00 · 2025-08-03 08:20:21 +02:00
1181 changed files with 37047 additions and 214564 deletions
@@ -46,6 +46,7 @@ dist
 /prof/
 README.html
 .vs/
+EnemizerCLI/
 /Players/
 /SNI/
 /sni-*/
@@ -2,16 +2,11 @@
  "include": [
    "../BizHawkClient.py",
    "../Patch.py",
-    "../rule_builder/cached_world.py",
-    "../rule_builder/field_resolvers.py",
-    "../rule_builder/options.py",
-    "../rule_builder/rules.py",
    "../test/param.py",
    "../test/general/test_groups.py",
    "../test/general/test_helpers.py",
    "../test/general/test_memory.py",
    "../test/general/test_names.py",
-    "../test/general/test_rule_builder.py",
    "../test/multiworld/__init__.py",
    "../test/multiworld/test_multiworlds.py",
    "../test/netutils/__init__.py",
@@ -19,7 +14,6 @@
    "../test/programs/test_multi_server.py",
    "../test/utils/__init__.py",
    "../test/webhost/test_descriptions.py",
-    "../test/webhost/test_suuid.py",
    "../worlds/AutoSNIClient.py",
    "type_check.py"
  ],
@@ -35,7 +29,7 @@
  "reportMissingImports": true,
  "reportMissingTypeStubs": true,

-  "pythonVersion": "3.11",
+  "pythonVersion": "3.10",
  "pythonPlatform": "Windows",

  "executionEnvironments": [
@@ -14,8 +14,6 @@ env:
  BEFORE: ${{ github.event.before }}
  AFTER: ${{ github.event.after }}

-permissions: {}
-
 jobs:
  flake8-or-mypy:
    strategy:
@@ -27,7 +25,7 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@v4

      - name: "Determine modified files (pull_request)"
        if: github.event_name == 'pull_request'
@@ -52,10 +50,10 @@ jobs:
        run: |
          echo "diff=." >> $GITHUB_ENV

-      - uses: actions/setup-python@v6.2.0
+      - uses: actions/setup-python@v5
        if: env.diff != ''
        with:
-          python-version: '3.11'
+          python-version: '3.10'

      - name: "Install dependencies"
        if: env.diff != ''
@@ -1,5 +1,4 @@
-# This workflow will build a release-like distribution when manually dispatched:
-# a Windows x64 7zip, a Windows x64 Installer, a Linux AppImage and a Linux binary .tar.gz.
+# This workflow will build a release-like distribution when manually dispatched

 name: Build

@@ -10,25 +9,22 @@ on:
      - 'setup.py'
      - 'requirements.txt'
      - '*.iss'
-      - 'worlds/*/archipelago.json'
  pull_request:
    paths:
      - '.github/workflows/build.yml'
      - 'setup.py'
      - 'requirements.txt'
      - '*.iss'
-      - 'worlds/*/archipelago.json'
  workflow_dispatch:

 env:
  ENEMIZER_VERSION: 7.1
  # NOTE: since appimage/appimagetool and appimage/type2-runtime does not have tags anymore,
  #       we check the sha256 and require manual intervention if it was updated.
-  APPIMAGE_FORK: 'PopTracker'
-  APPIMAGETOOL_VERSION: 'r-2025-11-18'
-  APPIMAGETOOL_X86_64_HASH: '4577a452b30af2337123fbb383aea154b618e51ad5448c3b62085cbbbfbfd9a2'
-  APPIMAGE_RUNTIME_VERSION: 'r-2025-11-07'
-  APPIMAGE_RUNTIME_X86_64_HASH: '27ddd3f78e483fc5f7856e413d7c17092917f8c35bfe3318a0d378aa9435ad17'
+  APPIMAGETOOL_VERSION: continuous
+  APPIMAGETOOL_X86_64_HASH: '363dafac070b65cc36ca024b74db1f043c6f5cd7be8fca760e190dce0d18d684'
+  APPIMAGE_RUNTIME_VERSION: continuous
+  APPIMAGE_RUNTIME_X86_64_HASH: 'e3c4dfb70eddf42e7e5a1d28dff396d30563aa9a901970aebe6f01f3fecf9f8e'

 permissions:  # permissions required for attestation
  id-token: 'write'
@@ -41,9 +37,9 @@ jobs:
    runs-on: windows-latest
    steps:
      # - copy code below to release.yml -
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@v4
      - name: Install python
-        uses: actions/setup-python@v6.2.0
+        uses: actions/setup-python@v5
        with:
          python-version: '~3.12.7'
          check-latest: true
@@ -51,7 +47,7 @@ jobs:
        run: |
          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
          Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
-          choco install innosetup --version=6.7.0 --allow-downgrade
+          choco install innosetup --version=6.2.2 --allow-downgrade
      - name: Build
        run: |
          python -m pip install --upgrade pip
@@ -82,7 +78,7 @@ jobs:
      # - copy code above to release.yml -
      - name: Attest Build
        if: ${{ github.event_name == 'workflow_dispatch' }}
-        uses: actions/attest@v4.1.0
+        uses: actions/attest-build-provenance@v2
        with:
          subject-path: |
            build/exe.*/ArchipelagoLauncher.exe
@@ -110,17 +106,18 @@ jobs:
          cp Players/Templates/VVVVVV.yaml Players/
          timeout 30 ./ArchipelagoGenerate
      - name: Store 7z
-        uses: actions/upload-artifact@v7.0.0
+        uses: actions/upload-artifact@v4
        with:
+          name: ${{ env.ZIP_NAME }}
          path: dist/${{ env.ZIP_NAME }}
-          archive: false
+          compression-level: 0  # .7z is incompressible by zip
          if-no-files-found: error
          retention-days: 7  # keep for 7 days, should be enough
      - name: Store Setup
-        uses: actions/upload-artifact@v7.0.0
+        uses: actions/upload-artifact@v4
        with:
+          name: ${{ env.SETUP_NAME }}
          path: setups/${{ env.SETUP_NAME }}
-          archive: false
          if-no-files-found: error
          retention-days: 7  # keep for 7 days, should be enough

@@ -128,23 +125,23 @@ jobs:
    runs-on: ubuntu-22.04
    steps:
      # - copy code below to release.yml -
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@v4
      - name: Install base dependencies
        run: |
          sudo apt update
          sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
          sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
      - name: Get a recent python
-        uses: actions/setup-python@v6.2.0
+        uses: actions/setup-python@v5
        with:
          python-version: '~3.12.7'
          check-latest: true
      - name: Install build-time dependencies
        run: |
          echo "PYTHON=python3.12" >> $GITHUB_ENV
-          wget -nv https://github.com/$APPIMAGE_FORK/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          wget -nv https://github.com/AppImage/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
          echo "$APPIMAGETOOL_X86_64_HASH appimagetool-x86_64.AppImage" | sha256sum -c
-          wget -nv https://github.com/$APPIMAGE_FORK/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
+          wget -nv https://github.com/AppImage/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
          echo "$APPIMAGE_RUNTIME_X86_64_HASH runtime-x86_64" | sha256sum -c
          chmod a+rx appimagetool-x86_64.AppImage
          ./appimagetool-x86_64.AppImage --appimage-extract
@@ -172,7 +169,7 @@ jobs:
      # - copy code above to release.yml -
      - name: Attest Build
        if: ${{ github.event_name == 'workflow_dispatch' }}
-        uses: actions/attest@v4.1.0
+        uses: actions/attest-build-provenance@v2
        with:
          subject-path: |
            build/exe.*/ArchipelagoLauncher
@@ -203,17 +200,17 @@ jobs:
          cp Players/Templates/VVVVVV.yaml Players/
          timeout 30 ./ArchipelagoGenerate
      - name: Store AppImage
-        uses: actions/upload-artifact@v7.0.0
+        uses: actions/upload-artifact@v4
        with:
+          name: ${{ env.APPIMAGE_NAME }}
          path: dist/${{ env.APPIMAGE_NAME }}
-          archive: false
-          # TODO: decide if we want to also upload the zsync
          if-no-files-found: error
          retention-days: 7
      - name: Store .tar.gz
-        uses: actions/upload-artifact@v7.0.0
+        uses: actions/upload-artifact@v4
        with:
+          name: ${{ env.TAR_NAME }}
          path: dist/${{ env.TAR_NAME }}
-          archive: false
+          compression-level: 0  # .gz is incompressible by zip
          if-no-files-found: error
          retention-days: 7
@@ -17,26 +17,17 @@ on:
    paths:
      - '**.py'
      - '**.js'
-      - '.github/workflows/*.yml'
-      - '.github/workflows/*.yaml'
-      - '**/action.yml'
-      - '**/action.yaml'
+      - '.github/workflows/codeql-analysis.yml'
  pull_request:
    # The branches below must be a subset of the branches above
    branches: [ main ]
    paths:
      - '**.py'
      - '**.js'
-      - '.github/workflows/*.yml'
-      - '.github/workflows/*.yaml'
-      - '**/action.yml'
-      - '**/action.yaml'
+      - '.github/workflows/codeql-analysis.yml'
  schedule:
    - cron: '44 8 * * 1'

-permissions:
-  security-events: write
-
 jobs:
  analyze:
    name: Analyze
@@ -45,17 +36,18 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        language: [ 'javascript', 'python', 'actions' ]
+        language: [ 'javascript', 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
        # Learn more:
        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v6.0.2
+      uses: actions/checkout@v4

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v4.35.1
+      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.
@@ -66,7 +58,7 @@ jobs:
    # 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: Autobuild
-      uses: github/codeql-action/autobuild@v4.35.1
+      uses: github/codeql-action/autobuild@v3

    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 https://git.io/JvXDl
@@ -80,4 +72,4 @@ jobs:
    #   make release

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v4.35.1
+      uses: github/codeql-action/analyze@v3
@@ -24,8 +24,6 @@ on:
      - '**/CMakeLists.txt'
      - '.github/workflows/ctest.yml'

-permissions: {}
-
 jobs:
  ctest:
    runs-on: ${{ matrix.os }}
@@ -37,7 +35,7 @@ jobs:
        os: [ubuntu-latest, windows-latest]

    steps:
-    - uses: actions/checkout@v6.0.2
+    - uses: actions/checkout@v4
    - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756
      if: startsWith(matrix.os,'windows')
    - uses: Bacondish2023/setup-googletest@49065d1f7a6d21f6134864dd65980fe5dbe06c73
@@ -1,156 +0,0 @@
-name: Build and Publish Docker Images
-
-on:
-  push:
-    paths:
-      - "**"
-      - "!docs/**"
-      - "!deploy/**"
-      - "!setup.py"
-      - "!.gitignore"
-      - "!.github/workflows/**"
-      - ".github/workflows/docker.yml"
-    branches:
-      - "main"
-    tags:
-      - "v?[0-9]+.[0-9]+.[0-9]*"
-  workflow_dispatch:
-
-env:
-  REGISTRY: ghcr.io
-
-permissions: {}
-
-jobs:
-  prepare:
-    runs-on: ubuntu-latest
-    outputs:
-      image-name: ${{ steps.image.outputs.name }}
-      tags: ${{ steps.meta.outputs.tags }}
-      labels: ${{ steps.meta.outputs.labels }}
-      package-name: ${{ steps.package.outputs.name }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6.0.2
-
-      - name: Set lowercase image name
-        id: image
-        run: |
-          echo "name=${GITHUB_REPOSITORY,,}" >> $GITHUB_OUTPUT
-
-      - name: Set package name
-        id: package
-        run: |
-          echo "name=$(basename ${GITHUB_REPOSITORY,,})" >> $GITHUB_OUTPUT
-
-      - name: Extract metadata
-        id: meta
-        uses: docker/metadata-action@v6.0.0
-        with:
-          images: ${{ env.REGISTRY }}/${{ steps.image.outputs.name }}
-          tags: |
-            type=ref,event=branch,enable={{is_not_default_branch}}
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=raw,value=nightly,enable={{is_default_branch}}
-
-      - name: Compute final tags
-        id: final-tags
-        run: |
-          readarray -t tags <<< "${{ steps.meta.outputs.tags }}"
-
-          if [[ "${{ github.ref_type }}" == "tag" ]]; then
-            tag="${{ github.ref_name }}"
-            if [[ "$tag" =~ ^v?[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-              full_latest="${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:latest"
-              # Check if latest is already in tags to avoid duplicates
-              if ! printf '%s\n' "${tags[@]}" | grep -q "^$full_latest$"; then
-                tags+=("$full_latest")
-              fi
-            fi
-          fi
-
-          # Set multiline output
-          echo "tags<<EOF" >> $GITHUB_OUTPUT
-          printf '%s\n' "${tags[@]}" >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
-
-  build:
-    needs: prepare
-    runs-on: ${{ matrix.runner }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      matrix:
-        include:
-          - platform: amd64
-            runner: ubuntu-latest
-            suffix: amd64
-            cache-scope: amd64
-          - platform: arm64
-            runner: ubuntu-24.04-arm
-            suffix: arm64
-            cache-scope: arm64
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6.0.2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd  # v4.0.0
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2  # v4.0.0
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Compute suffixed tags
-        id: tags
-        run: |
-          readarray -t tags <<< "${{ needs.prepare.outputs.tags }}"
-          suffixed=()
-          for t in "${tags[@]}"; do
-            suffixed+=("$t-${{ matrix.suffix }}")
-          done
-          echo "tags=$(IFS=','; echo "${suffixed[*]}")" >> $GITHUB_OUTPUT
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v7.0.0
-        with:
-          context: .
-          file: ./Dockerfile
-          platforms: linux/${{ matrix.platform }}
-          push: true
-          tags: ${{ steps.tags.outputs.tags }}
-          labels: ${{ needs.prepare.outputs.labels }}
-          cache-from: type=gha,scope=${{ matrix.cache-scope }}
-          cache-to: type=gha,mode=max,scope=${{ matrix.cache-scope }}
-          provenance: false
-
-  manifest:
-    needs: [prepare, build]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2  # v4.0.0
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Create and push multi-arch manifest
-        run: |
-          readarray -t tag_array <<< "${{ needs.prepare.outputs.tags }}"
-
-          for tag in "${tag_array[@]}"; do
-            docker manifest create "$tag" \
-              "$tag-amd64" \
-              "$tag-arm64"
-            
-            docker manifest push "$tag"
-          done
@@ -12,9 +12,10 @@ env:
 jobs:
  labeler:
    name: 'Apply content-based labels'
+    if: github.event.action == 'opened' || github.event.action == 'reopened' || github.event.action == 'synchronize'
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/labeler@v6.0.1
+      - uses: actions/labeler@v5
        with:
          sync-labels: false
  peer_review:
@@ -5,17 +5,16 @@ name: Release
 on:
  push:
    tags:
-      - 'v?[0-9]+.[0-9]+.[0-9]*'
+      - '*.*.*'

 env:
  ENEMIZER_VERSION: 7.1
  # NOTE: since appimage/appimagetool and appimage/type2-runtime does not have tags anymore,
  #       we check the sha256 and require manual intervention if it was updated.
-  APPIMAGE_FORK: 'PopTracker'
-  APPIMAGETOOL_VERSION: 'r-2025-11-18'
-  APPIMAGETOOL_X86_64_HASH: '4577a452b30af2337123fbb383aea154b618e51ad5448c3b62085cbbbfbfd9a2'
-  APPIMAGE_RUNTIME_VERSION: 'r-2025-11-07'
-  APPIMAGE_RUNTIME_X86_64_HASH: '27ddd3f78e483fc5f7856e413d7c17092917f8c35bfe3318a0d378aa9435ad17'
+  APPIMAGETOOL_VERSION: continuous
+  APPIMAGETOOL_X86_64_HASH: '363dafac070b65cc36ca024b74db1f043c6f5cd7be8fca760e190dce0d18d684'
+  APPIMAGE_RUNTIME_VERSION: continuous
+  APPIMAGE_RUNTIME_X86_64_HASH: 'e3c4dfb70eddf42e7e5a1d28dff396d30563aa9a901970aebe6f01f3fecf9f8e'

 permissions:  # permissions required for attestation
  id-token: 'write'
@@ -29,7 +28,7 @@ jobs:
      - name: Set env
        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV  # tag x.y.z will become "Archipelago x.y.z"
      - name: Create Release
-        uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda  # v3.0.0
+        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
        with:
          draft: true  # don't publish right away, especially since windows build is added by hand
          prerelease: false
@@ -48,9 +47,9 @@ jobs:
        shell: bash
        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
      # - code below copied from build.yml -
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@v4
      - name: Install python
-        uses: actions/setup-python@v6.2.0
+        uses: actions/setup-python@v5
        with:
          python-version: '~3.12.7'
          check-latest: true
@@ -88,7 +87,7 @@ jobs:
          echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
      # - code above copied from build.yml -
      - name: Attest Build
-        uses: actions/attest@v4.1.0
+        uses: actions/attest-build-provenance@v2
        with:
          subject-path: |
            build/exe.*/ArchipelagoLauncher.exe
@@ -97,15 +96,13 @@ jobs:
            build/exe.*/ArchipelagoServer.exe
            setups/*
      - name: Add to Release
-        uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda  # v3.0.0
+        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
        with:
          draft: true  # see above
          prerelease: false
          name: Archipelago ${{ env.RELEASE_VERSION }}
          files: |
            setups/*
-          fail_on_unmatched_files: true
-          overwrite_files: false  # Windows release is usually built by hand
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

@@ -116,23 +113,23 @@ jobs:
      - name: Set env
        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
      # - code below copied from build.yml -
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@v4
      - name: Install base dependencies
        run: |
          sudo apt update
          sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
          sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
      - name: Get a recent python
-        uses: actions/setup-python@v6.2.0
+        uses: actions/setup-python@v5
        with:
          python-version: '~3.12.7'
          check-latest: true
      - name: Install build-time dependencies
        run: |
          echo "PYTHON=python3.12" >> $GITHUB_ENV
-          wget -nv https://github.com/$APPIMAGE_FORK/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          wget -nv https://github.com/AppImage/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
          echo "$APPIMAGETOOL_X86_64_HASH appimagetool-x86_64.AppImage" | sha256sum -c
-          wget -nv https://github.com/$APPIMAGE_FORK/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
+          wget -nv https://github.com/AppImage/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
          echo "$APPIMAGE_RUNTIME_X86_64_HASH runtime-x86_64" | sha256sum -c
          chmod a+rx appimagetool-x86_64.AppImage
          ./appimagetool-x86_64.AppImage --appimage-extract
@@ -159,7 +156,7 @@ jobs:
          echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
      # - code above copied from build.yml -
      - name: Attest Build
-        uses: actions/attest@v4.1.0
+        uses: actions/attest-build-provenance@v2
        with:
          subject-path: |
            build/exe.*/ArchipelagoLauncher
@@ -167,14 +164,12 @@ jobs:
            build/exe.*/ArchipelagoServer
            dist/*
      - name: Add to Release
-        uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda  # v3.0.0
+        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
        with:
          draft: true  # see above
          prerelease: false
          name: Archipelago ${{ env.RELEASE_VERSION }}
          files: |
            dist/*
-          fail_on_unmatched_files: true
-          overwrite_files: false  # should never happen; avoids accidentally changing a release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -28,14 +28,12 @@ on:
      - 'requirements.txt'
      - '.github/workflows/scan-build.yml'

-permissions: {}
-
 jobs:
  scan-build:
    runs-on: ubuntu-latest

    steps:
-    - uses: actions/checkout@v6.0.2
+    - uses: actions/checkout@v4
      with:
        submodules: recursive
    - name: Install newer Clang
@@ -47,7 +45,7 @@ jobs:
      run: |
        sudo apt install clang-tools-19
    - name: Get a recent python
-      uses: actions/setup-python@v6.2.0
+      uses: actions/setup-python@v5
      with:
        python-version: '3.11'
    - name: Install dependencies
@@ -61,9 +59,7 @@ jobs:
        scan-build-19 --status-bugs -o scan-build-reports -disable-checker deadcode.DeadStores python setup.py build -y
    - name: Store report
      if: failure()
-      uses: actions/upload-artifact@v7.0.0
+      uses: actions/upload-artifact@v4
      with:
        name: scan-build-reports
        path: scan-build-reports
-        compression-level: 9  # highly compressible
-        if-no-files-found: error
@@ -14,15 +14,13 @@ on:
      - ".github/workflows/strict-type-check.yml"
      - "**.pyi"

-permissions: {}
-
 jobs:
  pyright:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@v4

-      - uses: actions/setup-python@v6.2.0
+      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"

@@ -29,8 +29,6 @@ on:
      - '!.github/workflows/**'
      - '.github/workflows/unittests.yml'

-permissions: {}
-
 jobs:
  unit:
    runs-on: ${{ matrix.os }}
@@ -41,27 +39,27 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        python:
-          - {version: '3.11.2'} # Change to '3.11' around 2026-06-10
+          - {version: '3.10'}
+          - {version: '3.11'}
          - {version: '3.12'}
-          - {version: '3.13'}
        include:
-          - python: {version: '3.11'}  # old compat
+          - python: {version: '3.10'}  # old compat
            os: windows-latest
-          - python: {version: '3.13'}  # current
+          - python: {version: '3.12'}  # current
            os: windows-latest
-          - python: {version: '3.13'}  # current
+          - python: {version: '3.12'}  # current
            os: macos-latest

    steps:
-    - uses: actions/checkout@v6.0.2
+    - uses: actions/checkout@v4
    - name: Set up Python ${{ matrix.python.version }}
-      uses: actions/setup-python@v6.2.0
+      uses: actions/setup-python@v5
      with:
        python-version: ${{ matrix.python.version }}
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
-        pip install -r ci-requirements.txt
+        pip install pytest pytest-subtests pytest-xdist
        python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
        python Launcher.py --update_settings  # make sure host.yaml exists for tests
    - name: Unittests
@@ -77,12 +75,12 @@ jobs:
        os:
          - ubuntu-latest
        python:
-          - {version: '3.13'}  # current
+          - {version: '3.12'}  # current

    steps:
-    - uses: actions/checkout@v6.0.2
+    - uses: actions/checkout@v4
    - name: Set up Python ${{ matrix.python.version }}
-      uses: actions/setup-python@v6.2.0
+      uses: actions/setup-python@v5
      with:
        python-version: ${{ matrix.python.version }}
    - name: Install dependencies
@@ -45,7 +45,6 @@ EnemizerCLI/
 /SNI/
 /sni-*/
 /appimagetool*
-/VC_redist.x64.exe
 /host.yaml
 /options.yaml
 /config.yaml
@@ -64,10 +63,7 @@ Output Logs/
 /installdelete.iss
 /data/user.kv
 /datapackage
-/datapackage_export.json
 /custom_worlds
-# stubgen output
-/out/

 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -1,24 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Build APWorlds" type="PythonConfigurationType" factoryName="Python">
-    <module name="Archipelago" />
-    <option name="ENV_FILES" value="" />
-    <option name="INTERPRETER_OPTIONS" value="" />
-    <option name="PARENT_ENVS" value="true" />
-    <envs>
-      <env name="PYTHONUNBUFFERED" value="1" />
-    </envs>
-    <option name="SDK_HOME" value="" />
-    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/" />
-    <option name="IS_MODULE_SDK" value="true" />
-    <option name="ADD_CONTENT_ROOTS" value="true" />
-    <option name="ADD_SOURCE_ROOTS" value="true" />
-    <option name="SCRIPT_NAME" value="$PROJECT_DIR$/Launcher.py" />
-    <option name="PARAMETERS" value="&quot;Build APWorlds&quot;" />
-    <option name="SHOW_COMMAND_LINE" value="false" />
-    <option name="EMULATE_TERMINAL" value="false" />
-    <option name="MODULE_MODE" value="false" />
-    <option name="REDIRECT_INPUT" value="false" />
-    <option name="INPUT_FILE" value="" />
-    <method v="2" />
-  </configuration>
-</component>
@@ -8,10 +8,10 @@ import secrets
 import warnings
 from argparse import Namespace
 from collections import Counter, deque, defaultdict
-from collections.abc import Callable, Collection, Iterable, Iterator, Mapping, MutableSequence, Set
+from collections.abc import Collection, MutableSequence
 from enum import IntEnum, IntFlag
-from typing import (AbstractSet, Any, ClassVar, Dict, List, Literal, NamedTuple,
-                    Optional, Protocol, Tuple, Union, TYPE_CHECKING, overload)
+from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Literal, Mapping, NamedTuple,
+                    Optional, Protocol, Set, Tuple, Union, TYPE_CHECKING, Literal, overload)
 import dataclasses

 from typing_extensions import NotRequired, TypedDict
@@ -22,7 +22,6 @@ import Utils

 if TYPE_CHECKING:
    from entrance_rando import ERPlacementState
-    from rule_builder.rules import Rule
    from worlds import AutoWorld


@@ -86,7 +85,7 @@ class MultiWorld():
    local_items: Dict[int, Options.LocalItems]
    non_local_items: Dict[int, Options.NonLocalItems]
    progression_balancing: Dict[int, Options.ProgressionBalancing]
-    completion_condition: Dict[int, CollectionRule]
+    completion_condition: Dict[int, Callable[[CollectionState], bool]]
    indirect_connections: Dict[Region, Set[Entrance]]
    exclude_locations: Dict[int, Options.ExcludeLocations]
    priority_locations: Dict[int, Options.PriorityLocations]
@@ -262,7 +261,6 @@ class MultiWorld():
                        "local_items": set(item_link.get("local_items", [])),
                        "non_local_items": set(item_link.get("non_local_items", [])),
                        "link_replacement": replacement_prio.index(item_link["link_replacement"]),
-                        "skip_if_solo": item_link.get("skip_if_solo", False),
                    }

        for _name, item_link in item_links.items():
@@ -286,8 +284,6 @@ class MultiWorld():

        for group_name, item_link in item_links.items():
            game = item_link["game"]
-            if item_link["skip_if_solo"] and len(item_link["players"]) == 1:
-                continue
            group_id, group = self.add_group(group_name, game, set(item_link["players"]))

            group["item_pool"] = item_link["item_pool"]
@@ -727,7 +723,6 @@ class CollectionState():
    advancements: Set[Location]
    path: Dict[Union[Region, Entrance], PathValue]
    locations_checked: Set[Location]
-    """Internal cache for Advancement Locations already checked by this CollectionState. Not for use in logic."""
    stale: Dict[int, bool]
    allow_partial_entrances: bool
    additional_init_functions: List[Callable[[CollectionState, MultiWorld], None]] = []
@@ -768,7 +763,7 @@ class CollectionState():
        else:
            self._update_reachable_regions_auto_indirect_conditions(player, queue)

-    def _update_reachable_regions_explicit_indirect_conditions(self, player: int, queue: deque[Entrance]):
+    def _update_reachable_regions_explicit_indirect_conditions(self, player: int, queue: deque):
        reachable_regions = self.reachable_regions[player]
        blocked_connections = self.blocked_connections[player]
        # run BFS on all connections, and keep track of those blocked by missing items
@@ -786,16 +781,13 @@ class CollectionState():
                blocked_connections.update(new_region.exits)
                queue.extend(new_region.exits)
                self.path[new_region] = (new_region.name, self.path.get(connection, None))
-                self.multiworld.worlds[player].reached_region(self, new_region)

                # Retry connections if the new region can unblock them
-                entrances = self.multiworld.indirect_connections.get(new_region)
-                if entrances is not None:
-                    relevant_entrances = entrances.intersection(blocked_connections)
-                    relevant_entrances.difference_update(queue)
-                    queue.extend(relevant_entrances)
+                for new_entrance in self.multiworld.indirect_connections.get(new_region, set()):
+                    if new_entrance in blocked_connections and new_entrance not in queue:
+                        queue.append(new_entrance)

-    def _update_reachable_regions_auto_indirect_conditions(self, player: int, queue: deque[Entrance]):
+    def _update_reachable_regions_auto_indirect_conditions(self, player: int, queue: deque):
        reachable_regions = self.reachable_regions[player]
        blocked_connections = self.blocked_connections[player]
        new_connection: bool = True
@@ -817,7 +809,6 @@ class CollectionState():
                    queue.extend(new_region.exits)
                    self.path[new_region] = (new_region.name, self.path.get(connection, None))
                    new_connection = True
-                    self.multiworld.worlds[player].reached_region(self, new_region)
            # sweep for indirect connections, mostly Entrance.can_reach(unrelated_Region)
            queue.extend(blocked_connections)

@@ -1175,17 +1166,13 @@ class CollectionState():
            self.prog_items[player][item] = count


-CollectionRule = Callable[[CollectionState], bool]
-DEFAULT_COLLECTION_RULE: CollectionRule = staticmethod(lambda state: True)
-
-
 class EntranceType(IntEnum):
    ONE_WAY = 1
    TWO_WAY = 2


 class Entrance:
-    access_rule: CollectionRule = DEFAULT_COLLECTION_RULE
+    access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
    hide_path: bool = False
    player: int
    name: str
@@ -1356,7 +1343,8 @@ class Region:
        for entrance in self.entrances:  # BFS might be better here, trying DFS for now.
            return entrance.parent_region.get_connecting_entrance(is_main_entrance)

-    def add_locations(self, locations: Mapping[str, int | None], location_type: type[Location] | None = None) -> None:
+    def add_locations(self, locations: Dict[str, Optional[int]],
+                      location_type: Optional[type[Location]] = None) -> None:
        """
        Adds locations to the Region object, where location_type is your Location class and locations is a dict of
        location names to address.
@@ -1372,7 +1360,7 @@ class Region:
        self,
        location_name: str,
        item_name: str | None = None,
-        rule: CollectionRule | Rule[Any] | None = None,
+        rule: Callable[[CollectionState], bool] | None = None,
        location_type: type[Location] | None = None,
        item_type: type[Item] | None = None,
        show_in_spoiler: bool = True,
@@ -1400,7 +1388,7 @@ class Region:
        event_location = location_type(self.player, location_name, None, self)
        event_location.show_in_spoiler = show_in_spoiler
        if rule is not None:
-            self.multiworld.worlds[self.player].set_rule(event_location, rule)
+            event_location.access_rule = rule

        event_item = item_type(item_name, ItemClassification.progression, None, self.player)

@@ -1411,7 +1399,7 @@ class Region:
        return event_item

    def connect(self, connecting_region: Region, name: Optional[str] = None,
-                rule: Optional[CollectionRule | Rule[Any]] = None) -> Entrance:
+                rule: Optional[Callable[[CollectionState], bool]] = None) -> Entrance:
        """
        Connects this Region to another Region, placing the provided rule on the connection.

@@ -1419,8 +1407,8 @@ class Region:
        :param name: name of the connection being created
        :param rule: callable to determine access of this connection to go from self to the exiting_region"""
        exit_ = self.create_exit(name if name else f"{self.name} -> {connecting_region.name}")
-        if rule is not None:
-            self.multiworld.worlds[self.player].set_rule(exit_, rule)
+        if rule:
+            exit_.access_rule = rule
        exit_.connect(connecting_region)
        return exit_

@@ -1444,8 +1432,8 @@ class Region:
        entrance.connect(self)
        return entrance

-    def add_exits(self, exits: Iterable[str] | Mapping[str, str | None],
-                  rules: Mapping[str, CollectionRule | Rule[Any]] | None = None) -> List[Entrance]:
+    def add_exits(self, exits: Union[Iterable[str], Dict[str, Optional[str]]],
+                  rules: Dict[str, Callable[[CollectionState], bool]] = None) -> List[Entrance]:
        """
        Connects current region to regions in exit dictionary. Passed region names must exist first.

@@ -1453,7 +1441,7 @@ class Region:
                      created entrances will be named "self.name -> connecting_region"
        :param rules: rules for the exits from this region. format is {"connecting_region": rule}
        """
-        if not isinstance(exits, Mapping):
+        if not isinstance(exits, Dict):
            exits = dict.fromkeys(exits)
        return [
            self.connect(
@@ -1484,7 +1472,7 @@ class Location:
    show_in_spoiler: bool = True
    progress_type: LocationProgressType = LocationProgressType.DEFAULT
    always_allow: Callable[[CollectionState, Item], bool] = staticmethod(lambda state, item: False)
-    access_rule: CollectionRule = DEFAULT_COLLECTION_RULE
+    access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
    item_rule: Callable[[Item], bool] = staticmethod(lambda item: True)
    item: Optional[Item] = None

@@ -1561,7 +1549,7 @@ class ItemClassification(IntFlag):
    skip_balancing = 0b01000
    """ should technically never occur on its own
    Item that is logically relevant, but progression balancing should not touch.
-
+    
    Possible reasons for why an item should not be pulled ahead by progression balancing:
    1. This item is quite insignificant, so pulling it earlier doesn't help (currency/etc.)
    2. It is important for the player experience that this item is evenly distributed in the seed (e.g. goal items) """
@@ -1569,13 +1557,13 @@ class ItemClassification(IntFlag):
    deprioritized = 0b10000
    """ Should technically never occur on its own.
    Will not be considered for priority locations,
-    unless Priority Locations Fill runs out of regular progression items before filling all priority locations.
-
+    unless Priority Locations Fill runs out of regular progression items before filling all priority locations. 
+    
    Should be used for items that would feel bad for the player to find on a priority location.
    Usually, these are items that are plentiful or insignificant. """

    progression_deprioritized_skip_balancing = 0b11001
-    """ Since a common case of both skip_balancing and deprioritized is "insignificant progression",
+    """ Since a common case of both skip_balancing and deprioritized is "insignificant progression", 
    these items often want both flags. """

    progression_skip_balancing = 0b01001  # only progression gets balanced
@@ -1583,7 +1571,7 @@ class ItemClassification(IntFlag):

    def as_flag(self) -> int:
        """As Network API flag int."""
-        return int(self & 0b00111)
+        return int(self & 0b0111)


 class Item:
@@ -1731,10 +1719,9 @@ class Spoiler:
                logging.debug('The following items could not be reached: %s', ['%s (Player %d) at %s (Player %d)' % (
                    location.item.name, location.item.player, location.name, location.player) for location in
                                                                               sphere_candidates])
-                if not multiworld.has_beaten_game(state):
-                    raise RuntimeError("During playthrough generation, the game was determined to be unbeatable. "
-                                       "Something went terribly wrong here. "
-                                       f"Unreachable progression items: {sphere_candidates}")
+                if any([multiworld.worlds[location.item.player].options.accessibility != 'minimal' for location in sphere_candidates]):
+                    raise RuntimeError(f'Not all progression items reachable ({sphere_candidates}). '
+                                       f'Something went terribly wrong here.')
                else:
                    self.unreachables = sphere_candidates
                    break
@@ -1868,9 +1855,6 @@ class Spoiler:
                    Utils.__version__, self.multiworld.seed))
            outfile.write('Filling Algorithm:               %s\n' % self.multiworld.algorithm)
            outfile.write('Players:                         %d\n' % self.multiworld.players)
-            if self.multiworld.players > 1:
-                loc_count = len([loc for loc in self.multiworld.get_locations() if not loc.is_event])
-                outfile.write('Total Location Count:            %d\n' % loc_count)
            outfile.write(f'Plando Options:                  {self.multiworld.plando_options}\n')
            AutoWorld.call_stage(self.multiworld, "write_spoiler_header", outfile)

@@ -1879,9 +1863,6 @@ class Spoiler:
                    outfile.write('\nPlayer %d: %s\n' % (player, self.multiworld.get_player_name(player)))
                outfile.write('Game:                            %s\n' % self.multiworld.game[player])

-                loc_count = len([loc for loc in self.multiworld.get_locations(player) if not loc.is_event])
-                outfile.write('Location Count:                  %d\n' % loc_count)
-
                for f_option, option in self.multiworld.worlds[player].options_dataclass.type_hints.items():
                    write_option(f_option, option)

@@ -1918,8 +1899,7 @@ class Spoiler:
            if self.unreachables:
                outfile.write('\n\nUnreachable Progression Items:\n\n')
                outfile.write(
-                    '\n'.join(['%s: %s' % (unreachable.item, unreachable)
-                               for unreachable in sorted(self.unreachables)]))
+                    '\n'.join(['%s: %s' % (unreachable.item, unreachable) for unreachable in self.unreachables]))

            if self.paths:
                outfile.write('\n\nPaths:\n\n')
@@ -9,7 +9,6 @@ import sys
 import typing
 import time
 import functools
-import warnings

 import ModuleUpdate
 ModuleUpdate.update()
@@ -22,10 +21,11 @@ if __name__ == "__main__":
    Utils.init_logging("TextClient", exception_logger="Client")

 from MultiServer import CommandProcessor, mark_raw
-from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
-                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes, HintStatus, SlotType)
-from Utils import gui_enabled, Version, stream_input, async_start
-from worlds import network_data_package, AutoWorldRegister
+from NetUtils import (Endpoint, decode, NetworkItem, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
+                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes, HintStatus,
+                      SlotType, NetworkPlayer, encode_to_bytes)
+from Utils import Version, stream_input, async_start
+from worlds import network_data_package
 import os
 import ssl

@@ -35,6 +35,9 @@ if typing.TYPE_CHECKING:

 logger = logging.getLogger("Client")

+# without terminal, we have to use gui mode
+gui_enabled = not sys.stdout or "--nogui" not in sys.argv
+

@Utils.cache_argsless
 def get_ssl_context():
@@ -62,8 +65,6 @@ class ClientCommandProcessor(CommandProcessor):

    def _cmd_exit(self) -> bool:
        """Close connections and client"""
-        if self.ctx.ui:
-            self.ctx.ui.stop()
        self.ctx.exit_event.set()
        return True

@@ -98,6 +99,17 @@ class ClientCommandProcessor(CommandProcessor):
            self.ctx.on_print_json({"data": parts, "cmd": "PrintJSON"})
        return True

+    def get_current_datapackage(self) -> dict[str, typing.Any]:
+        """
+        Return datapackage for current game if known.
+
+        :return: The datapackage for the currently registered game. If not found, an empty dictionary will be returned.
+        """
+        if not self.ctx.game:
+            return {}
+        checksum = self.ctx.checksums[self.ctx.game]
+        return Utils.load_data_package_for_checksum(self.ctx.game, checksum)
+
    def _cmd_missing(self, filter_text = "") -> bool:
        """List all missing location checks, from your local game state.
        Can be given text, which will be used as filter."""
@@ -107,8 +119,8 @@ class ClientCommandProcessor(CommandProcessor):
        count = 0
        checked_count = 0

-        lookup = self.ctx.location_names[self.ctx.game]
-        for location_id, location in lookup.items():
+        lookup = self.get_current_datapackage().get("location_name_to_id", {})
+        for location, location_id in lookup.items():
            if filter_text and filter_text not in location:
                continue
            if location_id < 0:
@@ -129,10 +141,11 @@ class ClientCommandProcessor(CommandProcessor):
            self.output("No missing location checks found.")
        return True

-    def output_datapackage_part(self, name: typing.Literal["Item Names", "Location Names"]) -> bool:
+    def output_datapackage_part(self, key: str, name: str) -> bool:
        """
        Helper to digest a specific section of this game's datapackage.

+        :param key: The dictionary key in the datapackage.
        :param name: Printed to the user as context for the part.

        :return: Whether the process was successful.
@@ -141,20 +154,23 @@ class ClientCommandProcessor(CommandProcessor):
            self.output(f"No game set, cannot determine {name}.")
            return False

-        lookup = self.ctx.item_names if name == "Item Names" else self.ctx.location_names
-        lookup = lookup[self.ctx.game]
+        lookup = self.get_current_datapackage().get(key)
+        if lookup is None:
+            self.output("datapackage not yet loaded, try again")
+            return False
+
        self.output(f"{name} for {self.ctx.game}")
-        for name in lookup.values():
-            self.output(name)
+        for key in lookup:
+            self.output(key)
        return True

    def _cmd_items(self) -> bool:
        """List all item names for the currently running game."""
-        return self.output_datapackage_part("Item Names")
+        return self.output_datapackage_part("item_name_to_id", "Item Names")

    def _cmd_locations(self) -> bool:
        """List all location names for the currently running game."""
-        return self.output_datapackage_part("Location Names")
+        return self.output_datapackage_part("location_name_to_id", "Location Names")

    def output_group_part(self, group_key: typing.Literal["item_name_groups", "location_name_groups"],
                          filter_key: str,
@@ -322,7 +338,7 @@ class CommonContext:
    hint_cost: int | None
    """Current Hint Cost per Hint from the server"""
    hint_points: int | None
-    """Current available Hint Points from the server"""
+    """Current avaliable Hint Points from the server"""
    player_names: dict[int, str]
    """Current lookup of slot number to player display name from server (includes aliases)"""

@@ -486,10 +502,11 @@ class CommonContext:
        """ `msgs` JSON serializable """
        if not self.server or not self.server.socket.open or self.server.socket.closed:
            return
-        await self.server.socket.send(encode(msgs))
+        await self.server.socket.send(encode_to_bytes(msgs))

-    def consume_players_package(self, package: typing.List[tuple]):
-        self.player_names = {slot: name for team, slot, name, orig_name in package if self.team == team}
+    def consume_players_package(self, package: typing.List[NetworkPlayer]):
+        self.player_names = {network_player.slot: network_player.name for network_player in package
+                             if self.team == network_player.team}
        self.player_names[0] = "Archipelago"

    def event_invalid_slot(self):
@@ -498,11 +515,12 @@ class CommonContext:
    def event_invalid_game(self):
        raise Exception('Invalid Game; please verify that you connected with the right game to the correct world.')

-    async def server_auth(self, password_requested: bool = False):
+    async def server_auth(self, password_requested: bool = False) -> typing.Optional[str]:
        if password_requested and not self.password:
            logger.info('Enter the password required to join this game:')
            self.password = await self.console_input()
            return self.password
+        return None

    async def get_username(self):
        if not self.auth:
@@ -571,10 +589,6 @@ class CommonContext:
        return print_json_packet.get("type", "") == "ItemSend" \
            and not self.slot_concerns_self(print_json_packet["receiving"]) \
            and not self.slot_concerns_self(print_json_packet["item"].player)
-    
-    def is_connection_change(self, print_json_packet: dict) -> bool:
-        """Helper function for filtering out connection changes."""
-        return print_json_packet.get("type", "") in ["Join","Part"]

    def on_print(self, args: dict):
        logger.info(args["text"])
@@ -773,7 +787,7 @@ class CommonContext:
        if len(parts) == 1:
            parts = title.split(', ', 1)
        if len(parts) > 1:
-            text = f"{parts[1]}\n\n{text}" if text else parts[1]
+            text = parts[1] + '\n\n' + text
            title = parts[0]
        # display error
        self._messagebox = MessageBox(title, text, error=True)
@@ -859,9 +873,9 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)

    server_url = urllib.parse.urlparse(address)
    if server_url.username:
-        ctx.username = urllib.parse.unquote(server_url.username)
+        ctx.username = server_url.username
    if server_url.password:
-        ctx.password = urllib.parse.unquote(server_url.password)
+        ctx.password = server_url.password

    def reconnect_hint() -> str:
        return ", type /connect to reconnect" if ctx.server_address else ""
@@ -896,8 +910,6 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
                                   "May not be running Archipelago on that address or port.")
    except websockets.InvalidURI:
        ctx.handle_connection_loss("Failed to connect to the multiworld server (invalid URI)")
-    except asyncio.TimeoutError:
-        ctx.handle_connection_loss("Failed to connect to the multiworld server. Connection timed out.")
    except OSError:
        ctx.handle_connection_loss("Failed to connect to the multiworld server")
    except Exception:
@@ -932,11 +944,10 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
            logger.info('--------------------------------')
            logger.info('Room Information:')
            logger.info('--------------------------------')
-            version = args["version"]
-            ctx.server_version = Version(*version)
+            ctx.server_version = Version.from_network_dict(args["version"])

            if "generator_version" in args:
-                ctx.generator_version = Version(*args["generator_version"])
+                ctx.generator_version = Version.from_network_dict(args["generator_version"])
                logger.info(f'Server protocol version: {ctx.server_version.as_simple_string()}, '
                            f'generator version: {ctx.generator_version.as_simple_string()}, '
                            f'tags: {", ".join(args["tags"])}')
@@ -1006,9 +1017,9 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
        ctx.slot = args["slot"]
        # int keys get lost in JSON transfer
        ctx.slot_info = {0: NetworkSlot("Archipelago", "Archipelago", SlotType.player)}
-        ctx.slot_info.update({int(pid): data for pid, data in args["slot_info"].items()})
+        ctx.slot_info.update({int(pid): NetworkSlot.from_network_dict(data) for pid, data in args["slot_info"].items()})
        ctx.hint_points = args.get("hint_points", 0)
-        ctx.consume_players_package(args["players"])
+        ctx.consume_players_package([NetworkPlayer.from_network_dict(player) for player in args["players"]])
        ctx.stored_data_notification_keys.add(f"_read_hints_{ctx.team}_{ctx.slot}")
        if ctx.game:
            game = ctx.game
@@ -1057,19 +1068,19 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
            await ctx.send_msgs(sync_msg)
        if start_index == len(ctx.items_received):
            for item in args['items']:
-                ctx.items_received.append(NetworkItem(*item))
+                ctx.items_received.append(NetworkItem.from_network_dict(item))
        ctx.watcher_event.set()

    elif cmd == 'LocationInfo':
-        for item in [NetworkItem(*item) for item in args['locations']]:
+        for item in [NetworkItem.from_network_dict(item) for item in args['locations']]:
            ctx.locations_info[item.location] = item
        ctx.watcher_event.set()

    elif cmd == "RoomUpdate":
        if "players" in args:
-            ctx.consume_players_package(args["players"])
+            ctx.consume_players_package([NetworkPlayer.from_network_dict(player) for player in args["players"]])
        if "hint_points" in args:
-            ctx.hint_points = args["hint_points"]
+            ctx.hint_points = args['hint_points']
        if "checked_locations" in args:
            checked = set(args["checked_locations"])
            ctx.checked_locations |= checked
@@ -1077,10 +1088,6 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
        if "permissions" in args:
            ctx.update_permissions(args["permissions"])

-        # Update hint info for local display
-        if "hint_cost" in args:
-            ctx.hint_cost = int(args["hint_cost"])
-
    elif cmd == 'Print':
        ctx.on_print(args)

@@ -1,5 +1,23 @@
 # hadolint global ignore=SC1090,SC1091

+# Source
+FROM scratch AS release
+WORKDIR /release
+ADD https://github.com/Ijwu/Enemizer/releases/latest/download/ubuntu.16.04-x64.zip Enemizer.zip
+
+# Enemizer
+FROM alpine:3.21 AS enemizer
+ARG TARGETARCH
+WORKDIR /release
+COPY --from=release /release/Enemizer.zip .
+
+# No release for arm architecture. Skip.
+RUN if [ "$TARGETARCH" = "amd64" ]; then \
+    apk add unzip=6.0-r15 --no-cache && \
+    unzip -u Enemizer.zip -d EnemizerCLI && \
+    chmod -R 777 EnemizerCLI; \
+    else touch EnemizerCLI; fi
+
 # Cython builder stage
 FROM python:3.12 AS cython-builder

@@ -10,7 +28,7 @@ COPY requirements.txt WebHostLib/requirements.txt

 RUN pip install --no-cache-dir -r \
    WebHostLib/requirements.txt \
-    "setuptools>=75,<81"
+    setuptools

 COPY _speedups.pyx .
 COPY intset.h .
@@ -18,7 +36,7 @@ COPY intset.h .
 RUN cythonize -b -i _speedups.pyx

 # Archipelago
-FROM python:3.12-slim-bookworm AS archipelago
+FROM python:3.12-slim AS archipelago
 ARG TARGETARCH
 ENV VIRTUAL_ENV=/opt/venv
 ENV PYTHONUNBUFFERED=1
@@ -63,6 +81,15 @@ RUN apt-get purge -y \
    g++ && \
    apt-get autoremove -y

+# Copy necessary components
+COPY --from=enemizer /release/EnemizerCLI /tmp/EnemizerCLI
+
+# No release for arm architecture. Skip.
+RUN if [ "$TARGETARCH" = "amd64" ]; then \
+    cp -r /tmp/EnemizerCLI EnemizerCLI; \
+    fi; \
+    rm -rf /tmp/EnemizerCLI
+
 # Define health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
    CMD curl -f http://localhost:${PORT:-80} || exit 1
@@ -129,10 +129,6 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                                     for i, location in enumerate(placements))
                    for (i, location, unsafe) in swap_attempts:
                        placed_item = location.item
-                        if item_to_place == placed_item:
-                            # The number of allowed swaps is limited, so do not allow a swap of an item with a copy of
-                            # itself.
-                            continue
                        # Unplaceable items can sometimes be swapped infinitely. Limit the
                        # number of times we will swap an individual item to prevent this
                        swap_count = swapped_items[placed_item.player, placed_item.name, unsafe]
@@ -280,7 +276,6 @@ def remaining_fill(multiworld: MultiWorld,
        item_to_place = itempool.pop()
        spot_to_fill: typing.Optional[Location] = None

-        # going through locations in the same order as the provided `locations` argument
        for i, location in enumerate(locations):
            if location_can_fill_item(location, item_to_place):
                # popping by index is faster than removing by content,
@@ -554,12 +549,10 @@ def distribute_items_restrictive(multiworld: MultiWorld,
        if prioritylocations and regular_progression:
            # retry with one_item_per_player off because some priority fills can fail to fill with that optimization
            # deprioritized items are still not in the mix, so they need to be collected into state first.
-            # allow_partial should only be set if there is deprioritized progression to fall back on.
            priority_retry_state = sweep_from_pool(multiworld.state, deprioritized_progression)
            fill_restrictive(multiworld, priority_retry_state, prioritylocations, regular_progression,
                             single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                             name="Priority Retry", one_item_per_player=False,
-                             allow_partial=bool(deprioritized_progression))
+                             name="Priority Retry", one_item_per_player=False, allow_partial=True)

        if prioritylocations and deprioritized_progression:
            # There are no more regular progression items that can be placed on any priority locations.
@@ -23,7 +23,7 @@ from BaseClasses import seeddigits, get_seed, PlandoOptions
 from Utils import parse_yamls, version_tuple, __version__, tuplize_version


-def mystery_argparse(argv: list[str] | None = None) -> argparse.Namespace:
+def mystery_argparse():
    from settings import get_settings
    settings = get_settings()
    defaults = settings.generator
@@ -40,8 +40,6 @@ def mystery_argparse(argv: list[str] | None = None) -> argparse.Namespace:
    parser.add_argument('--spoiler', type=int, default=defaults.spoiler)
    parser.add_argument('--outputpath', default=settings.general_options.output_path,
                        help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
-    parser.add_argument('--allow_quantity', action="store_true", default=defaults.allow_quantity,
-                        help='Allows the use of the quantity option in yamls. Default is the set value in the host.yaml.')
    parser.add_argument('--race', action='store_true', default=defaults.race)
    parser.add_argument('--meta_file_path', default=defaults.meta_file_path)
    parser.add_argument('--log_level', default=defaults.loglevel, help='Sets log level')
@@ -59,7 +57,7 @@ def mystery_argparse(argv: list[str] | None = None) -> argparse.Namespace:
    parser.add_argument("--spoiler_only", action="store_true",
                        help="Skips generation assertion and multidata, outputting only a spoiler log. "
                             "Intended for debugging and testing purposes.")
-    args = parser.parse_args(argv)
+    args = parser.parse_args()

    if args.skip_output and args.spoiler_only:
        parser.error("Cannot mix --skip_output and --spoiler_only")
@@ -70,7 +68,7 @@ def mystery_argparse(argv: list[str] | None = None) -> argparse.Namespace:
        args.weights_file_path = os.path.join(args.player_files_path, args.weights_file_path)
    if not os.path.isabs(args.meta_file_path):
        args.meta_file_path = os.path.join(args.player_files_path, args.meta_file_path)
-    args.plando = PlandoOptions.from_option_string(args.plando)
+    args.plando: PlandoOptions = PlandoOptions.from_option_string(args.plando)

    return args

@@ -89,8 +87,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:

    seed = get_seed(args.seed)

-    if __name__ == "__main__":
-        Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level, add_timestamp=args.log_time)
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level, add_timestamp=args.log_time)
    random.seed(seed)
    seed_name = get_seed_name(random)

@@ -122,10 +119,9 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
    else:
        meta_weights = None

-    player_id: int = 1
-    player_files: dict[int, str] = {}
-    player_errors: list[str] = []
-    allow_quantity = args.allow_quantity
+
+    player_id = 1
+    player_files = {}
    for file in os.scandir(args.player_files_path):
        fname = file.name
        if file.is_file() and not fname.startswith(".") and not fname.lower().endswith(".ini") and \
@@ -137,22 +133,11 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                    if yaml is None:
                        logging.warning(f"Ignoring empty yaml document #{doc_idx + 1} in {fname}")
                    else:
-                        quantity = yaml.get("quantity", 1)
-                        if quantity <= 0:
-                            raise ValueError("A quantity of 0 or less is invalid. Please change it to at least 1.")
-                        if not allow_quantity and quantity > 1:
-                            raise ValueError("Quantity greater than 1 is deactivated by host settings.")
-
-                        for _ in range(quantity):
-                            weights_for_file.append(yaml)
+                        weights_for_file.append(yaml)
                weights_cache[fname] = tuple(weights_for_file)
-
+                        
            except Exception as e:
-                logging.exception(f"Exception reading weights in file {fname}")
-                player_errors.append(
-                    f"{len(player_errors) + 1}. "
-                    f"File {fname} is invalid. Please fix your yaml.\n{Utils.get_all_causes(e)}"
-                )
+                raise ValueError(f"File {fname} is invalid. Please fix your yaml.") from e

    # sort dict for consistent results across platforms:
    weights_cache = {key: value for key, value in sorted(weights_cache.items(), key=lambda k: k[0].casefold())}
@@ -167,10 +152,6 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
    args.multi = max(player_id - 1, args.multi)

    if args.multi == 0:
-        if player_errors:
-            errors = "\n\n".join(player_errors)
-            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
-                             f"See logs for full tracebacks.\n\n{errors}")
        raise ValueError(
            "No individual player files found and number of players is 0. "
            "Provide individual player files or specify the number of players via host.yaml or --multi."
@@ -180,19 +161,28 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                 f"{seed_name} Seed {seed} with plando: {args.plando}")

    if not weights_cache:
-        if player_errors:
-            errors = "\n\n".join(player_errors)
-            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
-                             f"See logs for full tracebacks.\n\n{errors}")
        raise Exception(f"No weights found. "
                        f"Provide a general weights file ({args.weights_file_path}) or individual player files. "
                        f"A mix is also permitted.")

    from worlds.AutoWorld import AutoWorldRegister
-    args.outputname = seed_name
-    args.sprite = dict.fromkeys(range(1, args.multi+1), None)
-    args.sprite_pool = dict.fromkeys(range(1, args.multi+1), None)
-    args.name = {}
+    from worlds.alttp.EntranceRandomizer import parse_arguments
+    erargs = parse_arguments(['--multi', str(args.multi)])
+    erargs.seed = seed
+    erargs.plando_options = args.plando
+    erargs.spoiler = args.spoiler
+    erargs.race = args.race
+    erargs.outputname = seed_name
+    erargs.outputpath = args.outputpath
+    erargs.skip_prog_balancing = args.skip_prog_balancing
+    erargs.skip_output = args.skip_output
+    erargs.spoiler_only = args.spoiler_only
+    erargs.name = {}
+    erargs.csv_output = args.csv_output
+
+    settings_cache: dict[str, tuple[argparse.Namespace, ...]] = \
+        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
+         for fname, yamls in weights_cache.items()}

    if meta_weights:
        for category_name, category_dict in meta_weights.items():
@@ -208,95 +198,52 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                                        yaml[category][key] = option
                            elif category_name not in yaml:
                                logging.warning(f"Meta: Category {category_name} is not present in {path}.")
-                            elif key == "triggers":
-                                if "triggers" not in yaml[category_name]:
-                                    yaml[category_name][key] = []
-                                for trigger in option:
-                                    yaml[category_name][key].append(trigger)
                            else:
                                yaml[category_name][key] = option

-    settings_cache: dict[str, tuple[argparse.Namespace, ...] | None] = {fname: None for fname in weights_cache}
-    if args.sameoptions:
-        for fname, yamls in weights_cache.items():
-            try:
-                settings_cache[fname] = tuple(roll_settings(yaml, args.plando) for yaml in yamls)
-            except Exception as e:
-                logging.exception(f"Exception reading settings in file {fname}")
-                player_errors.append(
-                    f"{len(player_errors) + 1}. "
-                    f"File {fname} is invalid. Please fix your yaml.\n{Utils.get_all_causes(e)}"
-                )
-        # Exit early here to avoid throwing the same errors again later
-        if player_errors:
-            errors = "\n\n".join(player_errors)
-            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
-                             f"See logs for full tracebacks.\n\n{errors}")
-
-    player_path_cache: dict[int, str] = {}
+    player_path_cache = {}
    for player in range(1, args.multi + 1):
        player_path_cache[player] = player_files.get(player, args.weights_file_path)
-    name_counter: Counter[str] = Counter()
-    args.player_options = {}
+    name_counter = Counter()
+    erargs.player_options = {}

    player = 1
    while player <= args.multi:
        path = player_path_cache[player]
-        if not path:
-            player_errors.append(f'No weights specified for player {player}')
-            player += 1
-            continue
-
-        for doc_index, yaml in enumerate(weights_cache[path]):
-            name = yaml.get("name")
+        if path:
            try:
-                # Use the cached settings object if it exists, otherwise roll settings within the try-catch
-                # Invariant: settings_cache[path] and weights_cache[path] have the same length
-                cached = settings_cache[path]
-                settings_object: argparse.Namespace = (cached[doc_index] if cached else roll_settings(yaml, args.plando))
+                settings: tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
+                    tuple(roll_settings(yaml, args.plando) for yaml in weights_cache[path])
+                for settingsObject in settings:
+                    for k, v in vars(settingsObject).items():
+                        if v is not None:
+                            try:
+                                getattr(erargs, k)[player] = v
+                            except AttributeError:
+                                setattr(erargs, k, {player: v})
+                            except Exception as e:
+                                raise Exception(f"Error setting {k} to {v} for player {player}") from e

-                for k, v in vars(settings_object).items():
-                    if v is not None:
-                        try:
-                            getattr(args, k)[player] = v
-                        except AttributeError:
-                            setattr(args, k, {player: v})
-                        except Exception as e:
-                            raise Exception(f"Error setting {k} to {v} for player {player}") from e
-
-                # name was not specified
-                if player not in args.name:
-                    if path == args.weights_file_path:
-                        # weights file, so we need to make the name unique
-                        args.name[player] = f"Player{player}"
-                    else:
-                        # use the filename
-                        args.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
-                args.name[player] = handle_name(args.name[player], player, name_counter)
+                    # name was not specified
+                    if player not in erargs.name:
+                        if path == args.weights_file_path:
+                            # weights file, so we need to make the name unique
+                            erargs.name[player] = f"Player{player}"
+                        else:
+                            # use the filename
+                            erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
+                    erargs.name[player] = handle_name(erargs.name[player], player, name_counter)

+                    player += 1
            except Exception as e:
-                logging.exception(f"Exception reading settings in file {path} document #{doc_index + 1} "
-                                  f"(name: {args.name.get(player, name)})")
-                player_errors.append(
-                    f"{len(player_errors) + 1}. "
-                    f"File {path} document #{doc_index + 1} (name: {args.name.get(player, name)}) is invalid. "
-                    f"Please fix your yaml.\n{Utils.get_all_causes(e)}")
+                raise ValueError(f"File {path} is invalid. Please fix your yaml.") from e
+        else:
+            raise RuntimeError(f'No weights specified for player {player}')

-            # increment for each yaml document in the file
-            player += 1
+    if len(set(name.lower() for name in erargs.name.values())) != len(erargs.name):
+        raise Exception(f"Names have to be unique. Names: {Counter(name.lower() for name in erargs.name.values())}")

-    if len(set(name.lower() for name in args.name.values())) != len(args.name):
-        player_errors.append(
-            f"{len(player_errors) + 1}. "
-            f"Names have to be unique. Names: {Counter(name.lower() for name in args.name.values())}"
-        )
-
-    if player_errors:
-        errors = "\n\n".join(player_errors)
-        raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
-                         f"See logs for full tracebacks.\n\n{errors}")
-
-    return args, seed
+    return erargs, seed


 def read_weights_yamls(path) -> tuple[Any, ...]:
@@ -373,7 +320,7 @@ class SafeFormatter(string.Formatter):
            return kwargs.get(key, "{" + key + "}")


-def handle_name(name: str, player: int, name_counter: Counter[str]):
+def handle_name(name: str, player: int, name_counter: Counter):
    name_counter[name.lower()] += 1
    number = name_counter[name.lower()]
    new_name = "%".join([x.replace("%number%", "{number}").replace("%player%", "{player}") for x in name.split("%%")])
@@ -404,9 +351,7 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
            elif isinstance(new_value, list):
                cleaned_value.extend(new_value)
            elif isinstance(new_value, dict):
-                counter_value = Counter(cleaned_value)
-                counter_value.update(new_value)
-                cleaned_value = dict(counter_value)
+                cleaned_value = dict(Counter(cleaned_value) + Counter(new_value))
            else:
                raise Exception(f"Cannot apply merge to non-dict, set, or list type {option_name},"
                                f" received {type(new_value).__name__}.")
@@ -420,18 +365,13 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
                for element in new_value:
                    cleaned_value.remove(element)
            elif isinstance(new_value, dict):
-                counter_value = Counter(cleaned_value)
-                counter_value.subtract(new_value)
-                cleaned_value = dict(counter_value)
+                cleaned_value = dict(Counter(cleaned_value) - Counter(new_value))
            else:
                raise Exception(f"Cannot apply remove to non-dict, set, or list type {option_name},"
                                f" received {type(new_value).__name__}.")
            cleaned_weights[option_name] = cleaned_value
        else:
-            # Options starting with + and - may modify values in-place, and new_weights may be shared by multiple slots
-            # using the same .yaml, so ensure that the new value is a copy.
-            cleaned_value = copy.deepcopy(new_weights[option])
-            cleaned_weights[option_name] = cleaned_value
+            cleaned_weights[option_name] = new_weights[option]
    new_options = set(cleaned_weights) - set(weights)
    weights.update(cleaned_weights)
    if new_options:
@@ -454,8 +394,6 @@ def roll_meta_option(option_key, game: str, category_dict: dict) -> Any:
            if options[option_key].supports_weighting:
                return get_choice(option_key, category_dict)
            return category_dict[option_key]
-        if option_key == "triggers":
-            return category_dict[option_key]
    raise Options.OptionError(f"Error generating meta option {option_key} for {game}.")


@@ -511,7 +449,7 @@ def roll_triggers(weights: dict, triggers: list, valid_keys: set) -> dict:
    return weights


-def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type[Options.Option], plando_options: PlandoOptions):
+def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option), plando_options: PlandoOptions):
    try:
        if option_key in game_weights:
            if not option.supports_weighting:
@@ -557,22 +495,7 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
            if required_plando_options:
                raise Exception(f"Settings reports required plando module {str(required_plando_options)}, "
                                f"which is not enabled.")
-        games = requirements.get("game", {})
-        for game, version in games.items():
-            if game not in AutoWorldRegister.world_types:
-                continue
-            if not version:
-                raise Exception(f"Invalid version for game {game}: {version}.")
-            if isinstance(version, str):
-                version = {"min": version}
-            if "min" in version and tuplize_version(version["min"]) > AutoWorldRegister.world_types[game].world_version:
-                raise Exception(f"Settings reports required version of world \"{game}\" is at least {version['min']}, "
-                                f"however world is of version "
-                                f"{AutoWorldRegister.world_types[game].world_version.as_simple_string()}.")
-            if "max" in version and tuplize_version(version["max"]) < AutoWorldRegister.world_types[game].world_version:
-                raise Exception(f"Settings reports required version of world \"{game}\" is no later than {version['max']}, "
-                                f"however world is of version "
-                                f"{AutoWorldRegister.world_types[game].world_version.as_simple_string()}.")
+
    ret = argparse.Namespace()
    for option_key in Options.PerGameCommonOptions.type_hints:
        if option_key in weights and option_key not in Options.CommonOptions.type_hints:
@@ -585,8 +508,7 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
        raise Exception(f"Invalid game: {ret.game}")
    if ret.game not in AutoWorldRegister.world_types:
        from worlds import failed_world_loads
-        picks = Utils.get_fuzzy_results(ret.game, list(AutoWorldRegister.world_types) + list(failed_world_loads.keys()),
-                                        limit=1)[0]
+        picks = Utils.get_fuzzy_results(ret.game, list(AutoWorldRegister.world_types) + failed_world_loads, limit=1)[0]
        if picks[0] in failed_world_loads:
            raise Exception(f"No functional world found to handle game {ret.game}. "
                            f"Did you mean '{picks[0]}' ({picks[1]}% sure)? "
@@ -0,0 +1,9 @@
+if __name__ == '__main__':
+    import ModuleUpdate
+    ModuleUpdate.update()
+
+    import Utils
+    Utils.init_logging("KH1Client", exception_logger="Client")
+
+    from worlds.kh1.Client import launch
+    launch()
@@ -0,0 +1,8 @@
+import ModuleUpdate
+import Utils
+from worlds.kh2.Client import launch
+ModuleUpdate.update()
+
+if __name__ == '__main__':
+    Utils.init_logging("KH2Client", exception_logger="Client")
+    launch()
@@ -29,14 +29,9 @@ if __name__ == "__main__":

 import settings
 import Utils
-from Utils import (env_cleared_lib_path, init_logging, is_frozen, is_linux, is_macos, is_windows, local_path,
-                   messagebox, open_filename, user_path)
-
-if __name__ == "__main__":
-    init_logging('Launcher')
-
+from Utils import (init_logging, is_frozen, is_linux, is_macos, is_windows, local_path, messagebox, open_filename,
+                   user_path)
 from worlds.LauncherComponents import Component, components, icon_paths, SuffixIdentifier, Type
-from worlds import failed_world_loads


 def open_host_yaml():
@@ -53,7 +48,10 @@ def open_host_yaml():
        webbrowser.open(file)
        return

-    env = env_cleared_lib_path()
+    env = os.environ
+    if "LD_LIBRARY_PATH" in env:
+        env = env.copy()
+        del env["LD_LIBRARY_PATH"]  # exe is a system binary, so reset LD_LIBRARY_PATH
    subprocess.Popen([exe, file], env=env)

 def open_patch():
@@ -77,17 +75,12 @@ def open_patch():
            launch([*exe, file], component.cli)


-def generate_yamls(*args):
+def generate_yamls():
    from Options import generate_yaml_templates

-    parser = argparse.ArgumentParser(description="Generate Template Options", usage="[-h] [--skip_open_folder]")
-    parser.add_argument("--skip_open_folder", action="store_true")
-    args = parser.parse_args(args)
-
    target = Utils.user_path("Players", "Templates")
    generate_yaml_templates(target, False)
-    if not args.skip_open_folder:
-        open_folder(target)
+    open_folder(target)


 def browse_files():
@@ -104,7 +97,10 @@ def open_folder(folder_path):
        return

    if exe:
-        env = env_cleared_lib_path()
+        env = os.environ
+        if "LD_LIBRARY_PATH" in env:
+            env = env.copy()
+            del env["LD_LIBRARY_PATH"]  # exe is a system binary, so reset LD_LIBRARY_PATH
        subprocess.Popen([exe, folder_path], env=env)
    else:
        logging.warning(f"No file browser available to open {folder_path}")
@@ -197,47 +193,32 @@ def get_exe(component: str | Component) -> Sequence[str] | None:
        return [sys.executable, local_path(f"{component.script_name}.py")] if component.script_name else None


-def launch(exe: Sequence[str], in_terminal: bool = False) -> bool:
-    """Runs the given command/args in `exe` in a new process.
-
-    If `in_terminal` is True, it will attempt to run in a terminal window,
-    and the return value will indicate whether one was found."""
+def launch(exe, in_terminal=False):
    if in_terminal:
        if is_windows:
            # intentionally using a window title with a space so it gets quoted and treated as a title
            subprocess.Popen(["start", "Running Archipelago", *exe], shell=True)
-            return True
+            return
        elif is_linux:
-            terminal = which("x-terminal-emulator") or which("konsole") or which("gnome-terminal") or which("xterm")
+            terminal = which('x-terminal-emulator') or which('gnome-terminal') or which('xterm')
            if terminal:
-                # Clear LD_LIB_PATH during terminal startup, but set it again when running command in case it's needed
-                ld_lib_path = os.environ.get("LD_LIBRARY_PATH")
-                lib_path_setter = f"env LD_LIBRARY_PATH={shlex.quote(ld_lib_path)} " if ld_lib_path else ""
-                env = env_cleared_lib_path()
-
-                subprocess.Popen([terminal, "-e", lib_path_setter + shlex.join(exe)], env=env)
-                return True
+                subprocess.Popen([terminal, '-e', shlex.join(exe)])
+                return
        elif is_macos:
-            terminal = [which("open"), "-W", "-a", "Terminal.app"]
+            terminal = [which('open'), '-W', '-a', 'Terminal.app']
            subprocess.Popen([*terminal, *exe])
-            return True
+            return
    subprocess.Popen(exe)
-    return False


 def create_shortcut(button: Any, component: Component) -> None:
    from pyshortcuts import make_shortcut
-    env = os.environ
-    if "APPIMAGE" in env:
-        script = env["ARGV0"]
-        wkdir = None # defaults to ~ on Linux
-    else:
-        script = sys.argv[0]
-        wkdir = Utils.local_path()
+    script = sys.argv[0]
+    wkdir = Utils.local_path()

    script = f"{script} \"{component.display_name}\""
    make_shortcut(script, name=f"Archipelago {component.display_name}", icon=local_path("data", "icon.ico"),
-                  startmenu=False, terminal=False, working_dir=wkdir, noexe=Utils.is_frozen())
+                  startmenu=False, terminal=False, working_dir=wkdir)
    button.menu.dismiss()


@@ -276,7 +257,6 @@ def run_gui(launch_components: list[Component], args: Any) -> None:
        search_box: MDTextField = ObjectProperty(None)
        cards: list[LauncherCard]
        current_filter: Sequence[str | Type] | None
-        failed_worlds: bool = bool(failed_world_loads)

        def __init__(self, ctx=None, components=None, args=None):
            self.title = self.base_title + " " + Utils.__version__
@@ -412,50 +392,12 @@ def run_gui(launch_components: list[Component], args: Any) -> None:

        @staticmethod
        def component_action(button):
-            open_text = "Opening in a new window..."
+            MDSnackbar(MDSnackbarText(text="Opening in a new window..."), y=dp(24), pos_hint={"center_x": 0.5},
+                       size_hint_x=0.5).open()
            if button.component.func:
-                # Note: if we want to draw the Snackbar before running func, func needs to be wrapped in schedule_once
                button.component.func()
            else:
-                # if launch returns False, it started the process in background (not in a new terminal)
-                if not launch(get_exe(button.component), button.component.cli) and button.component.cli:
-                    open_text = "Running in the background..."
-
-            MDSnackbar(MDSnackbarText(text=open_text), y=dp(24), pos_hint={"center_x": 0.5},
-                       size_hint_x=0.5).open()
-
-        @staticmethod
-        def copy_to_clipboard(text):
-            from kivy.core.clipboard import Clipboard
-            Clipboard.copy(text)
-            MDSnackbar(MDSnackbarText(text="Copied to clipboard."), y=dp(24), pos_hint={"center_x": 0.5},
-                       size_hint_x=0.5).open()
-
-        def display_failed(self):
-            """Display a dialog showing the exceptions produced by any world that failed to load during
-            initialization."""
-            if not self.failed_worlds:
-                return
-            from kivymd.uix.dialog import MDDialog, MDDialogIcon, MDDialogHeadlineText, MDDialogContentContainer
-            from kivymd.uix.divider import MDDivider
-            from kivymd.uix.list import MDListItem, MDListItemHeadlineText, MDListItemSupportingText
-            entries = []
-            for world, reason in failed_world_loads.items():
-                entries.append(MDListItem(
-                    MDListItemHeadlineText(text=world),
-                    MDListItemSupportingText(text=reason),
-                    on_release=lambda x, r=reason: self.copy_to_clipboard(r)
-                ))
-            dialog = MDDialog(
-                MDDialogIcon(icon="alert"),
-                MDDialogHeadlineText(text="Failed World Loads"),
-                MDDialogContentContainer(
-                    MDDivider(),
-                    *entries,
-                    orientation="vertical",
-                )
-            )
-            dialog.open()
+                launch(get_exe(button.component), button.component.cli)

        def _on_drop_file(self, window: Window, filename: bytes, x: int, y: int) -> None:
            """ When a patch file is dropped into the window, run the associated component. """
@@ -541,7 +483,8 @@ def main(args: argparse.Namespace | dict | None = None):


 if __name__ == '__main__':
-    multiprocessing.freeze_support()
+    init_logging('Launcher')
+    Utils.freeze_support()
    multiprocessing.set_start_method("spawn")  # if launched process uses kivy, fork won't work
    parser = argparse.ArgumentParser(
        description='Archipelago Launcher',
@@ -3,6 +3,9 @@ ModuleUpdate.update()

 import Utils

+if __name__ == "__main__":
+    Utils.init_logging("LinksAwakeningContext", exception_logger="Client")
+
 import asyncio
 import base64
 import binascii
@@ -23,14 +26,16 @@ import typing
 from CommonClient import (CommonContext, get_base_parser, gui_enabled, logger,
                          server_loop)
 from NetUtils import ClientStatus
-from . import LinksAwakeningWorld
-from .Common import BASE_ID as LABaseID
-from .GpsTracker import GpsTracker
-from .TrackerConsts import storage_key
-from .ItemTracker import ItemTracker
-from .LADXR.checkMetadata import checkMetadataTable
-from .Locations import get_locations_to_id, meta_to_name
-from .Tracker import LocationTracker, MagpieBridge, Check
+from worlds.ladx import LinksAwakeningWorld
+from worlds.ladx.Common import BASE_ID as LABaseID
+from worlds.ladx.GpsTracker import GpsTracker
+from worlds.ladx.TrackerConsts import storage_key
+from worlds.ladx.ItemTracker import ItemTracker
+from worlds.ladx.LADXR.checkMetadata import checkMetadataTable
+from worlds.ladx.Locations import get_locations_to_id, meta_to_name
+from worlds.ladx.Tracker import LocationTracker, MagpieBridge, Check
+
+
 class GameboyException(Exception):
    pass

@@ -47,10 +52,6 @@ class BadRetroArchResponse(GameboyException):
    pass


-class VersionError(Exception):
-    pass
-
-
 class LAClientConstants:
    # Connector version
    VERSION = 0x01
@@ -140,7 +141,7 @@ class RAGameboy():
        return response

    async def async_recv(self, timeout=1.0):
-        response = await asyncio.wait_for(asyncio.get_running_loop().sock_recv(self.socket, 4096), timeout)
+        response = await asyncio.wait_for(asyncio.get_event_loop().sock_recv(self.socket, 4096), timeout)
        return response

    async def check_safe_gameplay(self, throw=True):
@@ -411,10 +412,10 @@ class LinksAwakeningClient():
            status = (await self.gameboy.async_read_memory_safe(LAClientConstants.wLinkStatusBits))[0]

        item_id -= LABaseID
-        # The player name table only goes up to 101, so don't go past that
+        # The player name table only goes up to 100, so don't go past that
        # Even if it didn't, the remote player _index_ byte is just a byte, so 255 max
-        if from_player > 101:
-            from_player = 101
+        if from_player > 100:
+            from_player = 100

        next_index += 1
        self.gameboy.write_memory(LAClientConstants.wLinkGiveItem, [
@@ -522,7 +523,7 @@ class LinksAwakeningContext(CommonContext):
                ("Client", "Archipelago"),
                ("Tracker", "Tracker"),
            ]
-            base_title = f"Links Awakening DX Client {LinksAwakeningWorld.world_version.as_simple_string()} | Archipelago"
+            base_title = "Archipelago Links Awakening DX Client"

            def build(self):
                b = super().build()
@@ -618,20 +619,11 @@ class LinksAwakeningContext(CommonContext):
        if cmd == "Connected":
            self.game = self.slot_info[self.slot].game
            self.slot_data = args.get("slot_data", {})
-            generated_version = Utils.tuplize_version(self.slot_data.get("world_version", "2.0.0"))
-            client_version = LinksAwakeningWorld.world_version
-            if generated_version.major != client_version.major:
-                self.disconnected_intentionally = True
-                raise VersionError(
-                    f"The installed world ({client_version.as_simple_string()}) is incompatible with "
-                    f"the world this game was generated on ({generated_version.as_simple_string()})"
-                )
            # This is sent to magpie over local websocket to make its own connection
            self.slot_data.update({
                "server_address": self.server_address,
                "slot_name": self.player_names[self.slot],
                "password": self.password,
-                "client_version": client_version.as_simple_string(),
            })

            # We can process linked items on already-checked checks now that we have slot_data
@@ -768,44 +760,42 @@ def run_game(romfile: str) -> None:
        except FileNotFoundError:
            logger.error(f"Couldn't launch ROM, {args[0]} is missing")

-def launch(*launch_args):
-    async def main():
-        parser = get_base_parser(description="Link's Awakening Client.")
-        parser.add_argument("--url", help="Archipelago connection url")
-        parser.add_argument("--no-magpie", dest='magpie', default=True, action='store_false', help="Disable magpie bridge")
-        parser.add_argument('diff_file', default="", type=str, nargs="?",
-                            help='Path to a .apladx Archipelago Binary Patch file')
+async def main():
+    parser = get_base_parser(description="Link's Awakening Client.")
+    parser.add_argument("--url", help="Archipelago connection url")
+    parser.add_argument("--no-magpie", dest='magpie', default=True, action='store_false', help="Disable magpie bridge")
+    parser.add_argument('diff_file', default="", type=str, nargs="?",
+                        help='Path to a .apladx Archipelago Binary Patch file')

-        args = parser.parse_args(launch_args)
+    args = parser.parse_args()

-        if args.diff_file:
-            import Patch
-            logger.info("patch file was supplied - creating rom...")
-            meta, rom_file = Patch.create_rom_file(args.diff_file)
-            if "server" in meta and not args.connect:
-                args.connect = meta["server"]
-            logger.info(f"wrote rom file to {rom_file}")
+    if args.diff_file:
+        import Patch
+        logger.info("patch file was supplied - creating rom...")
+        meta, rom_file = Patch.create_rom_file(args.diff_file)
+        if "server" in meta and not args.connect:
+            args.connect = meta["server"]
+        logger.info(f"wrote rom file to {rom_file}")


-        ctx = LinksAwakeningContext(args.connect, args.password, args.magpie)
+    ctx = LinksAwakeningContext(args.connect, args.password, args.magpie)

-        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
+    ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")

-        # TODO: nothing about the lambda about has to be in a lambda
-        ctx.la_task = create_task_log_exception(ctx.run_game_loop())
-        if gui_enabled:
-            ctx.run_gui()
-        ctx.run_cli()
+    # TODO: nothing about the lambda about has to be in a lambda
+    ctx.la_task = create_task_log_exception(ctx.run_game_loop())
+    if gui_enabled:
+        ctx.run_gui()
+    ctx.run_cli()

-        # Down below run_gui so that we get errors out of the process
-        if args.diff_file:
-            run_game(rom_file)
+    # Down below run_gui so that we get errors out of the process
+    if args.diff_file:
+        run_game(rom_file)

-        await ctx.exit_event.wait()
-        await ctx.shutdown()
-
-    Utils.init_logging("LinksAwakeningContext", exception_logger="Client")
+    await ctx.exit_event.wait()
+    await ctx.shutdown()

+if __name__ == '__main__':
    colorama.just_fix_windows_console()
    asyncio.run(main())
    colorama.deinit()
@@ -241,8 +241,8 @@ async def gba_sync_task(ctx: MMBN3Context):
                                await ctx.server_auth(False)
                    else:
                        if not ctx.version_warning:
-                            logger.warning(f"Your Lua script is version {reported_version}, expected {script_version}. "
-                                           "Please update to the latest version. "
+                            logger.warning(f"Your Lua script is version {reported_version}, expected {script_version}."
+                                           "Please update to the latest version."
                                           "Your connection to the Archipelago server will not be accepted.")
                            ctx.version_warning = True
                except asyncio.TimeoutError:
@@ -37,7 +37,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)

    logger = logging.getLogger()
    multiworld.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
-    multiworld.plando_options = args.plando
+    multiworld.plando_options = args.plando_options
    multiworld.game = args.game.copy()
    multiworld.player_name = args.name.copy()
    multiworld.sprite = args.sprite.copy()
@@ -54,17 +54,12 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
    logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
    longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)

-    world_classes = AutoWorld.AutoWorldRegister.world_types.values()
-
-    version_count = max(len(cls.world_version.as_simple_string()) for cls in world_classes)
-    item_count = len(str(max(len(cls.item_names) for cls in world_classes)))
-    location_count = len(str(max(len(cls.location_names) for cls in world_classes)))
+    item_count = len(str(max(len(cls.item_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
+    location_count = len(str(max(len(cls.location_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))

    for name, cls in AutoWorld.AutoWorldRegister.world_types.items():
        if not cls.hidden and len(cls.item_names) > 0:
-            logger.info(f" {name:{longest_name}}: "
-                        f"v{cls.world_version.as_simple_string():{version_count}} | "
-                        f"Items: {len(cls.item_names):{item_count}} | "
+            logger.info(f" {name:{longest_name}}: Items: {len(cls.item_names):{item_count}} | "
                        f"Locations: {len(cls.location_names):{location_count}}")

    del item_count, location_count
@@ -207,9 +202,6 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
    else:
        logger.info("Progression balancing skipped.")

-    AutoWorld.call_all(multiworld, "finalize_multiworld")
-    AutoWorld.call_all(multiworld, "pre_output")
-
    # we're about to output using multithreading, so we're removing the global random state to prevent accidental use
    multiworld.random.passthrough = False

@@ -329,7 +321,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                    if current_sphere:
                        spheres.append(dict(current_sphere))

-                multidata: NetUtils.MultiData = {
+                multidata: NetUtils.MultiData | bytes = {
                    "slot_data": slot_data,
                    "slot_info": slot_info,
                    "connect_names": {name: (0, player) for player, name in multiworld.player_name.items()},
@@ -350,14 +342,25 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                # TODO: change to `"version": version_tuple` after getting better serialization
                AutoWorld.call_all(multiworld, "modify_multidata", multidata)

-                for key in ("slot_data", "er_hint_data"):
+                base_types_keys = ["er_hint_data"]
+
+                # starting with 0.7.0 pre-encode slot data, until then multiserver does it on load
+                if version_tuple < (0, 7, 0):
+                    base_types_keys.append("slot_data")
+                else:
+                    for slot, data in multidata["slot_data"].items():
+                        multidata[slot] = NetUtils.encode_to_bytes(data)
+                        assert type(multidata[slot]) is bytes
+                    multidata["minimum_versions"]["server"] = max((0, 7, 0), multidata["minimum_versions"]["server"])
+
+                for key in base_types_keys:
                    multidata[key] = convert_to_base_types(multidata[key])

-                serialized_multidata = zlib.compress(restricted_dumps(multidata), 9)
+                multidata = zlib.compress(restricted_dumps(multidata), 9)

                with open(os.path.join(temp_dir, f'{outfilebase}.archipelago'), 'wb') as f:
                    f.write(bytes([3]))  # version of format
-                    f.write(serialized_multidata)
+                    f.write(multidata)

            output_file_futures.append(pool.submit(write_multidata))
            if not check_accessibility_task.result():
@@ -5,16 +5,15 @@ import multiprocessing
 import warnings


-if sys.platform in ("win32", "darwin") and not (3, 11, 9) <= sys.version_info < (3, 14, 0):
+if sys.platform in ("win32", "darwin") and sys.version_info < (3, 10, 11):
    # Official micro version updates. This should match the number in docs/running from source.md.
-    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. "
-                       "Official 3.11.9 through 3.13.x is supported.")
-elif sys.platform in ("win32", "darwin") and sys.version_info < (3, 11, 13):
+    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. Official 3.10.15+ is supported.")
+elif sys.platform in ("win32", "darwin") and sys.version_info < (3, 10, 15):
    # There are known security issues, but no easy way to install fixed versions on Windows for testing.
    warnings.warn(f"Python Version {sys.version_info} has security issues. Don't use in production.")
-elif not (3, 11, 0) <= sys.version_info < (3, 14, 0):
+elif sys.version_info < (3, 10, 1):
    # Other platforms may get security backports instead of micro updates, so the number is unreliable.
-    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. 3.11.0 through 3.13.x is supported.")
+    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. 3.10.1+ is supported.")

 # don't run update if environment is frozen/compiled or if not the parent process (skip in subprocess)
 _skip_update = bool(
@@ -75,11 +74,11 @@ def update_command():
 def install_pkg_resources(yes=False):
    try:
        import pkg_resources  # noqa: F401
-    except (AttributeError, ImportError):
+    except ImportError:
        check_pip()
        if not yes:
            confirm("pkg_resources not found, press enter to install it")
-        subprocess.call([sys.executable, "-m", "pip", "install", "--upgrade", "setuptools>=75,<81"])
+        subprocess.call([sys.executable, "-m", "pip", "install", "--upgrade", "setuptools"])


 def update(yes: bool = False, force: bool = False) -> None:
@@ -21,7 +21,6 @@ import time
 import typing
 import weakref
 import zlib
-from signal import SIGINT, SIGTERM, signal

 import ModuleUpdate

@@ -32,8 +31,9 @@ if typing.TYPE_CHECKING:
    from NetUtils import ServerConnection

 import colorama
+import orjson
 import websockets
-from websockets.extensions.permessage_deflate import PerMessageDeflate, ServerPerMessageDeflateFactory
+from websockets.extensions.permessage_deflate import PerMessageDeflate
 try:
    # ponyorm is a requirement for webhost, not default server, so may not be importable
    from pony.orm.dbapiprovider import OperationalError
@@ -42,24 +42,15 @@ except ImportError:

 import NetUtils
 import Utils
-from Utils import version_tuple, restricted_loads, Version, async_start, get_intended_text
+from Utils import version_tuple, restricted_loads, Version, async_start, get_intended_text, __version__
 from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission, NetworkSlot, \
-    SlotType, LocationStore, MultiData, Hint, HintStatus
+    SlotType, LocationStore, MultiData, Hint, HintStatus, encode_to_bytes
 from BaseClasses import ItemClassification


 min_client_version = Version(0, 5, 0)
 colorama.just_fix_windows_console()

-no_version = Version(0, 0, 0)
-assert isinstance(no_version, tuple)  # assert immutable
-
-server_per_message_deflate_factory = ServerPerMessageDeflateFactory(
-    server_max_window_bits=11,
-    client_max_window_bits=11,
-    compress_settings={"memLevel": 4},
-)
-

 def remove_from_list(container, value):
    try:
@@ -70,12 +61,6 @@ def remove_from_list(container, value):


 def pop_from_container(container, value):
-    if isinstance(container, list) and isinstance(value, int) and len(container) <= value:
-        return container
-
-    if isinstance(container, dict) and value not in container:
-        return container
-
    try:
        container.pop(value)
    except ValueError:
@@ -141,31 +126,8 @@ def get_saving_second(seed_name: str, interval: int = 60) -> int:


 class Client(Endpoint):
-    __slots__ = (
-        "__weakref__",
-        "version",
-        "auth",
-        "team",
-        "slot",
-        "send_index",
-        "tags",
-        "messageprocessor",
-        "ctx",
-        "remote_items",
-        "remote_start_inventory",
-        "no_items",
-        "no_locations",
-        "no_text",
-    )
-
-    version: Version
-    auth: bool
-    team: int | None
-    slot: int | None
-    send_index: int
-    tags: list[str]
-    messageprocessor: ClientMessageProcessor
-    ctx: weakref.ref[Context]
+    version = Version(0, 0, 0)
+    tags: typing.List[str]
    remote_items: bool
    remote_start_inventory: bool
    no_items: bool
@@ -174,7 +136,6 @@ class Client(Endpoint):

    def __init__(self, socket: "ServerConnection", ctx: Context) -> None:
        super().__init__(socket)
-        self.version = no_version
        self.auth = False
        self.team = None
        self.slot = None
@@ -182,11 +143,6 @@ class Client(Endpoint):
        self.tags = []
        self.messageprocessor = client_message_processor(ctx, self)
        self.ctx = weakref.ref(ctx)
-        self.remote_items = False
-        self.remote_start_inventory = False
-        self.no_items = False
-        self.no_locations = False
-        self.no_text = False

    @property
    def items_handling(self):
@@ -214,7 +170,7 @@ team_slot = typing.Tuple[int, int]


 class Context:
-    dumper = staticmethod(encode)
+    dumper = staticmethod(encode_to_bytes)
    loader = staticmethod(decode)

    simple_options = {"hint_cost": int,
@@ -224,7 +180,6 @@ class Context:
                      "release_mode": str,
                      "remaining_mode": str,
                      "collect_mode": str,
-                      "countdown_mode": str,
                      "item_cheat": bool,
                      "compatibility": int}
    # team -> slot id -> list of clients authenticated to slot.
@@ -254,8 +209,8 @@ class Context:

    def __init__(self, host: str, port: int, server_password: str, password: str, location_check_points: int,
                 hint_cost: int, item_cheat: bool, release_mode: str = "disabled", collect_mode="disabled",
-                 countdown_mode: str = "auto", remaining_mode: str = "disabled", auto_shutdown: typing.SupportsFloat = 0, 
-                 compatibility: int = 2, log_network: bool = False, logger: logging.Logger = logging.getLogger()):
+                 remaining_mode: str = "disabled", auto_shutdown: typing.SupportsFloat = 0, compatibility: int = 2,
+                 log_network: bool = False, logger: logging.Logger = logging.getLogger()):
        self.logger = logger
        super(Context, self).__init__()
        self.slot_info = {}
@@ -288,7 +243,6 @@ class Context:
        self.release_mode: str = release_mode
        self.remaining_mode: str = remaining_mode
        self.collect_mode: str = collect_mode
-        self.countdown_mode: str = countdown_mode
        self.item_cheat = item_cheat
        self.exit_event = asyncio.Event()
        self.client_activity_timers: typing.Dict[
@@ -497,8 +451,7 @@ class Context:

        self.read_data = {}
        # there might be a better place to put this.
-        race_mode = decoded_obj.get("race_mode", 0)
-        self.read_data["race_mode"] = lambda: race_mode
+        self.read_data["race_mode"] = lambda: decoded_obj.get("race_mode", 0)
        mdata_ver = decoded_obj["minimum_versions"]["server"]
        if mdata_ver > version_tuple:
            raise RuntimeError(f"Supplied Multidata (.archipelago) requires a server of at least version {mdata_ver}, "
@@ -538,6 +491,10 @@ class Context:
        self.locations = LocationStore(decoded_obj.pop("locations"))  # pre-emptively free memory
        self.slot_data = decoded_obj['slot_data']
        for slot, data in self.slot_data.items():
+            if not isinstance(data, bytes):
+                data = encode_to_bytes(data)
+            data = orjson.Fragment(data)
+            self.slot_data[slot] = data
            self.read_data[f"slot_data_{slot}"] = lambda data=data: data
        self.er_hint_data = {int(player): {int(address): name for address, name in loc_data.items()}
                             for player, loc_data in decoded_obj["er_hint_data"].items()}
@@ -675,7 +632,6 @@ class Context:
                             "server_password": self.server_password, "password": self.password,
                             "release_mode": self.release_mode,
                             "remaining_mode": self.remaining_mode, "collect_mode": self.collect_mode,
-                             "countdown_mode": self.countdown_mode,
                             "item_cheat": self.item_cheat, "compatibility": self.compatibility}

        }
@@ -710,7 +666,6 @@ class Context:
            self.release_mode = savedata["game_options"]["release_mode"]
            self.remaining_mode = savedata["game_options"]["remaining_mode"]
            self.collect_mode = savedata["game_options"]["collect_mode"]
-            self.countdown_mode = savedata["game_options"].get("countdown_mode", self.countdown_mode)
            self.item_cheat = savedata["game_options"]["item_cheat"]
            self.compatibility = savedata["game_options"]["compatibility"]

@@ -919,6 +874,12 @@ async def server(websocket: "ServerConnection", path: str = "/", ctx: Context =


 async def on_client_connected(ctx: Context, client: Client):
+    players = []
+    for team, clients in ctx.clients.items():
+        for slot, connected_clients in clients.items():
+            if connected_clients:
+                name = ctx.player_names[team, slot]
+                players.append(NetworkPlayer(team, slot, ctx.name_aliases.get((team, slot), name), name))
    games = {ctx.games[x] for x in range(1, len(ctx.games) + 1)}
    games.add("Archipelago")
    await ctx.send_msgs(client, [{
@@ -1179,13 +1140,8 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
        ctx.save()


-def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, str],
-                  status: HintStatus | None = None) -> typing.List[Hint]:
-    """
-    Collect a new hint for a given item id or name, with a given status.
-    If status is None (which is the default value), an automatic status will be determined from the item's quality.
-    """
-
+def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, str], auto_status: HintStatus) \
+        -> typing.List[Hint]:
    hints = []
    slots: typing.Set[int] = {slot}
    for group_id, group in ctx.groups.items():
@@ -1201,39 +1157,25 @@ def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, st
        else:
            found = location_id in ctx.location_checks[team, finding_player]
            entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
-
-            hint_status = status  # Assign again because we're in a for loop
+            new_status = auto_status
            if found:
-                hint_status = HintStatus.HINT_FOUND
-            elif hint_status is None:
-                if item_flags & ItemClassification.trap:
-                    hint_status = HintStatus.HINT_AVOID
-                else:
-                    hint_status = HintStatus.HINT_PRIORITY
-
-            hints.append(
-                Hint(receiving_player, finding_player, location_id, item_id, found, entrance, item_flags, hint_status)
-            )
+                new_status = HintStatus.HINT_FOUND
+            elif item_flags & ItemClassification.trap:
+                new_status = HintStatus.HINT_AVOID
+            hints.append(Hint(receiving_player, finding_player, location_id, item_id, found, entrance,
+                                       item_flags, new_status))

    return hints


-def collect_hint_location_name(ctx: Context, team: int, slot: int, location: str,
-                               status: HintStatus | None = HintStatus.HINT_UNSPECIFIED) -> typing.List[Hint]:
-    """
-    Collect a new hint for a given location name, with a given status (defaults to "unspecified").
-    If None is passed for the status, then an automatic status will be determined from the item's quality.
-    """
+def collect_hint_location_name(ctx: Context, team: int, slot: int, location: str, auto_status: HintStatus) \
+        -> typing.List[Hint]:
    seeked_location: int = ctx.location_names_for_game(ctx.games[slot])[location]
-    return collect_hint_location_id(ctx, team, slot, seeked_location, status)
+    return collect_hint_location_id(ctx, team, slot, seeked_location, auto_status)


-def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location: int,
-                             status: HintStatus | None = HintStatus.HINT_UNSPECIFIED) -> typing.List[Hint]:
-    """
-    Collect a new hint for a given location id, with a given status (defaults to "unspecified").
-    If None is passed for the status, then an automatic status will be determined from the item's quality.
-    """
+def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location: int, auto_status: HintStatus) \
+        -> typing.List[Hint]:
    prev_hint = ctx.get_hint(team, slot, seeked_location)
    if prev_hint:
        return [prev_hint]
@@ -1243,16 +1185,13 @@ def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location

        found = seeked_location in ctx.location_checks[team, slot]
        entrance = ctx.er_hint_data.get(slot, {}).get(seeked_location, "")
-
+        new_status = auto_status
        if found:
-            status = HintStatus.HINT_FOUND
-        elif status is None:
-            if item_flags & ItemClassification.trap:
-                status = HintStatus.HINT_AVOID
-            else:
-                status = HintStatus.HINT_PRIORITY
-
-        return [Hint(receiving_player, slot, seeked_location, item_id, found, entrance, item_flags, status)]
+            new_status = HintStatus.HINT_FOUND
+        elif item_flags & ItemClassification.trap:
+            new_status = HintStatus.HINT_AVOID
+        return [Hint(receiving_player, slot, seeked_location, item_id, found, entrance, item_flags,
+                              new_status)]
    return []


@@ -1303,13 +1242,6 @@ class CommandMeta(type):
            commands.update(base.commands)
        commands.update({command_name[5:]: method for command_name, method in attrs.items() if
                         command_name.startswith("_cmd_")})
-        for command_name, method in commands.items():
-            # wrap async def functions so they run on default asyncio loop
-            if inspect.iscoroutinefunction(method):
-                def _wrapper(self, *args, _method=method, **kwargs):
-                    return async_start(_method(self, *args, **kwargs))
-                functools.update_wrapper(_wrapper, method)
-                commands[command_name] = _wrapper
        return super(CommandMeta, cls).__new__(cls, name, bases, attrs)


@@ -1373,11 +1305,7 @@ class CommandProcessor(metaclass=CommandMeta):
                        argname += "=" + parameter.default
                argtext += argname
                argtext += " "
-            method_doc = inspect.getdoc(method)
-            if method_doc is None:
-                method_doc = "(missing help text)"
-            doctext = "\n    ".join(method_doc.split("\n"))
-            s += f"{self.marker}{command} {argtext}\n    {doctext}\n"
+            s += f"{self.marker}{command} {argtext}\n    {method.__doc__}\n"
        return s

    def _cmd_help(self):
@@ -1406,6 +1334,19 @@ class CommandProcessor(metaclass=CommandMeta):
 class CommonCommandProcessor(CommandProcessor):
    ctx: Context

+    def _cmd_countdown(self, seconds: str = "10") -> bool:
+        """Start a countdown in seconds"""
+        try:
+            timer = int(seconds, 10)
+        except ValueError:
+            timer = 10
+        else:
+            if timer > 60 * 60:
+                raise ValueError(f"{timer} is invalid. Maximum is 1 hour.")
+
+        async_start(countdown(self.ctx, timer))
+        return True
+
    def _cmd_options(self):
        """List all current options. Warning: lists password."""
        self.output("Current options:")
@@ -1547,23 +1488,6 @@ class ClientMessageProcessor(CommonCommandProcessor):
                    " You can ask the server admin for a /collect")
                return False

-    def _cmd_countdown(self, seconds: str = "10") -> bool:
-        """Start a countdown in seconds"""
-        if self.ctx.countdown_mode == "disabled" or \
-           self.ctx.countdown_mode == "auto" and len(self.ctx.player_names) >= 30:
-            self.output("Sorry, client countdowns have been disabled on this server. You can ask the server admin for a /countdown")
-            return False
-        try:
-            timer = int(seconds, 10)
-        except ValueError:
-            timer = 10
-        else:
-            if timer > 60 * 60:
-                raise ValueError(f"{timer} is invalid. Maximum is 1 hour.")
-
-        async_start(countdown(self.ctx, timer))
-        return True
-
    def _cmd_remaining(self) -> bool:
        """List remaining items in your game, but not their location or recipient"""
        if self.ctx.remaining_mode == "enabled":
@@ -1691,6 +1615,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
    def get_hints(self, input_text: str, for_location: bool = False) -> bool:
        points_available = get_client_points(self.ctx, self.client)
        cost = self.ctx.get_hint_cost(self.client.slot)
+        auto_status = HintStatus.HINT_UNSPECIFIED if for_location else HintStatus.HINT_PRIORITY
        if not input_text:
            hints = {hint.re_check(self.ctx, self.client.team) for hint in
                     self.ctx.hints[self.client.team, self.client.slot]}
@@ -1716,9 +1641,9 @@ class ClientMessageProcessor(CommonCommandProcessor):
                self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
                hints = []
            elif not for_location:
-                hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_id)
+                hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_id, auto_status)
            else:
-                hints = collect_hint_location_id(self.ctx, self.client.team, self.client.slot, hint_id)
+                hints = collect_hint_location_id(self.ctx, self.client.team, self.client.slot, hint_id, auto_status)

        else:
            game = self.ctx.games[self.client.slot]
@@ -1738,18 +1663,16 @@ class ClientMessageProcessor(CommonCommandProcessor):
                    hints = []
                    for item_name in self.ctx.item_name_groups[game][hint_name]:
                        if item_name in self.ctx.item_names_for_game(game):  # ensure item has an ID
-                            hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item_name))
+                            hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item_name, auto_status))
                elif not for_location and hint_name in self.ctx.item_names_for_game(game):  # item name
-                    hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name)
+                    hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name, auto_status)
                elif hint_name in self.ctx.location_name_groups[game]:  # location group name
                    hints = []
                    for loc_name in self.ctx.location_name_groups[game][hint_name]:
                        if loc_name in self.ctx.location_names_for_game(game):
-                            hints.extend(
-                                collect_hint_location_name(self.ctx, self.client.team, self.client.slot, loc_name)
-                            )
+                            hints.extend(collect_hint_location_name(self.ctx, self.client.team, self.client.slot, loc_name, auto_status))
                else:  # location name
-                    hints = collect_hint_location_name(self.ctx, self.client.team, self.client.slot, hint_name)
+                    hints = collect_hint_location_name(self.ctx, self.client.team, self.client.slot, hint_name, auto_status)

            else:
                self.output(response)
@@ -1868,11 +1791,11 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):

    if cmd == 'Connect':
        if not args or 'password' not in args or type(args['password']) not in [str, type(None)] or \
-                'game' not in args:
+                'game' not in args or "version" not in args:
            await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments", 'text': 'Connect',
                                          "original_cmd": cmd}])
            return
-
+        args["version"] = Version.from_network_dict(args["version"])
        errors = set()
        if ctx.password and args['password'] != ctx.password:
            errors.add('InvalidPassword')
@@ -1888,7 +1811,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
            if not ignore_game and args['game'] != game:
                errors.add('InvalidGame')
            minver = min_client_version if ignore_game else ctx.minimum_client_versions[slot]
-            if minver > args['version']:
+            if minver > args["version"]:
                errors.add('IncompatibleVersion')
            try:
                client.items_handling = args['items_handling']
@@ -1896,7 +1819,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                errors.add('InvalidItemsHandling')

        # only exact version match allowed
-        if ctx.compatibility == 0 and args['version'] != version_tuple:
+        if ctx.compatibility == 0 and args['version'] != Version(__version__):
            errors.add('IncompatibleVersion')
        if errors:
            ctx.logger.info(f"A client connection was refused due to: {errors}, the sent connect information was {args}.")
@@ -2027,7 +1950,8 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):

                target_item, target_player, flags = ctx.locations[client.slot][location]
                if create_as_hint:
-                    hints.extend(collect_hint_location_id(ctx, client.team, client.slot, location))
+                    hints.extend(collect_hint_location_id(ctx, client.team, client.slot, location,
+                                                          HintStatus.HINT_UNSPECIFIED))
                locs.append(NetworkItem(target_item, location, target_player, flags))
            ctx.notify_hints(client.team, hints, only_new=create_as_hint == 2, persist_even_if_found=True)
            if locs and create_as_hint:
@@ -2042,16 +1966,6 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
            if not locations:
                await ctx.send_msgs(client, [{"cmd": "InvalidPacket", "type": "arguments",
                                              "text": "CreateHints: No locations specified.", "original_cmd": cmd}])
-                return
-
-            try:
-                status = HintStatus(status)
-            except ValueError as err:
-                await ctx.send_msgs(client,
-                                    [{"cmd": "InvalidPacket", "type": "arguments",
-                                      "text": f"Unknown Status: {err}",
-                                      "original_cmd": cmd}])
-                return

            hints = []

@@ -2319,19 +2233,6 @@ class ServerCommandProcessor(CommonCommandProcessor):
        self.output(f"Could not find player {player_name} to collect")
        return False

-    def _cmd_countdown(self, seconds: str = "10") -> bool:
-        """Start a countdown in seconds"""
-        try:
-            timer = int(seconds, 10)
-        except ValueError:
-            timer = 10
-        else:
-            if timer > 60 * 60:
-                raise ValueError(f"{timer} is invalid. Maximum is 1 hour.")
-
-        async_start(countdown(self.ctx, timer))
-        return True
-
    @mark_raw
    def _cmd_release(self, player_name: str) -> bool:
        """Send out the remaining items from a player to their intended recipients."""
@@ -2453,9 +2354,9 @@ class ServerCommandProcessor(CommonCommandProcessor):
                    hints = []
                    for item_name_from_group in self.ctx.item_name_groups[game][item]:
                        if item_name_from_group in self.ctx.item_names_for_game(game):  # ensure item has an ID
-                            hints.extend(collect_hints(self.ctx, team, slot, item_name_from_group))
+                            hints.extend(collect_hints(self.ctx, team, slot, item_name_from_group, HintStatus.HINT_PRIORITY))
                else:  # item name or id
-                    hints = collect_hints(self.ctx, team, slot, item)
+                    hints = collect_hints(self.ctx, team, slot, item, HintStatus.HINT_PRIORITY)

                if hints:
                    self.ctx.notify_hints(team, hints)
@@ -2489,14 +2390,17 @@ class ServerCommandProcessor(CommonCommandProcessor):

            if usable:
                if isinstance(location, int):
-                    hints = collect_hint_location_id(self.ctx, team, slot, location)
+                    hints = collect_hint_location_id(self.ctx, team, slot, location,
+                                                     HintStatus.HINT_UNSPECIFIED)
                elif game in self.ctx.location_name_groups and location in self.ctx.location_name_groups[game]:
                    hints = []
                    for loc_name_from_group in self.ctx.location_name_groups[game][location]:
                        if loc_name_from_group in self.ctx.location_names_for_game(game):
-                            hints.extend(collect_hint_location_name(self.ctx, team, slot, loc_name_from_group))
+                            hints.extend(collect_hint_location_name(self.ctx, team, slot, loc_name_from_group,
+                                                                    HintStatus.HINT_UNSPECIFIED))
                else:
-                    hints = collect_hint_location_name(self.ctx, team, slot, location)
+                    hints = collect_hint_location_name(self.ctx, team, slot, location,
+                                                       HintStatus.HINT_UNSPECIFIED)
                if hints:
                    self.ctx.notify_hints(team, hints)
                else:
@@ -2524,11 +2428,6 @@ class ServerCommandProcessor(CommonCommandProcessor):
        elif value_type == str and option_name.endswith("password"):
            def value_type(input_text: str):
                return None if input_text.lower() in {"null", "none", '""', "''"} else input_text
-        elif option_name == "countdown_mode":
-            valid_values = {"enabled", "disabled", "auto"}
-            if option_value.lower() not in valid_values:
-                self.output(f"Unrecognized {option_name} value '{option_value}', known: {', '.join(valid_values)}")
-                return False
        elif value_type == str and option_name.endswith("mode"):
            valid_values = {"goal", "enabled", "disabled"}
            valid_values.update(("auto", "auto_enabled") if option_name != "remaining_mode" else [])
@@ -2572,8 +2471,6 @@ async def console(ctx: Context):
            input_text = await queue.get()
            queue.task_done()
            ctx.commandprocessor(input_text)
-        except asyncio.exceptions.CancelledError:
-            ctx.logger.info("ConsoleTask cancelled")
        except:
            import traceback
            traceback.print_exc()
@@ -2618,13 +2515,6 @@ def parse_args() -> argparse.Namespace:
                             goal:     !collect can be used after goal completion
                             auto-enabled: !collect is available and automatically triggered on goal completion
                             ''')
-    parser.add_argument('--countdown_mode', default=defaults["countdown_mode"], nargs='?',
-                        choices=['enabled', 'disabled', "auto"], help='''\
-                                Select !countdown Accessibility. (default: %(default)s)
-                                enabled:  !countdown is always available
-                                disabled: !countdown is never available
-                                auto:     !countdown is available for rooms with less than 30 players
-                                ''')
    parser.add_argument('--remaining_mode', default=defaults["remaining_mode"], nargs='?',
                        choices=['enabled', 'disabled', "goal"], help='''\
                             Select !remaining Accessibility. (default: %(default)s)
@@ -2633,8 +2523,8 @@ def parse_args() -> argparse.Namespace:
                             goal:     !remaining can be used after goal completion
                             ''')
    parser.add_argument('--auto_shutdown', default=defaults["auto_shutdown"], type=int,
-                        help="automatically shut down the server after this many seconds without new location checks. "
-                             "0 to keep running.")
+                        help="automatically shut down the server after this many minutes without new location checks. "
+                             "0 to keep running. Not yet implemented.")
    parser.add_argument('--use_embedded_options', action="store_true",
                        help='retrieve release, remaining and hint options from the multidata file,'
                             ' instead of host.yaml')
@@ -2690,7 +2580,7 @@ async def main(args: argparse.Namespace):

    ctx = Context(args.host, args.port, args.server_password, args.password, args.location_check_points,
                  args.hint_cost, not args.disable_item_cheat, args.release_mode, args.collect_mode,
-                  args.countdown_mode, args.remaining_mode,
+                  args.remaining_mode,
                  args.auto_shutdown, args.compatibility, args.log_network)
    data_filename = args.multidata

@@ -2725,13 +2615,7 @@ async def main(args: argparse.Namespace):

    ssl_context = load_server_cert(args.cert, args.cert_key) if args.cert else None

-    ctx.server = websockets.serve(
-        functools.partial(server, ctx=ctx),
-        host=ctx.host,
-        port=ctx.port,
-        ssl=ssl_context,
-        extensions=[server_per_message_deflate_factory],
-    )
+    ctx.server = websockets.serve(functools.partial(server, ctx=ctx), host=ctx.host, port=ctx.port, ssl=ssl_context)
    ip = args.host if args.host else Utils.get_public_ipv4()
    logging.info('Hosting game at %s:%d (%s)' % (ip, ctx.port,
                                                 'No password' if not ctx.password else 'Password: %s' % ctx.password))
@@ -2740,26 +2624,6 @@ async def main(args: argparse.Namespace):
    console_task = asyncio.create_task(console(ctx))
    if ctx.auto_shutdown:
        ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, [console_task]))
-
-    def stop():
-        try:
-            for remove_signal in [SIGINT, SIGTERM]:
-                asyncio.get_event_loop().remove_signal_handler(remove_signal)
-        except NotImplementedError:
-            pass
-        ctx.commandprocessor._cmd_exit()
-
-    def shutdown(signum, frame):
-        stop()
-
-    try:
-        for sig in [SIGINT, SIGTERM]:
-            asyncio.get_event_loop().add_signal_handler(sig, stop)
-    except NotImplementedError:
-        # add_signal_handler is only implemented for UNIX platforms
-        for sig in [SIGINT, SIGTERM]:
-            signal(sig, shutdown)
-
    await ctx.exit_event.wait()
    console_task.cancel()
    if ctx.shutdown_task:
@@ -4,7 +4,7 @@ from collections.abc import Mapping, Sequence
 import typing
 import enum
 import warnings
-from json import JSONEncoder, JSONDecoder
+import orjson

 if typing.TYPE_CHECKING:
    from websockets import WebSocketServerProtocol as ServerConnection
@@ -78,6 +78,11 @@ class NetworkPlayer(typing.NamedTuple):
    alias: str
    name: str

+    @classmethod
+    def from_network_dict(cls, source: dict):
+        source.pop("class", None)
+        return cls(**source)
+

 class NetworkSlot(typing.NamedTuple):
    """Represents a particular slot across teams."""
@@ -86,6 +91,11 @@ class NetworkSlot(typing.NamedTuple):
    type: SlotType
    group_members: Sequence[int] = ()  # only populated if type == group

+    @classmethod
+    def from_network_dict(cls, source: dict):
+        source.pop("class", None)
+        return cls(**source)
+

 class NetworkItem(typing.NamedTuple):
    item: int
@@ -94,6 +104,11 @@ class NetworkItem(typing.NamedTuple):
    """ Sending player, except in LocationInfo (from LocationScouts), where it is the receiving player. """
    flags: int = 0

+    @classmethod
+    def from_network_dict(cls, source: dict):
+        source.pop("class", None)
+        return cls(**source)
+

 def _scan_for_TypedTuples(obj: typing.Any) -> typing.Any:
    if isinstance(obj, tuple) and hasattr(obj, "_fields"):  # NamedTuple is not actually a parent class
@@ -128,15 +143,12 @@ def convert_to_base_types(obj: typing.Any) -> _base_types:
        raise Exception(f"Cannot handle {type(obj)}")


-_encode = JSONEncoder(
-    ensure_ascii=False,
-    check_circular=False,
-    separators=(',', ':'),
-).encode
+def encode_to_bytes(obj: typing.Any) -> bytes:
+    return orjson.dumps(_scan_for_TypedTuples(obj), option=orjson.OPT_NON_STR_KEYS)


 def encode(obj: typing.Any) -> str:
-    return _encode(_scan_for_TypedTuples(obj))
+    return encode_to_bytes(obj).decode()


 def get_any_version(data: dict) -> Version:
@@ -144,38 +156,13 @@ def get_any_version(data: dict) -> Version:
    return Version(int(data["major"]), int(data["minor"]), int(data["build"]))


-allowlist = {
-    "NetworkPlayer": NetworkPlayer,
-    "NetworkItem": NetworkItem,
-    "NetworkSlot": NetworkSlot
-}
-
-custom_hooks = {
-    "Version": get_any_version
-}
-
-
-def _object_hook(o: typing.Any) -> typing.Any:
-    if isinstance(o, dict):
-        hook = custom_hooks.get(o.get("class", None), None)
-        if hook:
-            return hook(o)
-        cls = allowlist.get(o.get("class", None), None)
-        if cls:
-            for key in tuple(o):
-                if key not in cls._fields:
-                    del (o[key])
-            return cls(**o)
-
-    return o
-
-
-decode = JSONDecoder(object_hook=_object_hook).decode
+def decode(data: str | bytes) -> typing.Any:
+    if isinstance(data, str):
+        data = data.encode()
+    return orjson.loads(data)


 class Endpoint:
-    __slots__ = ("socket",)
-
    socket: "ServerConnection"

    def __init__(self, socket):
@@ -527,11 +514,7 @@ else:
        except ImportError:
            pyximport = None
        try:
-            import logging
-            logger = logging.getLogger()
-            old_level = logger.level
            from _speedups import LocationStore
-            logger.setLevel(old_level)
        except ImportError:
            warnings.warn("_speedups not available. Falling back to pure python LocationStore. "
                          "Install a matching C++ compiler for your platform to compile _speedups.")
@@ -24,39 +24,6 @@ if typing.TYPE_CHECKING:
    import pathlib


-_RANDOM_OPTS = [
-        "random", "random-low", "random-middle", "random-high", 
-        "random-range-low-<min>-<max>", "random-range-middle-<min>-<max>",
-        "random-range-high-<min>-<max>", "random-range-<min>-<max>",
-]
-    
-    
-def triangular(lower: int, end: int, tri: float = 0.5) -> int:
-    """
-    Integer triangular distribution for `lower` inclusive to `end` inclusive.
-
-    Expects `lower <= end` and `0.0 <= tri <= 1.0`. The result of other inputs is undefined.
-    """
-    # Use the continuous range [lower, end + 1) to produce an integer result in [lower, end].
-    # random.triangular is actually [a, b] and not [a, b), so there is a very small chance of getting exactly b even
-    # when a != b, so ensure the result is never more than `end`.
-    return min(end, math.floor(random.triangular(0.0, 1.0, tri) * (end - lower + 1) + lower))
-  
-
-def random_weighted_range(text: str, range_start: int, range_end: int):
-    if text == "random-low":
-        return triangular(range_start, range_end, 0.0)
-    elif text == "random-high":
-        return triangular(range_start, range_end, 1.0)
-    elif text == "random-middle":
-        return triangular(range_start, range_end)
-    elif text == "random":
-        return random.randint(range_start, range_end)
-    else:
-            raise Exception(f"random text \"{text}\" did not resolve to a recognized pattern. "
-                            f"Acceptable values are: {', '.join(_RANDOM_OPTS)}.")
-
-        
 def roll_percentage(percentage: int | float) -> bool:
    """Roll a percentage chance.
    percentage is expected to be in range [0, 100]"""
@@ -212,13 +179,6 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
        else:
            return cls.name_lookup[value]

-    def __eq__(self, other: typing.Any) -> bool:
-        if isinstance(other, self.__class__):
-            return self.value == other.value
-        if isinstance(other, Option):
-            raise TypeError(f"Can't compare {self.__class__.__name__} with {other.__class__.__name__}")
-        return self.value == other
-
    def __int__(self) -> T:
        return self.value

@@ -457,12 +417,10 @@ class Toggle(NumericOption):
    def from_text(cls, text: str) -> Toggle:
        if text == "random":
            return cls(random.choice(list(cls.name_lookup)))
-        elif text.lower() in {"off", "0", "false", "none", "null", "no", "disabled"}:
+        elif text.lower() in {"off", "0", "false", "none", "null", "no"}:
            return cls(0)
-        elif text.lower() in {"on", "1", "true", "yes", "enabled"}:
-            return cls(1)
        else:
-            raise OptionError(f"Option {cls.__name__} does not support a value of {text}")
+            return cls(1)

    @classmethod
    def from_any(cls, data: typing.Any):
@@ -565,9 +523,9 @@ class Choice(NumericOption):

 class TextChoice(Choice):
    """Allows custom string input and offers choices. Choices will resolve to int and text will resolve to string"""
-    value: str | int
+    value: typing.Union[str, int]

-    def __init__(self, value: str | int):
+    def __init__(self, value: typing.Union[str, int]):
        assert isinstance(value, str) or isinstance(value, int), \
            f"'{value}' is not a valid option for '{self.__class__.__name__}'"
        self.value = value
@@ -588,7 +546,7 @@ class TextChoice(Choice):
        return cls(text)

    @classmethod
-    def get_option_name(cls, value: str | int) -> str:
+    def get_option_name(cls, value: T) -> str:
        if isinstance(value, str):
            return value
        return super().get_option_name(value)
@@ -755,39 +713,33 @@ class Range(NumericOption):
            # these are the conditions where "true" and "false" make sense
            if text == "true":
                return cls.from_any(cls.default)
-            # "false"
-            return cls(0)
-
-        try:
-            num = int(text)
-        except ValueError:
-            # text is not a number
-            # Handle conditionally acceptable values here rather than in the f-string
-            default = ""
-            truefalse = ""
-            if hasattr(cls, "default"):
-                default = ", default"
-                if cls.range_start == 0 and cls.default != 0:
-                    truefalse = ", \"true\", \"false\""
-            raise Exception(f"Invalid range value {text!r}. Acceptable values are: "
-                            f"<int>{default}, high, low{truefalse}, "
-                            f"{', '.join(cls._RANDOM_OPTS)}.")
-
-        return cls(num)
-
+            else:  # "false"
+                return cls(0)
+        return cls(int(text))

    @classmethod
    def weighted_range(cls, text) -> Range:
-        if text.startswith("random-range-"):
+        if text == "random-low":
+            return cls(cls.triangular(cls.range_start, cls.range_end, 0.0))
+        elif text == "random-high":
+            return cls(cls.triangular(cls.range_start, cls.range_end, 1.0))
+        elif text == "random-middle":
+            return cls(cls.triangular(cls.range_start, cls.range_end))
+        elif text.startswith("random-range-"):
            return cls.custom_range(text)
+        elif text == "random":
+            return cls(random.randint(cls.range_start, cls.range_end))
        else:
-            return cls(random_weighted_range(text, cls.range_start, cls.range_end))
+            raise Exception(f"random text \"{text}\" did not resolve to a recognized pattern. "
+                            f"Acceptable values are: random, random-high, random-middle, random-low, "
+                            f"random-range-low-<min>-<max>, random-range-middle-<min>-<max>, "
+                            f"random-range-high-<min>-<max>, or random-range-<min>-<max>.")

    @classmethod
    def custom_range(cls, text) -> Range:
        textsplit = text.split("-")
        try:
-            random_range = [int(textsplit[-2]), int(textsplit[-1])]
+            random_range = [int(textsplit[len(textsplit) - 2]), int(textsplit[len(textsplit) - 1])]
        except ValueError:
            raise ValueError(f"Invalid random range {text} for option {cls.__name__}")
        random_range.sort()
@@ -795,9 +747,14 @@ class Range(NumericOption):
            raise Exception(
                f"{random_range[0]}-{random_range[1]} is outside allowed range "
                f"{cls.range_start}-{cls.range_end} for option {cls.__name__}")
-        if textsplit[2] in ("low", "middle", "high"):
-            return cls(random_weighted_range(f"{textsplit[0]}-{textsplit[2]}", *random_range))
-        return cls(random_weighted_range("random", *random_range))
+        if text.startswith("random-range-low"):
+            return cls(cls.triangular(random_range[0], random_range[1], 0.0))
+        elif text.startswith("random-range-middle"):
+            return cls(cls.triangular(random_range[0], random_range[1]))
+        elif text.startswith("random-range-high"):
+            return cls(cls.triangular(random_range[0], random_range[1], 1.0))
+        else:
+            return cls(random.randint(random_range[0], random_range[1]))

    @classmethod
    def from_any(cls, data: typing.Any) -> Range:
@@ -812,6 +769,18 @@ class Range(NumericOption):
    def __str__(self) -> str:
        return str(self.value)

+    @staticmethod
+    def triangular(lower: int, end: int, tri: float = 0.5) -> int:
+        """
+        Integer triangular distribution for `lower` inclusive to `end` inclusive.
+
+        Expects `lower <= end` and `0.0 <= tri <= 1.0`. The result of other inputs is undefined.
+        """
+        # Use the continuous range [lower, end + 1) to produce an integer result in [lower, end].
+        # random.triangular is actually [a, b] and not [a, b), so there is a very small chance of getting exactly b even
+        # when a != b, so ensure the result is never more than `end`.
+        return min(end, math.floor(random.triangular(0.0, 1.0, tri) * (end - lower + 1) + lower))
+

 class NamedRange(Range):
    special_range_names: typing.Dict[str, int] = {}
@@ -901,7 +870,7 @@ class VerifyKeys(metaclass=FreezeValidKeys):
    def __iter__(self) -> typing.Iterator[typing.Any]:
        return self.value.__iter__()

-
+    
 class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mapping[str, typing.Any]):
    default = {}
    supports_weighting = False
@@ -916,8 +885,7 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mappin
        else:
            raise NotImplementedError(f"Cannot Convert from non-dictionary, got {type(data)}")

-    @classmethod
-    def get_option_name(cls, value):
+    def get_option_name(self, value):
        return ", ".join(f"{key}: {v}" for key, v in value.items())

    def __getitem__(self, item: str) -> typing.Any:
@@ -937,34 +905,13 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mappin
 class OptionCounter(OptionDict):
    min: int | None = None
    max: int | None = None
-    cull_zeroes: bool = False

    def __init__(self, value: dict[str, int]) -> None:
-        cleaned_dict = {}
-
-        invalid_value_errors = []
-        for key, value in value.items():
-            if not isinstance(value, (int, float)) or int(value) != value:
-                invalid_value_errors += [f"Invalid value {value} for key {key}, must be an integer."]
-                continue
-
-            if self.cull_zeroes and value == 0:
-                continue
-
-            cleaned_dict[key] = int(value)
-
-        if invalid_value_errors:
-            type_errors = [f"For option {self.__class__.__name__}:"] + invalid_value_errors
-            raise TypeError("\n".join(invalid_value_errors))
-
-        super(OptionCounter, self).__init__(collections.Counter(cleaned_dict))
+        super(OptionCounter, self).__init__(collections.Counter(value))

    def verify(self, world: type[World], player_name: str, plando_options: PlandoOptions) -> None:
        super(OptionCounter, self).verify(world, player_name, plando_options)

-        self.verify_values()
-
-    def verify_values(self):
        range_errors = []

        if self.max is not None:
@@ -987,8 +934,13 @@ class OptionCounter(OptionDict):
 class ItemDict(OptionCounter):
    verify_item_name = True

-    # Backwards compatibility: Cull 0s to make "in" checks behave the same as when this wasn't a OptionCounter
-    cull_zeroes = True
+    min = 0
+
+    def __init__(self, value: dict[str, int]) -> None:
+        # Backwards compatibility: Cull 0s to make "in" checks behave the same as when this wasn't a OptionCounter
+        value = {item_name: amount for item_name, amount in value.items() if amount != 0}
+
+        super(ItemDict, self).__init__(value)


 class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
@@ -1013,8 +965,7 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
            return cls(data)
        return cls.from_text(str(data))

-    @classmethod
-    def get_option_name(cls, value):
+    def get_option_name(self, value):
        return ", ".join(map(str, value))

    def __contains__(self, item):
@@ -1024,19 +975,13 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
 class OptionSet(Option[typing.Set[str]], VerifyKeys):
    default = frozenset()
    supports_weighting = False
-    random_str: str | None

-    def __init__(self, value: typing.Iterable[str], random_str: str | None = None):
+    def __init__(self, value: typing.Iterable[str]):
        self.value = set(deepcopy(value))
-        self.random_str = random_str
        super(OptionSet, self).__init__()

    @classmethod
    def from_text(cls, text: str):
-        check_text = text.lower().split(",")
-        if ((cls.valid_keys or cls.verify_item_name or cls.verify_location_name)
-                and len(check_text) == 1 and check_text[0].startswith("random")):
-            return cls((), check_text[0])
        return cls([option.strip() for option in text.split(",")])

    @classmethod
@@ -1045,37 +990,7 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
            return cls(data)
        return cls.from_text(str(data))

-    def verify(self, world: typing.Type[World], player_name: str, plando_options: PlandoOptions) -> None:
-        if self.random_str and not self.value:
-            choice_list = sorted(self.valid_keys)
-            if self.verify_item_name:
-                choice_list.extend(sorted(world.item_names))
-            if self.verify_location_name:
-                choice_list.extend(sorted(world.location_names))
-            if self.random_str.startswith("random-range-"):
-                textsplit = self.random_str.split("-")
-                try:
-                    random_range = [int(textsplit[-2]), int(textsplit[-1])]
-                except ValueError:
-                    raise ValueError(f"Invalid random range {self.random_str} for option {self.__class__.__name__} "
-                                     f"for player {player_name}")
-                random_range.sort()
-                if random_range[0] < 0 or random_range[1] > len(choice_list):
-                    raise Exception(
-                        f"{random_range[0]}-{random_range[1]} is outside allowed range "
-                        f"0-{len(choice_list)} for option {self.__class__.__name__} for player {player_name}")
-                if textsplit[2] in ("low", "middle", "high"):
-                    choice_count = random_weighted_range(f"{textsplit[0]}-{textsplit[2]}",
-                                                         random_range[0], random_range[1])
-                else:
-                    choice_count = random_weighted_range("random", random_range[0], random_range[1])
-            else:
-                choice_count = random_weighted_range(self.random_str, 0, len(choice_list))
-            self.value = set(random.sample(choice_list, k=choice_count))
-        super(Option, self).verify(world, player_name, plando_options)
-
-    @classmethod
-    def get_option_name(cls, value):
+    def get_option_name(self, value):
        return ", ".join(sorted(value))

    def __contains__(self, item):
@@ -1103,8 +1018,6 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
    supports_weighting = False
    display_name = "Plando Texts"

-    visibility = Visibility.template | Visibility.complex_ui | Visibility.spoiler
-
    def __init__(self, value: typing.Iterable[PlandoText]) -> None:
        self.value = list(deepcopy(value))
        super().__init__()
@@ -1231,8 +1144,6 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
    entrances: typing.ClassVar[typing.AbstractSet[str]]
    exits: typing.ClassVar[typing.AbstractSet[str]]

-    visibility = Visibility.template | Visibility.complex_ui | Visibility.spoiler
-
    duplicate_exits: bool = False
    """Whether or not exits should be allowed to be duplicate."""

@@ -1469,7 +1380,7 @@ class NonLocalItems(ItemSet):


 class StartInventory(ItemDict):
-    """Start with the specified amount of these items. Example: {Bomb: 1, Arrow: 3} """
+    """Start with these items."""
    verify_item_name = True
    display_name = "Start Inventory"
    rich_text_doc = True
@@ -1477,7 +1388,7 @@ class StartInventory(ItemDict):


 class StartInventoryPool(StartInventory):
-    """Start with the specified amount of these items and don't place them in the world. Example: {Bomb: 1, Arrow: 3}
+    """Start with these items and don't place them in the world.

    The game decides what the replacement items will be.
    """
@@ -1524,7 +1435,6 @@ class DeathLink(Toggle):
 class ItemLinks(OptionList):
    """Share part of your item pool with other players."""
    display_name = "Item Links"
-    visibility = Visibility.template | Visibility.complex_ui | Visibility.spoiler
    rich_text_doc = True
    default = []
    schema = Schema([
@@ -1536,7 +1446,6 @@ class ItemLinks(OptionList):
            Optional("local_items"): [And(str, len)],
            Optional("non_local_items"): [And(str, len)],
            Optional("link_replacement"): Or(None, bool),
-            Optional("skip_if_solo"): Or(None, bool),
        }
    ])

@@ -1564,10 +1473,8 @@ class ItemLinks(OptionList):
        super(ItemLinks, self).verify(world, player_name, plando_options)
        existing_links = set()
        for link in self.value:
-            link["name"] = link["name"].strip()[:16].strip()
            if link["name"] in existing_links:
-                raise Exception(f"Item link names are limited to their first 16 characters and must be unique. "
-                                f"You have more than one link named '{link['name']}'.")
+                raise Exception(f"You cannot have more than one link named {link['name']}.")
            existing_links.add(link["name"])

            pool = self.verify_items(link["item_pool"], link["name"], "item_pool", world)
@@ -1609,7 +1516,6 @@ class PlandoItems(Option[typing.List[PlandoItem]]):
    default = ()
    supports_weighting = False
    display_name = "Plando Items"
-    visibility = Visibility.template | Visibility.spoiler

    def __init__(self, value: typing.Iterable[PlandoItem]) -> None:
        self.value = list(deepcopy(value))
@@ -1720,7 +1626,7 @@ class PlandoItems(Option[typing.List[PlandoItem]]):
    def __len__(self) -> int:
        return len(self.value)

-
+        
 class Removed(FreeText):
    """This Option has been Removed."""
    rich_text_doc = True
@@ -1806,10 +1712,8 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
    from Utils import local_path, __version__

    full_path: str
-    preset_folder = os.path.join(target_folder, "Presets")

    os.makedirs(target_folder, exist_ok=True)
-    os.makedirs(preset_folder, exist_ok=True)

    # clean out old
    for file in os.listdir(target_folder):
@@ -1817,30 +1721,18 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
        if os.path.isfile(full_path) and full_path.endswith(".yaml"):
            os.unlink(full_path)

-    for file in os.listdir(preset_folder):
-        full_path = os.path.join(preset_folder, file)
-        if os.path.isfile(full_path) and full_path.endswith(".yaml"):
-            os.unlink(full_path)
-
-    def dictify_range(option: Range, option_val: int | str):
-        data = {option_val: 50}
-        for sub_option in ["random", "random-low", "random-high",
-                           f"random-range-{option.range_start}-{option.range_end}"]:
-            if sub_option != option_val:
+    def dictify_range(option: Range):
+        data = {option.default: 50}
+        for sub_option in ["random", "random-low", "random-high"]:
+            if sub_option != option.default:
                data[sub_option] = 0
-        notes = {
-            "random-low": "random value weighted towards lower values",
-            "random-high": "random value weighted towards higher values",
-            f"random-range-{option.range_start}-{option.range_end}": f"random value between "
-                                                                     f"{option.range_start} and {option.range_end}"
-        }
+
+        notes = {}
        for name, number in getattr(option, "special_range_names", {}).items():
            notes[name] = f"equivalent to {number}"
            if number in data:
                data[name] = data[number]
                del data[number]
-            elif name in data:
-                pass
            else:
                data[name] = 0

@@ -1856,30 +1748,17 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge

    for game_name, world in AutoWorldRegister.world_types.items():
        if not world.hidden or generate_hidden:
-            try:
-                presets = world.web.options_presets.copy()
-                presets.update({"": {}})
+            option_groups = get_option_groups(world)

-                option_groups = get_option_groups(world)
-                for name, preset in presets.items():
-                    res = template.render(
-                        option_groups=option_groups,
-                        __version__=__version__,
-                        game=game_name,
-                        world_version=world.world_version.as_simple_string(),
-                        yaml_dump=yaml_dump_scalar,
-                        dictify_range=dictify_range,
-                        cleandoc=cleandoc,
-                        preset_name=name,
-                        preset=preset,
-                    )
-                    preset_name = f" - {name}" if name else ""
-                    with open(os.path.join(preset_folder if name else target_folder,
-                                           get_file_safe_name(game_name + preset_name) + ".yaml"),
-                              "w", encoding="utf-8-sig") as f:
-                        f.write(res)
-            except Exception as ex:
-                raise Exception(f"Template generation failed for world {game_name}") from ex
+            res = template.render(
+                option_groups=option_groups,
+                __version__=__version__, game=game_name, yaml_dump=yaml_dump_scalar,
+                dictify_range=dictify_range,
+                cleandoc=cleandoc,
+            )
+
+            with open(os.path.join(target_folder, get_file_safe_name(game_name) + ".yaml"), "w", encoding="utf-8-sig") as f:
+                f.write(res)


 def dump_player_options(multiworld: MultiWorld) -> None:
@@ -1,709 +0,0 @@
-if __name__ == "__main__":
-    import ModuleUpdate
-
-    ModuleUpdate.update()
-
-
-from kvui import (ThemedApp, ScrollBox, MainLayout, ContainerLayout, dp, Widget, MDBoxLayout, TooltipLabel, MDLabel,
-                  ToggleButton, MarkupDropdown, ResizableTextField)
-from kivy.clock import Clock
-from kivy.uix.behaviors.button import ButtonBehavior
-from kivymd.uix.behaviors import RotateBehavior
-from kivymd.uix.anchorlayout import MDAnchorLayout
-from kivymd.uix.expansionpanel import MDExpansionPanel, MDExpansionPanelContent, MDExpansionPanelHeader
-from kivymd.uix.list import MDListItem, MDListItemTrailingIcon, MDListItemSupportingText
-from kivymd.uix.slider import MDSlider
-from kivymd.uix.snackbar import MDSnackbar, MDSnackbarText
-from kivymd.uix.menu import MDDropdownMenu
-from kivymd.uix.button import MDButton, MDButtonText, MDIconButton
-from kivymd.uix.dialog import MDDialog
-from kivy.core.text.markup import MarkupLabel
-from kivy.utils import escape_markup
-from kivy.lang.builder import Builder
-from kivy.properties import ObjectProperty
-from textwrap import dedent
-from copy import deepcopy
-import Utils
-import typing
-import webbrowser
-import re
-from urllib.parse import urlparse
-from worlds.AutoWorld import AutoWorldRegister, World
-from Options import (Option, Toggle, TextChoice, Choice, FreeText, NamedRange, Range, OptionSet, OptionList,
-                     OptionCounter, Visibility)
-
-
-def validate_url(x):
-    try:
-        result = urlparse(x)
-        return all([result.scheme, result.netloc])
-    except AttributeError:
-        return False
-
-
-def filter_tooltip(tooltip):
-    if tooltip is None:
-        tooltip = "No tooltip available."
-    tooltip = dedent(tooltip).strip().replace("\n", "<br>").replace("&", "&amp;") \
-        .replace("[", "&bl;").replace("]", "&br;")
-    tooltip = re.sub(r"\*\*(.+?)\*\*", r"[b]\g<1>[/b]", tooltip)
-    tooltip = re.sub(r"\*(.+?)\*", r"[i]\g<1>[/i]", tooltip)
-    return escape_markup(tooltip)
-
-
-def option_can_be_randomized(option: typing.Type[Option]):
-    # most options can be randomized, so we should just check for those that cannot
-    if not option.supports_weighting:
-        return False
-    elif issubclass(option, FreeText) and not issubclass(option, TextChoice):
-        return False
-    return True
-
-
-def check_random(value: typing.Any):
-    if not isinstance(value, str):
-        return value  # cannot be random if evaluated
-    if value.startswith("random-"):
-        return "random"
-    return value
-
-
-class TrailingPressedIconButton(ButtonBehavior, RotateBehavior, MDListItemTrailingIcon):
-    pass
-
-
-class WorldButton(ToggleButton):
-    world_cls: typing.Type[World]
-
-
-class VisualRange(MDBoxLayout):
-    option: typing.Type[Range]
-    name: str
-    tag: MDLabel = ObjectProperty(None)
-    slider: MDSlider = ObjectProperty(None)
-
-    def __init__(self, *args, option: typing.Type[Range], name: str, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-
-        def update_points(*update_args):
-            pass
-
-        self.slider._update_points = update_points
-
-
-class VisualChoice(MDButton):
-    option: typing.Type[Choice]
-    name: str
-    text: MDButtonText = ObjectProperty(None)
-
-    def __init__(self, *args, option: typing.Type[Choice], name: str, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-
-
-class VisualNamedRange(MDBoxLayout):
-    option: typing.Type[NamedRange]
-    name: str
-    range: VisualRange = ObjectProperty(None)
-    choice: MDButton = ObjectProperty(None)
-
-    def __init__(self, *args, option: typing.Type[NamedRange], name: str, range_widget: VisualRange, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-        self.range = range_widget
-        self.add_widget(self.range)
-
-
-class VisualFreeText(ResizableTextField):
-    option: typing.Type[FreeText] | typing.Type[TextChoice]
-    name: str
-
-    def __init__(self, *args, option: typing.Type[FreeText] | typing.Type[TextChoice], name: str, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-
-
-class VisualTextChoice(MDBoxLayout):
-    option: typing.Type[TextChoice]
-    name: str
-    choice: VisualChoice = ObjectProperty(None)
-    text: VisualFreeText = ObjectProperty(None)
-
-    def __init__(self, *args, option: typing.Type[TextChoice], name: str, choice: VisualChoice,
-                 text: VisualFreeText, **kwargs):
-        self.option = option
-        self.name = name
-        super(MDBoxLayout, self).__init__(*args, **kwargs)
-        self.choice = choice
-        self.text = text
-        self.add_widget(self.choice)
-        self.add_widget(self.text)
-
-
-class VisualToggle(MDBoxLayout):
-    button: MDIconButton = ObjectProperty(None)
-    option: typing.Type[Toggle]
-    name: str
-
-    def __init__(self, *args, option: typing.Type[Toggle], name: str, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-
-
-class CounterItemValue(ResizableTextField):
-    pat = re.compile('[^0-9]')
-
-    def insert_text(self, substring, from_undo=False):
-        return super().insert_text(re.sub(self.pat, "", substring), from_undo=from_undo)
-
-
-class VisualListSetCounter(MDDialog):
-    button: MDIconButton = ObjectProperty(None)
-    option: typing.Type[OptionSet] | typing.Type[OptionList] | typing.Type[OptionCounter]
-    scrollbox: ScrollBox = ObjectProperty(None)
-    add: MDIconButton = ObjectProperty(None)
-    save: MDButton = ObjectProperty(None)
-    input: ResizableTextField = ObjectProperty(None)
-    dropdown: MDDropdownMenu
-    valid_keys: typing.Iterable[str]
-
-    def __init__(self, *args, option: typing.Type[OptionSet] | typing.Type[OptionList],
-                 name: str, valid_keys: typing.Iterable[str], **kwargs):
-        self.option = option
-        self.name = name
-        self.valid_keys = valid_keys
-        super().__init__(*args, **kwargs)
-        self.dropdown = MarkupDropdown(caller=self.input, border_margin=dp(2),
-                                       width=self.input.width, position="bottom")
-        self.input.bind(text=self.on_text)
-        self.input.bind(on_text_validate=self.validate_add)
-
-    def validate_add(self, instance):
-        if self.valid_keys:
-            if self.input.text not in self.valid_keys:
-                MDSnackbar(MDSnackbarText(text="Item must be a valid key for this option."), y=dp(24),
-                           pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
-                return
-
-        if not issubclass(self.option, OptionList):
-            if any(self.input.text == child.text.text for child in self.scrollbox.layout.children):
-                MDSnackbar(MDSnackbarText(text="This value is already in the set."), y=dp(24),
-                           pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
-                return
-
-        self.add_set_item(self.input.text)
-        self.input.set_text(self.input, "")
-
-    def remove_item(self, button: MDIconButton):
-        list_item = button.parent
-        self.scrollbox.layout.remove_widget(list_item)
-
-    def add_set_item(self, key: str, value: int | None = None):
-        text = MDListItemSupportingText(text=key, id="value")
-        if issubclass(self.option, OptionCounter):
-            value_txt = CounterItemValue(text=str(value) if value else "1")
-            item = MDListItem(text,
-                              value_txt,
-                              MDIconButton(icon="minus", on_release=self.remove_item), focus_behavior=False)
-            item.value = value_txt
-        else:
-            item = MDListItem(text, MDIconButton(icon="minus", on_release=self.remove_item), focus_behavior=False)
-        item.text = text
-        self.scrollbox.layout.add_widget(item)
-
-    def on_text(self, instance, value):
-        if not self.valid_keys:
-            return
-        if len(value) >= 3:
-            self.dropdown.items.clear()
-
-            def on_press(txt):
-                split_text = MarkupLabel(text=txt, markup=True).markup
-                self.input.set_text(self.input, "".join(text_frag for text_frag in split_text
-                                                        if not text_frag.startswith("[")))
-                self.input.focus = True
-                self.dropdown.dismiss()
-
-            lowered = value.lower()
-            for item_name in self.valid_keys:
-                try:
-                    index = item_name.lower().index(lowered)
-                except ValueError:
-                    pass  # substring not found
-                else:
-                    text = escape_markup(item_name)
-                    text = text[:index] + "[b]" + text[index:index + len(value)] + "[/b]" + text[index + len(value):]
-                    self.dropdown.items.append({
-                        "text": text,
-                        "on_release": lambda txt=text: on_press(txt),
-                        "markup": True
-                    })
-            if not self.dropdown.parent:
-                self.dropdown.open()
-        else:
-            self.dropdown.dismiss()
-
-
-class OptionsCreator(ThemedApp):
-    base_title: str = "Archipelago Options Creator"
-    container: ContainerLayout
-    main_layout: MainLayout
-    scrollbox: ScrollBox
-    main_panel: MainLayout
-    player_options: MainLayout
-    option_layout: MainLayout
-    name_input: ResizableTextField
-    game_label: MDLabel
-    current_game: str
-    options: typing.Dict[str, typing.Any]
-
-    def __init__(self):
-        self.title = self.base_title + " " + Utils.__version__
-        self.icon = r"data/icon.png"
-        self.current_game = ""
-        self.options = {}
-        super().__init__()
-
-    @staticmethod
-    def show_result_snack(text: str) -> None:
-        MDSnackbar(MDSnackbarText(text=text), y=dp(24), pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
-
-    def on_export_result(self, text: str | None) -> None:
-        self.container.disabled = False
-        if text is not None:
-            Clock.schedule_once(lambda _: self.show_result_snack(text), 0)
-
-    def export_options_background(self, options: dict[str, typing.Any]) -> None:
-        try:
-            file_name = Utils.save_filename("Export Options File As...", [("YAML", [".yaml"])],
-                                            Utils.get_file_safe_name(f"{self.name_input.text}.yaml"))
-        except Exception:
-            self.on_export_result("Could not open dialog. Already open?")
-            raise
-
-        if not file_name:
-            self.on_export_result(None)  # No file selected. No need to show a message for this.
-            return
-
-        try:
-            with open(file_name, 'w') as f:
-                f.write(Utils.dump(options, sort_keys=False))
-                f.close()
-                self.on_export_result("File saved successfully.")
-        except Exception:
-            self.on_export_result("Could not save file.")
-            raise
-
-    def export_options(self, button: Widget) -> None:
-        if 0 < len(self.name_input.text) < 17 and self.current_game:
-            import threading
-            options = {
-                "name": self.name_input.text,
-                "description": f"YAML generated by Archipelago {Utils.__version__}.",
-                "game": self.current_game,
-                self.current_game: {k: check_random(v) for k, v in self.options.items()}
-            }
-            threading.Thread(target=self.export_options_background, args=(options,), daemon=True).start()
-            self.container.disabled = True
-        elif not self.name_input.text:
-            self.show_result_snack("Name must not be empty.")
-        elif not self.current_game:
-            self.show_result_snack("You must select a game to play.")
-        else:
-            self.show_result_snack("Name cannot be longer than 16 characters.")
-
-    def create_range(self, option: typing.Type[Range], name: str, bind=True):
-        def update_text(range_box: VisualRange):
-            self.options[name] = int(range_box.slider.value)
-            range_box.tag.text = str(int(range_box.slider.value))
-            return
-
-        box = VisualRange(option=option, name=name)
-        if bind:
-            box.slider.bind(value=lambda _, _1: update_text(box))
-        self.options[name] = option.default
-        return box
-
-    def create_named_range(self, option: typing.Type[NamedRange], name: str):
-        def set_to_custom(range_box: VisualNamedRange):
-            range_box.range.tag.text = str(int(range_box.range.slider.value))
-            if range_box.range.slider.value in option.special_range_names.values():
-                value = next(key for key, val in option.special_range_names.items()
-                             if val == range_box.range.slider.value)
-                self.options[name] = value
-                set_button_text(box.choice, value.title())
-            else:
-                self.options[name] = int(range_box.range.slider.value)
-                set_button_text(range_box.choice, "Custom")
-
-        def set_button_text(button: MDButton, text: str):
-            button.text.text = text
-
-        def set_value(text: str, range_box: VisualNamedRange):
-            range_box.range.slider.value = min(max(option.special_range_names[text.lower()], option.range_start),
-                                               option.range_end)
-            range_box.range.tag.text = str(option.special_range_names[text.lower()])
-            set_button_text(range_box.choice, text)
-            self.options[name] = text.lower()
-            range_box.range.slider.dropdown.dismiss()
-
-        def open_dropdown(button):
-            # for some reason this fixes an issue causing some to not open
-            box.range.slider.dropdown.open()
-
-        box = VisualNamedRange(option=option, name=name, range_widget=self.create_range(option, name, bind=False))
-        default: int | str = option.default
-        if default in option.special_range_names:
-            # value can get mismatched in this case
-            box.range.slider.value = min(max(option.special_range_names[default], option.range_start),
-                                               option.range_end)
-            box.range.tag.text = str(int(box.range.slider.value))
-        elif default in option.special_range_names.values():
-            # better visual
-            default = next(key for key, val in option.special_range_names.items() if val == option.default)
-            set_button_text(box.choice, default.title())
-        box.range.slider.bind(value=lambda _, _2: set_to_custom(box))
-        items = [
-            {
-                "text": choice.title(),
-                "on_release": lambda text=choice.title(): set_value(text, box)
-            }
-            for choice in option.special_range_names
-        ]
-        box.range.slider.dropdown = MDDropdownMenu(caller=box.choice, items=items)
-        box.choice.bind(on_release=open_dropdown)
-        self.options[name] = default
-        return box
-
-    def create_free_text(self, option: typing.Type[FreeText] | typing.Type[TextChoice], name: str):
-        text = VisualFreeText(option=option, name=name)
-
-        def set_value(instance, value):
-            self.options[name] = value
-
-        text.bind(text=set_value)
-        self.options[name] = option.default
-        return text
-
-    def create_choice(self, option: typing.Type[Choice], name: str):
-        def set_button_text(button: VisualChoice, text: str):
-            button.text.text = text
-
-        def set_value(text, value):
-            set_button_text(main_button, text)
-            self.options[name] = value
-            dropdown.dismiss()
-
-        def open_dropdown(button):
-            # for some reason this fixes an issue causing some to not open
-            dropdown.open()
-
-        default_string = isinstance(option.default, str)
-        main_button = VisualChoice(option=option, name=name)
-        main_button.bind(on_release=open_dropdown)
-
-        items = [
-            {
-                "text": option.get_option_name(choice),
-                "on_release": lambda val=choice: set_value(option.get_option_name(val), option.name_lookup[val])
-            }
-            for choice in option.name_lookup
-        ]
-        dropdown = MDDropdownMenu(caller=main_button, items=items)
-        self.options[name] = option.name_lookup[option.default] if not default_string else option.default
-        return main_button
-
-    def create_text_choice(self, option: typing.Type[TextChoice], name: str):
-        def set_button_text(button: MDButton, text: str):
-            for child in button.children:
-                if isinstance(child, MDButtonText):
-                    child.text = text
-
-        box = VisualTextChoice(option=option, name=name, choice=self.create_choice(option, name),
-                               text=self.create_free_text(option, name))
-
-        def set_value(instance):
-            set_button_text(box.choice, "Custom")
-            self.options[name] = instance.text
-
-        box.text.bind(on_text_validate=set_value)
-        return box
-
-    def create_toggle(self, option: typing.Type[Toggle], name: str) -> Widget:
-        def set_value(instance: MDIconButton):
-            if instance.icon == "checkbox-outline":
-                instance.icon = "checkbox-blank-outline"
-            else:
-                instance.icon = "checkbox-outline"
-            self.options[name] = bool(not self.options[name])
-
-        self.options[name] = bool(option.default)
-        checkbox = VisualToggle(option=option, name=name)
-        checkbox.button.bind(on_release=set_value)
-
-        return checkbox
-
-    def create_popup(self, option: typing.Type[OptionList] | typing.Type[OptionSet] | typing.Type[OptionCounter],
-                     name: str, world: typing.Type[World]):
-
-        valid_keys = sorted(option.valid_keys)
-        if option.verify_item_name:
-            valid_keys += list(world.item_name_to_id.keys())
-            if option.convert_name_groups:
-                valid_keys += list(world.item_name_groups.keys())
-        if option.verify_location_name:
-            valid_keys += list(world.location_name_to_id.keys())
-            if option.convert_name_groups:
-                valid_keys += list(world.location_name_groups.keys())
-
-        if not issubclass(option, OptionCounter):
-            def apply_changes(button):
-                self.options[name].clear()
-                for list_item in dialog.scrollbox.layout.children:
-                    self.options[name].append(getattr(list_item.text, "text"))
-                dialog.dismiss()
-        else:
-            def apply_changes(button):
-                self.options[name].clear()
-                for list_item in dialog.scrollbox.layout.children:
-                    self.options[name][getattr(list_item.text, "text")] = int(getattr(list_item.value, "text"))
-                dialog.dismiss()
-
-        dialog = VisualListSetCounter(option=option, name=name, valid_keys=valid_keys)
-        dialog.ids.container.spacing = dp(30)
-        dialog.scrollbox.layout.theme_bg_color = "Custom"
-        dialog.scrollbox.layout.md_bg_color = self.theme_cls.surfaceContainerLowColor
-        dialog.scrollbox.layout.spacing = dp(5)
-        dialog.scrollbox.layout.padding = [0, dp(5), 0, 0]
-
-        if issubclass(option, OptionCounter):
-            for value in sorted(self.options[name]):
-                dialog.add_set_item(value, self.options[name].get(value, None))
-        else:
-            for value in sorted(self.options[name]):
-                dialog.add_set_item(value)
-
-        dialog.save.bind(on_release=apply_changes)
-        dialog.open()
-
-    def create_option_set_list_counter(self, option: typing.Type[OptionList] | typing.Type[OptionSet] |
-                                       typing.Type[OptionCounter], name: str, world: typing.Type[World]):
-        main_button = MDButton(MDButtonText(text="Edit"), on_release=lambda x: self.create_popup(option, name, world))
-
-        if name not in self.options:
-            # convert from non-mutable to mutable
-            # We use list syntax even for sets, set behavior is enforced through GUI
-            if issubclass(option, OptionCounter):
-                self.options[name] = deepcopy(option.default)
-            else:
-                self.options[name] = sorted(option.default)
-
-        return main_button
-
-    def create_option(self, option: typing.Type[Option], name: str, world: typing.Type[World]) -> Widget:
-        option_base = MDBoxLayout(orientation="vertical", size_hint_y=None, padding=[0, 0, dp(5), dp(5)])
-
-        tooltip = filter_tooltip(option.__doc__)
-        option_label = TooltipLabel(text=f"[ref=0|{tooltip}]{getattr(option, 'display_name', name)}")
-        label_box = MDBoxLayout(orientation="horizontal")
-        label_anchor = MDAnchorLayout(anchor_x="right", anchor_y="center")
-        label_anchor.add_widget(option_label)
-        label_box.add_widget(label_anchor)
-
-        option_base.add_widget(label_box)
-        if issubclass(option, NamedRange):
-            option_base.add_widget(self.create_named_range(option, name))
-        elif issubclass(option, Range):
-            option_base.add_widget(self.create_range(option, name))
-        elif issubclass(option, Toggle):
-            option_base.add_widget(self.create_toggle(option, name))
-        elif issubclass(option, TextChoice):
-            option_base.add_widget(self.create_text_choice(option, name))
-        elif issubclass(option, Choice):
-            option_base.add_widget(self.create_choice(option, name))
-        elif issubclass(option, FreeText):
-            option_base.add_widget(self.create_free_text(option, name))
-        elif any(issubclass(option, cls) for cls in (OptionSet, OptionList, OptionCounter)):
-            option_base.add_widget(self.create_option_set_list_counter(option, name, world))
-        else:
-            option_base.add_widget(MDLabel(text="This option isn't supported by the option creator.\n"
-                                                "Please edit your yaml manually to set this option."))
-
-        if option_can_be_randomized(option):
-            def randomize_option(instance: Widget, value: str):
-                value = value == "down"
-                if value:
-                    self.options[name] = "random-" + str(self.options[name])
-                else:
-                    self.options[name] = self.options[name].replace("random-", "")
-                    if self.options[name].isnumeric():
-                        self.options[name] = int(self.options[name])
-                    elif self.options[name] in ("True", "False"):
-                        self.options[name] = self.options[name] == "True"
-
-                base_object = instance.parent.parent
-                label_object = instance.parent
-                for child in base_object.children:
-                    if child is not label_object:
-                        child.disabled = value
-
-            default_random = option.default == "random"
-            random_toggle = ToggleButton(MDButtonText(text="Random?"), size_hint_x=None, width=dp(100),
-                                         state="down" if default_random else "normal")
-            random_toggle.bind(state=randomize_option)
-            label_box.add_widget(random_toggle)
-            if default_random:
-                randomize_option(random_toggle, "down")
-
-        return option_base
-
-    def create_options_panel(self, world_button: WorldButton):
-        self.option_layout.clear_widgets()
-        self.options.clear()
-        cls: typing.Type[World] = world_button.world_cls
-
-        self.current_game = cls.game
-        if not cls.web.options_page:
-            self.current_game = "None"
-            return
-        elif isinstance(cls.web.options_page, str):
-            self.current_game = "None"
-            if validate_url(cls.web.options_page):
-                webbrowser.open(cls.web.options_page)
-                MDSnackbar(MDSnackbarText(text="Launching in default browser..."), y=dp(24), pos_hint={"center_x": 0.5},
-                           size_hint_x=0.5).open()
-                world_button.state = "normal"
-            else:
-                # attach onto archipelago.gg and see if we pass
-                new_url = "https://archipelago.gg/" + cls.web.options_page
-                if validate_url(new_url):
-                    webbrowser.open(new_url)
-                    MDSnackbar(MDSnackbarText(text="Launching in default browser..."), y=dp(24),
-                               pos_hint={"center_x": 0.5},
-                               size_hint_x=0.5).open()
-                else:
-                    MDSnackbar(MDSnackbarText(text="Invalid options page, please report to world developer."), y=dp(24),
-                               pos_hint={"center_x": 0.5},
-                               size_hint_x=0.5).open()
-                world_button.state = "normal"
-                # else just fall through
-        else:
-            expansion_box = ScrollBox()
-            expansion_box.layout.orientation = "vertical"
-            expansion_box.layout.spacing = dp(3)
-            expansion_box.scroll_type = ["bars"]
-            expansion_box.do_scroll_x = False
-            group_names = ["Game Options", *(group.name for group in cls.web.option_groups)]
-            groups = {name: [] for name in group_names}
-            for name, option in cls.options_dataclass.type_hints.items():
-                group = next((group.name for group in cls.web.option_groups if option in group.options), "Game Options")
-                groups[group].append((name, option))
-
-            for group, options in groups.items():
-                options = [(name, option) for name, option in options
-                           if name and option.visibility & Visibility.simple_ui]
-                if not options:
-                    continue  # Game Options can be empty if every other option is in another group
-                    # Can also have an option group of options that should not render on simple ui
-                group_item = MDExpansionPanel(size_hint_y=None)
-                group_header = MDExpansionPanelHeader(MDListItem(MDListItemSupportingText(text=group),
-                                                                 TrailingPressedIconButton(icon="chevron-right",
-                                                                                           on_release=lambda x,
-                                                                                           item=group_item:
-                                                                                           self.tap_expansion_chevron(
-                                                                                               item, x)),
-                                                                 md_bg_color=self.theme_cls.surfaceContainerLowestColor,
-                                                                 theme_bg_color="Custom",
-                                                                 on_release=lambda x, item=group_item:
-                                                                 self.tap_expansion_chevron(item, x)))
-                group_content = MDExpansionPanelContent(orientation="vertical", theme_bg_color="Custom",
-                                                        md_bg_color=self.theme_cls.surfaceContainerLowestColor,
-                                                        padding=[dp(12), dp(100), dp(12), 0],
-                                                        spacing=dp(3))
-                group_item.add_widget(group_header)
-                group_item.add_widget(group_content)
-                group_box = ScrollBox()
-                group_box.layout.orientation = "vertical"
-                group_box.layout.spacing = dp(3)
-                for name, option in options:
-                    group_content.add_widget(self.create_option(option, name, cls))
-                expansion_box.layout.add_widget(group_item)
-            self.option_layout.add_widget(expansion_box)
-        self.game_label.text = f"Game: {self.current_game}"
-
-    @staticmethod
-    def tap_expansion_chevron(panel: MDExpansionPanel, chevron: TrailingPressedIconButton | MDListItem):
-        if isinstance(chevron, MDListItem):
-            chevron = next((child for child in chevron.ids.trailing_container.children
-                            if isinstance(child, TrailingPressedIconButton)), None)
-        panel.open() if not panel.is_open else panel.close()
-        if chevron:
-            panel.set_chevron_down(
-                chevron
-            ) if not panel.is_open else panel.set_chevron_up(chevron)
-
-    def build(self):
-        self.set_colors()
-        self.options = {}
-        self.container = Builder.load_file(Utils.local_path("data/optionscreator.kv"))
-        self.root = self.container
-        self.main_layout = self.container.ids.main
-        self.scrollbox = self.container.ids.scrollbox
-
-        def world_button_action(world_btn: WorldButton):
-            if self.current_game != world_btn.world_cls.game:
-                old_button = next((button for button in self.scrollbox.layout.children
-                                   if button.world_cls.game == self.current_game), None)
-                if old_button:
-                    old_button.state = "normal"
-            else:
-                world_btn.state = "down"
-            self.create_options_panel(world_btn)
-
-        for world, cls in sorted(AutoWorldRegister.world_types.items(), key=lambda x: x[0]):
-            if cls.hidden:
-                continue
-            world_text = MDButtonText(text=world, size_hint_y=None, width=dp(150),
-                                      pos_hint={"x": 0.03, "center_y": 0.5})
-            world_text.text_size = (world_text.width, None)
-            world_text.bind(width=lambda *x, text=world_text: text.setter('text_size')(text, (text.width, None)),
-                            texture_size=lambda *x, text=world_text: text.setter("height")(text,
-                                                                                           world_text.texture_size[1]))
-            world_button = WorldButton(world_text, size_hint_x=None, width=dp(150), theme_width="Custom",
-                                       radius=(dp(5), dp(5), dp(5), dp(5)))
-            world_button.bind(on_release=world_button_action)
-            world_button.world_cls = cls
-            self.scrollbox.layout.add_widget(world_button)
-        self.main_panel = self.container.ids.player_layout
-        self.player_options = self.container.ids.player_options
-        self.game_label = self.container.ids.game
-        self.name_input = self.container.ids.player_name
-        self.option_layout = self.container.ids.options
-
-        def set_height(instance, value):
-            instance.height = value[1]
-
-        self.game_label.bind(texture_size=set_height)
-
-        # Uncomment to re-enable the Kivy console/live editor
-        # Ctrl-E to enable it, make sure numlock/capslock is disabled
-        # from kivy.modules.console import create_console
-        # from kivy.core.window import Window
-        # create_console(Window, self.container)
-
-        return self.container
-
-
-def launch():
-    OptionsCreator().run()
-
-
-if __name__ == "__main__":
-    Utils.init_logging("OptionsCreator")
-    launch()
@@ -20,10 +20,12 @@ Currently, the following games are supported:
 * Meritous
 * Super Metroid/Link to the Past combo randomizer (SMZ3)
 * ChecksFinder
+* ArchipIDLE
 * Hollow Knight
 * The Witness
 * Sonic Adventure 2: Battle
 * Starcraft 2
+* Donkey Kong Country 3
 * Dark Souls 3
 * Super Mario World
 * Pokémon Red and Blue
@@ -79,12 +81,6 @@ Currently, the following games are supported:
 * Super Mario Land 2: 6 Golden Coins
 * shapez
 * Paint
-* Celeste (Open World)
-* Choo-Choo Charles
-* APQuest
-* Satisfactory
-* EarthBound
-* Mega Man 3

 For setup and instructions check out our [tutorials page](https://archipelago.gg/tutorial/).
 Downloads can be found at [Releases](https://github.com/ArchipelagoMW/Archipelago/releases), including compiled
@@ -18,7 +18,7 @@ from json import loads, dumps
 from CommonClient import CommonContext, server_loop, ClientCommandProcessor, gui_enabled, get_base_parser

 import Utils
-import settings
+from settings import Settings
 from Utils import async_start
 from MultiServer import mark_raw
 if typing.TYPE_CHECKING:
@@ -286,7 +286,7 @@ class SNESState(enum.IntEnum):


 def launch_sni() -> None:
-    sni_path = settings.get_settings().sni_options.sni_path
+    sni_path = Settings.sni_options.sni_path

    if not os.path.isdir(sni_path):
        sni_path = Utils.local_path(sni_path)
@@ -669,7 +669,7 @@ async def game_watcher(ctx: SNIContext) -> None:


 async def run_game(romfile: str) -> None:
-    auto_start = settings.get_settings().sni_options.snes_rom_start
+    auto_start = Settings.sni_options.snes_rom_start
    if auto_start is True:
        import webbrowser
        webbrowser.open(romfile)
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import ModuleUpdate
+ModuleUpdate.update()
+
+from worlds.sc2.Client import launch
+import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("Starcraft2Client", exception_logger="Client")
+    launch()
@@ -1,7 +1,6 @@
 from __future__ import annotations
 import os
 import sys
-import time
 import asyncio
 import typing
 import bsdiff4
@@ -16,9 +15,6 @@ from CommonClient import CommonContext, server_loop, \
    gui_enabled, ClientCommandProcessor, logger, get_base_parser
 from Utils import async_start

-# Heartbeat for position sharing via bounces, in seconds
-UNDERTALE_STATUS_INTERVAL = 30.0
-UNDERTALE_ONLINE_TIMEOUT  = 60.0

 class UndertaleCommandProcessor(ClientCommandProcessor):
    def __init__(self, ctx):
@@ -49,7 +45,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
        if isinstance(self.ctx, UndertaleContext):
            os.makedirs(name=Utils.user_path("Undertale"), exist_ok=True)
            tempInstall = steaminstall
-            if tempInstall and not os.path.isfile(os.path.join(tempInstall, "data.win")):
+            if not os.path.isfile(os.path.join(tempInstall, "data.win")):
                tempInstall = None
            if tempInstall is None:
                tempInstall = "C:\\Program Files (x86)\\Steam\\steamapps\\common\\Undertale"
@@ -113,11 +109,6 @@ class UndertaleContext(CommonContext):
        self.completed_routes = {"pacifist": 0, "genocide": 0, "neutral": 0}
        # self.save_game_folder: files go in this path to pass data between us and the actual game
        self.save_game_folder = os.path.expandvars(r"%localappdata%/UNDERTALE")
-        self.last_sent_position: typing.Optional[tuple] = None
-        self.last_room: typing.Optional[str] = None
-        self.last_status_write: float = 0.0
-        self.other_undertale_status: dict[int, dict] = {}
-

    def patch_game(self):
        with open(Utils.user_path("Undertale", "data.win"), "rb") as f:
@@ -228,9 +219,6 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
        await ctx.send_msgs([{"cmd": "SetNotify", "keys": [str(ctx.slot)+" RoutesDone neutral",
                                                           str(ctx.slot)+" RoutesDone pacifist",
                                                           str(ctx.slot)+" RoutesDone genocide"]}])
-        if any(info.game == "Undertale" and slot != ctx.slot 
-               for slot, info in ctx.slot_info.items()):
-            ctx.set_notify("undertale_room_status")
        if args["slot_data"]["only_flakes"]:
            with open(os.path.join(ctx.save_game_folder, "GenoNoChest.flag"), "w") as f:
                f.close()
@@ -275,12 +263,6 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
        if str(ctx.slot)+" RoutesDone pacifist" in args["keys"]:
            if args["keys"][str(ctx.slot) + " RoutesDone pacifist"] is not None:
                ctx.completed_routes["pacifist"] = args["keys"][str(ctx.slot)+" RoutesDone pacifist"]
-        if "undertale_room_status" in args["keys"] and args["keys"]["undertale_room_status"]:
-            status = args["keys"]["undertale_room_status"]
-            ctx.other_undertale_status = {
-                int(key): val for key, val in status.items()
-                if int(key) != ctx.slot
-            }
    elif cmd == "SetReply":
        if args["value"] is not None:
            if str(ctx.slot)+" RoutesDone pacifist" == args["key"]:
@@ -289,19 +271,17 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
                ctx.completed_routes["genocide"] = args["value"]
            elif str(ctx.slot)+" RoutesDone neutral" == args["key"]:
                ctx.completed_routes["neutral"] = args["value"]
-        if args.get("key") == "undertale_room_status" and args.get("value"):
-            ctx.other_undertale_status = {
-                int(key): val for key, val in args["value"].items()
-                if int(key) != ctx.slot
-            }
    elif cmd == "ReceivedItems":
        start_index = args["index"]

        if start_index == 0:
            ctx.items_received = []
        elif start_index != len(ctx.items_received):
-            await ctx.check_locations(ctx.locations_checked)
-            await ctx.send_msgs([{"cmd": "Sync"}])
+            sync_msg = [{"cmd": "Sync"}]
+            if ctx.locations_checked:
+                sync_msg.append({"cmd": "LocationChecks",
+                                 "locations": list(ctx.locations_checked)})
+            await ctx.send_msgs(sync_msg)
        if start_index == len(ctx.items_received):
            counter = -1
            placedWeapon = 0
@@ -388,8 +368,9 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
                f.close()

    elif cmd == "Bounced":
-        data = args.get("data", {})
-        if "x" in data and "room" in data:
+        tags = args.get("tags", [])
+        if "Online" in tags:
+            data = args.get("data", {})
            if data["player"] != ctx.slot and data["player"] is not None:
                filename = f"FRISK" + str(data["player"]) + ".playerspot"
                with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
@@ -400,63 +381,21 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):

 async def multi_watcher(ctx: UndertaleContext):
    while not ctx.exit_event.is_set():
-        if "Online" in ctx.tags and any(
-                info.game == "Undertale" and slot != ctx.slot
-                for slot, info in ctx.slot_info.items()):
-            now = time.time()
-            path = ctx.save_game_folder
-            for root, dirs, files in os.walk(path):
-                for file in files:
-                    if "spots.mine" in file:
-                        with open(os.path.join(root, file), "r") as mine:
-                            this_x = mine.readline()
-                            this_y = mine.readline()
-                            this_room = mine.readline()
-                            this_sprite = mine.readline()
-                            this_frame = mine.readline()
-
-                        if this_room != ctx.last_room or \
-                                now - ctx.last_status_write >= UNDERTALE_STATUS_INTERVAL:
-                            ctx.last_room = this_room
-                            ctx.last_status_write = now
-                            await ctx.send_msgs([{
-                                "cmd": "Set",
-                                "key": "undertale_room_status",
-                                "default": {},
-                                "want_reply": False,
-                                "operations": [{"operation": "update",
-                                                "value": {str(ctx.slot): {"room": this_room,
-                                                                           "time": now}}}]
-                            }])
-
-                        # If player was visible but timed out (heartbeat) or left the room, remove them.
-                        for slot, entry in ctx.other_undertale_status.items():
-                            if entry.get("room") != this_room or \
-                                    now - entry.get("time", now) > UNDERTALE_ONLINE_TIMEOUT:
-                                playerspot = os.path.join(ctx.save_game_folder,
-                                                          f"FRISK{slot}.playerspot")
-                                if os.path.exists(playerspot):
-                                    os.remove(playerspot)
-
-                        current_position = (this_x, this_y, this_room, this_sprite, this_frame)
-                        if current_position == ctx.last_sent_position:
-                            continue
-
-                        # Empty status dict = no data yet → send to bootstrap.
-                        online_in_room = any(
-                            entry.get("room") == this_room and
-                            now - entry.get("time", now) <= UNDERTALE_ONLINE_TIMEOUT
-                            for entry in ctx.other_undertale_status.values()
-                        )
-                        if ctx.other_undertale_status and not online_in_room:
-                            continue
-
-                        message = [{"cmd": "Bounce", "games": ["Undertale"],
-                                    "data": {"player": ctx.slot, "x": this_x, "y": this_y,
-                                             "room": this_room, "spr": this_sprite,
-                                             "frm": this_frame}}]
-                        await ctx.send_msgs(message)
-                        ctx.last_sent_position = current_position
+        path = ctx.save_game_folder
+        for root, dirs, files in os.walk(path):
+            for file in files:
+                if "spots.mine" in file and "Online" in ctx.tags:
+                    with open(os.path.join(root, file), "r") as mine:
+                        this_x = mine.readline()
+                        this_y = mine.readline()
+                        this_room = mine.readline()
+                        this_sprite = mine.readline()
+                        this_frame = mine.readline()
+                        mine.close()
+                    message = [{"cmd": "Bounce", "tags": ["Online"],
+                                "data": {"player": ctx.slot, "x": this_x, "y": this_y, "room": this_room,
+                                         "spr": this_sprite, "frm": this_frame}}]
+                    await ctx.send_msgs(message)

        await asyncio.sleep(0.1)

@@ -470,9 +409,10 @@ async def game_watcher(ctx: UndertaleContext):
                for file in files:
                    if ".item" in file:
                        os.remove(os.path.join(root, file))
-            await ctx.check_locations(ctx.locations_checked)
-            await ctx.send_msgs([{"cmd": "Sync"}])
-
+            sync_msg = [{"cmd": "Sync"}]
+            if ctx.locations_checked:
+                sync_msg.append({"cmd": "LocationChecks", "locations": list(ctx.locations_checked)})
+            await ctx.send_msgs(sync_msg)
            ctx.syncing = False
        if ctx.got_deathlink:
            ctx.got_deathlink = False
@@ -507,7 +447,7 @@ async def game_watcher(ctx: UndertaleContext):
                        for l in lines:
                            sending = sending+[(int(l.rstrip('\n')))+12000]
                    finally:
-                        await ctx.check_locations(sending)
+                        await ctx.send_msgs([{"cmd": "LocationChecks", "locations": sending}])
                if "victory" in file and str(ctx.route) in file:
                    victory = True
                if ".playerspot" in file and "Online" not in ctx.tags:
@@ -1,7 +1,6 @@
 from __future__ import annotations

 import asyncio
-import concurrent.futures
 import json
 import typing
 import builtins
@@ -18,14 +17,10 @@ import logging
 import warnings

 from argparse import Namespace
-from datetime import datetime, timezone
-
 from settings import Settings, get_settings
 from time import sleep
-from typing import BinaryIO, Coroutine, Mapping, Optional, Set, Dict, Any, Union, TypeGuard
+from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union, TypeGuard
 from yaml import load, load_all, dump
-from pathspec import PathSpec, GitIgnoreSpec
-from typing_extensions import deprecated

 try:
    from yaml import CLoader as UnsafeLoader, CSafeLoader as SafeLoader, CDumper as Dumper
@@ -40,7 +35,7 @@ if typing.TYPE_CHECKING:


 def tuplize_version(version: str) -> Version:
-    return Version(*(int(piece) for piece in version.split(".")))
+    return Version(*(int(piece, 10) for piece in version.split(".")))


 class Version(typing.NamedTuple):
@@ -51,8 +46,13 @@ class Version(typing.NamedTuple):
    def as_simple_string(self) -> str:
        return ".".join(str(item) for item in self)

+    @classmethod
+    def from_network_dict(cls, source: dict):
+        source.pop("class", None)
+        return cls(**source)

-__version__ = "0.6.8"
+
+__version__ = "0.6.3"
 version_tuple = tuplize_version(__version__)

 is_linux = sys.platform.startswith("linux")
@@ -236,7 +236,10 @@ def open_file(filename: typing.Union[str, "pathlib.Path"]) -> None:
        open_command = which("open") if is_macos else (which("xdg-open") or which("gnome-open") or which("kde-open"))
        assert open_command, "Didn't find program for open_file! Please report this together with system details."

-        env = env_cleared_lib_path()
+        env = os.environ
+        if "LD_LIBRARY_PATH" in env:
+            env = env.copy()
+            del env["LD_LIBRARY_PATH"]  # exe is a system binary, so reset LD_LIBRARY_PATH
        subprocess.call([open_command, filename], env=env)


@@ -315,19 +318,20 @@ def get_public_ipv6() -> str:
    return ip


-@deprecated("Utils.get_options() is deprecated. Use the settings API instead.")
+OptionsType = Settings  # TODO: remove when removing get_options
+
+
 def get_options() -> Settings:
-    deprecate("Utils.get_options() is deprecated. Use the settings API instead.")
+    # TODO: switch to Utils.deprecate after 0.4.4
+    warnings.warn("Utils.get_options() is deprecated. Use the settings API instead.", DeprecationWarning)
    return get_settings()


-def persistent_store(category: str, key: str, value: typing.Any, force_store: bool = False):
+def persistent_store(category: str, key: str, value: typing.Any):
+    path = user_path("_persistent_storage.yaml")
    storage = persistent_load()
-    if not force_store and category in storage and key in storage[category] and storage[category][key] == value:
-        return  # no changes necessary
    category_dict = storage.setdefault(category, {})
    category_dict[key] = value
-    path = user_path("_persistent_storage.yaml")
    with open(path, "wt") as f:
        f.write(dump(storage, Dumper=Dumper))

@@ -342,9 +346,6 @@ def persistent_load() -> Dict[str, Dict[str, Any]]:
        try:
            with open(path, "r") as f:
                storage = unsafe_parse_yaml(f.read())
-            if "datapackage" in storage:
-                del storage["datapackage"]
-                logging.debug("Removed old datapackage from persistent storage")
        except Exception as e:
            logging.debug(f"Could not read store: {e}")
    if storage is None:
@@ -369,6 +370,11 @@ def load_data_package_for_checksum(game: str, checksum: typing.Optional[str]) ->
            except Exception as e:
                logging.debug(f"Could not load data package: {e}")

+    # fall back to old cache
+    cache = persistent_load().get("datapackage", {}).get("games", {}).get(game, {})
+    if cache.get("checksum") == checksum:
+        return cache
+
    # cache does not match
    return {}

@@ -387,14 +393,6 @@ def store_data_package_for_checksum(game: str, data: typing.Dict[str, Any]) -> N
            logging.debug(f"Could not store data package: {e}")


-def read_apignore(filename: str | pathlib.Path) -> PathSpec | None:
-    try:
-        with open(filename) as ignore_file:
-            return GitIgnoreSpec.from_lines(ignore_file)
-    except FileNotFoundError:
-        return None
-
-
 def get_default_adjuster_settings(game_name: str) -> Namespace:
    import LttPAdjuster
    adjuster_settings = Namespace()
@@ -421,11 +419,11 @@ def get_adjuster_settings(game_name: str) -> Namespace:
@cache_argsless
 def get_unique_identifier():
    common_path = cache_path("common.json")
-    try:
+    if os.path.exists(common_path):
        with open(common_path) as f:
            common_file = json.load(f)
            uuid = common_file.get("uuid", None)
-    except FileNotFoundError:
+    else:
        common_file = {}
        uuid = None

@@ -435,9 +433,6 @@ def get_unique_identifier():
    from uuid import uuid4
    uuid = str(uuid4())
    common_file["uuid"] = uuid
-
-    cache_folder = os.path.dirname(common_path)
-    os.makedirs(cache_folder, exist_ok=True)
    with open(common_path, "w") as f:
        json.dump(common_file, f, separators=(",", ":"))
    return uuid
@@ -450,10 +445,13 @@ safe_builtins = frozenset((


 class RestrictedUnpickler(pickle.Unpickler):
+    generic_properties_module: Optional[object]
+
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super(RestrictedUnpickler, self).__init__(*args, **kwargs)
        self.options_module = importlib.import_module("Options")
        self.net_utils_module = importlib.import_module("NetUtils")
+        self.generic_properties_module = None

    def find_class(self, module: str, name: str) -> type:
        if module == "builtins" and name in safe_builtins:
@@ -467,6 +465,10 @@ class RestrictedUnpickler(pickle.Unpickler):
                                             "SlotType", "NetworkSlot", "HintStatus"}:
            return getattr(self.net_utils_module, name)
        # Options and Plando are unpickled by WebHost -> Generate
+        if module == "worlds.generic" and name == "PlandoItem":
+            if not self.generic_properties_module:
+                self.generic_properties_module = importlib.import_module("worlds.generic")
+            return getattr(self.generic_properties_module, name)
        # pep 8 specifies that modules should have "all-lowercase names" (options, not Options)
        if module.lower().endswith("options"):
            if module == "Options":
@@ -475,7 +477,7 @@ class RestrictedUnpickler(pickle.Unpickler):
                mod = importlib.import_module(module)
            obj = getattr(mod, name)
            if issubclass(obj, (self.options_module.Option, self.options_module.PlandoConnection,
-                                self.options_module.PlandoItem, self.options_module.PlandoText)):
+                                self.options_module.PlandoText)):
                return obj
        # Forbid everything else.
        raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
@@ -718,22 +720,13 @@ def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bo


 def get_input_text_from_response(text: str, command: str) -> typing.Optional[str]:
-    """
-    Parses the response text from `get_intended_text` to find the suggested input and autocomplete the command in
-    arguments with it.
-
-    :param text: The response text from `get_intended_text`.
-    :param command: The command to which the input text should be added. Must contain the prefix used by the command
-                    (`!` or `/`).
-    :return: The command with the suggested input text appended, or None if no suggestion was found.
-    """
    if "did you mean " in text:
        for question in ("Didn't find something that closely matches",
                         "Too many close matches"):
            if text.startswith(question):
                name = get_text_between(text, "did you mean '",
                                        "'? (")
-                return f"{command} {name}"
+                return f"!{command} {name}"
    elif text.startswith("Missing: "):
        return text.replace("Missing: ", "!hint_location ")
    return None
@@ -746,32 +739,17 @@ def is_kivy_running() -> bool:
    return False


-def env_cleared_lib_path() -> Mapping[str, str]:
-    """
-    Creates a copy of the current environment vars with the LD_LIBRARY_PATH removed if set, as this can interfere when
-    launching something in a subprocess.
-    """
-    env = os.environ
-    if "LD_LIBRARY_PATH" in env:
-        env = env.copy()
-        del env["LD_LIBRARY_PATH"]
-
-    return env
-
-
 def _mp_open_filename(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
    if is_kivy_running():
        raise RuntimeError("kivy should not be running in multiprocess")
    res.put(open_filename(*args))


-def _mp_save_filename(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
-    if is_kivy_running():
-        raise RuntimeError("kivy should not be running in multiprocess")
-    res.put(save_filename(*args))
-    
 def _run_for_stdout(*args: str):
-    env = env_cleared_lib_path()
+    env = os.environ
+    if "LD_LIBRARY_PATH" in env:
+        env = env.copy()
+        del env["LD_LIBRARY_PATH"]  # exe is a system binary, so reset LD_LIBRARY_PATH
    return subprocess.run(args, capture_output=True, text=True, env=env).stdout.split("\n", 1)[0] or None


@@ -813,62 +791,8 @@ def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typin
        except tkinter.TclError:
            return None  # GUI not available. None is the same as a user clicking "cancel"
        root.withdraw()
-        try:
-            return tkinter.filedialog.askopenfilename(
-                title=title,
-                filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
-                initialfile=suggest or None,
-            )
-        finally:
-            root.destroy()
-
-
-def save_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typing.Iterable[str]]], suggest: str = "") \
-        -> typing.Optional[str]:
-    logging.info(f"Opening file save dialog for {title}.")
-
-    if is_linux:
-        # prefer native dialog
-        from shutil import which
-        kdialog = which("kdialog")
-        if kdialog:
-            k_filters = '|'.join((f'{text} (*{" *".join(ext)})' for (text, ext) in filetypes))
-            return _run_for_stdout(kdialog, f"--title={title}", "--getsavefilename", suggest or ".", k_filters)
-        zenity = which("zenity")
-        if zenity:
-            z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
-            selection = (f"--filename={suggest}",) if suggest else ()
-            return _run_for_stdout(zenity, f"--title={title}", "--file-selection", "--save", *z_filters, *selection)
-
-    # fall back to tk
-    try:
-        import tkinter
-        import tkinter.filedialog
-    except Exception as e:
-        logging.error('Could not load tkinter, which is likely not installed. '
-                      f'This attempt was made because save_filename was used for "{title}".')
-        raise e
-    else:
-        if is_macos and is_kivy_running():
-            # on macOS, mixing kivy and tk does not work, so spawn a new process
-            # FIXME: performance of this is pretty bad, and we should (also) look into alternatives
-            from multiprocessing import Process, Queue
-            res: "Queue[typing.Optional[str]]" = Queue()
-            Process(target=_mp_save_filename, args=(res, title, filetypes, suggest)).start()
-            return res.get()
-        try:
-            root = tkinter.Tk()
-        except tkinter.TclError:
-            return None  # GUI not available. None is the same as a user clicking "cancel"
-        root.withdraw()
-        try:
-            return tkinter.filedialog.asksaveasfilename(
-                title=title,
-                filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
-                initialfile=suggest or None,
-            )
-        finally:
-            root.destroy()
+        return tkinter.filedialog.askopenfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
+                                                  initialfile=suggest or None)


 def _mp_open_directory(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
@@ -916,13 +840,6 @@ def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:


 def messagebox(title: str, text: str, error: bool = False) -> None:
-    if not gui_enabled:
-        if error:
-            logging.error(f"{title}: {text}")
-        else:
-            logging.info(f"{title}: {text}")
-        return
-
    if is_kivy_running():
        from kvui import MessageBox
        MessageBox(title, text, error).open()
@@ -958,9 +875,6 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
        root.update()


-gui_enabled = not sys.stdout or "--nogui" not in sys.argv
-"""Checks if the user wanted no GUI mode and has a terminal to use it with."""
-
 def title_sorted(data: typing.Iterable, key=None, ignore: typing.AbstractSet[str] = frozenset(("a", "the"))):
    """Sorts a sequence of text ignoring typical articles like "a" or "the" in the beginning."""
    def sorter(element: Union[str, Dict[str, Any]]) -> str:
@@ -991,7 +905,7 @@ def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = Non
    Use this to start a task when you don't keep a reference to it or immediately await it,
    to prevent early garbage collection. "fire-and-forget"
    """
-    # https://docs.python.org/3.11/library/asyncio-task.html#asyncio.create_task
+    # https://docs.python.org/3.10/library/asyncio-task.html#asyncio.create_task
    # Python docs:
    # ```
    # Important: Save a reference to the result of [asyncio.create_task],
@@ -1005,7 +919,6 @@ def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = Non


 def deprecate(message: str, add_stacklevels: int = 0):
-    """also use typing_extensions.deprecated wherever you use this"""
    if __debug__:
        raise Exception(message)
    warnings.warn(message, stacklevel=2 + add_stacklevels)
@@ -1029,15 +942,15 @@ class DeprecateDict(dict):


 def _extend_freeze_support() -> None:
-    """Extend multiprocessing.freeze_support() to also work on Non-Windows and without setting spawn method first."""
-    # original upstream issue: https://github.com/python/cpython/issues/76327
+    """Extend multiprocessing.freeze_support() to also work on Non-Windows for spawn."""
+    # upstream issue: https://github.com/python/cpython/issues/76327
    # code based on https://github.com/pyinstaller/pyinstaller/blob/develop/PyInstaller/hooks/rthooks/pyi_rth_multiprocessing.py#L26
    import multiprocessing
    import multiprocessing.spawn

    def _freeze_support() -> None:
        """Minimal freeze_support. Only apply this if frozen."""
-        from subprocess import _args_from_interpreter_flags  # noqa
+        from subprocess import _args_from_interpreter_flags

        # Prevent `spawn` from trying to read `__main__` in from the main script
        multiprocessing.process.ORIGINAL_DIR = None
@@ -1064,36 +977,20 @@ def _extend_freeze_support() -> None:
            multiprocessing.spawn.spawn_main(**kwargs)
            sys.exit()

-    def _noop() -> None:
-        pass
-
-    multiprocessing.freeze_support = multiprocessing.spawn.freeze_support = _freeze_support if is_frozen() else _noop
+    if not is_windows and is_frozen():
+        multiprocessing.freeze_support = multiprocessing.spawn.freeze_support = _freeze_support


-@deprecated("Use multiprocessing.freeze_support() instead")
 def freeze_support() -> None:
-    """This now only calls multiprocessing.freeze_support since we are patching freeze_support on module load."""
+    """This behaves like multiprocessing.freeze_support but also works on Non-Windows."""
    import multiprocessing
-
-    deprecate("Use multiprocessing.freeze_support() instead")
+    _extend_freeze_support()
    multiprocessing.freeze_support()


-_extend_freeze_support()
-
-
-def visualize_regions(
-        root_region: Region,
-        file_name: str,
-        *,
-        show_entrance_names: bool = False,
-        show_locations: bool = True,
-        show_other_regions: bool = True,
-        linetype_ortho: bool = True,
-        regions_to_highlight: set[Region] | None = None,
-        entrance_highlighting: dict[int, int] | None = None,
-        detail_other_regions: bool = False,
-        auto_assign_colors: bool = False) -> None:
+def visualize_regions(root_region: Region, file_name: str, *,
+                      show_entrance_names: bool = False, show_locations: bool = True, show_other_regions: bool = True,
+                      linetype_ortho: bool = True, regions_to_highlight: set[Region] | None = None) -> None:
    """Visualize the layout of a world as a PlantUML diagram.

    :param root_region: The region from which to start the diagram from. (Usually the "Menu" region of your world.)
@@ -1110,13 +1007,6 @@ def visualize_regions(
    :param show_other_regions: (default True) If enabled, regions that can't be reached by traversing exits are shown.
    :param linetype_ortho: (default True) If enabled, orthogonal straight line parts will be used; otherwise polylines.
    :param regions_to_highlight: Regions that will be highlighted in green if they are reachable.
-    :param entrance_highlighting: a mapping from your world's entrance randomization groups to RGB values, used to color
-            your entrances
-    :param detail_other_regions: (default False) If enabled, will fully visualize regions that aren't reachable
-            from root_region.
-    :param auto_assign_colors: (default False) If enabled, will automatically assign random colors to entrances of the
-            same randomization group. Uses entrance_highlighting first, and only picks random colors for entrance groups
-            not found in the passed-in map

    Example usage in World code:
    from Utils import visualize_regions
@@ -1142,34 +1032,6 @@ def visualize_regions(
    regions: typing.Deque[Region] = deque((root_region,))
    multiworld: MultiWorld = root_region.multiworld

-    colors_used: set[int] = set()
-    if entrance_highlighting:
-        for color in entrance_highlighting.values():
-            # filter the colors to their most-significant bits to avoid too similar colors
-            colors_used.add(color & 0xF0F0F0)
-    else:
-        # assign an empty dict to not crash later
-        # the parameter is optional for ease of use when you don't care about colors
-        entrance_highlighting = {}
-
-    def select_color(group: int) -> int:
-        # specifically spacing color indexes by three different prime numbers (3, 5, 7) for the RGB components to avoid
-        # obvious cyclical color patterns
-        COLOR_INDEX_SPACING: int = 0x357
-        new_color_index: int = (group * COLOR_INDEX_SPACING) % 0x1000
-        new_color = ((new_color_index & 0xF00) << 12) + \
-                    ((new_color_index & 0xF0) << 8) + \
-                    ((new_color_index & 0xF) << 4)
-        while new_color in colors_used:
-            # while this is technically unbounded, expected collisions are low. There are 4095 possible colors
-            # and worlds are unlikely to get to anywhere close to that many entrance groups
-            # intentionally not using multiworld.random to not affect output when debugging with this tool
-            new_color_index += COLOR_INDEX_SPACING
-            new_color = ((new_color_index & 0xF00) << 12) + \
-                        ((new_color_index & 0xF0) << 8) + \
-                        ((new_color_index & 0xF) << 4)
-        return new_color
-
    def fmt(obj: Union[Entrance, Item, Location, Region]) -> str:
        name = obj.name
        if isinstance(obj, Item):
@@ -1189,28 +1051,18 @@ def visualize_regions(

    def visualize_exits(region: Region) -> None:
        for exit_ in region.exits:
-            color_code: str = ""
-            if exit_.randomization_group in entrance_highlighting:
-                color_code = f" #{entrance_highlighting[exit_.randomization_group]:0>6X}"
            if exit_.connected_region:
                if show_entrance_names:
-                    uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\" : \"{fmt(exit_)}\"{color_code}")
+                    uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\" : \"{fmt(exit_)}\"")
                else:
                    try:
-                        uml.remove(f"\"{fmt(exit_.connected_region)}\" --> \"{fmt(region)}\"{color_code}")
-                        uml.append(f"\"{fmt(exit_.connected_region)}\" <--> \"{fmt(region)}\"{color_code}")
+                        uml.remove(f"\"{fmt(exit_.connected_region)}\" --> \"{fmt(region)}\"")
+                        uml.append(f"\"{fmt(exit_.connected_region)}\" <--> \"{fmt(region)}\"")
                    except ValueError:
-                        uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\"{color_code}")
+                        uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\"")
            else:
-                uml.append(f"circle \"unconnected exit:\\n{fmt(exit_)}\" {color_code}")
-                uml.append(f"\"{fmt(region)}\" --> \"unconnected exit:\\n{fmt(exit_)}\"{color_code}")
-        for entrance in region.entrances:
-            color_code: str = ""
-            if entrance.randomization_group in entrance_highlighting:
-                color_code = f" #{entrance_highlighting[entrance.randomization_group]:0>6X}"
-            if not entrance.parent_region:
-                uml.append(f"circle \"unconnected entrance:\\n{fmt(entrance)}\"{color_code}")
-                uml.append(f"\"unconnected entrance:\\n{fmt(entrance)}\" --> \"{fmt(region)}\"{color_code}")
+                uml.append(f"circle \"unconnected exit:\\n{fmt(exit_)}\"")
+                uml.append(f"\"{fmt(region)}\" --> \"unconnected exit:\\n{fmt(exit_)}\"")

    def visualize_locations(region: Region) -> None:
        any_lock = any(location.locked for location in region.locations)
@@ -1231,27 +1083,9 @@ def visualize_regions(
        if other_regions := [region for region in multiworld.get_regions(root_region.player) if region not in seen]:
            uml.append("package \"other regions\" <<Cloud>> {")
            for region in other_regions:
-                if detail_other_regions:
-                    visualize_region(region)
-                else:
-                    uml.append(f"class \"{fmt(region)}\"")
+                uml.append(f"class \"{fmt(region)}\"")
            uml.append("}")

-    if auto_assign_colors:
-        all_entrances: list[Entrance] = []
-        for region in multiworld.get_regions(root_region.player):
-            all_entrances.extend(region.entrances)
-            all_entrances.extend(region.exits)
-        all_groups: list[int] = sorted(set([entrance.randomization_group for entrance in all_entrances]))
-        for group in all_groups:
-            if group not in entrance_highlighting:
-                if len(colors_used) >= 0x1000:
-                    # on the off chance someone makes 4096 different entrance groups, don't cycle forever
-                    break
-                new_color: int = select_color(group)
-                entrance_highlighting[group] = new_color
-                colors_used.add(new_color)
-
    uml.append("@startuml")
    uml.append("hide circle")
    uml.append("hide empty members")
@@ -1262,7 +1096,7 @@ def visualize_regions(
            seen.add(current_region)
            visualize_region(current_region)
            regions.extend(exit_.connected_region for exit_ in current_region.exits if exit_.connected_region)
-    if show_other_regions or detail_other_regions:
+    if show_other_regions:
        visualize_other_regions()
    uml.append("@enduml")

@@ -1289,81 +1123,3 @@ def is_iterable_except_str(obj: object) -> TypeGuard[typing.Iterable[typing.Any]
    if isinstance(obj, str):
        return False
    return isinstance(obj, typing.Iterable)
-
-
-def utcnow() -> datetime:
-    """
-    Implementation of Python's datetime.utcnow() function for use after deprecation.
-    Needed for timezone-naive UTC datetimes stored in databases with PonyORM (upstream).
-    https://ponyorm.org/ponyorm-list/2014-August/000113.html
-    """
-    return datetime.now(timezone.utc).replace(tzinfo=None)
-
-
-class DaemonThreadPoolExecutor(concurrent.futures.ThreadPoolExecutor):
-    """
-    ThreadPoolExecutor that uses daemonic threads that do not keep the program alive.
-    NOTE: use this with caution because killed threads will not properly clean up.
-    """
-
-    def _adjust_thread_count(self):
-        # see upstream ThreadPoolExecutor for details
-        import threading
-        import weakref
-        from concurrent.futures.thread import _worker
-
-        if self._idle_semaphore.acquire(timeout=0):
-            return
-
-        def weakref_cb(_, q=self._work_queue):
-            q.put(None)
-
-        num_threads = len(self._threads)
-        if num_threads < self._max_workers:
-            thread_name = f"{self._thread_name_prefix or self}_{num_threads}"
-            t = threading.Thread(
-                name=thread_name,
-                target=_worker,
-                args=(
-                    weakref.ref(self, weakref_cb),
-                    self._work_queue,
-                    self._initializer,
-                    self._initargs,
-                ),
-                daemon=True,
-            )
-            t.start()
-            self._threads.add(t)
-            # NOTE: don't add to _threads_queues so we don't block on shutdown
-
-
-def get_full_typename(t: type) -> str:
-    """Returns the full qualified name of a type, including its module (if not builtins)."""
-    module = t.__module__
-    if module and module != "builtins":
-        return f"{module}.{t.__qualname__}"
-    return t.__qualname__
-
-
-def get_all_causes(ex: Exception) -> str:
-    """Return a string describing the recursive causes of this exception.
-
-    :param ex: The exception to be described.
-    :return A multiline string starting with the initial exception on the first line and each resulting exception
-            on subsequent lines with progressive indentation.
-
-            For example:
-
-            ```
-            Exception: Invalid value 'bad'.
-             Which caused: Options.OptionError: Error generating option
-              Which caused: ValueError: File bad.yaml is invalid.
-            ```
-    """
-    cause = ex
-    causes = [f"{get_full_typename(type(ex))}: {ex}"]
-    while cause := cause.__cause__:
-        causes.append(f"{get_full_typename(type(cause))}: {cause}")
-    top = causes[-1]
-    others = "".join(f"\n{' ' * (i + 1)}Which caused: {c}" for i, c in enumerate(reversed(causes[:-1])))
-    return f"{top}{others}"
@@ -20,8 +20,7 @@ if typing.TYPE_CHECKING:
 Utils.local_path.cached_path = os.path.dirname(__file__)
 settings.no_gui = True
 configpath = os.path.abspath("config.yaml")
-if not os.path.exists(configpath):
-    # fall back to config.yaml in user_path if config does not exist in cwd to match settings.py
+if not os.path.exists(configpath):  # fall back to config.yaml in home
    configpath = os.path.abspath(Utils.user_path('config.yaml'))


@@ -100,24 +99,16 @@ if __name__ == "__main__":
    multiprocessing.set_start_method('spawn')
    logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO)

+    from WebHostLib.lttpsprites import update_sprites_lttp
    from WebHostLib.autolauncher import autohost, autogen, stop
    from WebHostLib.options import create as create_options_files

    try:
-        from WebHostLib.lttpsprites import update_sprites_lttp
        update_sprites_lttp()
    except Exception as e:
        logging.exception(e)
        logging.warning("Could not update LttP sprites.")
    app = get_app()
-    from worlds import AutoWorldRegister, network_data_package
-    # Update to only valid WebHost worlds
-    invalid_worlds = {name for name, world in AutoWorldRegister.world_types.items()
-                      if not hasattr(world.web, "tutorials")}
-    if invalid_worlds:
-        logging.error(f"Following worlds not loaded as they are invalid for WebHost: {invalid_worlds}")
-    AutoWorldRegister.world_types = {k: v for k, v in AutoWorldRegister.world_types.items() if k not in invalid_worlds}
-    network_data_package["games"] = {k: v for k, v in network_data_package["games"].items() if k not in invalid_worlds}
    create_options_files()
    copy_tutorials_files_to_static()
    if app.config["SELFLAUNCH"]:
@@ -1,20 +1,46 @@
 # WebHost

-## Asset License
-
-The image files used in the page design were specifically designed for archipelago.gg and are **not** covered by the top
-level LICENSE.
-See individual LICENSE files in `./static/static/**`.
-
-You are only allowed to use them for personal use, testing and development.
-If the site is reachable over the internet, have a robots.txt in place (see `ASSET_RIGHTS` in `config.yaml`)
-and do not promote it publicly. Alternatively replace or remove the assets.
-
 ## Contribution Guidelines
+**Thank you for your interest in contributing to the Archipelago website!**  
+Much of the content on the website is generated automatically, but there are some things
+that need a personal touch. For those things, we rely on contributions from both the core
+team and the community. The current primary maintainer of the website is Farrak Kilhn.
+He may be found on Discord as `Farrak Kilhn#0418`, or on GitHub as `LegendaryLinux`.

-Pages should preferably be rendered on the server side with Jinja. Features should work with noscript if feasible.
-Design changes have to fit the overall design.
+### Small Changes
+Little changes like adding a button or a couple new select elements are perfectly fine.
+Tweaks to style specific to a PR's content are also probably not a problem. For example, if
+you build a new page which needs two side by side tables, and you need to write a CSS file
+specific to your page, that is perfectly reasonable.

-Introduction of JS dependencies should first be discussed on Discord or in a draft PR.
+### Content Additions
+Once you develop a new feature or add new content the website, make a pull request. It will
+be reviewed by the community and there will probably be some discussion around it. Depending
+on the size of the feature, and if new styles are required, there may be an additional step
+before the PR is accepted wherein Farrak works with the designer to implement styles.

-See also [docs/style.md](/docs/style.md) for the style guide.
+### Restrictions on Style Changes
+A professional designer is paid to develop the styles and assets for the Archipelago website.
+In an effort to maintain a consistent look and feel, pull requests which *exclusively*
+change site styles are rejected. Please note this applies to code which changes the overall
+look and feel of the site, not to small tweaks to CSS for your custom page. The intention
+behind these restrictions is to maintain a curated feel for the design of the site. If
+any PR affects the overall feel of the site but includes additive changes, there will
+likely be a conversation about how to implement those changes without compromising the
+curated site style. It is therefore worth noting there are a couple files which, if
+changed in your pull request, will cause it to draw additional scrutiny.
+
+These closely guarded files are:
+- `globalStyles.css`
+- `islandFooter.css`
+- `landing.css`
+- `markdown.css`
+- `tooltip.css`
+
+### Site Themes
+There are several themes available for game pages. It is possible to request a new theme in
+the `#art-and-design` channel on Discord. Because themes are created by the designer, they
+are not free, and take some time to create. Farrak works closely with the designer to implement
+these themes, and pays for the assets out of pocket. Therefore, only a couple themes per year
+are added. If a proposed theme seems like a cool idea and the community likes it, there is a
+good chance it will become a reality.
@@ -1,7 +1,6 @@
 import base64
 import os
 import socket
-import typing
 import uuid

 from flask import Flask
@@ -11,7 +10,6 @@ from pony.flask import Pony
 from werkzeug.routing import BaseConverter

 from Utils import title_sorted, get_file_safe_name
-from .cli import CLI

 UPLOAD_FOLDER = os.path.relpath('uploads')
 LOGS_FOLDER = os.path.relpath('logs')
@@ -24,17 +22,6 @@ app.jinja_env.filters['any'] = any
 app.jinja_env.filters['all'] = all
 app.jinja_env.filters['get_file_safe_name'] = get_file_safe_name

-# overwrites of flask default config
-app.config["DEBUG"] = False
-app.config["PORT"] = 80
-app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
-app.config["MAX_CONTENT_LENGTH"] = 64 * 1024 * 1024  # 64 megabyte limit
-# if you want to deploy, make sure you have a non-guessable secret key
-app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
-app.config["SESSION_PERMANENT"] = True
-app.config["MAX_FORM_MEMORY_SIZE"] = 2 * 1024 * 1024  # 2 MB, needed for large option pages such as SC2
-
-# custom config
 app.config["SELFHOST"] = True  # application process is in charge of running the websites
 app.config["GENERATORS"] = 8  # maximum concurrent world gens
 app.config["HOSTERS"] = 8  # maximum concurrent room hosters
@@ -42,16 +29,19 @@ app.config["SELFLAUNCH"] = True  # application process is in charge of launching
 app.config["SELFLAUNCHCERT"] = None  # can point to a SSL Certificate to encrypt Room websocket connections
 app.config["SELFLAUNCHKEY"] = None  # can point to a SSL Certificate Key to encrypt Room websocket connections
 app.config["SELFGEN"] = True  # application process is in charge of scheduling Generations.
+app.config["DEBUG"] = False
+app.config["PORT"] = 80
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 64 * 1024 * 1024  # 64 megabyte limit
+# if you want to deploy, make sure you have a non-guessable secret key
+app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
 # at what amount of worlds should scheduling be used, instead of rolling in the web-thread
 app.config["JOB_THRESHOLD"] = 1
 # after what time in seconds should generation be aborted, freeing the queue slot. Can be set to None to disable.
 app.config["JOB_TIME"] = 600
-# maximum time in seconds since last activity for a room to be hosted
-app.config["MAX_ROOM_TIMEOUT"] = 259200
-# minimum time in days since last activity for a room to be deleted. 0 to disable.
-app.config["ROOM_AUTO_DELETE"] = 0
 # memory limit for generator processes in bytes
 app.config["GENERATOR_MEMORY_LIMIT"] = 4294967296
+app.config['SESSION_PERMANENT'] = True

 # waitress uses one thread for I/O, these are for processing of views that then get sent
 # archipelago.gg uses gunicorn + nginx; ignoring this option
@@ -69,26 +59,22 @@ app.config["ASSET_RIGHTS"] = False

 cache = Cache()
 Compress(app)
-CLI(app)


-def to_python(value: str) -> uuid.UUID:
-    if "=" in value or any(c.isspace() for c in value):
-        raise ValueError("Invalid UUID format")
-    return uuid.UUID(bytes=base64.urlsafe_b64decode(value + '=' * (-len(value) % 4)))
+def to_python(value):
+    return uuid.UUID(bytes=base64.urlsafe_b64decode(value + '=='))


-def to_url(value: uuid.UUID) -> str:
+def to_url(value):
    return base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')


 class B64UUIDConverter(BaseConverter):

-    def to_python(self, value: str) -> uuid.UUID:
+    def to_python(self, value):
        return to_python(value)

-    def to_url(self, value: typing.Any) -> str:
-        assert isinstance(value, uuid.UUID)
+    def to_url(self, value):
        return to_url(value)


@@ -98,7 +84,7 @@ app.jinja_env.filters["suuid"] = to_url
 app.jinja_env.filters["title_sorted"] = title_sorted


-def register() -> None:
+def register():
    """Import submodules, triggering their registering on flask routing.
    Note: initializes worlds subsystem."""
    import importlib
@@ -2,24 +2,14 @@
 from typing import List, Tuple

 from flask import Blueprint
-from flask_cors import CORS

 from ..models import Seed, Slot

 api_endpoints = Blueprint('api', __name__, url_prefix="/api")
-cors = CORS(api_endpoints, resources={
-                r"/api/datapackage/*": {"origins": "*"},
-                r"/api/datapackage": {"origins": "*"},
-                r"/api/datapackage_checksum/*": {"origins": "*"},
-                r"/api/room_status/*": {"origins": "*"},
-                r"/api/tracker/*": {"origins": "*"},
-                r"/api/static_tracker/*": {"origins": "*"},
-                r"/api/slot_data_tracker/*": {"origins": "*"}
-            })


 def get_players(seed: Seed) -> List[Tuple[str, str]]:
    return [(slot.player_name, slot.game) for slot in seed.slots.order_by(Slot.player_id)]

-# trigger endpoint registration
-from . import datapackage, generate, room, tracker, user
+
+from . import datapackage, generate, room, user  # trigger registration
@@ -1,258 +0,0 @@
-from datetime import datetime, timezone
-from typing import Any, TypedDict
-from uuid import UUID
-
-from flask import abort
-
-from NetUtils import ClientStatus, Hint, NetworkItem, SlotType
-from WebHostLib import cache
-from WebHostLib.api import api_endpoints
-from WebHostLib.models import Room
-from WebHostLib.tracker import TrackerData
-
-
-class PlayerAlias(TypedDict):
-    team: int
-    player: int
-    alias: str | None
-
-
-class PlayerItemsReceived(TypedDict):
-    team: int
-    player: int
-    items: list[NetworkItem]
-
-
-class PlayerChecksDone(TypedDict):
-    team: int
-    player: int
-    locations: list[int]
-
-
-class TeamTotalChecks(TypedDict):
-    team: int
-    checks_done: int
-
-
-class PlayerHints(TypedDict):
-    team: int
-    player: int
-    hints: list[Hint]
-
-
-class PlayerTimer(TypedDict):
-    team: int
-    player: int
-    time: datetime | None
-
-
-class PlayerStatus(TypedDict):
-    team: int
-    player: int
-    status: ClientStatus
-
-
-class PlayerLocationsTotal(TypedDict):
-    team: int
-    player: int
-    total_locations: int
-
-
-class PlayerGame(TypedDict):
-    team: int
-    player: int
-    game: str
-
-
-@api_endpoints.route("/tracker/<suuid:tracker>")
-@cache.memoize(timeout=60)
-def tracker_data(tracker: UUID) -> dict[str, Any]:
-    """
-    Outputs json data to <root_path>/api/tracker/<id of current session tracker>.
-
-    :param tracker: UUID of current session tracker.
-
-    :return: Tracking data for all players in the room. Typing and docstrings describe the format of each value.
-    """
-    room: Room | None = Room.get(tracker=tracker)
-    if not room:
-        abort(404)
-
-    tracker_data = TrackerData(room)
-
-    all_players: dict[int, list[int]] = tracker_data.get_all_players()
-
-    player_aliases: list[PlayerAlias] = []
-    """Slot aliases of all players."""
-    for team, players in all_players.items():
-        for player in players:
-            player_aliases.append(
-                {"team": team, "player": player, "alias": tracker_data.get_player_alias(team, player)})
-
-    player_items_received: list[PlayerItemsReceived] = []
-    """Items received by each player."""
-    for team, players in all_players.items():
-        for player in players:
-            player_items_received.append(
-                {"team": team, "player": player, "items": tracker_data.get_player_received_items(team, player)})
-
-    player_checks_done: list[PlayerChecksDone] = []
-    """ID of all locations checked by each player."""
-    for team, players in all_players.items():
-        for player in players:
-            player_checks_done.append(
-                {"team": team, "player": player,
-                 "locations": sorted(tracker_data.get_player_checked_locations(team, player))})
-
-    total_checks_done: list[TeamTotalChecks] = [
-        {"team": team, "checks_done": checks_done}
-        for team, checks_done in tracker_data.get_team_locations_checked_count().items()
-    ]
-    """Total number of locations checked for the entire multiworld per team."""
-
-    hints: list[PlayerHints] = []
-    """Hints that all players have used or received."""
-    for team, players in tracker_data.get_all_slots().items():
-        for player in players:
-            player_hints = sorted(tracker_data.get_player_hints(team, player))
-            hints.append({"team": team, "player": player, "hints": player_hints})
-            slot_info = tracker_data.get_slot_info(player)
-            # this assumes groups are always after players
-            if slot_info.type != SlotType.group:
-                continue
-            for member in slot_info.group_members:
-                hints[member - 1]["hints"] += player_hints
-
-    activity_timers: list[PlayerTimer] = []
-    """Time of last activity per player. Returned as RFC 1123 format and null if no connection has been made."""
-    for team, players in all_players.items():
-        for player in players:
-            activity_timers.append({"team": team, "player": player, "time": None})
-
-    for (team, player), timestamp in tracker_data._multisave.get("client_activity_timers", []):
-        for entry in activity_timers:
-            if entry["team"] == team and entry["player"] == player:
-                entry["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
-                break
-
-    connection_timers: list[PlayerTimer] = []
-    """Time of last connection per player. Returned as RFC 1123 format and null if no connection has been made."""
-    for team, players in all_players.items():
-        for player in players:
-            connection_timers.append({"team": team, "player": player, "time": None})
-
-    for (team, player), timestamp in tracker_data._multisave.get("client_connection_timers", []):
-        # find the matching entry
-        for entry in connection_timers:
-            if entry["team"] == team and entry["player"] == player:
-                entry["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
-                break
-
-    player_status: list[PlayerStatus] = []
-    """The current client status for each player."""
-    for team, players in all_players.items():
-        for player in players:
-            player_status.append(
-                {"team": team, "player": player, "status": tracker_data.get_player_client_status(team, player)})
-
-    return {
-        "aliases": player_aliases,
-        "player_items_received": player_items_received,
-        "player_checks_done": player_checks_done,
-        "total_checks_done": total_checks_done,
-        "hints": hints,
-        "activity_timers": activity_timers,
-        "connection_timers": connection_timers,
-        "player_status": player_status,
-    }
-
-
-class PlayerGroups(TypedDict):
-    slot: int
-    name: str
-    members: list[int]
-
-
-class PlayerSlotData(TypedDict):
-    player: int
-    slot_data: dict[str, Any]
-
-
-@api_endpoints.route("/static_tracker/<suuid:tracker>")
-@cache.memoize(timeout=300)
-def static_tracker_data(tracker: UUID) -> dict[str, Any]:
-    """
-    Outputs json data to <root_path>/api/static_tracker/<id of current session tracker>.
-
-    :param tracker: UUID of current session tracker.
-
-    :return: Static tracking data for all players in the room. Typing and docstrings describe the format of each value.
-    """
-    room: Room | None = Room.get(tracker=tracker)
-    if not room:
-        abort(404)
-    tracker_data = TrackerData(room)
-
-    all_players: dict[int, list[int]] = tracker_data.get_all_players()
-
-    groups: list[PlayerGroups] = []
-    """The Slot ID of groups and the IDs of the group's members."""
-    for team, players in tracker_data.get_all_slots().items():
-        for player in players:
-            slot_info = tracker_data.get_slot_info(player)
-            if slot_info.type != SlotType.group or not slot_info.group_members:
-                continue
-            groups.append(
-                {
-                    "slot": player,
-                    "name": slot_info.name,
-                    "members": list(slot_info.group_members),
-                })
-        break
-
-    player_locations_total: list[PlayerLocationsTotal] = []
-    for team, players in all_players.items():
-        for player in players:
-            player_locations_total.append(
-                {"team": team, "player": player, "total_locations": len(tracker_data.get_player_locations(player))})
-
-    player_game: list[PlayerGame] = []
-    """The played game per player slot."""
-    for team, players in all_players.items():
-        for player in players:
-            player_game.append({"team": team, "player": player, "game": tracker_data.get_player_game(player)})
-
-    return {
-        "groups": groups,
-        "datapackage": tracker_data._multidata["datapackage"],
-        "player_locations_total": player_locations_total,
-        "player_game": player_game,
-    }
-
-
-# It should be exceedingly rare that slot data is needed, so it's separated out.
-@api_endpoints.route("/slot_data_tracker/<suuid:tracker>")
-@cache.memoize(timeout=300)
-def tracker_slot_data(tracker: UUID) -> list[PlayerSlotData]:
-    """
-    Outputs json data to <root_path>/api/slot_data_tracker/<id of current session tracker>.
-
-    :param tracker: UUID of current session tracker.
-
-    :return: Slot data for all players in the room. Typing completely arbitrary per game.
-    """
-    room: Room | None = Room.get(tracker=tracker)
-    if not room:
-        abort(404)
-    tracker_data = TrackerData(room)
-
-    all_players: dict[int, list[int]] = tracker_data.get_all_players()
-
-    slot_data: list[PlayerSlotData] = []
-    """Slot data for each player."""
-    for team, players in all_players.items():
-        for player in players:
-            slot_data.append({"player": player, "slot_data": tracker_data.get_slot_data(player)})
-        break
-
-    return slot_data
@@ -4,20 +4,20 @@ import json
 import logging
 import multiprocessing
 import typing
-from datetime import timedelta
+from datetime import timedelta, datetime
 from threading import Event, Thread
 from typing import Any
 from uuid import UUID

-from pony.orm import db_session, select, commit, PrimaryKey, desc
+from pony.orm import db_session, select, commit, PrimaryKey

-from Utils import restricted_loads, utcnow
+from Utils import restricted_loads
 from .locker import Locker, AlreadyRunningException

 _stop_event = Event()


-def stop() -> None:
+def stop():
    """Stops previously launched threads"""
    global _stop_event
    stop_event = _stop_event
@@ -36,39 +36,25 @@ def handle_generation_failure(result: BaseException):
        logging.exception(e)


-def _mp_gen_game(
-    gen_options: dict,
-    meta: dict[str, Any] | None = None,
-    owner=None,
-    sid=None,
-    timeout: int|None = None,
-) -> PrimaryKey | None:
+def _mp_gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None) -> PrimaryKey | None:
    from setproctitle import setproctitle

    setproctitle(f"Generator ({sid})")
-    try:
-        return gen_game(gen_options, meta=meta, owner=owner, sid=sid, timeout=timeout)
-    finally:
-        setproctitle(f"Generator (idle)")
+    res = gen_game(gen_options, meta=meta, owner=owner, sid=sid)
+    setproctitle(f"Generator (idle)")
+    return res


-def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation, timeout: int|None) -> None:
+def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
    try:
        meta = json.loads(generation.meta)
        options = restricted_loads(generation.options)
        logging.info(f"Generating {generation.id} for {len(options)} players")
-        pool.apply_async(
-            _mp_gen_game,
-            (options,),
-            {
-                "meta": meta,
-                "sid": generation.id,
-                "owner": generation.owner,
-                "timeout": timeout,
-            },
-            handle_generation_success,
-            handle_generation_failure,
-        )
+        pool.apply_async(_mp_gen_game, (options,),
+                         {"meta": meta,
+                          "sid": generation.id,
+                          "owner": generation.owner},
+                         handle_generation_success, handle_generation_failure)
    except Exception as e:
        generation.state = STATE_ERROR
        commit()
@@ -100,18 +86,13 @@ def init_generator(config: dict[str, Any]) -> None:
    db.generate_mapping()


-def cleanup(config: dict[str, Any]):
-    """delete unowned or old user-content"""
-    auto_delete: int = config.get("ROOM_AUTO_DELETE", 0)
+def cleanup():
+    """delete unowned user-content"""
    with db_session:
        # >>> bool(uuid.UUID(int=0))
        # True
        rooms = Room.select(lambda room: room.owner == UUID(int=0)).delete(bulk=True)
        seeds = Seed.select(lambda seed: seed.owner == UUID(int=0) and not seed.rooms).delete(bulk=True)
-        if auto_delete > 0:
-            cutoff = utcnow() - timedelta(days=auto_delete)
-            rooms += Room.select(lambda room: room.last_activity < cutoff).delete(bulk=True)
-            seeds += Seed.select(lambda seed: not seed.rooms and seed.creation_time < cutoff).delete(bulk=True)
        slots = Slot.select(lambda slot: not slot.seed).delete(bulk=True)
        # Command gets deleted by ponyorm Cascade Delete, as Room is Required
    if rooms or seeds or slots:
@@ -123,7 +104,7 @@ def autohost(config: dict):
        stop_event = _stop_event
        try:
            with Locker("autohost"):
-                cleanup(config)
+                cleanup()
                hosters = []
                for x in range(config["HOSTERS"]):
                    hoster = MultiworldInstance(config, x)
@@ -134,11 +115,10 @@ def autohost(config: dict):
                    with db_session:
                        rooms = select(
                            room for room in Room if
-                            room.last_activity >= utcnow() - timedelta(
-                                seconds=config["MAX_ROOM_TIMEOUT"])).order_by(desc(Room.last_port))
+                            room.last_activity >= datetime.utcnow() - timedelta(days=3))
                        for room in rooms:
                            # we have to filter twice, as the per-room timeout can't currently be PonyORM transpiled.
-                            if room.last_activity >= utcnow() - timedelta(seconds=room.timeout + 5):
+                            if room.last_activity >= datetime.utcnow() - timedelta(seconds=room.timeout + 5):
                                hosters[room.id.int % len(hosters)].start_room(room.id)

        except AlreadyRunningException:
@@ -155,7 +135,6 @@ def autogen(config: dict):

                with multiprocessing.Pool(config["GENERATORS"], initializer=init_generator,
                                          initargs=(config,), maxtasksperchild=10) as generator_pool:
-                    job_time = config["JOB_TIME"]
                    with db_session:
                        to_start = select(generation for generation in Generation if generation.state == STATE_STARTED)

@@ -166,7 +145,7 @@ def autogen(config: dict):
                                if sid:
                                    generation.delete()
                                else:
-                                    launch_generator(generator_pool, generation, timeout=job_time)
+                                    launch_generator(generator_pool, generation)

                            commit()
                        select(generation for generation in Generation if generation.state == STATE_ERROR).delete()
@@ -178,7 +157,7 @@ def autogen(config: dict):
                                generation for generation in Generation
                                if generation.state == STATE_QUEUED).for_update()
                            for generation in to_start:
-                                launch_generator(generator_pool, generation, timeout=job_time)
+                                launch_generator(generator_pool, generation)
        except AlreadyRunningException:
            logging.info("Autogen reports as already running, not starting another.")

@@ -1,8 +0,0 @@
-from flask import Flask
-
-
-class CLI:
-    def __init__(self, app: Flask) -> None:
-        from .stats import stats_cli
-
-        app.cli.add_command(stats_cli)
@@ -1,36 +0,0 @@
-import click
-from flask.cli import AppGroup
-from pony.orm import raw_sql
-
-from Utils import format_SI_prefix
-
-stats_cli = AppGroup("stats")
-
-
-@stats_cli.command("show")
-def show() -> None:
-    from pony.orm import db_session, select
-
-    from WebHostLib.models import GameDataPackage
-
-    total_games_package_count: int = 0
-    total_games_package_size: int
-    top_10_package_sizes: list[tuple[int, str]] = []
-
-    with db_session:
-        data_length = raw_sql("LENGTH(data)")
-        data_length_desc = raw_sql("LENGTH(data) DESC")
-        data_length_sum = raw_sql("SUM(LENGTH(data))")
-        total_games_package_count = GameDataPackage.select().count()
-        total_games_package_size = select(data_length_sum for _ in GameDataPackage).first()  # type: ignore
-        top_10_package_sizes = list(
-            select((data_length, dp.checksum) for dp in GameDataPackage)  # type: ignore
-            .order_by(lambda _, _2: data_length_desc)
-            .limit(10)
-        )
-
-    click.echo(f"Total number of games packages: {total_games_package_count}")
-    click.echo(f"Total size of games packages:   {format_SI_prefix(total_games_package_size, power=1024)}B")
-    click.echo(f"Top {len(top_10_package_sizes)} biggest games packages:")
-    for size, checksum in top_10_package_sizes:
-        click.echo(f"    {checksum}: {size:>8d}")
@@ -19,10 +19,7 @@ from pony.orm import commit, db_session, select

 import Utils

-from MultiServer import (
-    Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert,
-    server_per_message_deflate_factory,
-)
+from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert
 from Utils import restricted_loads, cache_argsless
 from .locker import Locker
 from .models import Command, GameDataPackage, Room, db
@@ -89,24 +86,18 @@ class WebHostContext(Context):
            setattr(self, key, value)
        self.non_hintable_names = collections.defaultdict(frozenset, self.non_hintable_names)

-    async def listen_to_db_commands(self):
+    def listen_to_db_commands(self):
        cmdprocessor = DBCommandProcessor(self)

        while not self.exit_event.is_set():
-            await self.main_loop.run_in_executor(None, self._process_db_commands, cmdprocessor)
-            try:
-                await asyncio.wait_for(self.exit_event.wait(), 5)
-            except asyncio.TimeoutError:
-                pass
-
-    def _process_db_commands(self, cmdprocessor):
-        with db_session:
-            commands = select(command for command in Command if command.room.id == self.room_id)
-            if commands:
-                for command in commands:
-                    self.main_loop.call_soon_threadsafe(cmdprocessor, command.commandtext)
-                    command.delete()
-                commit()
+            with db_session:
+                commands = select(command for command in Command if command.room.id == self.room_id)
+                if commands:
+                    for command in commands:
+                        self.main_loop.call_soon_threadsafe(cmdprocessor, command.commandtext)
+                        command.delete()
+                    commit()
+            time.sleep(5)

    @db_session
    def load(self, room_id: int):
@@ -155,15 +146,15 @@ class WebHostContext(Context):
            self.location_name_groups = static_location_name_groups
        return self._load(multidata, game_data_packages, True)

+    @db_session
    def init_save(self, enabled: bool = True):
        self.saving = enabled
        if self.saving:
-            with db_session:
-                savegame_data = Room.get(id=self.room_id).multisave
-                if savegame_data:
-                    self.set_save(restricted_loads(savegame_data))
+            savegame_data = Room.get(id=self.room_id).multisave
+            if savegame_data:
+                self.set_save(restricted_loads(Room.get(id=self.room_id).multisave))
            self._start_async_saving(atexit_save=False)
-        asyncio.create_task(self.listen_to_db_commands())
+        threading.Thread(target=self.listen_to_db_commands, daemon=True).start()

    @db_session
    def _save(self, exit_save: bool = False) -> bool:
@@ -172,7 +163,7 @@ class WebHostContext(Context):
        room.multisave = pickle.dumps(self.get_save())
        # saving only occurs on activity, so we can "abuse" this information to mark this as last_activity
        if not exit_save:  # we don't want to count a shutdown as activity, which would restart the server again
-            room.last_activity = Utils.utcnow()
+            room.last_activity = datetime.datetime.utcnow()
        return True

    def get_save(self) -> dict:
@@ -234,17 +225,6 @@ def set_up_logging(room_id) -> logging.Logger:
    return logger


-def tear_down_logging(room_id):
-    """Close logging handling for a room."""
-    logger_name = f"RoomLogger {room_id}"
-    if logger_name in logging.Logger.manager.loggerDict:
-        logger = logging.getLogger(logger_name)
-        for handler in logger.handlers[:]:
-            logger.removeHandler(handler)
-            handler.close()
-        del logging.Logger.manager.loggerDict[logger_name]
-
-
 def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                       cert_file: typing.Optional[str], cert_key_file: typing.Optional[str],
                       host: str, rooms_to_run: multiprocessing.Queue, rooms_shutting_down: multiprocessing.Queue):
@@ -302,12 +282,8 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                assert ctx.server is None
                try:
                    ctx.server = websockets.serve(
-                        functools.partial(server, ctx=ctx),
-                        ctx.host,
-                        ctx.port,
-                        ssl=get_ssl_context(),
-                        extensions=[server_per_message_deflate_factory],
-                    )
+                        functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=get_ssl_context())
+
                    await ctx.server
                except OSError:  # likely port in use
                    ctx.server = websockets.serve(
@@ -328,7 +304,6 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                    with db_session:
                        room = Room.get(id=ctx.room_id)
                        room.last_port = port
-                    del room
                else:
                    ctx.logger.exception("Could not determine port. Likely hosting failure.")
                with db_session:
@@ -341,35 +316,28 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,

            except (KeyboardInterrupt, SystemExit):
                if ctx.saving:
-                    ctx._save(True)
+                    ctx._save()
                    setattr(asyncio.current_task(), "save", None)
            except Exception as e:
                with db_session:
                    room = Room.get(id=room_id)
                    room.last_port = -1
-                del room
                logger.exception(e)
                raise
            else:
                if ctx.saving:
-                    ctx._save(True)
+                    ctx._save()
                    setattr(asyncio.current_task(), "save", None)
            finally:
                try:
                    ctx.save_dirty = False  # make sure the saving thread does not write to DB after final wakeup
                    ctx.exit_event.set()  # make sure the saving thread stops at some point
                    # NOTE: async saving should probably be an async task and could be merged with shutdown_task
-
-                    if ctx.server and hasattr(ctx.server, "ws_server"):
-                        ctx.server.ws_server.close()
-                        await ctx.server.ws_server.wait_closed()
-
-                    with db_session:
+                    with (db_session):
                        # ensure the Room does not spin up again on its own, minute of safety buffer
                        room = Room.get(id=room_id)
-                        room.last_activity = Utils.utcnow() - datetime.timedelta(minutes=1, seconds=room.timeout)
-                    del room
-                    tear_down_logging(room_id)
+                        room.last_activity = datetime.datetime.utcnow() - \
+                                             datetime.timedelta(minutes=1, seconds=room.timeout)
                    logging.info(f"Shutting down room {room_id} on {name}.")
                finally:
                    await asyncio.sleep(5)
@@ -12,11 +12,12 @@ from flask import flash, redirect, render_template, request, session, url_for
 from pony.orm import commit, db_session

 from BaseClasses import get_seed, seeddigits
-from Generate import PlandoOptions, handle_name, mystery_argparse
+from Generate import PlandoOptions, handle_name
 from Main import main as ERmain
-from Utils import __version__, restricted_dumps, DaemonThreadPoolExecutor
+from Utils import __version__, restricted_dumps
 from WebHostLib import app
 from settings import ServerOptions, GeneratorOptions
+from worlds.alttp.EntranceRandomizer import parse_arguments
 from .check import get_yaml_data, roll_options
 from .models import Generation, STATE_ERROR, STATE_QUEUED, Seed, UUID
 from .upload import upload_zip_to_db
@@ -33,7 +34,6 @@ def get_meta(options_source: dict, race: bool = False) -> dict[str, list[str] |
        "release_mode": str(options_source.get("release_mode", ServerOptions.release_mode)),
        "remaining_mode": str(options_source.get("remaining_mode", ServerOptions.remaining_mode)),
        "collect_mode": str(options_source.get("collect_mode", ServerOptions.collect_mode)),
-        "countdown_mode": str(options_source.get("countdown_mode", ServerOptions.countdown_mode)),
        "item_cheat": bool(int(options_source.get("item_cheat", not ServerOptions.disable_item_cheat))),
        "server_password": str(options_source.get("server_password", None)),
    }
@@ -73,10 +73,6 @@ def generate(race=False):
    return render_template("generate.html", race=race, version=__version__)


-def format_exception(e: BaseException) -> str:
-    return f"{e.__class__.__name__}: {e}"
-
-
 def start_generation(options: dict[str, dict | str], meta: dict[str, Any]):
    results, gen_options = roll_options(options, set(meta["plando_options"]))

@@ -97,9 +93,7 @@ def start_generation(options: dict[str, dict | str], meta: dict[str, Any]):
        except PicklingError as e:
            from .autolauncher import handle_generation_failure
            handle_generation_failure(e)
-            meta["error"] = format_exception(e)
-            details = json.dumps(meta, indent=4).strip()
-            return render_template("seedError.html", seed_error=meta["error"], details=details)
+            return render_template("seedError.html", seed_error=("PicklingError: " + str(e)))

        commit()

@@ -107,18 +101,16 @@ def start_generation(options: dict[str, dict | str], meta: dict[str, Any]):
    else:
        try:
            seed_id = gen_game({name: vars(options) for name, options in gen_options.items()},
-                               meta=meta, owner=session["_id"].int, timeout=app.config["JOB_TIME"])
+                               meta=meta, owner=session["_id"].int)
        except BaseException as e:
            from .autolauncher import handle_generation_failure
            handle_generation_failure(e)
-            meta["error"] = format_exception(e)
-            details = json.dumps(meta, indent=4).strip()
-            return render_template("seedError.html", seed_error=meta["error"], details=details)
+            return render_template("seedError.html", seed_error=(e.__class__.__name__ + ": " + str(e)))

        return redirect(url_for("view_seed", seed=seed_id))


-def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None, timeout: int|None = None):
+def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None):
    if meta is None:
        meta = {}

@@ -137,47 +129,43 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,

        seedname = "W" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))

-        args = mystery_argparse([])  # Just to set up the Namespace with defaults
-        args.multi = playercount
-        args.seed = seed
-        args.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
-        args.spoiler = meta["generator_options"].get("spoiler", 0)
-        args.race = race
-        args.outputname = seedname
-        args.outputpath = target.name
-        args.teams = 1
-        args.plando_options = PlandoOptions.from_set(meta.setdefault("plando_options",
-                                                                     {"bosses", "items", "connections", "texts"}))
-        args.skip_prog_balancing = False
-        args.skip_output = False
-        args.spoiler_only = False
-        args.csv_output = False
-        args.sprite = dict.fromkeys(range(1, args.multi+1), None)
-        args.sprite_pool = dict.fromkeys(range(1, args.multi+1), None)
+        erargs = parse_arguments(['--multi', str(playercount)])
+        erargs.seed = seed
+        erargs.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
+        erargs.spoiler = meta["generator_options"].get("spoiler", 0)
+        erargs.race = race
+        erargs.outputname = seedname
+        erargs.outputpath = target.name
+        erargs.teams = 1
+        erargs.plando_options = PlandoOptions.from_set(meta.setdefault("plando_options",
+                                                                       {"bosses", "items", "connections", "texts"}))
+        erargs.skip_prog_balancing = False
+        erargs.skip_output = False
+        erargs.spoiler_only = False
+        erargs.csv_output = False

        name_counter = Counter()
        for player, (playerfile, settings) in enumerate(gen_options.items(), 1):
            for k, v in settings.items():
                if v is not None:
-                    if hasattr(args, k):
-                        getattr(args, k)[player] = v
+                    if hasattr(erargs, k):
+                        getattr(erargs, k)[player] = v
                    else:
-                        setattr(args, k, {player: v})
+                        setattr(erargs, k, {player: v})

-            if not args.name[player]:
-                args.name[player] = os.path.splitext(os.path.split(playerfile)[-1])[0]
-            args.name[player] = handle_name(args.name[player], player, name_counter)
-        if len(set(args.name.values())) != len(args.name):
-            raise Exception(f"Names have to be unique. Names: {Counter(args.name.values())}")
-        ERmain(args, seed, baked_server_options=meta["server_options"])
+            if not erargs.name[player]:
+                erargs.name[player] = os.path.splitext(os.path.split(playerfile)[-1])[0]
+            erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
+        if len(set(erargs.name.values())) != len(erargs.name):
+            raise Exception(f"Names have to be unique. Names: {Counter(erargs.name.values())}")
+        ERmain(erargs, seed, baked_server_options=meta["server_options"])

        return upload_to_db(target.name, sid, owner, race)
-
-    thread_pool = DaemonThreadPoolExecutor(max_workers=1)
+    thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
    thread = thread_pool.submit(task)

    try:
-        return thread.result(timeout)
+        return thread.result(app.config["JOB_TIME"])
    except concurrent.futures.TimeoutError as e:
        if sid:
            with db_session:
@@ -185,14 +173,11 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
                if gen is not None:
                    gen.state = STATE_ERROR
                    meta = json.loads(gen.meta)
-                    meta["error"] = ("Allowed time for Generation exceeded, " +
-                                     "please consider generating locally instead. " +
-                                     format_exception(e))
+                    meta["error"] = (
+                            "Allowed time for Generation exceeded, please consider generating locally instead. " +
+                            e.__class__.__name__ + ": " + str(e))
                    gen.meta = json.dumps(meta)
                    commit()
-    except (KeyboardInterrupt, SystemExit):
-        # don't update db, retry next time
-        raise
    except BaseException as e:
        if sid:
            with db_session:
@@ -200,15 +185,10 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
                if gen is not None:
                    gen.state = STATE_ERROR
                    meta = json.loads(gen.meta)
-                    meta["error"] = format_exception(e)
+                    meta["error"] = (e.__class__.__name__ + ": " + str(e))
                    gen.meta = json.dumps(meta)
                    commit()
        raise
-    finally:
-        # free resources claimed by thread pool, if possible
-        # NOTE: Timeout depends on the process being killed at some point
-        #       since we can't actually cancel a running gen at the moment.
-        thread_pool.shutdown(wait=False, cancel_futures=True)


@app.route('/wait/<suuid:seed>')
@@ -222,9 +202,7 @@ def wait_seed(seed: UUID):
    if not generation:
        return "Generation not found."
    elif generation.state == STATE_ERROR:
-        meta = json.loads(generation.meta)
-        details = json.dumps(meta, indent=4).strip()
-        return render_template("seedError.html", seed_error=meta["error"], details=details)
+        return render_template("seedError.html", seed_error=generation.meta)
    return render_template("waitSeed.html", seed_id=seed_id)


@@ -1,9 +1,8 @@
-from datetime import timedelta
+from datetime import timedelta, datetime

 from flask import render_template
 from pony.orm import count

-from Utils import utcnow
 from WebHostLib import app, cache
 from .models import Room, Seed

@@ -11,6 +10,6 @@ from .models import Room, Seed
@app.route('/', methods=['GET', 'POST'])
@cache.cached(timeout=300)  # cache has to appear under app route for caching to work
 def landing():
-    rooms = count(room for room in Room if room.creation_time >= utcnow() - timedelta(days=7))
-    seeds = count(seed for seed in Seed if seed.creation_time >= utcnow() - timedelta(days=7))
+    rooms = count(room for room in Room if room.creation_time >= datetime.utcnow() - timedelta(days=7))
+    seeds = count(seed for seed in Seed if seed.creation_time >= datetime.utcnow() - timedelta(days=7))
    return render_template("landing.html", rooms=rooms, seeds=seeds)
@@ -3,10 +3,10 @@ import threading
 import json

 from Utils import local_path, user_path
+from worlds.alttp.Rom import Sprite


 def update_sprites_lttp():
-    from worlds.alttp.Rom import Sprite
    from tkinter import Tk
    from LttPAdjuster import get_image_for_sprite
    from LttPAdjuster import BackgroundTaskProgress
@@ -1,90 +0,0 @@
-import re
-from collections import Counter
-
-import mistune
-from werkzeug.utils import secure_filename
-
-
-__all__ = [
-    "ImgUrlRewriteInlineParser",
-    'render_markdown',
-]
-
-
-class ImgUrlRewriteInlineParser(mistune.InlineParser):
-    relative_url_base: str
-
-    def __init__(self, relative_url_base: str, hard_wrap: bool = False) -> None:
-        super().__init__(hard_wrap)
-        self.relative_url_base = relative_url_base
-
-    @staticmethod
-    def _find_game_name_by_folder_name(name: str) -> str | None:
-        from worlds.AutoWorld import AutoWorldRegister
-
-        for world_name, world_type in AutoWorldRegister.world_types.items():
-            if world_type.__module__ == f"worlds.{name}":
-                return world_name
-        return None
-
-    def parse_link(self, m: re.Match[str], state: mistune.InlineState) -> int | None:
-        res = super().parse_link(m, state)
-        if res is not None and state.tokens and state.tokens[-1]["type"] == "image":
-            image_token = state.tokens[-1]
-            url: str = image_token["attrs"]["url"]
-            if not url.startswith("/") and not "://" in url:
-                # replace relative URL to another world's doc folder with the webhost folder layout
-                if url.startswith("../../") and "/docs/" in self.relative_url_base:
-                    parts = url.split("/", 4)
-                    if parts[2] != ".." and parts[3] == "docs":
-                        game_name = self._find_game_name_by_folder_name(parts[2])
-                        if game_name is not None:
-                            url = "/".join(parts[1:2] + [secure_filename(game_name)] + parts[4:])
-                # change relative URL to point to deployment folder
-                url = f"{self.relative_url_base}/{url}"
-                image_token['attrs']['url'] = url
-        return res
-
-
-def render_markdown(path: str, img_url_base: str | None = None) -> str:
-    markdown = mistune.create_markdown(
-        escape=False,
-        plugins=[
-            "strikethrough",
-            "footnotes",
-            "table",
-            "speedup",
-        ],
-    )
-
-    heading_id_count: Counter[str] = Counter()
-
-    def heading_id(text: str) -> str:
-        nonlocal heading_id_count
-
-        # there is no good way to do this without regex
-        s = re.sub(r"[^\w\- ]", "", text.lower()).replace(" ", "-").strip("-")
-        n = heading_id_count[s]
-        heading_id_count[s] += 1
-        if n > 0:
-            s += f"-{n}"
-        return s
-
-    def id_hook(_: mistune.Markdown, state: mistune.BlockState) -> None:
-        for tok in state.tokens:
-            if tok["type"] == "heading" and tok["attrs"]["level"] < 4:
-                text = tok["text"]
-                assert isinstance(text, str)
-                unique_id = heading_id(text)
-                tok["attrs"]["id"] = unique_id
-                tok["text"] = f"<a href=\"#{unique_id}\">{text}</a>"  # make header link to itself
-
-    markdown.before_render_hooks.append(id_hook)
-    if img_url_base:
-        markdown.inline = ImgUrlRewriteInlineParser(img_url_base)
-
-    with open(path, encoding="utf-8-sig") as f:
-        document = f.read()
-    html = markdown(document)
-    assert isinstance(html, str), "Unexpected mistune renderer in render_markdown"
-    return html
@@ -1,7 +1,5 @@
 import datetime
 import os
-import warnings
-from enum import StrEnum
 from typing import Any, IO, Dict, Iterator, List, Tuple, Union

 import jinja2.exceptions
@@ -9,32 +7,16 @@ from flask import request, redirect, url_for, render_template, Response, session
 from pony.orm import count, commit, db_session
 from werkzeug.utils import secure_filename

-
 from worlds.AutoWorld import AutoWorldRegister, World
 from . import app, cache
-from .markdown import render_markdown
 from .models import Seed, Room, Command, UUID, uuid4
-from Utils import title_sorted, utcnow
+from Utils import title_sorted

-class WebWorldTheme(StrEnum):
-    DIRT = "dirt"
-    GRASS = "grass"
-    GRASS_FLOWERS = "grassFlowers"
-    ICE = "ice"
-    JUNGLE = "jungle"
-    OCEAN = "ocean"
-    PARTY_TIME = "partyTime"
-    STONE = "stone"

 def get_world_theme(game_name: str) -> str:
-    if game_name not in AutoWorldRegister.world_types:
-        return "grass"
-    chosen_theme = AutoWorldRegister.world_types[game_name].web.theme
-    available_themes = [theme.value for theme in WebWorldTheme]
-    if chosen_theme not in available_themes:
-        warnings.warn(f"Theme '{chosen_theme}' for {game_name} not valid, switching to default 'grass' theme.")
-        return "grass"
-    return chosen_theme
+    if game_name in AutoWorldRegister.world_types:
+        return AutoWorldRegister.world_types[game_name].web.theme
+    return 'grass'


 def get_visible_worlds() -> dict[str, type(World)]:
@@ -45,6 +27,49 @@ def get_visible_worlds() -> dict[str, type(World)]:
    return worlds


+def render_markdown(path: str) -> str:
+    import mistune
+    from collections import Counter
+
+    markdown = mistune.create_markdown(
+        escape=False,
+        plugins=[
+            "strikethrough",
+            "footnotes",
+            "table",
+            "speedup",
+        ],
+    )
+
+    heading_id_count: Counter[str] = Counter()
+
+    def heading_id(text: str) -> str:
+        nonlocal heading_id_count
+        import re  # there is no good way to do this without regex
+
+        s = re.sub(r"[^\w\- ]", "", text.lower()).replace(" ", "-").strip("-")
+        n = heading_id_count[s]
+        heading_id_count[s] += 1
+        if n > 0:
+            s += f"-{n}"
+        return s
+
+    def id_hook(_: mistune.Markdown, state: mistune.BlockState) -> None:
+        for tok in state.tokens:
+            if tok["type"] == "heading" and tok["attrs"]["level"] < 4:
+                text = tok["text"]
+                assert isinstance(text, str)
+                unique_id = heading_id(text)
+                tok["attrs"]["id"] = unique_id
+                tok["text"] = f"<a href=\"#{unique_id}\">{text}</a>"  # make header link to itself
+
+    markdown.before_render_hooks.append(id_hook)
+
+    with open(path, encoding="utf-8-sig") as f:
+        document = f.read()
+    return markdown(document)
+
+
@app.errorhandler(404)
@app.errorhandler(jinja2.exceptions.TemplateNotFound)
 def page_not_found(err):
@@ -66,9 +91,10 @@ def game_info(game, lang):
        theme = get_world_theme(game)
        secure_game_name = secure_filename(game)
        lang = secure_filename(lang)
-        file_dir = os.path.join(app.static_folder, "generated", "docs", secure_game_name)
-        file_dir_url = url_for("static", filename=f"generated/docs/{secure_game_name}")
-        document = render_markdown(os.path.join(file_dir, f"{lang}_{secure_game_name}.md"), file_dir_url)
+        document = render_markdown(os.path.join(
+            app.static_folder, "generated", "docs",
+            secure_game_name, f"{lang}_{secure_game_name}.md"
+        ))
        return render_template(
            "markdown_document.html",
            title=f"{game} Guide",
@@ -93,9 +119,10 @@ def tutorial(game: str, file: str):
        theme = get_world_theme(game)
        secure_game_name = secure_filename(game)
        file = secure_filename(file)
-        file_dir = os.path.join(app.static_folder, "generated", "docs", secure_game_name)
-        file_dir_url = url_for("static", filename=f"generated/docs/{secure_game_name}")
-        document = render_markdown(os.path.join(file_dir, f"{file}.md"), file_dir_url)
+        document = render_markdown(os.path.join(
+            app.static_folder, "generated", "docs",
+            secure_game_name, file+".md"
+        ))
        return render_template(
            "markdown_document.html",
            title=f"{game} Guide",
@@ -106,15 +133,6 @@ def tutorial(game: str, file: str):
        return abort(404)


-@app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
-def tutorial_redirect(game: str, file: str, lang: str):
-    """
-    Permanent redirect old tutorial URLs to new ones to keep search engines happy.
-    e.g. /tutorial/Archipelago/setup/en -> /tutorial/Archipelago/setup_en
-    """
-    return redirect(url_for("tutorial", game=game, file=f"{file}_{lang}"), code=301)
-
-
@app.route('/tutorial/')
@cache.cached()
 def tutorial_landing():
@@ -129,13 +147,8 @@ def tutorial_landing():
                "authors": tutorial.authors,
                "language": tutorial.language
            }
-
-    worlds = dict(
-        title_sorted(
-            worlds.items(), key=lambda element: "\x00" if element[0] == "Archipelago" else worlds[element[0]].game
-        )
-    )
-
+    tutorials = {world_name: tutorials for world_name, tutorials in title_sorted(
+        tutorials.items(), key=lambda element: "\x00" if element[0] == "Archipelago" else worlds[element[0]].game)}
    return render_template("tutorialLanding.html", worlds=worlds, tutorials=tutorials)


@@ -234,15 +247,11 @@ def host_room(room: UUID):
    if room is None:
        return abort(404)

-    now = utcnow()
+    now = datetime.datetime.utcnow()
    # indicate that the page should reload to get the assigned port
-    should_refresh = (
-        (not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3))
-        or room.last_activity < now - datetime.timedelta(seconds=room.timeout)
-    )
-    if now - room.last_activity > datetime.timedelta(minutes=1):
-        # we only set last_activity if needed, otherwise parallel access on /room will cause an internal server error
-        # due to "pony.orm.core.OptimisticCheckError: Object Room was updated outside of current transaction"
+    should_refresh = ((not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3))
+                      or room.last_activity < now - datetime.timedelta(seconds=room.timeout))
+    with db_session:
        room.last_activity = now  # will trigger a spinup, if it's not already running

    browser_tokens = "Mozilla", "Chrome", "Safari"
@@ -250,9 +259,9 @@ def host_room(room: UUID):
                 or "Discordbot" in request.user_agent.string
                 or not any(browser_token in request.user_agent.string for browser_token in browser_tokens))

-    def get_log(max_size: int = 0 if automated else 1024000) -> Tuple[str, int]:
+    def get_log(max_size: int = 0 if automated else 1024000) -> str:
        if max_size == 0:
-            return "…", 0
+            return "…"
        try:
            with open(os.path.join("logs", str(room.id) + ".txt"), "rb") as log:
                raw_size = 0
@@ -263,9 +272,9 @@ def host_room(room: UUID):
                        break
                    raw_size += len(block)
                    fragments.append(block.decode("utf-8"))
-                return "".join(fragments), raw_size
+                return "".join(fragments)
        except FileNotFoundError:
-            return "", 0
+            return ""

    return render_template("hostRoom.html", room=room, should_refresh=should_refresh, get_log=get_log)

@@ -2,8 +2,6 @@ from datetime import datetime
 from uuid import UUID, uuid4
 from pony.orm import Database, PrimaryKey, Required, Set, Optional, buffer, LongStr

-from Utils import utcnow
-
 db = Database()

 STATE_QUEUED = 0
@@ -22,8 +20,8 @@ class Slot(db.Entity):

 class Room(db.Entity):
    id = PrimaryKey(UUID, default=uuid4)
-    last_activity: datetime = Required(datetime, default=lambda: utcnow(), index=True)
-    creation_time: datetime = Required(datetime, default=lambda: utcnow(), index=True)  # index used by landing page
+    last_activity = Required(datetime, default=lambda: datetime.utcnow(), index=True)
+    creation_time = Required(datetime, default=lambda: datetime.utcnow(), index=True)  # index used by landing page
    owner = Required(UUID, index=True)
    commands = Set('Command')
    seed = Required('Seed', index=True)
@@ -40,7 +38,7 @@ class Seed(db.Entity):
    rooms = Set(Room)
    multidata = Required(bytes, lazy=True)
    owner = Required(UUID, index=True)
-    creation_time: datetime = Required(datetime, default=lambda: utcnow(), index=True)  # index used by landing page
+    creation_time = Required(datetime, default=lambda: datetime.utcnow(), index=True)  # index used by landing page
    slots = Set(Slot)
    spoiler = Optional(LongStr, lazy=True)
    meta = Required(LongStr, default=lambda: "{\"race\": false}")  # additional meta information/tags
@@ -13,7 +13,6 @@ from Utils import local_path
 from worlds.AutoWorld import AutoWorldRegister
 from . import app, cache
 from .generate import get_meta
-from .misc import get_world_theme


 def create() -> None:
@@ -23,6 +22,12 @@ def create() -> None:
    Options.generate_yaml_templates(yaml_folder)


+def get_world_theme(game_name: str) -> str:
+    if game_name in AutoWorldRegister.world_types:
+        return AutoWorldRegister.world_types[game_name].web.theme
+    return 'grass'
+
+
 def render_options_page(template: str, world_name: str, is_complex: bool = False) -> Union[Response, str]:
    world = AutoWorldRegister.world_types[world_name]
    if world.hidden or world.web.options_page is False:
@@ -71,7 +76,7 @@ def filter_rst_to_html(text: str) -> str:
        lines = text.splitlines()
        text = lines[0] + "\n" + dedent("\n".join(lines[1:]))

-    return publish_parts(text, writer='html', settings=None, settings_overrides={
+    return publish_parts(text, writer_name='html', settings=None, settings_overrides={
        'raw_enable': False,
        'file_insertion_enabled': False,
        'output_encoding': 'unicode'
@@ -150,9 +155,7 @@ def generate_weighted_yaml(game: str):
        options = {}

        for key, val in request.form.items():
-            if val == "_ensure-empty-list":
-                options[key] = {}
-            elif "||" not in key:
+            if "||" not in key:
                if len(str(val)) == 0:
                    continue

@@ -209,11 +212,8 @@ def generate_yaml(game: str):
    if request.method == "POST":
        options = {}
        intent_generate = False
-
        for key, val in request.form.items(multi=True):
-            if val == "_ensure-empty-list":
-                options[key] = []
-            elif options.get(key):
+            if key in options:
                if not isinstance(options[key], list):
                    options[key] = [options[key]]
                options[key].append(val)
@@ -226,7 +226,7 @@ def generate_yaml(game: str):
            if key_parts[-1] == "qty":
                if key_parts[0] not in options:
                    options[key_parts[0]] = {}
-                if val and val != "0":
+                if val != "0":
                    options[key_parts[0]][key_parts[1]] = int(val)
                del options[key]

@@ -1,14 +1,11 @@
-flask==3.1.3
-werkzeug==3.1.6
-pony==0.7.19; python_version <= '3.12'
-pony @ git+https://github.com/black-sliver/pony@7feb1221953b7fa4a6735466bf21a8b4d35e33ba#0.7.19; python_version >= '3.13'
-waitress==3.0.2
-Flask-Caching==2.3.1
-Flask-Compress==1.18  # pkg_resources can't resolve the "backports.zstd" dependency of >1.18, breaking ModuleUpdate.py
-Flask-Limiter==4.1.1
-Flask-Cors==6.0.2
-bokeh==3.8.2
-markupsafe==3.0.3
-setproctitle==1.3.7
-mistune==3.2.0
-docutils==0.22.4
+flask>=3.1.1
+werkzeug>=3.1.3
+pony>=0.7.19
+waitress>=3.0.2
+Flask-Caching>=2.3.0
+Flask-Compress>=1.17
+Flask-Limiter>=3.12
+bokeh>=3.6.3
+markupsafe>=3.0.2
+setproctitle>=1.3.5
+mistune>=3.1.3
@@ -23,7 +23,7 @@ players to rely upon each other to complete their game.
 While a multiworld game traditionally requires all players to be playing the same game, a multi-game multiworld allows
 players to randomize any of the supported games, and send items between them. This allows players of different
 games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworlds.
-Here is a list of our [Supported Games](/games).
+Here is a list of our [Supported Games](https://archipelago.gg/games).

 ## Can I generate a single-player game with Archipelago?

@@ -33,7 +33,7 @@ play, open the Settings Page, pick your settings, and click Generate Game.

 ## How do I get started?

-We have a [Getting Started](/tutorial/Archipelago/setup/en) guide that will help you get the
+We have a [Getting Started](https://archipelago.gg/tutorial/Archipelago/setup/en) guide that will help you get the
 software set up. You can use that guide to learn how to generate multiworlds. There are also basic instructions for
 including multiple games, and hosting multiworlds on the website for ease and convenience.

@@ -57,7 +57,7 @@ their multiworld.

 If a player must leave early, they can use Archipelago's release system. When a player releases their game, all items
 in that game belonging to other players are sent out automatically. This allows other players to continue to play
-uninterrupted. Here is a list of all of our [Server Commands](/tutorial/Archipelago/commands/en).
+uninterrupted. Here is a list of all of our [Server Commands](https://archipelago.gg/tutorial/Archipelago/commands/en).

 ## What happens if an item is placed somewhere it is impossible to get?

@@ -66,7 +66,7 @@ is to ensure items necessary to complete the game will be accessible to the play
 rules allowing certain items to be placed in normally unreachable locations, provided the player has indicated they are
 comfortable exploiting certain glitches in the game.

-## I want to develop a game implementation for Archipelago. How do I do that?
+## I want to add a game to the Archipelago randomizer. How do I do that?

 The best way to get started is to take a look at our code on GitHub:  
 [Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
@@ -77,5 +77,4 @@ There, you will find examples of games in the `worlds` folder:
 You may also find developer documentation in the `docs` folder:  
 [/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).

-If you have more questions regarding development of a game implementation, feel free to ask in the **#ap-world-dev** 
-channel on our Discord.
+If you have more questions, feel free to ask in the **#ap-world-dev** channel on our Discord.
@@ -1,43 +1,49 @@
-let updateSection = (sectionName, fakeDOM) => {
-    document.getElementById(sectionName).innerHTML = fakeDOM.getElementById(sectionName).innerHTML;
-}
-
 window.addEventListener('load', () => {
-    // Reload tracker every 60 seconds (sync'd)
-    const url = window.location;
-    // Note: This synchronization code is adapted from code in trackerCommon.js
-    const targetSecond = parseInt(document.getElementById('player-tracker').getAttribute('data-second')) + 3;
-    console.log("Target second of refresh: " + targetSecond);
+  // Reload tracker every 15 seconds
+  const url = window.location;
+  setInterval(() => {
+    const ajax = new XMLHttpRequest();
+    ajax.onreadystatechange = () => {
+      if (ajax.readyState !== 4) { return; }

-    let getSleepTimeSeconds = () => {
-        // -40 % 60 is -40, which is absolutely wrong and should burn
-        var sleepSeconds = (((targetSecond - new Date().getSeconds()) % 60) + 60) % 60;
-        return sleepSeconds || 60;
-    };
+      // Create a fake DOM using the returned HTML
+      const domParser = new DOMParser();
+      const fakeDOM = domParser.parseFromString(ajax.responseText, 'text/html');

-    let updateTracker = () => {
-        const ajax = new XMLHttpRequest();
-        ajax.onreadystatechange = () => {
-            if (ajax.readyState !== 4) { return; }
-    
-            // Create a fake DOM using the returned HTML
-            const domParser = new DOMParser();
-            const fakeDOM = domParser.parseFromString(ajax.responseText, 'text/html');
-    
-            // Update dynamic sections
-            updateSection('player-info', fakeDOM);
-            updateSection('section-filler', fakeDOM);
-            updateSection('section-terran', fakeDOM);
-            updateSection('section-zerg', fakeDOM);
-            updateSection('section-protoss', fakeDOM);
-            updateSection('section-nova', fakeDOM);
-            updateSection('section-kerrigan', fakeDOM);
-            updateSection('section-keys', fakeDOM);
-            updateSection('section-locations', fakeDOM);
-        };
-        ajax.open('GET', url);
-        ajax.send();
-        updater = setTimeout(updateTracker, getSleepTimeSeconds() * 1000);
+      // Update item tracker
+      document.getElementById('inventory-table').innerHTML = fakeDOM.getElementById('inventory-table').innerHTML;
+      // Update only counters in the location-table
+      let counters = document.getElementsByClassName('counter');
+      const fakeCounters = fakeDOM.getElementsByClassName('counter');
+      for (let i = 0; i < counters.length; i++) {
+        counters[i].innerHTML = fakeCounters[i].innerHTML;
+      }
    };
-    window.updater = setTimeout(updateTracker, getSleepTimeSeconds() * 1000);
+    ajax.open('GET', url);
+    ajax.send();
+  }, 15000)
+
+  // Collapsible advancement sections
+  const categories = document.getElementsByClassName("location-category");
+  for (let category of categories) {
+    let hide_id = category.id.split('_')[0];
+    if (hide_id === 'Total') {
+      continue;
+    }
+    category.addEventListener('click', function() {
+      // Toggle the advancement list
+      document.getElementById(hide_id).classList.toggle("hide");
+      // Change text of the header
+      const tab_header = document.getElementById(hide_id+'_header').children[0];
+      const orig_text = tab_header.innerHTML;
+      let new_text;
+      if (orig_text.includes("▼")) {
+        new_text = orig_text.replace("▼", "▲");
+      }
+      else {
+        new_text = orig_text.replace("▲", "▼");
+      }
+      tab_header.innerHTML = new_text;
+    });
+  }
 });
@@ -123,26 +123,12 @@ window.addEventListener('load', () => {
 });

 const addRangeRow = (optionName) => {
-  const inputQuery = `input[data-option="${optionName}"]`;
+  const inputQuery = `input[type=number][data-option="${optionName}"].range-option-value`;
  const inputTarget = document.querySelector(inputQuery);
  const newValue = inputTarget.value;
-  switch (inputTarget.type) {
-    case 'number':
-      if (!/^-?\d+$/.test(newValue)) {
-        alert('Range values must be a positive or negative integer!');
-        return;
-      }
-      break;
-    case 'text':
-      if (newValue === "") {
-        alert('Range values for text must be a non-empty string!');
-        return;
-      }
-      break;
-    default:
-      console.error(`Found unsupported input type: ${inputTarget.type}`);
-      return;
-      break;
+  if (!/^-?\d+$/.test(newValue)) {
+    alert('Range values must be a positive or negative integer!');
+    return;
  }
  inputTarget.value = '';
  const tBody = document.querySelector(`table[data-option="${optionName}"].range-rows tbody`);
@@ -28,6 +28,7 @@
    font-weight: normal;
    font-family: LondrinaSolid-Regular, sans-serif;
    text-transform: uppercase;
+    cursor: pointer; /* TODO: remove once we drop showdown.js */
    width: 100%;
    text-shadow: 1px 1px 4px #000000;
 }
@@ -36,6 +37,7 @@
    font-size: 38px;
    font-weight: normal;
    font-family: LondrinaSolid-Light, sans-serif;
+    cursor: pointer; /* TODO: remove once we drop showdown.js */
    width: 100%;
    margin-top: 20px;
    margin-bottom: 0.5rem;
@@ -48,6 +50,7 @@
    font-family: LexendDeca-Regular, sans-serif;
    text-transform: none;
    text-align: left;
+    cursor: pointer; /* TODO: remove once we drop showdown.js */
    width: 100%;
    margin-bottom: 0.5rem;
 }
@@ -56,6 +59,7 @@
    font-family: LexendDeca-Regular, sans-serif;
    text-transform: none;
    font-size: 24px;
+    cursor: pointer; /* TODO: remove once we drop showdown.js */
    margin-bottom: 24px;
 }

@@ -63,12 +67,14 @@
    font-family: LexendDeca-Regular, sans-serif;
    text-transform: none;
    font-size: 22px;
+    cursor: pointer; /* TODO: remove once we drop showdown.js */
 }

 .markdown h6, .markdown details summary.h6{
    font-family: LexendDeca-Regular, sans-serif;
    text-transform: none;
    font-size: 20px;
+    cursor: pointer; /* TODO: remove once we drop showdown.js */
 }

 .markdown h4, .markdown h5, .markdown h6{
@@ -1,276 +1,160 @@
-*{
-  margin: 0;
-  font-family: "JuraBook", monospace;
-}
-body{
-  --icon-size: 36px;
-  --item-class-padding: 4px;
-}
-a{
-  color: #1ae;
+#player-tracker-wrapper{
+    margin: 0;
 }

-/* Section colours */
-#player-info{
-  background-color: #37a;
-}
-.player-tracker{
-  max-width: 100%;
-}
-.tracker-section{
-  background-color: grey;
-}
-#terran-items{
-  background-color: #3a7;
-}
-#zerg-items{
-  background-color: #d94;
-}
-#protoss-items{
-  background-color: #37a;
-}
-#nova-items{
-  background-color: #777;
-}
-#kerrigan-items{
-  background-color: #a37;
-}
-#keys{
-  background-color: #aa2;
+#tracker-table td {
+    vertical-align: top;
 }

-/* Sections */
-.section-body{
-  display: flex;
-  flex-flow: row wrap;
-  justify-content: flex-start;
-  align-items: flex-start;
-  padding-bottom: 3px;
-}
-.section-body-2{
-  display: flex;
-  flex-direction: column;
-}
-.tracker-section:has(input.collapse-section[type=checkbox]:checked) .section-body,
-.tracker-section:has(input.collapse-section[type=checkbox]:checked) .section-body-2{
-  display: none;
-}
-.section-title{
-  position: relative;
-  border-bottom: 3px solid black;
-  /* Prevent text selection */
-  user-select: none;
-  -webkit-user-select: none;
-  -ms-user-select: none;
-}
-input[type="checkbox"]{
-  position: absolute;
-  cursor: pointer;
-  opacity: 0;
-  z-index: 1;
-  width: 100%;
-  height: 100%;
-}
-.section-title:hover h2{
-  text-shadow: 0 0 4px #ddd;
-}
-.f {
-  display: flex;
-  overflow: hidden;
+.inventory-table-area{
+    border: 2px solid #000000;
+    border-radius: 4px;
+    padding: 3px 10px 3px 10px;
 }

-/* Acquire item filters */
-.tracker-section img{
-  height: 100%;
-  width: var(--icon-size);
-  height: var(--icon-size);
-  background-color: black;
-}
-.unacquired, .lvl-0 .f{
-  filter: grayscale(100%) contrast(80%) brightness(42%) blur(0.5px);
-}
-.spacer{
-  width: var(--icon-size);
-  height: var(--icon-size);
+.inventory-table-area:has(.inventory-table-terran) {
+    width: 690px;
+    background-color: #525494;
 }

-/* Item groups */
-.item-class{
-  display: flex;
-  flex-flow: column;
-  justify-content: center;
-  padding: var(--item-class-padding);
-}
-.item-class-header{
-  display: flex;
-  flex-flow: row;
-}
-.item-class-upgrades{
-  /* Note: {display: flex; flex-flow: column wrap} */
-  /* just breaks on Firefox (width does not scale to content) */
-  display: grid;
-  grid-template-rows: repeat(4, auto);
-  grid-auto-flow: column;
+.inventory-table-area:has(.inventory-table-zerg) {
+    width: 360px;
+    background-color: #9d60d2;
 }

-/* Subsections */
-.section-toc{
-  display: flex;
-  flex-direction: row;
-}
-.toc-box{
-  position: relative;
-  padding-left: 15px;
-  padding-right: 15px;
-}
-.toc-box:hover{
-  text-shadow: 0 0 7px white;
-}
-.ss-header{
-  position: relative;
-  text-align: center;
-  writing-mode: sideways-lr;
-  user-select: none;
-  padding-top: 5px;
-  font-size: 115%;
-}
-.tracker-section:has(input.ss-1-toggle:checked) .ss-1{
-  display: none;
-}
-.tracker-section:has(input.ss-2-toggle:checked) .ss-2{
-  display: none;
-}
-.tracker-section:has(input.ss-3-toggle:checked) .ss-3{
-  display: none;
-}
-.tracker-section:has(input.ss-4-toggle:checked) .ss-4{
-  display: none;
-}
-.tracker-section:has(input.ss-5-toggle:checked) .ss-5{
-  display: none;
-}
-.tracker-section:has(input.ss-6-toggle:checked) .ss-6{
-  display: none;
-}
-.tracker-section:has(input.ss-7-toggle:checked) .ss-7{
-  display: none;
-}
-.tracker-section:has(input.ss-1-toggle:hover) .ss-1{
-  background-color: #fff5;
-  box-shadow: 0 0 1px 1px white;
-}
-.tracker-section:has(input.ss-2-toggle:hover) .ss-2{
-  background-color: #fff5;
-  box-shadow: 0 0 1px 1px white;
-}
-.tracker-section:has(input.ss-3-toggle:hover) .ss-3{
-  background-color: #fff5;
-  box-shadow: 0 0 1px 1px white;
-}
-.tracker-section:has(input.ss-4-toggle:hover) .ss-4{
-  background-color: #fff5;
-  box-shadow: 0 0 1px 1px white;
-}
-.tracker-section:has(input.ss-5-toggle:hover) .ss-5{
-  background-color: #fff5;
-  box-shadow: 0 0 1px 1px white;
-}
-.tracker-section:has(input.ss-6-toggle:hover) .ss-6{
-  background-color: #fff5;
-  box-shadow: 0 0 1px 1px white;
-}
-.tracker-section:has(input.ss-7-toggle:hover) .ss-7{
-  background-color: #fff5;
-  box-shadow: 0 0 1px 1px white;
+.inventory-table-area:has(.inventory-table-protoss) {
+    width: 400px;
+    background-color: #d2b260;
 }

-/* Progressive items */
-.progressive{
-  max-height: var(--icon-size);
-  display: contents;
+#tracker-table .inventory-table td{
+    width: 40px;
+    height: 40px;
+    text-align: center;
+    vertical-align: middle;
 }

-.lvl-0 > :nth-child(2),
-.lvl-0 > :nth-child(3),
-.lvl-0 > :nth-child(4),
-.lvl-0 > :nth-child(5){
-  display: none;
-}
-.lvl-1 > :nth-child(2),
-.lvl-1 > :nth-child(3),
-.lvl-1 > :nth-child(4),
-.lvl-1 > :nth-child(5){
-  display: none;
-}
-.lvl-2 > :nth-child(1),
-.lvl-2 > :nth-child(3),
-.lvl-2 > :nth-child(4),
-.lvl-2 > :nth-child(5){
-  display: none;
-}
-.lvl-3 > :nth-child(1),
-.lvl-3 > :nth-child(2),
-.lvl-3 > :nth-child(4),
-.lvl-3 > :nth-child(5){
-  display: none;
-}
-.lvl-4 > :nth-child(1),
-.lvl-4 > :nth-child(2),
-.lvl-4 > :nth-child(3),
-.lvl-4 > :nth-child(5){
-  display: none;
-}
-.lvl-5 > :nth-child(1),
-.lvl-5 > :nth-child(2),
-.lvl-5 > :nth-child(3),
-.lvl-5 > :nth-child(4){
-  display: none;
+.inventory-table td.title{
+    padding-top: 10px;
+    height: 20px;
+    font-family: "JuraBook", monospace;
+    font-size: 16px;
+    font-weight: bold;
 }

-/* Filler item counters */
-.item-counter{
-  display: table;
-  text-align: center;
-  padding: var(--item-class-padding);
-}
-.item-count{
-  display: table-cell;
-  vertical-align: middle;
-  padding-left: 3px;
-  padding-right: 15px;
+.inventory-table img{
+    height: 100%;
+    max-width: 40px;
+    max-height: 40px;
+    border: 1px solid #000000;
+    filter: grayscale(100%) contrast(75%) brightness(20%);
+    background-color: black;
 }

-/* Hidden items */
-.hidden-class:not(:has(.f:not(.unacquired))), .hidden-item{
-  display: none;
+.inventory-table img.acquired{
+    filter: none;
+    background-color: black;
 }

-/* Keys */
-#keys ol, #keys ul{
-  columns: 3;
-  -webkit-columns: 3;
-  -moz-columns: 3;
-}
-#keys li{
-  padding-right: 15pt;
+.inventory-table .tint-terran img.acquired {
+    filter: sepia(100%) saturate(300%) brightness(130%) hue-rotate(120deg)
 }

-/* Locations */
-#section-locations{
-    padding-left: 5px;
-}
-@media only screen and (min-width: 120ch){
-  #section-locations ul{
-    columns: 2;
-    -webkit-columns: 2;
-    -moz-columns: 2;
-  }
-}
-#locations li.checked{
-  list-style-type: "✔ ";
+.inventory-table .tint-protoss img.acquired {
+    filter: sepia(100%) saturate(1000%) brightness(110%) hue-rotate(180deg)
 }

-/* Allowing scrolling down a little further */
-.bottom-padding{
-  min-height: 33vh;
-}
+.inventory-table .tint-level-1 img.acquired {
+    filter: sepia(100%) saturate(1000%) brightness(110%) hue-rotate(60deg)
+}
+
+.inventory-table .tint-level-2 img.acquired {
+    filter: sepia(100%) saturate(1000%) brightness(110%) hue-rotate(60deg) hue-rotate(120deg)
+}
+
+.inventory-table .tint-level-3 img.acquired {
+    filter: sepia(100%) saturate(1000%) brightness(110%) hue-rotate(60deg) hue-rotate(240deg)
+}
+
+.inventory-table div.counted-item {
+    position: relative;
+}
+
+.inventory-table div.item-count {
+    width: 160px;
+    text-align: left;
+    color: black;
+    font-family: "JuraBook", monospace;
+    font-weight: bold;
+}
+
+#location-table{
+    border: 2px solid #000000;
+    border-radius: 4px;
+    background-color: #87b678;
+    padding: 10px 3px 3px;
+    font-family: "JuraBook", monospace;
+    font-size: 16px;
+    font-weight: bold;
+    cursor: default;
+}
+
+#location-table table{
+    width: 100%;
+}
+
+#location-table th{
+    vertical-align: middle;
+    text-align: left;
+    padding-right: 10px;
+}
+
+#location-table td{
+    padding-top: 2px;
+    padding-bottom: 2px;
+    line-height: 20px;
+}
+
+#location-table td.counter {
+    text-align: right;
+    font-size: 14px;
+}
+
+#location-table td.toggle-arrow {
+    text-align: right;
+}
+
+#location-table tr#Total-header {
+    font-weight: bold;
+}
+
+#location-table img{
+    height: 100%;
+    max-width: 30px;
+    max-height: 30px;
+}
+
+#location-table tbody.locations {
+    font-size: 16px;
+}
+
+#location-table td.location-name {
+    padding-left: 16px;
+}
+
+#location-table td:has(.location-column) {
+    vertical-align: top;
+}
+
+#location-table .location-column {
+    width: 100%;
+    height: 100%;
+}
+
+#location-table .location-column .spacer {
+    min-height: 24px;
+}
+
+.hide {
+    display: none;
+}
@@ -72,13 +72,3 @@ code{
    padding-right: 0.25rem;
    color: #000000;
 }
-
-code.grassy {
-    background-color: #b5e9a4;
-    border: 1px solid #2a6c2f;
-    white-space: preserve;
-    text-align: left;
-    display: block;
-    font-size: 14px;
-    line-height: 20px;
-}
@@ -13,7 +13,3 @@
    min-height: 360px;
    text-align: center;
 }
-
-h2, h4 {
-    color: #ffffff;
-}
@@ -98,7 +98,7 @@
                            <td>
                                {% if hint.finding_player == player %}
                                    <b>{{ player_names_with_alias[(team, hint.finding_player)] }}</b>
-                                {% elif get_slot_info(hint.finding_player).type == 2 %}
+                                {% elif get_slot_info(team, hint.finding_player).type == 2 %}
                                    <i>{{ player_names_with_alias[(team, hint.finding_player)] }}</i>
                                {% else %}
                                    <a href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=team, tracked_player=hint.finding_player) }}">
@@ -109,7 +109,7 @@
                            <td>
                                {% if hint.receiving_player == player %}
                                    <b>{{ player_names_with_alias[(team, hint.receiving_player)] }}</b>
-                                {% elif get_slot_info(hint.receiving_player).type == 2 %}
+                                {% elif get_slot_info(team, hint.receiving_player).type == 2 %}
                                    <i>{{ player_names_with_alias[(team, hint.receiving_player)] }}</i>
                                {% else %}
                                    <a href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=team, tracked_player=hint.receiving_player) }}">
@@ -58,7 +58,8 @@
                    Open Log File...
                </a>
            </div>
-        {%  set log, log_len = get_log() -%}
+        {%  set log = get_log() -%}
+        {%- set log_len = log | length - 1 if log.endswith("…") else log | length -%}
        <div id="logger" style="white-space: pre">{{ log }}</div>
        <script>
          let url = '{{ url_for('display_log', room = room.id) }}';
@@ -1,6 +1,6 @@
 {% block footer %}
    <footer id="island-footer">
-        <div id="copyright-notice">Copyright 2026 Archipelago</div>
+        <div id="copyright-notice">Copyright 2025 Archipelago</div>
        <div id="links">
            <a href="/sitemap">Site Map</a>
            -
@@ -45,15 +45,15 @@
                    {%- set current_sphere = loop.index %}
                    {%- for player, sphere_location_ids in sphere.items() %}
                        {%- set checked_locations = tracker_data.get_player_checked_locations(team, player) %}
-                        {%- set finder_game = tracker_data.get_player_game(player) %}
-                        {%- set player_location_data = tracker_data.get_player_locations(player) %}
+                        {%- set finder_game = tracker_data.get_player_game(team, player) %}
+                        {%- set player_location_data = tracker_data.get_player_locations(team, player) %}
                        {%- for location_id in sphere_location_ids.intersection(checked_locations) %}
                        <tr>
                            {%- set item_id, receiver, item_flags = player_location_data[location_id] %}
-                            {%- set receiver_game = tracker_data.get_player_game(receiver) %}
+                            {%- set receiver_game = tracker_data.get_player_game(team, receiver) %}
                            <td>{{ current_sphere }}</td>
-                            <td>{{ tracker_data.get_player_name(player) }}</td>
-                            <td>{{ tracker_data.get_player_name(receiver) }}</td>
+                            <td>{{ tracker_data.get_player_name(team, player) }}</td>
+                            <td>{{ tracker_data.get_player_name(team, receiver) }}</td>
                            <td>{{ tracker_data.item_id_to_name[receiver_game][item_id] }}</td>
                            <td>{{ tracker_data.location_id_to_name[finder_game][location_id] }}</td>
                            <td>{{ finder_game }}</td>
@@ -22,14 +22,14 @@
                -%}
                    <tr>
                        <td>
-                            {% if get_slot_info(hint.finding_player).type == 2 %}
+                            {% if get_slot_info(team, hint.finding_player).type == 2 %}
                                <i>{{ player_names_with_alias[(team, hint.finding_player)] }}</i>
                            {% else %}
                                {{ player_names_with_alias[(team, hint.finding_player)] }}
                            {% endif %}
                        </td>
                        <td>
-                            {% if get_slot_info(hint.receiving_player).type == 2 %}
+                            {% if get_slot_info(team, hint.receiving_player).type == 2 %}
                                <i>{{ player_names_with_alias[(team, hint.receiving_player)] }}</i>
                            {% else %}
                                {{ player_names_with_alias[(team, hint.receiving_player)] }}
@@ -55,9 +55,6 @@
    {{ OptionTitle(option_name, option) }}
    <div class="named-range-container">
        <select id="{{ option_name }}-select" name="{{ option_name }}" data-option-name="{{ option_name }}" {{ "disabled" if option.default == "random" }}>
-            {% if option.default not in option.special_range_names.values() %}
-                <option value="{{ option.default }}" selected>Default ({{ option.default }})</option>
-            {% endif %}
            {% for key, val in option.special_range_names.items() %}
                {% if option.default == val %}
                    <option value="{{ val }}" selected>{{ key|replace("_", " ")|title }} ({{ val }})</option>
@@ -97,9 +94,6 @@
    <div class="text-choice-container">
        <div class="text-choice-wrapper">
            <select id="{{ option_name }}" name="{{ option_name }}" {{ "disabled" if option.default == "random" }}>
-            {% if option.default not in option.options.values()  %}
-                <option value="{{ option.default }}" selected>Default ({{ option.default }})</option>
-            {% endif %}
            {% for id, name in option.name_lookup.items()|sort %}
                {% if name != "random" %}
                    {% if option.default == id %}
@@ -140,7 +134,6 @@

 {% macro OptionList(option_name, option) %}
    {{ OptionTitle(option_name, option) }}
-    <input type="hidden" id="{{ option_name }}-{{ key }}-hidden" name="{{ option_name }}" value="_ensure-empty-list"/>
    <div class="option-container">
        {% for key in (option.valid_keys if option.valid_keys is ordered else option.valid_keys|sort) %}
            <div class="option-entry">
@@ -153,7 +146,6 @@

 {% macro LocationSet(option_name, option) %}
    {{ OptionTitle(option_name, option) }}
-    <input type="hidden" id="{{ option_name }}-{{ key }}-hidden" name="{{ option_name }}" value="_ensure-empty-list"/>
    <div class="option-container">
        {% for group_name in world.location_name_groups.keys()|sort %}
            {% if group_name != "Everywhere" %}
@@ -177,7 +169,6 @@

 {% macro ItemSet(option_name, option) %}
    {{ OptionTitle(option_name, option) }}
-    <input type="hidden" id="{{ option_name }}-{{ key }}-hidden" name="{{ option_name }}" value="_ensure-empty-list"/>
    <div class="option-container">
        {% for group_name in world.item_name_groups.keys()|sort %}
            {% if group_name != "Everything" %}
@@ -201,7 +192,6 @@

 {% macro OptionSet(option_name, option) %}
    {{ OptionTitle(option_name, option) }}
-    <input type="hidden" id="{{ option_name }}-{{ key }}-hidden" name="{{ option_name }}" value="_ensure-empty-list"/>
    <div class="option-container">
        {% for key in (option.valid_keys if option.valid_keys is ordered else option.valid_keys|sort) %}
            <div class="option-entry">
@@ -4,20 +4,16 @@

 {% block head %}
    <title>Generation failed, please retry.</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/waitSeed.css') }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/waitSeed.css") }}"/>
 {% endblock %}

 {% block body %}
    {% include 'header/oceanIslandHeader.html' %}
    <div id="wait-seed-wrapper" class="grass-island">
        <div id="wait-seed">
-            <h1>Generation Failed</h1>
-            <h2>Please try again!</h2>
-            <p>{{ seed_error }}</p>
-            <h4>More details:</h4>
-            <p>
-                <code class="grassy">{{ details }}</code>
-            </p>
+            <h1>Generation failed</h1>
+			<h2>please retry</h2>
+            {{ seed_error }}
        </div>
    </div>
 {% endblock %}
@@ -11,32 +11,32 @@
        <h1>Site Map</h1>
        <h2>Base Pages</h2>
        <ul>
-            <li><a href="{{ url_for('discord') }}">Discord Link</a></li>
-            <li><a href="{{ url_for('faq', lang='en') }}">F.A.Q. Page</a></li>
-            <li><a href="{{ url_for('favicon') }}">Favicon</a></li>
-            <li><a href="{{ url_for('generate') }}">Generate Game Page</a></li>
-            <li><a href="{{ url_for('landing') }}">Homepage</a></li>
-            <li><a href="{{ url_for('uploads') }}">Host Game Page</a></li>
-            <li><a href="{{ url_for('get_datapackage') }}">Raw Data Package</a></li>
-            <li><a href="{{ url_for('check') }}">Settings Validator</a></li>
-            <li><a href="{{ url_for('get_sitemap') }}">Site Map</a></li>
-            <li><a href="{{ url_for('start_playing') }}">Start Playing</a></li>
-            <li><a href="{{ url_for('games') }}">Supported Games Page</a></li>
-            <li><a href="{{ url_for('tutorial_landing') }}">Tutorials Page</a></li>
-            <li><a href="{{ url_for('user_content') }}">User Content</a></li>
-            <li><a href="{{ url_for('stats') }}">Game Statistics</a></li>
-            <li><a href="{{ url_for('glossary', lang='en') }}">Glossary</a></li>
-            <li><a href="{{ url_for('show_session') }}">Session / Login</a></li>
+            <li><a href="/discord">Discord Link</a></li>
+            <li><a href="/faq/en">F.A.Q. Page</a></li>
+            <li><a href="/favicon.ico">Favicon</a></li>
+            <li><a href="/generate">Generate Game Page</a></li>
+            <li><a href="/">Homepage</a></li>
+            <li><a href="/uploads">Host Game Page</a></li>
+            <li><a href="/datapackage">Raw Data Package</a></li>
+            <li><a href="{{ url_for('check')}}">Settings Validator</a></li>
+            <li><a href="/sitemap">Site Map</a></li>
+            <li><a href="/start-playing">Start Playing</a></li>
+            <li><a href="/games">Supported Games Page</a></li>
+            <li><a href="/tutorial">Tutorials Page</a></li>
+            <li><a href="/user-content">User Content</a></li>
+            <li><a href="{{url_for('stats')}}">Game Statistics</a></li>
+            <li><a href="/glossary/en">Glossary</a></li>
+            <li><a href="{{url_for("show_session")}}">Session / Login</a></li>
        </ul>

        <h2>Tutorials</h2>
        <ul>
-            <li><a href="{{ url_for('tutorial', game='Archipelago', file='setup_en') }}">Multiworld Setup Tutorial</a></li>
-            <li><a href="{{ url_for('tutorial', game='Archipelago', file='mac_en') }}">Setup Guide for Mac</a></li>
-            <li><a href="{{ url_for('tutorial', game='Archipelago', file='commands_en') }}">Server and Client Commands</a></li>
-            <li><a href="{{ url_for('tutorial', game='Archipelago', file='advanced_settings_en') }}">Advanced YAML Guide</a></li>
-            <li><a href="{{ url_for('tutorial', game='Archipelago', file='triggers_en') }}">Triggers Guide</a></li>
-            <li><a href="{{ url_for('tutorial', game='Archipelago', file='plando_en') }}">Plando Guide</a></li>
+            <li><a href="/tutorial/Archipelago/setup/en">Multiworld Setup Tutorial</a></li>
+            <li><a href="/tutorial/Archipelago/mac/en">Setup Guide for Mac</a></li>
+            <li><a href="/tutorial/Archipelago/commands/en">Server and Client Commands</a></li>
+            <li><a href="/tutorial/Archipelago/advanced_settings/en">Advanced YAML Guide</a></li>
+            <li><a href="/tutorial/Archipelago/triggers/en">Triggers Guide</a></li>
+            <li><a href="/tutorial/Archipelago/plando/en">Plando Guide</a></li>
        </ul>

        <h2>Game Info Pages</h2>
@@ -31,11 +31,6 @@
    {% include 'header/oceanHeader.html' %}
    <div id="games" class="markdown">
        <h1>Currently Supported Games</h1>
-        <p>Below are the games that are currently included with the Archipelago software. To play a game that is not on
-        this page, please refer to the <a href="/tutorial/Archipelago/setup/en#playing-with-custom-worlds">playing with
-                custom worlds</a> section of the setup guide and the
-            <a href="{{ url_for("tutorial", game="Archipelago", file="other_en") }}">other games and tools guide</a>
-            to find more.</p>
        <div class="js-only">
            <label for="game-search">Search for your game below!</label><br />
            <div class="page-controls">
@@ -68,9 +63,6 @@
            <a href="{{ world.web.bug_report_page }}">Report a Bug</a>
            {% endif %}
        </details>
-        {% if "authors" in world.manifest %}
-        <p>Authors: {{ world.manifest["authors"] | join(", ") }}</p>
-        {% endif %}
        {% endfor %}
    </div>
 {% endblock %}
@@ -20,7 +20,11 @@
                {% for file_name, file_data in tutorial_data.files.items() %}
                    <li>
                        <a href="{{ url_for("tutorial", game=world_name, file=file_name) }}">{{ file_data.language }}</a>
-                        by {{ file_data.authors | join(", ") }}
+                        by
+                        {% for author in file_data.authors %}
+                            {{ author }}
+                            {% if not loop.last %}, {% endif %}
+                        {% endfor %}
                    </li>
                {% endfor %}
            </ul>
@@ -71,10 +71,10 @@
    <div class="hint-text">
        This option allows custom values only. Please enter your desired values below.
        <div class="custom-value-wrapper">
-            <input type="text" class="custom-value" data-option="{{ option_name }}" placeholder="Custom Value" />
-            <button type="button" class="add-range-option-button" data-option="{{ option_name }}">Add</button>
+            <input class="custom-value" data-option="{{ option_name }}" placeholder="Custom Value" />
+            <button type="button" data-option="{{ option_name }}">Add</button>
        </div>
-        <table class="range-rows" data-option="{{ option_name }}">
+        <table>
            <tbody>
                {% if option.default %}
                    {{ RangeRow(option_name, option, option.default, option.default) }}
@@ -88,11 +88,11 @@
    <div class="hint-text">
        Custom values are also allowed for this option. To create one, enter it into the input box below.
        <div class="custom-value-wrapper">
-            <input type="text" class="custom-value" data-option="{{ option_name }}" placeholder="Custom Value" />
-            <button type="button" class="add-range-option-button" data-option="{{ option_name }}">Add</button>
+            <input class="custom-value" data-option="{{ option_name }}" placeholder="Custom Value" />
+            <button type="button" data-option="{{ option_name }}">Add</button>
        </div>
    </div>
-    <table class="range-rows" data-option="{{ option_name }}">
+    <table>
        <tbody>
            {% for id, name in option.name_lookup.items() %}
                {% if name != 'random' %}
@@ -139,7 +139,6 @@
 {% endmacro %}

 {% macro OptionList(option_name, option) %}
-    <input type="hidden" id="{{ option_name }}-{{ key }}-hidden" name="{{ option_name }}" value="_ensure-empty-list"/>
    <div class="list-container">
        {% for key in (option.valid_keys if option.valid_keys is ordered else option.valid_keys|sort) %}
            <div class="list-entry">
@@ -159,7 +158,6 @@
 {% endmacro %}

 {% macro LocationSet(option_name, option, world) %}
-    <input type="hidden" id="{{ option_name }}-{{ key }}-hidden" name="{{ option_name }}" value="_ensure-empty-list"/>
    <div class="set-container">
        {% for group_name in world.location_name_groups.keys()|sort %}
            {% if group_name != "Everywhere" %}
@@ -182,7 +180,6 @@
 {% endmacro %}

 {% macro ItemSet(option_name, option, world) %}
-    <input type="hidden" id="{{ option_name }}-{{ key }}-hidden" name="{{ option_name }}" value="_ensure-empty-list"/>
    <div class="set-container">
        {% for group_name in world.item_name_groups.keys()|sort %}
            {% if group_name != "Everything" %}
@@ -205,7 +202,6 @@
 {% endmacro %}

 {% macro OptionSet(option_name, option) %}
-    <input type="hidden" id="{{ option_name }}-{{ key }}-hidden" name="{{ option_name }}" value="_ensure-empty-list"/>
    <div class="set-container">
        {% for key in (option.valid_keys if option.valid_keys is ordered else option.valid_keys|sort) %}
            <div class="set-entry">
@@ -20,8 +20,6 @@ from worlds.tloz.Items import item_game_ids
 from worlds.tloz.Locations import location_ids
 from worlds.tloz import Items, Locations, Rom

-from settings import get_settings
-
 SYSTEM_MESSAGE_ID = 0

 CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart connector_tloz.lua"
@@ -289,7 +287,7 @@ async def nes_sync_task(ctx: ZeldaContext):
                    if not ctx.auth:
                        ctx.auth = ''.join([chr(i) for i in data_decoded['playerName'] if i != 0])
                        if ctx.auth == '':
-                            logger.info("Invalid ROM detected. No player name built into the ROM. Please regenerate "
+                            logger.info("Invalid ROM detected. No player name built into the ROM. Please regenerate"
                                        "the ROM using the same link but adding your slot name")
                        if ctx.awaiting_rom:
                            await ctx.server_auth(False)
@@ -343,12 +341,13 @@ if __name__ == '__main__':
    # Text Mode to use !hint and such with games that have no text entry
    Utils.init_logging("ZeldaClient")

-    DISPLAY_MSGS = get_settings()["tloz_options"]["display_msgs"]
+    options = Utils.get_options()
+    DISPLAY_MSGS = options["tloz_options"]["display_msgs"]


    async def run_game(romfile: str) -> None:
        auto_start = typing.cast(typing.Union[bool, str],
-                                 get_settings()["tloz_options"].get("rom_start", True))
+                                 Utils.get_options()["tloz_options"].get("rom_start", True))
        if auto_start is True:
            import webbrowser
            webbrowser.open(romfile)
@@ -1,2 +0,0 @@
-pytest>=9.0.1,<10  # this includes subtests support
-pytest-xdist>=3.8.0
@@ -1,13 +0,0 @@
-# This file specifies patterns that are ignored by default for any world built with the "Build APWorlds" component.
-# These patterns can be overriden by a world-specific .apignore using !-prefixed patterns for negation.
-
-# Auto-created folders
-__MACOSX
-.DS_Store
-__pycache__
-
-# Unneeded files
-/archipelago.json
-/.apignore
-/.git
-/.gitignore
@@ -220,11 +220,8 @@
 <MessageBoxLabel>:
    theme_text_color: "Custom"
    text_color: 1, 1, 1, 1
-<MessageBox>:
-    height: self.content.texture_size[1] + 80
 <ScrollBox>:
    layout: layout
-    box_height: dp(100)
    bar_width: "12dp"
    scroll_wheel_distance: 40
    do_scroll_x: False
@@ -235,11 +232,9 @@
        orientation: "vertical"
        spacing: 10
        size_hint_y: None
-        height: max(self.minimum_height, root.box_height)
-
+        height: self.minimum_height
 <MessageBoxLabel>:
    valign: "middle"
    halign: "center"
    text_size: self.width, None
    height: self.texture_size[1]
-
@@ -140,15 +140,6 @@ MDFloatLayout:

            MDNavigationDrawerDivider:

-            MDBoxLayout:
-                orientation: "horizontal"
-                MDIconButton:
-                    icon: "alert" if app.failed_worlds else ""
-                    theme_text_color: "Custom"
-                    text_color: "D23C42"
-                    disabled: not app.failed_worlds
-                    on_release: app.display_failed()
-

        MDGridLayout:
            id: main_layout
@@ -28,21 +28,17 @@
 name: Player{number}

 # Used to describe your yaml. Useful if you have multiple files.
-description: {{ yaml_dump("%s Preset for %s" % (preset_name, game)) if preset_name else yaml_dump("Default %s Template" % game) }}
+description: {{ yaml_dump("Default %s Template" % game) }}

 game: {{ yaml_dump(game) }}
 requires:
  version: {{ __version__ }} # Version of Archipelago required for this yaml to work as expected.
-  {%- if world_version != "0.0.0" %}
-  game:
-    {{ yaml_dump(game) }}: {{ world_version }} # Version of the world required for this yaml to work as expected.
-  {%- endif %}

-{%- macro range_option(option, option_val) %}
+{%- macro range_option(option) %}
    # You can define additional values between the minimum and maximum values.
    # Minimum value is {{ option.range_start }}
    # Maximum value is {{ option.range_end }}
-    {%- set data, notes = dictify_range(option, option_val) %}
+    {%- set data, notes = dictify_range(option) %}
    {%- for entry, default in data.items() %}
    {{ entry }}: {{ default }}{% if notes[entry] %} # {{ notes[entry] }}{% endif %}
    {%- endfor -%}
@@ -56,10 +52,6 @@ requires:

  {%- for option_key, option in group_options.items() %}
  {{ option_key }}:
-    {%- set option_val = option.default %}
-    {%- if option_key in preset %}
-      {%- set option_val = preset[option_key] %}
-    {%- endif -%}
    {%- if option.__doc__ %}
    # {{ cleandoc(option.__doc__)
        | trim
@@ -73,25 +65,25 @@ requires:
    {%- endif -%}

    {%- if option.range_start is defined and option.range_start is number %}
-    {{- range_option(option, option_val) -}}
+    {{- range_option(option) -}}

    {%- elif option.options -%}
    {%- for suboption_option_id, sub_option_name in option.name_lookup.items() %}
-    {{ yaml_dump(sub_option_name) }}: {% if suboption_option_id == option_val or sub_option_name == option_val %}50{% else %}0{% endif %}
+    {{ yaml_dump(sub_option_name) }}: {% if suboption_option_id == option.default %}50{% else %}0{% endif %}
    {%- endfor -%}
-  
-    {%- if option.name_lookup[option_val] not in option.options and option_val not in option.options %}
-    {{ yaml_dump(option_val) }}: 50
+
+    {%- if option.name_lookup[option.default] not in option.options %}
+    {{ yaml_dump(option.default) }}: 50
    {%- endif -%}

-    {%- elif option_val is string %}
-    {{ yaml_dump(option_val) }}: 50
+    {%- elif option.default is string %}
+    {{ yaml_dump(option.default) }}: 50

-    {%- elif option_val is iterable and option_val is not mapping %}
-    {{ option_val | list }}
+    {%- elif option.default is iterable and option.default is not mapping %}
+    {{ option.default | list }}

    {%- else %}
-    {{ yaml_dump(option_val) | indent(4, first=false) }}
+    {{ yaml_dump(option.default) | indent(4, first=false) }}
    {%- endif -%}
    {{ "\n" }}
  {%- endfor %}
@@ -1,174 +0,0 @@
-<VisualRange>:
-    id: this
-    spacing: 15
-    orientation: "horizontal"
-    slider: slider
-    tag: tag
-    MDLabel:
-        id: tag
-        text: str(this.option.default) if not isinstance(this.option.default, str) else str(this.option.range_start)
-    MDSlider:
-        id: slider
-        min: this.option.range_start
-        max: this.option.range_end
-        value: min(max(this.option.default, this.option.range_start), this.option.range_end) if not isinstance(this.option.default, str) else this.option.range_start
-        step: 1
-        step_point_size: 0
-        MDSliderHandle:
-
-        MDSliderValueLabel:
-
-<VisualChoice>:
-    id: this
-    text: text
-    MDButtonText:
-        id: text
-        text: this.option.get_option_name(this.option.default if not isinstance(this.option.default, str) else list(this.option.options.values())[0])
-        theme_text_color: "Primary"
-
-<VisualNamedRange>:
-    id: this
-    orientation: "horizontal"
-    spacing: "10dp"
-    padding: (0, 0, "10dp", 0)
-    choice: choice
-
-    MDButton:
-        id: choice
-        text: text
-        MDButtonText:
-            id: text
-            text: this.option.default.title() if this.option.default in this.option.special_range_names else "Custom"
-
-<VisualFreeText>:
-    multiline: False
-    font_size: "15sp"
-    text: self.option.default if isinstance(self.option.default, str) else ""
-    theme_height: "Custom"
-    height: "30dp"
-
-
-<VisualTextChoice>:
-    id: this
-    orientation: "horizontal"
-    spacing: "5dp"
-    padding: (0, 0, "10dp", 0)
-
-<VisualToggle>:
-    id: this
-    button: button
-    MDIconButton:
-        id: button
-        icon: "checkbox-outline" if this.option.default else "checkbox-blank-outline"
-
-<VisualListSetEntry@ResizableTextField>:
-    height: "20dp"
-
-<CounterItemValue>:
-    height: "30dp"
-
-<VisualListSetCounter>:
-    id: this
-    scrollbox: scrollbox
-    add: add
-    save: save
-    input: input
-    focus_behavior: False
-
-    MDDialogHeadlineText:
-        text: getattr(this.option, "display_name", this.name)
-
-    MDDialogSupportingText:
-        text: "Add or Remove Entries"
-
-    MDDialogContentContainer:
-        orientation: "vertical"
-        spacing: 10
-
-        MDBoxLayout:
-            orientation: "horizontal"
-            VisualListSetEntry:
-                id: input
-                height: "20dp"
-
-            MDIconButton:
-                id: add
-                icon: "plus"
-                theme_height: "Custom"
-                height: "20dp"
-                on_press: root.validate_add(input)
-
-        ScrollBox:
-            id: scrollbox
-            size_hint_y: None
-            adapt_minimum: False
-
-        MDButton:
-            id: save
-            MDButtonText:
-                text: "Save Changes"
-
-ContainerLayout:
-    md_bg_color: app.theme_cls.backgroundColor
-
-    MainLayout:
-        id: main
-        cols: 3
-        padding: 3, 5, 0, 3
-        spacing: "2dp"
-
-        ScrollBox:
-            id: scrollbox
-            size_hint_x: None
-            width: "150dp"
-
-        MDDivider:
-            orientation: "vertical"
-            width: "4dp"
-
-        MainLayout:
-            id: player_layout
-            rows: 2
-            spacing: "20dp"
-
-            MDBoxLayout:
-                id: player_options
-                orientation: "horizontal"
-                height: "75dp"
-                size_hint_y: None
-                padding: ["10dp", "30dp", "10dp", 0]
-                spacing: "10dp"
-
-                ResizableTextField:
-                    id: player_name
-                    multiline: False
-
-                    MDTextFieldHintText:
-                        text: "Player Name"
-
-                    MDTextFieldMaxLengthText:
-                        max_text_length: 16
-
-                MDBoxLayout:
-                    orientation: "vertical"
-                    spacing: "15dp"
-
-                    MDLabel:
-                        id: game
-                        text: "Game: None"
-                        pos_hint: {"center_x": 0.5, "center_y": 0.5}
-
-                    MDButton:
-                        pos_hint: {"center_x": 0.5, "center_y": 0.5}
-                        on_press: app.export_options(self)
-                        theme_width: "Custom"
-                        size_hint_y: 1
-                        size_hint_x: 1
-
-                        MDButtonText:
-                            pos_hint: {"center_x": 0.5, "center_y": 0.5}
-                            text: "Export Options"
-
-            MainLayout:
-                cols: 1
-                id: options
@@ -0,0 +1,7 @@
+author: Nintendo
+data: null
+game: A Link to the Past
+min_format_version: 1
+name: Link
+format_version: 1
+sprite_version: 1
@@ -0,0 +1,2 @@
+*
+!.gitignore
@@ -8,7 +8,3 @@ SELFLAUNCH: false
 # Host Address.  This is the address encoded into the patch that will be used for client auto-connect.
 # Set as your local IP (192.168.x.x) to serve over LAN.
 HOST_ADDRESS: localhost
-
-# Asset redistribution rights.  If true, the host affirms they have been given explicit permission to redistribute
-# the proprietary assets in WebHostLib
-#ASSET_RIGHTS: false
@@ -41,8 +41,16 @@ http {
    # server_name example.com www.example.com;

    keepalive_timeout 5;
-    
+
+    # path for static files
+    root /app/WebHostLib;
+
    location / {
+      # checks for static file, if not found proxy to app
+      try_files $uri @proxy_to_app;
+    }
+
+    location @proxy_to_app {
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;
      proxy_set_header Host $http_host;
@@ -52,15 +60,5 @@ http {

      proxy_pass http://app_server;
    }
-
-    location /static/ {
-      root /app/WebHostLib/;
-      autoindex off;
-    }
-
-    location = /favicon.ico {
-      alias /app/WebHostLib/static/static/favicon.ico;
-      access_log off;
-    }
  }
 }
@@ -15,14 +15,15 @@
 # A Link to the Past
 /worlds/alttp/ @Berserker66

-# APQuest
-# NewSoupVi is acting maintainer, but world belongs to core with the exception of the music
-/worlds/apquest/ @NewSoupVi
-
+# Sudoku (APSudoku)
+/worlds/apsudoku/ @EmilyV99

 # Aquaria
 /worlds/aquaria/ @tioui

+# ArchipIDLE
+/worlds/archipidle/ @LegendaryLinux
+
 # Blasphemous
 /worlds/blasphemous/ @TRPG0

@@ -41,21 +42,18 @@
 # Celeste 64
 /worlds/celeste64/ @PoryGone

-# Celeste (Open World)
-/worlds/celeste_open_world/ @PoryGone
-
 # ChecksFinder
 /worlds/checksfinder/ @SunCatMC

-# Choo-Choo Charles
-/worlds/cccharles/ @Yaranorgoth
-
 # Civilization VI
 /worlds/civ6/ @hesto2

 # Dark Souls III
 /worlds/dark_souls_3/ @Marechal-L @nex3

+# Donkey Kong Country 3
+/worlds/dkc3/ @PoryGone
+
 # DLCQuest
 /worlds/dlcquest/ @axe-y @agilbert1412

@@ -65,18 +63,12 @@
 # DOOM II
 /worlds/doom_ii/ @Daivuk @KScl

-# EarthBound
-/worlds/earthbound/ @PinkSwitch
-
 # Factorio
 /worlds/factorio/ @Berserker66

 # Faxanadu
 /worlds/faxanadu/ @Daivuk

-# Final Fantasy (1)
-/worlds/ff1/ @Rosalie-A
-
 # Final Fantasy Mystic Quest
 /worlds/ffmq/ @Alchav @wildham0

@@ -129,9 +121,6 @@
 # Mega Man 2
 /worlds/mm2/ @Silvris

-# Mega Man 3
-/worlds/mm3/ @Silvris
-
 # MegaMan Battle Network 3
 /worlds/mmbn3/ @digiholic

@@ -177,12 +166,8 @@
 # Sonic Adventure 2 Battle
 /worlds/sa2b/ @PoryGone @RaspberrySpace

-# Satisfactory
-/worlds/satisfactory/ @Jarno458 @budak7273
-
 # Starcraft 2
-# Note: @Ziktofel acts as a mentor
-/worlds/sc2/ @MatthewMarinets @Snarkie @SirChuckOfTheChuckles
+/worlds/sc2/ @Ziktofel

 # Super Metroid
 /worlds/sm/ @lordlou
@@ -253,6 +238,9 @@
 # compatibility, these worlds may be deleted. If you are interested in stepping up as maintainer for
 # any of these worlds, please review `/docs/world maintainer.md` documentation.

+# Final Fantasy (1)
+# /worlds/ff1/
+
 # Ocarina of Time
 # /worlds/oot/

@@ -17,8 +17,7 @@ it will not be detailed here.
 The client is an intermediary program between the game and the Archipelago server. This can either be a direct
 modification to the game, an external program, or both. This can be implemented in nearly any modern language, but it
 must fulfill a few requirements in order to function as expected. Libraries for most modern languages and the spec for 
-various packets can be found in the [network protocol](/docs/network%20protocol.md) API reference document. Additional help with specific game
-engines and rom formats can be found in the #ap-modding-help channel in the [Discord](https://archipelago.gg/discord).
+various packets can be found in the [network protocol](/docs/network%20protocol.md) API reference document.

 ### Hard Requirements

@@ -63,38 +62,18 @@ if possible.
 * If your client appears in the Archipelago Launcher, you may define an icon for it that differentiates it from
  other clients. The icon size is 48x48 pixels, but smaller or larger images will scale to that size.

-### Launcher Integration
-
-If you have a python client or want to utilize the integration features of the Archipelago Launcher (ex. Slot links in
-webhost) you can define a Component to be a part of the Launcher. `LauncherComponents.components` can be appended to
-with additional Components in order to automatically add them to the Launcher. Most Components only need a
-`display_name` and `func`, but `supports_uri` and `game_name` can be defined to support launching by webhost links,
-`icon` and `description` can be used to customize display in the Launcher UI, and `file_identifier` can be used to
-launch by file.
-
-Additionally, if you use `func` you have access to LauncherComponent.launch or launch_subprocess to run your
-function as a subprocesses that can be utilized side by side other clients.
-```py
-def my_func(*args: str):
-	from .client import run_client
-	LauncherComponent.launch(run_client, name="My Client", args=args)
-```
-
-
 ## World

 The world is your game integration for the Archipelago generator, webhost, and multiworld server. It contains all the
 information necessary for creating the items and locations to be randomized, the logic for item placement, the 
 datapackage information so other game clients can recognize your game data, and documentation. Your world must be
 written as a Python package to be loaded by Archipelago. This is currently done by creating a fork of the Archipelago
-repository and creating a new world package in `/worlds/` (see [running from source](/docs/running%20from%20source.md)
-for setup).
+repository and creating a new world package in `/worlds/`. 

 The base World class can be found in [AutoWorld](/worlds/AutoWorld.py). Methods available for your world to call 
 during generation can be found in [BaseClasses](/BaseClasses.py) and [Fill](/Fill.py). Some examples and documentation 
-regarding the API can be found in the [world api doc](/docs/world%20api.md), and the [APQuest](/worlds/apquest/) world
-is a complete world implementation that functions as an introduction to world development. Before publishing, make sure
-to also check out [world maintainer.md](/docs/world%20maintainer.md).
+regarding the API can be found in the [world api doc](/docs/world%20api.md). Before publishing, make sure to also 
+check out [world maintainer.md](/docs/world%20maintainer.md).

 ### Hard Requirements

@@ -142,8 +121,8 @@ if possible.

 * An implementation of
  [get_filler_item_name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L473)
-  * By default, this function chooses any item name from `item_name_to_id`, which may include items you consider
-  "non-repeatable".
+  * By default, this function chooses any item name from `item_name_to_id`, so you want to limit it to only the true
+    filler items.
 * An `options_dataclass` defining the options players have available to them
  * This should be accompanied by a type hint for `options` with the same class name
 * A [bug report page](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L220)
@@ -1,110 +1,35 @@
-# APWorld Specification
+# apworld Specification

 Archipelago depends on worlds to provide game-specific details like items, locations and output generation.
-These are called "APWorlds".
-They are located in the `worlds/` folder (source) or `<install dir>/lib/worlds/` (when installed).
+Those are located in the `worlds/` folder (source) or `<install dir>/lib/worlds/` (when installed).
 See [world api.md](world%20api.md) for details.
-APWorlds can either be a folder, or they can be packaged as an .apworld file.

-## .apworld File Format
+apworld provides a way to package and ship a world that is not part of the main distribution by placing a `*.apworld`
+file into the worlds folder.

-The `.apworld` file format provides a way to package and ship an APWorld that is not part of the main distribution
-by placing a `*.apworld` file into the worlds folder.
+**Warning:** apworlds have to be all lower case, otherwise they raise a bogus Exception when trying to import in frozen python 3.10+!

-`.apworld` files are zip archives, all lower case, with the file ending `.apworld`.
+
+## File Format
+
+apworld files are zip archives, all lower case, with the file ending `.apworld`.
 The zip has to contain a folder with the same name as the zip, case-sensitive, that contains what would normally be in
 the world's folder in `worlds/`. I.e. `worlds/ror2.apworld` containing `ror2/__init__.py`.

-**Warning:** `.apworld` files have to be all lower case,
-otherwise they raise a bogus Exception when trying to import in frozen python 3.10+!

 ## Metadata

-Metadata about the APWorld is defined in an `archipelago.json` file.
+No metadata is specified yet.

-If the APWorld is a folder, the only required field is "game":
-```json
-{
-  "game": "Game Name"
-}
-```

-There are also the following optional fields:
-* `minimum_ap_version` and `maximum_ap_version` - which if present will each be compared against the current
-  Archipelago version respectively to filter those files from being loaded.
-* `world_version` - an arbitrary version for that world in order to only load the newest valid world.
-  An APWorld without a world_version is always treated as older than one with a version
-  (**Must** use exactly the format `"major.minor.build"`, e.g. `1.0.0`)
-* `authors` - a list of authors of the world. Displayed in user-facing places like the Supported Games page
-  on WebHost. Should always be a list of strings.
+## Extra Data

-If the APWorld is packaged as an `.apworld` zip file, it also needs to have `version` and `compatible_version`,
-which refer to the version of the APContainer packaging scheme defined in [Files.py](../worlds/Files.py).  
-These get automatically added to the `archipelago.json` of an .apworld if it is packaged using the 
-["Build APWorlds" launcher component](#build-apworlds-launcher-component),
-which is the correct way to package your `.apworld` as a world developer. Do not write these fields yourself.
+The zip can contain arbitrary files in addition what was specified above.

-### "Build APWorlds" Launcher Component
-
-In the Archipelago Launcher (on [source only](/docs/running%20from%20source.md)), there is a "Build APWorlds"
-component that will package all world folders to `.apworld`, and add `archipelago.json` manifest files to them.  
-These .apworld files will be output to `build/apworlds` (relative to the Archipelago root directory).  
-The `archipelago.json` file in each .apworld will automatically include the appropriate
-`version` and `compatible_version`.  
-The component can also be called from the command line to allow for specifying a certain list of worlds to build.
-For example, running `Launcher.py "Build APWorlds" -- "Game Name"` will build only the game called `Game Name`.
-
-If a world folder has an `archipelago.json` in its root, any fields it contains will be carried over.  
-So, a world folder with an `archipelago.json` that looks like this:
-
-```json
-{
-    "game": "Game Name",
-    "minimum_ap_version": "0.6.4",
-    "world_version": "2.1.4",
-    "authors": ["NewSoupVi"]
-}
-```
-
-will be packaged into an `.apworld` with a manifest file inside of it that looks like this:
-
-```json
-{
-    "minimum_ap_version": "0.6.4", 
-    "world_version": "2.1.4",
-    "authors": ["NewSoupVi"],
-    "version": 7,
-    "compatible_version": 7,
-    "game": "Game Name"
-}
-```
-
-This is the recommended workflow for packaging your world to an `.apworld`.
-
-### .apignore Exclusions
-
-By default, any additional files inside of the world folder will be packaged into the resulting `.apworld` archive and
-can then be read by the world. However, if there are any other files that aren't needed in the resulting `.apworld`, you
-can automatically prevent the build component from including them by specifying them in a file called `.apignore` inside
-the root of the world folder.
-
-The `.apignore` file selects files in the same way as the `.gitignore` format with patterns separated by line describing
-which files to ignore. For example, an `.apignore` like this:
-
-```gitignore
-*.iso
-scripts/
-!scripts/needed.py
-```
-
-would ignore any `.iso` files and anything in the scripts folder except for `scripts/needed.py`.
-
-Some exclusions are made by default for all worlds such as `__pycache__` folders. These are listed in the
-`GLOBAL.apignore` file inside of the `data` directory.

 ## Caveats

-Imports from other files inside the APWorld have to use relative imports. e.g. `from .options import MyGameOptions`
+Imports from other files inside the apworld have to use relative imports. e.g. `from .options import MyGameOptions`

 Imports from AP base have to use absolute imports, e.g. `from Options import Toggle` or
 `from worlds.AutoWorld import World`
@@ -6,49 +6,6 @@ including [Contributing](contributing.md), [Adding Games](<adding games.md>), an

 ---

-### I've never added a game to Archipelago before. Should I start with the APWorld or the game client?
-
-Strictly speaking, this is a false dichotomy: we do *not* recommend doing 100% of client work before the APWorld,
-or 100% of APWorld work before the client. It's important to iterate on both parts and test them together.
-However, the early iterations tend to be very similar for most games,
-so the typical recommendation for first-time AP developers is:
-
- Start with a proof-of-concept for [the game client](adding%20games.md#client)
-  - Figure out how to interface with the game. Whether that means "modding" the game, or patching a ROM file,
-    or developing a separate client program that edits the game's memory, or some other technique.
-  - Figure out how to give items and detect locations in the actual game. Not every item and location,
-    just one of each major type (e.g. opening a chest vs completing a sidequest) to prove all the items and locations
-    you want can actually be implemented.
-  - Figure out how to make a websocket connection to an AP server, possibly using a client library (see [Network Protocol](<network%20protocol.md>).
-    To make absolutely sure this part works, you may want to test the connection by generating a multiworld
-    with a different game, then making your client temporarily pretend to be that other game.
- Next, make a "trivial" APWorld, i.e. an APWorld that always generates the same items and locations
-  - If you've never done this before, likely the fastest approach is to copy-paste [APQuest](<../worlds/apquest>), and read the many
-    comments in there until you understand how to edit the items and locations.
- Then you can do your first "end-to-end test": generate a multiworld using your APWorld, [run a local server](<running%20from%20source.md>)
-  to host it, connect to that local server from your game client, actually check a location in the game,
-  and finally make sure the client successfully sent that location check to the AP server
-  as well as received an item from it.
-
-That's about where general recommendations end. What you should do next will depend entirely on your game
-(e.g. implement more items, write down logic rules, add client features, prototype a tracker, etc).
-If you're not sure, then this would be a good time to re-read [Adding Games](<adding%20games.md>), and [World API](<world%20api.md>).
-
-There are a few assumptions in this recommendation worth stating explicitly, namely:
-
- If something you want to do is infeasible, you want to find out that it's infeasible as soon as possible, before
-  you write a bunch of code assuming it could be done. That's why we recommend starting with the game client.
-  - Getting an APWorld to generate whatever items/locations you want is always feasible, since items/locations are
-    little more than id numbers and name strings during generation.
- You generally want to get to an "end-to-end playable" prototype quickly. On top of all the technical challenges these
-  docs describe, it's also important to check that a randomizer is *fun to play*, and figure out what features would be
-  essential for a public release.
- A first-time world developer may or may not be deeply familiar with Archipelago, but they're almost certainly familiar
-  with the game they want to randomize. So judging whether your game client is working correctly might be significantly
-  easier than judging if your APWorld is working.
-
---
-
 ### My game has a restrictive start that leads to fill errors

 A "restrictive start" here means having a combination of very few sphere 1 locations and potentially requiring more
@@ -183,58 +140,3 @@ So when the game itself does not follow this assumption, the options are:
  - For connections, any logical regions will still need to be reachable through other, *repeatable* connections
  - For locations, this may require game changes to remove the vanilla item if it affects logic
 - Decide that resetting the save file is part of the game's logic, and warn players about that
-
---
-
-### What are "local" vs "remote" items, and what are the pros and cons of each?
-
-First off, these terms can be misleading. Since the whole point of a multi-game multiworld randomizer is that some items
-are going to be placed in other slots (unless there's only one slot), the choice isn't really "local vs remote";
-it's "mixed local/remote vs all remote". You have to get "remote items" working to be an AP implementation at all, and
-it's often simpler to handle every item/location the same way, so you generally shouldn't worry about "local items"
-until you've finished more critical features.
-
-Next, "local" and "remote" items confusingly refer to multiple concepts, so it's important to clearly separate them:
-
- Whether an item happens to get placed in the same slot it originates from, or a different slot. I'll call these
-  "locally placed" and "remotely placed" items.
- Whether an AP client implements location checking for locally placed items by skipping the usual AP server roundtrip
-  (i.e. sending [LocationChecks](<network%20protocol.md#locationchecks>)
-  then receiving [ReceivedItems](<network%20protocol.md#receiveditems>)
-  ) and directly giving the item to the player, or by doing the AP server roundtrip regardless. I'll call these
-  "locally implemented" items and "remotely implemented" items.
-  - Locally implementing items requires the AP client to know what the locally placed items were without asking an AP
-    server (or else you'd effectively be doing remote items with extra steps). Typically, it gets that information from
-    a patch file, which is one reason why games that already need a patch file are more likely to choose local items.
-  - If items are remotely implemented, the AP client can use [location scouts](<network%20protocol.md#LocationScouts>)
-    to learn what items are placed on what locations. Features that require this information are sometimes mistakenly
-    assumed to require locally implemented items, but location scouts work just as well as patch file data.
- [The `items_handling` bitflags in the Connect packet](<network%20protocol.md#items_handling-flags>).
-  AP clients with remotely implemented items will typically set all three flags, including "from your own world".
-  Clients with locally implemented items might set only the "from other worlds" flag.
-  - Whether a local items client sets the "starting inventory" flag likely depends on other details. For example, if a ROM
-    is being patched, and starting inventory can be added to that patch, then it makes sense to leave the flag unset.
-
-When people talk about "local vs remote items" as a choice that world devs have to make, they mean deciding whether
-your client will locally or remotely implement the items which happen to be locally placed (or make both
-implementations, or let the player choose an implementation).
-
-Theoretically, the biggest benefit of "local items" is that it allows a solo (single slot) multiworld to be played
-entirely offline, with no AP server, from start to finish. This is similar to a "standalone"/non-AP randomizer,
-except that you still get AP's player options, generation, etc. for free.
-For some games, there are also technical constraints that make certain items easier to implement locally,
-or less glitchy when implemented locally, as long as you're okay with never allowing these items to be placed remotely
-(or offering the player even more options).
-
-The main downside (besides more implementation work) is that "local items" can't support "same slot co-op".
-That's when two players on two different machines connect to the same slot and play together.
-This only works if both players receive all the items for that slot, including ones found by the other player,
-which requires those items to be implemented remotely so the AP server can send them to all of that slot's clients.
-
-So to recap:
-
- (All) remote items is often the simplest choice, since you have to implement remote items anyway.
- Remote items enable same slot co-op.
- Local items enable solo offline play.
- If you want to support both solo offline play and same slot co-op,
-  you might need to expose local vs remote items as an option to the player.
@@ -16,11 +16,11 @@ game contributions:
 * **Do not introduce unit test failures/regressions.**
  Archipelago supports multiple versions of Python. You may need to download older Python versions to fully test
  your changes. Currently, the oldest supported version
-  is [Python 3.11](https://www.python.org/downloads/release/python-31113/).
+  is [Python 3.10](https://www.python.org/downloads/release/python-31015/).
  It is recommended that automated github actions are turned on in your fork to have github run unit tests after
  pushing.
  You can turn them on here:  
-  ![Github actions example](/docs/img/github-actions-example.png)
+  ![Github actions example](./img/github-actions-example.png)

 * **When reviewing PRs, please leave a message about what was done.**
  We don't have full test coverage, so manual testing can help.
@@ -77,6 +77,15 @@ Changes made to `docker-compose.yaml` can be applied by running `docker compose
 It is possible to carry out these deployment steps on Windows under [Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/install).


+## Optional: A Link to the Past Enemizer
+
+Only required to generate seeds that include A Link to the Past with certain options enabled. You will receive an
+error if it is required.
+Enemizer can be enabled on `x86_64` platform architecture, and is included in the image build process. Enemizer requires a version 1.0 Japanese "Zelda no Densetsu" `.sfc` rom file to be placed in the application directory:
+`docker run archipelago -v "/path/to/zelda.sfc:/app/Zelda no Densetsu - Kamigami no Triforce (Japan).sfc"`.
+Enemizer is not currently available for `aarch64`.
+
+
 ## Optional: Git

 Building the image requires a local copy of the ArchipelagoMW source code.
@@ -352,14 +352,14 @@ direction_matching_group_lookup = {

 Terrain matching or dungeon shuffle:
 ```python
-def randomize_within_same_group(group: int) -> list[int]:
+def randomize_within_same_group(group: int) -> List[int]:
    return [group]
 identity_group_lookup = bake_target_group_lookup(world, randomize_within_same_group)
 ```

 Directional + area shuffle:
 ```python
-def get_target_groups(group: int) -> list[int]:
+def get_target_groups(group: int) -> List[int]:
    # example group: LEFT | CAVE
    # example result: [RIGHT | CAVE, DOOR | CAVE]
    direction = group & Groups.DIRECTION_MASK
@@ -69,6 +69,12 @@ flowchart LR
    end
    SNI <-- Various, depending on SNES device --> SMZ

+    %% Donkey Kong Country 3
+    subgraph Donkey Kong Country 3
+        DK3[SNES]
+    end
+    SNI <-- Various, depending on SNES device --> DK3
+
    %% Super Mario World
    subgraph Super Mario World
        SMW[SNES]
@@ -79,7 +79,7 @@ Sent to clients when they connect to an Archipelago server.
 | generator_version     | [NetworkVersion](#NetworkVersion)             | Object denoting the version of Archipelago which generated the multiworld.                                                                                                                                                            |
 | tags                  | list\[str\]                                   | Denotes special features or capabilities that the sender is capable of. Example: `WebHost`                                                                                                                                            |
 | password              | bool                                          | Denoted whether a password is required to join this room.                                                                                                                                                                             |
-| permissions           | dict\[str, [Permission](#Permission)\]        | Mapping of permission name to [Permission](#Permission), keys are: "release", "collect" and "remaining".                                                                                                                              |
+| permissions           | dict\[str, [Permission](#Permission)\[int\]\] | Mapping of permission name to [Permission](#Permission), keys are: "release", "collect" and "remaining".                                                                                                                              |
 | hint_cost             | int                                           | The percentage of total locations that need to be checked to receive a hint from the server.                                                                                                                                          |
 | location_check_points | int                                           | The amount of hint points you receive per item/location check completed.                                                                                                                                                              |
 | games                 | list\[str\]                                   | List of games present in this multiworld.                                                                                                                                                                                             |
@@ -225,7 +225,7 @@ Sent to clients after a client requested this message be sent to them, more info
 | games | list\[str\] | Optional. Game names this message is targeting |
 | slots | list\[int\] | Optional. Player slot IDs that this message is targeting |
 | tags | list\[str\] | Optional. Client [Tags](#Tags) this message is targeting |
-| data | dict | Optional. The data in the [Bounce](#Bounce) package copied |
+| data | dict | The data in the [Bounce](#Bounce) package copied |

 ### InvalidPacket
 Sent to clients if the server caught a problem with a packet. This only occurs for errors that are explicitly checked for.
@@ -425,7 +425,7 @@ the server will forward the message to all those targets to which any one requir
 | games | list\[str\] | Optional. Game names that should receive this message |
 | slots | list\[int\] | Optional. Player IDs that should receive this message |
 | tags | list\[str\] | Optional. Client tags that should receive this message |
-| data | dict | Optional. Any data you want to send |
+| data | dict | Any data you want to send |

 ### Get
 Used to request a single or multiple values from the server's data storage, see the [Set](#Set) package for how to write values to the data storage. A Get package will be answered with a [Retrieved](#Retrieved) package.
@@ -647,16 +647,6 @@ class Version(NamedTuple):
    build: int
 ```

-If constructing version information as a dict for a custom client rather than as a NamedTuple built into the CommonClient, you must add the `class` key to allow Archipelago to compare version support.
-```
-"version": {
-      "class": "Version",
-      "build": X,
-      "major": Y,
-      "minor": Z
-    }
-```
-
 ### SlotType
 An enum representing the nature of a slot.

@@ -672,14 +662,13 @@ class SlotType(enum.IntFlag):
 An object representing static information about a slot.

 ```python
-from collections.abc import Sequence
-from typing import NamedTuple
+import typing
 from NetUtils import SlotType
-class NetworkSlot(NamedTuple):
+class NetworkSlot(typing.NamedTuple):
   name: str
   game: str
   type: SlotType
-   group_members: Sequence[int] = []  # only populated if type == group
+   group_members: typing.List[int] = []  # only populated if type == group
 ```

 ### Permission
@@ -697,8 +686,8 @@ class Permission(enum.IntEnum):
 ### Hint
 An object representing a Hint.
 ```python
-from typing import NamedTuple
-class Hint(NamedTuple):
+import typing
+class Hint(typing.NamedTuple):
    receiving_player: int
    finding_player: int
    location: int
@@ -269,8 +269,7 @@ placed on them.

 ### PriorityLocations
 Marks locations given here as `LocationProgressType.Priority` forcing progression items on them if any are available in
-the pool. Progression items without a deprioritized flag will be used first when filling priority_locations. Progression items with
-a deprioritized flag will be used next.
+the pool.

 ### ItemLinks
 Allows users to share their item pool with other players. Currently item links are per game. A link of one game between
@@ -345,7 +344,7 @@ names, and `def can_place_boss`, which passes a boss and location, allowing you
 your game. When this function is called, `bosses`, `locations`, and the passed strings will all be lowercase. There is
 also a `duplicate_bosses` attribute allowing you to define if a boss can be placed multiple times in your world. False
 by default, and will reject duplicate boss names from the user. For an example of using this class, refer to
-`worlds/alttp/Options.py`
+`worlds.alttp.options.py`

 ### OptionDict
 This option returns a dictionary. Setting a default here is recommended as it will output the dictionary to the
@@ -1,619 +0,0 @@
-# Rule Builder
-
-This document describes the API provided for the rule builder. Using this API provides you with with a simple interface
-to define rules and the following advantages:
-
- Rule classes that avoid all the common pitfalls
- Logic optimization
- Automatic result caching (opt-in)
- Serialization/deserialization
- Human-readable logic explanations for players
-
-## Overview
-
-The rule builder consists of 3 main parts:
-
-1. The rules, which are classes that inherit from `rule_builder.rules.Rule`. These are what you write for your logic.
-   They can be combined and take into account your world's options. There are a number of default rules listed below,
-   and you can create as many custom rules for your world as needed. When assigning the rules to a location or entrance
-   they must be resolved.
-2. Resolved rules, which are classes that inherit from `rule_builder.rules.Rule.Resolved`. These are the optimized rules
-   specific to one player that are set as a location or entrance's access rule. You generally shouldn't be directly
-   creating these but they'll be created when assigning rules to locations or entrances. These are what power the
-   human-readable logic explanations.
-3. The optional rule builder world subclass `CachedRuleBuilderWorld`, which is a class your world can inherit from
-   instead of `World`. It adds a caching system to the rules that will lazy evaluate and cache the result.
-
-## Usage
-
-For the most part the only difference in usage is instead of writing lambdas for your logic, you write static Rule
-objects. You then must use `world.set_rule` to assign the rule to a location or entrance.
-
-```python
-# In your world's create_regions method
-location = MyWorldLocation(...)
-self.set_rule(location, Has("A Big Gun"))
-```
-
-The rule builder comes with a number of rules by default:
-
- `True_`: Always returns true
- `False_`: Always returns false
- `And`: Checks that all child rules are true (also provided by `&` operator)
- `Or`: Checks that at least one child rule is true (also provided by `|` operator)
- `AtLeast`: Checks that at least some count of rules is true
- `Has`: Checks that the player has the given item with the given count (default 1)
- `HasAll`: Checks that the player has all given items
- `HasAny`: Checks that the player has at least one of the given items
- `HasAllCounts`: Checks that the player has all of the counts for the given items
- `HasAnyCount`: Checks that the player has any of the counts for the given items
- `HasFromList`: Checks that the player has some number of given items
- `HasFromListUnique`: Checks that the player has some number of given items, ignoring duplicates of the same item
- `HasGroup`: Checks that the player has some number of items from a given item group
- `HasGroupUnique`: Checks that the player has some number of items from a given item group, ignoring duplicates of the
-  same item
- `CanReachLocation`: Checks that the player can logically reach the given location
- `CanReachRegion`: Checks that the player can logically reach the given region
- `CanReachEntrance`: Checks that the player can logically reach the given entrance
-
-You can combine these rules together to describe the logic required for something. For example, to check if a player
-either has `Movement ability` or they have both `Key 1` and `Key 2`, you can do:
-
-```python
-rule = Has("Movement ability") | HasAll("Key 1", "Key 2")
-```
-
-> ⚠️ Composing rules with the `and` and `or` keywords will not work. You must use the bitwise `&` and `|` operators. In
-> order to catch mistakes, the rule builder will not let you do boolean operations. As a consequence, in order to check
-> if a rule is defined you must use `if rule is not None`.
-
-### Assigning rules
-
-When assigning the rule you must use the `set_rule` helper to correctly resolve and register the rule.
-
-```python
-self.set_rule(location_or_entrance, rule)
-```
-
-There is also a `create_entrance` helper that will resolve the rule, check if it's `False`, and if not create the
-entrance and set the rule. This allows you to skip creating entrances that will never be valid. You can also specify
-`force_creation=True` if you would like to create the entrance even if the rule is `False`.
-
-```python
-self.create_entrance(from_region, to_region, rule)
-```
-
-> ⚠️ If you use a `CanReachLocation` rule on an entrance, you will either have to create the locations first, or specify
-> the location's parent region name with the `parent_region_name` argument of `CanReachLocation`.
-
-You can also set a rule for your world's completion condition:
-
-```python
-self.set_completion_rule(rule)
-```
-
-### Restricting options
-
-Every rule allows you to specify which options it's applicable for. You can provide the argument `options` which is an
-iterable of `OptionFilter` instances. When resolved, if no filters are provided or all of them pass then the rule will
-resolve as normal. Otherwise, the rule will be replaced with `True` or `False` depending on what `filtered_resolution`
-is set to, which defaults to `False`.
-
-```python
-rule1 = Has(
-    "Fast Travel Spell",
-    options=[OptionFilter(RandoFastTravel, RandoFastTravel.option_true)],
-)
-rule2 = Has(
-    "Starting Party Member",
-    options=[OptionFilter(RandoParty, 1)],  # option attributes are suggested but any value works
-    filtered_resolution=True,
-)
-```
-
-If you want a comparison that isn't equals, you can specify with the `operator` argument. The following operators are
-allowed:
-
- `eq`: `option_value == filter_value`
- `ne`: `option_value != filter_value`
- `gt`: `option_value > filter_value`
- `lt`: `option_value < filter_value`
- `ge`: `option_value >= filter_value`
- `le`: `option_value <= filter_value`
- `in`: `option_value in filter_value`
- `contains`: `filter_value in option_value` (note reversed operands)
-
-```python
-rule1 = Has("Movement Ability", options=[OptionFilter(SkipsLevel, SkipsLevel.option_hard, operator="lt")])
-rule2 = Has("Item", options=[OptionFilter(ChoiceOption, [1, 5], operator="in")])
-```
-
-To check if the player has received the switch item if switches are randomized, or if they can reach the switch when not
-randomized:
-
-```python
-rule = (
-    Has("Red switch", options=[OptionFilter(SwitchRando, 1)])
-    | CanReachLocation("Red switch", options=[OptionFilter(SwitchRando, 0)])
-)
-```
-
-To add an extra logic requirement on the easiest difficulty which is ignored for other difficulties:
-
-```python
-rule = (
-    # ...the rest of the logic
-    & Has("QoL item", options=[OptionFilter(Difficulty, Difficulty.option_easy)], filtered_resolution=True)
-)
-```
-
-If you would like to provide option filters when reusing or composing rules, you can use the `Filtered` helper rule:
-
-```python
-common_rule = Has("A") | HasAny("B", "C")
-...
-rule = (
-    Filtered(common_rule, options=[OptionFilter(Opt, 0)])
-    | Filtered(Has("X") | CanReachRegion("Y"), options=[OptionFilter(Opt, 1)])
-)
-```
-
-For convenience, you can also use the `&` and `|` operators to apply options to rules:
-
-```python
-common_rule = Has("A")
-easy_filter = [OptionFilter(Difficulty, Difficulty.option_easy)]
-common_rule_only_on_easy = common_rule & easy_filter
-common_rule_skipped_on_easy = common_rule | easy_filter
-```
-
-Combining the above, you can easily bypass a requirement based on option choices:
-
-```python
-rule = Has("Some Upgrade") | OptionFilter(CombatDifficulty, CombatDifficulty.option_medium, operator="ge")
-```
-
-### Field resolvers
-
-When creating rules you may sometimes need to set a field to a value that depends on the world instance. You can use a
-`FieldResolver` to define how to populate that field when the rule is being resolved.
-
-There are two build-in field resolvers:
-
- `FromOption`: Resolves to the value of the given option
- `FromWorldAttr`: Resolves to the value of the given world instance attribute, can specify a dotted path `a.b.c` to get
-  a nested attribute or dict item
-
-```python
-world.options.mcguffin_count = 5
-world.precalculated_value = 99
-rule = (
-    Has("A", count=FromOption(McguffinCount))
-    | HasGroup("Important items", count=FromWorldAttr("precalculated_value"))
-)
-# Results in Has("A", count=5) | HasGroup("Important items", count=99)
-```
-
-You can define your own resolvers by creating a class that inherits from `FieldResolver`, provides your game name, and
-implements a `resolve` function:
-
-```python
-@dataclasses.dataclass(frozen=True)
-class FromCustomResolution(FieldResolver, game="MyGame"):
-    modifier: str
-
-    @override
-    def resolve(self, world: "World") -> Any:
-        return some_math_calculation(world, self.modifier)
-
-
-rule = Has("Combat Level", count=FromCustomResolution("combat"))
-```
-
-If you want to support rule serialization and your resolver contains non-serializable properties you may need to
-override `to_dict` or `from_dict`.
-
-## Enabling caching
-
-The rule builder provides a `CachedRuleBuilderWorld` base class for your `World` class that enables caching on your
-rules.
-
-```python
-class MyWorld(CachedRuleBuilderWorld):
-    game = "My Game"
-```
-
-If your world's logic is very simple and you don't have many nested rules, the caching system may have more overhead
-cost than time it saves. You'll have to benchmark your own world to see if it should be enabled or not.
-
-### Item name mapping
-
-If you have multiple real items that map to a single logic item, add a `item_mapping` class dict to your world that maps
-actual item names to real item names so the cache system knows what to invalidate.
-
-For example, if you have multiple `Currency x<num>` items on locations, but your rules only check a singular logical
-`Currency` item, eg `Has("Currency", 1000)`, you'll want to map each numerical currency item to the single logical
-`Currency`.
-
-```python
-class MyWorld(CachedRuleBuilderWorld):
-    item_mapping = {
-        "Currency x10": "Currency",
-        "Currency x50": "Currency",
-        "Currency x100": "Currency",
-        "Currency x500": "Currency",
-    }
-```
-
-## Defining custom rules
-
-You can create a custom rule by creating a class that inherits from `Rule` or any of the default rules. You must provide
-the game name as an argument to the class. It's recommended to use the `@dataclass` decorator to reduce boilerplate, and
-to also provide your world as a type argument to add correct type checking to the `_instantiate` method.
-
-You must provide or inherit a `Resolved` child class that defines an `_evaluate` method. This class will automatically
-be converted into a frozen `dataclass`. If your world has caching enabled you may need to define one or more
-dependencies functions as outlined below.
-
-To add a rule that checks if the user has enough mcguffins to goal, with a randomized requirement:
-
-```python
-@dataclasses.dataclass()
-class CanGoal(Rule["MyWorld"], game="My Game"):
-    @override
-    def _instantiate(self, world: "MyWorld") -> Rule.Resolved:
-        # caching_enabled only needs to be passed in when your world inherits from CachedRuleBuilderWorld
-        return self.Resolved(world.required_mcguffins, player=world.player, caching_enabled=True)
-
-    class Resolved(Rule.Resolved):
-        goal: int
-
-        @override
-        def _evaluate(self, state: CollectionState) -> bool:
-            return state.has("McGuffin", self.player, count=self.goal)
-
-        @override
-        def item_dependencies(self) -> dict[str, set[int]]:
-            # this function is only required if you have caching enabled
-            return {"McGuffin": {id(self)}}
-
-        @override
-        def explain_json(self, state: CollectionState | None = None) -> list[JSONMessagePart]:
-            # this method can be overridden to display custom explanations
-            return [
-                {"type": "text", "text": "Goal with "},
-                {"type": "color", "color": "green" if state and self(state) else "salmon", "text": str(self.goal)},
-                {"type": "text", "text": " McGuffins"},
-            ]
-```
-
-Your custom rule can also resolve to builtin rules instead of needing to define your own:
-
-```python
-@dataclasses.dataclass()
-class ComplicatedFilter(Rule["MyWorld"], game="My Game"):
-    def _instantiate(self, world: "MyWorld") -> Rule.Resolved:
-        if world.some_precalculated_bool:
-            return Has("Item 1").resolve(world)
-        if world.options.some_option:
-            return CanReachRegion("Region 1").resolve(world)
-        return False_().resolve(world)
-```
-
-### Item dependencies
-
-If your world inherits from `CachedRuleBuilderWorld` and there are items that when collected will affect the result of
-your rule evaluation, it must define an `item_dependencies` function that returns a mapping of the item name to the id
-of your rule. These dependencies will be combined to inform the caching system. It may be worthwhile to define this
-function even when caching is disabled as more things may use it in the future.
-
-```python
-@dataclasses.dataclass()
-class MyRule(Rule["MyWorld"], game="My Game"):
-    class Resolved(Rule.Resolved):
-        item_name: str
-
-        @override
-        def item_dependencies(self) -> dict[str, set[int]]:
-            return {self.item_name: {id(self)}}
-```
-
-All of the default `Has*` rules define this function already.
-
-### Region dependencies
-
-If your custom rule references other regions, it must define a `region_dependencies` function that returns a mapping of
-region names to the id of your rule regardless of if your world inherits from `CachedRuleBuilderWorld`. These
-dependencies will be combined to register indirect connections when you set this rule on an entrance and inform the
-caching system if applicable.
-
-```python
-@dataclasses.dataclass()
-class MyRule(Rule["MyWorld"], game="My Game"):
-    class Resolved(Rule.Resolved):
-        region_name: str
-
-        @override
-        def region_dependencies(self) -> dict[str, set[int]]:
-            return {self.region_name: {id(self)}}
-```
-
-The default `CanReachLocation`, `CanReachRegion`, and `CanReachEntrance` rules define this function already.
-
-### Location dependencies
-
-If your custom rule references other locations, it must define a `location_dependencies` function that returns a mapping
-of the location name to the id of your rule regardless of if your world inherits from `CachedRuleBuilderWorld`. These
-dependencies will be combined to register indirect connections when you set this rule on an entrance and inform the
-caching system if applicable.
-
-```python
-@dataclasses.dataclass()
-class MyRule(Rule["MyWorld"], game="My Game"):
-    class Resolved(Rule.Resolved):
-        location_name: str
-
-        @override
-        def location_dependencies(self) -> dict[str, set[int]]:
-            return {self.location_name: {id(self)}}
-```
-
-The default `CanReachLocation` rule defines this function already.
-
-### Entrance dependencies
-
-If your custom rule references other entrances, it must define a `entrance_dependencies` function that returns a mapping
-of the entrance name to the id of your rule regardless of if your world inherits from `CachedRuleBuilderWorld`. These
-dependencies will be combined to register indirect connections when you set this rule on an entrance and inform the
-caching system if applicable.
-
-```python
-@dataclasses.dataclass()
-class MyRule(Rule["MyWorld"], game="My Game"):
-    class Resolved(Rule.Resolved):
-        entrance_name: str
-
-        @override
-        def entrance_dependencies(self) -> dict[str, set[int]]:
-            return {self.entrance_name: {id(self)}}
-```
-
-The default `CanReachEntrance` rule defines this function already.
-
-### Rule explanations
-
-Resolved rules have a default implementation for `explain_json` and `explain_str` functions. The former optionally
-accepts a `CollectionState` and returns a list of `JSONMessagePart` appropriate for `print_json` in a client. It will
-display a human-readable message that explains what the rule requires. The latter is similar but returns a string. It is
-useful when debugging. There is also a `__str__` method defined to check what a rule is without a state.
-
-To implement a custom message with a custom rule, override the `explain_json` and/or `explain_str` method on your
-`Resolved` class:
-
-```python
-class MyRule(Rule, game="My Game"):
-    class Resolved(Rule.Resolved):
-        @override
-        def explain_json(self, state: CollectionState | None = None) -> list[JSONMessagePart]:
-            has_item = state and state.has("growth spurt", self.player)
-            color = "yellow"
-            start = "You must be "
-            if has_item:
-                start = "You are "
-                color = "green"
-            elif state is not None:
-                start = "You are not "
-                color = "salmon"
-            return [
-                {"type": "text", "text": start},
-                {"type": "color", "color": color, "text": "THIS"},
-                {"type": "text", "text": " tall to beat the game"},
-            ]
-
-        @override
-        def explain_str(self, state: CollectionState | None = None) -> str:
-            if state is None:
-                return str(self)
-            if state.has("growth spurt", self.player):
-                return "You ARE this tall and can beat the game"
-            return "You are not THIS tall and cannot beat the game"
-
-        @override
-        def __str__(self) -> str:
-            return "You must be THIS tall to beat the game"
-```
-
-### Cache control
-
-By default your custom rule will work through the cache system as any other rule if caching is enabled. There are two
-class attributes on the `Resolved` class you can override to change this behavior.
-
- `force_recalculate`: Setting this to `True` will cause your custom rule to skip going through the caching system and
-  always recalculate when being evaluated. When a rule with this flag enabled is composed with `And` or `Or` it will
-  cause any parent rules to always force recalculate as well. Use this flag when it's difficult to determine when your
-  rule should be marked as stale.
- `skip_cache`: Setting this to `True` will also cause your custom rule to skip going through the caching system when
-  being evaluated. However, it will **not** affect any other rules when composed with `And` or `Or`, so it must still
-  define its `*_dependencies` functions as required. Use this flag when the evaluation of this rule is trivial and the
-  overhead of the caching system will slow it down.
-
-### Caveats
-
- Ensure you are passing `caching_enabled=True` in your `_instantiate` function when creating resolved rule instances if
-  your world has opted into caching.
- Resolved rules are forced to be frozen dataclasses. They and all their attributes must be immutable and hashable.
- If your rule creates child rules ensure they are being resolved through the world rather than creating `Resolved`
-  instances directly.
-
-## Serialization
-
-The rule builder is intended to be written first in Python for optimization and type safety. To facilitate exporting the
-rules to a client or tracker, rules have a `to_dict` method that returns a JSON-compatible dict. Since the location and
-entrance logic structure varies greatly from world to world, the actual JSON dumping is left up to the world dev.
-
-The dict contains a `rule` key with the name of the rule, an `options` key with the rule's list of option filters, and
-an `args` key that contains any other arguments the individual rule has. For example, this is what a simple `Has` rule
-would look like:
-
-```python
-{
-    "rule": "Has",
-    "options": [],
-    "args": {
-        "item_name": "Some item",
-        "count": 1,
-    },
-}
-```
-
-For `And` and `Or` rules, instead of an `args` key, they have a `children` key containing a list of their child rules in
-the same serializable format:
-
-```python
-{
-    "rule": "And",
-    "options": [],
-    "children": [
-        ...,  # each serialized rule
-    ]
-}
-```
-
-A full example is as follows:
-
-```python
-rule = And(
-    Has("a", options=[OptionFilter(ToggleOption, 0)]),
-    Or(Has("b", count=2), CanReachRegion("c"), options=[OptionFilter(ToggleOption, 1)]),
-)
-assert rule.to_dict() == {
-    "rule": "And",
-    "options": [],
-    "children": [
-        {
-            "rule": "Has",
-            "options": [
-                {
-                    "option": "worlds.my_world.options.ToggleOption",
-                    "value": 0,
-                    "operator": "eq",
-                },
-            ],
-            "args": {
-                "item_name": "a",
-                "count": 1,
-            },
-        },
-        {
-            "rule": "Or",
-            "options": [
-                {
-                    "option": "worlds.my_world.options.ToggleOption",
-                    "value": 1,
-                    "operator": "eq",
-                },
-            ],
-            "children": [
-                {
-                    "rule": "Has",
-                    "options": [],
-                    "args": {
-                        "item_name": "b",
-                        "count": 2,
-                    },
-                },
-                {
-                    "rule": "CanReachRegion",
-                    "options": [],
-                    "args": {
-                        "region_name": "c",
-                    },
-                },
-            ],
-        },
-    ],
-}
-```
-
-### Custom serialization
-
-To define a different format for your custom rules, override the `to_dict` function:
-
-```python
-class BasicLogicRule(Rule, game="My Game"):
-    items = ("one", "two")
-
-    def to_dict(self) -> dict[str, Any]:
-        # Return whatever format works best for you
-        return {
-            "logic": "basic",
-            "items": self.items,
-        }
-```
-
-If your logic has been done in custom JSON first, you can define a `from_dict` class method on your rules to parse it
-correctly:
-
-```python
-class BasicLogicRule(Rule, game="My Game"):
-    @classmethod
-    def from_dict(cls, data: Mapping[str, Any], world_cls: type[World]) -> Self:
-        items = data.get("items", ())
-        return cls(*items)
-```
-
-## APIs
-
-This section is provided for reference, refer to the above sections for examples.
-
-### World API
-
-These are properties and helpers that are available to you in your world.
-
-#### Methods
-
- `rule_from_dict(data)`: Create a rule instance from a deserialized dict representation
- `register_rule_builder_dependencies()`: Register all rules that depend on location or entrance access with the
-  inherited dependencies, gets called automatically after set_rules
- `set_rule(spot: Location | Entrance, rule: Rule)`: Resolve a rule, register its dependencies, and set it on the given
-  location or entrance
- `set_completion_rule(rule: Rule)`: Sets the completion condition for this world
- `create_entrance(from_region: Region, to_region: Region, rule: Rule | None, name: str | None = None, force_creation: bool = False)`:
-  Attempt to create an entrance from `from_region` to `to_region`, skipping creation if `rule` is defined and evaluates
-  to `False_()` unless force_creation is `True`
-
-#### CachedRuleBuilderWorld Properties
-
-The following property is only available when inheriting from `CachedRuleBuilderWorld`
-
- `item_mapping: dict[str, str]`: A mapping of actual item name to logical item name
-
-### Rule API
-
-These are properties and helpers that you can use or override for custom rules.
-
- `_instantiate(world: World)`: Create a new resolved rule instance, override for custom rules as required
- `to_dict()`: Create a JSON-compatible dict representation of this rule, override if you want to customize your rule's
-  serialization
- `from_dict(data, world_cls: type[World])`: Return a new rule instance from a deserialized representation, override if
-  you've overridden `to_dict`
- `__str__()`: Basic string representation of a rule, useful for debugging
-
-#### Resolved rule API
-
- `player: int`: The slot this rule is resolved for
- `_evaluate(state: CollectionState)`: Evaluate this rule against the given state, override this to define the logic for
-  this rule
- `item_dependencies()`: A mapping of item name to set of ids, override this if your custom rule depends on item
-  collection
- `region_dependencies()`: A mapping of region name to set of ids, override this if your custom rule depends on reaching
-  regions
- `location_dependencies()`: A mapping of location name to set of ids, override this if your custom rule depends on
-  reaching locations
- `entrance_dependencies()`: A mapping of entrance name to set of ids, override this if your custom rule depends on
-  reaching entrances
- `explain_json(state: CollectionState | None = None)`: Return a list of printJSON messages describing this rule's logic
-  (and if state is defined its evaluation) in a human readable way, override to explain custom rules
- `explain_str(state: CollectionState | None = None)`: Return a string describing this rule's logic (and if state is
-  defined its evaluation) in a human readable way, override to explain custom rules, more useful for debugging
- `__str__()`: A string describing this rule's logic without its evaluation, override to explain custom rules
@@ -7,9 +7,10 @@ use that version. These steps are for developers or platforms without compiled r
 ## General

 What you'll need:
- * [Python 3.11.9 or newer but less than 3.14](https://www.python.org/downloads/), not the Windows Store version
+ * [Python 3.10.11 or newer](https://www.python.org/downloads/), not the Windows Store version
   * On Windows, please consider only using the latest supported version in production environments since security
     updates for older versions are not easily available.
+   * Python 3.12.x is currently the newest supported version
 * pip: included in downloads from python.org, separate in many Linux distributions
 * Matching C compiler
   * possibly optional, read operating system specific sections
@@ -52,30 +53,14 @@ Recommended steps
 Refer to [Guide to Run Archipelago from Source Code on macOS](../worlds/generic/docs/mac_en.md).


-## Linux
+## Optional: A Link to the Past Enemizer

-If your Linux distribution ships a compatible Python version (see [General](#general)) and pip, you can use that,
-otherwise you may need to install Python from a 3rd party. Refer to documentation of your Linux distribution.
+Only required to generate seeds that include A Link to the Past with certain options enabled. You will receive an
+error if it is required.

-Installing a C compiler is usually optional. The package is typically named `gcc`, sometimes another package with the
-base build tools may be required, i.e. `build-essential` (Debian/Ubuntu) or `base-devel` (Arch).
-
-After getting the source code, it is strongly recommended to create a
-[venv](https://docs.python.org/3/tutorial/venv.html) (Virtual Environment)
-by hand or using an IDE, such as PyCharm, because Archipelago requires specific versions of Python packages.
-
-Run `python ModuleUpdate.py` in the project root to install packages, run `python Launcher.py` to run the Launcher.
-
-### Building
-
-Builds contain (almost) all dependencies to run Archipelago on any Linux distribution that is as new or newer than the
-one it was built on. Beware that currently only the oldest Ubuntu LTS available in GitHub actions is supported for that.
-This means the easiest way to generate a build is by running the `Build` action from GitHub actions instead of building
-locally. If you still want to, e.g. for local testing, you can by running
-
-`python setup.py build_exe` to generate a binary distribution of Archipelago in `build/`. Or to generate an AppImage
-first generate the binary distribution and then run `python setup.py bdist_appimage` to populate `dist/`. You need to
-put an `appimagetool` into the directory you run the command from, rename it to `appimagetool` and make it executable.
+You can get the latest Enemizer release at [Enemizer Github releases](https://github.com/Ijwu/Enemizer/releases).
+It should be dropped as "EnemizerCLI" into the root folder of the project. Alternatively, you can point the Enemizer
+setting in host.yaml at your Enemizer executable.


 ## Optional: SNI
@@ -28,7 +28,7 @@ if it does not exist.
 ## Global Settings

 All non-world-specific settings are defined directly in settings.py.
-Each value needs to have a default. If the default should be `None`, annotate it using `T | None = None`.
+Each value needs to have a default. If the default should be `None`, define it as `typing.Optional` and assign `None`.

 To access a "global" config value, with correct typing, use one of
 ```python
@@ -1,18 +0,0 @@
-# Shared Cache
-
-Archipelago maintains a shared folder of information that can be persisted for a machine and reused across Libraries.
-It can be found at the User Cache Directory for appname `Archipelago` in the `Cache` subfolder
-(ex. `%LOCALAPPDATA%/Archipelago/Cache`).
-
-## Common Cache
-
-The Common Cache `common.json` can be used to store any generic data that is expected to be shared across programs
-for the same User.
-
-* `uuid`: A UUID identifier used to identify clients as from the same user/machine, to be sent in the Connect packet
-
-## Data Package Cache
-
-The `datapackage` folder in the shared cache folder is used to store datapackages by game and checksum to be reused
-in order to save network traffic. The expected structure is `datapackage/Game Name/checksum_value.json` with the
-contents of each json file being the no-whitespace datapackage contents.
@@ -15,10 +15,8 @@
 * Prefer [format string literals](https://peps.python.org/pep-0498/) over string concatenation,
  use single quotes inside them: `f"Like {dct['key']}"`
 * Use type annotations where possible for function signatures and class members.
-* Use type annotations where appropriate for local variables (e.g. `var: list[int] = []`, or when the
-  type is hard or impossible to deduce). Clear annotations help developers look up and validate API calls.
-* Prefer new style type annotations for new code (e.g. `var: dict[str, str | int]` over
-  `var: Dict[str, Union[str, int]]`).
+* Use type annotations where appropriate for local variables (e.g. `var: List[int] = []`, or when the
+  type is hard or impossible to deduce.) Clear annotations help developers look up and validate API calls.
 * If a line ends with an open bracket/brace/parentheses, the matching closing bracket should be at the
  beginning of a line at the same indentation as the beginning of the line with the open bracket.
  ```python
@@ -47,30 +45,18 @@

 ## HTML

-* Indent with 4 spaces for new code.
+* Indent with 2 spaces for new code.
 * kebab-case for ids and classes.
-* Avoid using on* attributes (onclick, etc.).

-## CSS / SCSS
+## CSS

-* Indent with 4 spaces for new code.
+* Indent with 2 spaces for new code.
 * `{` on the same line as the selector.
-* Space between selector and `{`.
+* No space between selector and `{`.

 ## JS

-* Indent with 4 spaces.
-* Indent `case` inside `switch ` with 4 spaces.
-* Prefer double quotation marks (`"`).
+* Indent with 2 spaces.
+* Indent `case` inside `switch ` with 2 spaces.
+* Use single quotes.
 * Semicolons are required after every statement.
-* Use [IIFEs](https://developer.mozilla.org/docs/Glossary/IIFE) to avoid polluting global scope.
-* Prefer to use [defer](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script#defer)
-  in script tags, which retains order of execution but does not block.
-* Avoid `<script async ...` in most cases, see [async and defer](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script#async_and_defer).
-* Use addEventListener.
-
-## KV
-
-* Style should be defined in `.kv` as much as possible, only Python when unavailable.
-* Should follow [our Python style](#python-code) where appropriate (quotation marks, indentation).
-* When escaping a line break, add a space between code and backslash.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Fabian Dill	43100f2c43	Test: add a failing test for big int	2025-08-03 10:54:17 +02:00
Fabian Dill	c6df02a355	Core: move MultiServer.py and CommonClient.py to orjson	2025-08-03 08:20:21 +02:00