splitscreen hack

2026-11-08 08:12:20 -10:00 · 2023-11-28 20:19:08 -05:00
6391 changed files with 632117 additions and 2990199 deletions
@@ -10,7 +10,7 @@ IncludeCategories:
    Priority: 2
  - Regex: '^(<|")common.*'
    Priority: 3
-  - Regex: '^"(third-party|fmt|curl).*'
+  - Regex: '^"third-party.*'
    Priority: 4
    SortPriority: 5
  - Regex: '.*'
@@ -32,4 +32,4 @@ cp -r $SOURCE/decompiler/config $DEST/data/decompiler/
 cp -r $SOURCE/goal_src $DEST/data
 cp -r $SOURCE/game/assets $DEST/data/game/
 cp -r $SOURCE/game/graphics/opengl_renderer/shaders $DEST/data/game/graphics/opengl_renderer
-cp -r $SOURCE/custom_assets $DEST/data
+cp -r $SOURCE/custom_levels $DEST/data
@@ -24,4 +24,4 @@ cp -r $SOURCE/decompiler/config $DEST/data/decompiler/
 cp -r $SOURCE/goal_src $DEST/data
 cp -r $SOURCE/game/assets $DEST/data/game/
 cp -r $SOURCE/game/graphics/opengl_renderer/shaders $DEST/data/game/graphics/opengl_renderer
-cp -r $SOURCE/custom_assets $DEST/data
+cp -r $SOURCE/custom_levels $DEST/data
@@ -23,7 +23,7 @@ jobs:
      - name: Bump Version and Push Tag
        if: github.repository == 'open-goal/jak-project'
        id: tag_version
-        uses: mathieudutour/github-tag-action@v6.2
+        uses: mathieudutour/github-tag-action@v6.1
        with:
          github_token: ${{ secrets.BOT_PAT }}
          tag_prefix: v
@@ -58,16 +58,12 @@ jobs:
        run: |
          ./build/goalc/goalc --cmd "(begin (make-group \"all-code\") (gen-docs \"${PWD}\"))" --game jak2

-      - name: Generate Docs For Jak 3
-        run: |
-          ./build/goalc/goalc --cmd "(begin (make-group \"all-code\") (gen-docs \"${PWD}\"))" --game jak3
-
      - name: Append File Docstrings
        run: |
-          python ./scripts/ci/docs/append-file-docs.py
+          python ./scripts/docs/append-file-docs.py

      - name: Upload Docs Artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: opengoal-docs
          if-no-files-found: error
@@ -79,7 +75,7 @@ jobs:
        run: echo ${{ github.run_id }}

      - name: Send Dispatch
-        uses: peter-evans/repository-dispatch@v3
+        uses: peter-evans/repository-dispatch@v2
        with:
          token: ${{ secrets.BOT_PAT }}
          repository: 'open-goal/open-goal.github.io'
@@ -41,9 +41,6 @@ jobs:
      - name: Checkout Repository
        uses: actions/checkout@v4

-      - name: Check for Trailing Whitespace in goal_src
-        run: python ./scripts/ci/lint-trailing-whitespace.py
-
      - name: Check for Unresolved Conflicts
        run: python ./scripts/gsrc/check-for-conflicts.py

@@ -20,6 +20,13 @@ jobs:
    runs-on: ubuntu-20.04
    timeout-minutes: 60

+    env: # overrides: https://github.com/mbitsnbites/buildcache/blob/master/doc/configuration.md
+      BUILDCACHE_MAX_CACHE_SIZE: 1000000000 # 1gb
+      BUILDCACHE_COMPRESS_FORMAT: ZSTD
+      BUILDCACHE_COMPRESS_LEVEL: 19
+      BUILDCACHE_DIRECT_MODE: true
+      BUILDCACHE_LOG_FILE: ${{ github.workspace }}/buildcache.log
+
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
@@ -32,13 +39,11 @@ jobs:
            libxinerama-dev libxcursor-dev libpulse-dev \
            libxi-dev zip ninja-build libgl1-mesa-dev libssl-dev

-      - name: Setup sccache
-        uses: hendrikmuhs/ccache-action@v1.2.13
+      - name: Setup Buildcache
+        uses: mikehardy/build[email protected].0
        with:
-          variant: sccache
-          key: linux-ubuntu-20.04-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}-${{ github.sha }}
-          restore-keys: linux-ubuntu-20.04-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
-          max-size: 1000M
+          cache_key: linux-ubuntu-20.04-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
+          buildcache_tag: v0.28.1

      - name: CMake Generation
        env:
@@ -46,8 +51,8 @@ jobs:
          CXX: clang++
        run: |
          cmake -B build --preset=${{ inputs.cmakePreset }} \
-            -DCMAKE_C_COMPILER_LAUNCHER=sccache \
-            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
+            -DCMAKE_C_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache

      - name: Build Project
        run: cmake --build build --parallel $((`nproc`))
@@ -66,7 +71,7 @@ jobs:
          strip ./build/lsp/lsp

      - name: Upload artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        if: ${{ inputs.uploadArtifacts }}
        with:
          name: opengoal-linux-${{ inputs.cachePrefix }}
@@ -16,6 +16,13 @@ jobs:
    runs-on: ubuntu-20.04
    timeout-minutes: 60

+    env: # overrides: https://github.com/mbitsnbites/buildcache/blob/master/doc/configuration.md
+      BUILDCACHE_MAX_CACHE_SIZE: 1000000000 # 1gb
+      BUILDCACHE_COMPRESS_FORMAT: ZSTD
+      BUILDCACHE_COMPRESS_LEVEL: 19
+      BUILDCACHE_DIRECT_MODE: true
+      BUILDCACHE_LOG_FILE: ${{ github.workspace }}/buildcache.log
+
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
@@ -24,22 +31,15 @@ jobs:
        run: |
          sudo apt update
          sudo apt install build-essential cmake \
-            clang gcc-10 g++-10 lcov make nasm libxrandr-dev \
+            clang gcc g++ lcov make nasm libxrandr-dev \
            libxinerama-dev libxcursor-dev libpulse-dev \
            libxi-dev zip ninja-build libgl1-mesa-dev libssl-dev

-            sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100
-            sudo update-alternatives --set gcc /usr/bin/gcc-10
-            sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-10 100
-            sudo update-alternatives --set g++ /usr/bin/g++-10
-
-      - name: Setup sccache
-        uses: hendrikmuhs/[email protected]
+      - name: Setup Buildcache
+        uses: mikehardy/[email protected]
        with:
-          variant: sccache
-          key: linux-ubuntu-20.04-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}-${{ github.sha }}
-          restore-keys: linux-ubuntu-20.04-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
-          max-size: 1000M
+          cache_key: linux-ubuntu-20.04-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
+          buildcache_tag: v0.28.1

      - name: CMake Generation
        env:
@@ -48,11 +48,18 @@ jobs:
        run: |
          cmake -B build --preset=${{ inputs.cmakePreset }} \
            -DCODE_COVERAGE=OFF \
-            -DCMAKE_C_COMPILER_LAUNCHER=sccache \
-            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
+            -DCMAKE_C_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache

      - name: Build Project
        run: cmake --build build --parallel $((`nproc`)) -- -w dupbuild=warn

      - name: Run Tests
        run: ./test.sh
+
+      # - name: Submit Coverage Report to Codacy
+      #   uses: codacy/codacy-coverage-reporter-action@v1
+      #   continue-on-error: true
+      #   with:
+      #     project-token: ${{ secrets.CODACY_PROJECT_KEY }}
+      #     coverage-reports: ./build/goalc-test_coverage.info
@@ -13,9 +13,16 @@ on:
 jobs:
  build:
    name: ARM
-    runs-on: macos-12
+    runs-on: macos-latest
    timeout-minutes: 120

+    env: # overrides: https://github.com/mbitsnbites/buildcache/blob/master/doc/configuration.md
+      BUILDCACHE_MAX_CACHE_SIZE: 1000000000 # 1gb
+      BUILDCACHE_COMPRESS_FORMAT: ZSTD
+      BUILDCACHE_COMPRESS_LEVEL: 19
+      BUILDCACHE_DIRECT_MODE: true
+      BUILDCACHE_LOG_FILE: ${{ github.workspace }}/buildcache.log
+
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
@@ -26,13 +33,11 @@ jobs:
      - name: Install Package Dependencies
        run: arch -arm64 brew install cmake ninja

-      - name: Setup sccache
-        uses: hendrikmuhs/ccache-action@v1.2.13
+      - name: Setup Buildcache
+        uses: mikehardy/build[email protected].0
        with:
-          variant: sccache
-          key: macos-12-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}-${{ github.sha }}
-          restore-keys: macos-12-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
-          max-size: 1000M
+          cache_key: macos-12-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
+          buildcache_tag: v0.28.1

      - name: CMake Generation
        env:
@@ -40,8 +45,8 @@ jobs:
          CXX: clang++
        run: |
          cmake -B build --preset=${{ inputs.cmakePreset }} \
-            -DCMAKE_C_COMPILER_LAUNCHER=sccache \
-            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
+            -DCMAKE_C_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache

      - name: Build Project
        run: cmake --build build --parallel $((`sysctl -n hw.logicalcpu`))
@@ -50,7 +55,7 @@ jobs:
        run: ./test.sh

      - name: Upload artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: opengoal-macos-${{ inputs.cachePrefix }}
          if-no-files-found: error
@@ -17,9 +17,16 @@ on:
 jobs:
  build:
    name: Intel
-    runs-on: macos-12
+    runs-on: macos-11
    timeout-minutes: 120

+    env: # overrides: https://github.com/mbitsnbites/buildcache/blob/master/doc/configuration.md
+      BUILDCACHE_MAX_CACHE_SIZE: 1000000000 # 1gb
+      BUILDCACHE_COMPRESS_FORMAT: ZSTD
+      BUILDCACHE_COMPRESS_LEVEL: 19
+      BUILDCACHE_DIRECT_MODE: true
+      BUILDCACHE_LOG_FILE: ${{ github.workspace }}/buildcache.log
+
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
@@ -27,13 +34,11 @@ jobs:
      - name: Install Package Dependencies
        run: brew install cmake nasm ninja

-      - name: Setup sccache
-        uses: hendrikmuhs/ccache-action@v1.2.13
+      - name: Setup Buildcache
+        uses: mikehardy/build[email protected].0
        with:
-          variant: sccache
-          key: macos-12-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}-${{ github.sha }}
-          restore-keys: macos-12-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
-          max-size: 1000M
+          cache_key: macos-11-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
+          buildcache_tag: v0.28.1

      - name: CMake Generation
        env:
@@ -41,8 +46,8 @@ jobs:
          CXX: clang++
        run: |
          cmake -B build --preset=${{ inputs.cmakePreset }} \
-            -DCMAKE_C_COMPILER_LAUNCHER=sccache \
-            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
+            -DCMAKE_C_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache

      - name: Build Project
        run: cmake --build build --parallel $((`sysctl -n hw.logicalcpu`))
@@ -59,7 +64,7 @@ jobs:
          strip ./build/lsp/lsp

      - name: Upload artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        if: ${{ inputs.uploadArtifacts }}
        with:
          name: opengoal-macos-${{ inputs.cachePrefix }}
@@ -51,7 +51,7 @@ jobs:
      - name: Prepare Artifact Folder
        run: mkdir -p ./ci-artifacts/final

-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v3
        name: Download all Artifacts
        with:
          path: ./ci-artifacts/
@@ -19,7 +19,7 @@ jobs:
          wget -O ./game/assets/sdl_controller_db.txt https://raw.githubusercontent.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt

      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v6
+        uses: peter-evans/create-pull-request@v5
        with:
          token: ${{ secrets.BOT_PAT }}
          author: 'OpenGOALBot <[email protected]>'
@@ -21,6 +21,13 @@ jobs:
    # Set some sort of timeout in the event of run-away builds.  We are limited on concurrent jobs so, get rid of them.
    timeout-minutes: 60

+    env: # overrides: https://github.com/mbitsnbites/buildcache/blob/master/doc/configuration.md
+      BUILDCACHE_MAX_CACHE_SIZE: 1000000000 # 1gb
+      BUILDCACHE_COMPRESS_FORMAT: ZSTD
+      BUILDCACHE_COMPRESS_LEVEL: 19
+      BUILDCACHE_DIRECT_MODE: true
+      BUILDCACHE_LOG_FILE: ${{ github.workspace }}/buildcache.log
+
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
@@ -35,13 +42,10 @@ jobs:
            choco install ${{ github.workspace }}/third-party/nasm/old/nasm.2.15.05.nupkg
          }

-      - name: Setup sccache
-        uses: hendrikmuhs/ccache-action@v1.2.13
+      - name: Setup Buildcache
+        uses: mikehardy/build[email protected].0
        with:
-          variant: sccache
-          key: windows-2022-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}-${{ github.sha }}
-          restore-keys: windows-2022-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
-          max-size: 1000M
+          cache_key: windows-2022-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}

      - uses: ilammy/msvc-dev-cmd@v1

@@ -54,19 +58,20 @@ jobs:

      - name: CMake Generation
        shell: cmd
-        run: cmake -B build --preset=${{ inputs.cmakePreset }} -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache .
+        run: cmake -B build --preset=${{ inputs.cmakePreset }} -DCMAKE_C_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache.exe -DCMAKE_CXX_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache.exe .

      - name: Build Project
        shell: cmd
        run: cmake --build build --parallel %NUMBER_OF_PROCESSORS%

      - name: Run Tests
+        timeout-minutes: 10
        env:
          GTEST_OUTPUT: "xml:opengoal-test-report.xml"
        run: ./build/bin/goalc-test.exe --gtest_color=yes --gtest_brief=0 --gtest_filter="-*MANUAL_TEST*"

      - name: Upload artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        if: ${{ inputs.uploadArtifacts }}
        with:
          name: opengoal-windows-${{ inputs.cachePrefix }}
@@ -16,6 +16,13 @@ jobs:
    runs-on: windows-2022
    timeout-minutes: 60

+    env: # overrides: https://github.com/mbitsnbites/buildcache/blob/master/doc/configuration.md
+      BUILDCACHE_MAX_CACHE_SIZE: 1000000000 # 1gb
+      BUILDCACHE_COMPRESS_FORMAT: ZSTD
+      BUILDCACHE_COMPRESS_LEVEL: 19
+      BUILDCACHE_DIRECT_MODE: true
+      BUILDCACHE_LOG_FILE: ${{ github.workspace }}/buildcache.log
+
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
@@ -30,13 +37,10 @@ jobs:
            choco install ${{ github.workspace }}/third-party/nasm/old/nasm.2.15.05.nupkg
          }

-      - name: Setup sccache
-        uses: hendrikmuhs/ccache-action@v1.2.13
+      - name: Setup Buildcache
+        uses: mikehardy/build[email protected].0
        with:
-          variant: sccache
-          key: windows-2022-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}-${{ github.sha }}
-          restore-keys: windows-2022-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}
-          max-size: 1000M
+          cache_key: windows-2022-${{ inputs.cachePrefix }}-${{ inputs.cmakePreset }}

      - uses: ilammy/msvc-dev-cmd@v1

@@ -48,7 +52,7 @@ jobs:

      - name: CMake Generation - MSVC
        shell: cmd
-        run: cmake -B build --preset=${{ inputs.cmakePreset }} -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache .
+        run: cmake -B build --preset=${{ inputs.cmakePreset }} -DCMAKE_C_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache.exe -DCMAKE_CXX_COMPILER_LAUNCHER=${{ github.workspace }}/buildcache/bin/buildcache.exe .

      - name: Build Project
        shell: cmd
@@ -54,14 +54,7 @@ imgui.ini
 node_modules/

 # texture replacements
-custom_assets/jak1/texture_replacements/*
-custom_assets/jak2/texture_replacements/*
-custom_assets/jak3/texture_replacements/*
-
-# merc replacements
-custom_assets/jak1/merc_replacements/*
-custom_assets/jak2/merc_replacements/*
-custom_assets/jak3/merc_replacements/*
+texture_replacements/*

 # generated cmake files
 svnrev.h
@@ -83,4 +76,3 @@ __pycache__/
 /TODO.md
 unifont-15.0.03.ttf
 *.diff
-goalc-report.html
@@ -0,0 +1 @@
+endOfLine: "auto"
@@ -1,11 +0,0 @@
-{
-  "endOfLine": "auto",
-  "overrides": [
-    {
-      "files": ["**/*.jsonc"],
-      "options": {
-        "parser": "json"
-      }
-    }
-  ]
-}
@@ -7,58 +7,42 @@
      "project": "CMakeLists.txt",
      "projectTarget": "goalc-test.exe (bin\\goalc-test.exe)",
      "name": "Tests - Unit-Tests - Summary",
-      "args": [
-        "--gtest_brief=1"
-      ]
+      "args": ["--gtest_brief=1"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "goalc-test.exe (bin\\goalc-test.exe)",
      "name": "Tests - Unit-Tests - Verbose",
-      "args": [
-        "--gtest_brief=0"
-      ]
+      "args": ["--gtest_brief=0"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "goalc-test.exe (bin\\goalc-test.exe)",
      "name": "Tests - Draft Tests - Verbose",
-      "args": [
-        "--gtest_brief=0",
-        "--gtest_filter=\"*Draft*\""
-      ]
+      "args": ["--gtest_brief=0", "--gtest_filter=\"*Draft*\""]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "goalc-test.exe (bin\\goalc-test.exe)",
      "name": "Tests - TypeConsistency - Verbose",
-      "args": [
-        "--gtest_brief=0",
-        "--gtest_filter=\"*TypeConsistency*\""
-      ]
+      "args": ["--gtest_brief=0", "--gtest_filter=\"*TypeConsistency*\""]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "goalc-test.exe (bin\\goalc-test.exe)",
      "name": "Tests - TypeConsistency - Jak 2 - Verbose",
-      "args": [
-        "--gtest_brief=0",
-        "--gtest_filter=\"*Jak2TypeConsistency*\""
-      ]
+      "args": ["--gtest_brief=0", "--gtest_filter=\"*Jak2TypeConsistency*\""]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "goalc-test.exe (bin\\goalc-test.exe)",
      "name": "Tests - WithGameTests - Verbose",
-      "args": [
-        "--gtest_brief=0",
-        "--gtest_filter=\"*WithGameTests*\""
-      ]
+      "args": ["--gtest_brief=0", "--gtest_filter=\"*WithGameTests*\""]
    },
    {
      "type": "default",
@@ -84,18 +68,6 @@
        "jak2"
      ]
    },
-    {
-      "type": "default",
-      "project": "CMakeLists.txt",
-      "projectTarget": "offline-test.exe (bin\\offline-test.exe)",
-      "name": "Tests - Offline Tests - Jak 3",
-      "args": [
-        "--iso_data_path",
-        "${workspaceRoot}/iso_data/jak3",
-        "--game",
-        "jak3"
-      ]
-    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
@@ -129,109 +101,56 @@
      "project": "CMakeLists.txt",
      "projectTarget": "gk.exe (bin\\gk.exe)",
      "name": "Game - Jak 1 - Runtime",
-      "args": [
-        "-v",
-        "--game",
-        "jak1",
-        "--",
-        "-fakeiso",
-        "-debug"
-      ]
+      "args": ["-v", "--game", "jak1", "--", "-fakeiso", "-debug"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "gk.exe (bin\\gk.exe)",
      "name": "Game - Jak 1 - Runtime (boot)",
-      "args": [
-        "-v",
-        "--game",
-        "jak1",
-        "--",
-        "-boot",
-        "-fakeiso",
-        "-debug"
-      ]
+      "args": ["-v", "--game", "jak1", "--", "-boot", "-fakeiso", "-debug"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "gk.exe (bin\\gk.exe)",
      "name": "Game - Jak 2 - Runtime (no boot)",
-      "args": [
-        "-v",
-        "--game",
-        "jak2",
-        "--",
-        "-fakeiso",
-        "-debug"
-      ]
+      "args": ["-v", "--game", "jak2", "--", "-fakeiso", "-debug"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "gk.exe (bin\\gk.exe)",
      "name": "Game - Jak 2 - Runtime (boot)",
-      "args": [
-        "-v",
-        "--game",
-        "jak2",
-        "--",
-        "-boot",
-        "-fakeiso",
-        "-debug"
-      ]
+      "args": ["-v", "--game", "jak2", "--", "-boot", "-fakeiso", "-debug"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "gk.exe (bin\\gk.exe)",
      "name": "Game - Jak 2 - Runtime (release)",
-      "args": [
-        "-v",
-        "--game",
-        "jak2",
-        "--",
-        "-boot",
-        "-fakeiso"
-      ]
+      "args": ["-v", "--game", "jak2", "--", "-boot", "-fakeiso"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
-      "projectTarget": "gk.exe (bin\\gk.exe)",
-      "name": "Game - Jak 3 - Runtime (boot)",
-      "args": [
-        "-v",
-        "--game",
-        "jak3",
-        "--",
-        "-boot",
-        "-fakeiso",
-        "-debug"
-      ]
+      "projectTarget": "goalc.exe (bin\\goalc.exe)",
+      "name": "REPL",
+      "args": ["--user-auto"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "goalc.exe (bin\\goalc.exe)",
      "name": "REPL - Jak 1",
-      "args": [
-        "--user-auto",
-        "--game",
-        "jak1"
-      ]
+      "args": ["--user-auto", "--game", "jak1"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "goalc.exe (bin\\goalc.exe)",
      "name": "REPL - Jak 2",
-      "args": [
-        "--user-auto",
-        "--game",
-        "jak2"
-      ]
+      "args": ["--user-auto", "--game", "jak2"]
    },
    {
      "type": "default",
@@ -299,58 +218,19 @@
        "--config-override \"{\\\"decompile_code\\\": false, \\\"levels_extract\\\": true, \\\"allowed_objects\\\": []}\""
      ]
    },
-    {
-      "type": "default",
-      "project": "CMakeLists.txt",
-      "projectTarget": "decompiler.exe (bin\\decompiler.exe)",
-      "name": "Decompiler - Jak 3",
-      "args": [
-        "${workspaceRoot}/decompiler/config/jak3/jak3_config.jsonc",
-        "${workspaceRoot}/iso_data",
-        "${workspaceRoot}/decompiler_out",
-        "--version",
-        "ntsc_v1"
-      ]
-    },
-    {
-      "type": "default",
-      "project": "CMakeLists.txt",
-      "projectTarget": "decompiler.exe (bin\\decompiler.exe)",
-      "name": "Decompiler - Jak 3 - Extract",
-      "args": [
-        "${workspaceRoot}/decompiler/config/jak3/jak3_config.jsonc",
-        "${workspaceRoot}/iso_data",
-        "${workspaceRoot}/decompiler_out",
-        "--version",
-        "ntsc_v1",
-        "--config-override \"{\\\"decompile_code\\\": false, \\\"levels_extract\\\": true, \\\"allowed_objects\\\": []}\""
-      ]
-    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "memory_dump_tool.exe (bin\\memory_dump_tool.exe)",
      "name": "Tools - EE Memory Analyze - Jak 1",
-      "args": [
-        "\"${workspaceRoot}/eeMemory.bin\"",
-        "--output-path",
-        "\"${workspaceRoot}\"",
-        "--game",
-        "jak1"
-      ]
+      "args": ["\"${workspaceRoot}/eeMemory.bin\"", "--output-path", "\"${workspaceRoot}\"", "--game", "jak1"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "memory_dump_tool.exe (bin\\memory_dump_tool.exe)",
      "name": "Tools - EE Memory Analyze - Jak 2",
-      "args": [
-        "\"${workspaceRoot}/eeMemory.bin\"",
-        "--output-path",
-        "\"${workspaceRoot}\"",
-        "--game",
-        "jak2"
-      ]
+      "args": ["\"${workspaceRoot}/eeMemory.bin\"", "--output-path", "\"${workspaceRoot}\"", "--game", "jak2"]
    },
    {
      "type": "default",
@@ -367,53 +247,35 @@
      "project": "CMakeLists.txt",
      "projectTarget": "extractor.exe (bin\\extractor.exe)",
      "name": "Tools - Extractor - Full",
-      "args": [
-        "\"E:\\ISOs\\Jak\\Jak 1.iso\""
-      ]
+      "args": ["\"E:\\ISOs\\Jak\\Jak 1.iso\""]
    },
    {
-      "type": "default",
-      "project": "CMakeLists.txt",
-      "projectTarget": "lsp.exe (bin\\lsp.exe)",
-      "name": "Tools - LSP",
-      "args": []
+      "type" : "default",
+      "project" : "CMakeLists.txt",
+      "projectTarget" : "lsp.exe (bin\\lsp.exe)",
+      "name" : "Tools - LSP",
+      "args" : []
    },
    {
-      "type": "default",
-      "project": "CMakeLists.txt",
-      "projectTarget": "type_searcher.exe (bin\\type_searcher.exe)",
-      "name": "Tools - Type Searcher",
-      "args": [
-        "--game",
-        "jak2",
-        "--output-path",
-        "./search-results.json",
-        "--size",
-        255,
-        "--fields",
-        "[{\\\"type\\\":\\\"quaternion\\\",\\\"offset\\\":48}]"
-      ]
+      "type" : "default",
+      "project" : "CMakeLists.txt",
+      "projectTarget" : "type_searcher.exe (bin\\type_searcher.exe)",
+      "name" : "Tools - Type Searcher",
+      "args" : ["--game", "jak2", "--output-path", "./search-results.json", "--size", 255, "--fields", "[{\\\"type\\\":\\\"quaternion\\\",\\\"offset\\\":48}]"]
    },
    {
-      "type": "default",
-      "project": "CMakeLists.txt",
-      "projectTarget": "formatter.exe (bin\\formatter.exe)",
-      "name": "Tools - Formatter - Inplace",
-      "args": [
-        "--write",
-        "--file",
-        "C:\\Users\\xtvas\\Repositories\\opengoal\\jak-project\\goal_src\\jak1\\engine\\camera\\cam-states.gc"
-      ]
+      "type" : "default",
+      "project" : "CMakeLists.txt",
+      "projectTarget" : "formatter.exe (bin\\formatter.exe)",
+      "name" : "Tools - Formatter - Inplace",
+      "args" : ["--write", "--file", "C:\\Users\\xtvas\\Repos\\opengoal\\jak-project\\goal_src\\jak2\\pc\\util\\popup-menu-h.gc"]
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "goalc-test.exe (bin\\goalc-test.exe)",
      "name": "Tests - Formatter",
-      "args": [
-        "--gtest_brief=0",
-        "--gtest_filter=\"*FormatterTests*\""
-      ]
+      "args": ["--gtest_brief=0", "--gtest_filter=\"*FormatterTests*\""]
    }
  ]
-}
+}
@@ -5,13 +5,13 @@
  "version": "0.2.0",
  "configurations": [
    {
-      "name": "run python script",
+      "name": "Append File Docs",
      "type": "python",
      "request": "launch",
-      "program": "${workspaceFolder}/scripts/gsrc/compare-compilation-outputs.py",
+      "program": "${workspaceFolder}/scripts/ci/lint-characters.py",
      "console": "integratedTerminal",
      "cwd": "${workspaceFolder}",
-      "args": []
+      "args": ["--fix"]
    },
  ]
 }
@@ -5,8 +5,101 @@
      "comments": true,
      "strings": true
    },
-    "editor.wordBasedSuggestions": "matchingDocuments",
+    "editor.wordBasedSuggestions": true,
    "editor.snippetSuggestions": "top"
  },
-  "cmake.configureOnOpen": false
+  "python.formatting.provider": "black",
+  "files.associations": {
+    "optional": "cpp",
+    "algorithm": "cpp",
+    "any": "cpp",
+    "array": "cpp",
+    "atomic": "cpp",
+    "bit": "cpp",
+    "bitset": "cpp",
+    "cctype": "cpp",
+    "charconv": "cpp",
+    "chrono": "cpp",
+    "cinttypes": "cpp",
+    "clocale": "cpp",
+    "cmath": "cpp",
+    "codecvt": "cpp",
+    "compare": "cpp",
+    "concepts": "cpp",
+    "condition_variable": "cpp",
+    "cstdarg": "cpp",
+    "cstddef": "cpp",
+    "cstdint": "cpp",
+    "cstdio": "cpp",
+    "cstdlib": "cpp",
+    "cstring": "cpp",
+    "ctime": "cpp",
+    "cwchar": "cpp",
+    "cwctype": "cpp",
+    "deque": "cpp",
+    "exception": "cpp",
+    "filesystem": "cpp",
+    "format": "cpp",
+    "forward_list": "cpp",
+    "fstream": "cpp",
+    "functional": "cpp",
+    "future": "cpp",
+    "initializer_list": "cpp",
+    "iomanip": "cpp",
+    "ios": "cpp",
+    "iosfwd": "cpp",
+    "iostream": "cpp",
+    "istream": "cpp",
+    "iterator": "cpp",
+    "limits": "cpp",
+    "list": "cpp",
+    "locale": "cpp",
+    "map": "cpp",
+    "memory": "cpp",
+    "mutex": "cpp",
+    "new": "cpp",
+    "numeric": "cpp",
+    "ostream": "cpp",
+    "queue": "cpp",
+    "random": "cpp",
+    "ranges": "cpp",
+    "ratio": "cpp",
+    "regex": "cpp",
+    "set": "cpp",
+    "shared_mutex": "cpp",
+    "span": "cpp",
+    "sstream": "cpp",
+    "stack": "cpp",
+    "stdexcept": "cpp",
+    "stop_token": "cpp",
+    "streambuf": "cpp",
+    "string": "cpp",
+    "system_error": "cpp",
+    "thread": "cpp",
+    "tuple": "cpp",
+    "type_traits": "cpp",
+    "typeinfo": "cpp",
+    "unordered_map": "cpp",
+    "unordered_set": "cpp",
+    "utility": "cpp",
+    "valarray": "cpp",
+    "variant": "cpp",
+    "vector": "cpp",
+    "xfacet": "cpp",
+    "xhash": "cpp",
+    "xiosbase": "cpp",
+    "xlocale": "cpp",
+    "xlocbuf": "cpp",
+    "xlocinfo": "cpp",
+    "xlocmes": "cpp",
+    "xlocmon": "cpp",
+    "xlocnum": "cpp",
+    "xloctime": "cpp",
+    "xmemory": "cpp",
+    "xstddef": "cpp",
+    "xstring": "cpp",
+    "xtr1common": "cpp",
+    "xtree": "cpp",
+    "xutility": "cpp"
+  }
 }
