diff --git a/package-lock.json b/package-lock.json
index 62307fe..23c6d3c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23,6 +23,7 @@
       "devDependencies": {
         "@cloudflare/vite-plugin": "^1.50.0",
         "@cloudflare/vitest-pool-workers": "^0.20.1",
+        "@oxlint/plugins": "1.78.0",
         "@testing-library/react": "^16.3.2",
         "@testing-library/user-event": "^14.6.1",
         "@types/node": "^26.1.2",
@@ -30,6 +31,7 @@
         "@types/react-dom": "^19.2.3",
         "@vitejs/plugin-react": "^6.0.5",
         "jsdom": "^26.1.0",
+        "oxlint": "1.78.0",
         "tsx": "^4.23.5",
         "typescript": "^7.0.2",
         "vite": "^8.2.0",
@@ -1900,9 +1902,9 @@
       ]
     },
     "node_modules/@oxlint/binding-android-arm-eabi": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-android-arm-eabi/-/binding-android-arm-eabi-1.75.0.tgz",
-      "integrity": "sha512-lutovtFzJqlRaqpZrCqSSGaHZzl9nIxxpjLzhSRLunN6dCLylj0uzlCyQGaQDIys7rrv8kVXiFO+R4Zpn0bX7g==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-android-arm-eabi/-/binding-android-arm-eabi-1.78.0.tgz",
+      "integrity": "sha512-Bu819lmAfZMUHErrpe0cEWj3iaefuUODHSU8+UbXy67V/r7/7f4K3FL0NmbD85E+wiFLDYuhP8Zlv0XnVeXshw==",
       "cpu": [
         "arm"
       ],
@@ -1917,9 +1919,9 @@
       }
     },
     "node_modules/@oxlint/binding-android-arm64": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-android-arm64/-/binding-android-arm64-1.75.0.tgz",
-      "integrity": "sha512-hXI0hDgHkw4w5nfru72aG7y+2iQJmC4waH/KV6H/hbgA6yAP5jYNx0P9yug15Hs0tWl/+mda3Jjn/2gmDT48tw==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-android-arm64/-/binding-android-arm64-1.78.0.tgz",
+      "integrity": "sha512-CDfxZgB61B7buRdY2FJoAYYPPXCZ1EoC1LKscnC5dg3kjobdxiconvAvvN1BmHyW4PyFT3jRLDag/BY/roSNBQ==",
       "cpu": [
         "arm64"
       ],
@@ -1934,9 +1936,9 @@
       }
     },
     "node_modules/@oxlint/binding-darwin-arm64": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-darwin-arm64/-/binding-darwin-arm64-1.75.0.tgz",
-      "integrity": "sha512-D91BWbK/dMYfCcrghspPIuKs2D9LF4Z/OabVSQjw1AO6PWxArD7teDA48bm0ySFqWDaPVqmQRl5GMWNglTXyrQ==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-darwin-arm64/-/binding-darwin-arm64-1.78.0.tgz",
+      "integrity": "sha512-2Y2U9Ahrz+OO0Ej88f9SJYq51/jUBp1Mc7iZu0ukrbeeZ3gpRGfzIFnoqfHDY96xr0GEfNrPUBFEy0nN5aD7HA==",
       "cpu": [
         "arm64"
       ],
@@ -1951,9 +1953,9 @@
       }
     },
     "node_modules/@oxlint/binding-darwin-x64": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-darwin-x64/-/binding-darwin-x64-1.75.0.tgz",
-      "integrity": "sha512-02mpwzf12BonZ6PT0TuQoomvEh2kVl2WGBIKWezCyToIS+rYkQZ6GXnARBAl9A4Ovm2V+Xe7M4KretyqmmcnJQ==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-darwin-x64/-/binding-darwin-x64-1.78.0.tgz",
+      "integrity": "sha512-rpych6eJq6m9jDRypTEaPD1xysaEW5h9+xuxhGK/QhOg+/xaqPZrCrTNoIl/f3nEjuJeCEmstNDlrE9rJi/3/g==",
       "cpu": [
         "x64"
       ],
@@ -1968,9 +1970,9 @@
       }
     },
     "node_modules/@oxlint/binding-freebsd-x64": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-freebsd-x64/-/binding-freebsd-x64-1.75.0.tgz",
-      "integrity": "sha512-qZJgLnDaBsiL5YESx2t/TZ8eXkL9fEkKoXEdzegROhlz9A0lgyGnZ0dAzJrh7LJAHQl2K9RdRueN2s/9N7+odg==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-freebsd-x64/-/binding-freebsd-x64-1.78.0.tgz",
+      "integrity": "sha512-IcMGrQT3QizkOESUJd5et+rOhVqSkNDfNik1cvrKDqIbzqx9KMtRswpFgkCuNTSwylCFLKhGUu8KmqY1ZnC0Dg==",
       "cpu": [
         "x64"
       ],
@@ -1985,9 +1987,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-arm-gnueabihf": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.75.0.tgz",
-      "integrity": "sha512-7XlaWA5BJD3XpCfrEqjEe6Zseeb14S7QGa304XfwKignRaKQ+eIj775BQ7nIslggWickl4IsPUFqJ+/gAyNHVg==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.78.0.tgz",
+      "integrity": "sha512-/uLdoJ0IXE6vo/0f0LKjinQAp+re+VMaCWaNT8ENIv2EOCkSsc8SGaflXAuW0Jua2dq5+GLVWm1NQK7P3UFSNQ==",
       "cpu": [
         "arm"
       ],
@@ -2002,9 +2004,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-arm-musleabihf": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm-musleabihf/-/binding-linux-arm-musleabihf-1.75.0.tgz",
-      "integrity": "sha512-av6Tpv8yrcMMMOadOqENBhlsLRcGFXXwoQ0hzHhsmS9FJ4Wioy8we427GbcMe2XTxmL2e60T67H1Dyr3up+tAA==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm-musleabihf/-/binding-linux-arm-musleabihf-1.78.0.tgz",
+      "integrity": "sha512-7xi4Wb/O8NRJhLoUXmDJMUVpNYvB5kefdhFU1Jb8rtae4QoXlTiLwI14X4YvAXVZLNZChP8m5qO9SQAlWQTbkQ==",
       "cpu": [
         "arm"
       ],
@@ -2019,9 +2021,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-arm64-gnu": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.75.0.tgz",
-      "integrity": "sha512-WcUhd8fHT5plrA14lANevl+hOl815mVI5t2hU21oFWrZKFXIVV/Sr4rWQV0NzSvzBupbMLNc5ErEA6Ehxh5jMg==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.78.0.tgz",
+      "integrity": "sha512-4hFW0+fVXa3OIh1Y4A5SPkmvI4wuuBSrCVKzOyE7PTjhc7yEqZ1pmvEEeS5Lj/MaqvegFxXyF33N+6jkehxdyg==",
       "cpu": [
         "arm64"
       ],
@@ -2039,9 +2041,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-arm64-musl": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.75.0.tgz",
-      "integrity": "sha512-UWzp5wRHFe/ESO3+eEaxXsTkYTGLYjnTsi/I5neEacXSItQ6WNleapfOAeA4x2b8nyhJ4uQxqvtv9pHv8kWJtQ==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.78.0.tgz",
+      "integrity": "sha512-oC0mvsgBJjlMijSDEhx9KuvR9zYeHXceA9MjbuXB1F8NSR78Yj2unOBrstEvTVaq+pko+kuue6DajC00eqvTdg==",
       "cpu": [
         "arm64"
       ],
@@ -2059,9 +2061,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-ppc64-gnu": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.75.0.tgz",
-      "integrity": "sha512-XEVRwGMLKCUKrvhLAz4F6AIh8MJrQVdSZtAmPpRZt9tGPsUnamPOcl3dS/ZQzJnar/Ymgc//+xho0L60Emzuxg==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.78.0.tgz",
+      "integrity": "sha512-XAllT5SUZS+ohjuZ3/5S0cwe0r7eboiuigeStCZ5DXRYx/2KVM2UvQXvAfyzXEimtQjAB7cDQ2YxDe2Zl2WNQQ==",
       "cpu": [
         "ppc64"
       ],
@@ -2079,9 +2081,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-riscv64-gnu": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-riscv64-gnu/-/binding-linux-riscv64-gnu-1.75.0.tgz",
-      "integrity": "sha512-mAG4DUXqfLC8cTjMD2kt3jDmVzFREYtDyeLNdLdsCcBc4Zbl2EMuiFektGBilQwkNjYnMvCqJs55U+Hyb+b+jw==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-riscv64-gnu/-/binding-linux-riscv64-gnu-1.78.0.tgz",
+      "integrity": "sha512-trucMER/0QtecoXvc1y/UVqE3kwJipDwrx4oHfj+nNm3dq2zjP44WT0CfHNDPM3G1DXIkx/gY6lAD21NSCZVhA==",
       "cpu": [
         "riscv64"
       ],
@@ -2099,9 +2101,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-riscv64-musl": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-riscv64-musl/-/binding-linux-riscv64-musl-1.75.0.tgz",
-      "integrity": "sha512-95hrAvriAlI+pekSomTFIn0+bawMDlDwTNVmdjsFusTHyL2JWh7TWvRNG/Lkim72uN8OiCcO9wcaC6omLP5E3w==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-riscv64-musl/-/binding-linux-riscv64-musl-1.78.0.tgz",
+      "integrity": "sha512-cm3O4F/HQbdzOUX5mKHqG5KDL6E5w0pnlZ+fbBy2rmLryPOowkuLagFHTopQsEIpjcaZoPOrL+BmmAytAG9HFg==",
       "cpu": [
         "riscv64"
       ],
@@ -2119,9 +2121,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-s390x-gnu": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.75.0.tgz",
-      "integrity": "sha512-4b6f2+FrtruAESrCqIKcrarzfrSx+wk2QNcp+RT91/Prc+pMQMAfyZ1rG1c3tFQNl8Bc616tx40uNXyxNBRPbQ==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.78.0.tgz",
+      "integrity": "sha512-33wRf6HqGNsybJ3qX4cGaQN2ODPxNmc1rMa0mrTmx3eFq1VzOnvQooi9bIGVYakW8a/wmqVx1mgsUm8R2xfTiw==",
       "cpu": [
         "s390x"
       ],
@@ -2139,9 +2141,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-x64-gnu": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.75.0.tgz",
-      "integrity": "sha512-nshAhrUvXFUWOvqQ2soIw7HFNWvpvEV4o0cYSqPtzLiPF5gKyYTDOOTJ6Rn8g8K/iGvPIrbDA4v8+5MvnjJrrg==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.78.0.tgz",
+      "integrity": "sha512-rRdISSYegj6VganMZ9tjRjijowfHJ09IZU01i0toBAqr6n5LEtwHq2IeS4FjW2RoskOHlb6efB26H5izYb3GEQ==",
       "cpu": [
         "x64"
       ],
@@ -2159,9 +2161,9 @@
       }
     },
     "node_modules/@oxlint/binding-linux-x64-musl": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-x64-musl/-/binding-linux-x64-musl-1.75.0.tgz",
-      "integrity": "sha512-e4jNxLKnxLC6sYBQRxrI2pgIIxnmMtF8U/VwNYcjTT/CLS+spH624cYVnj07bTKwaEWT37/e025isOs6j/0xqA==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-x64-musl/-/binding-linux-x64-musl-1.78.0.tgz",
+      "integrity": "sha512-GmsP4rW0xTL6u5CVdcDsaN5Fbc7hBc382Wmar1kttbnwSEviM+rSINKOMQ+UQ6iH+AGwC+8gaAiwu134Tgh6Lg==",
       "cpu": [
         "x64"
       ],
@@ -2179,9 +2181,9 @@
       }
     },
     "node_modules/@oxlint/binding-openharmony-arm64": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-openharmony-arm64/-/binding-openharmony-arm64-1.75.0.tgz",
-      "integrity": "sha512-hZ2lH+1qLf/DiEP9UWuQTK2JWj/BgvMB4jhIV4SmNU1wfEiYYX4TynQyAZXx0j9X4qRYizAL042SKaV+8ynh4w==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-openharmony-arm64/-/binding-openharmony-arm64-1.78.0.tgz",
+      "integrity": "sha512-sy9yeYuADc8a+n4TLBayzMCZiHPW78DcIFVpOXTmdKHWQeM9xe5uzkqIIZmi326D5hY9XVwacipEB1p7tQjPAg==",
       "cpu": [
         "arm64"
       ],
@@ -2196,9 +2198,9 @@
       }
     },
     "node_modules/@oxlint/binding-win32-arm64-msvc": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.75.0.tgz",
-      "integrity": "sha512-Ilj6PNzGDS3bCU0MSJH7Msh0NhH+T/mRp2shwg+q+GHeVlPwP5LEboW96aW+3kVKFk6zYZy1Xi5pZkqZh6X8KQ==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.78.0.tgz",
+      "integrity": "sha512-rjc2hF1KfMi8fZj1X/m3AmnHbdsF3rL0v6KQg0Uc880Yb2khjz+3U14sfdZ7jWTpRnN1m1NQa/TT7uU9lJWPrA==",
       "cpu": [
         "arm64"
       ],
@@ -2213,9 +2215,9 @@
       }
     },
     "node_modules/@oxlint/binding-win32-ia32-msvc": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.75.0.tgz",
-      "integrity": "sha512-QVit2nOEOiPhkmsrksPSkoGCdnZRNkspt8fwoYyP09te1VEbnSj4LAxua4rc8FKTmWkySVe05j8iz9GXYfF1AQ==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.78.0.tgz",
+      "integrity": "sha512-zcuXFVrEFHIafRfkCQT8w/Xe41o07ozl/vwHq7p94vB29xVzsB0sZGYORU1jhcYKv3Lr0J3HbJ2T4fHH5rWmvA==",
       "cpu": [
         "ia32"
       ],
@@ -2230,9 +2232,9 @@
       }
     },
     "node_modules/@oxlint/binding-win32-x64-msvc": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.75.0.tgz",
-      "integrity": "sha512-DSxnNkBUAYARPwJtR12Ig3deWr8w0H997xP6jy33i+e0SyYJw8FKuz4+cZtpmPEhQmvlPJE3X/2vNxDmLkd/rA==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.78.0.tgz",
+      "integrity": "sha512-Sb5ocmLSuYeOuXd+CFOToGKp/gjXUEWDnvIGwhnh8aq8wY4TMmEnKnvbogSW7RdMZv77JSARduS7/gv+khYEjA==",
       "cpu": [
         "x64"
       ],
