diff --git a/packages/solid/test/mutable.spec.ts b/packages/solid/test/mutable.spec.ts
index 6c743668d..6866ec544 100644
--- a/packages/solid/test/mutable.spec.ts
+++ b/packages/solid/test/mutable.spec.ts
@@ -95,7 +95,7 @@ describe("Simple update modes", () => {
 
 describe("Unwrapping Edge Cases", () => {
   test("Unwrap nested frozen state object", () => {
-    var state = createMutable({
+    const state = createMutable({
         data: Object.freeze({ user: { firstName: "John", lastName: "Snow" } })
       }),
       s = unwrap({ ...state });
@@ -105,7 +105,7 @@ describe("Unwrapping Edge Cases", () => {
     expect(s.data.user[$RAW]).toBeUndefined();
   });
   test("Unwrap nested frozen array", () => {
-    var state = createMutable({
+    const state = createMutable({
         data: [{ user: { firstName: "John", lastName: "Snow" } }]
       }),
       s = unwrap({ data: state.data.slice(0) });
@@ -115,7 +115,7 @@ describe("Unwrapping Edge Cases", () => {
     expect(s.data[0].user[$RAW]).toBeUndefined();
   });
   test("Unwrap nested frozen state array", () => {
-    var state = createMutable({
+    const state = createMutable({
         data: Object.freeze([{ user: { firstName: "John", lastName: "Snow" } }])
       }),
       s = unwrap({ ...state });
@@ -129,8 +129,8 @@ describe("Unwrapping Edge Cases", () => {
 describe("Tracking State changes", () => {
   test("Track a state change", () => {
     createRoot(() => {
-      var state = createMutable({ data: 2 }),
-        executionCount = 0;
+      const state = createMutable({ data: 2 })
+      let executionCount = 0;
 
       expect.assertions(2);
       createComputed(() => {
@@ -152,10 +152,10 @@ describe("Tracking State changes", () => {
 
   test("Track a nested state change", () => {
     createRoot(() => {
-      var state = createMutable({
+      const state = createMutable({
           user: { firstName: "John", lastName: "Smith" }
-        }),
-        executionCount = 0;
+        })
+      let executionCount = 0;
 
       expect.assertions(2);
       createComputed(() => {
@@ -178,7 +178,7 @@ describe("Tracking State changes", () => {
 describe("Handling functions in state", () => {
   test("Array Native Methods: Array.Filter", () => {
     createRoot(() => {
-      var state = createMutable({ list: [0, 1, 2] }),
+      const state = createMutable({ list: [0, 1, 2] }),
         getFiltered = createMemo(() => state.list.filter(i => i % 2));
       expect(getFiltered()).toStrictEqual([1]);
     });
@@ -186,7 +186,7 @@ describe("Handling functions in state", () => {
 
   test("Track function change", () => {
     createRoot(() => {
-      var state = createMutable<{ fn: () => number }>({
+      const state = createMutable<{ fn: () => number }>({
           fn: () => 1
         }),
         getValue = createMemo(() => state.fn());
@@ -199,7 +199,7 @@ describe("Handling functions in state", () => {
 describe("Setting state from Effects", () => {
   test("Setting state from signal", () => {
     createRoot(() => {
-      var [getData, setData] = createSignal("init"),
+      const [getData, setData] = createSignal("init"),
         state = createMutable({ data: "" });
       createComputed(() => (state.data = getData()));
       setData("signal");
@@ -209,7 +209,7 @@ describe("Setting state from Effects", () => {
 
   test("Select Promise", done => {
     createRoot(async () => {
-      var p = new Promise<string>(resolve => {
+      const p = new Promise<string>(resolve => {
           setTimeout(resolve, 20, "promised");
         }),
         state = createMutable({ data: "" });
diff --git a/packages/solid/test/signals.memo.spec.ts b/packages/solid/test/signals.memo.spec.ts
index 0f4ad02e9..c0f14fb4c 100644
--- a/packages/solid/test/signals.memo.spec.ts
+++ b/packages/solid/test/signals.memo.spec.ts
@@ -4,9 +4,9 @@ describe("createMemo", () => {
   describe("executing propagating", () => {
     it("does not trigger downstream computations unless changed", () => {
       createRoot(() => {
-        let [s1, set] = createSignal(1, { equals: false });
+        const [s1, set] = createSignal(1, { equals: false });
         let order = "";
-        let t1 = createMemo(() => {
+        const t1 = createMemo(() => {
           order += "t1";
           return s1();
         });
@@ -26,9 +26,9 @@ describe("createMemo", () => {
 
     it("applies updates to changed dependees in same order as createComputed", () => {
       createRoot(() => {
-        let [s1, set] = createSignal(0);
+        const [s1, set] = createSignal(0);
         let order = "";
-        let t1 = createMemo(() => {
+        const t1 = createMemo(() => {
           order += "t1";
           return s1() === 0;
         });
@@ -50,10 +50,10 @@ describe("createMemo", () => {
 
     it("updates downstream pending computations", () => {
       createRoot(() => {
-        let [s1, set] = createSignal(0);
-        let [s2] = createSignal(0);
+        const [s1, set] = createSignal(0);
+        const [s2] = createSignal(0);
         let order = "";
-        let t1 = createMemo(() => {
+        const t1 = createMemo(() => {
           order += "t1";
           return s1() === 0;
         });
@@ -77,11 +77,11 @@ describe("createMemo", () => {
   });
 
   describe("with changing dependencies", () => {
-    var i: () => boolean, setI: (v: boolean) => void;
-    var t: () => number, setT: (v: number) => void;
-    var e: () => number, setE: (v: number) => void;
-    var fevals: number;
-    var f: () => number;
+    let i: () => boolean, setI: (v: boolean) => void;
+    let t: () => number, setT: (v: number) => void;
+    let e: () => number, setE: (v: number) => void;
+    let fevals: number;
+    let f: () => number;
 
     function init() {
       [i, setI] = createSignal<boolean>(true);
@@ -177,8 +177,8 @@ describe("createMemo", () => {
   describe("with intercepting computations", () => {
     it("does not update subsequent pending computations after stale invocations", () => {
       createRoot(() => {
-        let [s1, set1] = createSignal(1);
-        let [s2, set2] = createSignal(false);
+        const [s1, set1] = createSignal(1);
+        const [s2, set2] = createSignal(false);
         let count = 0;
         /*
                     s1
@@ -189,12 +189,12 @@ describe("createMemo", () => {
                    c3
              [PN,PN,STL,void]
         */
-        let t1 = createMemo(() => s1() > 0);
-        let t2 = createMemo(() => s1() > 0);
-        let c1 = createMemo(() => s1());
-        let t3 = createMemo(() => {
-          let a = s1();
-          let b = s2();
+        const t1 = createMemo(() => s1() > 0);
+        const t2 = createMemo(() => s1() > 0);
+        const c1 = createMemo(() => s1());
+        const t3 = createMemo(() => {
+          const a = s1();
+          const b = s2();
           return a && b;
         });
         createComputed(() => {
@@ -252,8 +252,8 @@ describe("createMemo", () => {
 
     it("evaluates nested trackings", () => {
       createRoot(() => {
-        let [s1, set1] = createSignal(1);
-        let [s2] = createSignal(1);
+        const [s1, set1] = createSignal(1);
+        const [s2] = createSignal(1);
         let count = 0;
         let c1: () => number;
         createMemo(() => {
@@ -271,13 +271,13 @@ describe("createMemo", () => {
 
     it("propagates in topological order", () => {
       createRoot(() => {
-        let [s1, set] = createSignal(true);
+        const [s1, set] = createSignal(true);
         let order = "";
-        let t1 = createMemo(() => {
+        const t1 = createMemo(() => {
           order += "t1";
           return s1();
         });
-        let t2 = createMemo(() => {
+        const t2 = createMemo(() => {
           order += "t2";
           return s1();
         });
@@ -294,7 +294,7 @@ describe("createMemo", () => {
 
     it("does not evaluate dependencies with tracking sources that have not changed", () => {
       createRoot(() => {
-        let [s1, set] = createSignal(1);
+        const [s1, set] = createSignal(1);
         let order = "";
         let c2: () => boolean;
         createComputed(() => {
@@ -303,11 +303,11 @@ describe("createMemo", () => {
             c2();
           }
         });
-        let t1 = createMemo(() => {
+        const t1 = createMemo(() => {
           order += "t1";
           return s1() < 3;
         });
-        let t2 = createMemo(() => {
+        const t2 = createMemo(() => {
           order += "t2";
           return t1();
         });
@@ -326,17 +326,17 @@ describe("createMemo", () => {
 
     it("correctly marks downstream computations as stale on change", () => {
       createRoot(() => {
-        let [s1, set] = createSignal(1);
+        const [s1, set] = createSignal(1);
         let order = "";
-        let t1 = createMemo(() => {
+        const t1 = createMemo(() => {
           order += "t1";
           return s1();
         });
-        let c1 = createMemo(() => {
+        const c1 = createMemo(() => {
           order += "c1";
           return t1();
         });
-        let c2 = createMemo(() => {
+        const c2 = createMemo(() => {
           order += "c2";
           return c1();
         });
@@ -354,7 +354,7 @@ describe("createMemo", () => {
   describe("with unending changes", () => {
     it("throws when continually setting a direct dependency", () => {
       createRoot(() => {
-        var [d, set] = createSignal(1);
+        const [d, set] = createSignal(1);
 
         expect(() => {
           createMemo(() => {
@@ -367,7 +367,7 @@ describe("createMemo", () => {
     it("throws when continually setting an indirect dependency", () => {
       createRoot(() => {
         let i = 2;
-        var [d, set] = createSignal(1),
+        const [d, set] = createSignal(1),
           f1 = createMemo(() => d()),
           f2 = createMemo(() => f1()),
           f3 = createMemo(() => f2());
diff --git a/packages/solid/test/state.spec.ts b/packages/solid/test/state.spec.ts
index efc24d2fa..8bd9e1e2d 100644
--- a/packages/solid/test/state.spec.ts
+++ b/packages/solid/test/state.spec.ts
@@ -153,7 +153,7 @@ describe("Array setState modes", () => {
 
 describe("Unwrapping Edge Cases", () => {
   test("Unwrap nested frozen state object", () => {
-    var [state] = createState({
+    const [state] = createState({
         data: Object.freeze({ user: { firstName: "John", lastName: "Snow" } })
       }),
       s = unwrap({ ...state });
@@ -163,7 +163,7 @@ describe("Unwrapping Edge Cases", () => {
     expect(s.data.user[$RAW]).toBeUndefined();
   });
   test("Unwrap nested frozen array", () => {
-    var [state] = createState({
+    const [state] = createState({
         data: [{ user: { firstName: "John", lastName: "Snow" } }]
       }),
       s = unwrap({ data: state.data.slice(0) });
@@ -173,7 +173,7 @@ describe("Unwrapping Edge Cases", () => {
     expect(s.data[0].user[$RAW]).toBeUndefined();
   });
   test("Unwrap nested frozen state array", () => {
-    var [state] = createState({
+    const [state] = createState({
         data: Object.freeze([{ user: { firstName: "John", lastName: "Snow" } }])
       }),
       s = unwrap({ ...state });
@@ -187,8 +187,8 @@ describe("Unwrapping Edge Cases", () => {
 describe("Tracking State changes", () => {
   test("Track a state change", () => {
     createRoot(() => {
-      var [state, setState] = createState({ data: 2 }),
-        executionCount = 0;
+      const [state, setState] = createState({ data: 2 });
+      let executionCount = 0;
 
       expect.assertions(2);
       createComputed(() => {
@@ -211,10 +211,10 @@ describe("Tracking State changes", () => {
 
   test("Track a nested state change", () => {
     createRoot(() => {
-      var [state, setState] = createState({
+      const [state, setState] = createState({
           user: { firstName: "John", lastName: "Smith" }
-        }),
-        executionCount = 0;
+        });
+      let executionCount = 0;
 
       expect.assertions(2);
       createComputed(() => {
@@ -235,8 +235,8 @@ describe("Tracking State changes", () => {
 
   test("Tracking Object key addition/removal", () => {
     createRoot(() => {
-      var [state, setState] = createState<{ obj: { item?: number } }>({ obj: {} }),
-        executionCount = 0;
+      const [state, setState] = createState<{ obj: { item?: number } }>({ obj: {} });
+      let executionCount = 0;
 
       createComputed(on(() => state.obj, (v) => {
         if (executionCount === 0) expect(v.item).toBeUndefined();
@@ -264,7 +264,7 @@ describe("Tracking State changes", () => {
 describe("Handling functions in state", () => {
   test("Array Native Methods: Array.Filter", () => {
     createRoot(() => {
-      var [state] = createState({ list: [0, 1, 2] }),
+      const [state] = createState({ list: [0, 1, 2] }),
         getFiltered = createMemo(() => state.list.filter(i => i % 2));
       expect(getFiltered()).toStrictEqual([1]);
     });
@@ -272,7 +272,7 @@ describe("Handling functions in state", () => {
 
   test("Track function change", () => {
     createRoot(() => {
-      var [state, setState] = createState<{ fn: () => number }>({
+      const [state, setState] = createState<{ fn: () => number }>({
           fn: () => 1
         }),
         getValue = createMemo(() => state.fn());
@@ -285,7 +285,7 @@ describe("Handling functions in state", () => {
 describe("Setting state from Effects", () => {
   test("Setting state from signal", () => {
     createRoot(() => {
-      var [getData, setData] = createSignal("init"),
+      const [getData, setData] = createSignal("init"),
         [state, setState] = createState({ data: "" });
       createComputed(() => setState("data", getData()));
       setData("signal");
@@ -295,10 +295,10 @@ describe("Setting state from Effects", () => {
 
   test("Select Promise", done => {
     createRoot(async () => {
-      var p = new Promise<string>(resolve => {
+      const p = new Promise<string>(resolve => {
           setTimeout(resolve, 20, "promised");
-        }),
-        [state, setState] = createState({ data: "" });
+        });
+      const [state, setState] = createState({ data: "" });
       p.then(v => setState("data", v));
       await p;
       expect(state.data).toBe("promised");
@@ -333,7 +333,7 @@ describe("Array length", () => {
     const [state, setState] = createState<{ list: number[] }>({ list: [] });
     let length;
     // isolate length tracking
-    let list = state.list;
+    const list = state.list;
     createRoot(() => {
       createComputed(() => {
         length = list.length;
@@ -348,7 +348,7 @@ describe("Array length", () => {
 
 describe("State recursion", () => {
   test("there is no infinite loop", () => {
-    let x: { a: number; b: any } = { a: 1, b: undefined };
+    const x: { a: number; b: any } = { a: 1, b: undefined };
     x.b = x;
 
     const [state, setState] = createState(x);
diff --git a/packages/solid/test/stateModifiers.spec.ts b/packages/solid/test/stateModifiers.spec.ts
index accc2ed19..b6e69973d 100644
--- a/packages/solid/test/stateModifiers.spec.ts
+++ b/packages/solid/test/stateModifiers.spec.ts
@@ -2,7 +2,7 @@ import { createState, reconcile, produce, unwrap } from "../src";
 
 describe("setState with reconcile", () => {
   test("Reconcile a simple object", () => {
-    var [state, setState] = createState({ data: 2, missing: "soon" });
+    const [state, setState] = createState({ data: 2, missing: "soon" });
     expect(state.data).toBe(2);
     expect(state.missing).toBe("soon");
     setState(reconcile({ data: 5 }));
@@ -11,7 +11,7 @@ describe("setState with reconcile", () => {
   });
 
   test("Reconcile a simple object on a nested path", () => {
-    var [state, setState] = createState({
+    const [state, setState] = createState({
       data: { user: { firstName: "John", middleName: "", lastName: "Snow" } }
     });
     expect(state.data.user.firstName).toBe("John");
@@ -23,7 +23,7 @@ describe("setState with reconcile", () => {
   });
 
   test("Reconcile a simple object on a nested path with no prev state", () => {
-    var [state, setState] = createState<{ user?: { firstName: string; middleName: string } }>({});
+    const [state, setState] = createState<{ user?: { firstName: string; middleName: string } }>({});
     expect(state.user).toBeUndefined();
     setState("user", reconcile({ firstName: "Jake", middleName: "R" }));
     expect(state.user!.firstName).toBe("Jake");
@@ -35,7 +35,7 @@ describe("setState with reconcile", () => {
       NED = { id: 2, firstName: "Ned", lastName: "Stark" },
       BRANDON = { id: 3, firstName: "Brandon", lastName: "Start" },
       ARYA = { id: 4, firstName: "Arya", lastName: "Start" };
-    var [state, setState] = createState({ users: [JOHN, NED, BRANDON] });
+    const [state, setState] = createState({ users: [JOHN, NED, BRANDON] });
     expect(Object.is(unwrap(state.users[0]), JOHN)).toBe(true);
     expect(Object.is(unwrap(state.users[1]), NED)).toBe(true);
     expect(Object.is(unwrap(state.users[2]), BRANDON)).toBe(true);
@@ -62,7 +62,7 @@ describe("setState with reconcile", () => {
     const JOHN = { id: 1, firstName: "John", lastName: "Snow" },
       NED = { id: 2, firstName: "Ned", lastName: "Stark" },
       BRANDON = { id: 3, firstName: "Brandon", lastName: "Start" };
-    var [state, setState] = createState({
+    const [state, setState] = createState({
       users: [{ ...JOHN }, { ...NED }, { ...BRANDON }]
     });
     expect(state.users[0].id).toBe(1);
diff --git a/packages/solid/web/test/suspense.spec.tsx b/packages/solid/web/test/suspense.spec.tsx
index 911278c9e..e2cf2d93f 100644
--- a/packages/solid/web/test/suspense.spec.tsx
+++ b/packages/solid/web/test/suspense.spec.tsx
@@ -9,7 +9,7 @@ describe("Testing Suspense", () => {
     [triggered, trigger] = createSignal(false);
   const LazyComponent = lazy<typeof ChildComponent>(() => new Promise(r => resolvers.push(r))),
     ChildComponent = (props: { greeting: string }) => {
-      let [value] = createResource<string, string>(
+      const [value] = createResource<string, string>(
         () =>  triggered() && "child",
         () => new Promise(r => setTimeout(() => r("Jo"), 300)),
         { initialValue: "" }