@@ -1,7 +1,7 @@
 # Top Level CMakeLists.txt
 cmake_minimum_required(VERSION 3.10)

-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 17)
 project(jak)
 include(CTest)

@@ -39,6 +39,7 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
        -fcxx-exceptions \
        -fexceptions \
        -fdiagnostics-color=always \
+        -std=c++17 \
        -mavx \
        -Wall \
        -Wno-c++11-narrowing \
@@ -85,6 +86,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        -Wdisabled-optimization \
        -Wformat \
        -Wextra \
+        -Wmissing-include-dirs \
        -Woverloaded-virtual \
        -Wredundant-decls \
        -Wshadow \
@@ -101,6 +103,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
    message(STATUS "AppleClang detected - Setting Defaults")
    set(CMAKE_CXX_FLAGS
        "${CMAKE_CXX_FLAGS} \
+        -march=native \
        -Wall \
        -Winit-self \
        -ggdb \
@@ -110,18 +113,13 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
        -Wdisabled-optimization \
        -Wformat \
        -Wextra \
+        -Wmissing-include-dirs \
        -Woverloaded-virtual \
        -Wredundant-decls \
        -Wshadow \
        -Wsign-promo \
        -fdiagnostics-color=always"
        )
-    
-    # pin to AVX for macOS, hopefully all macOS runners have atleast this architecture
-    # technically speaking, SSE4 is the cutoff for Apple Silicon so...only a matter of time!
-    if(NOT CMAKE_CXX_COMPILER_TARGET STREQUAL "arm64-apple-darwin")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
-    endif()

    # additional c++ flags for release mode for our projects
    if(CMAKE_BUILD_TYPE MATCHES "Release")
@@ -221,15 +219,12 @@ build_third_party_lib(sqlite3 sqlite3)

 # build tree-sitter parser
 include_directories(third-party/tree-sitter/tree-sitter/lib/include)
+include_directories(third-party/tree-sitter/tree-sitter-opengoal/include)
 build_third_party_lib(tree-sitter tree-sitter)

 # native OS dialogs for error messages
 build_third_party_lib(libtinyfiledialogs libtinyfiledialogs)

-# build format library
-include_directories(third-party/fmt/include)
-build_third_party_lib(fmt fmt)
-
 # build common library
 add_subdirectory(common)

@@ -282,6 +277,9 @@ include(test/CMakeLists.txt)
 # build lzokay library
 build_third_party_lib(lzokay lzokay)

+# build format library
+build_third_party_lib(fmt fmt)
+
 build_third_party_lib(stb_image stb_image)
 build_third_party_lib(tiny_gltf tiny_gltf)
 build_third_party_lib(xdelta3 xdelta3)
@@ -108,16 +108,6 @@
      "description": "Build with Clang with Debug Symbols",
      "inherits": ["base-windows-debug", "base-clang"]
    },