@@ -2247,9 +2249,9 @@
       }
     },
     "node_modules/@oxlint/plugins": {
-      "version": "1.73.0",
-      "resolved": "https://registry.npmjs.org/@oxlint/plugins/-/plugins-1.73.0.tgz",
-      "integrity": "sha512-OhgMQeMmZA0dcFcX4/priaJZWdFECxiClgq6mRX6aatZEcV9PbKC3P3/v8U1hVjviT1i5U+vR8lAtBV6m4FXAA==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/plugins/-/plugins-1.78.0.tgz",
+      "integrity": "sha512-Ypt8KeRYw+4jUtlPirfcHWMrn5ms12VrrFPD+Mds477/7tJxG1Kcz2Yrg2nVcTQEUx/GdlhS+BUg1kmxNm04Ug==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -5866,9 +5868,9 @@
       }
     },
     "node_modules/oxlint": {
-      "version": "1.75.0",
-      "resolved": "https://registry.npmjs.org/oxlint/-/oxlint-1.75.0.tgz",
-      "integrity": "sha512-m9WzjRcRYA/uqIZDa9tclrieoPJ/ln1QYTKdFx6NUOs8uY5DiHlIwRQoCrHT6OM6O3ww3l2skY5gO7G7ZphE7g==",
+      "version": "1.78.0",
+      "resolved": "https://registry.npmjs.org/oxlint/-/oxlint-1.78.0.tgz",
+      "integrity": "sha512-QgQePuxIqKOzo1KSjG2EnITEeWvWnKAm77eq8nrMtf6AGoA+zyGc4PFYtDNJSD25g/ibOwfQ851hZ4/SPkMVoA==",
       "dev": true,
       "license": "MIT",
       "bin": {
@@ -5881,25 +5883,25 @@
         "url": "https://github.com/sponsors/Boshen"
       },
       "optionalDependencies": {
-        "@oxlint/binding-android-arm-eabi": "1.75.0",
-        "@oxlint/binding-android-arm64": "1.75.0",
-        "@oxlint/binding-darwin-arm64": "1.75.0",
-        "@oxlint/binding-darwin-x64": "1.75.0",
-        "@oxlint/binding-freebsd-x64": "1.75.0",
-        "@oxlint/binding-linux-arm-gnueabihf": "1.75.0",
-        "@oxlint/binding-linux-arm-musleabihf": "1.75.0",
-        "@oxlint/binding-linux-arm64-gnu": "1.75.0",
-        "@oxlint/binding-linux-arm64-musl": "1.75.0",
-        "@oxlint/binding-linux-ppc64-gnu": "1.75.0",
-        "@oxlint/binding-linux-riscv64-gnu": "1.75.0",
-        "@oxlint/binding-linux-riscv64-musl": "1.75.0",
-        "@oxlint/binding-linux-s390x-gnu": "1.75.0",
-        "@oxlint/binding-linux-x64-gnu": "1.75.0",
-        "@oxlint/binding-linux-x64-musl": "1.75.0",
-        "@oxlint/binding-openharmony-arm64": "1.75.0",
-        "@oxlint/binding-win32-arm64-msvc": "1.75.0",
-        "@oxlint/binding-win32-ia32-msvc": "1.75.0",
-        "@oxlint/binding-win32-x64-msvc": "1.75.0"
+        "@oxlint/binding-android-arm-eabi": "1.78.0",
+        "@oxlint/binding-android-arm64": "1.78.0",
+        "@oxlint/binding-darwin-arm64": "1.78.0",
+        "@oxlint/binding-darwin-x64": "1.78.0",
+        "@oxlint/binding-freebsd-x64": "1.78.0",
+        "@oxlint/binding-linux-arm-gnueabihf": "1.78.0",
+        "@oxlint/binding-linux-arm-musleabihf": "1.78.0",
+        "@oxlint/binding-linux-arm64-gnu": "1.78.0",
+        "@oxlint/binding-linux-arm64-musl": "1.78.0",
+        "@oxlint/binding-linux-ppc64-gnu": "1.78.0",
+        "@oxlint/binding-linux-riscv64-gnu": "1.78.0",
+        "@oxlint/binding-linux-riscv64-musl": "1.78.0",
+        "@oxlint/binding-linux-s390x-gnu": "1.78.0",
+        "@oxlint/binding-linux-x64-gnu": "1.78.0",
+        "@oxlint/binding-linux-x64-musl": "1.78.0",
+        "@oxlint/binding-openharmony-arm64": "1.78.0",
+        "@oxlint/binding-win32-arm64-msvc": "1.78.0",
+        "@oxlint/binding-win32-ia32-msvc": "1.78.0",
+        "@oxlint/binding-win32-x64-msvc": "1.78.0"
       },
       "peerDependencies": {
         "oxlint-tsgolint": ">=7.0.2001",
diff --git a/package.json b/package.json
index e50b9a6..af1ce49 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
     "start": "vp dev",
     "typecheck": "tsc -b",
     "format:check": "vp fmt --check .",
-    "lint": "vp lint src/app src/worker scripts test vite.config.ts vitest.config.ts vitest.app.config.ts vitest.migration.config.ts --deny-warnings",
+    "lint": "vp lint src processor scripts test vite.config.ts vitest.config.ts vitest.app.config.ts vitest.migration.config.ts --deny-warnings",
     "test": "node scripts/run-worker-tests.mjs && vp test run --config vitest.app.config.ts && vp test run --config vitest.migration.config.ts",
     "test:worker": "node scripts/run-worker-tests.mjs",
     "test:app": "vp test run --config vitest.app.config.ts",
@@ -43,6 +43,7 @@
   "devDependencies": {
     "@cloudflare/vite-plugin": "^1.50.0",
     "@cloudflare/vitest-pool-workers": "^0.20.1",
+    "@oxlint/plugins": "1.78.0",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
     "@types/node": "^26.1.2",
@@ -50,6 +51,7 @@
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.0.5",
     "jsdom": "^26.1.0",
+    "oxlint": "1.78.0",
     "tsx": "^4.23.5",
     "typescript": "^7.0.2",
     "vite": "^8.2.0",
@@ -57,6 +59,10 @@
     "vitest": "^4.1.10",
     "wrangler": "^4.118.0"
   },
+  "overrides": {
+    "@oxlint/plugins": "$@oxlint/plugins",
+    "oxlint": "$oxlint"
+  },
   "engines": {
     "node": ">=24.11.0"
   },
diff --git a/processor/video-processor.mjs b/processor/video-processor.mjs
index 7aa7257..16459fb 100644
--- a/processor/video-processor.mjs
+++ b/processor/video-processor.mjs
@@ -355,8 +355,8 @@ async function processRequest(payload) {
 function validatePayload(value) {
   if (
     !value ||
-    typeof value !== 'object' ||
-    typeof value.videoId !== 'string' ||
+    Object.prototype.toString.call(value) !== '[object Object]' ||
+    Object.prototype.toString.call(value.videoId) !== '[object String]' ||
     !/^[a-zA-Z0-9-]{1,128}$/.test(value.videoId) ||
     !Number.isInteger(value.attempt) ||
     value.attempt < 1
diff --git a/scripts/migrate/cli.ts b/scripts/migrate/cli.ts
index 50e5dec..c3bbb8d 100644
--- a/scripts/migrate/cli.ts
+++ b/scripts/migrate/cli.ts
@@ -30,7 +30,7 @@ interface Arguments {
 async function main() {
   const args = parseArguments(process.argv.slice(2));
   assertExplicitDestination(args.target, args.environment, args.confirmation);
-  const database = JSON.parse(await readFile(args.database, 'utf8')) as unknown;
+  const database = JSON.parse(await readFile(args.database, 'utf8'));
   const manifest = args.storageManifest
     ? await readStorageManifest(args.storageManifest)
     : [];
@@ -92,13 +92,22 @@ function destination(args: Arguments): ImportOptions {
   };
 }
 
-function parseArguments(argv: string[]): Arguments {
-  const command = argv.shift() as Arguments['command'] | undefined;
-  if (!command || !['validate', 'dry-run', 'import', 'reconcile'].includes(command)) {
-    throw new Error(
-      'Usage: cli.ts <validate|dry-run|import|reconcile> --database <export.json>',
-    );
+function parseCommand(value: string | undefined): Arguments['command'] {
+  switch (value) {
+    case 'validate':
+    case 'dry-run':
+    case 'import':
+    case 'reconcile':
+      return value;
+    default:
+      throw new Error(
+        'Usage: cli.ts <validate|dry-run|import|reconcile> --database <export.json>',
+      );
   }
+}
+
+function parseArguments(argv: string[]): Arguments {
+  const command = parseCommand(argv.shift());
   const flags = new Map<string, string>();
   for (let index = 0; index < argv.length; index += 2) {
     const flag = argv[index];
@@ -144,7 +153,7 @@ async function output(report: MigrationReport, filename?: string) {
   if (filename) console.log(`Report: ${path.resolve(filename)}`);
 }
 
-main().catch((error: unknown) => {
-  console.error(error instanceof Error ? error.message : error);
+main().catch((cause: unknown) => {
+  console.error(cause instanceof Error ? cause.message : cause);
   process.exitCode = 1;
 });
diff --git a/scripts/migrate/import.ts b/scripts/migrate/import.ts
index 22f7524..e6730d7 100644
--- a/scripts/migrate/import.ts
+++ b/scripts/migrate/import.ts
@@ -3,6 +3,7 @@ import {mkdtemp, rm, writeFile} from 'node:fs/promises';
 import {tmpdir} from 'node:os';
 import path from 'node:path';
 
+import {isJsonNumber, isJsonString} from '../../src/shared/json';
 import type {MigrationData, MigrationReport} from './types';
 
 export type Destination = 'local' | 'cloudflare';
@@ -180,7 +181,9 @@ export function migrationSql(data: MigrationData, destination: Destination = 'lo
   return `${statements.join('\n')}\n`;
 }
 
-function sql(strings: TemplateStringsArray, ...values: unknown[]) {
+type SqlValue = boolean | null | number | string | undefined;
+
+function sql(strings: TemplateStringsArray, ...values: SqlValue[]) {
   return strings.reduce(
     (result, part, index) =>
       result + part + (index < values.length ? quote(values[index]) : ''),
@@ -188,11 +191,10 @@ function sql(strings: TemplateStringsArray, ...values: unknown[]) {
   );
 }
 
-function quote(value: unknown) {
+function quote(value: SqlValue) {
   if (value === null || value === undefined) return 'NULL';
-  if (typeof value === 'number') return String(value);
-  if (typeof value !== 'string')
-    throw new TypeError('SQL values must be strings or numbers');
+  if (isJsonNumber(value)) return String(value);
+  if (!isJsonString(value)) throw new TypeError('SQL values must be strings or numbers');
   return `'${value.replaceAll("'", "''")}'`;
 }
 
@@ -228,8 +230,7 @@ function wrangler(args: string[], config?: string) {
   );
 }
 
-function commandError(error: unknown) {
-  if (error && typeof error === 'object' && 'stderr' in error)
-    return String(error.stderr).trim();
-  return error instanceof Error ? error.message : String(error);
+function commandError(cause: unknown) {
+  if (cause instanceof Error && 'stderr' in cause) return String(cause.stderr).trim();
+  return cause instanceof Error ? cause.message : String(cause);
 }
diff --git a/scripts/migrate/reconcile.ts b/scripts/migrate/reconcile.ts
index 262eb20..d430d1b 100644
--- a/scripts/migrate/reconcile.ts
+++ b/scripts/migrate/reconcile.ts
@@ -11,7 +11,7 @@ import {
 } from './types';
 import type {Destination, ImportOptions} from './import';
 
-const tables: Record<EntityName, string> = {
+const tables = {
   users: 'users',
   years: 'years',
   groups: 'groups',
@@ -22,12 +22,21 @@ const tables: Record<EntityName, string> = {
   votes: 'votes',
   awards: 'awards',
   media: 'media',
-};
+} satisfies Record<EntityName, string>;
 
-export function transformedCounts(data: MigrationData): Record<EntityName, number> {
-  return Object.fromEntries(
-    entityNames.map((name) => [name, data[name].length]),
-  ) as Record<EntityName, number>;
+export function transformedCounts(data: MigrationData) {
+  return {
+    users: data.users.length,
+    years: data.years.length,
+    groups: data.groups.length,
+    projects: data.projects.length,
+    projectMembers: data.projectMembers.length,
+    awardCategories: data.awardCategories.length,
+    projectNominations: data.projectNominations.length,
+    votes: data.votes.length,
+    awards: data.awards.length,
+    media: data.media.length,
+  } satisfies Record<EntityName, number>;
 }
 
 export function destinationCounts(options: ImportOptions, data: MigrationData) {
@@ -38,11 +47,11 @@ export function destinationCounts(options: ImportOptions, data: MigrationData) {
   const counts: Partial<Record<EntityName, number>> = {};
   const sourceCounts: Partial<Record<EntityName, number>> = {};
   for (const {row} of parsed.flatMap(({results}) => results)) {
-    const value = JSON.parse(row) as {
+    const value: {
       entity: EntityName;
       kind: 'all' | 'source';
       count: number;
-    };
+    } = JSON.parse(row);
     const target = value.kind === 'all' ? counts : sourceCounts;
     target[value.entity] = (target[value.entity] ?? 0) + value.count;
   }
@@ -55,7 +64,8 @@ function executeLocalCountQueries(options: ImportOptions, data: MigrationData) {
   writeFileSync(sqlFile, destinationCountSql(data), {mode: 0o600});
   try {
     const output = wranglerCountCommand(options, ['--file', sqlFile]);
-    return parseWranglerJson(output) as Array<{results: Array<{row: string}>}>;
+    const parsed: Array<{results: Array<{row: string}>}> = parseWranglerJson(output);
+    return parsed;
   } finally {
     rmSync(directory, {recursive: true, force: true});
   }
@@ -64,7 +74,8 @@ function executeLocalCountQueries(options: ImportOptions, data: MigrationData) {
 function executeRemoteCountQueries(options: ImportOptions, data: MigrationData) {
   return destinationCountStatements(data).flatMap((statement) => {
     const output = wranglerCountCommand(options, ['--command', statement]);
-    return parseWranglerJson(output) as Array<{results: Array<{row: string}>}>;
+    const parsed: Array<{results: Array<{row: string}>}> = parseWranglerJson(output);
+    return parsed;
   });
 }
 
@@ -129,41 +140,101 @@ export function reconcileCounts(report: MigrationReport) {
   }
 }
 
-function sourceCountQueries(name: EntityName, data: MigrationData) {
-  const rows = data[name] as unknown as Array<Record<string, unknown>>;
-  if (!rows.length) {
-    return [`SELECT json_object('entity','${name}','kind','source','count',0) row`];
+function sourceCountQueries(name: EntityName, data: MigrationData): string[] {
+  switch (name) {
+    case 'users':
+      return singleSourceCountQueries(
+        name,
+        'source_uid',
+        data.users.map((row) => row.sourceUid),
+      );
+    case 'years':
+      return singleSourceCountQueries(
+        name,
+        'id',
+        data.years.map((row) => row.id),
+      );
+    case 'groups':
+      return singleSourceCountQueries(
+        name,
+        'source_id',
+        data.groups.map((row) => row.sourceId),
+      );
+    case 'projects':
+      return singleSourceCountQueries(
+        name,
+        'source_id',
+        data.projects.map((row) => row.sourceId),
+      );
+    case 'projectMembers':
+      return pairSourceCountQueries(
+        name,
+        'user_id',
+        data.projectMembers.map((row) => [row.projectId, row.userId]),
+      );
+    case 'awardCategories':
+      return singleSourceCountQueries(
+        name,
+        'source_id',
+        data.awardCategories.map((row) => row.sourceId),
+      );
+    case 'projectNominations':
+      return pairSourceCountQueries(
+        name,
+        'award_category_id',
+        data.projectNominations.map((row) => [row.projectId, row.awardCategoryId]),
+      );
+    case 'votes':
+      return singleSourceCountQueries(
+        name,
+        'source_id',
+        data.votes.map((row) => row.sourceId),
+      );
+    case 'awards':
+      return singleSourceCountQueries(
+        name,
+        'source_id',
+        data.awards.map((row) => row.sourceId),
+      );
+    case 'media':
+      return singleSourceCountQueries(
+        name,
+        'source_id',
+        data.media.map((row) => row.sourceId),
+      );
   }
-  return chunks(rows, 100).map((chunk) => sourceCountQuery(name, chunk));
-}
-
-function sourceCountQuery(name: EntityName, rows: Array<Record<string, unknown>>) {
-  const column =
-    name === 'projectMembers' || name === 'projectNominations'
-      ? null
-      : name === 'years'
-        ? 'id'
-        : name === 'users'
-          ? 'source_uid'
-          : 'source_id';
-  const sourceProperty =
-    name === 'years' ? 'id' : name === 'users' ? 'sourceUid' : 'sourceId';
-  if (column) {
-    const values = rows.map((row) => `(${quote(row[sourceProperty])})`).join(',');
-    return `WITH expected(value) AS (VALUES ${values})
+}
+
+function singleSourceCountQueries(name: EntityName, column: string, values: string[]) {
+  if (!values.length) return [emptySourceCountQuery(name)];
+  return chunks(values, 100).map((chunk) => {
+    const expected = chunk.map((value) => `(${quote(value)})`).join(',');
+    return `WITH expected(value) AS (VALUES ${expected})
       SELECT json_object('entity','${name}','kind','source','count',COUNT(*)) row
       FROM ${tables[name]} destination JOIN expected ON destination.${column}=expected.value`;
-  }
-  const secondColumn = name === 'projectMembers' ? 'user_id' : 'award_category_id';
-  const secondProperty = name === 'projectMembers' ? 'userId' : 'awardCategoryId';
-  const values = rows
-    .map((row) => `(${quote(row.projectId)},${quote(row[secondProperty])})`)
-    .join(',');
-  return `WITH expected(project_id, related_id) AS (VALUES ${values})
-    SELECT json_object('entity','${name}','kind','source','count',COUNT(*)) row
-    FROM ${tables[name]} destination JOIN expected
-      ON destination.project_id=expected.project_id
-      AND destination.${secondColumn}=expected.related_id`;
+  });
+}
+
+function pairSourceCountQueries(
+  name: EntityName,
+  secondColumn: string,
+  values: Array<[string, string]>,
+) {
+  if (!values.length) return [emptySourceCountQuery(name)];
+  return chunks(values, 100).map((chunk) => {
+    const expected = chunk
+      .map(([projectId, relatedId]) => `(${quote(projectId)},${quote(relatedId)})`)
+      .join(',');
+    return `WITH expected(project_id, related_id) AS (VALUES ${expected})
+      SELECT json_object('entity','${name}','kind','source','count',COUNT(*)) row
+      FROM ${tables[name]} destination JOIN expected
+        ON destination.project_id=expected.project_id
+        AND destination.${secondColumn}=expected.related_id`;
+  });
+}
+
+function emptySourceCountQuery(name: EntityName) {
+  return `SELECT json_object('entity','${name}','kind','source','count',0) row`;
 }
 
 function chunks<T>(values: T[], size: number) {
@@ -172,7 +243,7 @@ function chunks<T>(values: T[], size: number) {
   );
 }
 
-function quote(value: unknown) {
+function quote<T>(value: T) {
   return `'${String(value).replaceAll("'", "''")}'`;
 }
 
diff --git a/scripts/migrate/transform.ts b/scripts/migrate/transform.ts
index f388b87..12d6756 100644
--- a/scripts/migrate/transform.ts
+++ b/scripts/migrate/transform.ts
@@ -3,15 +3,19 @@ import {readFile} from 'node:fs/promises';
 import path from 'node:path';
 
 import {
-  entityNames,
+  isJsonNumber,
+  isJsonObject,
+  isJsonString,
+  type JsonInput,
+  type JsonObject,
+} from '../../src/shared/json';
+import {
   type EntityName,
   type MigrationData,
   type MigrationIssue,
   type StorageManifestEntry,
 } from './types';
 
-type JsonObject = Record<string, unknown>;
-
 export interface TransformResult {
   data: MigrationData;
   issues: MigrationIssue[];
@@ -27,8 +31,8 @@ export interface TransformResult {
   }>;
 }
 
-export async function transformFirebaseExport(
-  value: unknown,
+export async function transformFirebaseExport<T>(
+  value: T,
   manifest: StorageManifestEntry[] = [],
   storageRoot?: string,
 ): Promise<TransformResult> {
@@ -37,10 +41,18 @@ export async function transformFirebaseExport(
   const data = emptyData();
   const issues: MigrationIssue[] = [];
   reportUnknownKeys(root, new Set(['users', 'years']), '', issues);
-  const sourceCounts = Object.fromEntries(entityNames.map((name) => [name, 0])) as Record<
-    EntityName,
-    number
-  >;
+  const sourceCounts = {
+    users: 0,
+    years: 0,
+    groups: 0,
+    projects: 0,
+    projectMembers: 0,
+    awardCategories: 0,
+    projectNominations: 0,
+    votes: 0,
+    awards: 0,
+    media: 0,
+  } satisfies Record<EntityName, number>;
   const manifestByPath = new Map<string, StorageManifestEntry>();
   for (const [index, entry] of manifest.entries()) {
     const sourcePath = normalizeSourcePath(entry.path);
@@ -268,7 +280,7 @@ export async function transformFirebaseExport(
         data.projectNominations.push({
           projectId,
           awardCategoryId: categoryId,
-          position: (positionIndex + 1) as 1 | 2,
+          position: positionIndex === 0 ? 1 : 2,
         });
       }
 
@@ -511,29 +523,30 @@ function safeStorageFile(root: string, relative: string) {
   return candidate.startsWith(`${absoluteRoot}${path.sep}`) ? candidate : null;
 }
 
-function object(value: unknown): JsonObject | null {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-    ? (value as JsonObject)
-    : null;
+function object<T>(value: T): JsonObject | null {
+  return isJsonObject(value) ? value : null;
 }
 
-function entries(value: unknown, at: string, issues: MigrationIssue[]) {
-  if (value === undefined || value === null || value === '')
-    return [] as Array<[string, unknown]>;
+function entries(
+  value: JsonInput,
+  at: string,
+  issues: MigrationIssue[],
+): Array<[string, JsonInput]> {
+  if (value === undefined || value === null || value === '') return [];
   const record = object(value);
   if (!record) {
     issue(issues, 'error', 'INVALID_COLLECTION', at, 'expected an object map');
-    return [] as Array<[string, unknown]>;
+    return [];
   }
   return Object.entries(record);
 }
 
-function text(value: unknown) {
-  return typeof value === 'string' && value.trim() ? value.trim() : null;
+function text(value: JsonInput) {
+  return isJsonString(value) && value.trim() ? value.trim() : null;
 }
 
-function timestamp(value: unknown) {
-  return typeof value === 'number' && Number.isFinite(value)
+function timestamp(value: JsonInput) {
+  return isJsonNumber(value) && Number.isFinite(value)
     ? new Date(value).toISOString()
     : '1970-01-01T00:00:00.000Z';
 }
@@ -583,42 +596,58 @@ function emptyData(): MigrationData {
 }
 
 function detectDuplicates(data: MigrationData, issues: MigrationIssue[]) {
-  for (const name of entityNames) {
-    const rows = data[name] as unknown as Array<Record<string, unknown>>;
-    const seen = new Set<string>();
-    for (const [index, row] of rows.entries()) {
-      const key =
-        name === 'projectMembers'
-          ? `${stringValue(row.projectId)}:${stringValue(row.userId)}`
-          : name === 'projectNominations'
-            ? `${stringValue(row.projectId)}:${stringValue(row.awardCategoryId)}`
-            : stringValue(row.id);
-      if (seen.has(key)) issue(issues, 'error', 'DUPLICATE_ID', `${name}/${index}`, key);
-      seen.add(key);
-    }
-  }
+  checkDuplicates('users', data.users, (row) => row.id, issues);
+  checkDuplicates('years', data.years, (row) => row.id, issues);
+  checkDuplicates('groups', data.groups, (row) => row.id, issues);
+  checkDuplicates('projects', data.projects, (row) => row.id, issues);
+  checkDuplicates(
+    'projectMembers',
+    data.projectMembers,
+    (row) => `${row.projectId}:${row.userId}`,
+    issues,
+  );
+  checkDuplicates('awardCategories', data.awardCategories, (row) => row.id, issues);
+  checkDuplicates(
+    'projectNominations',
+    data.projectNominations,
+    (row) => `${row.projectId}:${row.awardCategoryId}`,
+    issues,
+  );
+  checkDuplicates('votes', data.votes, (row) => row.id, issues);
+  checkDuplicates('awards', data.awards, (row) => row.id, issues);
+  checkDuplicates('media', data.media, (row) => row.id, issues);
 }
 
-function stringValue(value: unknown) {
-  return typeof value === 'string' ? value : '';
+function checkDuplicates<T>(
+  name: EntityName,
+  rows: T[],
+  keyFor: (row: T) => string,
+  issues: MigrationIssue[],
+) {
+  const seen = new Set<string>();
+  for (const [index, row] of rows.entries()) {
+    const key = keyFor(row);
+    if (seen.has(key)) issue(issues, 'error', 'DUPLICATE_ID', `${name}/${index}`, key);
+    seen.add(key);
+  }
 }
 
 export async function readStorageManifest(
   filename: string,
 ): Promise<StorageManifestEntry[]> {
-  const parsed: unknown = JSON.parse(await readFile(filename, 'utf8'));
+  const parsed: JsonInput = JSON.parse(await readFile(filename, 'utf8'));
   if (!Array.isArray(parsed)) throw new Error('Storage manifest must be a JSON array');
   return parsed.map((value, index) => {
     const entry = object(value);
-    if (!entry || typeof entry.path !== 'string') {
+    if (!entry || !isJsonString(entry.path)) {
       throw new Error(`Storage manifest entry ${index} must contain a path`);
     }
     return {
       path: entry.path,
-      file: typeof entry.file === 'string' ? entry.file : undefined,
-      size: typeof entry.size === 'number' ? entry.size : undefined,
-      sha256: typeof entry.sha256 === 'string' ? entry.sha256 : undefined,
-      contentType: typeof entry.contentType === 'string' ? entry.contentType : undefined,
+      file: isJsonString(entry.file) ? entry.file : undefined,
+      size: isJsonNumber(entry.size) ? entry.size : undefined,
+      sha256: isJsonString(entry.sha256) ? entry.sha256 : undefined,
+      contentType: isJsonString(entry.contentType) ? entry.contentType : undefined,
     };
   });
 }
diff --git a/scripts/setup-worktree.mjs b/scripts/setup-worktree.mjs
index a3231e2..ff62e21 100644
--- a/scripts/setup-worktree.mjs
+++ b/scripts/setup-worktree.mjs
@@ -128,7 +128,7 @@ async function masterWorktree() {
       ),
     );
   const master = worktrees.find((worktree) => worktree.branch === 'refs/heads/master');
-  if (typeof master?.worktree !== 'string') {
+  if (Object.prototype.toString.call(master?.worktree) !== '[object String]') {
     throw new Error(
       'The master branch must have a checked-out worktree to seed local state',
     );
@@ -148,7 +148,8 @@ async function filesMatch(left, right) {
     ]);
     return leftContent.equals(rightContent);
   } catch (error) {
-    if (error && typeof error === 'object' && error.code === 'ENOENT') return false;
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+      return false;
     throw error;
   }
 }
@@ -157,7 +158,8 @@ async function exists(value) {
   return stat(value).then(
     () => true,
     (error) => {
-      if (error && typeof error === 'object' && error.code === 'ENOENT') return false;
+      if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+        return false;
       throw error;
     },
   );
diff --git a/src/app/components/ProjectForm.tsx b/src/app/components/ProjectForm.tsx
index 28f34cd..2c2ae11 100644
--- a/src/app/components/ProjectForm.tsx
+++ b/src/app/components/ProjectForm.tsx
@@ -237,7 +237,10 @@ export function ProjectForm({
             <div
               className="teamSearch"
               onBlur={(event) => {
-                if (!event.currentTarget.contains(event.relatedTarget as Node | null)) {
+                if (
+                  !(event.relatedTarget instanceof Node) ||
+                  !event.currentTarget.contains(event.relatedTarget)
+                ) {
                   setMemberResultsOpen(false);
                   setHighlightedMember(-1);
                 }
diff --git a/src/app/player/audio.ts b/src/app/player/audio.ts
index d2f7d23..08ae8e8 100644
--- a/src/app/player/audio.ts
+++ b/src/app/player/audio.ts
@@ -15,11 +15,21 @@ export interface PlayerAudioGraph {
   close(): Promise<void>;
 }
 
+export interface PlayerAudioContext {
+  state: AudioContextState;
+  destination: AudioDestinationNode;
+  createDynamicsCompressor(): DynamicsCompressorNode;
+  createMediaElementSource(element: HTMLMediaElement): MediaElementAudioSourceNode;
+  createGain(): GainNode;
+  resume(): Promise<void>;
+  close(): Promise<void>;
+}
+
 export function createPlayerAudioGraph(
   elements: [HTMLVideoElement, HTMLVideoElement],
-  AudioContextClass: typeof AudioContext = window.AudioContext,
+  createContext: () => PlayerAudioContext = () => new window.AudioContext(),
 ): PlayerAudioGraph {
-  const context = new AudioContextClass();
+  const context = createContext();
   const limiter = context.createDynamicsCompressor();
   limiter.threshold.value = -3;
   limiter.knee.value = 6;
@@ -28,13 +38,14 @@ export function createPlayerAudioGraph(
   limiter.release.value = 0.25;
   limiter.connect(context.destination);
 
-  const gains = elements.map((element) => {
+  const gainFor = (element: HTMLVideoElement) => {
     const source = context.createMediaElementSource(element);
     const gain = context.createGain();
     source.connect(gain);
     gain.connect(limiter);
     return gain;
-  }) as [GainNode, GainNode];
+  };
+  const gains: [GainNode, GainNode] = [gainFor(elements[0]), gainFor(elements[1])];
 
   return {
     async resume() {
diff --git a/src/app/player/controller.ts b/src/app/player/controller.ts
index 5ebf413..3cb6872 100644
--- a/src/app/player/controller.ts
+++ b/src/app/player/controller.ts
@@ -144,8 +144,8 @@ export function createScreeningController({
       notify();
       void elements[active]
         .play()
-        .catch((error: unknown) =>
-          fail(error instanceof Error ? error.message : 'playback could not start'),
+        .catch((cause: unknown) =>
+          fail(cause instanceof Error ? cause.message : 'playback could not start'),
         );
     }, titleDurationMs);
   }
@@ -210,10 +210,10 @@ export function createScreeningController({
     clearTransitionTimers();
     elements[active].pause();
     index = nextIndex;
-    active = (nextIndex % 2) as 0 | 1;
+    active = nextIndex % 2 === 0 ? 0 : 1;
     await audio.resume();
-    await playCurrent().catch((error: unknown) =>
-      fail(error instanceof Error ? error.message : 'playback could not start'),
+    await playCurrent().catch((cause: unknown) =>
+      fail(cause instanceof Error ? cause.message : 'playback could not start'),
     );
   }
 
diff --git a/src/app/queries/api.ts b/src/app/queries/api.ts
index 38e4476..ea20390 100644
--- a/src/app/queries/api.ts
+++ b/src/app/queries/api.ts
@@ -15,7 +15,7 @@ export async function apiRequest<T>(path: string, init?: RequestInit): Promise<T
   if (!response.ok) {
     let error: ApiErrorResponse | null = null;
     try {
-      error = (await response.json()) as ApiErrorResponse;
+      error = await response.json();
     } catch {
       // The status remains useful when an upstream response is not JSON.
     }
@@ -25,11 +25,14 @@ export async function apiRequest<T>(path: string, init?: RequestInit): Promise<T
       error?.error.message ?? 'The request could not be completed',
     );
   }
-  if (response.status === 204) return undefined as T;
-  return response.json() as Promise<T>;
+  if (response.status === 204) {
+    // SAFETY: API callers use `void` for endpoints whose documented response is 204.
+    return undefined as T;
+  }
+  return response.json();
 }
 
-export function jsonRequest(method: string, body: unknown): RequestInit {
+export function jsonRequest<T>(method: string, body: T): RequestInit {
   return {
     method,
     headers: {'Content-Type': 'application/json'},
diff --git a/src/app/session.tsx b/src/app/session.tsx
index 19dda1d..3d8355c 100644
--- a/src/app/session.tsx
+++ b/src/app/session.tsx
@@ -54,7 +54,7 @@ export function SessionProvider({children}: {children: ReactNode}) {
     fetch('/api/session', {signal: controller.signal})
       .then(async (response) => {
         if (response.ok) {
-          const result = (await response.json()) as SessionResponse;
+          const result: SessionResponse = await response.json();
           setSession({
             status: 'authenticated',
             user: result.user,
@@ -64,7 +64,7 @@ export function SessionProvider({children}: {children: ReactNode}) {
           return;
         }
 
-        const result = (await response.json()) as ApiErrorResponse;
+        const result: ApiErrorResponse = await response.json();
         if (response.status === 401) {
           setSession({status: 'unauthenticated', user: null, reason: authError});
         } else if (response.status === 403 || result.error.code === 'AUTH_FORBIDDEN') {
diff --git a/src/app/video/ProjectVideoPanel.tsx b/src/app/video/ProjectVideoPanel.tsx
index 2ab5f46..293d9df 100644
--- a/src/app/video/ProjectVideoPanel.tsx
+++ b/src/app/video/ProjectVideoPanel.tsx
@@ -203,12 +203,12 @@ export function ProjectVideoPanel(props: {
 }
 
 function VideoStatusCard({video}: {video: ProjectVideo}) {
-  const labels: Record<ProjectVideo['status'], string> = {
+  const labels = {
     queued: 'queued for processing',
     processing: 'processing video',
     ready: 'ready to watch',
     failed: 'needs attention',
-  };
+  } satisfies Record<ProjectVideo['status'], string>;
   return (
     <div className={`videoStatus videoStatus--${video.status}`}>
       <span className="statusDot" aria-hidden="true" />
diff --git a/src/app/video/upload.ts b/src/app/video/upload.ts
index 766d1e2..c0321d4 100644
--- a/src/app/video/upload.ts
+++ b/src/app/video/upload.ts
@@ -1,3 +1,9 @@
+import {
+  isJsonNumber,
+  isJsonObject,
+  isJsonString,
+  type JsonInput,
+} from '../../shared/json';
 import type {VideoUploadPart, VideoUploadSession} from '../../shared/videos';
 
 export type UploadPhase = 'uploading' | 'paused' | 'interrupted' | 'complete';
@@ -25,6 +31,39 @@ interface ResumeRecord {
   completedParts: VideoUploadPart[];
 }
 
+function parseResumeRecord(value: JsonInput): ResumeRecord {
+  if (
+    !isJsonObject(value) ||
+    !isJsonString(value.projectId) ||
+    !isJsonString(value.uploadId) ||
+    !isJsonString(value.fileName) ||
+    !isJsonNumber(value.fileSize) ||
+    !isJsonNumber(value.lastModified) ||
+    !Array.isArray(value.completedParts)
+  ) {
+    throw new Error('Invalid resumable upload record');
+  }
+  const completedParts = value.completedParts.map((part) => {
+    if (
+      !isJsonObject(part) ||
+      !isJsonNumber(part.partNumber) ||
+      !isJsonString(part.etag) ||
+      !isJsonNumber(part.sizeBytes)
+    ) {
+      throw new Error('Invalid resumable upload part');
+    }
+    return {partNumber: part.partNumber, etag: part.etag, sizeBytes: part.sizeBytes};
+  });
+  return {
+    projectId: value.projectId,
+    uploadId: value.uploadId,
+    fileName: value.fileName,
+    fileSize: value.fileSize,
+    lastModified: value.lastModified,
+    completedParts,
+  };
+}
+
 export function createMultipartUpload(
   file: File,
   session: VideoUploadSession,
@@ -63,7 +102,7 @@ export function createMultipartUpload(
           signal: active.signal,
         });
         if (!response.ok) throw await responseError(response);
-        const result = (await response.json()) as {part: VideoUploadPart};
+        const result: {part: VideoUploadPart} = await response.json();
         parts = [...parts, result.part].sort(
           (left, right) => left.partNumber - right.partNumber,
         );
@@ -119,11 +158,11 @@ export function resumeStorageKey(projectId: string, file: File) {
 }
 
 export function readResumeRecord(projectId: string, file: File) {
-  if (typeof localStorage === 'undefined') return null;
+  if (!('localStorage' in globalThis)) return null;
   const value = localStorage.getItem(resumeStorageKey(projectId, file));
   if (!value) return null;
   try {
-    const record = JSON.parse(value) as ResumeRecord;
+    const record = parseResumeRecord(JSON.parse(value));
     if (
       record.projectId !== projectId ||
       record.fileName !== file.name ||
@@ -146,7 +185,7 @@ export function persistResumeRecord(
   session: VideoUploadSession,
   completedParts = session.completedParts,
 ) {
-  if (typeof localStorage === 'undefined') return;
+  if (!('localStorage' in globalThis)) return;
   const record: ResumeRecord = {
     projectId: session.projectId,
     uploadId: session.uploadId,
@@ -159,7 +198,7 @@ export function persistResumeRecord(
 }
 
 export function clearResumeRecord(projectId: string, file: File) {
-  if (typeof localStorage === 'undefined') return;
+  if (!('localStorage' in globalThis)) return;
   localStorage.removeItem(resumeStorageKey(projectId, file));
 }
 
@@ -173,7 +212,7 @@ function partUrl(session: VideoUploadSession, partNumber: number) {
 
 async function responseError(response: Response) {
   try {
-    const value = (await response.json()) as {error?: {message?: string}};
+    const value: {error?: {message?: string}} = await response.json();
     return new Error(value.error?.message || `Upload failed (${response.status})`);
   } catch {
     return new Error(`Upload failed (${response.status})`);
diff --git a/src/shared/json.ts b/src/shared/json.ts
new file mode 100644
index 0000000..bf8f3a9
--- /dev/null
+++ b/src/shared/json.ts
@@ -0,0 +1,33 @@
+export type JsonInput =
+  | boolean
+  | null
+  | number
+  | string
+  | JsonInput[]
+  | JsonObject
+  | undefined;
+
+export interface JsonObject {
+  [key: string]: JsonInput;
+}
+
+export function isJsonObject<T>(value: T): value is T & JsonObject {
+  return (
+    value !== null &&
+    value !== undefined &&
+    !Array.isArray(value) &&
+    Object.prototype.toString.call(value) === '[object Object]'
+  );
+}
+
+export function isJsonString<T>(value: T): value is T & string {
+  return Object.prototype.toString.call(value) === '[object String]';
+}
+
+export function isJsonNumber<T>(value: T): value is T & number {
+  return Object.prototype.toString.call(value) === '[object Number]';
+}
+
+export function isJsonBoolean<T>(value: T): value is T & boolean {
+  return Object.prototype.toString.call(value) === '[object Boolean]';
+}
diff --git a/src/shared/profile.ts b/src/shared/profile.ts
index e4890d3..fb7c3f4 100644
--- a/src/shared/profile.ts
+++ b/src/shared/profile.ts
@@ -1,13 +1,14 @@
 import type {UpdateProfileRequest} from './api';
+import {isJsonObject, isJsonString, type JsonInput} from './json';
 
 export class ProfileValidationError extends Error {}
 
-export function parseUpdateProfile(value: unknown): UpdateProfileRequest {
-  if (!isObject(value)) {
+export function parseUpdateProfile(value: JsonInput): UpdateProfileRequest {
+  if (!isJsonObject(value)) {
     throw new ProfileValidationError('Profile must be a JSON object');
   }
 
-  if (typeof value.displayName !== 'string') {
+  if (!isJsonString(value.displayName)) {
     throw new ProfileValidationError('Display name is required');
   }
 
@@ -16,12 +17,12 @@ export function parseUpdateProfile(value: unknown): UpdateProfileRequest {
     throw new ProfileValidationError('Display name must be between 1 and 100 characters');
   }
 
-  if (value.avatarUrl !== null && typeof value.avatarUrl !== 'string') {
+  if (value.avatarUrl !== null && !isJsonString(value.avatarUrl)) {
     throw new ProfileValidationError('Avatar URL must be a URL or null');
   }
 
   let avatarUrl: string | null = null;
-  if (typeof value.avatarUrl === 'string' && value.avatarUrl.length > 0) {
+  if (isJsonString(value.avatarUrl) && value.avatarUrl.length > 0) {
     if (value.avatarUrl.length > 2048) {
       throw new ProfileValidationError('Avatar URL is too long');
     }
@@ -41,7 +42,3 @@ export function parseUpdateProfile(value: unknown): UpdateProfileRequest {
 
   return {displayName, avatarUrl};
 }
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
diff --git a/src/worker/integrations/google-oauth.ts b/src/worker/integrations/google-oauth.ts
index e6e465a..2a57f60 100644
--- a/src/worker/integrations/google-oauth.ts
+++ b/src/worker/integrations/google-oauth.ts
@@ -1,5 +1,6 @@
 import {createLocalJWKSet, createRemoteJWKSet, jwtVerify, type JWTPayload} from 'jose';
 
+import {isJsonString} from '../../shared/json';
 import {
   assertAllowedEmail,
   AuthenticationError,
@@ -72,7 +73,7 @@ export async function exchangeAuthorizationCode(
   }
   let body: TokenExchangeResponse;
   try {
-    body = (await response.json()) as TokenExchangeResponse;
+    body = await response.json();
   } catch {
     throw new AuthenticationError('AUTH_INVALID', 'Google token exchange failed', 401);
   }
@@ -105,12 +106,12 @@ export async function verifyGoogleIdToken(
   if (
     payload.aud !== config.clientId ||
     payload.nonce !== expectedNonce ||
-    typeof payload.sub !== 'string' ||
+    !isJsonString(payload.sub) ||
     !payload.sub
   ) {
     throw new AuthenticationError('AUTH_INVALID', 'Google ID token is invalid', 401);
   }
-  if (payload.email_verified !== true || typeof payload.email !== 'string') {
+  if (payload.email_verified !== true || !isJsonString(payload.email)) {
     throw new AuthenticationError(
       'AUTH_FORBIDDEN',
       'Verified Google email is required',
@@ -120,7 +121,7 @@ export async function verifyGoogleIdToken(
   const email = payload.email.trim().toLowerCase();
   assertAllowedEmail(email, config.allowedEmailDomain);
   const displayName =
-    typeof payload.name === 'string' && payload.name.trim()
+    isJsonString(payload.name) && payload.name.trim()
       ? payload.name.trim().slice(0, 100)
       : email.slice(0, email.lastIndexOf('@'));
   return {
@@ -133,8 +134,9 @@ export async function verifyGoogleIdToken(
 
 function parseJwks(value: string) {
   try {
-    const parsed = JSON.parse(value) as {keys?: unknown};
+    const parsed: {keys?: unknown} = JSON.parse(value);
     if (!Array.isArray(parsed.keys) || parsed.keys.length === 0) throw new Error();
+    // SAFETY: createLocalJWKSet performs the authoritative validation of every JWK.
     return parsed as Parameters<typeof createLocalJWKSet>[0];
   } catch {
     throw new AuthenticationError(
@@ -145,8 +147,8 @@ function parseJwks(value: string) {
   }
 }
 
-function safeAvatarUrl(value: unknown) {
-  if (typeof value !== 'string' || value.length > 2048) return null;
+function safeAvatarUrl<T>(value: T) {
+  if (!isJsonString(value) || value.length > 2048) return null;
   try {
     const url = new URL(value);
     return url.protocol === 'https:' ? url.toString() : null;
diff --git a/src/worker/integrations/historical-source.ts b/src/worker/integrations/historical-source.ts
index 6eeeaf3..286f7b1 100644
--- a/src/worker/integrations/historical-source.ts
+++ b/src/worker/integrations/historical-source.ts
@@ -1,3 +1,5 @@
+import {isJsonString} from '../../shared/json';
+
 export interface HistoricalVideoSource {
   createReadUrl(key: string, expiresInSeconds: number): Promise<string>;
 }
@@ -77,7 +79,7 @@ async function sha256Hex(value: string) {
 }
 
 async function hmac(key: string | ArrayBuffer, value: string) {
-  const rawKey = typeof key === 'string' ? new TextEncoder().encode(key) : key;
+  const rawKey = isJsonString(key) ? new TextEncoder().encode(key) : key;
   const cryptoKey = await crypto.subtle.importKey(
     'raw',
     rawKey,
diff --git a/src/worker/middleware/auth.ts b/src/worker/middleware/auth.ts
index 15202f6..f9ac9c5 100644
--- a/src/worker/middleware/auth.ts
+++ b/src/worker/middleware/auth.ts
@@ -227,10 +227,10 @@ function readCookie(header: string | undefined, name: string) {
   return undefined;
 }
 
-function authenticationErrorResponse(c: {json: Function}, error: unknown) {
+function authenticationErrorResponse(c: {json: Function}, cause: unknown) {
   const authError =
-    error instanceof AuthenticationError
-      ? error
+    cause instanceof AuthenticationError
+      ? cause
       : new AuthenticationError('AUTH_INVALID', 'Authentication failed', 401);
   const response: ApiErrorResponse = {
     error: {code: authError.code, message: authError.message},
diff --git a/src/worker/repositories/administration.ts b/src/worker/repositories/administration.ts
index 95d0b6b..adb1d1d 100644
--- a/src/worker/repositories/administration.ts
+++ b/src/worker/repositories/administration.ts
@@ -362,7 +362,7 @@ export async function replaceNominations(
   }
   return categoryIds.map((categoryId, index) => ({
     categoryId,
-    position: (index + 1) as 1 | 2,
+    position: index === 0 ? 1 : 2,
   }));
 }
 
@@ -607,9 +607,9 @@ function mapAward(row: {
   };
 }
 
-function administrationConstraint(error: unknown, fallback: string) {
-  if (!(error instanceof Error)) return error;
-  if (error.message.includes('UNIQUE constraint failed')) {
+function administrationConstraint(cause: unknown, fallback: string) {
+  if (!(cause instanceof Error)) return cause;
+  if (cause.message.includes('UNIQUE constraint failed')) {
     return new ServiceError('CONFLICT', 'That record already exists', 409);
   }
   const known = [
@@ -621,7 +621,7 @@ function administrationConstraint(error: unknown, fallback: string) {
     'award references must',
     'screening entry must',
     'FOREIGN KEY constraint failed',
-  ].find((message) => error.message.includes(message));
+  ].find((message) => cause.message.includes(message));
   if (known) return new ServiceError('VALIDATION_FAILED', known, 400);
   return new ServiceError('CONFLICT', fallback, 409);
 }
diff --git a/src/worker/repositories/groups.ts b/src/worker/repositories/groups.ts
index 3f592d8..2376fb1 100644
--- a/src/worker/repositories/groups.ts
+++ b/src/worker/repositories/groups.ts
@@ -77,13 +77,13 @@ export async function deleteGroup(db: D1Database, groupId: string) {
   ]);
 }
 
-function constraintError(error: unknown) {
-  if (error instanceof Error && error.message.includes('UNIQUE constraint failed')) {
+function constraintError(cause: unknown) {
+  if (cause instanceof Error && cause.message.includes('UNIQUE constraint failed')) {
     return new ServiceError(
       'CONFLICT',
       'A group with this identifier already exists',
       409,
     );
   }
-  return error;
+  return cause;
 }
diff --git a/src/worker/routes/auth.ts b/src/worker/routes/auth.ts
index 7f9add1..01db6c5 100644
--- a/src/worker/routes/auth.ts
+++ b/src/worker/routes/auth.ts
@@ -131,9 +131,9 @@ function safeConfig(c: {env: AuthBindings}) {
   }
 }
 
-function callbackFailure(c: Parameters<typeof callbackErrorRedirect>[0], error: unknown) {
+function callbackFailure(c: Parameters<typeof callbackErrorRedirect>[0], cause: unknown) {
   const reason =
-    error instanceof AuthenticationError && error.code === 'AUTH_FORBIDDEN'
+    cause instanceof AuthenticationError && cause.code === 'AUTH_FORBIDDEN'
       ? 'forbidden'
       : 'failed';
   return callbackErrorRedirect(c, reason);
diff --git a/src/worker/routes/session.ts b/src/worker/routes/session.ts
index e7c9445..6566da1 100644
--- a/src/worker/routes/session.ts
+++ b/src/worker/routes/session.ts
@@ -1,6 +1,7 @@
 import {Hono} from 'hono';
 
 import type {ApiErrorResponse, SessionResponse, SessionViewMode} from '../../shared/api';
+import {isJsonObject, type JsonInput} from '../../shared/json';
 import {parseUpdateProfile, ProfileValidationError} from '../../shared/profile';
 import type {AuthBindings, AuthVariables} from '../middleware/auth';
 import {setSessionViewMode} from '../services/sessions';
@@ -68,13 +69,8 @@ sessionRoutes.put('/profile', async (c) => {
   }
 });
 
-function parseViewMode(value: unknown): SessionViewMode {
-  if (
-    typeof value !== 'object' ||
-    value === null ||
-    !('mode' in value) ||
-    (value.mode !== 'admin' && value.mode !== 'member')
-  ) {
+function parseViewMode(value: JsonInput): SessionViewMode {
+  if (!isJsonObject(value) || (value.mode !== 'admin' && value.mode !== 'member')) {
     throw new ViewModeValidationError();
   }
   return value.mode;
diff --git a/src/worker/routes/videos.ts b/src/worker/routes/videos.ts
index ef108c8..746612e 100644
--- a/src/worker/routes/videos.ts
+++ b/src/worker/routes/videos.ts
@@ -8,6 +8,12 @@ import type {
   PlaylistResponse,
   ProjectVideoResponse,
 } from '../../shared/videos';
+import {
+  isJsonNumber,
+  isJsonObject,
+  isJsonString,
+  type JsonInput,
+} from '../../shared/json';
 import type {WorkerEnv} from '../index';
 import {errorResponse, ServiceError} from '../services/errors';
 import {
@@ -227,14 +233,13 @@ projectVideoRoutes.delete('/:projectId/video', async (c) => {
   }
 });
 
-function parseUpload(value: unknown): DirectUploadRequest {
-  if (!value || typeof value !== 'object') invalid('Request body must be an object');
-  const input = value as Record<string, unknown>;
+function parseUpload(value: JsonInput): DirectUploadRequest {
+  if (!isJsonObject(value)) invalid('Request body must be an object');
   if (
-    typeof input.fileName !== 'string' ||
-    input.fileName.trim().length === 0 ||
-    input.fileName.trim().length > 255 ||
-    Array.from(input.fileName).some((character) => {
+    !isJsonString(value.fileName) ||
+    value.fileName.trim().length === 0 ||
+    value.fileName.trim().length > 255 ||
+    Array.from(value.fileName).some((character) => {
       const code = character.charCodeAt(0);
       return code <= 31 || code === 127;
     })
@@ -242,25 +247,25 @@ function parseUpload(value: unknown): DirectUploadRequest {
     invalid('File name is invalid');
   }
   if (
-    typeof input.fileSize !== 'number' ||
-    !Number.isSafeInteger(input.fileSize) ||
-    input.fileSize <= 0 ||
-    input.fileSize > MAX_VIDEO_BYTES
+    !isJsonNumber(value.fileSize) ||
+    !Number.isSafeInteger(value.fileSize) ||
+    value.fileSize <= 0 ||
+    value.fileSize > MAX_VIDEO_BYTES
   ) {
     invalid(`File size must be between 1 and ${MAX_VIDEO_BYTES} bytes`);
   }
-  const fileName = input.fileName.trim();
+  const fileName = value.fileName.trim();
   return {
     fileName,
-    fileSize: input.fileSize,
-    contentType: normalizeVideoContentType(input.contentType, fileName),
+    fileSize: value.fileSize,
+    contentType: normalizeVideoContentType(value.contentType, fileName),
   };
 }
 
-function normalizeVideoContentType(value: unknown, fileName: string) {
+function normalizeVideoContentType(value: JsonInput, fileName: string) {
   if (value === null) return null;
   if (
-    typeof value !== 'string' ||
+    !isJsonString(value) ||
     value.length > 255 ||
     Array.from(value).some((character) => {
       const code = character.charCodeAt(0);
@@ -277,26 +282,26 @@ function normalizeVideoContentType(value: unknown, fileName: string) {
   invalid('File must be a recognized video');
 }
 
-function parseCompletion(value: unknown): CompleteVideoUploadRequest {
-  if (!value || typeof value !== 'object') invalid('Request body must be an object');
-  const parts = (value as Record<string, unknown>).parts;
+function parseCompletion(value: JsonInput): CompleteVideoUploadRequest {
+  if (!isJsonObject(value)) invalid('Request body must be an object');
+  const {parts} = value;
   if (!Array.isArray(parts) || parts.length === 0 || parts.length > 10_000) {
     invalid('Completed parts are required');
   }
   const parsed = parts.map((part) => {
-    if (!part || typeof part !== 'object') invalid('Completed part is invalid');
-    const record = part as Record<string, unknown>;
+    if (!isJsonObject(part)) invalid('Completed part is invalid');
     if (
-      !Number.isInteger(record.partNumber) ||
-      (record.partNumber as number) < 1 ||
-      (record.partNumber as number) > 10_000 ||
-      typeof record.etag !== 'string' ||
-      !record.etag ||
-      record.etag.length > 256
+      !isJsonNumber(part.partNumber) ||
+      !Number.isInteger(part.partNumber) ||
+      part.partNumber < 1 ||
+      part.partNumber > 10_000 ||
+      !isJsonString(part.etag) ||
+      !part.etag ||
+      part.etag.length > 256
     ) {
       invalid('Completed part is invalid');
     }
-    return {partNumber: record.partNumber as number, etag: record.etag};
+    return {partNumber: part.partNumber, etag: part.etag};
   });
   parsed.sort((left, right) => left.partNumber - right.partNumber);
   if (new Set(parsed.map((part) => part.partNumber)).size !== parsed.length) {
@@ -305,9 +310,9 @@ function parseCompletion(value: unknown): CompleteVideoUploadRequest {
   return {parts: parsed};
 }
 
-function parseRetirement(value: unknown) {
-  if (!value || typeof value !== 'object') invalid('Request body must be an object');
-  return (value as Record<string, unknown>).confirmed === true;
+function parseRetirement(value: JsonInput) {
+  if (!isJsonObject(value)) invalid('Request body must be an object');
+  return value.confirmed === true;
 }
 
 function videoContentHeaders(content: {
@@ -355,7 +360,7 @@ function invalid(message: string): never {
   throw new ServiceError('VALIDATION_FAILED', message, 400);
 }
 
-function respondError(c: Context<WorkerEnv>, error: unknown) {
-  const result = errorResponse(error);
+function respondError(c: Context<WorkerEnv>, cause: unknown) {
+  const result = errorResponse(cause);
   return c.json(result.response, result.status);
 }
diff --git a/src/worker/services/administration-input.ts b/src/worker/services/administration-input.ts
index 985a59a..62cf74d 100644
--- a/src/worker/services/administration-input.ts
+++ b/src/worker/services/administration-input.ts
@@ -6,9 +6,16 @@ import type {
   VoteWriteRequest,
   YearWriteRequest,
 } from '../../shared/administration';
+import {
+  isJsonBoolean,
+  isJsonObject,
+  isJsonString,
+  type JsonInput,
+  type JsonObject,
+} from '../../shared/json';
 import {ServiceError} from './errors';
 
-export function parseVote(value: unknown): VoteWriteRequest {
+export function parseVote(value: JsonInput): VoteWriteRequest {
   const body = record(value);
   return {
     yearId: identifier(body.yearId, 'Year'),
@@ -17,28 +24,25 @@ export function parseVote(value: unknown): VoteWriteRequest {
   };
 }
 
-export function parseYear(value: unknown): YearWriteRequest {
+export function parseYear(value: JsonInput): YearWriteRequest {
   const body = record(value);
-  if (
-    typeof body.votingEnabled !== 'boolean' ||
-    typeof body.submissionsClosed !== 'boolean'
-  ) {
+  if (!isJsonBoolean(body.votingEnabled) || !isJsonBoolean(body.submissionsClosed)) {
     invalid('Year flags must be booleans');
   }
   return {
-    votingEnabled: body.votingEnabled as boolean,
-    submissionsClosed: body.submissionsClosed as boolean,
+    votingEnabled: body.votingEnabled,
+    submissionsClosed: body.submissionsClosed,
   };
 }
 
-export function parseNamed(value: unknown): NamedWriteRequest {
+export function parseNamed(value: JsonInput): NamedWriteRequest {
   const body = record(value);
-  const name = typeof body.name === 'string' ? body.name.trim() : '';
+  const name = isJsonString(body.name) ? body.name.trim() : '';
   if (!name || name.length > 120) invalid('Name must be between 1 and 120 characters');
   return {name};
 }
 
-export function parseAward(value: unknown): AwardWriteRequest {
+export function parseAward(value: JsonInput): AwardWriteRequest {
   const body = record(value);
   return {
     ...parseNamed(body),
@@ -47,7 +51,7 @@ export function parseAward(value: unknown): AwardWriteRequest {
   };
 }
 
-export function parseNominations(value: unknown): NominationsWriteRequest {
+export function parseNominations(value: JsonInput): NominationsWriteRequest {
   const body = record(value);
   if (!Array.isArray(body.categoryIds) || body.categoryIds.length > 2) {
     invalid('A project can have at most two nominations');
@@ -59,7 +63,7 @@ export function parseNominations(value: unknown): NominationsWriteRequest {
   return {categoryIds};
 }
 
-export function parseScreeningOrder(value: unknown): ScreeningOrderWriteRequest {
+export function parseScreeningOrder(value: JsonInput): ScreeningOrderWriteRequest {
   const body = record(value);
   if (!Array.isArray(body.projectIds)) invalid('Project order must be an array');
   const projectIds = body.projectIds.map((value) => identifier(value, 'Project'));
@@ -69,18 +73,18 @@ export function parseScreeningOrder(value: unknown): ScreeningOrderWriteRequest
   return {projectIds};
 }
 
-function record(value: unknown): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+function record(value: JsonInput): JsonObject {
+  if (!isJsonObject(value)) {
     invalid('Request body must be an object');
   }
-  return value as Record<string, unknown>;
+  return value;
 }
 
-function identifier(value: unknown, label: string) {
-  if (typeof value !== 'string' || !value.trim() || value.length > 128) {
+function identifier(value: JsonInput, label: string) {
+  if (!isJsonString(value) || !value.trim() || value.length > 128) {
     invalid(`${label} identifier is invalid`);
   }
-  return value as string;
+  return value;
 }
 
 function invalid(message: string): never {
diff --git a/src/worker/services/errors.ts b/src/worker/services/errors.ts
index 849e166..d12dab5 100644
--- a/src/worker/services/errors.ts
+++ b/src/worker/services/errors.ts
@@ -10,20 +10,20 @@ export class ServiceError extends Error {
   }
 }
 
-export function errorResponse(error: unknown) {
-  if (error instanceof ServiceError) {
+export function errorResponse(cause: unknown) {
+  if (cause instanceof ServiceError) {
     const response: ApiErrorResponse = {
-      error: {code: error.code, message: error.message},
+      error: {code: cause.code, message: cause.message},
     };
-    return {response, status: error.status} as const;
+    return {response, status: cause.status} as const;
   }
 
-  if (error instanceof SyntaxError) {
+  if (cause instanceof SyntaxError) {
     const response: ApiErrorResponse = {
       error: {code: 'VALIDATION_FAILED', message: 'Request body must be valid JSON'},
     };
     return {response, status: 400} as const;
   }
 
-  throw error;
+  throw cause;
 }
diff --git a/src/worker/services/project-input.ts b/src/worker/services/project-input.ts
index 7934e50..c6f402f 100644
--- a/src/worker/services/project-input.ts
+++ b/src/worker/services/project-input.ts
@@ -1,10 +1,16 @@
+import {
+  isJsonBoolean,
+  isJsonObject,
+  isJsonString,
+  type JsonInput,
+} from '../../shared/json';
 import type {GroupWriteRequest, ProjectWriteRequest} from '../../shared/projects';
 import {ServiceError} from './errors';
 
 const MAX_MEMBERS = 50;
 
-export function parseProjectWrite(value: unknown): ProjectWriteRequest {
-  if (!isObject(value)) {
+export function parseProjectWrite(value: JsonInput): ProjectWriteRequest {
+  if (!isJsonObject(value)) {
     invalid('Project must be a JSON object');
   }
 
@@ -51,15 +57,15 @@ export function parseProjectWrite(value: unknown): ProjectWriteRequest {
   };
 }
 
-export function parseGroupWrite(value: unknown): GroupWriteRequest {
-  if (!isObject(value)) {
+export function parseGroupWrite(value: JsonInput): GroupWriteRequest {
+  if (!isJsonObject(value)) {
     invalid('Group must be a JSON object');
   }
   return {name: requiredText(value.name, 'Group name', 100)};
 }
 
-function requiredText(value: unknown, label: string, max: number) {
-  if (typeof value !== 'string') {
+function requiredText(value: JsonInput, label: string, max: number) {
+  if (!isJsonString(value)) {
     invalid(`${label} is required`);
   }
   const result = value.trim();
@@ -69,34 +75,30 @@ function requiredText(value: unknown, label: string, max: number) {
   return result;
 }
 
-function optionalText(value: unknown, label: string, max: number) {
+function optionalText(value: JsonInput, label: string, max: number) {
   if (value === null || value === undefined || value === '') {
     return null;
   }
-  if (typeof value !== 'string' || value.trim().length > max) {
+  if (!isJsonString(value) || value.trim().length > max) {
     invalid(`${label} must be at most ${max} characters`);
   }
   return value.trim() || null;
 }
 
-function optionalId(value: unknown, label: string) {
+function optionalId(value: JsonInput, label: string) {
   if (value === null || value === undefined || value === '') {
     return null;
   }
   return requiredText(value, label, 128);
 }
 
-function booleanValue(value: unknown, label: string) {
-  if (typeof value !== 'boolean') {
+function booleanValue(value: JsonInput, label: string) {
+  if (!isJsonBoolean(value)) {
     invalid(`${label} must be a boolean`);
   }
   return value;
 }
 
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
 function invalid(message: string): never {
   throw new ServiceError('VALIDATION_FAILED', message, 400);
 }
diff --git a/src/worker/services/videos.ts b/src/worker/services/videos.ts
index d5933a6..9aa8cb7 100644
--- a/src/worker/services/videos.ts
+++ b/src/worker/services/videos.ts
@@ -27,7 +27,7 @@ interface VideoRow {
   original_name: string;
   content_type: string | null;
   size_bytes: number;
-  status: string;
+  status: ProjectVideo['status'];
   processing_attempt: number;
   processed_r2_key: string | null;
   duration_seconds: number | null;
@@ -891,8 +891,8 @@ function uploadCleanupUnavailable() {
   );
 }
 
-function isMissingMultipartUpload(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
+function isMissingMultipartUpload(cause: unknown) {
+  const message = cause instanceof Error ? cause.message : String(cause);
   return (
     message.includes('(10024)') ||
     message.includes('The specified multipart upload does not exist')
@@ -971,7 +971,7 @@ function mapVideo(row: VideoRow): ProjectVideo {
   return {
     id: row.id,
     projectId: row.project_id,
-    status: row.status as ProjectVideo['status'],
+    status: row.status,
     originalName: row.original_name,
     contentType: row.content_type,
     sizeBytes: row.size_bytes,
@@ -1062,8 +1062,8 @@ function isExpired(upload: UploadRow, now: Date) {
   );
 }
 
-function isVideoSlotConflict(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
+function isVideoSlotConflict(cause: unknown) {
+  const message = cause instanceof Error ? cause.message : String(cause);
   return (
     message.includes('video_uploads_active_project_idx') ||
     message.includes('active project video exists') ||
diff --git a/src/worker/workflows/video-processing.ts b/src/worker/workflows/video-processing.ts
index 3cc6e79..3e5923b 100644
--- a/src/worker/workflows/video-processing.ts
+++ b/src/worker/workflows/video-processing.ts
@@ -5,6 +5,13 @@ import {
   type WorkflowStep,
 } from 'cloudflare:workers';
 
+import {
+  isJsonNumber,
+  isJsonObject,
+  isJsonString,
+  type JsonInput,
+  type JsonObject,
+} from '../../shared/json';
 import {VideoProcessorContainer} from '../containers/video-processor';
 import {
   claimVideoProcessingAttempt,
@@ -200,49 +207,63 @@ function processingConcurrency(value: string) {
   return concurrency;
 }
 
-function parseProcessorResult(value: unknown): VideoProcessorResult {
-  if (!value || typeof value !== 'object') throw invalidProcessorResult();
-  const result = value as Record<string, unknown>;
-  const loudness = result.loudnessLufs;
+function parseProcessorResult(value: JsonInput): VideoProcessorResult {
+  if (!isJsonObject(value)) throw invalidProcessorResult();
+  const loudness = value.loudnessLufs;
   if (
-    !finitePositive(result.durationSeconds) ||
-    (result.durationSeconds as number) > VIDEO_PROCESSOR_MAX_DURATION_SECONDS + 0.05 ||
-    !integerBetween(result.width, 1, 1920) ||
-    !integerBetween(result.height, 1, 1080) ||
-    result.videoCodec !== 'h264' ||
-    result.audioCodec !== 'aac' ||
-    result.pixelFormat !== 'yuv420p' ||
-    result.fastStart !== true ||
-    result.loudnessTargetLufs !== VIDEO_PROCESSOR_TARGET_LUFS ||
-    result.loudnessToleranceLu !== VIDEO_PROCESSOR_LOUDNESS_TOLERANCE_LU ||
-    !['normalized', 'generated-silence'].includes(String(result.audioMode)) ||
-    typeof result.sha256 !== 'string' ||
-    !/^[a-f0-9]{64}$/.test(result.sha256) ||
-    (loudness !== null && typeof loudness !== 'number')
+    !finitePositive(value.durationSeconds) ||
+    value.durationSeconds > VIDEO_PROCESSOR_MAX_DURATION_SECONDS + 0.05 ||
+    !integerBetween(value.width, 1, 1920) ||
+    !integerBetween(value.height, 1, 1080) ||
+    value.videoCodec !== 'h264' ||
+    value.audioCodec !== 'aac' ||
+    value.pixelFormat !== 'yuv420p' ||
+    value.fastStart !== true ||
+    value.loudnessTargetLufs !== VIDEO_PROCESSOR_TARGET_LUFS ||
+    value.loudnessToleranceLu !== VIDEO_PROCESSOR_LOUDNESS_TOLERANCE_LU ||
+    (value.audioMode !== 'normalized' && value.audioMode !== 'generated-silence') ||
+    !isJsonString(value.sha256) ||
+    !/^[a-f0-9]{64}$/.test(value.sha256) ||
+    (loudness !== null && !isJsonNumber(loudness))
   ) {
     throw invalidProcessorResult();
   }
   if (
-    result.audioMode === 'normalized' &&
-    (typeof loudness !== 'number' ||
+    value.audioMode === 'normalized' &&
+    (!isJsonNumber(loudness) ||
       !Number.isFinite(loudness) ||
       Math.abs(loudness - VIDEO_PROCESSOR_TARGET_LUFS) >
         VIDEO_PROCESSOR_LOUDNESS_TOLERANCE_LU)
   ) {
     throw invalidProcessorResult();
   }
-  return result as unknown as VideoProcessorResult;
+  return {
+    durationSeconds: value.durationSeconds,
+    width: value.width,
+    height: value.height,
+    videoCodec: value.videoCodec,
+    audioCodec: value.audioCodec,
+    pixelFormat: value.pixelFormat,
+    loudnessLufs: loudness,
+    loudnessTargetLufs: value.loudnessTargetLufs,
+    loudnessToleranceLu: value.loudnessToleranceLu,
+    audioMode: value.audioMode,
+    fastStart: value.fastStart,
+    sha256: value.sha256,
+  };
 }
 
-function finitePositive(value: unknown): value is number {
-  return typeof value === 'number' && Number.isFinite(value) && value > 0;
+function finitePositive(value: JsonInput): value is number {
+  return isJsonNumber(value) && Number.isFinite(value) && value > 0;
 }
 
-function integerBetween(value: unknown, minimum: number, maximum: number) {
+function integerBetween(
+  value: JsonInput,
+  minimum: number,
+  maximum: number,
+): value is number {
   return (
-    Number.isInteger(value) &&
-    (value as number) >= minimum &&
-    (value as number) <= maximum
+    isJsonNumber(value) && Number.isInteger(value) && value >= minimum && value <= maximum
   );
 }
 
@@ -250,14 +271,10 @@ function invalidProcessorResult() {
   return new Error('FFmpeg processor returned invalid canonical metadata');
 }
 
-function errorMessage(error: unknown) {
-  return (error instanceof Error ? error.message : String(error)).slice(0, 500);
+function errorMessage(cause: unknown) {
+  return (cause instanceof Error ? cause.message : String(cause)).slice(0, 500);
 }
 
-function logVideoProcessing(
-  level: 'info' | 'error',
-  event: string,
-  fields: Record<string, unknown>,
-) {
+function logVideoProcessing(level: 'info' | 'error', event: string, fields: JsonObject) {
   console[level](JSON.stringify({component: 'video-processing', event, ...fields}));
 }
diff --git a/test/admin/admin.test.ts b/test/admin/admin.test.ts
index eb0e1b3..5adbe26 100644
--- a/test/admin/admin.test.ts
+++ b/test/admin/admin.test.ts
@@ -205,7 +205,8 @@ async function createCategory(name: string) {
     body: {name},
   });
   expect(response.status).toBe(201);
-  return response.body.category as {id: string};
+  const category: {id: string} = response.body.category;
+  return category;
 }
 
 async function tokenAndSession(kind: 'admin' | 'member') {
@@ -228,15 +229,14 @@ async function api(
   token: string,
   options: {method?: string; body?: unknown} = {},
 ) {
+  const headers = new Headers({Cookie: token});
+  if (options.method && options.method !== 'GET') {
+    headers.set('Origin', 'https://hackweek.test');
+  }
+  if (options.body !== undefined) headers.set('Content-Type', 'application/json');
   const response = await SELF.fetch(`${base}${path}`, {
     method: options.method,
-    headers: {
-      Cookie: token,
-      ...(options.method && options.method !== 'GET'
-        ? {Origin: 'https://hackweek.test'}
-        : {}),
-      ...(options.body === undefined ? {} : {'Content-Type': 'application/json'}),
-    },
+    headers,
     body: options.body === undefined ? undefined : JSON.stringify(options.body),
   });
   return {
diff --git a/test/app/ProjectForm.test.tsx b/test/app/ProjectForm.test.tsx
index fcda9cc..b516bce 100644
--- a/test/app/ProjectForm.test.tsx
+++ b/test/app/ProjectForm.test.tsx
@@ -58,7 +58,9 @@ describe('ProjectForm team picker', () => {
     await userEvent.type(search, 'alice');
     await userEvent.click(screen.getByRole('option', {name: /Alice Example/}));
 
-    expect((search as HTMLInputElement).value).toBe('');
+    expect(search).toBeInstanceOf(HTMLInputElement);
+    if (!(search instanceof HTMLInputElement)) throw new Error();
+    expect(search.value).toBe('');
     expect(screen.queryByRole('listbox')).toBeNull();
     expect(
       within(screen.getByRole('list', {name: 'Selected team members'})).getByText(
@@ -106,7 +108,9 @@ describe('ProjectForm team picker', () => {
 
     await userEvent.keyboard('{ArrowDown}{Enter}');
     expect(screen.getByText('Bob Builder')).toBeTruthy();
-    expect((search as HTMLInputElement).value).toBe('');
+    expect(search).toBeInstanceOf(HTMLInputElement);
+    if (!(search instanceof HTMLInputElement)) throw new Error();
+    expect(search.value).toBe('');
   });
 
   it('selects the first result instead of submitting on Enter', async () => {
@@ -153,7 +157,7 @@ function renderProjectForm({
   );
 }
 
-function json(value: unknown) {
+function json<T>(value: T) {
   return new Response(JSON.stringify(value), {
     status: 200,
     headers: {'Content-Type': 'application/json'},
diff --git a/test/app/administration.test.tsx b/test/app/administration.test.tsx
index 2f5e7d2..213430e 100644
--- a/test/app/administration.test.tsx
+++ b/test/app/administration.test.tsx
@@ -62,8 +62,7 @@ describe('voting and administration journeys', () => {
 
   it('renders admin controls and sends year/category changes to aggregate APIs', async () => {
     fetchMock.mockImplementation(async (input, init) => {
-      const url =
-        typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+      const url = input instanceof Request ? input.url : input.toString();
       if (init?.method === 'PUT' && url.includes('/admin/years/2026'))
         return json({year: adminFixture.year});
       if (init?.method === 'POST')
@@ -104,14 +103,16 @@ describe('voting and administration journeys', () => {
     renderRoute(<AdminPage />, '/admin/years/2025', '/admin/years/:yearId');
 
     expect(await screen.findByText(/This year is archived/)).toBeTruthy();
-    expect(
-      (screen.getByRole('checkbox', {name: 'Submissions closed'}) as HTMLInputElement)
-        .disabled,
-    ).toBe(true);
-    expect(
-      (screen.getByRole('checkbox', {name: 'Voting enabled'}) as HTMLInputElement)
-        .disabled,
-    ).toBe(true);
+    const submissionsClosed = screen.getByRole('checkbox', {
+      name: 'Submissions closed',
+    });
+    const votingEnabled = screen.getByRole('checkbox', {name: 'Voting enabled'});
+    expect(submissionsClosed).toBeInstanceOf(HTMLInputElement);
+    expect(votingEnabled).toBeInstanceOf(HTMLInputElement);
+    if (!(submissionsClosed instanceof HTMLInputElement)) throw new Error();
+    if (!(votingEnabled instanceof HTMLInputElement)) throw new Error();
+    expect(submissionsClosed.disabled).toBe(true);
+    expect(votingEnabled.disabled).toBe(true);
   });
 
   it('renders D1 aggregate analytics without raw vote identities', async () => {
@@ -161,7 +162,7 @@ function renderRoute(element: ReactNode, path: string, pattern: string) {
   );
 }
 
-function json(value: unknown, status = 200) {
+function json<T>(value: T, status = 200) {
   return new Response(JSON.stringify(value), {
     status,
     headers: {'Content-Type': 'application/json'},
diff --git a/test/app/routes.test.tsx b/test/app/routes.test.tsx
index 9e2e9a4..8e8480e 100644
--- a/test/app/routes.test.tsx
+++ b/test/app/routes.test.tsx
@@ -167,8 +167,7 @@ describe('clickable project routes', () => {
   it('reveals the screening reel to admins or after submissions close', async () => {
     let submissionsClosed = false;
     fetchMock.mockImplementation(async (input) => {
-      const url =
-        typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+      const url = input instanceof Request ? input.url : input.toString();
       if (url.includes('/api/years/2026')) {
         return json({
           year: {
@@ -211,8 +210,7 @@ describe('clickable project routes', () => {
 
   it('defaults to the grid view when storage is unavailable', async () => {
     fetchMock.mockImplementation(async (input) => {
-      const url =
-        typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+      const url = input instanceof Request ? input.url : input.toString();
       if (url.includes('/api/years/2026')) {
         return json({
           year: {
@@ -290,8 +288,7 @@ describe('clickable project routes', () => {
 
   it('switches to compact list rows and restores the stored preference', async () => {
     fetchMock.mockImplementation(async (input) => {
-      const url =
-        typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+      const url = input instanceof Request ? input.url : input.toString();
       if (url.includes('/api/years/2026')) {
         return json({
           year: {
@@ -328,11 +325,12 @@ describe('clickable project routes', () => {
       .closest('.projectRow');
     expect(list.className).toBe('projectList');
     expect(row).toBeTruthy();
-    expect(within(row as HTMLElement).getByText('Orbital')).toBeTruthy();
-    expect(within(row as HTMLElement).getByText('looking for help')).toBeTruthy();
-    expect(within(row as HTMLElement).getByLabelText('Member One')).toBeTruthy();
-    expect(within(row as HTMLElement).queryByText('2 attachments')).toBeNull();
-    expect(within(row as HTMLElement).queryByText(projectFixture.summary)).toBeNull();
+    if (!(row instanceof HTMLElement)) throw new Error();
+    expect(within(row).getByText('Orbital')).toBeTruthy();
+    expect(within(row).getByText('looking for help')).toBeTruthy();
+    expect(within(row).getByLabelText('Member One')).toBeTruthy();
+    expect(within(row).queryByText('2 attachments')).toBeNull();
+    expect(within(row).queryByText(projectFixture.summary)).toBeNull();
     expect(window.localStorage.getItem('hackweek.projectsView')).toBe('list');
 
     firstRender.unmount();
@@ -353,8 +351,7 @@ describe('clickable project routes', () => {
       resolveSearch = resolve;
     });
     fetchMock.mockImplementation(async (input) => {
-      const url =
-        typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+      const url = input instanceof Request ? input.url : input.toString();
       if (url.includes('/api/years/2026')) {
         return json({
           year: {
@@ -430,11 +427,7 @@ describe('clickable project routes', () => {
     await waitFor(() => {
       const lastInput = fetchMock.mock.calls.at(-1)?.[0];
       const lastUrl =
-        typeof lastInput === 'string'
-          ? lastInput
-          : lastInput instanceof URL
-            ? lastInput.href
-            : lastInput?.url;
+        lastInput instanceof Request ? lastInput.url : lastInput?.toString();
       expect(lastUrl).not.toContain('q=');
     });
   });
@@ -478,7 +471,10 @@ describe('clickable project routes', () => {
     expect(screen.getByRole('link', {name: 'details'}).getAttribute('target')).toBeNull();
     expect(rendered.container.querySelector('.markdown br')).toBeTruthy();
     expect(screen.getByText('Use <Widget> safely.')).toBeTruthy();
-    expect((screen.getByRole('checkbox') as HTMLInputElement).checked).toBe(true);
+    const checkbox = screen.getByRole('checkbox');
+    expect(checkbox).toBeInstanceOf(HTMLInputElement);
+    if (!(checkbox instanceof HTMLInputElement)) throw new Error();
+    expect(checkbox.checked).toBe(true);
   });
 
   it('sanitizes unsafe Markdown URLs and raw HTML', async () => {
@@ -581,7 +577,7 @@ function renderRoute(element: ReactNode, path: string, pattern = path) {
   );
 }
 
-function json(value: unknown, status = 200) {
+function json<T>(value: T, status = 200) {
   return new Response(JSON.stringify(value), {
     status,
     headers: {'Content-Type': 'application/json'},
diff --git a/test/auth/auth.test.ts b/test/auth/auth.test.ts
index 39ff83a..b2c6cbb 100644
--- a/test/auth/auth.test.ts
+++ b/test/auth/auth.test.ts
@@ -77,7 +77,8 @@ describe('Google OAuth authorization code flow', () => {
     const idToken = await signGoogleIdToken({nonce});
     tokenFetch.mockImplementation(async (_input, init) => {
       expect(init?.body).toBeInstanceOf(URLSearchParams);
-      const body = init?.body as URLSearchParams;
+      if (!(init?.body instanceof URLSearchParams)) throw new Error();
+      const body = init.body;
       expect(body.get('code')).toBe('one-time-code');
       expect(body.get('client_secret')).toBe(googleAuthBindings.GOOGLE_CLIENT_SECRET);
       expect(body.get('code_verifier')).toHaveLength(86);
diff --git a/test/auth/fixture.ts b/test/auth/fixture.ts
index 68b9667..b44c3f3 100644
--- a/test/auth/fixture.ts
+++ b/test/auth/fixture.ts
@@ -1,6 +1,7 @@
 import {env} from 'cloudflare:test';
 import {importJWK, SignJWT, type JWTPayload} from 'jose';
 
+import {isJsonString} from '../../src/shared/json';
 import {SESSION_COOKIE_NAME} from '../../src/worker/middleware/auth';
 import {createSession} from '../../src/worker/services/sessions';
 import {synchronizeGoogleUser} from '../../src/worker/services/users';
@@ -32,13 +33,12 @@ const privateJwk = {
 };
 
 export async function createSessionCookie(overrides: JWTPayload = {}) {
-  const subject = typeof overrides.sub === 'string' ? overrides.sub : 'google-member';
-  const email =
-    typeof overrides.email === 'string' ? overrides.email : 'member@sentry.io';
+  const subject = isJsonString(overrides.sub) ? overrides.sub : 'google-member';
+  const email = isJsonString(overrides.email) ? overrides.email : 'member@sentry.io';
   const user = await synchronizeGoogleUser(env.DB, {
     subject,
     email: email.toLowerCase(),
-    displayName: typeof overrides.name === 'string' ? overrides.name : 'Hackweek Member',
+    displayName: isJsonString(overrides.name) ? overrides.name : 'Hackweek Member',
     avatarUrl: null,
   });
   const session = await createSession(env.DB, user.id);
diff --git a/test/e2e/readiness-fixture.ts b/test/e2e/readiness-fixture.ts
index 19d2dfb..574eead 100644
--- a/test/e2e/readiness-fixture.ts
+++ b/test/e2e/readiness-fixture.ts
@@ -11,7 +11,7 @@ const fixtureRoot = path.resolve('test/fixtures/firebase');
 export async function parseLocalReadinessFixture() {
   const source = JSON.parse(
     await readFile(path.join(fixtureRoot, 'database.json'), 'utf8'),
-  ) as unknown;
+  );
   const manifest = await readStorageManifest(
     path.join(fixtureRoot, 'storage-manifest.json'),
   );
diff --git a/test/migration/migration.test.ts b/test/migration/migration.test.ts
index a9d6db9..1ace03c 100644
--- a/test/migration/migration.test.ts
+++ b/test/migration/migration.test.ts
@@ -20,7 +20,7 @@ import {
 const fixtureRoot = path.resolve('test/fixtures/firebase');
 
 async function fixture(name: string) {
-  return JSON.parse(await readFile(path.join(fixtureRoot, name), 'utf8')) as unknown;
+  return JSON.parse(await readFile(path.join(fixtureRoot, name), 'utf8'));
 }
 
 describe('Firebase migration transformation', () => {
@@ -235,19 +235,17 @@ describe('Firebase migration transformation', () => {
 
   it('accepts legacy empty collections and awards without custom names', async () => {
     const database = await fixture('database.json');
-    const root = database as {
+    const root: {
       years: Record<
         string,
         {
           votes: unknown;
-          awards: Record<string, {name: string}> | string;
+          awards: Record<string, {name: string}>;
         }
       >;
-    };
+    } = database;
     root.years['2024'].votes = '';
-    const award = Object.values(
-      root.years['2024'].awards as Record<string, {name: string}>,
-    )[0];
+    const award = Object.values(root.years['2024'].awards)[0];
     award.name = '';
 
     const result = await transformFirebaseExport(root);
@@ -260,14 +258,14 @@ describe('Firebase migration transformation', () => {
 
   it('reports and omits legacy votes that conflict with current eligibility', async () => {
     const database = await fixture('database.json');
-    const root = database as {
+    const root: {
       years: Record<
         string,
         {
           votes: Record<string, {creator: string; project: string}>;
         }
       >;
-    };
+    } = database;
     const vote = Object.values(root.years['2024'].votes)[0];
     vote.creator = 'user-member';
     vote.project = 'project-history';
diff --git a/test/player/audio.test.tsx b/test/player/audio.test.tsx
index cf374ac..c0827e3 100644
--- a/test/player/audio.test.tsx
+++ b/test/player/audio.test.tsx
@@ -5,6 +5,7 @@ import {
   clampGainDb,
   createPlayerAudioGraph,
   gainDbToLinear,
+  type PlayerAudioContext,
 } from '../../src/app/player/audio';
 
 describe('screening audio graph', () => {
@@ -15,23 +16,26 @@ describe('screening audio graph', () => {
   });
 
   it('creates one context, per-element gains, and one shared limiter resumed by gesture', async () => {
-    const destination = {} as AudioDestinationNode;
-    const limiter = node() as unknown as DynamicsCompressorNode;
-    Object.assign(limiter, {
+    const destination: AudioDestinationNode = Object.create(null);
+    const limiter: DynamicsCompressorNode = Object.assign(Object.create(null), {
+      connect: vi.fn(),
       threshold: {value: 0},
       knee: {value: 0},
       ratio: {value: 0},
       attack: {value: 0},
       release: {value: 0},
     });
-    const gains = [gainNode(), gainNode()];
-    const sources = [node(), node()];
+    const gains: [GainNode, GainNode] = [gainNode(), gainNode()];
+    const sources: [MediaElementAudioSourceNode, MediaElementAudioSourceNode] = [
+      mediaSourceNode(),
+      mediaSourceNode(),
+    ];
     const resume = vi.fn(async () => undefined);
     const close = vi.fn(async () => undefined);
     let sourceIndex = 0;
     let gainIndex = 0;
-    const Context = vi.fn(function Context(this: Record<string, unknown>) {
-      Object.assign(this, {
+    const createContext = vi.fn(
+      (): PlayerAudioContext => ({
         state: 'suspended',
         destination,
         createDynamicsCompressor: () => limiter,
@@ -39,17 +43,17 @@ describe('screening audio graph', () => {
         createGain: () => gains[gainIndex++],
         resume,
         close,
-      });
-    }) as unknown as typeof AudioContext;
+      }),
+    );
 
     const graph = createPlayerAudioGraph(
       [document.createElement('video'), document.createElement('video')],
-      Context,
+      createContext,
     );
     graph.setGain(1, 6);
     await graph.resume();
 
-    expect(Context).toHaveBeenCalledTimes(1);
+    expect(createContext).toHaveBeenCalledTimes(1);
     expect(vi.mocked(sources[0].connect).mock.calls[0]?.[0]).toBe(gains[0]);
     expect(vi.mocked(sources[1].connect).mock.calls[0]?.[0]).toBe(gains[1]);
     expect(vi.mocked(gains[0].connect).mock.calls[0]?.[0]).toBe(limiter);
@@ -60,10 +64,13 @@ describe('screening audio graph', () => {
   });
 });
 
-function node() {
-  return {connect: vi.fn()};
+function mediaSourceNode(): MediaElementAudioSourceNode {
+  return Object.assign(Object.create(null), {connect: vi.fn()});
 }
 
-function gainNode() {
-  return {connect: vi.fn(), gain: {value: 1}} as unknown as GainNode;
+function gainNode(): GainNode {
+  return Object.assign(Object.create(null), {
+    connect: vi.fn(),
+    gain: {value: 1},
+  });
 }
diff --git a/test/projects/projects.test.ts b/test/projects/projects.test.ts
index dfed47a..813b40d 100644
--- a/test/projects/projects.test.ts
+++ b/test/projects/projects.test.ts
@@ -307,7 +307,8 @@ async function createProject(
     body: {...projectPayload(), ...overrides},
   });
   expect(response.status).toBe(201);
-  return response.body.project as {id: string};
+  const project: {id: string} = response.body.project;
+  return project;
 }
 
 function projectPayload(): ProjectWriteRequest {
@@ -335,15 +336,14 @@ async function api(
   token: string,
   options: {method?: string; body?: unknown} = {},
 ) {
+  const headers = new Headers({Cookie: token});
+  if (options.method && options.method !== 'GET') {
+    headers.set('Origin', 'https://hackweek.test');
+  }
+  if (options.body !== undefined) headers.set('Content-Type', 'application/json');
   const response = await SELF.fetch(`${base}${path}`, {
     method: options.method,
-    headers: {
-      Cookie: token,
-      ...(options.method && options.method !== 'GET'
-        ? {Origin: 'https://hackweek.test'}
-        : {}),
-      ...(options.body === undefined ? {} : {'Content-Type': 'application/json'}),
-    },
+    headers,
     body: options.body === undefined ? undefined : JSON.stringify(options.body),
   });
   const body = response.status === 204 ? null : await response.json<any>();
diff --git a/test/video-ui/video-ui.test.tsx b/test/video-ui/video-ui.test.tsx
index 663e810..bb0ee92 100644
--- a/test/video-ui/video-ui.test.tsx
+++ b/test/video-ui/video-ui.test.tsx
@@ -163,10 +163,10 @@ describe('video user experience', () => {
 
     await vi.waitFor(() => expect(snapshots.at(-1)?.phase).toBe('complete'));
     const firstRequest = fetchMock.mock.calls[0][0];
-    if (typeof firstRequest !== 'string')
-      throw new Error('Expected a string request URL');
-    expect(firstRequest).toContain('/parts/2');
-    expect(firstRequest).not.toContain('/parts/1');
+    const firstUrl =
+      firstRequest instanceof Request ? firstRequest.url : firstRequest.toString();
+    expect(firstUrl).toContain('/parts/2');
+    expect(firstUrl).not.toContain('/parts/1');
     expect(readResumeRecord('project', file)).toBeNull();
   });
 
@@ -229,7 +229,9 @@ describe('video user experience', () => {
         title="First project"
       />,
     );
-    const video = screen.getByLabelText('First project video') as HTMLVideoElement;
+    const video = screen.getByLabelText('First project video');
+    expect(video).toBeInstanceOf(HTMLVideoElement);
+    if (!(video instanceof HTMLVideoElement)) throw new Error();
     expect(video.getAttribute('src')).toBe('/api/videos/video-1/content');
     expect(video.preload).toBe('auto');
 
@@ -374,7 +376,7 @@ function client() {
   return new QueryClient({defaultOptions: {queries: {retry: false}}});
 }
 
-function json(value: unknown, status = 200) {
+function json<T>(value: T, status = 200) {
   return new Response(JSON.stringify(value), {
     status,
     headers: {'Content-Type': 'application/json'},
diff --git a/test/video/video.test.ts b/test/video/video.test.ts
index 2ff91dd..653a64d 100644
--- a/test/video/video.test.ts
+++ b/test/video/video.test.ts
@@ -94,7 +94,7 @@ describe('R2 multipart video lifecycle', () => {
       completedParts: [],
     });
 
-    const uploadId = created.body.upload.uploadId as string;
+    const uploadId = created.body.upload.uploadId;
     const firstPart = await putPart(
       projectId,
       uploadId,
@@ -185,7 +185,7 @@ describe('R2 multipart video lifecycle', () => {
 
   it('reaps an expired upload with lost resume state before creating a fresh upload', async () => {
     const stale = await createUpload(projectId, ownerToken, 11);
-    const staleUploadId = stale.body.upload.uploadId as string;
+    const staleUploadId = stale.body.upload.uploadId;
     expect(
       (
         await putPart(
@@ -219,9 +219,9 @@ describe('R2 multipart video lifecycle', () => {
 
   it('retries idempotent expiry cleanup without releasing after transient R2 failure', async () => {
     const stale = await createUpload(projectId, ownerToken, 10);
-    const staleUploadId = stale.body.upload.uploadId as string;
+    const staleUploadId = stale.body.upload.uploadId;
     await expireUpload(staleUploadId);
-    const failingBucket = {
+    const failingBucket: R2Bucket = Object.assign(Object.create(env.VIDEOS), {
       resumeMultipartUpload() {
         return {
           abort: async () => {
@@ -229,7 +229,7 @@ describe('R2 multipart video lifecycle', () => {
           },
         };
       },
-    } as unknown as R2Bucket;
+    });
 
     await expect(
       reapExpiredMultipartVideoUploads(env.DB, failingBucket, {projectId, limit: 1}),
@@ -249,7 +249,7 @@ describe('R2 multipart video lifecycle', () => {
 
   it('handles missing multipart state and simultaneous fresh creates idempotently', async () => {
     const stale = await createUpload(projectId, ownerToken, 10);
-    const staleUploadId = stale.body.upload.uploadId as string;
+    const staleUploadId = stale.body.upload.uploadId;
     const staleStorage = await uploadStorage(staleUploadId);
     await env.VIDEOS.resumeMultipartUpload(
       staleStorage.original_r2_key,
@@ -271,7 +271,7 @@ describe('R2 multipart video lifecycle', () => {
 
   it('fences an expired upload before an old completion can publish', async () => {
     const stale = await createUpload(projectId, ownerToken, 11);
-    const staleUploadId = stale.body.upload.uploadId as string;
+    const staleUploadId = stale.body.upload.uploadId;
     const part = await putPart(
       projectId,
       staleUploadId,
@@ -303,7 +303,7 @@ describe('R2 multipart video lifecycle', () => {
 
   it('leases an in-flight completion against a concurrent fresh create', async () => {
     const created = await createUpload(projectId, ownerToken, 11);
-    const uploadId = created.body.upload.uploadId as string;
+    const uploadId = created.body.upload.uploadId;
     const part = await putPart(
       projectId,
       uploadId,
@@ -330,7 +330,7 @@ describe('R2 multipart video lifecycle', () => {
       upload.original_r2_key,
       upload.r2_upload_id,
     );
-    const blockingBucket = {
+    const blockingBucket: R2Bucket = Object.assign(Object.create(env.VIDEOS), {
       head: env.VIDEOS.head.bind(env.VIDEOS),
       resumeMultipartUpload() {
         return {
@@ -341,7 +341,7 @@ describe('R2 multipart video lifecycle', () => {
           },
         };
       },
-    } as unknown as R2Bucket;
+    });
     const owner = {
       id: ownerId,
       email: `video-owner-${suffix}@sentry.io`,
@@ -496,7 +496,7 @@ describe('R2 multipart video lifecycle', () => {
       .run();
 
     const created = await createUpload(projectId, ownerToken, 10);
-    const uploadId = created.body.upload.uploadId as string;
+    const uploadId = created.body.upload.uploadId;
     const incomplete = await api(
       `/projects/${projectId}/video/upload/${uploadId}/complete`,
       ownerToken,
@@ -516,7 +516,7 @@ describe('R2 multipart video lifecycle', () => {
 
   it('allows aborting incomplete uploads idempotently but never completed objects', async () => {
     const created = await createUpload(projectId, ownerToken, 8);
-    const uploadId = created.body.upload.uploadId as string;
+    const uploadId = created.body.upload.uploadId;
     const first = await api(
       `/projects/${projectId}/video/upload/${uploadId}`,
       ownerToken,
@@ -820,9 +820,9 @@ async function publishReadyVideo(project: string, token: string, bytes: string)
 }
 
 function fetchVideoContent(videoId: string, token: string, range?: string) {
-  return SELF.fetch(`${base}/videos/${videoId}/content`, {
-    headers: {Cookie: token, ...(range ? {Range: range} : {})},
-  });
+  const headers = new Headers({Cookie: token});
+  if (range) headers.set('Range', range);
+  return SELF.fetch(`${base}/videos/${videoId}/content`, {headers});
 }
 
 async function responseText(response: Response) {
@@ -850,7 +850,7 @@ async function uploadStorage(uploadId: string) {
 async function completeSmallUpload(project: string, token: string, bytes: string) {
   const created = await createUpload(project, token, bytes.length);
   expect(created.status).toBe(201);
-  const uploadId = created.body.upload.uploadId as string;
+  const uploadId = created.body.upload.uploadId;
   const part = await putPart(
     project,
     uploadId,
@@ -892,6 +892,10 @@ async function putPart(
   body: Uint8Array,
   token: string,
 ) {
+  const payload =
+    body.buffer instanceof ArrayBuffer
+      ? body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)
+      : Uint8Array.from(body).buffer;
   const response = await SELF.fetch(
     `${base}/projects/${project}/video/upload/${uploadId}/parts/${partNumber}`,
     {
@@ -902,10 +906,7 @@ async function putPart(
         'Content-Type': 'application/octet-stream',
         'Content-Length': String(body.byteLength),
       },
-      body: body.buffer.slice(
-        body.byteOffset,
-        body.byteOffset + body.byteLength,
-      ) as ArrayBuffer,
+      body: payload,
     },
   );
   return parseResponse(response);
@@ -917,7 +918,7 @@ async function createProject(name: string) {
     body: projectPayload(name),
   });
   expect(response.status, JSON.stringify(response.body)).toBe(201);
-  return response.body.project.id as string;
+  return response.body.project.id;
 }
 
 function projectPayload(name: string): ProjectWriteRequest {
@@ -943,15 +944,14 @@ async function api(
   token: string,
   options: {method?: string; body?: unknown} = {},
 ) {
+  const headers = new Headers({Cookie: token});
+  if (options.method && options.method !== 'GET') {
+    headers.set('Origin', 'https://hackweek.test');
+  }
+  if (options.body !== undefined) headers.set('Content-Type', 'application/json');
   const response = await SELF.fetch(`${base}${path}`, {
     method: options.method,
-    headers: {
-      Cookie: token,
-      ...(options.method && options.method !== 'GET'
-        ? {Origin: 'https://hackweek.test'}
-        : {}),
-      ...(options.body === undefined ? {} : {'Content-Type': 'application/json'}),
-    },
+    headers,
     body: options.body === undefined ? undefined : JSON.stringify(options.body),
   });
   return parseResponse(response);
diff --git a/test/voting/voting.test.ts b/test/voting/voting.test.ts
index 25e5f80..66af722 100644
--- a/test/voting/voting.test.ts
+++ b/test/voting/voting.test.ts
@@ -261,15 +261,14 @@ async function api(
   token: string,
   options: {method?: string; body?: unknown} = {},
 ) {
+  const headers = new Headers({Cookie: token});
+  if (options.method && options.method !== 'GET') {
+    headers.set('Origin', 'https://hackweek.test');
+  }
+  if (options.body !== undefined) headers.set('Content-Type', 'application/json');
   const response = await SELF.fetch(`${base}${path}`, {
     method: options.method,
-    headers: {
-      Cookie: token,
-      ...(options.method && options.method !== 'GET'
-        ? {Origin: 'https://hackweek.test'}
-        : {}),
-      ...(options.body === undefined ? {} : {'Content-Type': 'application/json'}),
-    },
+    headers,
     body: options.body === undefined ? undefined : JSON.stringify(options.body),
   });
   return {
diff --git a/tools/oxlint/anti-slop/index.ts b/tools/oxlint/anti-slop/index.ts
new file mode 100644
index 0000000..2b4ae22
--- /dev/null
+++ b/tools/oxlint/anti-slop/index.ts
@@ -0,0 +1,41 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.ts";
+import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.ts";
+import { noKnownValueWideningRule } from "./rules/no-known-value-widening.ts";
+import { noModuleMockingRule } from "./rules/no-module-mocking.ts";
+import { noObjectParametersRule } from "./rules/no-object-parameters.ts";
+import { noReflectApplyRule } from "./rules/no-reflect-apply.ts";
+import { noReflectGetRule } from "./rules/no-reflect-get.ts";
+import { noRuntimeTypeofRule } from "./rules/no-runtime-typeof.ts";
+import { noForbiddenTermInSymbolNamesRule } from "./rules/no-shape-in-symbol-names.ts";
+import { noUnknownParametersRule } from "./rules/no-unknown-parameters.ts";
+import { noUnknownReturnsRule } from "./rules/no-unknown-returns.ts";
+import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.ts";
+import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.ts";
+import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.ts";
+import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.ts";
+
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+const antiSlopPlugin = eslintCompatPlugin({
+	meta: { name: "anti-slop" },
+	rules: {
+		"no-chained-type-assertions": noChainedTypeAssertionsRule,
+		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+		"no-known-value-widening": noKnownValueWideningRule,
+		"no-module-mocking": noModuleMockingRule,
+		"no-object-parameters": noObjectParametersRule,
+		"no-reflect-apply": noReflectApplyRule,
+		"no-reflect-get": noReflectGetRule,
+		"no-runtime-typeof": noRuntimeTypeofRule,
+		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
+		"no-unknown-parameters": noUnknownParametersRule,
+		"no-unknown-returns": noUnknownReturnsRule,
+		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"no-widen-then-assert": noWidenThenAssertRule,
+		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
+	},
+});
+
+export default antiSlopPlugin;
diff --git a/tools/oxlint/anti-slop/rules/no-chained-type-assertions.ts b/tools/oxlint/anti-slop/rules/no-chained-type-assertions.ts
new file mode 100644
index 0000000..0d11852
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-chained-type-assertions.ts
@@ -0,0 +1,77 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+type TypeAssertionExpression = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
+
+function isTypeAssertionExpression(node: ESTree.Node): node is TypeAssertionExpression {
+  return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+
+function unwrapParenthesizedExpression(expression: ESTree.Expression): ESTree.Expression {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+
+function isConstAssertion(node: TypeAssertionExpression): boolean {
+  const { typeAnnotation } = node;
+  return (
+    typeAnnotation.type === "TSTypeReference" &&
+    typeAnnotation.typeName.type === "Identifier" &&
+    typeAnnotation.typeName.name === "const"
+  );
+}
+
+function isOutermostAssertionInChain(node: TypeAssertionExpression): boolean {
+  let current: ESTree.Expression = node;
+  let parent = node.parent;
+
+  while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
+    current = parent;
+    parent = parent.parent;
+  }
+
+  return !isTypeAssertionExpression(parent) || parent.expression !== current;
+}
+
+function isForbiddenAssertionChain(node: TypeAssertionExpression): boolean {
+  let assertionCount = 0;
+  let hasNonConstAssertion = false;
+  let current: ESTree.Expression = node;
+
+  while (isTypeAssertionExpression(current)) {
+    assertionCount += 1;
+    hasNonConstAssertion ||= !isConstAssertion(current);
+    current = unwrapParenthesizedExpression(current.expression);
+  }
+
+  return assertionCount > 1 && hasNonConstAssertion;
+}
+
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+export const noChainedTypeAssertionsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains.",
+    },
+    messages: {
+      chained:
+        "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it.",
+    },
+  },
+  createOnce(context) {
+    const checkTypeAssertion = (node: TypeAssertionExpression) => {
+      if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node)) return;
+      context.report({ node, messageId: "chained" });
+    };
+
+    return {
+      TSAsExpression: checkTypeAssertion,
+      TSTypeAssertion: checkTypeAssertion,
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/no-conditional-empty-object-spread.ts b/tools/oxlint/anti-slop/rules/no-conditional-empty-object-spread.ts
new file mode 100644
index 0000000..ae7248d
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-conditional-empty-object-spread.ts
@@ -0,0 +1,49 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+function unwrapParentheses(node: ESTree.Expression): ESTree.Expression {
+  let current = node;
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+
+function isEmptyObjectExpression(node: ESTree.Expression): boolean {
+  return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+
+function isConditionalEmptyObjectSpread(node: ESTree.Expression): boolean {
+  const conditional = unwrapParentheses(node);
+  return (
+    conditional.type === "ConditionalExpression" &&
+    (isEmptyObjectExpression(conditional.consequent) ||
+      isEmptyObjectExpression(conditional.alternate))
+  );
+}
+
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+export const noConditionalEmptyObjectSpreadRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Disallow object spreads that conditionally spread an empty object to omit fields.",
+    },
+    messages: {
+      avoid:
+        "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present.",
+    },
+  },
+  createOnce(context) {
+    return {
+      SpreadElement(node) {
+        if (node.parent.type !== "ObjectExpression") return;
+
+        if (isConditionalEmptyObjectSpread(node.argument)) {
+          context.report({ node, messageId: "avoid" });
+        }
+      },
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/no-known-value-widening.ts b/tools/oxlint/anti-slop/rules/no-known-value-widening.ts
new file mode 100644
index 0000000..2a6806c
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-known-value-widening.ts
@@ -0,0 +1,247 @@
+import { defineRule } from "@oxlint/plugins";
+
+import {
+	classifyWideningTarget,
+	createTypeEnvironment,
+	isKnownEvidenceExpression,
+	type TypeEnvironment,
+	type WideningTarget,
+} from "../shared/dictionary-types.ts";
+
+import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
+
+type FunctionExpression = ESTree.ArrowFunctionExpression | ESTree.Function;
+
+function unwrapExpression(expression: ESTree.Expression): ESTree.Expression {
+	let current = expression;
+	while (
+		current.type === "ParenthesizedExpression" ||
+		current.type === "TSAsExpression" ||
+		current.type === "TSSatisfiesExpression" ||
+		current.type === "TSTypeAssertion" ||
+		current.type === "TSNonNullExpression"
+	) {
+		current = current.expression;
+	}
+	return current;
+}
+
+function resolveVariable(
+	sourceCode: SourceCode,
+	identifier: ESTree.IdentifierReference,
+): Variable | null {
+	let scope: Scope | null = sourceCode.getScope(identifier);
+	while (scope !== null) {
+		const variable = scope.set.get(identifier.name);
+		if (variable !== undefined) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+
+function variableDeclarator(variable: Variable): ESTree.VariableDeclarator | null {
+	if (variable.defs.length !== 1) return null;
+	const [definition] = variable.defs;
+	return definition?.type === "Variable" && definition.node.type === "VariableDeclarator"
+		? definition.node
+		: null;
+}
+
+function isStableConstVariable(variable: Variable, declarator: ESTree.VariableDeclarator): boolean {
+	return (
+		declarator.parent.type === "VariableDeclaration" &&
+		declarator.parent.kind === "const" &&
+		variable.references.every((reference) => reference.init || !reference.isWrite())
+	);
+}
+
+function hasKnownEvidence(
+	sourceCode: SourceCode,
+	expression: ESTree.Expression,
+	visitedVariables = new Set<Variable>(),
+): boolean {
+	if (isKnownEvidenceExpression(expression)) return true;
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type !== "Identifier") return false;
+	const variable = resolveVariable(sourceCode, unwrapped);
+	if (variable === null || visitedVariables.has(variable)) return false;
+	const declarator = variableDeclarator(variable);
+	if (
+		declarator === null ||
+		declarator.init === null ||
+		!isStableConstVariable(variable, declarator)
+	) {
+		return false;
+	}
+	visitedVariables.add(variable);
+	return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
+}
+
+function annotationTarget(
+	annotation: ESTree.TSTypeAnnotation | null | undefined,
+	environment: TypeEnvironment,
+): WideningTarget | null {
+	return annotation === null || annotation === undefined
+		? null
+		: classifyWideningTarget(annotation.typeAnnotation, environment);
+}
+
+function enclosingFunction(node: ESTree.Node): FunctionExpression | null {
+	let current: ESTree.Node | null = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (
+			current.type === "ArrowFunctionExpression" ||
+			current.type === "FunctionDeclaration" ||
+			current.type === "FunctionExpression"
+		) {
+			return current;
+		}
+		current = current.parent;
+	}
+	return null;
+}
+
+function sourceKeyName(sourceCode: SourceCode, key: ESTree.PropertyKey): string {
+	if (key.type === "Identifier" || key.type === "PrivateIdentifier") return key.name;
+	if (key.type === "Literal") return String(key.value);
+	return sourceCode.getText(key);
+}
+
+function functionName(sourceCode: SourceCode, owner: FunctionExpression | null): string {
+	if (owner === null) return "anonymous function";
+	if (owner.id !== null) return owner.id.name;
+	const parent = owner.parent;
+	if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier")
+		return parent.id.name;
+	if (parent.type === "MethodDefinition") return sourceKeyName(sourceCode, parent.key);
+	return "anonymous function";
+}
+
+function isEmptyObjectExpression(expression: ESTree.Expression): boolean {
+	const unwrapped = unwrapExpression(expression);
+	return unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0;
+}
+
+function isDictionaryAccumulatorTarget(destination: WideningTarget): boolean {
+	return destination.kind === "open dictionary" || destination.kind === "generic container";
+}
+
+function hasParentAssertion(node: ESTree.Node): boolean {
+	return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
+}
+
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+export const noKnownValueWideningRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence.",
+		},
+		messages: {
+			widening:
+				"The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract.",
+		},
+	},
+	createOnce(context) {
+		let environment: TypeEnvironment | null = null;
+
+		const reportFlow = (
+			expression: ESTree.Expression,
+			destination: WideningTarget | null,
+			subject: string,
+		) => {
+			if (destination === null) return;
+			if (
+				isDictionaryAccumulatorTarget(destination) &&
+				isEmptyObjectExpression(expression)
+			) {
+				return;
+			}
+			if (!hasKnownEvidence(context.sourceCode, expression)) return;
+			context.report({
+				node: expression,
+				messageId: "widening",
+				data: { subject, target: destination.kind },
+			});
+		};
+
+		const targetFromAnnotation = (annotation: ESTree.TSTypeAnnotation | null | undefined) =>
+			environment === null ? null : annotationTarget(annotation, environment);
+
+		return {
+			Program(node) {
+				environment = createTypeEnvironment(node);
+			},
+			VariableDeclarator(node) {
+				if (node.init === null || node.id.type !== "Identifier") return;
+				reportFlow(
+					node.init,
+					targetFromAnnotation(node.id.typeAnnotation),
+					`binding \`${node.id.name}\``,
+				);
+			},
+			PropertyDefinition(node) {
+				if (node.value === null) return;
+				reportFlow(
+					node.value,
+					targetFromAnnotation(node.typeAnnotation),
+					`property \`${sourceKeyName(context.sourceCode, node.key)}\``,
+				);
+			},
+			AccessorProperty(node) {
+				if (node.value === null) return;
+				reportFlow(
+					node.value,
+					targetFromAnnotation(node.typeAnnotation),
+					`property \`${sourceKeyName(context.sourceCode, node.key)}\``,
+				);
+			},
+			AssignmentExpression(node) {
+				if (node.operator !== "=" || node.left.type !== "Identifier") return;
+				const variable = resolveVariable(context.sourceCode, node.left);
+				if (variable === null) return;
+				const declarator = variableDeclarator(variable);
+				if (declarator === null || declarator.id.type !== "Identifier") return;
+				reportFlow(
+					node.right,
+					targetFromAnnotation(declarator.id.typeAnnotation),
+					`binding \`${declarator.id.name}\``,
+				);
+			},
+			ReturnStatement(node) {
+				if (node.argument === null) return;
+				const owner = enclosingFunction(node);
+				reportFlow(
+					node.argument,
+					targetFromAnnotation(owner?.returnType),
+					`return value of \`${functionName(context.sourceCode, owner)}\``,
+				);
+			},
+			ArrowFunctionExpression(node) {
+				if (node.body.type === "BlockStatement") return;
+				reportFlow(
+					node.body,
+					targetFromAnnotation(node.returnType),
+					`return value of \`${functionName(context.sourceCode, node)}\``,
+				);
+			},
+			TSAsExpression(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow(
+					node.expression,
+					classifyWideningTarget(node.typeAnnotation, environment),
+					"assertion",
+				);
+			},
+			TSTypeAssertion(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow(
+					node.expression,
+					classifyWideningTarget(node.typeAnnotation, environment),
+					"assertion",
+				);
+			},
+		};
+	},
+});
diff --git a/tools/oxlint/anti-slop/rules/no-module-mocking.ts b/tools/oxlint/anti-slop/rules/no-module-mocking.ts
new file mode 100644
index 0000000..d6fb5b4
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-module-mocking.ts
@@ -0,0 +1,91 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
+
+const moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
+
+function resolveVariable(
+  sourceCode: SourceCode,
+  identifier: ESTree.IdentifierReference,
+): Variable | null {
+  let scope: Scope | null = sourceCode.getScope(identifier);
+  while (scope !== null) {
+    const variable = scope.set.get(identifier.name);
+    if (variable !== undefined) return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+
+function importedName(node: ESTree.Node): string | null {
+  if (node.type !== "ImportSpecifier") return null;
+  return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+
+function isTestFrameworkObject(
+  sourceCode: SourceCode,
+  expression: ESTree.Expression,
+): expression is ESTree.IdentifierReference {
+  if (expression.type !== "Identifier") return false;
+  if (
+    (expression.name === "vi" || expression.name === "jest") &&
+    sourceCode.isGlobalReference(expression)
+  ) {
+    return true;
+  }
+
+  const variable = resolveVariable(sourceCode, expression);
+  if (variable === null || variable.defs.length === 0) {
+    return expression.name === "vi" || expression.name === "jest";
+  }
+  return variable.defs.some((definition) => {
+    if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
+      return false;
+    }
+    const source = definition.parent.source.value;
+    const name = importedName(definition.node);
+    return (source === "vitest" && name === "vi") || (source === "@jest/globals" && name === "jest");
+  });
+}
+
+function moduleMockCall(sourceCode: SourceCode, callee: ESTree.Expression): boolean {
+  if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
+  if (!isTestFrameworkObject(sourceCode, callee.object)) return false;
+  const property = callee.property;
+  const method = callee.computed
+    ? property.type === "Literal" &&
+      (property.value === "doMock" ||
+        property.value === "mock" ||
+        property.value === "unstable_mockModule")
+      ? property.value
+      : null
+    : property.type === "Identifier"
+      ? property.name
+      : null;
+  return method !== null && moduleMockMethods.has(method);
+}
+
+/** Ban test framework module mocking in favor of real dependency seams. */
+export const noModuleMockingRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces.",
+    },
+    messages: {
+      moduleMock:
+        "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation.",
+    },
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+        if (moduleMockCall(context.sourceCode, node.callee)) {
+          context.report({ node, messageId: "moduleMock" });
+        }
+      },
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/no-object-parameters.ts b/tools/oxlint/anti-slop/rules/no-object-parameters.ts
new file mode 100644
index 0000000..29b990f
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-object-parameters.ts
@@ -0,0 +1,126 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+
+import { lexicalTypeParameterNames } from "../shared/lexical-type-parameters.ts";
+
+type Parameter = ESTree.ParamPattern;
+type ParameterOwner =
+	| ESTree.ArrowFunctionExpression
+	| ESTree.Function
+	| ESTree.TSCallSignatureDeclaration
+	| ESTree.TSConstructSignatureDeclaration
+	| ESTree.TSConstructorType
+	| ESTree.TSFunctionType
+	| ESTree.TSMethodSignature;
+
+function parameterAnnotation(parameter: Parameter): ESTree.TSTypeAnnotation | null | undefined {
+	if (parameter.type === "TSParameterProperty") {
+		return parameterAnnotation(parameter.parameter);
+	}
+	if (parameter.type === "RestElement") {
+		return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
+	}
+	if (parameter.type === "AssignmentPattern") {
+		return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
+	}
+	return parameter.typeAnnotation;
+}
+
+function parameterName(parameter: Parameter, sourceCode: SourceCode): string {
+	return parameter.type === "Identifier"
+		? parameter.name
+		: sourceCode.getText(parameter).replace(/\s*:\s*object\s*$/u, "");
+}
+
+/** Ban the broad object type on function inputs, including local aliases to object. */
+export const noObjectParametersRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary.",
+		},
+		messages: {
+			objectParameter:
+				"Parameter `{{parameter}}` uses the broad `object` type. Accept a named owner type; parse external input at its boundary before calling this function.",
+		},
+	},
+	createOnce(context) {
+		const aliases = new Map<string, ESTree.TSType>();
+
+		const resolvesToObject = (
+			type: ESTree.TSType,
+			shadowedAliases: ReadonlySet<string>,
+			visited = new Set<string>(),
+		): boolean => {
+			if (type.type === "TSObjectKeyword") return true;
+			if (type.type === "TSParenthesizedType")
+				return resolvesToObject(type.typeAnnotation, shadowedAliases, visited);
+			if (type.type === "TSUnionType") {
+				return type.types.some((member) =>
+					resolvesToObject(member, shadowedAliases, visited),
+				);
+			}
+			if (
+				type.type !== "TSTypeReference" ||
+				type.typeName.type !== "Identifier" ||
+				(type.typeArguments !== null &&
+					type.typeArguments !== undefined &&
+					type.typeArguments.params.length > 0) ||
+				visited.has(type.typeName.name) ||
+				shadowedAliases.has(type.typeName.name)
+			) {
+				return false;
+			}
+			const alias = aliases.get(type.typeName.name);
+			if (alias === undefined) return false;
+			const nextVisited = new Set(visited);
+			nextVisited.add(type.typeName.name);
+			return resolvesToObject(alias, shadowedAliases, nextVisited);
+		};
+
+		const checkParameters = (node: ParameterOwner) => {
+			const shadowedAliases = lexicalTypeParameterNames(
+				node,
+				context.sourceCode.visitorKeys,
+			);
+			for (const parameter of node.params) {
+				const annotation = parameterAnnotation(parameter);
+				if (annotation === null || annotation === undefined) continue;
+				if (!resolvesToObject(annotation.typeAnnotation, shadowedAliases)) continue;
+				context.report({
+					node: annotation.typeAnnotation,
+					messageId: "objectParameter",
+					data: { parameter: parameterName(parameter, context.sourceCode) },
+				});
+			}
+		};
+
+		return {
+			Program(node) {
+				aliases.clear();
+				for (const statement of node.body) {
+					const declaration =
+						statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+					if (
+						declaration?.type === "TSTypeAliasDeclaration" &&
+						(declaration.typeParameters === null || declaration.typeParameters === undefined)
+					) {
+						aliases.set(declaration.id.name, declaration.typeAnnotation);
+					}
+				}
+			},
+			ArrowFunctionExpression: checkParameters,
+			FunctionDeclaration: checkParameters,
+			FunctionExpression: checkParameters,
+			TSCallSignatureDeclaration: checkParameters,
+			TSConstructSignatureDeclaration: checkParameters,
+			TSConstructorType: checkParameters,
+			TSDeclareFunction: checkParameters,
+			TSEmptyBodyFunctionExpression: checkParameters,
+			TSFunctionType: checkParameters,
+			TSMethodSignature: checkParameters,
+		};
+	},
+});
diff --git a/tools/oxlint/anti-slop/rules/no-reflect-apply.ts b/tools/oxlint/anti-slop/rules/no-reflect-apply.ts
new file mode 100644
index 0000000..2cc3045
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-reflect-apply.ts
@@ -0,0 +1,28 @@
+import { defineRule } from "@oxlint/plugins";
+
+import { isGlobalReflectMethodCall } from "../shared/reflect-method.ts";
+
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+export const noReflectApplyRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface.",
+    },
+    messages: {
+      reflectApply:
+        "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface.",
+    },
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+        if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply")) {
+          context.report({ node, messageId: "reflectApply" });
+        }
+      },
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/no-reflect-get.ts b/tools/oxlint/anti-slop/rules/no-reflect-get.ts
new file mode 100644
index 0000000..cf630ec
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-reflect-get.ts
@@ -0,0 +1,28 @@
+import { defineRule } from "@oxlint/plugins";
+
+import { isGlobalReflectMethodCall } from "../shared/reflect-method.ts";
+
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+export const noReflectGetRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type.",
+    },
+    messages: {
+      reflectGet:
+        "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it.",
+    },
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+        if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "get")) {
+          context.report({ node, messageId: "reflectGet" });
+        }
+      },
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/no-runtime-typeof.ts b/tools/oxlint/anti-slop/rules/no-runtime-typeof.ts
new file mode 100644
index 0000000..6a25c24
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-runtime-typeof.ts
@@ -0,0 +1,67 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree } from "@oxlint/plugins";
+
+type RuntimeFunction = ESTree.ArrowFunctionExpression | ESTree.Function;
+
+function isRuntimeFunction(node: ESTree.Node): node is RuntimeFunction {
+	return (
+		node.type === "ArrowFunctionExpression" ||
+		node.type === "FunctionDeclaration" ||
+		node.type === "FunctionExpression"
+	);
+}
+
+function isInsideTypeGuard(node: ESTree.Node): boolean {
+	let current: ESTree.Node | null = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (isRuntimeFunction(current)) {
+			return current.returnType?.typeAnnotation.type === "TSTypePredicate";
+		}
+		current = current.parent;
+	}
+	return false;
+}
+
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+export const noRuntimeTypeofRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary.",
+		},
+		messages: {
+			runtimeTypeof:
+				"A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value.",
+		},
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowInTypeGuards: { type: "boolean" },
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [{ allowInTypeGuards: false }],
+	},
+	createOnce(context) {
+		return {
+			UnaryExpression(node) {
+				const option = context.options?.[0];
+				const allowInTypeGuards =
+					typeof option === "object" &&
+					option !== null &&
+					!Array.isArray(option) &&
+					option.allowInTypeGuards === true;
+				if (
+					node.operator === "typeof" &&
+					(!allowInTypeGuards || !isInsideTypeGuard(node))
+				) {
+					context.report({ node, messageId: "runtimeTypeof" });
+				}
+			},
+		};
+	},
+});
diff --git a/tools/oxlint/anti-slop/rules/no-shape-in-symbol-names.ts b/tools/oxlint/anti-slop/rules/no-shape-in-symbol-names.ts
new file mode 100644
index 0000000..afc00dd
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-shape-in-symbol-names.ts
@@ -0,0 +1,39 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+const FORBIDDEN_SYMBOL_NAME = "shape";
+
+function containsForbiddenSymbolName(name: string): boolean {
+  return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
+}
+
+/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+export const noForbiddenTermInSymbolNamesRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        'Disallow the case-insensitive substring "shape" in JavaScript, TypeScript, private, and JSX symbol names.',
+    },
+    messages: {
+      forbiddenSymbolName:
+        'Rename symbol "{{name}}" for its domain role; "shape" describes structure rather than ownership.',
+    },
+  },
+  createOnce(context) {
+    const reportForbiddenSymbolName = (node: ESTree.Node & { name: string }) => {
+      if (!containsForbiddenSymbolName(node.name)) return;
+      context.report({
+        node,
+        messageId: "forbiddenSymbolName",
+        data: { name: node.name },
+      });
+    };
+
+    return {
+      Identifier: reportForbiddenSymbolName,
+      PrivateIdentifier: reportForbiddenSymbolName,
+      JSXIdentifier: reportForbiddenSymbolName,
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/no-unknown-parameters.ts b/tools/oxlint/anti-slop/rules/no-unknown-parameters.ts
new file mode 100644
index 0000000..cdc6c23
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-unknown-parameters.ts
@@ -0,0 +1,83 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+type Parameter = ESTree.ParamPattern;
+type ParameterOwner =
+  | ESTree.ArrowFunctionExpression
+  | ESTree.Function
+  | ESTree.TSCallSignatureDeclaration
+  | ESTree.TSConstructSignatureDeclaration
+  | ESTree.TSConstructorType
+  | ESTree.TSFunctionType
+  | ESTree.TSMethodSignature;
+
+function parameterAnnotation(parameter: Parameter): ESTree.TSTypeAnnotation | null | undefined {
+  if (parameter.type === "TSParameterProperty") {
+    return parameterAnnotation(parameter.parameter);
+  }
+  if (parameter.type === "RestElement") {
+    return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
+  }
+  if (parameter.type === "AssignmentPattern") {
+    return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
+  }
+  return parameter.typeAnnotation;
+}
+
+function parameterName(parameter: Parameter, sourceText: string): string {
+  if (parameter.type === "TSParameterProperty") {
+    return parameterName(parameter.parameter, sourceText);
+  }
+  if (parameter.type === "AssignmentPattern") {
+    return parameterName(parameter.left, sourceText);
+  }
+  if (parameter.type === "RestElement") {
+    return parameterName(parameter.argument, sourceText);
+  }
+  return parameter.type === "Identifier"
+    ? parameter.name
+    : sourceText.replace(/\s*:\s*unknown\s*$/u, "");
+}
+
+/** Disallow unknown inputs except explicitly named error-cause enrichment. */
+export const noUnknownParametersRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow explicitly unknown function parameters except `cause`; decode unknown input at its I/O boundary instead.",
+    },
+    messages: {
+      unknownParameter:
+        "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function.",
+    },
+  },
+  createOnce(context) {
+    const checkParameters = (node: ParameterOwner) => {
+      for (const parameter of node.params) {
+        const annotation = parameterAnnotation(parameter);
+        if (annotation?.typeAnnotation.type !== "TSUnknownKeyword") continue;
+        const name = parameterName(parameter, context.sourceCode.getText(parameter));
+        if (name === "cause") continue;
+        context.report({
+          node: annotation.typeAnnotation,
+          messageId: "unknownParameter",
+          data: { parameter: name },
+        });
+      }
+    };
+
+    return {
+      ArrowFunctionExpression: checkParameters,
+      FunctionDeclaration: checkParameters,
+      FunctionExpression: checkParameters,
+      TSCallSignatureDeclaration: checkParameters,
+      TSConstructSignatureDeclaration: checkParameters,
+      TSConstructorType: checkParameters,
+      TSDeclareFunction: checkParameters,
+      TSEmptyBodyFunctionExpression: checkParameters,
+      TSFunctionType: checkParameters,
+      TSMethodSignature: checkParameters,
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/no-unknown-returns.ts b/tools/oxlint/anti-slop/rules/no-unknown-returns.ts
new file mode 100644
index 0000000..4b16d6e
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-unknown-returns.ts
@@ -0,0 +1,115 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree } from "@oxlint/plugins";
+
+import { lexicalTypeParameterNames } from "../shared/lexical-type-parameters.ts";
+
+type FunctionWithReturnType =
+  | ESTree.ArrowFunctionExpression
+  | ESTree.Function
+  | ESTree.TSCallSignatureDeclaration
+  | ESTree.TSConstructSignatureDeclaration
+  | ESTree.TSConstructorType
+  | ESTree.TSFunctionType
+  | ESTree.TSMethodSignature;
+
+function referencedAliasName(type: ESTree.TSType): string | null {
+  if (type.type === "TSParenthesizedType") return referencedAliasName(type.typeAnnotation);
+  if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return null;
+  return type.typeArguments === null ||
+    type.typeArguments === undefined ||
+    type.typeArguments.params.length === 0
+    ? type.typeName.name
+    : null;
+}
+
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+export const noUnknownReturnsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow functions whose explicit return contract is unknown or Promise<unknown>.",
+    },
+    messages: {
+      unknownReturn:
+        "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type.",
+    },
+  },
+  createOnce(context) {
+    const aliases = new Map<string, ESTree.TSTypeAliasDeclaration>();
+
+    const resolvesToUnknown = (
+      type: ESTree.TSType,
+      shadowedAliases: ReadonlySet<string>,
+      visited = new Set<string>(),
+    ): boolean => {
+      if (type.type === "TSUnknownKeyword") return true;
+      if (type.type === "TSParenthesizedType") {
+        return resolvesToUnknown(type.typeAnnotation, shadowedAliases, visited);
+      }
+      if (type.type === "TSUnionType") {
+        return type.types.some((member) =>
+          resolvesToUnknown(member, shadowedAliases, visited),
+        );
+      }
+      if (
+        type.type === "TSTypeReference" &&
+        type.typeName.type === "Identifier" &&
+        (type.typeName.name === "Promise" || type.typeName.name === "PromiseLike")
+      ) {
+        const value = type.typeArguments?.params[0];
+        return value !== undefined && resolvesToUnknown(value, shadowedAliases, visited);
+      }
+      const name = referencedAliasName(type);
+      if (name === null || visited.has(name) || shadowedAliases.has(name)) return false;
+      const alias = aliases.get(name);
+      if (
+        alias === undefined ||
+        (alias.typeParameters !== null && alias.typeParameters !== undefined)
+      ) {
+        return false;
+      }
+      const nextVisited = new Set(visited);
+      nextVisited.add(name);
+      return resolvesToUnknown(alias.typeAnnotation, shadowedAliases, nextVisited);
+    };
+
+    const checkReturnType = (node: FunctionWithReturnType) => {
+      const annotation = node.returnType;
+      if (annotation === null || annotation === undefined) return;
+      if (
+        !resolvesToUnknown(
+          annotation.typeAnnotation,
+          lexicalTypeParameterNames(node, context.sourceCode.visitorKeys),
+        )
+      ) {
+        return;
+      }
+      context.report({ node: annotation.typeAnnotation, messageId: "unknownReturn" });
+    };
+
+    return {
+      Program(node) {
+        aliases.clear();
+        for (const statement of node.body) {
+          const declaration =
+            statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+          if (declaration?.type === "TSTypeAliasDeclaration") {
+            aliases.set(declaration.id.name, declaration);
+          }
+        }
+      },
+      ArrowFunctionExpression: checkReturnType,
+      FunctionDeclaration: checkReturnType,
+      FunctionExpression: checkReturnType,
+      TSCallSignatureDeclaration: checkReturnType,
+      TSConstructSignatureDeclaration: checkReturnType,
+      TSConstructorType: checkReturnType,
+      TSDeclareFunction: checkReturnType,
+      TSEmptyBodyFunctionExpression: checkReturnType,
+      TSFunctionType: checkReturnType,
+      TSMethodSignature: checkReturnType,
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/no-unknown-type-aliases.ts b/tools/oxlint/anti-slop/rules/no-unknown-type-aliases.ts
new file mode 100644
index 0000000..3e328fd
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-unknown-type-aliases.ts
@@ -0,0 +1,70 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree } from "@oxlint/plugins";
+
+function referencedAliasName(type: ESTree.TSType): string | null {
+	if (type.type === "TSParenthesizedType") return referencedAliasName(type.typeAnnotation);
+	if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return null;
+	return type.typeArguments === null ||
+		type.typeArguments === undefined ||
+		type.typeArguments.params.length === 0
+		? type.typeName.name
+		: null;
+}
+
+/** Ban named aliases that merely conceal TypeScript's unknown top type. */
+export const noUnknownTypeAliasesRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow type aliases whose resolved type is unknown; unknown must remain visible at an allowed boundary.",
+		},
+		messages: {
+			unknownAlias:
+				"Type alias `{{alias}}` hides `unknown`. Keep `unknown` explicit at the parsing boundary or on an allowed `cause` field; otherwise use the parsed owner type.",
+		},
+	},
+	createOnce(context) {
+		const aliases = new Map<string, ESTree.TSTypeAliasDeclaration>();
+
+		const resolvesToUnknown = (type: ESTree.TSType, visited = new Set<string>()): boolean => {
+			if (type.type === "TSUnknownKeyword") return true;
+			if (type.type === "TSParenthesizedType")
+				return resolvesToUnknown(type.typeAnnotation, visited);
+			const name = referencedAliasName(type);
+			if (name === null || visited.has(name)) return false;
+			const alias = aliases.get(name);
+			if (
+				alias === undefined ||
+				(alias.typeParameters !== null && alias.typeParameters !== undefined)
+			) {
+				return false;
+			}
+			const nextVisited = new Set(visited);
+			nextVisited.add(name);
+			return resolvesToUnknown(alias.typeAnnotation, nextVisited);
+		};
+
+		return {
+			Program(node) {
+				aliases.clear();
+				for (const statement of node.body) {
+					const declaration =
+						statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+					if (declaration?.type === "TSTypeAliasDeclaration") {
+						aliases.set(declaration.id.name, declaration);
+					}
+				}
+				for (const alias of aliases.values()) {
+					if (!resolvesToUnknown(alias.typeAnnotation, new Set([alias.id.name]))) continue;
+					context.report({
+						node: alias.id,
+						messageId: "unknownAlias",
+						data: { alias: alias.id.name },
+					});
+				}
+			},
+		};
+	},
+});
diff --git a/tools/oxlint/anti-slop/rules/no-unsafe-dictionary-type.ts b/tools/oxlint/anti-slop/rules/no-unsafe-dictionary-type.ts
new file mode 100644
index 0000000..8c45eed
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-unsafe-dictionary-type.ts
@@ -0,0 +1,134 @@
+import { defineRule } from "@oxlint/plugins";
+
+import {
+	classifyUnsafeDictionary,
+	classifyUnsafeDictionaryValue,
+	createTypeEnvironment,
+	type TypeEnvironment,
+} from "../shared/dictionary-types.ts";
+
+import type { ESTree } from "@oxlint/plugins";
+
+const typeNodeKinds: ReadonlySet<string> = new Set([
+	"JSDocNonNullableType",
+	"JSDocNullableType",
+	"JSDocUnknownType",
+	"TSAnyKeyword",
+	"TSArrayType",
+	"TSBigIntKeyword",
+	"TSBooleanKeyword",
+	"TSConditionalType",
+	"TSConstructorType",
+	"TSFunctionType",
+	"TSImportType",
+	"TSIndexedAccessType",
+	"TSInferType",
+	"TSIntersectionType",
+	"TSIntrinsicKeyword",
+	"TSLiteralType",
+	"TSMappedType",
+	"TSNamedTupleMember",
+	"TSNeverKeyword",
+	"TSNullKeyword",
+	"TSNumberKeyword",
+	"TSObjectKeyword",
+	"TSParenthesizedType",
+	"TSStringKeyword",
+	"TSSymbolKeyword",
+	"TSTemplateLiteralType",
+	"TSThisType",
+	"TSTupleType",
+	"TSTypeLiteral",
+	"TSTypeOperator",
+	"TSTypePredicate",
+	"TSTypeQuery",
+	"TSTypeReference",
+	"TSUndefinedKeyword",
+	"TSUnionType",
+	"TSUnknownKeyword",
+	"TSVoidKeyword",
+]);
+
+function isTypeNode(node: ESTree.Node): node is ESTree.TSType {
+	return typeNodeKinds.has(node.type);
+}
+
+function typeReferenceName(type: ESTree.TSTypeReference): string | null {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+
+function isInsideTypeAliasDeclaration(node: ESTree.Node): boolean {
+	let current: ESTree.Node | null = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "TSTypeAliasDeclaration") return true;
+		current = current.parent;
+	}
+	return false;
+}
+
+function isPlainAliasConsumerUse(node: ESTree.TSType, environment: TypeEnvironment): boolean {
+	if (node.type !== "TSTypeReference" || node.typeArguments?.params.length) return false;
+	const name = typeReferenceName(node);
+	return name !== null && environment.aliases.has(name) && !isInsideTypeAliasDeclaration(node);
+}
+
+function shouldReportType(node: ESTree.TSType, environment: TypeEnvironment): boolean {
+	if (isPlainAliasConsumerUse(node, environment)) return false;
+	if (classifyUnsafeDictionary(node, environment) === null) return false;
+	let current: ESTree.Node | null = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (isTypeNode(current) && classifyUnsafeDictionary(current, environment) !== null)
+			return false;
+		current = current.parent;
+	}
+	return true;
+}
+
+/** Disallow object-dictionary contracts whose direct value type is an unsafe escape hatch. */
+export const noUnsafeDictionaryTypeRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow object-dictionary contracts whose direct value type is unknown, any, object, {}, or a union/alias containing one of those escape hatches.",
+		},
+		messages: {
+			unsafeDictionary:
+				"This dictionary's {{value}} value type gives callers no concrete value contract. Use an owner/schema-derived value type; parse external payloads before insertion.",
+		},
+	},
+	createOnce(context) {
+		let environment: TypeEnvironment | null = null;
+		const report = (node: ESTree.Node, value: string) => {
+			context.report({ node, messageId: "unsafeDictionary", data: { value } });
+		};
+		const reportIfUnsafe = (node: ESTree.TSType) => {
+			if (environment === null || !shouldReportType(node, environment)) return;
+			const unsafe = classifyUnsafeDictionary(node, environment);
+			if (unsafe === null) return;
+			report(node, unsafe.unsafeValue);
+		};
+
+		return {
+			Program(node) {
+				environment = createTypeEnvironment(node);
+			},
+			TSTypeReference: reportIfUnsafe,
+			TSTypeLiteral: reportIfUnsafe,
+			TSMappedType: reportIfUnsafe,
+			TSIndexSignature(node) {
+				if (
+					environment === null ||
+					node.typeAnnotation === null ||
+					node.parent.type === "TSTypeLiteral"
+				)
+					return;
+				const unsafe = classifyUnsafeDictionaryValue(
+					node.typeAnnotation.typeAnnotation,
+					environment,
+				);
+				if (unsafe !== null) report(node, unsafe.unsafeValue);
+			},
+		};
+	},
+});
diff --git a/tools/oxlint/anti-slop/rules/no-widen-then-assert.ts b/tools/oxlint/anti-slop/rules/no-widen-then-assert.ts
new file mode 100644
index 0000000..c5e07f7
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/no-widen-then-assert.ts
@@ -0,0 +1,366 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree, Variable } from "@oxlint/plugins";
+
+type BroadTypeKind = "top" | "object" | "record";
+
+type KnownValueEvidence = {
+  readonly type: ESTree.TSType | null;
+};
+
+const functionBoundaryTypes = new Set([
+  "ArrowFunctionExpression",
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "TSDeclareFunction",
+  "TSEmptyBodyFunctionExpression",
+]);
+
+function unwrapExpressionParentheses(expression: ESTree.Expression): ESTree.Expression {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression") current = current.expression;
+  return current;
+}
+
+function unwrapTypeParentheses(type: ESTree.TSType): ESTree.TSType {
+  let current = type;
+  while (current.type === "TSParenthesizedType") current = current.typeAnnotation;
+  return current;
+}
+
+function typeReferenceName(type: ESTree.TSTypeReference): string | null {
+  return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+
+function isUnknownOrAnyType(type: ESTree.TSType): boolean {
+  const unwrapped = unwrapTypeParentheses(type);
+  return unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword";
+}
+
+function isBroadRecordKeyType(type: ESTree.TSType): boolean {
+  const unwrapped = unwrapTypeParentheses(type);
+  if (
+    unwrapped.type === "TSStringKeyword" ||
+    unwrapped.type === "TSNumberKeyword" ||
+    unwrapped.type === "TSSymbolKeyword"
+  ) {
+    return true;
+  }
+  if (unwrapped.type === "TSUnionType") return unwrapped.types.every(isBroadRecordKeyType);
+  return unwrapped.type === "TSTypeReference" && typeReferenceName(unwrapped) === "PropertyKey";
+}
+
+function isBroadRecordType(type: ESTree.TSType): boolean {
+  const unwrapped = unwrapTypeParentheses(type);
+
+  if (unwrapped.type === "TSTypeReference") {
+    if (typeReferenceName(unwrapped) === "Readonly") {
+      const [inner] = unwrapped.typeArguments?.params ?? [];
+      return inner !== undefined && isBroadRecordType(inner);
+    }
+
+    if (typeReferenceName(unwrapped) !== "Record") return false;
+    const parameters = unwrapped.typeArguments?.params ?? [];
+    return (
+      parameters.length === 2 &&
+      parameters[0] !== undefined &&
+      parameters[1] !== undefined &&
+      isBroadRecordKeyType(parameters[0]) &&
+      isUnknownOrAnyType(parameters[1])
+    );
+  }
+
+  if (unwrapped.type !== "TSTypeLiteral" || unwrapped.members.length !== 1) return false;
+  const [member] = unwrapped.members;
+  const [parameter] = member?.type === "TSIndexSignature" ? member.parameters : [];
+  return (
+    member?.type === "TSIndexSignature" &&
+    member.parameters.length === 1 &&
+    parameter !== undefined &&
+    isBroadRecordKeyType(parameter.typeAnnotation.typeAnnotation) &&
+    isUnknownOrAnyType(member.typeAnnotation.typeAnnotation)
+  );
+}
+
+function broadTypeKind(type: ESTree.TSType): BroadTypeKind | null {
+  const unwrapped = unwrapTypeParentheses(type);
+  if (unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword") return "top";
+  if (unwrapped.type === "TSObjectKeyword") return "object";
+  return isBroadRecordType(unwrapped) ? "record" : null;
+}
+
+function assertedExpression(
+  node: ESTree.TSAsExpression | ESTree.TSTypeAssertion,
+): ESTree.Expression {
+  return unwrapExpressionParentheses(node.expression);
+}
+
+function assertionFromExpression(
+  expression: ESTree.Expression,
+): ESTree.TSAsExpression | ESTree.TSTypeAssertion | null {
+  const unwrapped = unwrapExpressionParentheses(expression);
+  return unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion"
+    ? unwrapped
+    : null;
+}
+
+function normalizedTypeText(sourceText: string, type: ESTree.TSType): string {
+  return sourceText.slice(type.start, type.end).replaceAll(/\s+/gu, "");
+}
+
+function typesHaveSameSyntax(
+  sourceText: string,
+  left: ESTree.TSType | null,
+  right: ESTree.TSType,
+): boolean {
+  return (
+    left !== null &&
+    normalizedTypeText(sourceText, unwrapTypeParentheses(left)) ===
+      normalizedTypeText(sourceText, unwrapTypeParentheses(right))
+  );
+}
+
+function isDefinitelyObjectType(type: ESTree.TSType): boolean {
+  const unwrapped = unwrapTypeParentheses(type);
+  switch (unwrapped.type) {
+    case "TSArrayType":
+    case "TSConstructorType":
+    case "TSFunctionType":
+    case "TSMappedType":
+    case "TSObjectKeyword":
+    case "TSTupleType":
+      return true;
+    case "TSTypeLiteral":
+      return unwrapped.members.length > 0;
+    case "TSIntersectionType":
+      return unwrapped.types.every(isDefinitelyObjectType);
+    case "TSTypeOperator":
+      return unwrapped.operator === "readonly" && isDefinitelyObjectType(unwrapped.typeAnnotation);
+    default:
+      return false;
+  }
+}
+
+function isDefinitelyNarrowerRecordType(type: ESTree.TSType): boolean {
+  const unwrapped = unwrapTypeParentheses(type);
+  if (unwrapped.type === "TSTypeLiteral") {
+    return unwrapped.members.some((member) => member.type !== "TSIndexSignature");
+  }
+
+  if (unwrapped.type !== "TSTypeReference") return false;
+  if (typeReferenceName(unwrapped) === "Readonly") {
+    const [inner] = unwrapped.typeArguments?.params ?? [];
+    return inner !== undefined && isDefinitelyNarrowerRecordType(inner);
+  }
+  if (typeReferenceName(unwrapped) !== "Record") return false;
+
+  const parameters = unwrapped.typeArguments?.params ?? [];
+  return (
+    parameters.length === 2 && parameters[1] !== undefined && !isUnknownOrAnyType(parameters[1])
+  );
+}
+
+function functionBoundary(node: ESTree.Node): ESTree.Node | null {
+  let current = node.parent;
+  while (current !== null && current.type !== "Program") {
+    if (functionBoundaryTypes.has(current.type)) return current;
+    current = current.parent;
+  }
+  return null;
+}
+
+function resolvedVariableForIdentifier(
+  scopes: readonly {
+    readonly references: readonly {
+      readonly identifier: ESTree.Node;
+      readonly resolved: Variable | null;
+    }[];
+  }[],
+  identifier: ESTree.IdentifierReference,
+): Variable | null {
+  for (const scope of scopes) {
+    const reference = scope.references.find(
+      (candidate) =>
+        candidate.identifier.start === identifier.start &&
+        candidate.identifier.end === identifier.end,
+    );
+    if (reference !== undefined) return reference.resolved;
+  }
+  return null;
+}
+
+function variableDeclarator(variable: Variable): ESTree.VariableDeclarator | null {
+  for (const definition of variable.defs) {
+    if (definition.type === "Variable" && definition.node.type === "VariableDeclarator") {
+      return definition.node;
+    }
+  }
+  return null;
+}
+
+function knownValueEvidence(
+  expression: ESTree.Expression,
+  scopes: Parameters<typeof resolvedVariableForIdentifier>[0],
+  boundary: ESTree.Node | null,
+  visitedVariables: ReadonlySet<Variable>,
+): KnownValueEvidence | null {
+  const unwrapped = unwrapExpressionParentheses(expression);
+
+  if (unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion") {
+    if (broadTypeKind(unwrapped.typeAnnotation) !== null) return null;
+    return { type: unwrapped.typeAnnotation };
+  }
+
+  if (unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral") {
+    return { type: null };
+  }
+
+  if (
+    unwrapped.type === "ArrayExpression" ||
+    unwrapped.type === "ArrowFunctionExpression" ||
+    unwrapped.type === "ClassExpression" ||
+    unwrapped.type === "FunctionExpression" ||
+    unwrapped.type === "NewExpression" ||
+    unwrapped.type === "ObjectExpression"
+  ) {
+    return { type: null };
+  }
+
+  if (unwrapped.type !== "Identifier") return null;
+  const variable = resolvedVariableForIdentifier(scopes, unwrapped);
+  if (variable === null || visitedVariables.has(variable)) return null;
+
+  const annotatedIdentifier = variable.identifiers.find(
+    (identifier) => identifier.typeAnnotation !== null && identifier.typeAnnotation !== undefined,
+  );
+  const annotation = annotatedIdentifier?.typeAnnotation?.typeAnnotation;
+  if (annotation !== undefined && annotatedIdentifier !== undefined) {
+    if (functionBoundary(annotatedIdentifier) !== boundary || broadTypeKind(annotation) !== null) {
+      return null;
+    }
+    return { type: annotation };
+  }
+
+  const declarator = variableDeclarator(variable);
+  if (
+    declarator === null ||
+    declarator.parent.type !== "VariableDeclaration" ||
+    declarator.parent.kind !== "const" ||
+    declarator.init === null ||
+    variable.references.some((reference) => reference.isWrite() && !reference.init) ||
+    functionBoundary(declarator) !== boundary
+  ) {
+    return null;
+  }
+
+  return knownValueEvidence(
+    declarator.init,
+    scopes,
+    boundary,
+    new Set([...visitedVariables, variable]),
+  );
+}
+
+function widenedBinding(
+  variable: Variable,
+  scopes: Parameters<typeof resolvedVariableForIdentifier>[0],
+): {
+  readonly broadKind: BroadTypeKind;
+  readonly evidence: KnownValueEvidence;
+  readonly declaredAt: number;
+  readonly boundary: ESTree.Node | null;
+} | null {
+  const declarator = variableDeclarator(variable);
+  if (
+    declarator === null ||
+    declarator.parent.type !== "VariableDeclaration" ||
+    declarator.parent.kind !== "const" ||
+    declarator.id.type !== "Identifier" ||
+    declarator.init === null ||
+    variable.references.some((reference) => reference.isWrite() && !reference.init)
+  ) {
+    return null;
+  }
+
+  const boundary = functionBoundary(declarator);
+  const declaredType = declarator.id.typeAnnotation?.typeAnnotation;
+  const initializerAssertion = assertionFromExpression(declarator.init);
+  const initializerBroadKind =
+    initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
+  const declaredBroadKind = declaredType === undefined ? null : broadTypeKind(declaredType);
+  const broadKind = declaredBroadKind ?? initializerBroadKind;
+  if (broadKind === null) return null;
+
+  const originalExpression =
+    initializerAssertion !== null && initializerBroadKind !== null
+      ? assertedExpression(initializerAssertion)
+      : declarator.init;
+  const evidence = knownValueEvidence(originalExpression, scopes, boundary, new Set([variable]));
+  return evidence === null ? null : { broadKind, evidence, declaredAt: declarator.end, boundary };
+}
+
+function assertionIsNarrower(
+  sourceText: string,
+  broadKind: BroadTypeKind,
+  evidence: KnownValueEvidence,
+  assertedType: ESTree.TSType,
+): boolean {
+  if (broadTypeKind(assertedType) !== null) return false;
+  if (broadKind === "top") return true;
+  if (typesHaveSameSyntax(sourceText, evidence.type, assertedType)) return true;
+  if (broadKind === "object") return isDefinitelyObjectType(assertedType);
+  return isDefinitelyNarrowerRecordType(assertedType);
+}
+
+/** Detect immutable local bindings that erase a known type and are later asserted back to a narrower type. */
+export const noWidenThenAssertRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow local const flows that explicitly widen a known value before asserting the widened binding to a narrower type.",
+    },
+    messages: {
+      widenThenAssert:
+        'Binding "{{name}}" discards type evidence and later recreates it with an assertion. Keep the precise type from initialization through use; parse boundary input once.',
+    },
+  },
+  createOnce(context) {
+    let scopes: Parameters<typeof resolvedVariableForIdentifier>[0] = [];
+
+    const checkAssertion = (node: ESTree.TSAsExpression | ESTree.TSTypeAssertion) => {
+      const expression = assertedExpression(node);
+      if (expression.type !== "Identifier") return;
+
+      const variable = resolvedVariableForIdentifier(scopes, expression);
+      if (variable === null) return;
+      const widened = widenedBinding(variable, scopes);
+      if (
+        widened === null ||
+        node.start <= widened.declaredAt ||
+        functionBoundary(node) !== widened.boundary ||
+        !assertionIsNarrower(
+          context.sourceCode.text,
+          widened.broadKind,
+          widened.evidence,
+          node.typeAnnotation,
+        )
+      ) {
+        return;
+      }
+
+      context.report({
+        node,
+        messageId: "widenThenAssert",
+        data: { name: expression.name },
+      });
+    };
+
+    return {
+      Program() {
+        scopes = context.sourceCode.scopeManager.scopes;
+      },
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion,
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/rules/require-safety-comment-for-type-assertion.ts b/tools/oxlint/anti-slop/rules/require-safety-comment-for-type-assertion.ts
new file mode 100644
index 0000000..f1a2ffc
--- /dev/null
+++ b/tools/oxlint/anti-slop/rules/require-safety-comment-for-type-assertion.ts
@@ -0,0 +1,62 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+
+type TypeAssertion = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
+
+const commentOwnerKinds = new Set([
+  "ExpressionStatement",
+  "PropertyDefinition",
+  "ReturnStatement",
+  "ThrowStatement",
+  "VariableDeclaration",
+]);
+
+function isConstAssertion(node: TypeAssertion): boolean {
+  return (
+    node.typeAnnotation.type === "TSTypeReference" &&
+    node.typeAnnotation.typeName.type === "Identifier" &&
+    node.typeAnnotation.typeName.name === "const"
+  );
+}
+
+function hasSafetyComment(sourceCode: SourceCode, node: TypeAssertion): boolean {
+  let current: ESTree.Node = node;
+  while (true) {
+    if (
+      sourceCode
+        .getCommentsBefore(current)
+        .some((comment) => comment.end <= node.start && /\bSAFETY\s*:/u.test(comment.value))
+    ) {
+      return true;
+    }
+    if (commentOwnerKinds.has(current.type) || current.parent.type === "Program") return false;
+    current = current.parent;
+  }
+}
+
+/** Require every non-const type assertion to state the invariant TypeScript cannot express. */
+export const requireSafetyCommentForTypeAssertionRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require a nearby SAFETY comment for every TypeScript type assertion except const assertions.",
+    },
+    messages: {
+      missingSafetyComment:
+        "This type assertion has no `SAFETY:` justification. State the checked invariant immediately before the assertion or its containing statement.",
+    },
+  },
+  createOnce(context) {
+    const checkAssertion = (node: TypeAssertion) => {
+      if (isConstAssertion(node) || hasSafetyComment(context.sourceCode, node)) return;
+      context.report({ node, messageId: "missingSafetyComment" });
+    };
+
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion,
+    };
+  },
+});
diff --git a/tools/oxlint/anti-slop/shared/dictionary-types.ts b/tools/oxlint/anti-slop/shared/dictionary-types.ts
new file mode 100644
index 0000000..8651700
--- /dev/null
+++ b/tools/oxlint/anti-slop/shared/dictionary-types.ts
@@ -0,0 +1,502 @@
+import type { ESTree } from "@oxlint/plugins";
+
+const BUILT_INS = new Set([
+	"Record",
+	"Readonly",
+	"Partial",
+	"Required",
+	"Pick",
+	"Omit",
+	"PropertyKey",
+	"NonNullable",
+]);
+const TRANSPARENT_WRAPPERS = new Set(["Readonly", "Partial", "Required", "NonNullable"]);
+
+type TypeAliasEnvironment = ReadonlyMap<string, ESTree.TSType>;
+
+type ResolvedType = {
+	readonly type: ESTree.TSType;
+	readonly substitutions: TypeAliasEnvironment;
+};
+
+export type UnsafeDictionary = {
+	readonly kind: "unsafe-dictionary";
+	readonly unsafeValue: "any" | "empty-object" | "object" | "union" | "unknown";
+};
+
+export type WideningTargetKind =
+	| "anonymous object"
+	| "generic container"
+	| "object"
+	| "open dictionary"
+	| "unknown";
+
+export type WideningTarget = {
+	readonly kind: WideningTargetKind;
+};
+
+export type TypeEnvironment = {
+	readonly aliases: ReadonlyMap<string, ESTree.TSTypeAliasDeclaration>;
+	readonly interfaces: ReadonlyMap<string, readonly ESTree.TSInterfaceDeclaration[]>;
+	readonly shadowedBuiltIns: ReadonlySet<string>;
+};
+
+function declaredStatement(statement: ESTree.Statement): ESTree.Node | null {
+	return statement.type === "ExportNamedDeclaration" ||
+		statement.type === "ExportDefaultDeclaration"
+		? (statement.declaration ?? null)
+		: statement;
+}
+
+export function createTypeEnvironment(program: ESTree.Program): TypeEnvironment {
+	const aliases = new Map<string, ESTree.TSTypeAliasDeclaration>();
+	const interfaces = new Map<string, ESTree.TSInterfaceDeclaration[]>();
+	const shadowedBuiltIns = new Set<string>();
+
+	for (const statement of program.body) {
+		const declaration = declaredStatement(statement);
+		if (declaration?.type === "ImportDeclaration") {
+			for (const specifier of declaration.specifiers) {
+				if (BUILT_INS.has(specifier.local.name)) shadowedBuiltIns.add(specifier.local.name);
+			}
+			continue;
+		}
+
+		if (declaration?.type === "TSTypeAliasDeclaration") {
+			const existing = aliases.get(declaration.id.name);
+			if (existing === undefined) aliases.set(declaration.id.name, declaration);
+			else shadowedBuiltIns.add(declaration.id.name);
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+
+		if (declaration?.type === "TSInterfaceDeclaration") {
+			const declarations = interfaces.get(declaration.id.name) ?? [];
+			declarations.push(declaration);
+			interfaces.set(declaration.id.name, declarations);
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+
+		if (declaration?.type === "TSEnumDeclaration") {
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+
+		if (
+			(declaration?.type === "ClassDeclaration" ||
+				declaration?.type === "FunctionDeclaration") &&
+			declaration.id !== null
+		) {
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+		}
+	}
+
+	return { aliases, interfaces, shadowedBuiltIns };
+}
+
+function typeReferenceName(type: ESTree.TSTypeReference): string | null {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+
+function isBuiltIn(name: string, environment: TypeEnvironment): boolean {
+	return BUILT_INS.has(name) && !environment.shadowedBuiltIns.has(name);
+}
+
+function isUnappliedReferenceTo(type: ESTree.TSType, name: string): boolean {
+	const unwrapped = unwrapTransparentType(type);
+	return (
+		unwrapped.type === "TSTypeReference" &&
+		typeReferenceName(unwrapped) === name &&
+		(unwrapped.typeArguments === null ||
+			unwrapped.typeArguments === undefined ||
+			unwrapped.typeArguments.params.length === 0)
+	);
+}
+
+function unwrapTransparentType(type: ESTree.TSType): ESTree.TSType {
+	let current = type;
+	while (
+		current.type === "TSParenthesizedType" ||
+		(current.type === "TSTypeOperator" && current.operator === "readonly")
+	) {
+		current = current.typeAnnotation;
+	}
+	return current;
+}
+
+function isNeverType(type: ESTree.TSType): boolean {
+	return unwrapTransparentType(type).type === "TSNeverKeyword";
+}
+
+function isEffectivelyEmptyMember(member: ESTree.TSSignature): boolean {
+	return (
+		member.type === "TSPropertySignature" &&
+		member.optional === true &&
+		member.typeAnnotation !== null &&
+		member.typeAnnotation !== undefined &&
+		isNeverType(member.typeAnnotation.typeAnnotation)
+	);
+}
+
+function isEffectivelyEmptyTypeLiteral(type: ESTree.TSTypeLiteral): boolean {
+	return type.members.length === 0 || type.members.every(isEffectivelyEmptyMember);
+}
+
+function isEffectivelyEmptyInterface(
+	declarations: readonly ESTree.TSInterfaceDeclaration[],
+): boolean {
+	if (declarations.length !== 1) return false;
+	const [type] = declarations;
+	return (
+		type !== undefined &&
+		type.extends.length === 0 &&
+		(type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember))
+	);
+}
+
+function resolvedSubstitutionArgument(
+	type: ESTree.TSType,
+	base: TypeAliasEnvironment,
+	resolving: ReadonlySet<string> = new Set(),
+): ESTree.TSType {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type !== "TSTypeReference") return type;
+	const name = typeReferenceName(unwrapped);
+	if (name === null || resolving.has(name)) return type;
+	const substitution = base.get(name);
+	if (substitution === undefined) return type;
+	const nextResolving = new Set(resolving);
+	nextResolving.add(name);
+	return resolvedSubstitutionArgument(substitution, base, nextResolving);
+}
+
+function aliasSubstitution(
+	alias: ESTree.TSTypeAliasDeclaration,
+	type: ESTree.TSTypeReference,
+	base: TypeAliasEnvironment,
+): TypeAliasEnvironment | null {
+	const parameters = alias.typeParameters?.params ?? [];
+	const arguments_ = type.typeArguments?.params ?? [];
+	const next = new Map(base);
+	for (const [index, parameter] of parameters.entries()) {
+		const argument = arguments_[index] ?? parameter.default;
+		if (argument === null || argument === undefined) return null;
+		next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
+	}
+	return next;
+}
+
+function unsafeDirectValue(
+	type: ESTree.TSType,
+	environment: TypeEnvironment,
+	substitutions: TypeAliasEnvironment,
+	resolvingAliases: ReadonlySet<string>,
+): UnsafeDictionary["unsafeValue"] | null {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return "unknown";
+	if (unwrapped.type === "TSAnyKeyword") return "any";
+	if (unwrapped.type === "TSObjectKeyword") return "object";
+	if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped))
+		return "empty-object";
+	if (unwrapped.type === "TSUnionType") {
+		return unwrapped.types.some(
+			(member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases) !== null,
+		)
+			? "union"
+			: null;
+	}
+	if (unwrapped.type === "TSIntersectionType") {
+		const unsafeMembers = unwrapped.types.map((member) =>
+			unsafeDirectValue(member, environment, substitutions, resolvingAliases),
+		);
+		if (unsafeMembers.includes("any")) return "any";
+		return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null)
+			? unsafeMembers[0]
+			: null;
+	}
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName(unwrapped);
+	if (name === null) return null;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === undefined
+			? null
+			: unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases);
+	}
+	const substitution = substitutions.get(name);
+	if (substitution !== undefined) {
+		return isUnappliedReferenceTo(substitution, name)
+			? null
+			: unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+	}
+	const interfaceDeclarations = environment.interfaces.get(name);
+	if (interfaceDeclarations !== undefined) {
+		return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
+	}
+	const alias = environment.aliases.get(name);
+	if (alias === undefined || resolvingAliases.has(name)) return null;
+	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+	if (nextSubstitutions === null) return null;
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+
+function dictionaryValueTypes(
+	type: ESTree.TSType,
+	environment: TypeEnvironment,
+	substitutions: TypeAliasEnvironment,
+	resolvingAliases: ReadonlySet<string>,
+): readonly ResolvedType[] {
+	const unwrapped = unwrapTransparentType(type);
+
+	if (unwrapped.type === "TSTypeLiteral") {
+		return unwrapped.members.flatMap((member): readonly ResolvedType[] =>
+			member.type === "TSIndexSignature" && member.typeAnnotation !== null
+				? [{ type: member.typeAnnotation.typeAnnotation, substitutions }]
+				: [],
+		);
+	}
+
+	if (unwrapped.type === "TSMappedType") {
+		return unwrapped.typeAnnotation === null
+			? []
+			: [{ type: unwrapped.typeAnnotation, substitutions }];
+	}
+
+	if (unwrapped.type !== "TSTypeReference") return [];
+	const name = typeReferenceName(unwrapped);
+	if (name === null) return [];
+
+	const substitution = substitutions.get(name);
+	if (substitution !== undefined) {
+		return isUnappliedReferenceTo(substitution, name)
+			? []
+			: dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
+	}
+
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === undefined
+			? []
+			: dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
+	}
+
+	if (name === "Record" && isBuiltIn(name, environment)) {
+		const value = unwrapped.typeArguments?.params[1] ?? null;
+		return value === null ? [] : [{ type: value, substitutions }];
+	}
+
+	if ((name === "Pick" || name === "Omit") && isBuiltIn(name, environment)) {
+		const source = unwrapped.typeArguments?.params[0];
+		return source === undefined
+			? []
+			: dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
+	}
+
+	const alias = environment.aliases.get(name);
+	if (alias === undefined || resolvingAliases.has(name)) return [];
+	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+	if (nextSubstitutions === null) return [];
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return dictionaryValueTypes(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+
+export function classifyUnsafeDictionaryValue(
+	valueType: ESTree.TSType,
+	environment: TypeEnvironment,
+): UnsafeDictionary | null {
+	const unsafeValue = unsafeDirectValue(valueType, environment, new Map(), new Set());
+	return unsafeValue === null ? null : { kind: "unsafe-dictionary", unsafeValue };
+}
+
+export function classifyUnsafeDictionary(
+	type: ESTree.TSType,
+	environment: TypeEnvironment,
+): UnsafeDictionary | null {
+	for (const valueType of dictionaryValueTypes(type, environment, new Map(), new Set())) {
+		const unsafeValue = unsafeDirectValue(
+			valueType.type,
+			environment,
+			valueType.substitutions,
+			new Set(),
+		);
+		if (unsafeValue !== null) return { kind: "unsafe-dictionary", unsafeValue };
+	}
+	return null;
+}
+
+function resolvesToDictionary(
+	type: ESTree.TSType,
+	environment: TypeEnvironment,
+	substitutions: TypeAliasEnvironment,
+	resolvingAliases: ReadonlySet<string>,
+): boolean {
+	return dictionaryValueTypes(type, environment, substitutions, resolvingAliases).length > 0;
+}
+
+export function classifyWideningTarget(
+	type: ESTree.TSType,
+	environment: TypeEnvironment,
+): WideningTarget | null {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return { kind: "unknown" };
+	if (unwrapped.type === "TSObjectKeyword") return { kind: "object" };
+	if (unwrapped.type === "TSTypeLiteral") {
+		return unwrapped.members.some((member) => member.type === "TSIndexSignature")
+			? { kind: "open dictionary" }
+			: unwrapped.members.length > 0
+				? { kind: "anonymous object" }
+				: null;
+	}
+	if (unwrapped.type === "TSMappedType") return { kind: "open dictionary" };
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName(unwrapped);
+	if (name === null) return null;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === undefined ? null : classifyWideningTarget(wrapped, environment);
+	}
+	if (name === "Record" && isBuiltIn(name, environment)) return { kind: "open dictionary" };
+	const alias = environment.aliases.get(name);
+	if (alias === undefined) return null;
+	if ((alias.typeParameters?.params.length ?? 0) > 0) {
+		const substitutions = aliasSubstitution(alias, unwrapped, new Map());
+		return substitutions !== null &&
+			resolvesToDictionary(alias.typeAnnotation, environment, substitutions, new Set([name]))
+			? { kind: "generic container" }
+			: null;
+	}
+	const substitutions = aliasSubstitution(alias, unwrapped, new Map());
+	if (substitutions === null) return null;
+	const resolved = classifyAliasBroadTarget(
+		alias.typeAnnotation,
+		environment,
+		substitutions,
+		new Set([name]),
+	);
+	return resolved;
+}
+
+function isBroadMappedKey(
+	type: ESTree.TSType,
+	environment: TypeEnvironment,
+	substitutions: TypeAliasEnvironment,
+): boolean {
+	const unwrapped = unwrapTransparentType(type);
+	if (
+		unwrapped.type === "TSStringKeyword" ||
+		unwrapped.type === "TSNumberKeyword" ||
+		unwrapped.type === "TSSymbolKeyword"
+	) {
+		return true;
+	}
+	if (unwrapped.type === "TSUnionType") {
+		return unwrapped.types.every((member) =>
+			isBroadMappedKey(member, environment, substitutions),
+		);
+	}
+	if (unwrapped.type !== "TSTypeReference") return false;
+	const name = typeReferenceName(unwrapped);
+	if (name === null) return false;
+	const substitution = substitutions.get(name);
+	if (substitution !== undefined && !isUnappliedReferenceTo(substitution, name)) {
+		return isBroadMappedKey(substitution, environment, substitutions);
+	}
+	return name === "PropertyKey" && isBuiltIn(name, environment);
+}
+
+function classifyAliasBroadTarget(
+	type: ESTree.TSType,
+	environment: TypeEnvironment,
+	substitutions: TypeAliasEnvironment,
+	resolvingAliases: ReadonlySet<string>,
+): WideningTarget | null {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return { kind: "unknown" };
+	if (unwrapped.type === "TSObjectKeyword") return { kind: "object" };
+	if (unwrapped.type === "TSTypeLiteral") {
+		return unwrapped.members.some((member) => member.type === "TSIndexSignature")
+			? { kind: "open dictionary" }
+			: null;
+	}
+	if (unwrapped.type === "TSMappedType") {
+		return isBroadMappedKey(unwrapped.constraint, environment, substitutions)
+			? { kind: "open dictionary" }
+			: null;
+	}
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName(unwrapped);
+	if (name === null) return null;
+	const substitution = substitutions.get(name);
+	if (substitution !== undefined) {
+		return isUnappliedReferenceTo(substitution, name)
+			? null
+			: classifyAliasBroadTarget(
+					substitution,
+					environment,
+					substitutions,
+					resolvingAliases,
+				);
+	}
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === undefined
+			? null
+			: classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases);
+	}
+	if (name === "Record" && isBuiltIn(name, environment)) {
+		return { kind: "open dictionary" };
+	}
+	const alias = environment.aliases.get(name);
+	if (alias === undefined || resolvingAliases.has(name)) return null;
+	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+	if (nextSubstitutions === null) return null;
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return classifyAliasBroadTarget(
+		alias.typeAnnotation,
+		environment,
+		nextSubstitutions,
+		nextResolving,
+	);
+}
+
+export function isPopulatedObjectExpression(expression: ESTree.Expression): boolean {
+	let current = expression;
+	while (
+		current.type === "ParenthesizedExpression" ||
+		current.type === "TSAsExpression" ||
+		current.type === "TSTypeAssertion" ||
+		current.type === "TSNonNullExpression"
+	) {
+		current = current.expression;
+	}
+	return current.type === "ObjectExpression" && current.properties.length > 0;
+}
+
+export function isKnownEvidenceExpression(expression: ESTree.Expression): boolean {
+	let current = expression;
+	while (
+		current.type === "ParenthesizedExpression" ||
+		current.type === "TSAsExpression" ||
+		current.type === "TSTypeAssertion" ||
+		current.type === "TSNonNullExpression" ||
+		current.type === "TSSatisfiesExpression"
+	) {
+		current = current.expression;
+	}
+	if (current.type === "ObjectExpression") return true;
+	return (
+		current.type === "ArrayExpression" ||
+		current.type === "ArrowFunctionExpression" ||
+		current.type === "ClassExpression" ||
+		current.type === "FunctionExpression" ||
+		current.type === "NewExpression" ||
+		current.type === "Literal" ||
+		current.type === "TemplateLiteral" ||
+		current.type === "UnaryExpression"
+	);
+}
diff --git a/tools/oxlint/anti-slop/shared/lexical-type-parameters.ts b/tools/oxlint/anti-slop/shared/lexical-type-parameters.ts
new file mode 100644
index 0000000..7cdb18c
--- /dev/null
+++ b/tools/oxlint/anti-slop/shared/lexical-type-parameters.ts
@@ -0,0 +1,61 @@
+import type { ESTree } from "@oxlint/plugins";
+
+type VisitorKeys = Readonly<Record<string, readonly string[]>>;
+
+function isNode(value: unknown): value is ESTree.Node {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"type" in value &&
+		typeof value.type === "string"
+	);
+}
+
+function collectInferTypeParameterNames(
+	node: ESTree.Node,
+	visitorKeys: VisitorKeys,
+	names: Set<string>,
+): void {
+	if (node.type === "TSInferType") names.add(node.typeParameter.name.name);
+	const record = node as unknown as Readonly<Record<string, unknown>>;
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = record[key];
+		if (isNode(value)) {
+			collectInferTypeParameterNames(value, visitorKeys, names);
+			continue;
+		}
+		if (!Array.isArray(value)) continue;
+		for (const child of value) {
+			if (isNode(child)) collectInferTypeParameterNames(child, visitorKeys, names);
+		}
+	}
+}
+
+/** Collect type binders that are in scope at a node and can shadow module aliases. */
+export function lexicalTypeParameterNames(
+	node: ESTree.Node,
+	visitorKeys: VisitorKeys,
+): ReadonlySet<string> {
+	const names = new Set<string>();
+	let descendant: ESTree.Node = node;
+	let current: ESTree.Node | null = node;
+	while (current !== null && current.type !== "Program") {
+		if ("typeParameters" in current) {
+			for (const parameter of current.typeParameters?.params ?? []) {
+				names.add(parameter.name.name);
+			}
+		}
+		if (
+			current.type === "TSMappedType" &&
+			(descendant === current.nameType || descendant === current.typeAnnotation)
+		) {
+			names.add(current.key.name);
+		}
+		if (current.type === "TSConditionalType" && descendant === current.trueType) {
+			collectInferTypeParameterNames(current.extendsType, visitorKeys, names);
+		}
+		descendant = current;
+		current = current.parent;
+	}
+	return names;
+}
diff --git a/tools/oxlint/anti-slop/shared/reflect-method.ts b/tools/oxlint/anti-slop/shared/reflect-method.ts
new file mode 100644
index 0000000..39bc218
--- /dev/null
+++ b/tools/oxlint/anti-slop/shared/reflect-method.ts
@@ -0,0 +1,35 @@
+import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
+
+function resolveVariable(
+  sourceCode: SourceCode,
+  identifier: ESTree.IdentifierReference,
+): Variable | null {
+  let scope: Scope | null = sourceCode.getScope(identifier);
+  while (scope !== null) {
+    const variable = scope.set.get(identifier.name);
+    if (variable !== undefined) return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+
+function isGlobalReflect(sourceCode: SourceCode, expression: ESTree.Expression): boolean {
+  if (expression.type !== "Identifier" || expression.name !== "Reflect") return false;
+  if (sourceCode.isGlobalReference(expression)) return true;
+  const variable = resolveVariable(sourceCode, expression);
+  return variable === null || variable.defs.length === 0;
+}
+
+/** Reports whether a call target names one method on the global Reflect object. */
+export function isGlobalReflectMethodCall(
+  sourceCode: SourceCode,
+  callee: ESTree.Expression,
+  methodName: string,
+): boolean {
+  if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
+  if (!isGlobalReflect(sourceCode, callee.object)) return false;
+  const property = callee.property;
+  return callee.computed
+    ? property.type === "Literal" && property.value === methodName
+    : property.type === "Identifier" && property.name === methodName;
+}
diff --git a/vite.config.ts b/vite.config.ts
index a4c1d7b..d0609af 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -15,11 +15,24 @@ export default defineConfig({
   ],
   fmt: {
     ignorePatterns: [
+      '.agent/**',
+      '.agents/**',
+      '.claude/**',
+      '.codex/**',
+      '.continue/**',
+      '.cursor/**',
+      '.gemini/**',
+      '.opencode/**',
+      '.pi/**',
+      '.roo/**',
+      '.superconductor/**',
       '.vscode/**',
+      '.windsurf/**',
       'build/**',
       'dist/**',
       'node_modules/**',
       'src/assets/**',
+      'tools/oxlint/anti-slop/**',
       'worker-configuration.d.ts',
     ],
     bracketSpacing: false,
@@ -28,7 +41,42 @@ export default defineConfig({
     singleQuote: true,
   },
   lint: {
-    ignorePatterns: ['build/**', 'dist/**', 'node_modules/**'],
+    ignorePatterns: [
+      '.agent/**',
+      '.agents/**',
+      '.claude/**',
+      '.codex/**',
+      '.continue/**',
+      '.cursor/**',
+      '.gemini/**',
+      '.opencode/**',
+      '.pi/**',
+      '.roo/**',
+      '.superconductor/**',
+      '.windsurf/**',
+      'build/**',
+      'dist/**',
+      'node_modules/**',
+      'tools/oxlint/anti-slop/**',
+    ],
+    jsPlugins: [{name: 'anti-slop', specifier: './tools/oxlint/anti-slop/index.ts'}],
+    rules: {
+      'anti-slop/no-chained-type-assertions': 'error',
+      'anti-slop/no-conditional-empty-object-spread': 'error',
+      'anti-slop/no-known-value-widening': 'error',
+      'anti-slop/no-module-mocking': 'error',
+      'anti-slop/no-object-parameters': 'error',
+      'anti-slop/no-reflect-apply': 'error',
+      'anti-slop/no-reflect-get': 'error',
+      'anti-slop/no-runtime-typeof': 'error',
+      'anti-slop/no-shape-in-symbol-names': 'error',
+      'anti-slop/no-unknown-parameters': 'error',
+      'anti-slop/no-unknown-returns': 'error',
+      'anti-slop/no-unknown-type-aliases': 'error',
+      'anti-slop/no-unsafe-dictionary-type': 'error',
+      'anti-slop/no-widen-then-assert': 'error',
+      'anti-slop/require-safety-comment-for-type-assertion': 'error',
+    },
     options: {
       typeAware: true,
       typeCheck: true,