-    {
-      "name": "Debug-windows-clang-static",
-      "displayName": "Windows Static Debug (clang)",
-      "description": "Build with Clang as Debug but statically linked",
-      "inherits": ["base-windows-debug", "base-clang"],
-      "cacheVariables": {
-        "STATICALLY_LINK": "true",
-        "ZYDIS_BUILD_SHARED_LIB": "OFF"
-      }
-    },
    {
      "name": "RelWithDebInfo-windows-clang",
      "displayName": "Windows RelWithDebInfo (clang)",
@@ -74,26 +74,24 @@ tasks:
        msg: "Couldn't locate compiler executable in '{{.GOALC_BIN_RELEASE_DIR}}/goalc'"
    cmds:
      - "{{.GOALC_BIN_RELEASE_DIR}}/goalc --user-auto --game {{.GAME}}"
-  format-json:
-    desc: "Format code"
-    cmds:
-      # npm install -g prettier
-      - cmd: npx prettier --write ./decompiler/config/jak*/**/*.jsonc
-        ignore_error: true
  format:
    desc: "Format code"
    cmds:
      - cmd: python ./scripts/cpp/format-includes.py
-      - cmd: python ./scripts/ci/lint-trailing-whitespace.py --fix
      - cmd: python ./third-party/run-clang-format/run-clang-format.py -r common decompiler game goalc test tools lsp -i
-      - task: format-json
-  format-gsrc:
-    desc: "Run formatter on gsrc file"
-    preconditions:
-      - sh: test -f {{.FORMATTER_BIN_RELEASE_DIR}}/formatter{{.EXE_FILE_EXTENSION}}
-        msg: "Couldn't locate formatter executable in '{{.FORMATTER_BIN_RELEASE_DIR}}/formatter'"
+      # npm install -g prettier
+      - cmd: npx prettier --write ./decompiler/config/jak1/**/*.jsonc
+        ignore_error: true
+      - cmd: npx prettier --write ./decompiler/config/jak2/**/*.jsonc
+        ignore_error: true
+  format-json:
+    desc: "Format code"
    cmds:
-      - "{{.FORMATTER_BIN_RELEASE_DIR}}/formatter --write --file '{{.FILE}}'"
+      # npm install -g prettier
+      - cmd: npx prettier --write ./decompiler/config/jak1/**/*.jsonc
+        ignore_error: true
+      - cmd: npx prettier --write ./decompiler/config/jak2/**/*.jsonc
+        ignore_error: true
  # DECOMPILING
  decomp:
    cmds:
@@ -106,7 +104,7 @@ tasks:
      - python ./scripts/tasks/clean-decomp.py --game "{{.GAME}}"
  lint-gsrc-file:
    cmds:
-      - python ./scripts/gsrc/lint-gsrc-file.py --game {{.GAME}} --file "{{.FILE}}"
+      - python ./scripts/gsrc/lint-gsrc-file.py --game {{.GAME}} --file {{.FILE}}
  update-gsrc:
    cmds:
      - python ./scripts/gsrc/update-gsrc-via-refs.py --game "{{.GAME}}" --decompiler "{{.DECOMP_BIN_RELEASE_DIR}}/decompiler" --decompiler_config {{.DECOMP_CONFIG}} --version {{.DECOMP_CONFIG_VERSION}}
@@ -116,26 +114,8 @@ tasks:
  update-gsrc-file:
    cmds:
      - task: decomp-file
-      - python ./scripts/gsrc/update-from-decomp.py --game "{{.GAME}}" --file "{{.FILE}}"
+      - python ./scripts/gsrc/update-from-decomp.py --game "{{.GAME}}" --file {{.FILE}}
      - task: lint-gsrc-file
-  copy-common-naming:
-    cmds:
-      - python ./scripts/gsrc/copy-common-naming.py --file "{{.FILE}}" --decompiler "{{.DECOMP_BIN_RELEASE_DIR}}/decompiler"
-      - task: format-json
-  copy-common-naming-from-refs:
-    cmds:
-      - python ./scripts/gsrc/copy-common-naming.py --update-names-from-refs --decompiler "{{.DECOMP_BIN_RELEASE_DIR}}/decompiler"
-      - task: format-json
-  # ASSET RIPPING
-  rip-textures:
-    cmds:
-      - "{{.DECOMP_BIN_RELEASE_DIR}}/decompiler \"./decompiler/config/{{.DECOMP_CONFIG}}\" \"./iso_data\" \"./decompiler_out\" --version \"{{.DECOMP_CONFIG_VERSION}}\" --config-override '{\"decompile_code\": false, \"levels_extract\": true, \"save_texture_pngs\": true}'"
-  rip-levels:
-    cmds:
-      - "{{.DECOMP_BIN_RELEASE_DIR}}/decompiler \"./decompiler/config/{{.DECOMP_CONFIG}}\" \"./iso_data\" \"./decompiler_out\" --version \"{{.DECOMP_CONFIG_VERSION}}\" --config-override '{\"decompile_code\": false, \"levels_extract\": true, \"rip_levels\": true}'"
-  rip-collision:
-    cmds:
-      - "{{.DECOMP_BIN_RELEASE_DIR}}/decompiler \"./decompiler/config/{{.DECOMP_CONFIG}}\" \"./iso_data\" \"./decompiler_out\" --version \"{{.DECOMP_CONFIG_VERSION}}\" --config-override '{\"decompile_code\": false, \"levels_extract\": true, \"extract_collision\": true, \"rip_collision\": true}'"
  # TOOLS
  analyze-ee-memory:
    cmds:
@@ -161,9 +141,6 @@ tasks:
    desc: Finds and tries to fix invalid translation Characters
    cmds:
      - python ./scripts/ci/lint-characters.py --fix
-  lint:
-    cmds:
-      - python ./scripts/ci/lint-trailing-whitespace.py
  # TESTS
  offline-tests: # ran by jenkins
    cmds:
@@ -189,6 +166,9 @@ tasks:
        ignore_error: true
      - python ./scripts/update_decomp_reference.py ./failures ./test/decompiler/reference/ --game {{.GAME}}
      - task: offline-test-file
+  type-test-jak1:
+    cmds:
+      - cmd: '{{.GOALCTEST_BIN_RELEASE_DIR}}/goalc-test --gtest_brief=0 --gtest_filter="*Jak1TypeConsistency*" --gtest_break_on_failure'
  type-test:
    cmds:
-      - cmd: '{{.GOALCTEST_BIN_RELEASE_DIR}}/goalc-test --gtest_brief=0 --gtest_filter="*{{.TYPE_CONSISTENCY_TEST_FILTER}}*" --gtest_break_on_failure'
+      - cmd: '{{.GOALCTEST_BIN_RELEASE_DIR}}/goalc-test --gtest_brief=0 --gtest_filter="*Jak2TypeConsistency*" --gtest_break_on_failure'
@@ -51,7 +51,7 @@ add_library(common
        repl/config.cpp
        repl/nrepl/ReplClient.cpp
        repl/nrepl/ReplServer.cpp
-        repl/repl_wrapper.cpp
+        repl/util.cpp
        serialization/subtitles/subtitles_v1.cpp
        serialization/subtitles/subtitles_v2.cpp
        serialization/subtitles/subtitles.cpp
@@ -66,7 +66,6 @@ add_library(common
        type_system/TypeSpec.cpp
        type_system/TypeSystem.cpp
        util/Assert.cpp
-        util/ast_util.cpp
        util/BitUtils.cpp
        util/compress.cpp
        util/crc32.cpp
@@ -87,11 +86,10 @@ add_library(common
        util/term_util.cpp
        util/Timer.cpp
        util/unicode_util.cpp
-        util/gltf_util.cpp
        versions/versions.cpp
        )

-target_link_libraries(common fmt lzokay replxx libzstd_static tree-sitter sqlite3 libtinyfiledialogs tiny_gltf)
+target_link_libraries(common fmt lzokay replxx libzstd_static tree-sitter sqlite3 libtinyfiledialogs)

 if(WIN32)
    target_link_libraries(common wsock32 ws2_32 windowsapp)
@@ -3,7 +3,7 @@
 #include "common/log/log.h"
 #include "common/util/BinaryWriter.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 /*!
 * Write a wave file from a vector of samples.
@@ -56,14 +56,11 @@ void write_wave_file(const std::vector<s16>& left_samples,
  writer.write_to_file(name);
 }

-std::pair<std::vector<s16>, std::vector<s16>> decode_adpcm(BinaryReader& reader,
-                                                           const bool stereo) {
+std::pair<std::vector<s16>, std::vector<s16>> decode_adpcm(BinaryReader& reader, const bool mono) {
  std::vector<s16> left_samples;
  std::vector<s16> right_samples;
  s32 left_sample_prev[2] = {0, 0};
  s32 right_sample_prev[2] = {0, 0};
-  bool first_left = true;
-  bool first_right = true;
  constexpr s32 f1[5] = {0, 60, 115, 98, 122};
  constexpr s32 f2[5] = {0, 0, -52, -55, -60};

@@ -74,29 +71,15 @@ std::pair<std::vector<s16>, std::vector<s16>> decode_adpcm(BinaryReader& reader,
  // instead they are partitioned into contiguous 8kb (thats 8192 bytes) chunks
  // alternating left/right
  bool processing_left_chunk = true;
-  // We need to skip the vag header for each channel
-  if (first_left) {
-    reader.ffwd(48);
-    bytes_read += 48;
-    first_left = false;
-  }
  while (true) {
    if (!reader.bytes_left()) {
      break;
    }

-    if (stereo && bytes_read == 0x2000) {
+    if (bytes_read == 0x2000) {
      // switch streams
      processing_left_chunk = !processing_left_chunk;
      bytes_read = 0;
-
-      // We need to skip the vag header for each channel
-      if (first_right) {
-        // skip the header
-        reader.ffwd(48);
-        bytes_read += 48;
-        first_right = false;
-      }
    }

    u8 shift_filter = reader.read<u8>();
@@ -124,7 +107,7 @@ std::pair<std::vector<s16>, std::vector<s16>> decode_adpcm(BinaryReader& reader,
      s32 sample = (s32)(s16)(nibble << 12);
      sample >>= shift;

-      if (!stereo || processing_left_chunk) {
+      if (mono || processing_left_chunk) {
        sample += (left_sample_prev[0] * f1[filter] + left_sample_prev[1] * f2[filter] + 32) / 64;

        if (sample > 0x7fff) {
@@ -11,7 +11,7 @@
 #include "common/goal_constants.h"
 #include "common/util/Timer.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 #ifdef __linux
 #include <fcntl.h>
@@ -19,7 +19,7 @@
 #include <stdio.h>
 #include <string.h>

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"
 #include "common/log/log.h"
 // clang-format on

@@ -5,8 +5,6 @@
 #include "common/cross_sockets/XSocket.h"
 #include "common/log/log.h"

-#include "fmt/core.h"
-
 // clang-format off
 #ifdef _WIN32
 #define NOMINMAX
@@ -15,7 +13,9 @@
 #include <WinSock2.h>
 #include <WS2tcpip.h>
 #endif
+#include "common/repl/nrepl/ReplServer.h"

+#include "third-party/fmt/core.h"
 // clang-format on

 XSocketClient::XSocketClient(int _tcp_port) {
@@ -4,7 +4,7 @@
 #include "common/cross_sockets/XSocket.h"
 #include "common/common_types.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 #ifdef _WIN32
 #define NOMINMAX
@@ -35,7 +35,7 @@ void XSocketServer::shutdown_server() {
  close_server_socket();
 }

-bool XSocketServer::init_server(bool failure_may_occur) {
+bool XSocketServer::init_server() {
  listening_socket = open_socket(AF_INET, SOCK_STREAM, 0);
  if (listening_socket < 0) {
    listening_socket = -1;
@@ -76,27 +76,19 @@ bool XSocketServer::init_server(bool failure_may_occur) {
  addr.sin_port = htons(tcp_port);

  if (bind(listening_socket, (sockaddr*)&addr, sizeof(addr)) < 0) {
-    if (failure_may_occur) {
-      lg::debug("[XSocketServer:{}] failed to bind", tcp_port);
-    } else {
-      lg::error("[XSocketServer:{}] failed to bind", tcp_port);
-    }
+    lg::error("[XSocketServer:{}] failed to bind", tcp_port);
    close_server_socket();
    return false;
  }

  if (listen(listening_socket, 0) < 0) {
-    if (failure_may_occur) {
-      lg::debug("[XSocketServer:{}] failed to listen", tcp_port);
-    } else {
-      lg::error("[XSocketServer:{}] failed to listen", tcp_port);
-    }
+    lg::error("[XSocketServer:{}] failed to listen", tcp_port);
    close_server_socket();
    return false;
  }

  server_initialized = true;
-  lg::debug("[XSocketServer:{}] initialized", tcp_port);
+  lg::info("[XSocketServer:{}] initialized", tcp_port);
  post_init();
  return true;
 }
@@ -20,7 +20,7 @@ class XSocketServer {
  XSocketServer(const XSocketServer&) = delete;
  XSocketServer& operator=(const XSocketServer&) = delete;

-  bool init_server(bool failure_may_occur = false);
+  bool init_server();
  void shutdown_server();
  void close_server_socket();

@@ -9,16 +9,10 @@
 #include "third-party/sse2neon/sse2neon.h"
 #endif

-#include "common/log/log.h"
 #include "common/util/Assert.h"

 namespace tfrag3 {

-void PackedTimeOfDay::serialize(Serializer& ser) {
-  ser.from_pod_vector(&data);
-  ser.from_ptr(&color_count);
-}
-
 void PackedTieVertices::serialize(Serializer& ser) {
  ser.from_pod_vector(&color_indices);
  ser.from_pod_vector(&matrices);
@@ -48,7 +42,6 @@ void ShrubDraw::serialize(Serializer& ser) {
  ser.from_ptr(&num_triangles);
  ser.from_ptr(&first_index_index);
  ser.from_ptr(&num_indices);
-  ser.from_ptr(&proto_idx);
 }

 void InstancedStripDraw::serialize(Serializer& ser) {
@@ -77,9 +70,10 @@ void TfragTree::serialize(Serializer& ser) {
    draw.serialize(ser);
  }

+  // ser.from_pod_vector(&vertices);
  ser.from_pod_vector(&packed_vertices.vertices);
  ser.from_pod_vector(&packed_vertices.cluster_origins);
-  colors.serialize(ser);
+  ser.from_pod_vector(&colors);
  bvh.serialize(ser);
  ser.from_ptr(&use_strips);
 }
@@ -403,7 +397,7 @@ void TieTree::serialize(Serializer& ser) {
  }

  packed_vertices.serialize(ser);
-  colors.serialize(ser);
+  ser.from_pod_vector(&colors);
  bvh.serialize(ser);

  ser.from_ptr(&has_per_proto_visibility_toggle);
@@ -411,7 +405,7 @@ void TieTree::serialize(Serializer& ser) {
 }

 void ShrubTree::serialize(Serializer& ser) {
-  time_of_day_colors.serialize(ser);
+  ser.from_pod_vector(&time_of_day_colors);
  ser.from_pod_vector(&indices);
  packed_vertices.serialize(ser);
  if (ser.is_saving()) {
@@ -422,33 +416,6 @@ void ShrubTree::serialize(Serializer& ser) {
  for (auto& draw : static_draws) {
    draw.serialize(ser);
  }
-
-  ser.from_ptr(&has_per_proto_visibility_toggle);
-  ser.from_string_vector(&proto_names);
-}
-
-void HfragmentBucket::serialize(Serializer& ser) {
-  ser.from_pod_vector(&corners);
-  ser.from_ptr(&montage_table);
-}
-
-void Hfragment::serialize(Serializer& ser) {
-  ser.from_pod_vector(&vertices);
-  ser.from_pod_vector(&indices);
-  ser.from_pod_vector(&corners);
-
-  if (ser.is_saving()) {
-    ser.save<size_t>(buckets.size());
-  } else {
-    buckets.resize(ser.load<size_t>());
-  }
-  for (auto& x : buckets) {
-    x.serialize(ser);
-  }
-  time_of_day_colors.serialize(ser);
-  ser.from_ptr(&wang_tree_tex_id);
-  ser.from_ptr(&draw_mode);
-  ser.from_ptr(&occlusion_offset);
 }

 void BVH::serialize(Serializer& ser) {
@@ -492,7 +459,6 @@ void MercDraw::serialize(Serializer& ser) {
  ser.from_ptr(&first_index);
  ser.from_ptr(&index_count);
  ser.from_ptr(&num_triangles);
-  ser.from_ptr(&no_strip);
 }

 void Blerc::serialize(Serializer& ser) {
@@ -634,8 +600,6 @@ void Level::serialize(Serializer& ser) {
    tree.serialize(ser);
  }

-  hfrag.serialize(ser);
-
  collision.serialize(ser);
  merc_data.serialize(ser);

@@ -686,7 +650,8 @@ void PackedShrubVertices::memory_usage(MemoryUsageTracker* tracker) const {
 }

 void ShrubTree::memory_usage(MemoryUsageTracker* tracker) const {
-  tracker->add(MemoryUsageCategory::SHRUB_TIME_OF_DAY, sizeof(u8) * time_of_day_colors.data.size());
+  tracker->add(MemoryUsageCategory::SHRUB_TIME_OF_DAY,
+               sizeof(TimeOfDayColor) * time_of_day_colors.size());
  packed_vertices.memory_usage(tracker);
  tracker->add(MemoryUsageCategory::SHRUB_DRAW, sizeof(ShrubDraw) * static_draws.size());
  tracker->add(MemoryUsageCategory::SHRUB_IND, sizeof(u32) * indices.size());
@@ -714,7 +679,7 @@ void TieTree::memory_usage(MemoryUsageTracker* tracker) const {
                 draw.vis_groups.size() * sizeof(StripDraw::VisGroup));
  }
  packed_vertices.memory_usage(tracker);
-  tracker->add(MemoryUsageCategory::TIE_TIME_OF_DAY, sizeof(u8) * colors.data.size());
+  tracker->add(MemoryUsageCategory::TIE_TIME_OF_DAY, sizeof(TimeOfDayColor) * colors.size());

  for (auto& draw : instanced_wind_draws) {
    draw.memory_usage(tracker);
@@ -738,7 +703,7 @@ void TfragTree::memory_usage(MemoryUsageTracker* tracker) const {
                 draw.vis_groups.size() * sizeof(StripDraw::VisGroup));
  }
  packed_vertices.memory_usage(tracker);
-  tracker->add(MemoryUsageCategory::TFRAG_TIME_OF_DAY, sizeof(u8) * colors.data.size());
+  tracker->add(MemoryUsageCategory::TFRAG_TIME_OF_DAY, sizeof(TimeOfDayColor) * colors.size());
  tracker->add(MemoryUsageCategory::TFRAG_BVH, sizeof(VisNode) * bvh.vis_nodes.size());
 }

@@ -751,13 +716,6 @@ void IndexTexture::memory_usage(MemoryUsageTracker* tracker) const {
  tracker->add(MemoryUsageCategory::SPECIAL_TEXTURE, 256 * 4);  // clut
 }

-void Hfragment::memory_usage(tfrag3::MemoryUsageTracker* tracker) const {
-  tracker->add(MemoryUsageCategory::HFRAG_VERTS, vertices.size() * sizeof(HfragmentVertex));
-  tracker->add(MemoryUsageCategory::HFRAG_INDEX, indices.size() * sizeof(u32));
-  tracker->add(MemoryUsageCategory::HFRAG_TIME_OF_DAY, time_of_day_colors.data.size() * sizeof(u8));
-  tracker->add(MemoryUsageCategory::HFRAG_CORNERS, corners.size() * sizeof(HfragmentCorner));
-}
-
 void Level::memory_usage(MemoryUsageTracker* tracker) const {
  for (const auto& texture : textures) {
    texture.memory_usage(tracker);
@@ -778,7 +736,6 @@ void Level::memory_usage(MemoryUsageTracker* tracker) const {
  for (const auto& tree : shrub_trees) {
    tree.memory_usage(tracker);
  }
-  hfrag.memory_usage(tracker);
  collision.memory_usage(tracker);
  merc_data.memory_usage(tracker);
 }
@@ -822,11 +779,6 @@ void print_memory_usage(const tfrag3::Level& lev, int uncompressed_data_size) {
      {"merc-mod-draw-1", mem_use.data[tfrag3::MemoryUsageCategory::MERC_MOD_DRAW_1]},
      {"merc-mod-draw-2", mem_use.data[tfrag3::MemoryUsageCategory::MERC_MOD_DRAW_2]},
      {"blerc", mem_use.data[tfrag3::MemoryUsageCategory::BLERC]},
-      {"hfrag-verts", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_VERTS]},
-      {"hfrag-index", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_INDEX]},
-      {"hfrag-time-of-day", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_TIME_OF_DAY]},
-      {"hfrag-corners", mem_use.data[tfrag3::MemoryUsageCategory::HFRAG_CORNERS]}
-
  };
  for (auto& known : known_categories) {
    total_accounted += known.second;
@@ -839,8 +791,8 @@ void print_memory_usage(const tfrag3::Level& lev, int uncompressed_data_size) {

  for (const auto& x : known_categories) {
    if (x.second) {
-      lg::print("{:30s} : {:6d} kB {:3.1f}%\n", x.first, x.second / 1024,
-                100.f * (float)x.second / uncompressed_data_size);
+      fmt::print("{:30s} : {:6d} kB {:3.1f}%\n", x.first, x.second / 1024,
+                 100.f * (float)x.second / uncompressed_data_size);
    }
  }
 }
@@ -18,7 +18,7 @@ namespace tfrag3 {
 // - if changing any large things (vertices, vis, bvh, colors, textures) update get_memory_usage
 // - if adding a new category to the memory usage, update extract_level to print it.

-constexpr int TFRAG3_VERSION = 41;
+constexpr int TFRAG3_VERSION = 38;

 enum MemoryUsageCategory {
  TEXTURE,
@@ -61,11 +61,6 @@ enum MemoryUsageCategory {
  MERC_MOD_TABLE,
  BLERC,

-  HFRAG_VERTS,
-  HFRAG_INDEX,
-  HFRAG_TIME_OF_DAY,
-  HFRAG_CORNERS,
-
  COLLISION,

  NUM_CATEGORIES
@@ -224,8 +219,6 @@ struct ShrubDraw {

  // for debug counting.
  u32 num_triangles = 0;
-
-  u16 proto_idx = 0;
  void serialize(Serializer& ser);
 };

@@ -274,23 +267,18 @@ struct BVH {
  void serialize(Serializer& ser);
 };

-// This is split into groups of 4 colors.
-// The data in these groups is stored first by palette, then color, then channel.
-struct PackedTimeOfDay {
-  std::vector<u8> data;
-  u32 color_count = 0;
-  void serialize(Serializer& ser);
+// A time-of-day color. Each stores 8 colors. At a given "time of day", they are interpolated
+// to find a single color which goes into a color palette.
+struct TimeOfDayColor {
+  math::Vector<u8, 4> rgba[8];

-  u8 read(int color, int palette, int channel) const {
-    const int color_quad = color / 4;
-    const int color_in_quad = color % 4;
-    return data[color_quad * 4 * 4 * 8 + palette * 4 * 4 + color_in_quad * 4 + channel];
-  }
-
-  u8& read(int color, int palette, int channel) {
-    const int color_quad = color / 4;
-    const int color_in_quad = color % 4;
-    return data[color_quad * 4 * 4 * 8 + palette * 4 * 4 + color_in_quad * 4 + channel];
+  bool operator==(const TimeOfDayColor& other) const {
+    for (size_t i = 0; i < 8; i++) {
+      if (rgba[i] != other.rgba[i]) {
+        return false;
+      }
+    }
+    return true;
  }
 };

@@ -329,8 +317,8 @@ struct TfragTree {
  TFragmentTreeKind kind;        // our tfrag kind
  std::vector<StripDraw> draws;  // the actual topology and settings
  PackedTfragVertices packed_vertices;
-  PackedTimeOfDay colors;  // vertex colors (pre-interpolation)
-  BVH bvh;                 // the bvh for frustum culling
+  std::vector<TimeOfDayColor> colors;  // vertex colors (pre-interpolation)
+  BVH bvh;                             // the bvh for frustum culling
  bool use_strips = true;

  struct {
@@ -411,7 +399,7 @@ struct TieTree {
  std::array<u32, kNumTieCategories + 1> category_draw_indices;

  PackedTieVertices packed_vertices;
-  PackedTimeOfDay colors;  // vertex colors (pre-interpolation)
+  std::vector<TimeOfDayColor> colors;  // vertex colors (pre-interpolation)

  std::vector<InstancedStripDraw> instanced_wind_draws;
  std::vector<TieWindInstance> wind_instance_info;
@@ -432,7 +420,7 @@ struct TieTree {

 struct ShrubTree {
  // todo some visibility structure
-  PackedTimeOfDay time_of_day_colors;  // multiplier colors
+  std::vector<TimeOfDayColor> time_of_day_colors;  // multiplier colors

  PackedShrubVertices packed_vertices;
  std::vector<ShrubDraw> static_draws;  // the actual topology and settings
@@ -442,52 +430,11 @@ struct ShrubTree {
    std::vector<ShrubGpuVertex> vertices;  // mesh vertices
  } unpacked;

-  // jak 2 and later can toggle on and off visibility per proto by name
-  bool has_per_proto_visibility_toggle = false;
-  std::vector<std::string> proto_names;
-
  void serialize(Serializer& ser);
  void memory_usage(MemoryUsageTracker* tracker) const;
  void unpack();
 };

-struct HfragmentVertex {
-  float height = 0;
-  u32 vi = 0;
-  u16 color_index = 0;
-  u8 u = 0, v = 0;
-  u32 pad = 0;
-};
-
-struct HfragmentCorner {
-  math::Vector<float, 4> bsphere;
-  u32 vis_id = 0;
-  u32 index_start = 0;
-  u32 index_length = 0;
-  u32 num_tris = 0;
-};
-
-struct HfragmentBucket {
-  std::vector<u32> corners;
-  std::array<u16, 16> montage_table;
-  void serialize(Serializer& ser);
-};
-
-struct Hfragment {
-  std::vector<HfragmentVertex> vertices;
-  std::vector<u32> indices;
-  std::vector<HfragmentCorner> corners;
-  std::vector<HfragmentBucket> buckets;
-  PackedTimeOfDay time_of_day_colors;
-
-  std::array<s32, 4> wang_tree_tex_id;
-  DrawMode draw_mode;
-  u32 occlusion_offset;
-
-  void serialize(Serializer& ser);
-  void memory_usage(MemoryUsageTracker* tracker) const;
-};
-
 struct CollisionMesh {
  struct Vertex {
    float x, y, z;
@@ -530,8 +477,6 @@ struct MercDraw {
  u32 first_index;
  u32 index_count;
  u32 num_triangles;
-  // no strip hack for custom models
-  bool no_strip = false;
  void serialize(Serializer& ser);
 };

@@ -615,7 +560,6 @@ struct Level {
  std::array<std::vector<TfragTree>, TFRAG_GEOS> tfrag_trees;
  std::array<std::vector<TieTree>, TIE_GEOS> tie_trees;
  std::vector<ShrubTree> shrub_trees;
-  Hfragment hfrag;
  CollisionMesh collision;
  MercModelGroup merc_data;
  u16 version2 = TFRAG3_VERSION;
@@ -2,9 +2,9 @@

 #include "common/util/Assert.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

-std::string DmaTag::print() const {
+std::string DmaTag::print() {
  std::string result;
  const char* mode_names[8] = {"refe", "cnt", "next", "ref", "refs", "call", "ret", "end"};
  result += fmt::format("TAG: 0x{:08x} {:4s} qwc 0x{:04x}", addr, mode_names[(int)kind], qwc);
@@ -15,7 +15,7 @@ std::string DmaTag::print() const {
  return result;
 }

-std::string VifCode::print() const {
+std::string VifCode::print() {
  std::string result;

  switch (kind) {
@@ -11,7 +11,7 @@
 #include "common/common_types.h"
 #include "common/util/Assert.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 struct DmaStats {
  double sync_time_ms = 0;
@@ -52,7 +52,7 @@ struct DmaTag {

  bool operator!=(const DmaTag& other) const { return !((*this) == other); }

-  std::string print() const;
+  std::string print();
 };

 inline void emulate_dma(const void* source_base, void* dest_base, u32 tadr, u32 dadr) {
@@ -148,7 +148,7 @@ struct VifCode {
  u16 num;
  u16 immediate;

-  std::string print() const;
+  std::string print();
 };

 struct VifCodeStcycl {
@@ -6,7 +6,7 @@
 #include "common/log/log.h"
 #include "common/util/Timer.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 /*!
 * Convert a DMA chain to an array of bytes that can be directly fed to VIF.
@@ -2,8 +2,8 @@

 #include "common/util/Assert.h"

-#include "fmt/core.h"
-#include "fmt/format.h"
+#include "third-party/fmt/core.h"
+#include "third-party/fmt/format.h"

 std::string reg_descriptor_name(GifTag::RegisterDescriptor reg) {
  switch (reg) {
@@ -12,6 +12,7 @@ Also in general I found it _really_ hard to find modern and easy to understand a
 Atleast for me, it helps to understand the path code takes as it flows through the formatting process.  Originally I tried to do as much at once for sake of efficiency but this just makes things incredibly hard to reason about and fix bugs.  So like any problem that is complex, break it down, the formatter goes through many distinct phases chipping away at the problem:

 ```mermaid
+%%{init: {'theme': 'dark', "flowchart" : { "curve" : "basis" } } }%%
 flowchart TB
  subgraph top1 [Build a Formatting Tree]
    direction TB
@@ -2,16 +2,13 @@

 #include "formatter_tree.h"

-#include "common/formatter/rules/formatting_rules.h"
-#include "common/formatter/rules/rule_config.h"
 #include "common/log/log.h"
 #include "common/util/FileUtil.h"
-#include "common/util/ast_util.h"
 #include "common/util/string_util.h"

 #include "tree_sitter/api.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 // Declare the `tree_sitter_opengoal` function, which is
 // implemented by the `tree-sitter-opengoal` library.
@@ -33,27 +30,11 @@ int hang_indentation_width(const FormatterTreeNode& curr_node) {
  return 1 + hang_indentation_width(first_elt);
 }

-int get_total_form_inlined_width(const FormatterTreeNode& curr_node) {
-  if (curr_node.token) {
-    return curr_node.token->length();
-  }
-  int width = 1;
-  for (int i = 0; i < curr_node.refs.size(); i++) {
-    width += get_total_form_inlined_width(curr_node.refs.at(i));
-    if (i != curr_node.refs.size() - 1) {
-      width += 1;  // add the space between elements
-    }
-  }
-  return width + 1;
-}
-
-// TODO - compute length of each node and store it AOT
+// TODO - compute length of each node and store it
 void apply_formatting_config(
    FormatterTreeNode& curr_node,
    std::optional<std::shared_ptr<formatter_rules::config::FormFormattingConfig>>
-        config_from_parent = {},
-    std::optional<std::shared_ptr<formatter_rules::config::FormFormattingConfig>>
-        config_merge_from_parent = {}) {
+        config_from_parent = {}) {
  using namespace formatter_rules;
  // node is empty, base-case
  if (curr_node.token || curr_node.refs.empty()) {
@@ -69,15 +50,7 @@ void apply_formatting_config(
      predefined_config = config::opengoal_form_config.at(form_head.value());
      curr_node.formatting_config = predefined_config.value();
    }
-
-    if (config_merge_from_parent) {
-      const auto& merge_config = *config_merge_from_parent.value();
-      curr_node.formatting_config.parent_mutable_extra_indent +=
-          merge_config.parent_mutable_extra_indent;
-      curr_node.formatting_config.prevent_inlining = merge_config.prevent_inlining;
-    }
  } else if (config_from_parent) {
-    // TODO - doesn't merge just replaces, a bit inflexible
    predefined_config = *config_from_parent.value();
    curr_node.formatting_config = predefined_config.value();
  }
@@ -94,10 +67,10 @@ void apply_formatting_config(
  //
  // Otherwise, we always default to a hang.
  //
-  // NOTE - any modifications here to child elements could be superseeded later in the recursion!
-  // In order to maintain your sanity, only modify things here that _arent_ touched by default
+  // NOTE - any modifications here to child elements could be superseeded later in the recursion
+  // in order to maintain your sanity, only modify things here that _arent_ touched by default
  // configurations.  These are explicitly prepended with `parent_mutable_`
-  if (!predefined_config && !curr_node.formatting_config.config_set) {
+  if (!predefined_config) {
    if (curr_node.metadata.is_top_level) {
      curr_node.formatting_config.indentation_width = 0;
      curr_node.formatting_config.hang_forms = false;
@@ -115,7 +88,7 @@ void apply_formatting_config(
      if (curr_node.formatting_config.has_constant_pairs) {
        for (int i = 0; i < (int)curr_node.refs.size(); i++) {
          auto& child_ref = curr_node.refs.at(i);
-          const auto& type = child_ref.metadata.node_type;
+          const auto type = child_ref.metadata.node_type;
          if (constant_types.find(type) == constant_types.end() &&
              constant_pairs::is_element_second_in_constant_pair(curr_node, child_ref, i)) {
            child_ref.formatting_config.parent_mutable_extra_indent = 2;
@@ -131,8 +104,6 @@ void apply_formatting_config(
  }
  // If we are hanging, lets determine the indentation width since it is based on the form itself
  if (curr_node.formatting_config.hang_forms) {
-    // TODO - this isn't being calculated for a pre-defined config
-    // TODO - another idea is to do this during consolidation
    curr_node.formatting_config.indentation_width = hang_indentation_width(curr_node);
  }
  // iterate through the refs
@@ -140,67 +111,27 @@ void apply_formatting_config(
    auto& ref = curr_node.refs.at(i);
    if (!ref.token) {
      // If the child has a pre-defined configuration at that index, we pass it along
-      if (predefined_config && predefined_config->index_config_override.find(i) !=
-                                   predefined_config->index_config_override.end()) {
-        apply_formatting_config(ref, {}, predefined_config->index_config_override.at(i));
-      } else if (predefined_config && predefined_config->index_configs.find(i) !=
-                                          predefined_config->index_configs.end()) {
-        apply_formatting_config(ref, predefined_config->index_configs.at(i), {});
+      if (predefined_config &&
+          predefined_config->index_configs.find(i) != predefined_config->index_configs.end()) {
+        apply_formatting_config(ref, predefined_config->index_configs.at(i));
      } else if (predefined_config && predefined_config->default_index_config) {
-        apply_formatting_config(ref, predefined_config->default_index_config, {});
+        apply_formatting_config(ref, predefined_config->default_index_config);
      } else {
-        apply_formatting_config(ref, {}, {});
+        apply_formatting_config(ref);
      }
    }
  }
-  // Precompute the column widths for things like deftype fields
-  if (curr_node.formatting_config.determine_column_widths_for_list_elements) {
-    // iterate through each ref and find the max length of each index (may be a token, may not be!)
-    // then store that info in each list element's `list_element_column_widths` to be used when
-    // printing out the tokens (pad width)
-    // Find the maximum number of columns
-    int max_columns = 0;
-    for (const auto& field : curr_node.refs) {
-      if ((int)field.refs.size() > max_columns) {
-        max_columns = field.refs.size();
-      }
-    }
-    // if only one field has a value in the max col position, it looks weird for it to be indented
-    bool ignore_final_column_width = true;
-    int fields_with_atleast_max_col = 0;
-    for (const auto& field : curr_node.refs) {
-      if ((int)field.refs.size() == max_columns) {
-        fields_with_atleast_max_col++;
-        if (fields_with_atleast_max_col > 1) {
-          ignore_final_column_width = false;
-          break;
-        }
-      }
-    }
-    // Now find the column max widths
-    std::vector<int> column_max_widths = {};
-    for (int col = 0; col < max_columns; col++) {
-      column_max_widths.push_back(0);
-      // -2 because its the indentation before the final column that we want to skip
-      if (col >= curr_node.formatting_config.num_columns_to_compute_widths ||
-          (ignore_final_column_width && col == max_columns - 2)) {
-        continue;
-      }
-      for (const auto& field : curr_node.refs) {
-        if ((int)field.refs.size() > col) {
-          const auto width = get_total_form_inlined_width(field.refs.at(col));
-          if (width > column_max_widths.at(col)) {
-            column_max_widths[col] = width;
-          }
-        }
-      }
-    }
-    // Apply column info to every list
-    for (auto& field : curr_node.refs) {
-      field.formatting_config.list_element_column_widths = column_max_widths;
-      field.formatting_config.config_set = true;
-    }
+}
+
+int get_total_form_inlined_width(const FormatterTreeNode& curr_node) {
+  if (curr_node.token) {
+    return curr_node.token->length();
  }
+  int width = 1;
+  for (const auto& ref : curr_node.refs) {
+    width += get_total_form_inlined_width(ref);
+  }
+  return width + 1;
 }

 bool form_contains_comment(const FormatterTreeNode& curr_node) {
@@ -232,13 +163,6 @@ bool form_contains_node_that_prevents_inlining(const FormatterTreeNode& curr_nod

 bool can_node_be_inlined(const FormatterTreeNode& curr_node, int cursor_pos) {
  using namespace formatter_rules;
-  if (curr_node.formatting_config.force_inline) {
-    // Ensure there are no comments, this still trumps this
-    if (form_contains_comment(curr_node)) {
-      return false;
-    }
-    return true;
-  }
  // First off, we cannot inline the top level
  if (curr_node.metadata.is_top_level) {
    return false;
@@ -267,20 +191,17 @@ bool can_node_be_inlined(const FormatterTreeNode& curr_node, int cursor_pos) {
 }

 std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
-                                          std::vector<std::string> /*output*/ = {},
+                                          std::vector<std::string> output = {},
                                          int cursor_pos = 0) {
  using namespace formatter_rules;
  if (!curr_node.token && curr_node.refs.empty()) {
    // special case to handle an empty list
-    if (curr_node.node_prefix) {
-      return {fmt::format("{}()", curr_node.node_prefix.value())};
-    }
    return {"()"};
  }

  // If its a token, just print the token and move on
  if (curr_node.token) {
-    return {curr_node.token_str()};
+    return {curr_node.token.value()};
  }

  bool inline_form = can_node_be_inlined(curr_node, cursor_pos);
@@ -299,21 +220,13 @@ std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
    // Add new line entry
    if (ref.token) {
      // Cleanup block-comments
+      std::string val = ref.token.value();
      if (ref.metadata.node_type == "block_comment") {
-        const auto comment_lines = comments::format_block_comment(ref.token_str());
-        for (const auto& line : comment_lines) {
-          form_lines.push_back(line);
-        }
-      } else {
-        form_lines.push_back(ref.token_str());
-      }
-
-      if (!curr_node.metadata.is_top_level && i == (int)curr_node.refs.size() - 1 &&
-          (ref.metadata.is_comment)) {
-        // if there's an inline comment at the end of a form, we have to force the paren to the next
-        // line and do a new-line paren this is ugly, but we have no choice!
-        form_lines.push_back("");
+        // TODO - change this sanitization to return a list of lines instead of a single new-lined
+        // line
+        val = comments::format_block_comment(ref.token.value());
      }
+      form_lines.push_back(val);
    } else {
      // If it's not a token, we have to recursively build up the form
      // TODO - add the cursor_pos here
@@ -329,45 +242,23 @@ std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
    if (i == (int)curr_node.refs.size() - 1 && form_lines.size() > 1 &&
        (curr_node.formatting_config.hang_forms ||
         curr_node.formatting_config.combine_first_two_lines)) {
-      form_lines.at(0) += fmt::format(" {}", str_util::ltrim(form_lines.at(1)));
+      form_lines.at(0) += fmt::format(" {}", form_lines.at(1));
      form_lines.erase(form_lines.begin() + 1);
    } else if ((i + 1) < (int)curr_node.refs.size()) {
      const auto& next_ref = curr_node.refs.at(i + 1);
      // combine the next inline comment or constant pair
      if ((next_ref.metadata.node_type == "comment" && next_ref.metadata.is_inline) ||
          (curr_node.formatting_config.has_constant_pairs &&
-           constant_pairs::is_element_second_in_constant_pair(curr_node, next_ref, i + 1)) ||
-          constant_pairs::is_element_second_in_constant_pair_new(curr_node.refs.at(i), next_ref)) {
-        // TODO
-        // has issues with not consolidating first lines, this should probably just be moved to
-        // outside this loop for simplicity, do it later
+           constant_pairs::is_element_second_in_constant_pair(curr_node, next_ref, i + 1))) {
        if (next_ref.token) {
-          form_lines.at(form_lines.size() - 1) += fmt::format(" {}", next_ref.token_str());
+          form_lines.at(form_lines.size() - 1) += fmt::format(" {}", next_ref.token.value());
          i++;
-          // We have to handle hang-consolidation here or else it will never be reached above!
-          if (i == (int)curr_node.refs.size() - 1 && form_lines.size() > 1 &&
-              (curr_node.formatting_config.hang_forms ||
-               curr_node.formatting_config.combine_first_two_lines)) {
-            form_lines.at(0) += fmt::format(" {}", form_lines.at(1));
-            form_lines.erase(form_lines.begin() + 1);
-          }
        } else if (can_node_be_inlined(next_ref, cursor_pos)) {
          const auto& lines = apply_formatting(next_ref, {}, cursor_pos);  // TODO - cursor pos
          for (const auto& line : lines) {
            form_lines.at(form_lines.size() - 1) += fmt::format(" {}", line);
          }
          i++;
-          // We have to handle hang-consolidation here or else it will never be reached above!
-          if (i == (int)curr_node.refs.size() - 1 && form_lines.size() > 1 &&
-              (curr_node.formatting_config.hang_forms ||
-               curr_node.formatting_config.combine_first_two_lines)) {
-            form_lines.at(0) += fmt::format(" {}", form_lines.at(1));
-            form_lines.erase(form_lines.begin() + 1);
-          }
-        }
-        if (!curr_node.metadata.is_top_level && next_ref.metadata.node_type == "comment" &&
-            (i + 1) == (int)curr_node.refs.size()) {
-          form_lines.push_back("");
        }
      }
    }
@@ -378,14 +269,8 @@ std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
  }

  // Consolidate any lines if the configuration requires it
-  // TODO there is a hack here so that multi-line forms that are consolidated still line up properly
-  // i have to make consolidate a more first-class feature of the config
-  // TODO - hacky, but prevents a bad situation, clean up
-  if (curr_node.formatting_config.inline_until_index(form_lines) &&
-      !str_util::contains(form_lines.at(0), ";")) {
+  if (curr_node.formatting_config.inline_until_index(form_lines)) {
    std::vector<std::string> new_form_lines = {};
-    const auto original_form_head_width = str_util::split(form_lines.at(0), '\n').at(0).length();
-    bool consolidating_lines = true;
    for (int i = 0; i < (int)form_lines.size(); i++) {
      if (i < curr_node.formatting_config.inline_until_index(form_lines)) {
        if (new_form_lines.empty()) {
@@ -394,79 +279,51 @@ std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
          new_form_lines.at(0) += fmt::format(" {}", form_lines.at(i));
        }
      } else {
-        if (str_util::starts_with(form_lines.at(i), " ") && consolidating_lines) {
-          new_form_lines.push_back(fmt::format(
-              "{}{}", str_util::repeat(original_form_head_width, " "), form_lines.at(i)));
-        } else {
-          consolidating_lines = false;
-          new_form_lines.push_back(form_lines.at(i));
-        }
+        new_form_lines.push_back(form_lines.at(i));
      }
    }
    form_lines = new_form_lines;
  }

-  // Add any column padding
-  if (!curr_node.formatting_config.list_element_column_widths.empty()) {
-    for (int i = 0; i < (int)form_lines.size(); i++) {
-      const auto& token = form_lines.at(i);
-      if (i < (int)form_lines.size() - 1) {
-        form_lines[i] = str_util::pad_right(
-            token, curr_node.formatting_config.list_element_column_widths.at(i), ' ');
-      }
-    }
-  }
-
  // Apply necessary indentation to each line and add parens
  if (!curr_node.metadata.is_top_level) {
    std::string form_surround_start = "(";
-    if (curr_node.node_prefix) {
-      form_surround_start = fmt::format("{}(", curr_node.node_prefix.value());
-    }
    std::string form_surround_end = ")";
    form_lines[0] = fmt::format("{}{}", form_surround_start, form_lines[0]);
    form_lines[form_lines.size() - 1] =
        fmt::format("{}{}", form_lines[form_lines.size() - 1], form_surround_end);
  }
+  std::string curr_form = "";
+  if (curr_node.formatting_config.parent_mutable_extra_indent > 0) {
+    curr_form += str_util::repeat(curr_node.formatting_config.parent_mutable_extra_indent, " ");
+  }
  if (inline_form) {
-    // NOTE - not sure about this, if we are inlining a form, it always makes sense to eliminate
-    // trailing whitespace the only issue i can foresee is related to strings that span multiple
-    // lines.
-    std::vector<std::string> new_form_lines = {};
-    for (const auto& form_line : form_lines) {
-      new_form_lines.push_back(str_util::ltrim(form_line));
-    }
-    form_lines = {fmt::format("{}", fmt::join(new_form_lines, " "))};
+    form_lines = {fmt::format("{}", fmt::join(form_lines, " "))};
  } else {
-    bool currently_in_block_comment = false;
    for (int i = 0; i < (int)form_lines.size(); i++) {
-      auto& line = form_lines.at(i);
-      if (str_util::contains(line, "|#")) {
-        currently_in_block_comment = false;
-      }
-      if (i > 0 && !currently_in_block_comment) {
+      if (i > 0) {
+        auto& line = form_lines.at(i);
        line = fmt::format("{}{}",
                           str_util::repeat(curr_node.formatting_config.indentation_width_for_index(
                                                curr_node.formatting_config, i),
                                            " "),
                           line);
      }
-      if (str_util::contains(line, "#|") && !str_util::contains(line, "|#")) {
-        currently_in_block_comment = true;
-      }
    }
  }
  return form_lines;
 }

-std::string join_formatted_lines(const std::vector<std::string>& lines,
-                                 const std::string& line_ending) {
-  return fmt::format("{}", fmt::join(lines, line_ending));
+std::string join_formatted_lines(const std::vector<std::string> lines) {
+  // TODO - respect original file line endings
+  return fmt::format("{}", fmt::join(lines, "\n"));
 }

 std::optional<std::string> formatter::format_code(const std::string& source) {
  // Create a parser.
  std::shared_ptr<TSParser> parser(ts_parser_new(), TreeSitterParserDeleter());
+
+  // Set the parser's language (JSON in this case).
  ts_parser_set_language(parser.get(), tree_sitter_opengoal());

  // Build a syntax tree based on source code stored in a string.
@@ -476,11 +333,7 @@ std::optional<std::string> formatter::format_code(const std::string& source) {

  // Get the root node of the syntax tree.
  TSNode root_node = ts_tree_root_node(tree.get());
-  if (ts_node_is_null(root_node)) {
-    lg::error("null root node");
-    return std::nullopt;
-  } else if (ts_node_has_error(root_node)) {
-    lg::error("grammar parsing error, go figure it out!");
+  if (ts_node_is_null(root_node) || ts_node_has_error(root_node)) {
    return std::nullopt;
  }

@@ -499,8 +352,7 @@ std::optional<std::string> formatter::format_code(const std::string& source) {
    const auto formatted_lines = apply_formatting(formatting_tree.root);
    // 4. Now we joint he lines together, it's easier when formatting to leave all lines independent
    // so adding indentation is easier
-    const auto formatted_source =
-        join_formatted_lines(formatted_lines, file_util::get_majority_file_line_endings(source));
+    const auto formatted_source = join_formatted_lines(formatted_lines);
    return formatted_source;
  } catch (std::exception& e) {
    lg::error("Unable to format code - {}", e.what());
@@ -3,8 +3,13 @@
 #include <optional>
 #include <string>

+#include "common/formatter/rules/formatting_rules.h"
+#include "common/formatter/rules/rule_config.h"
+
 #include "tree_sitter/api.h"

+// TODO:
+// - Considering _eventually_ adding line-length heuristics
 namespace formatter {

 struct TreeSitterParserDeleter {
@@ -2,7 +2,7 @@

 #include "common/util/string_util.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 std::string get_source_code(const std::string& source, const TSNode& node) {
  uint32_t start = ts_node_start_byte(node);
@@ -78,24 +78,16 @@ FormatterTree::FormatterTree(const std::string& source, const TSNode& root_node)
  construct_formatter_tree_recursive(source, root_node, root);
 }

-const std::unordered_map<std::string, std::vector<std::string>> node_type_ignorable_contents = {
-    {"list_lit", {"(", ")"}}};
-
 // TODO make an imperative version eventually
-// TODO - cleanup duplication
 void FormatterTree::construct_formatter_tree_recursive(const std::string& source,
                                                       TSNode curr_node,
-                                                       FormatterTreeNode& tree_node,
-                                                       std::optional<std::string> node_prefix) {
+                                                       FormatterTreeNode& tree_node) {
  if (ts_node_child_count(curr_node) == 0) {
-    auto new_node = FormatterTreeNode(source, curr_node);
-    new_node.node_prefix = node_prefix;
-    tree_node.refs.push_back(new_node);
+    tree_node.refs.push_back(FormatterTreeNode(source, curr_node));
    return;
  }
  const std::string curr_node_type = ts_node_type(curr_node);
  FormatterTreeNode list_node;
-  std::optional<std::string> next_node_prefix;
  if (curr_node_type == "list_lit") {
    list_node = FormatterTreeNode();
  } else if (curr_node_type == "str_lit") {
@@ -105,73 +97,25 @@ void FormatterTree::construct_formatter_tree_recursive(const std::string& source
    tree_node.refs.push_back(FormatterTreeNode(source, curr_node));
    return;
  } else if (curr_node_type == "quoting_lit") {
-    if (node_prefix) {
-      node_prefix.value() += "'";
-    } else {
-      node_prefix = "'";
-    }
-    construct_formatter_tree_recursive(source, ts_node_child(curr_node, 1), tree_node, node_prefix);
+    // same story for quoted symbols
+    // TODO - expect to have to add more here
+    tree_node.refs.push_back(FormatterTreeNode(source, curr_node));
    return;
-  } else if (curr_node_type == "unquoting_lit") {
-    if (node_prefix) {
-      node_prefix.value() += ",";
-    } else {
-      node_prefix = ",";
-    }
-    construct_formatter_tree_recursive(source, ts_node_child(curr_node, 1), tree_node, node_prefix);
-    return;
-  } else if (curr_node_type == "quasi_quoting_lit") {
-    if (node_prefix) {
-      node_prefix.value() += "`";
-    } else {
-      node_prefix = "`";
-    }
-    construct_formatter_tree_recursive(source, ts_node_child(curr_node, 1), tree_node, node_prefix);
-    return;
-  } else if (curr_node_type == "unquote_splicing_lit") {
-    if (node_prefix) {
-      node_prefix.value() += ",@";
-    } else {
-      node_prefix = ",@";
-    }
-    construct_formatter_tree_recursive(source, ts_node_child(curr_node, 1), tree_node, node_prefix);
-    return;
-  }
-  std::vector<std::string> skippable_nodes = {};
-  if (node_type_ignorable_contents.find(curr_node_type) != node_type_ignorable_contents.end()) {
-    skippable_nodes = node_type_ignorable_contents.at(curr_node_type);
  }
  for (size_t i = 0; i < ts_node_child_count(curr_node); i++) {
    const auto child_node = ts_node_child(curr_node, i);
-    auto debug_child = ts_node_string(child_node);
+    // We skip parens
    const auto contents = get_source_code(source, child_node);
-    bool skip_node = false;
-    for (const auto& skippable_content : skippable_nodes) {
-      if (skippable_content == contents) {
-        skip_node = true;
-        break;
-      }
-    }
-    if (skip_node) {
+    if (contents == "(" || contents == ")") {
      continue;
    }
    if (curr_node_type == "list_lit") {
-      construct_formatter_tree_recursive(source, child_node, list_node, {});
-      if (node_prefix) {
-        list_node.node_prefix = node_prefix;
-      }
+      construct_formatter_tree_recursive(source, child_node, list_node);
    } else {
-      construct_formatter_tree_recursive(source, child_node, tree_node, node_prefix);
-      if (node_prefix && !tree_node.refs.empty()) {
-        tree_node.refs.at(tree_node.refs.size() - 1).node_prefix = node_prefix;
-      }
+      construct_formatter_tree_recursive(source, child_node, tree_node);
    }
  }
  if (curr_node_type == "list_lit") {
-    // special case for empty lists
-    if (node_prefix && !list_node.node_prefix) {
-      list_node.node_prefix = node_prefix;
-    }
    tree_node.refs.push_back(list_node);
  }
 }
@@ -18,9 +18,8 @@
 // we really care about is:
 // - getting all the text tokens for the source code
 // - having them in a proper, nested format
-//
-// TLDR - The treesitter format is complicated and highly nested, leading to some very hard to
-// understand code. So my solution is atleast a 2-pass format.
+// The treesitter format is complicated and highly nested, leading to some very hard to understand
+// code. So my solution is a 2-pass format.
 //
 // Pass 1 - convert the AST into a simplified FormatterTree
 // Pass 2 - use the simplified tree to output the final code
@@ -38,9 +37,8 @@ class FormatterTreeNode {
  std::vector<FormatterTreeNode> refs;
  Metadata metadata;
  // The token is optional because list nodes do not contain a token, they just contain a bunch of
-  // eventually-containing token node refs
+  // eventually token node refs
  std::optional<std::string> token;
-  std::optional<std::string> node_prefix;

  formatter_rules::config::FormFormattingConfig formatting_config;

@@ -49,15 +47,6 @@ class FormatterTreeNode {
  FormatterTreeNode(const Metadata& _metadata) : metadata(_metadata){};

  bool is_list() const { return !token.has_value(); }
-  std::string token_str() const {
-    if (node_prefix && token) {
-      return node_prefix.value() + token.value();
-    }
-    if (token) {
-      return token.value();
-    }
-    return "";
-  }
 };

 // A FormatterTree has a very simple and crude tree structure where:
@@ -73,6 +62,5 @@ class FormatterTree {
 private:
  void construct_formatter_tree_recursive(const std::string& source,
                                          TSNode curr_node,
-                                          FormatterTreeNode& tree_node,
-                                          std::optional<std::string> node_prefix = {});
+                                          FormatterTreeNode& tree_node);
 };
@@ -2,9 +2,11 @@

 #include <set>

+#include "rule_config.h"
+
 #include "common/util/string_util.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace formatter_rules {

@@ -12,16 +14,12 @@ namespace formatter_rules {
 // differentiate between a quoted symbol and a quoted form
 const std::set<std::string> constant_types = {"kwd_lit",  "num_lit",  "str_lit",
                                              "char_lit", "null_lit", "bool_lit"};
-const std::set<std::string> constant_type_forms = {"meters", "seconds", "degrees"};

 namespace constant_list {
 bool is_constant_list(const FormatterTreeNode& node) {
  if (!node.is_list() || node.refs.empty()) {
    return false;
  }
-  if (!node.refs.at(0).token) {
-    return true;
-  }
  const auto& type = node.refs.at(0).metadata.node_type;
  return constant_types.find(type) != constant_types.end();
 }
@@ -40,28 +38,21 @@ bool should_insert_blank_line(const FormatterTreeNode& containing_node,
  if (node.metadata.is_comment && node.metadata.num_blank_lines_following == 0) {
    return false;
  }
-  // If the next form is a comment and is inline, don't insert a new line
+  // If the next form is a comment and is inline, don't insert a comment
  if ((index + 1) < (int)containing_node.refs.size() &&
      containing_node.refs.at(index + 1).metadata.is_comment &&
      containing_node.refs.at(index + 1).metadata.is_inline) {
    return false;
  }

-  if (node.formatting_config.elide_top_level_newline) {
-    if ((index + 1) < (int)containing_node.refs.size() &&
-        containing_node.refs.at(index + 1).metadata.is_comment) {
-      return true;
-    }
-    return false;
-  }
-
+  // TODO - only if the form doesn't fit on a single line
  return true;
 }

 }  // namespace blank_lines

 namespace comments {
-std::vector<std::string> format_block_comment(const std::string& comment) {
+std::string format_block_comment(const std::string& comment) {
  // Normalize block comments, remove any trailing or leading whitespace
  // Only allow annotations on the first line, like #|@file
  // Don't mess with internal indentation as the user might intend it to be a certain way.
@@ -82,22 +73,12 @@ std::vector<std::string> format_block_comment(const std::string& comment) {
  // Remove trailing whitespace
  comment_contents = str_util::rtrim(comment_contents);
  // remove |#
-  if (str_util::ends_with(comment_contents, "|#")) {
-    comment_contents.pop_back();
-    comment_contents.pop_back();
-  }
+  // TODO - check suffix
+  comment_contents.pop_back();
+  comment_contents.pop_back();
  comment_contents = str_util::rtrim(comment_contents);
-  std::vector<std::string> lines = {new_comment};
-  const auto contents_as_lines = str_util::split_string(comment_contents, "\n");
-  if (contents_as_lines.size() > 1) {
-    for (const auto& line : contents_as_lines) {
-      lines.push_back(line);
-    }
-    lines.push_back("|#");
-  } else {
-    lines.at(0) = fmt::format("{} {} |#", new_comment, str_util::trim(contents_as_lines.at(0)));
-  }
-  return lines;
+  new_comment += fmt::format("\n{}\n|#", comment_contents);
+  return new_comment;
 }
 }  // namespace comments

@@ -122,46 +103,6 @@ bool is_element_second_in_constant_pair(const FormatterTreeNode& containing_node
  return true;
 }

-// TODO - potentially remove the above
-bool is_element_second_in_constant_pair_new(const FormatterTreeNode& prev_node,
-                                            const FormatterTreeNode& curr_node) {
-  if (prev_node.metadata.node_type == "kwd_lit") {
-    // Handle standard constant types
-    // TODO - pair up sym_names as well
-    if (constant_types.find(curr_node.metadata.node_type) != constant_types.end()) {
-      if (curr_node.metadata.node_type != "kwd_lit") {
-        // NOTE - there is ambiugity here which cannot be totally solved (i think?)
-        // if the element itself is also a keyword, assume this is two adjacent keywords and they
-        // should not be paired
-        return true;
-      }
-    }
-    // Quoted symbols
-    if (curr_node.metadata.node_type == "sym_name" && curr_node.node_prefix &&
-        (curr_node.node_prefix.value() == "'" || curr_node.node_prefix.value() == ",")) {
-      return true;
-    }
-    if (!curr_node.refs.empty()) {
-      // Constant forms special cases (ie. meters)
-      if (constant_type_forms.find(curr_node.refs.at(0).token_str()) != constant_type_forms.end()) {
-        return true;
-      }
-      // If they are just a list of symbol names (enum or simple method call)
-      bool all_symbols = true;
-      for (const auto& ref : curr_node.refs) {
-        if (ref.metadata.node_type != "sym_name") {
-          all_symbols = false;
-          break;
-        }
-      }
-      if (all_symbols) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
 bool form_should_be_constant_paired(const FormatterTreeNode& node) {
  // Criteria for a list to be constant paired:
  // - needs to start with a non-symbol
@@ -36,7 +36,7 @@ bool should_insert_blank_line(const FormatterTreeNode& containing_node,
 //
 // Reference - https://github.com/kkinnear/zprint/blob/main/doc/options/comments.md
 namespace comments {
-std::vector<std::string> format_block_comment(const std::string& comment);
+std::string format_block_comment(const std::string& comment);
 }

 // Paired elements in a list will be kept in-line rather than the default new-line indentation
@@ -72,8 +72,6 @@ const static int min_pair_amount = 4;
 bool is_element_second_in_constant_pair(const FormatterTreeNode& containing_node,
                                        const FormatterTreeNode& node,
                                        const int index);
-bool is_element_second_in_constant_pair_new(const FormatterTreeNode& prev_node,
-                                            const FormatterTreeNode& curr_node);
 bool form_should_be_constant_paired(const FormatterTreeNode& node);
 }  // namespace constant_pairs

@@ -1,147 +1,24 @@
 #include "rule_config.h"

-#include "common/util/string_util.h"
+#include "common/formatter/formatter_tree.h"

 namespace formatter_rules {
 namespace config {

-static FormFormattingConfig new_inlinable_simple_flow_rule() {
-  return {.config_set = true, .hang_forms = false};
-}
-
-static FormFormattingConfig new_permissive_flow_rule() {
-  return {.config_set = true, .hang_forms = false, .combine_first_two_lines = true};
-}
-
-static FormFormattingConfig new_flow_rule(int start_index, bool has_constant_pairs = false) {
-  return {.config_set = true,
-          .hang_forms = false,
-          .inline_until_index =
-              [start_index](const std::vector<std::string>& /*curr_lines*/) { return start_index; },
-          .has_constant_pairs = has_constant_pairs};
-}
-
-static FormFormattingConfig new_function_rule(int start_index, bool has_constant_pairs = false) {
-  FormFormattingConfig cfg = {
-      .config_set = true,
-      .hang_forms = false,
-      .inline_until_index =
-          [start_index](const std::vector<std::string>& /*curr_lines*/) { return start_index; },
-      .has_constant_pairs = has_constant_pairs};
-  auto arg_list_config = std::make_shared<FormFormattingConfig>();
-  arg_list_config->force_inline = true;
-  arg_list_config->hang_forms = false;
-  cfg.index_configs.emplace(2, arg_list_config);
-  return cfg;
-}
-
-static FormFormattingConfig new_inlineable_flow_rule(int start_index,
-                                                     bool has_constant_pairs = false) {
-  return {.config_set = true,
-          .hang_forms = false,
-          .inline_until_index =
-              [start_index](const std::vector<std::string>& curr_lines) {
-                int total_width = 0;
-                for (const auto& line : curr_lines) {
-                  // Check for comments
-                  // TODO - this shows how this isn't really the best strategy but it holds up
-                  if (str_util::contains(line, ";")) {
-                    // Can't inline, there's a comment!
-                    return start_index;
-                  }
-                  total_width += line.length();
-                  // an empty line implies a new-line was forced, this is bleeding implementation
-                  // details, but fine for now
-                  if (line.empty()) {
-                    return start_index;
-                  }
-                }
-                if (total_width <= 120) {
-                  return (int)curr_lines.size();
-                }
-                return start_index;
-              },
-          .has_constant_pairs = has_constant_pairs};
-}
-
-static FormFormattingConfig new_defstate_rule(int start_index, bool has_constant_pairs = false) {
-  FormFormattingConfig cfg = {
-      .config_set = true,
-      .hang_forms = false,
-      .inline_until_index =
-          [start_index](const std::vector<std::string>& /*curr_lines*/) { return start_index; },
-      .has_constant_pairs = has_constant_pairs};
-  std::vector<int> state_handler_indexes = {4,  6, 8, 10,
-                                            12, 14};  // NOTE - not all of these have to be defined
-  for (const auto& index : state_handler_indexes) {
-    auto temp_config = std::make_shared<FormFormattingConfig>();
-    temp_config->prevent_inlining = true;
-    temp_config->parent_mutable_extra_indent = 2;
-    cfg.index_config_override.emplace(index, temp_config);
-  }
-  return cfg;
-}
-
-static FormFormattingConfig new_defmethod_rule(int start_index, bool has_constant_pairs = false) {
-  // TODO - might be nice to have a function that returns a config based on a given index, instead
-  // of hardcoding them!
-  // Right now this only works for non-`new` methods (else we may bleed into the body of a normal
-  // method)
-  auto arg_list_config = std::make_shared<FormFormattingConfig>();
-  arg_list_config->force_inline = true;
-  arg_list_config->hang_forms = false;
-  FormFormattingConfig cfg = {.config_set = true,
-                              .hang_forms = false,
-                              .inline_until_index =
-                                  [start_index](const std::vector<std::string>& curr_lines) {
-                                    if (curr_lines.size() >= 2 && curr_lines.at(1) == "new") {
-                                      // defmethod was changed to omit the type name for everything
-                                      // except the `new` method, so special case.
-                                      return start_index + 1;
-                                    }
-                                    return start_index;
-                                  },
-                              .has_constant_pairs = has_constant_pairs};
-  cfg.index_configs.emplace(2, arg_list_config);
-  return cfg;
-}
-
-static FormFormattingConfig new_lambda_rule(int start_index, bool has_constant_pairs = false) {
-  FormFormattingConfig cfg = {.config_set = true,
-                              .hang_forms = false,
-                              .inline_until_index =
-                                  [start_index](const std::vector<std::string>& curr_lines) {
-                                    if (curr_lines.size() >= 2 && curr_lines.at(1) == ":behavior") {
-                                      // defmethod was changed to omit the type name for everything
-                                      // except the `new` method, so special case.
-                                      return start_index + 2;
-                                    }
-                                    return start_index;
-                                  },
-                              .has_constant_pairs = has_constant_pairs};
-  return cfg;
-}
-
-static FormFormattingConfig new_defenum_rule() {
-  auto temp_list_config = std::make_shared<FormFormattingConfig>();
-  temp_list_config->force_inline = true;
-  temp_list_config->hang_forms = false;
-  return {
-      .config_set = true,
-      .hang_forms = false,
-      .inline_until_index = [](const std::vector<std::string>& /*curr_lines*/) { return 2; },
-      .has_constant_pairs = true,
-      .default_index_config = temp_list_config,
+// TODO - this could be greatly simplified with C++20's designated initialization
+FormFormattingConfig new_flow_rule(int start_index) {
+  FormFormattingConfig cfg;
+  cfg.hang_forms = false;
+  cfg.inline_until_index = [start_index](const std::vector<std::string>& curr_lines) {
+    return start_index;
  };
+  return cfg;
 }

-static FormFormattingConfig new_deftype_rule(
+FormFormattingConfig new_flow_rule_prevent_inlining_indexes(
    int start_index,
-    int num_columns_to_compute_widths,
    const std::vector<int>& inlining_preventation_indices) {
  FormFormattingConfig cfg;
-  cfg.has_constant_pairs = true;
-  cfg.config_set = true;
  cfg.hang_forms = false;
  cfg.inline_until_index = [start_index](std::vector<std::string> curr_lines) {
    if (curr_lines.size() >= 4 && curr_lines.at(3) == "()") {
@@ -151,38 +28,26 @@ static FormFormattingConfig new_deftype_rule(
  };
  for (const auto& index : inlining_preventation_indices) {
    auto temp_config = std::make_shared<FormFormattingConfig>();
-    temp_config->config_set = true;
    temp_config->prevent_inlining = true;
    temp_config->hang_forms = false;
    temp_config->indentation_width = 1;
-    auto temp_list_config = std::make_shared<FormFormattingConfig>();
-    temp_list_config->force_inline = true;
-    temp_list_config->hang_forms = false;
-    temp_config->default_index_config = temp_list_config;
-    if (index == 3) {
-      temp_config->determine_column_widths_for_list_elements = true;
-      temp_config->num_columns_to_compute_widths = num_columns_to_compute_widths;
-    }
    cfg.index_configs.emplace(index, temp_config);
  }
  return cfg;
 }

-static FormFormattingConfig new_binding_rule(int form_head_width) {
+FormFormattingConfig new_binding_rule() {
  FormFormattingConfig cfg;
-  cfg.config_set = true;
  cfg.hang_forms = false;
  cfg.combine_first_two_lines = true;
  auto binding_list_config = std::make_shared<FormFormattingConfig>();
-  binding_list_config->config_set = true;
  binding_list_config->hang_forms = false;
  binding_list_config->indentation_width = 1;
-  binding_list_config->indentation_width_for_index = [form_head_width](FormFormattingConfig /*cfg*/,
-                                                                       int index) {
+  binding_list_config->indentation_width_for_index = [](FormFormattingConfig /*cfg*/, int index) {
    if (index == 0) {
      return 0;
    }
-    return form_head_width;
+    return 4;
  };
  binding_list_config->should_prevent_inlining = [](FormFormattingConfig /*config*/, int num_refs) {
    // Only prevent inlining a binding list, if there are more than 1 bindings
@@ -197,108 +62,27 @@ static FormFormattingConfig new_binding_rule(int form_head_width) {
  return cfg;
 }

-static FormFormattingConfig new_inline_binding_rule(int form_head_width) {
+FormFormattingConfig new_pair_rule(bool combine_first_two_expr) {
  FormFormattingConfig cfg;
-  cfg.config_set = true;
-  cfg.hang_forms = false;
-  cfg.combine_first_two_lines = true;
-  auto binding_list_config = std::make_shared<FormFormattingConfig>();
-  binding_list_config->config_set = true;
-  binding_list_config->hang_forms = false;
-  binding_list_config->indentation_width = 1;
-  binding_list_config->indentation_width_for_index = [form_head_width](FormFormattingConfig /*cfg*/,
-                                                                       int index) {
-    if (index == 0) {
-      return 0;
-    }
-    return form_head_width;
-  };
-  binding_list_config->should_prevent_inlining = [](FormFormattingConfig /*config*/, int num_refs) {
-    return false;
-  };
-  cfg.index_configs.emplace(1, binding_list_config);
-  return cfg;
-}
-
-static FormFormattingConfig new_pair_rule(bool combine_first_two_expr) {
-  FormFormattingConfig cfg;
-  cfg.config_set = true;
  cfg.hang_forms = false;
  cfg.prevent_inlining = true;
  cfg.combine_first_two_lines = combine_first_two_expr;
  auto pair_config = std::make_shared<FormFormattingConfig>();
-  pair_config->config_set = true;
  pair_config->hang_forms = false;
  pair_config->indentation_width = 1;
  cfg.default_index_config = pair_config;
  return cfg;
 }

-static FormFormattingConfig new_top_level_inline_form(bool elide_new_line) {
-  return {.force_inline = true, .elide_top_level_newline = elide_new_line};
-}
-
 const std::unordered_map<std::string, FormFormattingConfig> opengoal_form_config = {
    {"case", new_pair_rule(true)},
-    {"case-str", new_pair_rule(true)},
    {"cond", new_pair_rule(false)},
-    {"#cond", new_pair_rule(false)},
-    {"in-package", new_top_level_inline_form(true)},
-    {"bundles", new_top_level_inline_form(true)},
-    {"require", new_top_level_inline_form(true)},
-    {"def-art-elt", new_top_level_inline_form(true)},
-    {"def-joint-node", new_top_level_inline_form(true)},
-    {"declare-file", new_top_level_inline_form(false)},
-    {"defenum", new_defenum_rule()},
-    {"defmethod", new_defmethod_rule(3)},
-    {"lambda", new_lambda_rule(2)},
-    {"deftype", new_deftype_rule(3, 1, {3, 4, 5, 6})},
+    {"defmethod", new_flow_rule(3)},
+    {"deftype", new_flow_rule_prevent_inlining_indexes(3, {3, 4, 5})},
    {"defun", new_flow_rule(3)},
-    {"defun-recursive", new_flow_rule(4)},
-    {"defun-debug-recursive", new_flow_rule(4)},
-    {"defun-debug", new_flow_rule(3)},
-    {"defbehavior", new_flow_rule(4)},
-    {"if", new_inlineable_flow_rule(2)},
-    {"#if", new_inlineable_flow_rule(2)},
-    {"define", new_permissive_flow_rule()},
-    {"def-mips2c", new_permissive_flow_rule()},
-    {"defconstant", new_permissive_flow_rule()},
-    {"defglobalconstant", new_permissive_flow_rule()},
-    {"defmethod-mips2c", new_permissive_flow_rule()},
-    {"define-extern", new_permissive_flow_rule()},
-    {"declare-type", new_permissive_flow_rule()},
-    {"defmacro", new_function_rule(3)},
-    {"desfun", new_function_rule(3)},
-    {"defskelgroup", new_flow_rule(2, true)},
-    {"defpartgroup", new_flow_rule(2, true)},
-    {"defpart", new_flow_rule(2, true)},
-    {"defstate", new_defstate_rule(3, true)},
-    {"behavior", new_flow_rule(2)},
    {"dotimes", new_flow_rule(2)},
-    {"dolist", new_flow_rule(2)},
-    {"process-spawn-function", new_flow_rule(2)},
-    {"let", new_binding_rule(4)},
-    {"protect", new_binding_rule(4)},
-    {"let*", new_binding_rule(5)},
-    {"rlet", new_binding_rule(5)},
+    {"let", new_binding_rule()},
    {"when", new_flow_rule(2)},
-    {"unless", new_flow_rule(2)},
-    {"with-profiler", new_flow_rule(2)},
-    {"with-pc", new_flow_rule(0)},
-    {"#unless", new_flow_rule(2)},
-    {"#when", new_flow_rule(2)},
-    {"countdown", new_flow_rule(2)},
-    {"until", new_flow_rule(2)},
-    {"loop", new_flow_rule(0)},
-    {"while", new_flow_rule(2)},
-    {"begin", new_flow_rule(0)},
-    {"seval", new_flow_rule(0)},
-    {"with-pp", new_flow_rule(0)},
-    {"with-gensyms", new_flow_rule(2)},
-    {"with-vf0", new_flow_rule(0)},
-    {"with-vf", new_inline_binding_rule(8)},
-    {"with-cnt-vif-block", new_inline_binding_rule(19)},
-    {"local-vars", new_inlinable_simple_flow_rule()},
    {"with-dma-buffer-add-bucket", new_flow_rule(2)}};
 }  // namespace config
 }  // namespace formatter_rules
@@ -10,11 +10,9 @@
 namespace formatter_rules {
 namespace config {
 struct FormFormattingConfig {
-  bool config_set = false;
-  bool force_inline = false;
-  bool hang_forms =
-      true;  // TODO - remove this eventually, it's only involved in setting the
-             // indentation width, which we can do via the new indentation_width function
+  // new
+  bool hang_forms = true;  // TODO - remove this eventually, it's only involved in setting the
+                           // indentation width, which we can do via the indentation_width function
  int indentation_width =
      2;  // 2 for a flow // TODO - also remove this, prefer storing the first node's width in the
          // metadata on the first pass, that's basically all this does
@@ -23,8 +21,8 @@ struct FormFormattingConfig {
  bool combine_first_two_lines =
      false;  // NOTE - basically hang, but will probably stick around after hang is gone, may be
              // redundant (inline_until_index!)
-  std::function<std::optional<int>(const std::vector<std::string>& /*curr_lines*/)>
-      inline_until_index = [](std::vector<std::string> /*curr_lines*/) { return std::nullopt; };
+  std::function<std::optional<int>(const std::vector<std::string>& curr_lines)> inline_until_index =
+      [](std::vector<std::string> curr_lines) { return std::nullopt; };
  bool has_constant_pairs = false;
  bool prevent_inlining = false;  // TODO - duplicate of below
  std::function<bool(FormFormattingConfig, int num_refs)> should_prevent_inlining =
@@ -32,14 +30,6 @@ struct FormFormattingConfig {
  int parent_mutable_extra_indent = 0;
  std::optional<std::shared_ptr<FormFormattingConfig>> default_index_config;
  std::unordered_map<int, std::shared_ptr<FormFormattingConfig>> index_configs = {};
-  // TODO / NOTe - not fully implemented, only doing `parent_mutable_extra_indent` right now
-  std::unordered_map<int, std::shared_ptr<FormFormattingConfig>> index_config_override = {};
-
-  bool determine_column_widths_for_list_elements = false;
-  int num_columns_to_compute_widths = 0;
-  std::vector<int> list_element_column_widths = {};
-
-  bool elide_top_level_newline = false;
 };

 extern const std::unordered_map<std::string, FormFormattingConfig> opengoal_form_config;
@@ -9,7 +9,7 @@
 #include "common/util/FileUtil.h"
 #include "common/common_types.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"
 #include "third-party/json.hpp"

 #ifdef OS_POSIX
@@ -26,8 +26,6 @@ u64 get_current_tid() {
 }
 #endif
 #include "common/log/log.h"
-#include "common/util/compress.h"
-#include "common/util/string_util.h"
 // clang-format on

 u64 get_current_ts() {
@@ -36,25 +34,16 @@ u64 get_current_ts() {

 GlobalProfiler::GlobalProfiler() {
  m_t0 = get_current_ts();
-  m_nodes.resize(m_max_events);
+  set_max_events(65536);
 }

-void GlobalProfiler::update_event_buffer_size(size_t new_size) {
-  m_max_events = new_size;
-  m_nodes.resize(m_max_events);
-}
-
-void GlobalProfiler::set_waiting_for_event(const std::string& event_name) {
-  if (!event_name.empty()) {
-    m_waiting_for_event = event_name;
-  }
+void GlobalProfiler::set_max_events(size_t event_count) {
+  ASSERT(!m_enabled);
+  m_nodes.resize(event_count);
 }

 void GlobalProfiler::event(const char* name, ProfNode::Kind kind) {
-  if (m_waiting_for_event && m_waiting_for_event.value() == name) {
-    m_ignore_events = true;
-  }
-  if (!m_enabled || m_ignore_events) {
+  if (!m_enabled) {
    return;
  }
  size_t my_idx = (m_next_idx++ % m_nodes.size());
@@ -74,16 +63,12 @@ void GlobalProfiler::root_event() {
  instant_event("ROOT");
 }

-size_t GlobalProfiler::get_next_idx() {
-  return (m_next_idx % m_nodes.size());
-}
-
 void GlobalProfiler::begin_event(const char* name) {
  event(name, ProfNode::BEGIN);
 }

 void GlobalProfiler::end_event() {
-  if (!m_enabled || m_ignore_events) {
+  if (!m_enabled) {
    return;
  }
  size_t my_idx = (m_next_idx++ % m_nodes.size());
@@ -102,10 +87,8 @@ void GlobalProfiler::set_enable(bool en) {
  m_enabled = en;
 }

-void GlobalProfiler::dump_to_json() {
-  if (m_enabled) {
-    set_enable(false);
-  }
+void GlobalProfiler::dump_to_json(const std::string& path) {
+  ASSERT(!m_enabled);

  nlohmann::json json;
  auto& trace_events = json["traceEvents"];
@@ -183,7 +166,7 @@ void GlobalProfiler::dump_to_json() {
      lg::debug("out of order: {} {} {} ms", event.ts / 1000.f, info.debug / 1000.f,
                (info.debug - event.ts) / 1000000.f);
      lg::debug("  idx: {}, range {} {}", event_idx, info.lowest_at_target, info.highest_at_target);
-      lg::debug("  now: {}", m_next_idx.load());
+      lg::debug("  now: {}", m_next_idx);
    }
    info.debug = event.ts;
  }
@@ -193,20 +176,7 @@ void GlobalProfiler::dump_to_json() {
              t.second.highest_at_target);
  }

-  if (m_enable_compression) {
-    const auto json_str = json.dump();
-    const auto compressed_data =
-        compression::compress_zstd_no_header(json_str.data(), json_str.size());
-    auto file_path = file_util::get_jak_project_dir() / "profile_data" /
-                     fmt::format("prof-{}.json.zst", str_util::current_local_timestamp_no_colons());
-    file_util::create_dir_if_needed_for_file(file_path);
-    file_util::write_binary_file(file_path, compressed_data.data(), compressed_data.size());
-  } else {
-    auto file_path = file_util::get_jak_project_dir() / "profile_data" /
-                     fmt::format("prof-{}.json", str_util::current_local_timestamp_no_colons());
-    file_util::create_dir_if_needed_for_file(file_path);
-    file_util::write_text_file(file_path, json.dump());
-  }
+  file_util::write_text_file(path, json.dump());
 }

 GlobalProfiler gprof;
@@ -1,7 +1,6 @@
 #pragma once

 #include <atomic>
-#include <optional>
 #include <string>
 #include <vector>

@@ -17,37 +16,24 @@ struct ProfNode {
 class GlobalProfiler {
 public:
  GlobalProfiler();
-  size_t get_max_events() { return m_max_events; }
-  void update_event_buffer_size(size_t new_size);
-  void set_waiting_for_event(const std::string& event_name);
+  void set_max_events(size_t event_count);
  void instant_event(const char* name);
  void begin_event(const char* name);
  void event(const char* name, ProfNode::Kind kind);
  void end_event();
  void clear();
  void set_enable(bool en);
-  void dump_to_json();
+  void dump_to_json(const std::string& path);
  void root_event();
-  bool is_enabled() { return m_enabled; }
-  size_t get_next_idx();
-
-  bool m_enable_compression = false;

 private:
  std::atomic_bool m_enabled = false;
-  size_t m_max_events = 65536;
  u64 m_t0 = 0;
  std::atomic_size_t m_next_idx = 0;
  std::vector<ProfNode> m_nodes;
-  // this is very niche, but sometimes you want to capture up to a given event (ie. long startup)
-  // instead of having to make the user quit and record as fast as possible, we can instead just
-  // stop capturing events once we have received what we are looking for
-  std::optional<std::string> m_waiting_for_event = {};
-  bool m_ignore_events = false;
 };

 struct ScopedEvent {
-  ScopedEvent(GlobalProfiler* _prof) : prof(_prof){};
  ScopedEvent(const ScopedEvent&) = delete;
  ScopedEvent& operator=(const ScopedEvent&) = delete;
  GlobalProfiler* prof = nullptr;
@@ -62,9 +62,15 @@ constexpr int LEVEL_MAX = 6;
 constexpr int LEVEL_TOTAL = LEVEL_MAX + 1;
 }  // namespace jak2

+// TODO copypaste from jak 2 for now
 namespace jak3 {
 // for now, we don't have the ability to extend the size of the symbol table
 constexpr s32 GOAL_MAX_SYMBOLS = 0x4000;
+constexpr s32 SYM_TABLE_MEM_SIZE = 0x30000;
+// from the "off-by-one" symbol pointer
+constexpr int SYM_TO_STRING_OFFSET = 0xff37;
+constexpr int SYM_TO_HASH_OFFSET = 0x1fe6f;
+
 // amount of levels in level heap
 constexpr int LEVEL_MAX = 10;
 // total amount of levels, including ones outside level heap (default-level)
@@ -78,7 +84,7 @@ constexpr s32 max_symbols(GameVersion version) {
    case GameVersion::Jak2:
      return jak2::GOAL_MAX_SYMBOLS;
    case GameVersion::Jak3:
-      return jak3::GOAL_MAX_SYMBOLS;
+      return jak2::GOAL_MAX_SYMBOLS;
  }
 }

@@ -16,7 +16,7 @@
 #include "common/util/string_util.h"
 #include "common/util/unicode_util.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace goos {
 Interpreter::Interpreter(const std::string& username) {
@@ -571,6 +571,104 @@ Object Interpreter::eval(Object obj, const std::shared_ptr<EnvironmentObject>& e
  }
 }

+EnvironmentMap::EnvironmentMap() {
+  clear();
+}
+
+void EnvironmentMap::clear() {
+  m_entries.clear();
+  m_power_of_two_size = 3;  // 2 ^ 3 = 8
+  m_entries.resize(8);
+  m_used_entries = 0;
+  m_next_resize = (m_entries.size() * kMaxUsed);
+  m_mask = 0b111;
+}
+
+Object* EnvironmentMap::lookup(InternedSymbolPtr str) {
+  if (m_entries.size() < 10) {
+    for (auto& e : m_entries) {
+      if (e.key == str.name_ptr) {
+        return &e.value;
+      }
+    }
+    return nullptr;
+  }
+  u32 hash = crc32((const u8*)&str.name_ptr, sizeof(const char*));
+
+  // probe
+  for (u32 i = 0; i < m_entries.size(); i++) {
+    u32 slot_addr = (hash + i) & m_mask;
+    auto& slot = m_entries[slot_addr];
+    if (!slot.key) {
+      return nullptr;
+    } else {
+      if (slot.key != str.name_ptr) {
+        continue;  // bad hash
+      }
+      return &slot.value;
+    }
+  }
+
+  // should be impossible to reach.
+  ASSERT_NOT_REACHED();
+}
+
+void EnvironmentMap::set(InternedSymbolPtr ptr, const Object& obj) {
+  u32 hash = crc32((const u8*)&ptr.name_ptr, sizeof(const char*));
+
+  // probe
+  for (u32 i = 0; i < m_entries.size(); i++) {
+    u32 slot_addr = (hash + i) & m_mask;
+    auto& slot = m_entries[slot_addr];
+    if (!slot.key) {
+      // not found, insert!
+      slot.key = ptr.name_ptr;
+      slot.value = obj;
+      m_used_entries++;
+
+      if (m_used_entries >= m_next_resize) {
+        resize();
+      }
+      return;
+    } else {
+      if (slot.key == ptr.name_ptr) {
+        slot.value = obj;
+        return;
+      }
+    }
+  }
+
+  // should be impossible to reach.
+  ASSERT_NOT_REACHED();
+}
+
+void EnvironmentMap::resize() {
+  m_power_of_two_size++;
+  m_mask = (1U << m_power_of_two_size) - 1;
+
+  std::vector<Entry> new_entries(m_entries.size() * 2);
+  for (const auto& old_entry : m_entries) {
+    if (old_entry.key) {
+      bool done = false;
+      u32 hash = crc32((const u8*)&old_entry.key, sizeof(const char*));
+      for (u32 i = 0; i < new_entries.size(); i++) {
+        u32 slot_addr = (hash + i) & m_mask;
+        auto& slot = new_entries[slot_addr];
+        if (!slot.key) {
+          slot.key = old_entry.key;
+          slot.value = std::move(old_entry.value);
+          done = true;
+          break;
+        }
+      }
+      ASSERT(done);
+    }
+  }
+
+  m_entries = std::move(new_entries);
+  m_next_resize = kMaxUsed * m_entries.size();
+}
+
 namespace {

 /*!
@@ -1790,7 +1888,7 @@ Object Interpreter::eval_format(const Object& form,
                   fmt::format_args(args2.data(), static_cast<unsigned>(args2.size())));

  if (truthy(dest)) {
-    lg::print("{}", formatted.c_str());
+    lg::print(formatted.c_str());
  }

  return StringObject::make_new(formatted);
@@ -47,7 +47,7 @@
 #include "common/util/crc32.h"
 #include "common/util/print_float.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace goos {

@@ -55,7 +55,6 @@

 #include "common/common_types.h"
 #include "common/util/Assert.h"
-#include "common/util/crc32.h"

 namespace goos {

@@ -457,111 +456,23 @@ class PairObject : public HeapObject {
  ~PairObject() = default;
 };

-template <typename T>
-class InternedPtrMap {
+class EnvironmentMap {
 public:
-  InternedPtrMap(const InternedPtrMap&) = delete;
-  InternedPtrMap& operator=(const InternedPtrMap&) = delete;
-  InternedPtrMap() { clear(); }
-
-  T* lookup(InternedSymbolPtr str) {
-    if (m_entries.size() < 10) {
-      for (auto& e : m_entries) {
-        if (e.key == str.name_ptr) {
-          return &e.value;
-        }
-      }
-      return nullptr;
-    }
-    u32 hash = crc32((const u8*)&str.name_ptr, sizeof(const char*));
-
-    // probe
-    for (u32 i = 0; i < m_entries.size(); i++) {
-      u32 slot_addr = (hash + i) & m_mask;
-      auto& slot = m_entries[slot_addr];
-      if (!slot.key) {
-        return nullptr;
-      } else {
-        if (slot.key != str.name_ptr) {
-          continue;  // bad hash
-        }
-        return &slot.value;
-      }
-    }
-
-    // should be impossible to reach.
-    ASSERT_NOT_REACHED();
-  }
-  void set(InternedSymbolPtr ptr, const T& obj) {
-    u32 hash = crc32((const u8*)&ptr.name_ptr, sizeof(const char*));
-
-    // probe
-    for (u32 i = 0; i < m_entries.size(); i++) {
-      u32 slot_addr = (hash + i) & m_mask;
-      auto& slot = m_entries[slot_addr];
-      if (!slot.key) {
-        // not found, insert!
-        slot.key = ptr.name_ptr;
-        slot.value = obj;
-        m_used_entries++;
-
-        if (m_used_entries >= m_next_resize) {
-          resize();
-        }
-        return;
-      } else {
-        if (slot.key == ptr.name_ptr) {
-          slot.value = obj;
-          return;
-        }
-      }
-    }
-
-    // should be impossible to reach.
-    ASSERT_NOT_REACHED();
-  }
-  void clear() {
-    m_entries.clear();
-    m_power_of_two_size = 3;  // 2 ^ 3 = 8
-    m_entries.resize(8);
-    m_used_entries = 0;
-    m_next_resize = (m_entries.size() * kMaxUsed);
-    m_mask = 0b111;
-  }
+  EnvironmentMap(const EnvironmentMap&) = delete;
+  EnvironmentMap& operator=(const EnvironmentMap&) = delete;
+  EnvironmentMap();
+  Object* lookup(InternedSymbolPtr ptr);
+  void set(InternedSymbolPtr ptr, const Object& obj);
+  void clear();

 private:
  struct Entry {
    const char* key = nullptr;
-    T value;
+    Object value;
  };
  std::vector<Entry> m_entries;

-  void resize() {
-    m_power_of_two_size++;
-    m_mask = (1U << m_power_of_two_size) - 1;
-
-    std::vector<Entry> new_entries(m_entries.size() * 2);
-    for (const auto& old_entry : m_entries) {
-      if (old_entry.key) {
-        bool done = false;
-        u32 hash = crc32((const u8*)&old_entry.key, sizeof(const char*));
-        for (u32 i = 0; i < new_entries.size(); i++) {
-          u32 slot_addr = (hash + i) & m_mask;
-          auto& slot = new_entries[slot_addr];
-          if (!slot.key) {
-            slot.key = old_entry.key;
-            slot.value = std::move(old_entry.value);
-            done = true;
-            break;
-          }
-        }
-        ASSERT(done);
-      }
-    }
-
-    m_entries = std::move(new_entries);
-    m_next_resize = kMaxUsed * m_entries.size();
-  }
+  void resize();
  int m_power_of_two_size = 0;
  int m_used_entries = 0;
  int m_next_resize = 0;
@@ -569,8 +480,6 @@ class InternedPtrMap {
  static constexpr float kMaxUsed = 0.7;
 };

-using EnvironmentMap = InternedPtrMap<Object>;
-
 class EnvironmentObject : public HeapObject {
 public:
  std::string name;
@@ -1,6 +1,6 @@
 #include "ParseHelpers.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace goos {

@@ -15,7 +15,7 @@
 #include "common/goos/PrettyPrinter2.h"
 #include "common/util/Assert.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace pretty_print {

@@ -3,8 +3,8 @@
 #include "common/common_types.h"
 #include "common/util/Assert.h"

-#include "fmt/core.h"
-#include "fmt/format.h"
+#include "third-party/fmt/core.h"
+#include "third-party/fmt/format.h"

 namespace pretty_print {

@@ -6,7 +6,7 @@
 #include "common/goos/Object.h"
 #include "common/util/print_float.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace pretty_print {
 namespace {
@@ -12,10 +12,11 @@
 #include "Reader.h"

 #include "common/log/log.h"
+#include "common/repl/util.h"
 #include "common/util/FileUtil.h"
 #include "common/util/FontUtils.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace goos {

@@ -237,14 +238,9 @@ Object Reader::read_from_string(const std::string& str,
 * Read a file
 */
 Object Reader::read_from_file(const std::vector<std::string>& file_path, bool check_encoding) {
-  std::string file_descriptor = fmt::format("{}", fmt::join(file_path, "/"));
-  const auto joined_file_path = file_util::get_file_path(file_path);
+  std::string joined_path = fmt::format("{}", fmt::join(file_path, "/"));

-  if (!fs::exists(joined_file_path)) {
-    throw std::runtime_error(fmt::format("Cannot read {}, file doesn't exist", joined_file_path));
-  }
-
-  auto textFrag = std::make_shared<FileText>(joined_file_path, file_descriptor);
+  auto textFrag = std::make_shared<FileText>(file_util::get_file_path(file_path), joined_path);
  db.insert(textFrag);

  auto result = internal_read(textFrag, check_encoding);
@@ -18,7 +18,7 @@

 #include "common/goos/Object.h"
 #include "common/goos/TextDB.h"
-#include "common/repl/repl_wrapper.h"
+#include "common/repl/util.h"
 #include "common/util/Assert.h"

 namespace goos {
@@ -15,7 +15,7 @@

 #include "common/util/FileUtil.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace goos {

@@ -85,9 +85,9 @@ std::pair<int, int> SourceText::get_containing_line(int offset) {
 /*!
 * Read text from a file.
 */
-FileText::FileText(const std::string& file_path, const std::string& description_name)
-    : m_filepath(file_path), m_desc_name(description_name) {
-  m_text = file_util::read_text_file(m_filepath);
+FileText::FileText(const std::string& filename, const std::string& description_name)
+    : m_filename(filename), m_desc_name(description_name) {
+  m_text = file_util::read_text_file(m_filename);
  build_offsets();
 }

@@ -80,13 +80,13 @@ class ProgramString : public SourceText {
 */
 class FileText : public SourceText {
 public:
-  FileText(const std::string& file_path, const std::string& description_name);
+  FileText(const std::string& filename, const std::string& description_name);

  std::string get_description() { return m_desc_name; }
  ~FileText() = default;

 private:
-  std::string m_filepath;
+  std::string m_filename;
  std::string m_desc_name;
 };

@@ -54,21 +54,6 @@ struct LinkHeaderV4 {
  uint32_t code_size;  // length of object data before link data starts
 };

-struct LinkHeaderV5Core {
-  uint32_t length_to_get_to_code;  // 4 length.. of link data?
-  uint16_t version;                // 8
-  uint16_t unknown;                // 10
-  uint32_t length_to_get_to_link;  // 12
-  uint32_t link_length;            // 16
-  uint8_t n_segments;              // 20
-  char name[59];                   // 21 (really??)
-};
-
-struct LinkHeaderV5 {
-  uint32_t type_tag;  // 0 always 0?
-  LinkHeaderV5Core core;
-};
-
 // when a u32/s32 symbol link contains this value, (s7 + <val>) should be a 4-byte aligned address,
 // not including the 1 byte symbol offset. (no effect in jak 1).
 constexpr u32 LINK_SYM_NO_OFFSET_FLAG = 0xbadbeef;
@@ -1,11 +1,10 @@
 #include "log.h"

-#include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
 #include <mutex>

-#include "fmt/color.h"
+#include "third-party/fmt/color.h"
 #ifdef _WIN32  // see lg::initialize
 #define NOMINMAX
 #define WIN32_LEAN_AND_MEAN
@@ -107,28 +106,7 @@ void log_print(const char* message) {
    }

    if (gLogger.stdout_log_level < lg::level::off_unless_die) {
-      fmt::print("{}", message);
-      fflush(stdout);
-      fflush(stderr);
-    }
-  }
-}
-
-void log_vprintf(const char* format, va_list arg_list) {
-  {
-    // We always immediately flush prints because since it has no associated level
-    // it could be anything from a fatal error to a useless debug log.
-    std::lock_guard<std::mutex> lock(gLogger.mutex);
-    va_list arg_list_2;
-    va_copy(arg_list_2, arg_list);
-    if (gLogger.fp) {
-      // Log to File
-      vfprintf(gLogger.fp, format, arg_list);
-      fflush(gLogger.fp);
-    }
-
-    if (gLogger.stdout_log_level < lg::level::off_unless_die) {
-      vprintf(format, arg_list_2);
+      fmt::print(message);
      fflush(stdout);
      fflush(stderr);
    }
@@ -136,11 +114,7 @@ void log_vprintf(const char* format, va_list arg_list) {
 }
 }  // namespace internal

-void printstd(const char* format, va_list arg_list) {
-  internal::log_vprintf(format, arg_list);
-}
-
-// how many extra log files for a single program should be kept
+// how many extra log files for a single program should be kept?
 constexpr int LOG_ROTATE_MAX = 10;

 void set_file(const std::string& filename,
@@ -163,7 +137,7 @@ void set_file(const std::string& filename,
        file_util::find_files_in_dir(fs::path(complete_filename).parent_path(),
                                     std::regex(fmt::format("{}\\.(\\d\\.)?log", filename)));
    for (const auto& file : old_log_files) {
-      lg::debug("removing {}", file.string());
+      lg::info("removing {}", file.string());
      fs::remove(file);
    }
    // remove the oldest log file if there are more than LOG_ROTATE_MAX
@@ -172,9 +146,9 @@ void set_file(const std::string& filename,
    // sort the names and remove them
    existing_log_files = file_util::sort_filepaths(existing_log_files, true);
    if (existing_log_files.size() > (LOG_ROTATE_MAX - 1)) {
-      lg::debug("removing {} log files", existing_log_files.size() - (LOG_ROTATE_MAX - 1));
+      lg::info("removing {} log files", existing_log_files.size() - (LOG_ROTATE_MAX - 1));
      for (int i = 0; i < (int)existing_log_files.size() - (LOG_ROTATE_MAX - 1); i++) {
-        lg::debug("removing {}", existing_log_files.at(i).string());
+        lg::info("removing {}", existing_log_files.at(i).string());
        fs::remove(existing_log_files.at(i));
      }
    }
@@ -7,8 +7,8 @@
 #endif
 #include <string>

-#include "fmt/color.h"
-#include "fmt/core.h"
+#include "third-party/fmt/color.h"
+#include "third-party/fmt/core.h"

 namespace lg {

@@ -38,7 +38,6 @@ namespace internal {
 // log implementation stuff, not to be called by the user
 void log_message(level log_level, LogTime& now, const char* message);
 void log_print(const char* message);
-void log_vprintf(const char* format, va_list arg_list);
 }  // namespace internal

 void set_file(const std::string& filename,
@@ -61,13 +60,13 @@ void log(level log_level, const std::string& format, Args&&... args) {
 #else
  now.tim = time(nullptr);
 #endif
-  std::string formatted_message = fmt::format(fmt::runtime(format), std::forward<Args>(args)...);
+  std::string formatted_message = fmt::format(format, std::forward<Args>(args)...);
  internal::log_message(log_level, now, formatted_message.c_str());
 }

 template <typename... Args>
 void print(const std::string& format, Args&&... args) {
-  std::string formatted_message = fmt::format(fmt::runtime(format), std::forward<Args>(args)...);
+  std::string formatted_message = fmt::format(format, std::forward<Args>(args)...);
  internal::log_print(formatted_message.c_str());
 }
 template <typename... Args>
@@ -76,9 +75,6 @@ void print(const fmt::text_style& ts, const std::string& format, Args&&... args)
  internal::log_print(formatted_message.c_str());
 }

-// same as print but uses the C printf instead of fmt
-void printstd(const char* format, va_list arg_list);
-
 template <typename... Args>
 void trace(const std::string& format, Args&&... args) {
  log(level::trace, format, std::forward<Args>(args)...);
@@ -2,7 +2,7 @@

 #include <cmath>

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace math {

@@ -2,26 +2,20 @@

 #include "common/versions/versions.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace REPL {
 void to_json(json& j, const Config& obj) {
  j = json{
-      {"nreplPort", obj.nrepl_port},
      {"gameVersionFolder", obj.game_version_folder},
      {"numConnectToTargetAttempts", obj.target_connect_attempts},
      {"asmFileSearchDirs", obj.asm_file_search_dirs},
      {"keybinds", obj.keybinds},
      {"perGameHistory", obj.per_game_history},
-      {"permissiveRedefinitions", obj.permissive_redefinitions},
  };
 }

 void from_json(const json& j, Config& obj) {
-  // TODO - make a camelCase variant of json_serialize/deserialize macros
-  if (j.contains("nreplPort")) {
-    j.at("nreplPort").get_to(obj.nrepl_port);
-  }
  if (j.contains("gameVersionFolder")) {
    j.at("gameVersionFolder").get_to(obj.game_version_folder);
  }
@@ -61,9 +55,6 @@ void from_json(const json& j, Config& obj) {
  if (j.contains("perGameHistory")) {
    j.at("perGameHistory").get_to(obj.per_game_history);
  }
-  if (j.contains("permissiveRedefinitions")) {
-    j.at("permissiveRedefinitions").get_to(obj.permissive_redefinitions);
-  }
  // if there is game specific configuration, override any values we just set
  if (j.contains(version_to_game_name(obj.game_version))) {
    from_json(j.at(version_to_game_name(obj.game_version)), obj);
@@ -26,14 +26,11 @@ struct KeyBind {
 void to_json(json& j, const KeyBind& obj);
 void from_json(const json& j, KeyBind& obj);

-// TODO - per-game config
 struct Config {
  GameVersion game_version;
  Config(GameVersion _game_version) : game_version(_game_version){};

  // this is the default REPL configuration
-  int nrepl_port = 8181;
-  int temp_nrepl_port = -1;
  std::string game_version_folder;
  int target_connect_attempts = 30;
  std::vector<std::string> asm_file_search_dirs = {};
@@ -48,14 +45,6 @@ struct Config {
      {KeyBind::Modifier::CTRL, "B", "Displays the most recently caught backtrace", "(:di)"},
      {KeyBind::Modifier::CTRL, "N", "Full build of the game", "(mi)"}};
  bool per_game_history = true;
-  bool permissive_redefinitions = false;
-
-  int get_nrepl_port() {
-    if (temp_nrepl_port != -1) {
-      return temp_nrepl_port;
-    }
-    return nrepl_port;
-  }
 };
 void to_json(json& j, const Config& obj);
 void from_json(const json& j, Config& obj);
@@ -4,7 +4,7 @@
 #include "common/cross_sockets/XSocket.h"
 #include "common/versions/versions.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 #ifdef _WIN32
 #define NOMINMAX
@@ -4,7 +4,7 @@
 #include "common/cross_sockets/XSocket.h"
 #include "common/versions/versions.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 #ifdef _WIN32
 #define NOMINMAX
@@ -16,6 +16,10 @@
 #include "common/log/log.h"
 // clang-format on

+// TODO - basically REPL to listen and inject commands into a running REPL
+// - we will need a C++ side client as well which will let us communicate with the repl via for
+// example, ImgUI
+//
 // TODO - The server also needs to eventually return the result of the evaluation

 ReplServer::~ReplServer() {
@@ -27,18 +31,7 @@ ReplServer::~ReplServer() {

 void ReplServer::post_init() {
  // Add the listening socket to our set of sockets
-  lg::debug("[nREPL:{}:{}] awaiting connections", tcp_port, listening_socket);
-}
-
-void ReplServer::error_response(int socket, const std::string& error) {
-  std::string msg = fmt::format("[ERROR]: {}", error);
-  auto resp = write_to_socket(socket, msg.c_str(), msg.size());
-  if (resp == -1) {
-    lg::warn("[nREPL:{}] Client Disconnected: {}", tcp_port, address_to_string(addr),
-             ntohs(addr.sin_port), socket);
-    close_socket(socket);
-    client_sockets.erase(socket);
-  }
+  lg::info("[nREPL:{}:{}] awaiting connections", tcp_port, listening_socket);
 }

 void ReplServer::ping_response(int socket) {
@@ -59,6 +52,7 @@ std::optional<std::string> ReplServer::get_msg() {

  // Add the server's main listening socket (where we accept clients from)
  FD_SET(listening_socket, &read_sockets);
+
  int max_sd = listening_socket;
  for (const int& sock : client_sockets) {
    if (sock > max_sd) {
@@ -70,11 +64,12 @@ std::optional<std::string> ReplServer::get_msg() {
  }

  // Wait for activity on _something_, with a timeout so we don't get stuck here on exit.
-  struct timeval timeout = {0, 100000};
+  struct timeval timeout;
+  timeout.tv_sec = 0;
+  timeout.tv_usec = 100000;
  auto activity = select(max_sd + 1, &read_sockets, NULL, NULL, &timeout);
-  if (activity < 0 && errno != EINTR) {
-    lg::error("[nREPL:{}] select error, returned: {}, errno: {}", tcp_port, activity,
-              strerror(errno));
+
+  if (activity < 0) {  // TODO - || error!
    return std::nullopt;
  }

@@ -83,46 +78,44 @@ std::optional<std::string> ReplServer::get_msg() {
    socklen_t addr_len = sizeof(addr);
    auto new_socket = accept_socket(listening_socket, (sockaddr*)&addr, &addr_len);
    if (new_socket < 0) {
-      if (new_socket != -1) {
-        lg::error("[nREPL:{}] accept error, returned: {}, errono: {}", tcp_port, new_socket,
-                  strerror(errno));
-      }
+      // TODO - handle error
    } else {
      lg::info("[nREPL:{}]: New socket connection: {}:{}:{}", tcp_port, address_to_string(addr),
               ntohs(addr.sin_port), new_socket);
+
      // Say hello
      ping_response(new_socket);
      // Track the new socket
      if ((int)client_sockets.size() < max_clients) {
        client_sockets.insert(new_socket);
      } else {
-        // Respond with NO and close the socket
-        lg::warn("[nREPL:{}]: Maximum clients reached. Rejecting connection.", tcp_port);
-        error_response(new_socket, "Maximum clients reached. Rejecting connection.");
-        close_socket(new_socket);
+        // TODO - Respond with NO
      }
    }
  }

-  // Check all clients for activity
-  for (auto it = client_sockets.begin(); it != client_sockets.end();) {
-    int sock = *it;
+  // otherwise (and no matter what) check all the clients to see if they have sent us anything
+  // else its some IO operation on some other socket
+  //
+  // RACE - the first client wins
+
+  // TODO - there are ways to do this with iterators but, couldn't figure it out!
+  std::vector<int> sockets_to_scan(client_sockets.begin(), client_sockets.end());
+  for (const int& sock : sockets_to_scan) {
    if (FD_ISSET(sock, &read_sockets)) {
      // Attempt to read a header
+      // TODO - should this be in a loop?
      auto req_bytes = read_from_socket(sock, header_buffer.data(), header_buffer.size());
-      if (req_bytes <= 0) {
+      if (req_bytes == 0) {
+        // Socket disconnected
        // TODO - add a queue of messages in the REPL::Wrapper so we can print _BEFORE_ the prompt
        // is output
-        if (req_bytes == 0) {
-          lg::warn("[nREPL:{}] Client Disconnected: {}", tcp_port, address_to_string(addr));
-        } else {
-          lg::warn("[nREPL:{}] Error reading from socket on {}: {}", tcp_port,
-                   address_to_string(addr), strerror(errno));
-        }
+        lg::warn("[nREPL:{}] Client Disconnected: {}", tcp_port, address_to_string(addr),
+                 ntohs(addr.sin_port), sock);
+
        // Cleanup the socket and remove it from our set
        close_socket(sock);
-        it = client_sockets.erase(it);  // Erase and move to the next element
-        continue;
+        client_sockets.erase(sock);
      } else {
        // Otherwise, process the message
        auto* header = (ReplServerHeader*)(header_buffer.data());
@@ -130,12 +123,7 @@ std::optional<std::string> ReplServer::get_msg() {
        int expected_size = header->length;
        int got = 0;
        int tries = 0;
-        bool skip_to_next_socket = false;
        while (got < expected_size) {
-          if (want_exit_callback()) {
-            lg::warn("[nREPL:{}] Terminating nREPL early", tcp_port);
-            return std::nullopt;
-          }
          tries++;
          if (tries > 100) {
            break;
@@ -147,25 +135,11 @@ std::optional<std::string> ReplServer::get_msg() {
                tcp_port, got, expected_size, buffer.size());
            return std::nullopt;
          }
-          auto bytes_read = read_from_socket(sock, buffer.data() + got, expected_size - got);
-          if (bytes_read <= 0) {
-            if (bytes_read == 0) {
-              lg::warn("[nREPL:{}] Client Disconnected: {}", tcp_port, address_to_string(addr));
-            } else {
-              lg::warn("[nREPL:{}] Error reading from socket on {}: {}", tcp_port,
-                       address_to_string(addr), strerror(errno));
-            }
-            close_socket(sock);
-            it = client_sockets.erase(it);  // Erase and move to the next element
-            skip_to_next_socket = true;
-            break;
+          auto x = read_from_socket(sock, buffer.data() + got, expected_size - got);
+          if (want_exit_callback()) {
+            return std::nullopt;
          }
-          got += bytes_read;
-          std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        }
-
-        if (skip_to_next_socket) {
-          continue;
+          got += x > 0 ? x : 0;
        }

        switch (header->type) {
@@ -179,7 +153,6 @@ std::optional<std::string> ReplServer::get_msg() {
        }
      }
    }
-    ++it;
  }
  return std::nullopt;
 }
@@ -27,6 +27,5 @@ class ReplServer : public XSocketServer {
  fd_set read_sockets;
  std::set<int> client_sockets = {};

-  void error_response(int socket, const std::string& error);
  void ping_response(int socket);
 };
@@ -1,73 +1,43 @@
-#include "repl_wrapper.h"
+#include "util.h"

 #include "common/util/FileUtil.h"
 #include "common/util/json_util.h"
 #include "common/util/string_util.h"
 #include "common/versions/versions.h"

-#include "fmt/color.h"
-#include "fmt/core.h"
+#include "third-party/fmt/color.h"
+#include "third-party/fmt/core.h"
 #include "third-party/replxx/include/replxx.hxx"
+// TODO - expand a list of hints (ie. a hint for defun to show at a glance how to write a function,
+// or perhaps, show the docstring for the current function being used?)

 namespace REPL {
 void Wrapper::clear_screen() {
  repl.clear_screen();
 }

-void Wrapper::print_welcome_message(const std::vector<std::string>& loaded_projects) {
-  std::string message;
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "        ..:::::..\n");
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "     .:-----------:.\n");
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "         .-----.");
-  message += fmt::format(fmt::emphasis::bold, "         Welcome to OpenGOAL {}.{} [{}]",
-                         versions::GOAL_VERSION_MAJOR, versions::GOAL_VERSION_MINOR,
-                         fmt::format(fg(fmt::color::gray), "{}", build_revision()));
-  if (!username.empty() && username != "#f" && username != "unknown") {
-    message += fmt::format(fg(fmt::color::light_green), " {}", username);
-  }
-  message += "!\n";
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "          .---.");
-  if (repl_config.game_version == GameVersion::Jak1) {
-    message += fmt::format("          [{}]: ", fmt::format(fg(fmt::color::orange), "jak1"));
-  } else if (repl_config.game_version == GameVersion::Jak2) {
-    message += fmt::format("          [{}]: ", fmt::format(fg(fmt::color::purple), "jak2"));
-  } else if (repl_config.game_version == GameVersion::Jak3) {
-    message += fmt::format("          [{}]: ", fmt::format(fg(fmt::color::gold), "jak3"));
-  } else {
-    message += fmt::format("          [{}]: ", fmt::format(fg(fmt::color::magenta), "jakx"));
-  }
-  const auto loaded_projects_str = fmt::format("{}", fmt::join(loaded_projects, ","));
-  message += fmt::format(fg(fmt::color::gray), "{}\n", loaded_projects_str);
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "  .        ---        .");
-  message +=
-      fmt::format("  Project Path: {}\n",
-                  fmt::format(fg(fmt::color::gray), file_util::get_jak_project_dir().string()));
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "  -       :===:       -");
-  message += "  nREPL:";
-  if (!nrepl_alive) {
-    message += fmt::format(fg(fmt::color::red), "DISABLED\n");
-  } else {
-    message += fmt::format(fg(fmt::color::light_green), " Listening on {}\n",
-                           repl_config.get_nrepl_port());
-  }
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "  --.   .--: :--.   .--");
-  message += "  Source File Search Dirs: ";
-  const auto search_dir_string =
-      fmt::format("{}", fmt::join(repl_config.asm_file_search_dirs, ","));
-  message += fmt::format("[{}]\n", fmt::format(fg(fmt::color::gray), search_dir_string));
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "  .=======.    =======.");
-  message += fmt::format("  {} or {} for basic help and usage\n",
-                         fmt::format(fg(fmt::color::cyan), "(repl-help)"),
-                         fmt::format(fg(fmt::color::cyan), "(repl-keybinds)"));
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "   .-=====-. .-=====-");
-  message +=
-      fmt::format("    {} to connect to the game\n", fmt::format(fg(fmt::color::cyan), "(lt)"));
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "     .-===========-.");
-  message += fmt::format("     {} to recompile the active project.\n",
-                         fmt::format(fg(fmt::color::cyan), "(mi)"));
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "         .-===-.\n");
-  message += fmt::format(fmt::emphasis::bold | fg(fmt::color::orange), "            .\n");
-  fmt::print("{}", message);
+void Wrapper::print_welcome_message() {
+  // TODO - dont print on std-out
+  // Welcome message / brief intro for documentation
+  std::string ascii;
+  ascii += " _____             _____ _____ _____ __    \n";
+  ascii += "|     |___ ___ ___|   __|     |  _  |  |   \n";
+  ascii += "|  |  | . | -_|   |  |  |  |  |     |  |__ \n";
+  ascii += "|_____|  _|___|_|_|_____|_____|__|__|_____|\n";
+  ascii += "      |_|                                  \n";
+  fmt::print(fmt::emphasis::bold | fg(fmt::color::orange), ascii);
+
+  fmt::print("Welcome to OpenGOAL {}.{}!\n", versions::GOAL_VERSION_MAJOR,
+             versions::GOAL_VERSION_MINOR);
+  fmt::print("Run {} or {} for help with common commands and REPL usage.\n",
+             fmt::styled("(repl-help)", fmt::emphasis::bold | fg(fmt::color::cyan)),
+             fmt::styled("(repl-keybinds)", fmt::emphasis::bold | fg(fmt::color::cyan)));
+  fmt::print("Run ");
+  fmt::print(fmt::emphasis::bold | fg(fmt::color::cyan), "(lt)");
+  fmt::print(" to connect to the local target.\n");
+  fmt::print("Run ");
+  fmt::print(fmt::emphasis::bold | fg(fmt::color::cyan), "(mi)");
+  fmt::print(" to rebuild the entire game.\n\n");
 }

 void Wrapper::print_to_repl(const std::string& str) {
@@ -272,24 +242,20 @@ StartupFile load_user_startup_file(const std::string& username, const GameVersio
  return startup_file;
 }

-REPL::Config load_repl_config(const std::string& username,
-                              const GameVersion game_version,
-                              const int nrepl_port) {
+REPL::Config load_repl_config(const std::string& username, const GameVersion game_version) {
  auto repl_config_path =
      file_util::get_jak_project_dir() / "goal_src" / "user" / username / "repl-config.json";
-  REPL::Config loaded_config(game_version);
  if (file_util::file_exists(repl_config_path.string())) {
    try {
+      REPL::Config config(game_version);
      auto repl_config_data =
          parse_commented_json(file_util::read_text_file(repl_config_path), "repl-config.json");
-      from_json(repl_config_data, loaded_config);
-      loaded_config.temp_nrepl_port = nrepl_port;
-      return loaded_config;
+      from_json(repl_config_data, config);
+      return config;
    } catch (std::exception& e) {
-      // do nothing
+      REPL::Config config(game_version);
    }
  }
-  loaded_config.temp_nrepl_port = nrepl_port;
-  return loaded_config;
+  return REPL::Config(game_version);
 }
 }  // namespace REPL
@@ -17,23 +17,18 @@ struct StartupFile {
 };

 class Wrapper {
+  replxx::Replxx repl;
+
 public:
  std::string username;
  Config repl_config;
  StartupFile startup_file;
-  bool nrepl_alive = false;
  std::vector<std::string> examples{};
  std::vector<std::pair<std::string, replxx::Replxx::Color>> regex_colors{};

  Wrapper(GameVersion version) : repl_config(version) {}
-  Wrapper(const std::string& _username,
-          const Config& config,
-          const StartupFile& startup,
-          bool _nrepl_alive)
-      : username(_username),
-        repl_config(config),
-        startup_file(startup),
-        nrepl_alive(_nrepl_alive) {}
+  Wrapper(const std::string& _username, const Config& config, const StartupFile& startup)
+      : username(_username), repl_config(config), startup_file(startup) {}
  replxx::Replxx& get_repl() { return repl; }
  void init_settings();
  void reload_startup_file();
@@ -41,7 +36,7 @@ class Wrapper {
  // Functionality / Commands
  void clear_screen();
  void print_to_repl(const std::string& str);
-  void print_welcome_message(const std::vector<std::string>& loaded_projects);
+  void print_welcome_message();
  void set_history_max_size(size_t len);
  const char* readline(const std::string& prompt);
  void add_to_history(const std::string& line);
@@ -52,14 +47,11 @@ class Wrapper {
  std::pair<std::string, bool> get_current_repl_token(std::string const& context);

 private:
-  replxx::Replxx repl;
  replxx::Replxx::key_press_handler_t commit_text_action(std::string text_to_commit);
  std::vector<REPL::KeyBind> keybindings = {};
 };

 std::string find_repl_username();
 StartupFile load_user_startup_file(const std::string& username, const GameVersion game_version);
-REPL::Config load_repl_config(const std::string& username,
-                              const GameVersion game_version,
-                              const int nrepl_port);
+REPL::Config load_repl_config(const std::string& username, const GameVersion game_version);
 }  // namespace REPL
@@ -5,7 +5,7 @@
 #include "common/util/FileUtil.h"
 #include "common/util/json_util.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 void open_subtitle_project(const std::string& project_kind,
                           const std::string& file_path,
@@ -5,7 +5,7 @@

 #include "subtitles_v2.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 void to_json(json& j, const SubtitleCutsceneLineMetadataV1& obj) {
  json_serialize(frame_start);
@@ -5,7 +5,7 @@

 #include "subtitles_v1.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 void to_json(json& j, const SubtitleLineMetadata& obj) {
  json_serialize(frame_start);
@@ -89,9 +89,7 @@ const std::unordered_map<std::string, u16> jak2_speaker_name_to_enum_val = {
    {"citizen-male", 31},
    {"citizen-female", 32},
    {"oracle", 33},
-    {"precursor", 34},
-    {"metalkor-before-consite", 35},
-    {"metalkor-intro", 36}};
+    {"precursor", 34}};

 GameSubtitlePackage read_json_files_v2(const GameSubtitleDefinitionFile& file_info) {
  GameSubtitlePackage package;
@@ -375,7 +373,7 @@ bool GameSubtitleDB::write_subtitle_db_to_files(const GameVersion game_version)
      file_util::write_text_file(dump_path, lines_file.dump(2));
    }
  } catch (std::exception& ex) {
-    lg::error("{}", ex.what());
+    lg::error(ex.what());
    return false;
  }
  return true;
@@ -150,180 +150,6 @@ constexpr int FIX_FIXED_SYM_END_OFFSET = 0xec;

 }  // namespace jak2_symbols

-namespace jak3_symbols {
-
-constexpr int FIX_SYM_EMPTY_CAR = -0x8;
-constexpr int S7_OFF_FIX_SYM_EMPTY_PAIR = -0x6 - 1;
-constexpr int FIX_SYM_EMPTY_CDR = -0x4;
-constexpr int FIX_SYM_FALSE = 0x0;  // GOAL boolean #f (note that this is equal to the $s7 register)
-constexpr int FIX_SYM_TRUE = 0x4;   // GOAL boolean #t
-constexpr int FIX_SYM_FUNCTION_TYPE = 0x8;
-constexpr int FIX_SYM_BASIC = 0xc;
-constexpr int FIX_SYM_STRING_TYPE = 0x10;
-constexpr int FIX_SYM_SYMBOL_TYPE = 0x14;
-constexpr int FIX_SYM_TYPE_TYPE = 0x18;
-constexpr int FIX_SYM_OBJECT_TYPE = 0x1c;
-constexpr int FIX_SYM_LINK_BLOCK = 0x20;
-constexpr int FIX_SYM_INTEGER = 0x24;
-constexpr int FIX_SYM_SINTEGER = 0x28;
-constexpr int FIX_SYM_UINTEGER = 0x2c;
-constexpr int FIX_SYM_BINTEGER = 0x30;
-constexpr int FIX_SYM_INT8 = 0x34;
-constexpr int FIX_SYM_INT16 = 0x38;
-constexpr int FIX_SYM_INT32 = 0x3c;
-constexpr int FIX_SYM_INT64 = 0x40;
-constexpr int FIX_SYM_INT128 = 0x44;
-constexpr int FIX_SYM_UINT8 = 0x48;
-constexpr int FIX_SYM_UINT16 = 0x4c;
-constexpr int FIX_SYM_UINT32 = 0x50;
-constexpr int FIX_SYM_UINT64 = 0x54;
-constexpr int FIX_SYM_UINT128 = 0x58;
-constexpr int FIX_SYM_FLOAT = 0x5c;
-constexpr int FIX_SYM_PROCESS_TREE = 0x60;
-constexpr int FIX_SYM_PROCESS_TYPE = 0x64;
-constexpr int FIX_SYM_THREAD = 0x68;
-constexpr int FIX_SYM_STRUCTURE = 0x6c;
-constexpr int FIX_SYM_PAIR_TYPE = 0x70;
-constexpr int FIX_SYM_POINTER = 0x74;
-constexpr int FIX_SYM_NUMBER = 0x78;
-constexpr int FIX_SYM_ARRAY = 0x7c;
-constexpr int FIX_SYM_VU_FUNCTION = 0x80;
-constexpr int FIX_SYM_CONNECTABLE = 0x84;
-constexpr int FIX_SYM_STACK_FRAME = 0x88;
-constexpr int FIX_SYM_FILE_STREAM = 0x8c;
-constexpr int FIX_SYM_HEAP = 0x90;
-constexpr int FIX_SYM_NOTHING_FUNC = 0x94;
-constexpr int FIX_SYM_DELETE_BASIC = 0x98;
-constexpr int FIX_SYM_STATIC = 0x9c;
-constexpr int FIX_SYM_GLOBAL_HEAP = 0xa0;
-constexpr int FIX_SYM_DEBUG = 0xa4;
-constexpr int FIX_SYM_LOADING_LEVEL = 0xa8;
-constexpr int FIX_SYM_LOADING_PACKAGE = 0xac;
-constexpr int FIX_SYM_PROCESS_LEVEL_HEAP = 0xb0;
-constexpr int FIX_SYM_STACK = 0xb4;
-constexpr int FIX_SYM_SCRATCH = 0xb8;
-constexpr int FIX_SYM_SCRATCH_TOP = 0xbc;
-constexpr int FIX_SYM_ZERO_FUNC = 0xc0;
-constexpr int FIX_SYM_ASIZE_OF_BASIC_FUNC = 0xc4;
-constexpr int FIX_SYM_COPY_BASIC_FUNC = 0xc8;  // bugged name
-constexpr int FIX_SYM_LEVEL = 0xcc;
-constexpr int FIX_SYM_ART_GROUP = 0xd0;
-constexpr int FIX_SYM_TEXTURE_PAGE_DIR = 0xd4;
-constexpr int FIX_SYM_TEXTURE_PAGE = 0xd8;
-constexpr int FIX_SYM_SOUND = 0xdc;
-constexpr int FIX_SYM_DGO = 0xe0;
-constexpr int FIX_SYM_TOP_LEVEL = 0xe4;
-constexpr int FIX_SYM_QUOTE = 0xe8;
-constexpr int FIX_SYM_LISTENER_LINK_BLOCK = 0xec;
-constexpr int FIX_SYM_LISTENER_FUNCTION = 0xf0;
-constexpr int FIX_SYM_STACK_TOP = 0xf4;
-constexpr int FIX_SYM_STACK_BASE = 0xf8;
-constexpr int FIX_SYM_STACK_SIZE = 0xfc;
-constexpr int FIX_SYM_KERNEL_FUNCTION = 0x100;
-constexpr int FIX_SYM_KERNEL_PACKAGES = 0x104;
-constexpr int FIX_SYM_KERNEL_BOOT_MESSAGE = 0x108;
-constexpr int FIX_SYM_KERNEL_BOOT_MODE = 0x10c;
-constexpr int FIX_SYM_KERNEL_BOOT_LEVEL = 0x110;
-constexpr int FIX_SYM_KERNEL_BOOT_ART_GROUP = 0x114;
-constexpr int FIX_SYM_KERNEL_DEBUG = 0x118;
-constexpr int FIX_SYM_KERNEL_VERSION = 0x11c;
-constexpr int FIX_SYM_KERNEL_DISPATCHER = 0x120;
-constexpr int FIX_SYM_SYNC_DISPATCHER = 0x124;
-constexpr int FIX_SYM_PRINT_COLLUMN = 0x128;
-constexpr int FIX_SYM_DEBUG_SEGMENT = 300;
-constexpr int FIX_SYM_ENABLE_METHOD_SET = 0x130;
-constexpr int FIX_SYM_SQL_RESULT = 0x134;
-constexpr int FIX_SYM_COLLAPSE_QUOTE = 0x138;
-constexpr int FIX_SYM_LEVEL_TYPE_LIST = 0x13C;
-constexpr int FIX_SYM_DECI_COUNT = 0x140;
-constexpr int FIX_SYM_USER = 0x144;
-constexpr int FIX_SYM_VIDEO_MODE = 0x148;
-constexpr int FIX_SYM_BOOT_VIDEO_MODE = 0x14C;
-constexpr int FIX_SYM_BOOT = 0x150;
-constexpr int FIX_SYM_DEMO = 0x154;
-constexpr int FIX_SYM_DEMO_SHARED = 0x158;
-constexpr int FIX_SYM_PREVIEW = 0x15C;
-constexpr int FIX_SYM_KIOSK = 0x160;
-constexpr int FIX_SYM_PLAY_BOOT = 0x164;
-constexpr int FIX_SYM_SIN = 0x168;
-constexpr int FIX_SYM_COS = 0x16C;
-constexpr int FIX_SYM_PUT_DISPLAY_ENV = 0x170;
-constexpr int FIX_SYM_SYNCV = 0x174;
-constexpr int FIX_SYM_SYNC_PATH = 0x178;
-constexpr int FIX_SYM_RESET_PATH = 0x17C;
-constexpr int FIX_SYM_RESET_GRAPH = 0x180;
-constexpr int FIX_SYM_DMA_SYNC = 0x184;
-constexpr int FIX_SYM_GS_PUT_IMR = 0x188;
-constexpr int FIX_SYM_GS_GET_IMR = 0x18C;
-constexpr int FIX_SYM_GS_STORE_IMAGE = 400;
-constexpr int FIX_SYM_FLUSH_CACHE = 0x194;
-constexpr int FIX_SYM_CPAD_OPEN = 0x198;
-constexpr int FIX_SYM_CPAD_GET_DATA = 0x19C;
-constexpr int FIX_SYM_MOUSE_GET_DATA = 0x1A0;
-constexpr int FIX_SYM_KEYBD_GET_DATA = 0x1A4;
-constexpr int FIX_SYM_INSTALL_HANDLER = 0x1A8;
-constexpr int FIX_SYM_INSTALL_DEBUG_HANDLER = 0x1AC;
-constexpr int FIX_SYM_FILE_STREAM_OPEN = 0x1B0;
-constexpr int FIX_SYM_FILE_STREAM_CLOSE = 0x1B4;
-constexpr int FIX_SYM_FILE_STREAM_LENGTH = 0x1B8;
-constexpr int FIX_SYM_FILE_STREAM_SEEK = 0x1BC;
-constexpr int FIX_SYM_FILE_STREAM_READ = 0x1C0;
-constexpr int FIX_SYM_FILE_STREAM_WRITE = 0x1C4;
-constexpr int FIX_SYM_SCF_GET_LANGUAGE = 0x1C8;
-constexpr int FIX_SYM_SCF_GET_TIME = 0x1CC;
-constexpr int FIX_SYM_SCF_GET_ASPECT = 0x1D0;
-constexpr int FIX_SYM_SCF_GET_VOLUME = 0x1D4;
-constexpr int FIX_SYM_SCF_GET_TERRITORY = 0x1D8;
-constexpr int FIX_SYM_SCF_GET_TIMEOUT = 0x1DC;
-constexpr int FIX_SYM_SCF_GET_INACTIVE_TIMEOUT = 0x1E0;
-constexpr int FIX_SYM_DMA_TO_IOP = 0x1E4;
-constexpr int FIX_SYM_KERNEL_SHUTDOWN = 0x1E8;
-constexpr int FIX_SYM_AYBABTU = 0x1EC;
-constexpr int FIX_SYM_STRING_TO_SYMBOL = 0x1F0;
-constexpr int FIX_SYM_SYMBOL_TO_STRING = 500;
-constexpr int FIX_SYM_PRINT = 0x1F8;
-constexpr int FIX_SYM_INSPECT = 0x1FC;
-constexpr int FIX_SYM_LOAD = 0x200;
-constexpr int FIX_SYM_LOADB = 0x204;
-constexpr int FIX_SYM_LOADO = 0x208;
-constexpr int FIX_SYM_UNLOAD = 0x20C;
-constexpr int FIX_SYM_FORMAT = 0x210;
-constexpr int FIX_SYM_MALLOC = 0x214;
-constexpr int FIX_SYM_KMALLOC = 0x218;
-constexpr int FIX_SYM_KMEMOPEN = 0x21C;
-constexpr int FIX_SYM_KMEMCLOSE = 0x220;
-constexpr int FIX_SYM_NEW_DYNAMIC_STRUCTURE = 0x224;
-constexpr int FIX_SYM_METHOD_SET = 0x228;
-constexpr int FIX_SYM_LINK = 0x22C;
-constexpr int FIX_SYM_LINK_BUSY = 0x230;
-constexpr int FIX_SYM_LINK_RESET = 0x234;
-constexpr int FIX_SYM_LINK_BEGIN = 0x238;
-constexpr int FIX_SYM_LINK_RESUME = 0x23C;
-constexpr int FIX_SYM_DGO_LOAD = 0x240;
-constexpr int FIX_SYM_SQL_QUERY = 0x244;
-constexpr int FIX_SYM_MC_RUN = 0x248;
-constexpr int FIX_SYM_MC_FORMAT = 0x24C;
-constexpr int FIX_SYM_MC_UNFORMAT = 0x250;
-constexpr int FIX_SYM_MC_CREATE_FILE = 0x254;
-constexpr int FIX_SYM_MC_SAVE = 600;
-constexpr int FIX_SYM_MC_LOAD = 0x25C;
-constexpr int FIX_SYM_MC_CHECK_RESULT = 0x260;
-constexpr int FIX_SYM_MC_GET_SLOT_INFO = 0x264;
-constexpr int FIX_SYM_MC_MAKEFILE = 0x268;
-constexpr int FIX_SYM_KSET_LANGUAGE = 0x26C;
-constexpr int FIX_SYM_RPC_CALL = 0x270;
-constexpr int FIX_SYM_RPC_BUSY = 0x274;
-constexpr int FIX_SYM_TEST_LOAD_DGO_C = 0x278;
-constexpr int FIX_SYM_SYMLINK2 = 0x27c;
-constexpr int FIX_SYM_SYMLINK3 = 0x280;
-constexpr int FIX_SYM_ULTIMATE_MEMCPY = 0x284;
-constexpr int FIX_SYM_PLAY = 0x288;
-constexpr int FIX_SYM_SYMBOL_STRING = 0x28c;
-constexpr int FIX_SYM_KERNEL_SYMBOL_WARNINGS = 0x290;
-constexpr int FIX_SYM_NETWORK_BOOTSTRAP = 0x294;
-
-}  // namespace jak3_symbols
-
 constexpr int false_symbol_offset() {
  return jak1_symbols::FIX_SYM_FALSE;
 }
@@ -42,153 +42,7 @@ std::vector<std::string> jak2_slots = {
    "cas-toxic-slime-scroll-dest",
 };

-std::vector<std::string> jak3_slots = {
-    "skull-gem-dest",
-    "jakc-arm",
-    "jakc-eyebrow",
-    "jakc-face",
-    "jakc-finger",
-    "jakc-hair",
-    "jakchires-arm",
-    "jakchires-eye",
-    "jakchires-eyebrow",
-    "jakchires-eyelid",
-    "jakchires-facelft",
-    "jakchires-facert",
-    "jakchires-hair",
-    // default-water
-    "bomb-gradient",
-    "blue-beam-dest",
-    "lightjak-wings",
-    "mushroom-dest",
-    // default-warp
-    "shield-env-rim-dest",
-    // templea-water
-    "templea-waterfall-dest",
-    // templea-warp
-    "holograph-env-rim-dest",
-    // hanga-sprite
-    "glider-ring-dest2",
-    "glider-ring-dest",
-    // foresta-water
-    "fora-water-dest",
-    "fora-waterfall-01-dest",
-    "fora-water-wave-01-dest",
-    // forestb-water
-    "forb-water-dest",
-    "forb-waterfall-01-dest",
-    "forb-water-wave-01-dest",
-    // lforplnt-pris
-    "mh-gem-dest",
-    // lmhcitya-tfrag
-    "mhcitya-base-goo-01-dest",
-    // lmhcityb-tfrag
-    "mhcityb-base-goo-01-dest",
-    // mhcitya-pris
-    // "mhcity-de-door-skin-01-dest",
-    // templec-water
-    "tplc-water-dest",
-    // sewc-water
-    "sewer-water-01-c-dest",
-    "sewer-waterfall-01-c-dest",
-    "sewer-waterfall-02-c-dest",
-    "sewer-water-wave-01-c-dest",
-    "sewer-water-highlight-01-c-dest",
-    // sewd-water
-    "sewer-water-01-d-dest",
-    "sewer-waterfall-02-d-dest",
-    "sewer-water-highlight-01-d-dest",
-    "sewer-water-wave-01-d-dest",
-    "sewer-water-wave-02-d-dest",
-    "sewer-water-still-01-d-dest",
-    // sewe-water
-    "sewer-water-01-e-dest",
-    "sewer-waterfall-01-e-dest",
-    "sewer-waterfall-02-e-dest",
-    "sewer-water-highlight-01-e-dest",
-    // sewg-water
-    "sewer-water-01-g-dest",
-    "sewer-waterfall-02-g-dest",
-    "sewer-water-wave-01-g-dest",
-    // sewh-water
-    "sewer-water-01-h-dest",
-    "sewer-waterfall-02-h-dest",
-    "sewer-water-wave-02-h-dest",
-    "sewer-watefall-froth-01-h-dest",
-    // sewi-water
-    "sewer-water-still-01-i-dest",
-    "sewer-waterfall-02-i-dest",
-    "sewer-water-wave-01-i-dest",
-    // sewj-water
-    "sewer-waterfall-02-j-dest",
-    "sewer-watefall-froth-01-j-dest",
-    // sewl-water
-    "sewer-waterfall-02-l-dest",
-    "sewer-watefall-froth-01-l-dest",
-    // sewm-water
-    "sewer-water-01-m-dest",
-    "sewer-waterfall-01-m-dest",
-    "sewer-waterfall-02-m-dest",
-    "sewer-water-highlight-01-m-dest",
-    "sewer-water-wave-01-m-dest",
-    "sewer-water-still-01-m-dest",
-    "sewer-watefall-froth-01-m-dest",
-    // sewn-water
-    "sewer-waterfall-01-n-dest",
-    "sewer-waterfall-02-n-dest",
-    // "sewer-water-highlight-01-n-dest",
-    "sewer-water-wave-01-n-dest",
-    "sewer-water-still-01-n-dest",
-    // hanga-water
-    // "des-thermal-01-dest",
-    // desresc-warp
-    "sat-shield-dest",
-    // security
-    "security-env-dest",
-    "security-dot-dest",
-    // lgunnorm-water
-    "kg-target-c-forcefield-01-dest",
-    // templex-water
-    "temple-waterfall-dest",
-    // desertd-water
-    "des-waterfall-dest",
-    // towerb-water
-    "tow-energy-bridge-dest",
-    // factoryb-water
-    "hemi-gradient-dest",
-    "hemi-gradient-flames-dest",
-    // factoryc-alpha
-    "facc-convey-dest",
-    "facc-convey-02-dest",
-    // waspal-water
-    "waspala-water-dest",
-    "waspala-waterfall-dest",
-    // rubblea-water
-    "rub-water-dest",
-    // rubblea2-water
-    "rub-water-desta2",
-    // rubbleb-water
-    "rub-water-destb",
-    // rubblec-water
-    "rub-water-destc",
-    // nstb-quicksand
-    "nstb-quicksand-dest",
-    // ctyslumb-water
-    "ctyslumb-water-dest",
-    "ctyslumb-fountain-fall-dest",
-    // ctyslumc-water
-    "ctyslumc-water-dest",
-    "ctyslumc-fountain-fall-dest",
-    // mined-tfrag
-    "mined-pillar-side-dest",
-    "mined-pillar-top2side-dest",
-    "mined-pillar-top-dest",
-    // volcanoa-alpha
-    "vola-lava-01-dest",
-    "vola-lava-fall-dest",
-    // wasstada-alpha
-    "wstd-lava-base-dest",
-};
+std::vector<std::string> jak3_slots = {};

 }  // namespace

@@ -10,7 +10,7 @@
 #include "common/log/log.h"
 #include "common/util/Assert.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace {
 std::string reg_kind_to_string(RegClass kind) {
@@ -28,12 +28,8 @@ struct MethodInfo {
  std::string name;
  TypeSpec type;
  std::string defined_in_type;
-  // TODO - this might be redundant, but preventing an unknown breaking change, clean it up later
-  std::string type_name;
  bool no_virtual = false;
-  // TODO - this is no longer used anymore...but was not removed from th4e struct?
  bool overrides_parent = false;
-  // TODO - this is no longer used anymore...but was not removed from th4e struct?
  bool only_overrides_docstring = false;
  std::optional<std::string> docstring;
  std::optional<std::string> overlay_name;
@@ -9,7 +9,7 @@

 #include "common/log/log.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace {
 // debug prints for the reverse lookup
@@ -7,7 +7,7 @@

 #include <stdexcept>

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 bool TypeTag::operator==(const TypeTag& other) const {
  return name == other.name && value == other.value;
@@ -124,12 +124,10 @@ class TypeSpec {
    ASSERT(m_arguments);
    return m_arguments->at(idx);
  }
-
  TypeSpec& get_arg(int idx) {
    ASSERT(m_arguments);
    return m_arguments->at(idx);
  }
-
  const TypeSpec& last_arg() const {
    ASSERT(m_arguments);
    ASSERT(!m_arguments->empty());
@@ -14,8 +14,8 @@
 #include "common/util/Assert.h"
 #include "common/util/math_util.h"

-#include "fmt/color.h"
-#include "fmt/core.h"
+#include "third-party/fmt/color.h"
+#include "third-party/fmt/core.h"

 namespace {
 template <typename... Args>
@@ -28,7 +28,7 @@ template <typename... Args>
  }

  throw std::runtime_error(
-      fmt::format("Type Error: {}", fmt::format(fmt::runtime(str), std::forward<Args>(args)...)));
+      fmt::format("Type Error: {}", fmt::format(str, std::forward<Args>(args)...)));
 }
 }  // namespace

@@ -548,7 +548,6 @@ MethodInfo TypeSystem::override_method(Type* type,
                           existing_info.name,
                           existing_info.type,
                           type->get_name(),
-                           type->get_name(),
                           existing_info.no_virtual,
                           false,
                           true,
@@ -608,7 +607,6 @@ MethodInfo TypeSystem::declare_method(Type* type,
                             method_name,
                             ts,
                             type->get_name(),
-                             type->get_name(),
                             no_virtual,
                             true,
                             false,
@@ -647,7 +645,6 @@ MethodInfo TypeSystem::declare_method(Type* type,
                               method_name,
                               ts,
                               type->get_name(),
-                               type->get_name(),
                               no_virtual,
                               false,
                               false,
@@ -681,8 +678,8 @@ MethodInfo TypeSystem::overlay_method(Type* type,
  }

  // use the existing ID.
-  return type->add_method({existing_info.id, method_name, ts, type->get_name(), type->get_name(),
-                           false, true, false, docstring, std::make_optional(method_overlay_name)});
+  return type->add_method({existing_info.id, method_name, ts, type->get_name(), false, true, false,
+                           docstring, std::make_optional(method_overlay_name)});
 }

 MethodInfo TypeSystem::define_method(const std::string& type_name,
@@ -712,10 +709,8 @@ MethodInfo TypeSystem::define_method(Type* type,
  // look up the method
  MethodInfo existing_info;
  bool got_existing = try_lookup_method(type, method_name, &existing_info);
+
  if (got_existing) {
-    // The lookup will return a parents method, but the type should be equal
-    // to the type in question (it's a child)
-    existing_info.type_name = type->get_name();
    // Update the docstring
    existing_info.docstring = docstring;
    int bad_arg_idx = -99;
@@ -763,7 +758,7 @@ MethodInfo TypeSystem::add_new_method(Type* type,
    return existing;
  } else {
    return type->add_new_method(
-        {0, "new", ts, type->get_name(), type->get_name(), false, false, false, docstring, {}});
+        {0, "new", ts, type->get_name(), false, false, false, docstring, {}});
  }
 }

@@ -1447,21 +1442,6 @@ std::vector<std::string> TypeSystem::search_types_by_parent_type(
  return results;
 }

-std::vector<std::string> TypeSystem::search_types_by_parent_type_strict(
-    const std::string& parent_type) {
-  std::vector<std::string> results = {};
-  for (const auto& [type_name, type_info] : m_types) {
-    // Only NullType's have no parent
-    if (!type_info->has_parent()) {
-      continue;
-    }
-    if (type_info->get_parent() == parent_type) {
-      results.push_back(type_name);
-    }
-  }
-  return results;
-}
-
 std::vector<std::string> TypeSystem::search_types_by_minimum_method_id(
    const int minimum_method_id,
    const std::optional<std::vector<std::string>>& existing_matches) {
@@ -1502,7 +1482,8 @@ std::vector<std::string> TypeSystem::search_types_by_size(
    }
  } else {
    for (const auto& [type_name, type_info] : m_types) {
-      if (dynamic_cast<NullType*>(type_info.get())) {
+      // Only NullType's have no parent
+      if (!type_info->has_parent()) {
        continue;
      }
      const auto size_of_type = m_types[type_name]->get_size_in_memory();
@@ -2132,7 +2113,7 @@ std::optional<std::string> find_best_field_in_structure(const TypeSystem& ts,
  }
  for (size_t i = start_field; i < (size_t)end_field; ++i) {
    const auto& field = st->fields().at(i);
-    auto type = ts.lookup_type_allow_partial_def(field.type());
+    auto type = ts.lookup_type(field.type());
    if (field.is_dynamic() || field.offset() > offset || field.user_placed() != want_fixed) {
      continue;
    }
@@ -2166,12 +2147,6 @@ std::optional<std::string> find_best_field_in_structure(const TypeSystem& ts,
    } else {
      int rel_offset = offset - field.offset();
      // array case (and array encompasses what we want)
-      ASSERT_MSG(
-          type->get_size_in_memory() > 0,
-          fmt::format(
-              "In type {}, type size was 0 for array field {} of type {}, check that the type "
-              "is fully defined.",
-              st->get_name(), field.name(), field.type().print()));
      int array_idx = rel_offset / type->get_size_in_memory();
      if (!field.is_inline() &&
          field.offset() + field.array_size() * type->get_load_size() > offset) {
@@ -278,7 +278,6 @@ class TypeSystem {
  std::vector<std::string> search_types_by_parent_type(
      const std::string& parent_type,
      const std::optional<std::vector<std::string>>& existing_matches = {});
-  std::vector<std::string> search_types_by_parent_type_strict(const std::string& parent_type);

  std::vector<std::string> search_types_by_minimum_method_id(
      const int minimum_method_id,
@@ -13,7 +13,7 @@
 #include "common/util/BitUtils.h"
 #include "common/util/string_util.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 namespace {
 const goos::Object& car(const goos::Object* x) {
@@ -58,11 +58,10 @@ EnumType* parse_defenum(const goos::Object& defenum,
  auto& enum_name_obj = car(iter);
  iter = cdr(iter);
  // check for docstring
-  std::optional<std::string> maybe_docstring;
  if (iter->is_pair() && car(iter).is_string()) {
+    // TODO - docstring - store and use docstring if coming from the compiler
    if (symbol_metadata) {
-      maybe_docstring = str_util::trim_newline_indents(car(iter).as_string()->data);
-      symbol_metadata->docstring = maybe_docstring.value();
+      symbol_metadata->docstring = str_util::trim_newline_indents(car(iter).as_string()->data);
    }
    iter = cdr(iter);
  }
@@ -158,7 +157,6 @@ EnumType* parse_defenum(const goos::Object& defenum,
  if (is_type("integer", base_type, ts)) {
    auto parent = ts->get_type_of_type<ValueType>(base_type.base_type());
    auto new_type = std::make_unique<EnumType>(parent, name, is_bitfield, entries);
-    new_type->m_metadata.docstring = maybe_docstring;
    new_type->set_runtime_type(parent->get_runtime_name());
    return dynamic_cast<EnumType*>(ts->add_type(name, std::move(new_type)));
  } else {
@@ -13,7 +13,7 @@
 #include "common/type_system/state.h"
 #include "common/util/string_util.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 /*!
 * Missing Features
@@ -84,10 +84,12 @@ double get_float(const goos::Object& obj) {
  throw std::runtime_error(obj.print() + " was supposed to be an number, but isn't");
 }

-void add_field(StructureType* structure,
-               TypeSystem* ts,
-               const goos::Object& def,
-               goos::EnvironmentMap* constants) {
+void add_field(
+    StructureType* structure,
+    TypeSystem* ts,
+    const goos::Object& def,
+    std::unordered_map<goos::InternedSymbolPtr, goos::Object, goos::InternedSymbolPtr::hash>&
+        constants) {
  auto rest = &def;

  auto name = symbol_string(car(rest));
@@ -111,8 +113,9 @@ void add_field(StructureType* structure,
    if (car(rest).is_int()) {
      array_size = car(rest).integer_obj.value;
      rest = cdr(rest);
-    } else if (car(rest).is_symbol() && constants && constants->lookup((car(rest)).as_symbol())) {
-      array_size = get_int(*constants->lookup((car(rest)).as_symbol()));
+    } else if (car(rest).is_symbol() &&
+               constants.find((car(rest)).as_symbol()) != constants.end()) {
+      array_size = get_int(constants[(car(rest)).as_symbol()]);
      rest = cdr(rest);
    }

@@ -540,11 +543,13 @@ void declare_state(Type* type,
  });
 }

-StructureDefResult parse_structure_def(StructureType* type,
-                                       TypeSystem* ts,
-                                       const goos::Object& fields,
-                                       const goos::Object& options,
-                                       goos::EnvironmentMap* constants) {
+StructureDefResult parse_structure_def(
+    StructureType* type,
+    TypeSystem* ts,
+    const goos::Object& fields,
+    const goos::Object& options,
+    std::unordered_map<goos::InternedSymbolPtr, goos::Object, goos::InternedSymbolPtr::hash>&
+        constants) {
  StructureDefResult result;
  for_each_in_list(fields, [&](const goos::Object& o) { add_field(type, ts, o, constants); });
  TypeFlags flags;
@@ -806,11 +811,18 @@ TypeSpec parse_typespec(const TypeSystem* type_system, const goos::Object& src)
  return {};
 }

-DeftypeResult parse_deftype(const goos::Object& deftype,
-                            TypeSystem* ts,
-                            goos::EnvironmentMap* constants) {
+DeftypeResult parse_deftype(
+    const goos::Object& deftype,
+    TypeSystem* ts,
+    std::unordered_map<goos::InternedSymbolPtr, goos::Object, goos::InternedSymbolPtr::hash>*
+        constants) {
  DefinitionMetadata symbol_metadata;
-  goos::EnvironmentMap no_consts;
+  std::unordered_map<goos::InternedSymbolPtr, goos::Object, goos::InternedSymbolPtr::hash>
+      no_consts;
+  auto& constants_to_use = no_consts;
+  if (constants != nullptr) {
+    constants_to_use = *constants;
+  }

  auto iter = &deftype;

@@ -849,7 +861,8 @@ DeftypeResult parse_deftype(const goos::Object& deftype,
    }
    new_type->inherit(pto);
    ts->forward_declare_type_as(name, pto->get_name());
-    auto sr = parse_structure_def(new_type.get(), ts, field_list_obj, options_obj, constants);
+    auto sr =
+        parse_structure_def(new_type.get(), ts, field_list_obj, options_obj, constants_to_use);
    result.flags = sr.flags;
    result.create_runtime_type = sr.generate_runtime_type;
    structure_result = sr;
@@ -878,7 +891,8 @@ DeftypeResult parse_deftype(const goos::Object& deftype,
    ASSERT(pto);
    new_type->inherit(pto);
    ts->forward_declare_type_as(name, pto->get_name());
-    auto sr = parse_structure_def(new_type.get(), ts, field_list_obj, options_obj, constants);
+    auto sr =
+        parse_structure_def(new_type.get(), ts, field_list_obj, options_obj, constants_to_use);
    result.flags = sr.flags;
    result.create_runtime_type = sr.generate_runtime_type;
    structure_result = sr;
@@ -17,7 +17,9 @@ struct DeftypeResult {
  bool create_runtime_type = true;
 };

-DeftypeResult parse_deftype(const goos::Object& deftype,
-                            TypeSystem* ts,
-                            goos::EnvironmentMap* constants = nullptr);
+DeftypeResult parse_deftype(
+    const goos::Object& deftype,
+    TypeSystem* ts,
+    std::unordered_map<goos::InternedSymbolPtr, goos::Object, goos::InternedSymbolPtr::hash>*
+        constants = nullptr);
 TypeSpec parse_typespec(const TypeSystem* type_system, const goos::Object& src);
@@ -16,12 +16,12 @@ void private_assert_failed(const char* expr,
  if (!msg || msg[0] == '\0') {
    std::string log = fmt::format("Assertion failed: '{}'\n\tSource: {}:{}\n\tFunction: {}\n", expr,
                                  file, line, function);
-    lg::die("{}", log);
+    lg::die(log);
  } else {
    std::string log =
        fmt::format("Assertion failed: '{}'\n\tMessage: {}\n\tSource: {}:{}\n\tFunction: {}\n",
                    expr, msg, file, line, function);
-    lg::die("{}", log);
+    lg::die(log);
  }
  abort();
 }
@@ -36,9 +36,6 @@

 #define ASSERT_NOT_REACHED_MSG(STR) \
  (void)((private_assert_failed("not reached", __FILE__, __LINE__, __PRETTY_FUNCTION__, STR), 0))
-
-#define ASSERT_EQ_IMM(EXPR, EXPECTED) \
-  ASSERT_MSG((EXPR) == (EXPECTED), fmt::format("result was {}, expected {}", (EXPR), (EXPECTED)))
 #else

 #define ASSERT(EX) ((void)0)
@@ -7,7 +7,6 @@

 #include <cstdint>
 #include <cstring>
-#include <span>
 #include <vector>

 #include "common/common_types.h"
@@ -15,29 +14,28 @@

 class BinaryReader {
 public:
-  explicit BinaryReader(std::span<const uint8_t> _span) : m_span(_span) {}
+  explicit BinaryReader(const std::vector<uint8_t>& _buffer) : m_buffer(_buffer) {}

  template <typename T>
  T read() {
-    ASSERT(m_seek + sizeof(T) <= m_span.size());
+    ASSERT(m_seek + sizeof(T) <= m_buffer.size());
    T obj;
-    memcpy(&obj, m_span.data() + m_seek, sizeof(T));
+    memcpy(&obj, m_buffer.data() + m_seek, sizeof(T));
    m_seek += sizeof(T);
    return obj;
  }

  void ffwd(int amount) {
    m_seek += amount;
-    ASSERT(m_seek <= m_span.size());
+    ASSERT(m_seek <= m_buffer.size());
  }

-  uint32_t bytes_left() const { return m_span.size() - m_seek; }
-  const uint8_t* here() { return m_span.data() + m_seek; }
-  BinaryReader at(u32 pos) { return BinaryReader(m_span.subspan(pos)); }
+  uint32_t bytes_left() const { return m_buffer.size() - m_seek; }
+  uint8_t* here() { return m_buffer.data() + m_seek; }
  uint32_t get_seek() const { return m_seek; }
  void set_seek(u32 seek) { m_seek = seek; }

 private:
-  std::span<const u8> m_span;
+  std::vector<u8> m_buffer;
  uint32_t m_seek = 0;
 };
@@ -9,7 +9,6 @@
 #include "dgo_util.h"

 #include "common/link_types.h"
-#include "common/log/log.h"

 #include "third-party/json.hpp"

@@ -26,9 +25,9 @@ DgoReader::DgoReader(std::string file_name, const std::vector<u8>& data)

    if (reader.bytes_left() < obj_header.size && i == header.object_count - 1 &&
        obj_header.size - reader.bytes_left() <= 48) {
-      lg::print(
-          "Warning: final file {} in DGO {} has a size missing {} bytes.  It will be adjusted from "
-          "{} to {} bytes.\n",
+      printf(
+          "Warning: final file %s in DGO %s has a size missing %d bytes.  It will be adjusted from "
+          "%d to %d bytes.\n",
          obj_header.name, header.name, obj_header.size - reader.bytes_left(), obj_header.size,
          (int)reader.bytes_left());
      obj_header.size = reader.bytes_left();
@@ -41,7 +40,7 @@ DgoReader::DgoReader(std::string file_name, const std::vector<u8>& data)

    entry.unique_name = get_object_file_name(entry.internal_name, reader.here(), obj_header.size);
    if (all_unique_names.find(entry.unique_name) != all_unique_names.end()) {
-      lg::print("Warning: there are multiple files named {}\n", entry.unique_name.c_str());
+      printf("Warning: there are multiple files named %s\n", entry.unique_name.c_str());
      entry.unique_name += '-';
      entry.unique_name += std::to_string(obj_header.size);
    }
@@ -22,7 +22,7 @@
 // This disables the use of PCLMULQDQ which is probably ok, but let's just be safe and disable it
 // because nobody will care if png compression is 10% slower.
 #define FPNG_NO_SSE 1
-#include "fmt/core.h"
+#include "third-party/fmt/core.h"
 #include "third-party/fpng/fpng.cpp"
 #include "third-party/fpng/fpng.h"
 #include "third-party/lzokay/lzokay.hpp"
@@ -57,14 +57,6 @@ fs::path get_user_home_dir() {
 #endif
 }

-struct {
-  bool initialized = false;
-  fs::path path_to_data_folder;
-  fs::path user_config_dir_override = "";
-  // by default - if the config dir is overridden, we don't use the default save location
-  bool use_overridden_config_dir_for_saves = true;
-} g_file_path_info;
-
 fs::path get_user_config_dir() {
  fs::path config_base_path;
 #ifdef _WIN32
@@ -88,53 +80,23 @@ fs::path get_user_config_dir() {

 fs::path get_user_settings_dir(GameVersion game_version) {
  auto game_version_name = game_version_names[game_version];
-  auto config_dir = get_user_config_dir();
-  if (!g_file_path_info.user_config_dir_override.empty()) {
-    config_dir = g_file_path_info.user_config_dir_override / "OpenGOAL";
-  }
-  return config_dir / game_version_name / "settings";
+  return get_user_config_dir() / game_version_name / "settings";
 }

 fs::path get_user_memcard_dir(GameVersion game_version) {
  auto game_version_name = game_version_names[game_version];
-  auto config_dir = get_user_config_dir();
-  if (!g_file_path_info.user_config_dir_override.empty() &&
-      g_file_path_info.use_overridden_config_dir_for_saves) {
-    config_dir = g_file_path_info.user_config_dir_override / "OpenGOAL";
-  }
-  return config_dir / game_version_name / "saves";
-}
-
-fs::path get_user_screenshots_dir(GameVersion game_version) {
-  auto game_version_name = game_version_names[game_version];
-  auto config_dir = get_user_config_dir();
-  if (!g_file_path_info.user_config_dir_override.empty()) {
-    config_dir = g_file_path_info.user_config_dir_override / "OpenGOAL";
-  }
-  return config_dir / game_version_name / "screenshots";
+  return get_user_config_dir() / game_version_name / "saves";
 }

 fs::path get_user_misc_dir(GameVersion game_version) {
  auto game_version_name = game_version_names[game_version];
-  auto config_dir = get_user_config_dir();
-  if (!g_file_path_info.user_config_dir_override.empty()) {
-    config_dir = g_file_path_info.user_config_dir_override / "OpenGOAL";
-  }
-  return config_dir / game_version_name / "misc";
+  return get_user_config_dir() / game_version_name / "misc";
 }

-fs::path get_user_features_dir(GameVersion game_version) {
-  auto game_version_name = game_version_names[game_version];
-  auto config_dir = get_user_config_dir();
-  if (!g_file_path_info.user_config_dir_override.empty()) {
-    config_dir = g_file_path_info.user_config_dir_override / "OpenGOAL";
-  }
-  auto path = config_dir / game_version_name / "features";
-  file_util::create_dir_if_needed(path);
-  return path;
-}
-
-fs::path g_iso_data_directory = "";
+struct {
+  bool initialized = false;
+  fs::path path_to_data;
+} gFilePathInfo;

 /*!
 * Get the path to the current executable.
@@ -185,11 +147,9 @@ std::optional<std::string> try_get_jak_project_path() {
  return try_get_project_path_from_path(get_current_executable_path());
 }

-std::optional<fs::path> try_get_data_dir(bool skip_logs) {
+std::optional<fs::path> try_get_data_dir() {
  fs::path my_path = get_current_executable_path();
-  if (!skip_logs) {
-    lg::debug("Current executable directory - {}", my_path.string());
-  }
+  lg::info("Current executable directory - {}", my_path.string());
  auto data_dir = my_path.parent_path() / "data";
  if (fs::exists(data_dir) && fs::is_directory(data_dir)) {
    return std::make_optional(data_dir);
@@ -198,38 +158,31 @@ std::optional<fs::path> try_get_data_dir(bool skip_logs) {
  }
 }

-bool setup_project_path(std::optional<fs::path> project_path_override, bool skip_logs) {
-  if (g_file_path_info.initialized) {
+bool setup_project_path(std::optional<fs::path> project_path_override) {
+  if (gFilePathInfo.initialized) {
    return true;
  }

  if (project_path_override) {
-    g_file_path_info.path_to_data_folder = fs::absolute(project_path_override.value());
-    g_file_path_info.initialized = true;
-    if (!skip_logs) {
-      lg::debug("Using explicitly set project path: {}",
-                g_file_path_info.path_to_data_folder.string());
-    }
+    gFilePathInfo.path_to_data = fs::absolute(project_path_override.value());
+    gFilePathInfo.initialized = true;
+    lg::info("Using explicitly set project path: {}", gFilePathInfo.path_to_data.string());
    return true;
  }

-  auto data_path = try_get_data_dir(skip_logs);
+  auto data_path = try_get_data_dir();
  if (data_path) {
-    g_file_path_info.path_to_data_folder = *data_path;
-    g_file_path_info.initialized = true;
-    if (!skip_logs) {
-      lg::debug("Using data path: {}", data_path->string());
-    }
+    gFilePathInfo.path_to_data = *data_path;
+    gFilePathInfo.initialized = true;
+    lg::info("Using data path: {}", data_path->string());
    return true;
  }

  auto development_repo_path = try_get_jak_project_path();
  if (development_repo_path) {
-    g_file_path_info.path_to_data_folder = *development_repo_path;
-    g_file_path_info.initialized = true;
-    if (!skip_logs) {
-      lg::debug("Using development repo path: {}", *development_repo_path);
-    }
+    gFilePathInfo.path_to_data = *development_repo_path;
+    gFilePathInfo.initialized = true;
+    lg::info("Using development repo path: {}", *development_repo_path);
    return true;
  }

@@ -237,37 +190,9 @@ bool setup_project_path(std::optional<fs::path> project_path_override, bool skip
  return false;
 }

-void override_user_config_dir(fs::path user_config_dir_override,
-                              bool use_overridden_config_dir_for_saves) {
-  g_file_path_info.user_config_dir_override = user_config_dir_override;
-  g_file_path_info.use_overridden_config_dir_for_saves = use_overridden_config_dir_for_saves;
-}
-
 fs::path get_jak_project_dir() {
-  ASSERT(g_file_path_info.initialized);
-  return g_file_path_info.path_to_data_folder;
-}
-
-fs::path get_iso_dir_for_game(GameVersion game_version) {
-  if (!g_iso_data_directory.empty()) {
-    return g_iso_data_directory;
-  }
-  // Find the location based on the game version
-  std::string expected_subdir = "jak1";
-  if (game_version == GameVersion::Jak2) {
-    expected_subdir = "jak2";
-  } else if (game_version == GameVersion::Jak3) {
-    expected_subdir = "jak3";
-  }
-  const auto temp_dir = get_jak_project_dir() / "iso_data" / expected_subdir;
-  if (fs::exists(temp_dir)) {
-    g_iso_data_directory = temp_dir;
-  }
-  return g_iso_data_directory;
-}
-
-void set_iso_data_dir(const fs::path& directory) {
-  g_iso_data_directory = directory;
+  ASSERT(gFilePathInfo.initialized);
+  return gFilePathInfo.path_to_data;
 }

 std::string get_file_path(const std::vector<std::string>& input) {
@@ -456,7 +381,7 @@ std::string split_path_at(const fs::path& path, const std::vector<std::string>&
    split_str += folder + "/";
 #endif
  }
-  const auto& path_str = path.string();
+  const auto& path_str = path.u8string();
  return path_str.substr(path_str.find(split_str) + split_str.length());
 }

@@ -711,9 +636,6 @@ std::vector<fs::path> find_files_in_dir(const fs::path& dir, const std::regex& p

 std::vector<fs::path> find_files_recursively(const fs::path& base_dir, const std::regex& pattern) {
  std::vector<fs::path> files = {};
-  if (!fs::exists(base_dir)) {
-    return files;
-  }
  for (auto& p : fs::recursive_directory_iterator(base_dir)) {
    if (p.is_regular_file()) {
      if (std::regex_match(p.path().filename().string(), pattern)) {
@@ -770,59 +692,15 @@ void copy_file(const fs::path& src, const fs::path& dst) {
 std::string make_screenshot_filepath(const GameVersion game_version, const std::string& name) {
  std::string file_name;
  if (name.empty()) {
-    file_name = fmt::format("{}.png", str_util::current_local_timestamp_no_colons());
+    file_name = fmt::format("{}_{}.png", version_to_game_name(game_version),
+                            str_util::current_local_timestamp_no_colons());
  } else {
-    file_name = fmt::format("{}.png", name);
+    file_name = fmt::format("{}_{}_{}.png", version_to_game_name(game_version), name,
+                            str_util::current_local_timestamp_no_colons());
  }
-  const auto file_path = get_user_screenshots_dir(game_version) / file_name;
+  const auto file_path = file_util::get_file_path({"screenshots", file_name});
  file_util::create_dir_if_needed_for_file(file_path);
-  return file_path.string();
-}
-
-std::string get_majority_file_line_endings(const std::string& file_contents) {
-  size_t lf_count = 0;
-  size_t crlf_count = 0;
-
-  for (size_t i = 0; i < file_contents.size(); ++i) {
-    if (file_contents[i] == '\n') {
-      if (i > 0 && file_contents[i - 1] == '\r') {
-        crlf_count++;
-      } else {
-        lf_count++;
-      }
-    }
-  }
-
-  if (crlf_count > lf_count) {
-    return "\r\n";
-  }
-  return "\n";
-}
-
-std::pair<int, std::string> get_majority_file_line_endings_and_count(
-    const std::string& file_contents) {
-  size_t lf_count = 0;
-  size_t crlf_count = 0;
-
-  for (size_t i = 0; i < file_contents.size(); ++i) {
-    if (file_contents[i] == '\n') {
-      if (i > 0 && file_contents[i - 1] == '\r') {
-        crlf_count++;
-      } else {
-        lf_count++;
-      }
-    }
-  }
-
-  if (crlf_count > lf_count) {
-    return {lf_count + crlf_count, "\r\n"};
-  }
-  return {lf_count + crlf_count, "\n"};
-}
-
-bool is_dir_in_dir(const fs::path& parent, const fs::path& child) {
-  // Check if the parent path is a prefix of the child path
-  return child.has_parent_path() && child.parent_path().lexically_relative(parent) == fs::path(".");
+  return file_path;
 }

 }  // namespace file_util
@@ -31,21 +31,14 @@ fs::path get_user_home_dir();
 fs::path get_user_config_dir();
 fs::path get_user_settings_dir(GameVersion game_version);
 fs::path get_user_memcard_dir(GameVersion game_version);
-fs::path get_user_screenshots_dir(GameVersion game_version);
 fs::path get_user_misc_dir(GameVersion game_version);
-fs::path get_user_features_dir(GameVersion game_version);
 fs::path get_jak_project_dir();
-fs::path get_iso_dir_for_game(GameVersion game_version);
-void set_iso_data_dir(const fs::path& directory);

 bool create_dir_if_needed(const fs::path& path);
 bool create_dir_if_needed_for_file(const std::string& path);
 bool create_dir_if_needed_for_file(const fs::path& path);
-std::string get_current_executable_path();
 std::optional<std::string> try_get_project_path_from_path(const std::string& path);
-bool setup_project_path(std::optional<fs::path> project_path_override, bool skip_logs = false);
-void override_user_config_dir(fs::path user_config_dir_override,
-                              bool use_overridden_config_dir_for_saves);
+bool setup_project_path(std::optional<fs::path> project_path_override);
 std::string get_file_path(const std::vector<std::string>& path);
 void write_binary_file(const std::string& name, const void* data, size_t size);
 void write_binary_file(const fs::path& name, const void* data, size_t size);
@@ -76,8 +69,4 @@ std::vector<fs::path> sort_filepaths(const std::vector<fs::path>& paths, const b
 /// Will overwrite the destination if it exists
 void copy_file(const fs::path& src, const fs::path& dst);
 std::string make_screenshot_filepath(const GameVersion game_version, const std::string& name = "");
-std::string get_majority_file_line_endings(const std::string& file_contents);
-std::pair<int, std::string> get_majority_file_line_endings_and_count(
-    const std::string& file_contents);
-bool is_dir_in_dir(const fs::path& parent, const fs::path& child);
 }  // namespace file_util
@@ -16,14 +16,13 @@

 #include "common/util/Assert.h"

-#include "fmt/core.h"
-#include "fmt/format.h"
+#include "third-party/fmt/core.h"
+#include "third-party/fmt/format.h"

 const std::unordered_map<std::string, GameTextVersion> sTextVerEnumMap = {
    {"jak1-v1", GameTextVersion::JAK1_V1},
    {"jak1-v2", GameTextVersion::JAK1_V2},
-    {"jak2", GameTextVersion::JAK2},
-    {"jak3", GameTextVersion::JAK3}};
+    {"jak2", GameTextVersion::JAK2}};

 const std::string& get_text_version_name(GameTextVersion version) {
  for (auto& [name, ver] : sTextVerEnumMap) {
@@ -262,8 +261,7 @@ bool GameTextFontBank::valid_char_range(const char in) const {
    return ((in >= '0' && in <= '9') || (in >= 'A' && in <= 'Z') ||
            m_passthrus->find(in) != m_passthrus->end()) &&
           in != '\\';
-  } else if (m_version == GameTextVersion::JAK2 || m_version == GameTextVersion::JAK3 ||
-             m_version == GameTextVersion::JAKX) {
+  } else if (m_version == GameTextVersion::JAK2) {
    return ((in >= '0' && in <= '9') || (in >= 'A' && in <= 'Z') || (in >= 'a' && in <= 'z') ||
            m_passthrus->find(in) != m_passthrus->end()) &&
           in != '\\';
@@ -915,9 +913,7 @@ GameTextFontBank g_font_bank_jak1_v2(GameTextVersion::JAK1_V2,
 * GAME TEXT FONT BANK - JAK 2
 * ================================
 * This font is used in:
- * - Jak II
- * - Jak II: Renegade
- * - ジャックＸダクスター2
+ * - Jak 2 - NTSC - v1
 */

 static std::unordered_set<char> s_passthrus_jak2 = {'~', ' ', ',', '.', '-', '+', '(', ')',
@@ -985,8 +981,6 @@ static std::vector<ReplaceInfo> s_replace_info_jak2 = {
    {"o~Y~-26H~-4V'~Z", "ó"},
    {"U~Y~-24H~-3V'~Z", "Ú"},
    {"u~Y~-24H~-3V'~Z", "ú"},
-    {"Z~Y~-24H~-3V'~Z", "Ź"},
-    {"z~Y~-24H~-3V'~Z", "ź"},

    // circumflex
    {"A~Y~-20H~-4V^~Z", "Â"},
@@ -1017,7 +1011,6 @@ static std::vector<ReplaceInfo> s_replace_info_jak2 = {
    {"a~Y~-25H~-5V¨~Z", "ä"},
    {"E~Y~-20H~-5V¨~Z", "Ë"},
    {"I~Y~-19H~-5V¨~Z", "Ï"},
-    {"i~Y~-26H~-4V¨~Z", "ï"},
    {"O~Y~-26H~-8V¨~Z", "Ö"},
    {"o~Y~-26H~-4V¨~Z", "ö"},
    {"U~Y~-25H~-8V¨~Z", "Ü"},
@@ -1911,21 +1904,6 @@ GameTextFontBank g_font_bank_jak2(GameTextVersion::JAK2,
                                  &s_replace_info_jak2,
                                  &s_passthrus_jak2);

-/*!
- * ================================
- * GAME TEXT FONT BANK - JAK 3
- * ================================
- * This font is used in:
- * - Jak 3
- */
-
-// TODO cyrillic
-
-GameTextFontBank g_font_bank_jak3(GameTextVersion::JAK3,
-                                  &s_encode_info_jak2,
-                                  &s_replace_info_jak2,
-                                  &s_passthrus_jak2);
-
 /*!
 * ========================
 * GAME TEXT FONT BANK LIST
@@ -1936,8 +1914,7 @@ GameTextFontBank g_font_bank_jak3(GameTextVersion::JAK3,
 std::map<GameTextVersion, GameTextFontBank*> g_font_banks = {
    {GameTextVersion::JAK1_V1, &g_font_bank_jak1_v1},
    {GameTextVersion::JAK1_V2, &g_font_bank_jak1_v2},
-    {GameTextVersion::JAK2, &g_font_bank_jak2},
-    {GameTextVersion::JAK3, &g_font_bank_jak3}};
+    {GameTextVersion::JAK2, &g_font_bank_jak2}};

 const GameTextFontBank* get_font_bank(GameTextVersion version) {
  return g_font_banks.at(version);
@@ -1950,8 +1927,6 @@ const GameTextFontBank* get_font_bank_from_game_version(GameVersion version) {
      return get_font_bank(GameTextVersion::JAK1_V2);
    case GameVersion::Jak2:
      return get_font_bank(GameTextVersion::JAK2);
-    case GameVersion::Jak3:
-      return get_font_bank(GameTextVersion::JAK3);
    default:
      ASSERT_MSG(false, "Unsupported game for get_font_bank_from_game_version");
  }
@@ -67,4 +67,4 @@ class Range {
 private:
  T m_start = {};
  T m_end = {};
-};
+};
@@ -12,7 +12,7 @@
 * It owns the memory for the objects it stores.
 * Doing an insert will create a copy of your object.
 *
- * Other than deleting the whole thing, there is no support for removing a node.
+ * Other that deleting the whole thing, there is no support for removing a node.
 */
 template <typename T>
 class Trie {
@@ -150,7 +150,7 @@ class Trie {
 };

 template <typename T>
-Trie<T>::~Trie() {
+Trie<T>::~Trie<T>() {
  m_root.delete_children();
  m_size = 0;
 }
@@ -187,4 +187,4 @@ std::vector<T*> Trie<T>::get_all_nodes() const {
  std::vector<T*> result;
  m_root.get_all_children(result);
  return result;
-}
+}
@@ -1,31 +0,0 @@
-#include "ast_util.h"
-
-namespace ast_util {
-std::string get_source_code(const std::string& source, const TSNode& node) {
-  uint32_t start = ts_node_start_byte(node);
-  uint32_t end = ts_node_end_byte(node);
-  return source.substr(start, end - start);
-}
-
-void search_for_forms_that_begin_with(const std::string& source,
-                                      const TSNode curr_node,
-                                      const std::vector<std::string>& prefix,
-                                      std::vector<TSNode>& results) {
-  if (ts_node_child_count(curr_node) == 0) {
-    return;
-  }
-  std::vector<std::string> node_elements;
-  bool added = false;
-  for (size_t i = 0; i < ts_node_child_count(curr_node); i++) {
-    const auto child_node = ts_node_child(curr_node, i);
-    const auto contents = get_source_code(source, child_node);
-    node_elements.push_back(contents);
-    // Check for a match
-    if (node_elements == prefix && !added) {
-      results.push_back(curr_node);
-      added = true;
-    }
-    search_for_forms_that_begin_with(source, child_node, prefix, results);
-  }
-}
-}  // namespace ast_util
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "tree_sitter/api.h"
-
-namespace ast_util {
-std::string get_source_code(const std::string& source, const TSNode& node);
-void search_for_forms_that_begin_with(const std::string& source,
-                                      const TSNode curr_node,
-                                      const std::vector<std::string>& prefix,
-                                      std::vector<TSNode>& results);
-
-}  // namespace ast_util
@@ -5,7 +5,7 @@

 #include "common/util/Assert.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"
 #include "third-party/zstd/lib/zstd.h"

 namespace compression {
@@ -46,17 +46,4 @@ std::vector<u8> decompress_zstd(const void* data, size_t size) {
  ASSERT(decomp_size == decompressed_size);
  return result;
 }
-
-std::vector<u8> compress_zstd_no_header(const void* data, size_t size) {
-  size_t max_compressed = ZSTD_compressBound(size);
-  std::vector<u8> result(max_compressed);
-
-  size_t compressed_size = ZSTD_compress(result.data(), max_compressed, data, size, 1);
-  if (ZSTD_isError(compressed_size)) {
-    ASSERT_MSG(false, fmt::format("ZSTD error: {}", ZSTD_getErrorName(compressed_size)));
-  }
-
-  result.resize(compressed_size);
-  return result;
-}
 }  // namespace compression
@@ -8,5 +8,4 @@ namespace compression {
 // compress and decompress data with zstd
 std::vector<u8> compress_zstd(const void* data, size_t size);
 std::vector<u8> decompress_zstd(const void* data, size_t size);
-std::vector<u8> compress_zstd_no_header(const void* data, size_t size);
-}  // namespace compression
+}  // namespace compression
@@ -1,5 +1,3 @@
-#pragma once
-
 #include <cstdlib>

 #include "common/common_types.h"
@@ -5,7 +5,7 @@
 #include "common/util/Assert.h"
 #include "common/versions/versions.h"

-#include "fmt/core.h"
+#include "third-party/fmt/core.h"

 /*!
 * Assert false if the char[] has non-null data after the null terminated string.
@@ -21,7 +21,7 @@ void assert_string_empty_after(const char* str, int size) {
  }
 }

-std::string get_object_file_name(const std::string& original_name, const u8* data, int size) {
+std::string get_object_file_name(const std::string& original_name, u8* data, int size) {
  const std::string art_group_text_strings[] = {
      fmt::format("/src/next/data/art-group{}/", versions::jak1::ART_FILE_VERSION),
      fmt::format("/src/jak2/final/art-group{}/", versions::jak2::ART_FILE_VERSION),