diff --git a/packages/hoppscotch-cli/src/__tests__/e2e/commands/test.spec.ts b/packages/hoppscotch-cli/src/__tests__/e2e/commands/test.spec.ts
index 050285d3..0eaca361 100644
--- a/packages/hoppscotch-cli/src/__tests__/e2e/commands/test.spec.ts
+++ b/packages/hoppscotch-cli/src/__tests__/e2e/commands/test.spec.ts
@@ -236,45 +236,55 @@ describe("hopp test [options] <file_path_or_id>", { timeout: 100000 }, () => {
       expect(stdout).not.toContain("https://example.com/path?foo=bar&baz=qux");
       expect(stdout).not.toContain("Encoded");
     });
-  });
 
-  test("Ensures tests run in sequence order based on request path", async () => {
-    // Expected order of collection runs
-    const expectedOrder = [
-      "root-collection-request",
-      "folder-1/folder-1-request",
-      "folder-1/folder-11/folder-11-request",
-      "folder-1/folder-12/folder-12-request",
-      "folder-1/folder-13/folder-13-request",
-      "folder-2/folder-2-request",
-      "folder-2/folder-21/folder-21-request",
-      "folder-2/folder-22/folder-22-request",
-      "folder-2/folder-23/folder-23-request",
-      "folder-3/folder-3-request",
-      "folder-3/folder-31/folder-31-request",
-      "folder-3/folder-32/folder-32-request",
-      "folder-3/folder-33/folder-33-request",
-    ];
+    test("Ensures tests run in sequence order based on request path", async () => {
+      // Expected order of collection runs
+      const expectedOrder = [
+        "root-collection-request",
+        "folder-1/folder-1-request",
+        "folder-1/folder-11/folder-11-request",
+        "folder-1/folder-12/folder-12-request",
+        "folder-1/folder-13/folder-13-request",
+        "folder-2/folder-2-request",
+        "folder-2/folder-21/folder-21-request",
+        "folder-2/folder-22/folder-22-request",
+        "folder-2/folder-23/folder-23-request",
+        "folder-3/folder-3-request",
+        "folder-3/folder-31/folder-31-request",
+        "folder-3/folder-32/folder-32-request",
+        "folder-3/folder-33/folder-33-request",
+      ];
 
-    const normalizePath = (path: string) => path.replace(/\\/g, "/");
+      const normalizePath = (path: string) => path.replace(/\\/g, "/");
 
-    const extractRunningOrder = (stdout: string): string[] =>
-      [...stdout.matchAll(/Running:.*?\/(.*?)\r?\n/g)].map(
-        ([, path]) => normalizePath(path.replace(/\x1b\[\d+m/g, "")) // Remove ANSI codes and normalize paths
-      );
+      const extractRunningOrder = (stdout: string): string[] =>
+        [...stdout.matchAll(/Running:.*?\/(.*?)\r?\n/g)].map(
+          ([, path]) => normalizePath(path.replace(/\x1b\[\d+m/g, "")) // Remove ANSI codes and normalize paths
+        );
 
-    const args = `test ${getTestJsonFilePath(
-      "multiple-child-collections-auth-headers-coll.json",
-      "collection"
-    )}`;
+      const args = `test ${getTestJsonFilePath(
+        "multiple-child-collections-auth-headers-coll.json",
+        "collection"
+      )}`;
 
-    const { stdout, error } = await runCLI(args);
+      const { stdout, error } = await runCLI(args);
 
-    // Verify the actual order matches the expected order
-    expect(extractRunningOrder(stdout)).toStrictEqual(expectedOrder);
+      // Verify the actual order matches the expected order
+      expect(extractRunningOrder(stdout)).toStrictEqual(expectedOrder);
 
-    // Ensure no errors occurred
-    expect(error).toBeNull();
+      // Ensure no errors occurred
+      expect(error).toBeNull();
+    });
+
+    test("Supports the new scripting API method additions under the `hopp` and `pm` namespaces", async () => {
+      const args = `test ${getTestJsonFilePath(
+        "scripting-revamp-coll.json",
+        "collection"
+      )}`;
+      const { error } = await runCLI(args);
+
+      expect(error).toBeNull();
+    });
   });
 
   describe("Test `hopp test <file_path_or_id> --env <file_path_or_id>` command:", () => {
diff --git a/packages/hoppscotch-cli/src/__tests__/e2e/fixtures/collections/scripting-revamp-coll.json b/packages/hoppscotch-cli/src/__tests__/e2e/fixtures/collections/scripting-revamp-coll.json
new file mode 100644
index 00000000..bce7446f
--- /dev/null
+++ b/packages/hoppscotch-cli/src/__tests__/e2e/fixtures/collections/scripting-revamp-coll.json
@@ -0,0 +1,255 @@
+{
+  "id": "cmfhzf0oo0091qt0iu8yy94rw",
+  "_ref_id": "coll_mfhz1cx0_5ae46b4c-d9d4-4ef8-92bc-af63525a73d7",
+  "v": 10,
+  "name": "scripting-revamp-coll",
+  "folders": [],
+  "requests": [
+    {
+      "v": "15",
+      "id": "cmfhzf0oo0092qt0if5rvd2g4",
+      "name": "json-response-test",
+      "method": "POST",
+      "endpoint": "https://echo.hoppscotch.io",
+      "params": [],
+      "headers": [
+        {
+          "key": "Test-Header",
+          "value": "test",
+          "active": true,
+          "description": "test header"
+        }
+      ],
+      "preRequestScript": "export {};\n",
+      "testScript": "export {};\nhopp.test(\"`hopp.response.body.asJSON()` parses response body as JSON\", () => {\n    const parsedData = JSON.parse(hopp.response.body.asJSON().data)\n\n    hopp.expect(parsedData.name).toBe('John Doe')\n    hopp.expect(parsedData.age).toBeType(\"number\")\n})\n\npm.test(\"`pm.response.json()` parses response body as JSON\", () => {\n    const parsedData = JSON.parse(pm.response.json().data)\n\n    pm.expect(parsedData.name).toBe('John Doe')\n    pm.expect(parsedData.age).toBeType(\"number\")\n})\n\nhopp.test(\"`hopp.response.body.asText()` parses response body as plain text\", () => {\n    const textResponse = hopp.response.body.asText()\n    hopp.expect(textResponse).toInclude('\\\"test-header\\\":\\\"test\\\"')\n})\n\npm.test(\"`pm.response.text()` parses response body as plain text\", () => {\n    const textResponse = pm.response.text()\n    pm.expect(textResponse).toInclude('\\\"test-header\\\":\\\"test\\\"')\n})\n\nhopp.test(\"hopp.response.bytes()` parses response body as raw bytes\", () => {\n    const rawResponse = hopp.response.body.bytes()\n\n    hopp.expect(rawResponse[0]).toBe(123)\n})\n\npm.test(\"pm.response.stream` parses response body as raw bytes\", () => {\n    const rawResponse = pm.response.stream\n\n    pm.expect(rawResponse[0]).toBe(123)\n})\n",
+      "auth": {
+        "authType": "inherit",
+        "authActive": true
+      },
+      "body": {
+        "contentType": "application/json",
+        "body": "{\n  \"name\": \"John Doe\",\n  \"age\": 35\n}"
+      },
+      "requestVariables": [],
+      "responses": {}
+    },
+    {
+      "v": "15",
+      "id": "cmfhzf0op0093qt0ictgoxymy",
+      "name": "html-response-test",
+      "method": "GET",
+      "endpoint": "https://hoppscotch.io",
+      "params": [],
+      "headers": [
+        {
+          "key": "Test-Header",
+          "value": "test",
+          "active": true,
+          "description": "Test header"
+        }
+      ],
+      "preRequestScript": "export {};\n",
+      "testScript": "export {};\nhopp.test(\"`hopp.response.asText()` parses response body as plain text\", () => {\n    const textResponse = hopp.response.body.asText()\n    hopp.expect(textResponse).toInclude(\"Open source API development ecosystem\")\n})\n\npm.test(\"`pm.response.text()` parses response body as plain text\", () => {\n    const textResponse = pm.response.text()\n    pm.expect(textResponse).toInclude(\"Open source API development ecosystem\")\n})\n\nhopp.test(\"`hopp.response.body.bytes()` parses response body as raw bytes\", () => {\n    const rawResponse = hopp.response.body.bytes()\n\n    hopp.expect(rawResponse[0]).toBe(60)\n})\n\npm.test(\"`pm.response.stream` parses response body as raw bytes\", () => {\n    const rawResponse = pm.response.stream\n\n    pm.expect(rawResponse[0]).toBe(60)\n})\n\n\n",
+      "auth": {
+        "authType": "inherit",
+        "authActive": true
+      },
+      "body": {
+        "contentType": null,
+        "body": null
+      },
+      "requestVariables": [],
+      "responses": {}
+    },
+    {
+      "v": "15",
+      "id": "cmfhzf0op0094qt0ixbo9rqnw",
+      "name": "environment-variables-test",
+      "method": "GET",
+      "endpoint": "https://echo.hoppscotch.io",
+      "params": [],
+      "headers": [],
+      "preRequestScript": "export {};\nhopp.env.set('test_key', 'test_value')\nhopp.env.set('recursive_key', '<<test_key>>')\nhopp.env.global.set('global_key', 'global_value')\nhopp.env.active.set('active_key', 'active_value')\n\n// `pm` namespace equivalents\npm.variables.set('pm_test_key', 'pm_test_value')\npm.environment.set('pm_active_key', 'pm_active_value')\npm.globals.set('pm_global_key', 'pm_global_value')\n",
+      "testScript": "export {};\n\nhopp.test('`hopp.env.get()` retrieves environment variables', () => {\n    const value = hopp.env.get('test_key')\n    hopp.expect(value).toBe('test_value')\n})\n\npm.test('`pm.variables.get()` retrieves environment variables', () => {\n    const value = pm.variables.get('test_key')\n    pm.expect(value).toBe('test_value')\n})\n\nhopp.test('`hopp.env.getRaw()` retrieves raw environment variables without resolution', () => {\n    const rawValue = hopp.env.getRaw('recursive_key')\n    hopp.expect(rawValue).toBe('<<test_key>>')\n})\n\nhopp.test('`hopp.env.get()` resolves recursive environment variables', () => {\n    const resolvedValue = hopp.env.get('recursive_key')\n    hopp.expect(resolvedValue).toBe('test_value')\n})\n\npm.test('`pm.variables.replaceIn()` resolves template variables', () => {\n    const resolved = pm.variables.replaceIn('Value is {{test_key}}')\n    pm.expect(resolved).toBe('Value is test_value')\n})\n\nhopp.test('`hopp.env.global.get()` retrieves global environment variables', () => {\n    const globalValue = hopp.env.global.get('global_key')\n\n    // `hopp.env.global` would be empty for the CLI\n    if (globalValue) {\n      hopp.expect(globalValue).toBe('global_value')\n    }\n})\n\npm.test('`pm.globals.get()` retrieves global environment variables', () => {\n    const globalValue = pm.globals.get('global_key')\n\n    // `pm.globals` would be empty for the CLI\n    if (globalValue) {\n        pm.expect(globalValue).toBe('global_value')\n    }\n})\n\nhopp.test('`hopp.env.active.get()` retrieves active environment variables', () => {\n    const activeValue = hopp.env.active.get('active_key')\n    hopp.expect(activeValue).toBe('active_value')\n})\n\npm.test('`pm.environment.get()` retrieves active environment variables', () => {\n    const activeValue = pm.environment.get('active_key')\n    pm.expect(activeValue).toBe('active_value')\n})\n\nhopp.test('Environment methods return null for non-existent keys', () => {\n    hopp.expect(hopp.env.get('non_existent')).toBe(null)\n    hopp.expect(hopp.env.getRaw('non_existent')).toBe(null)\n    hopp.expect(hopp.env.global.get('non_existent')).toBe(null)\n    hopp.expect(hopp.env.active.get('non_existent')).toBe(null)\n})\n\npm.test('`pm` environment methods handle non-existent keys correctly', () => {\n    pm.expect(pm.variables.get('non_existent')).toBe(null)\n    pm.expect(pm.environment.get('non_existent')).toBe(null)\n    pm.expect(pm.globals.get('non_existent')).toBe(null)\n    pm.expect(pm.variables.has('non_existent')).toBe(false)\n    pm.expect(pm.environment.has('non_existent')).toBe(false)\n    pm.expect(pm.globals.has('non_existent')).toBe(false)\n})\n\npm.test('`pm` variables set in pre-request script are accessible', () => {\n    pm.expect(pm.variables.get('pm_test_key')).toBe('pm_test_value')\n    pm.expect(pm.environment.get('pm_active_key')).toBe('pm_active_value')\n\n    const pmGlobalValue = hopp.env.global.get('pm_global_key')\n\n    // `hopp.env.global` would be empty for the CLI\n    if (pmGlobalValue) {\n      hopp.expect(pmGlobalValue).toBe('pm_global_value')\n    }\n})\n",
+      "auth": {
+        "authType": "inherit",
+        "authActive": true
+      },
+      "body": {
+        "contentType": null,
+        "body": null
+      },
+      "requestVariables": [],
+      "responses": {}
+    },
+    {
+      "v": "15",
+      "id": "cmfhzf0op0095qt0ieogkxx1w",
+      "name": "request-modification-test",
+      "method": "GET",
+      "endpoint": "https://echo.hoppscotch.io",
+      "params": [
+        {
+          "key": "original_param",
+          "value": "original-param",
+          "active": true,
+          "description": ""
+        }
+      ],
+      "headers": [
+        {
+          "key": "Original-Header",
+          "value": "original_value",
+          "active": true,
+          "description": ""
+        }
+      ],
+      "preRequestScript": "export {};\nhopp.request.setUrl('https://echo.hoppscotch.io/modified')\nhopp.request.setMethod('POST')\nhopp.request.setHeader('Modified-Header', 'modified_value')\nhopp.request.setParam('new_param', 'new_value')\n\nhopp.request.setBody({\n  contentType: 'application/json',\n  body: JSON.stringify({ modified: true, timestamp: Date.now() })\n})\n\nhopp.request.setAuth({\n  authType: 'bearer',\n  token: 'test-bearer-token',\n  authActive: true\n})",
+      "testScript": "export {};\n\nhopp.test('Request URL was modified by pre-request script', () => {\n    hopp.expect(hopp.request.url).toInclude('/modified')\n    pm.expect(pm.request.url.toString()).toInclude('/modified')\n})\n\nhopp.test('Request method was modified by pre-request script', () => {\n    hopp.expect(hopp.request.method).toBe('POST')\n    pm.expect(pm.request.method).toBe('POST')\n})\n\nhopp.test('Request headers contain both original and modified headers', () => {\n    const headers = hopp.request.headers\n    const hasOriginal = headers.some(h => h.key === 'Original-Header')\n    const hasModified = headers.some(h => h.key === 'Modified-Header')\n    hopp.expect(hasOriginal).toBe(true)\n    hopp.expect(hasModified).toBe(true)\n})\n\npm.test('PM request headers can be accessed and checked', () => {\n    pm.expect(pm.request.headers.has('Original-Header')).toBe(true)\n    pm.expect(pm.request.headers.has('Modified-Header')).toBe(true)\n    pm.expect(pm.request.headers.get('Modified-Header')).toBe('modified_value')\n})\n\nhopp.test('Request parameters contain both original and new parameters', () => {\n    const params = hopp.request.params\n    const hasOriginal = params.some(p => p.key === 'original_param')\n    const hasNew = params.some(p => p.key === 'new_param')\n    hopp.expect(hasOriginal).toBe(true)\n    hopp.expect(hasNew).toBe(true)\n})\n\nhopp.test('Request body was modified by pre-request script', () => {\n    hopp.expect(hopp.request.body.contentType).toBe('application/json')\n    pm.expect(pm.request.body.contentType).toBe('application/json')\n    const bodyData = hopp.request.body\n\n    if (typeof bodyData.body === \"string\") {\n        hopp.expect(JSON.parse(bodyData.body).modified).toBe(true)\n        pm.expect(JSON.parse(bodyData.body).modified).toBe(true)\n    } else {\n        throw new Error(`Unexpected body type: ${bodyData.body}`)\n    }\n})\n\n\nhopp.test('Request auth was modified by pre-request script', () => {\n    const auth = hopp.request.auth\n\n    if (auth.authType === 'bearer') {\n        hopp.expect(auth.token).toBe('test-bearer-token')\n        pm.expect(auth.token).toBe('test-bearer-token')\n    } else {\n        throw new Error(`Unexpected auth type: ${auth.authType}`)\n    }\n\n    hopp.expect(auth.token).toBe('test-bearer-token')\n    pm.expect(auth.token).toBe('test-bearer-token')\n})\n\n",
+      "auth": {
+        "authType": "none",
+        "authActive": true
+      },
+      "body": {
+        "contentType": null,
+        "body": null
+      },
+      "requestVariables": [],
+      "responses": {}
+    },
+    {
+      "v": "15",
+      "id": "cmfhzf0op0096qt0i6wellfus",
+      "name": "response-parsing-test",
+      "method": "POST",
+      "endpoint": "https://echo.hoppscotch.io",
+      "params": [],
+      "headers": [
+        {
+          "key": "Content-Type",
+          "value": "application/json",
+          "active": true,
+          "description": ""
+        }
+      ],
+      "preRequestScript": "export {};\n",
+      "testScript": "export {};\n\nhopp.test('`hopp.response.statusCode` returns the response status code', () => {\n    hopp.expect(hopp.response.statusCode).toBe(200)\n})\n\npm.test('`pm.response.code` returns the response status code', () => {\n    pm.expect(pm.response.code).toBe(200)\n})\n\nhopp.test('`hopp.response.statusText` returns the response status text', () => {\n    hopp.expect(hopp.response.statusText).toBeType('string')\n})\n\npm.test('`pm.response.status` returns the response status text', () => {\n    pm.expect(pm.response.status).toBeType('string')\n})\n\nhopp.test('`hopp.response.headers` contains response headers', () => {\n    const { headers } = hopp.response\n\n    hopp.expect(headers).toBeType('object')\n    hopp.expect(headers.length > 0).toBe(true)\n})\n\npm.test('`pm.response.headers` contains response headers', () => {\n    const headersAll = pm.response.headers.all()\n    pm.expect(headersAll).toBeType('object')\n    pm.expect(Object.keys(headersAll).length > 0).toBe(true)\n})\n\nhopp.test('`hopp.response.responseTime` is a positive number', () => {\n    hopp.expect(hopp.response.responseTime).toBeType('number')\n    hopp.expect(hopp.response.responseTime > 0).toBe(true)\n})\n\npm.test('`pm.response.responseTime` is a positive number', () => {\n    pm.expect(pm.response.responseTime).toBeType('number')\n    pm.expect(pm.response.responseTime > 0).toBe(true)\n})\n\nhopp.test('`hopp.response.text()` returns response as text', () => {\n    const responseText = hopp.response.body.asText()\n    hopp.expect(responseText).toBeType('string')\n    hopp.expect(responseText.length > 0).toBe(true)\n})\n\npm.test('`pm.response.text()` returns response as text', () => {\n    const responseText = pm.response.text()\n    pm.expect(responseText).toBeType('string')\n    pm.expect(responseText.length > 0).toBe(true)\n})\n\nhopp.test('`hopp.response.json()` parses JSON response', () => {\n    const responseJSON = hopp.response.body.asJSON()\n    hopp.expect(responseJSON).toBeType('object')\n})\n\npm.test('`pm.response.json()` parses JSON response', () => {\n    const responseJSON = pm.response.json()\n    pm.expect(responseJSON).toBeType('object')\n})\n\n\nhopp.test('`hopp.response.bytes()` returns the raw response', () => {\n    const responseBuffer = hopp.response.body.bytes()\n    hopp.expect(responseBuffer).toBeType('object')\n    hopp.expect(responseBuffer.constructor.name).toBe('Object')\n})\n\npm.test('`pm.response.stream` returns the raw response', () => {\n    const responseBuffer = pm.response.stream\n    pm.expect(responseBuffer).toBeType('object')\n    pm.expect(responseBuffer.constructor.name).toBe('Object')\n})",
+      "auth": {
+        "authType": "inherit",
+        "authActive": true
+      },
+      "body": {
+        "contentType": "application/json",
+        "body": "{\n  \"test\": \"response parsing\",\n  \"timestamp\": \"{{$timestamp}}\",\n  \"data\": {\n    \"nested\": true,\n    \"value\": 42\n  }\n}"
+      },
+      "requestVariables": [],
+      "responses": {}
+    },
+    {
+      "v": "15",
+      "id": "cmfhzf0op0097qt0ia4wf0lej",
+      "name": "request-variables-test",
+      "method": "GET",
+      "endpoint": "https://echo.hoppscotch.io",
+      "params": [],
+      "headers": [],
+      "preRequestScript": "// Test request variables\nhopp.request.variables.set('dynamic_var', 'dynamic_value')\nhopp.request.variables.set('calculated_var', `timestamp_${Date.now()}`)",
+      "testScript": "export {};\n\nhopp.test('`hopp.request.variables.get()` retrieves request variables', () => {\n    const dynamicValue = hopp.request.variables.get('dynamic_var')\n    hopp.expect(dynamicValue).toBe('dynamic_value')\n})\n\nhopp.test('Request variables can store calculated values', () => {\n    const calculatedValue = hopp.request.variables.get('calculated_var')\n    hopp.expect(calculatedValue).toInclude('timestamp_')\n})\n\nhopp.test('Request variables return null for non-existent keys', () => {\n    const nonExistent = hopp.request.variables.get('non_existent_var')\n    hopp.expect(nonExistent).toBe(null)\n})\n\nhopp.test('Pre-defined request variables are accessible', () => {\n    const preDefinedVar = hopp.request.variables.get('req_var_1')\n    hopp.expect(preDefinedVar).toBe('request_variable_value')\n})",
+      "auth": {
+        "authType": "inherit",
+        "authActive": true
+      },
+      "body": {
+        "contentType": null,
+        "body": null
+      },
+      "requestVariables": [
+        {
+          "key": "req_var_1",
+          "value": "request_variable_value",
+          "active": true
+        },
+        {
+          "key": "dynamic_var",
+          "value": "dynamic_value",
+          "active": true
+        },
+        {
+          "key": "calculated_var",
+          "value": "timestamp_1757751657020",
+          "active": true
+        }
+      ],
+      "responses": {}
+    },
+    {
+      "v": "15",
+      "id": "cmfhzf0op0098qt0ii9fguj6e",
+      "name": "info-context-test",
+      "method": "GET",
+      "endpoint": "https://echo.hoppscotch.io",
+      "params": [],
+      "headers": [],
+      "preRequestScript": "export {};\n",
+      "testScript": "export {};\n\npm.test('`pm.info.eventName` indicates the script context', () => {\n    pm.expect(pm.info.eventName).toBe('post-request')\n})\n\npm.test('`pm.info.requestName` returns the request name', () => {\n    pm.expect(pm.info.requestName).toBe('info-context-test')\n})\n\npm.test('`pm.info.requestId` returns an optional request identifier', () => {\n    const requestId = pm.info.requestId\n    if (requestId) {\n      pm.expect(requestId).toBeType('string')\n      pm.expect(requestId?.length > 0).toBe(true)\n    } else {\n        pm.expect(requestId).toBe(undefined)\n    }\n})",
+      "auth": {
+        "authType": "inherit",
+        "authActive": true
+      },
+      "body": {
+        "contentType": null,
+        "body": null
+      },
+      "requestVariables": [],
+      "responses": {}
+    },
+    {
+      "v": "15",
+      "id": "cmfhzf0op0099qt0iamthw97r",
+      "name": "pm-namespace-additional-test",
+      "method": "GET",
+      "endpoint": "https://echo.hoppscotch.io",
+      "params": [],
+      "headers": [],
+      "preRequestScript": "export {};\n// Test `pm` namespace specific features\npm.environment.set('pm_pre_key', 'pm_pre_value')\npm.globals.set('pm_global_pre', 'pm_global_pre_value')\npm.variables.set('pm_var_pre', 'pm_var_pre_value')\n",
+      "testScript": "export {};\n\npm.test('`pm` namespace environment operations work correctly', () => {\n    // Test environment has() method\n    pm.expect(pm.environment.has('pm_pre_key')).toBe(true)\n    pm.expect(pm.environment.has('non_existent_key')).toBe(false)\n    \n    // Test globals has() method\n    const globalValue = pm.globals.has('pm_global_pre')\n    // `pm.globals` would be empty for the CLI\n    if (globalValue) {\n        pm.expect(pm.globals.has('pm_global_pre')).toBe(true)\n    }\n    \n    pm.expect(pm.globals.has('non_existent_global')).toBe(false)\n    \n    // Test variables has() method\n    pm.expect(pm.variables.has('pm_var_pre')).toBe(true)\n    pm.expect(pm.variables.has('non_existent_var')).toBe(false)\n})\n\npm.test('`pm` variables.replaceIn() handles template replacement', () => {\n    const template = 'Hello {{pm_pre_key}}, global: {{pm_global_pre}}'\n    const resolved = pm.variables.replaceIn(template)\n    pm.expect(resolved).toInclude('pm_pre_value')\n    pm.expect(resolved).toInclude('pm_global_pre_value')\n})\n\npm.test('`pm` request object provides URL as object with toString', () => {\n    const url = pm.request.url\n    pm.expect(url.toString()).toBeType('string')\n    pm.expect(url.toString()).toInclude('echo.hoppscotch.io')\n})\n\npm.test('`pm` request headers object methods work correctly', () => {\n    // Test headers.all() returns object\n    const allHeaders = pm.request.headers.all()\n    pm.expect(allHeaders).toBeType('object')\n    \n    // Test headers.has() and headers.get() methods\n    if (Object.keys(allHeaders).length > 0) {\n        const firstHeaderKey = Object.keys(allHeaders)[0]\n        pm.expect(pm.request.headers.has(firstHeaderKey)).toBe(true)\n        pm.expect(pm.request.headers.get(firstHeaderKey)).toBeType('string')\n    }\n    \n    // Test non-existent header\n    pm.expect(pm.request.headers.has('non-existent-header')).toBe(false)\n    pm.expect(pm.request.headers.get('non-existent-header')).toBe(null)\n})\n\npm.test('`pm` response headers work correctly', () => {\n    // Test response headers all() method\n    const allResponseHeaders = pm.response.headers.all()\n    pm.expect(allResponseHeaders).toBeType('object')\n    \n    // Test headers has() and get() for common headers\n    if (Object.keys(allResponseHeaders).length > 0) {\n        const firstKey = Object.keys(allResponseHeaders)[0]\n        pm.expect(pm.response.headers.has(firstKey)).toBe(true)\n        pm.expect(pm.response.headers.get(firstKey)).toBeType('string')\n    }\n})\n",
+      "auth": {
+        "authType": "inherit",
+        "authActive": true
+      },
+      "body": {
+        "contentType": null,
+        "body": null
+      },
+      "requestVariables": [],
+      "responses": {}
+    },
+    {
+      "v": "15",
+      "id": "cmfhzf0op009aqt0inw3j6dq9",
+      "name": "expectation-methods-test",
+      "method": "POST",
+      "endpoint": "https://echo.hoppscotch.io",
+      "params": [],
+      "headers": [],
+      "preRequestScript": "export {};\n",
+      "testScript": "export {};\n\nhopp.test('Basic equality expectations work correctly', () => {\n    hopp.expect(1).toBe(1)\n    hopp.expect('test').toBe('test')\n    hopp.expect(true).toBe(true)\n    hopp.expect(null).toBe(null)\n})\n\npm.test('`pm` basic equality expectations work correctly', () => {\n    pm.expect(1).toBe(1)\n    pm.expect('test').toBe('test')\n    pm.expect(true).toBe(true)\n    pm.expect(null).toBe(null)\n})\n\nhopp.test('Type checking expectations work correctly', () => {\n    hopp.expect(42).toBeType('number')\n    hopp.expect('hello').toBeType('string')\n    hopp.expect(true).toBeType('boolean')\n    hopp.expect({}).toBeType('object')\n    hopp.expect([]).toBeType('object')\n})\n\npm.test('`pm` type checking expectations work correctly', () => {\n    pm.expect(42).toBeType('number')\n    pm.expect('hello').toBeType('string')\n    pm.expect(true).toBeType('boolean')\n    pm.expect({}).toBeType('object')\n    pm.expect([]).toBeType('object')\n})\n\n\nhopp.test('String and array inclusion expectations work correctly', () => {\n    hopp.expect('hello world').toInclude('world')\n    hopp.expect([1, 2, 3]).toInclude(2)\n})\n\npm.test('`pm` string and array inclusion expectations work correctly', () => {\n    pm.expect('hello world').toInclude('world')\n    pm.expect([1, 2, 3]).toInclude(2)\n})\n\n\nhopp.test('Length expectations work correctly', () => {\n    hopp.expect('hello').toHaveLength(5)\n    hopp.expect([1, 2, 3]).toHaveLength(3)\n})\n\npm.test('`pm` length expectations work correctly', () => {\n    pm.expect('hello').toHaveLength(5)\n    pm.expect([1, 2, 3]).toHaveLength(3)\n})\n\nhopp.test('Response-based expectations work correctly', () => {\n    const responseData = hopp.response.body.asJSON()\n    hopp.expect(responseData).toBeType('object')\n    hopp.expect(hopp.response.statusCode).toBe(200)\n})\n\npm.test('`pm` response-based expectations work correctly', () => {\n    const responseData = pm.response.json()\n    pm.expect(responseData).toBeType('object')\n    pm.expect(pm.response.code).toBe(200)\n})",
+      "auth": {
+        "authType": "inherit",
+        "authActive": true
+      },
+      "body": {
+        "contentType": "application/json",
+        "body": "{\n  \"message\": \"Test expectation methods\",\n  \"numbers\": [1, 2, 3, 4, 5],\n  \"metadata\": {\n    \"timestamp\": \"{{$timestamp}}\",\n    \"test\": true\n  }\n}"
+      },
+      "requestVariables": [],
+      "responses": {}
+    }
+  ],
+  "auth": {
+    "authType": "none",
+    "authActive": true
+  },
+  "headers": [],
+  "variables": []
+}
diff --git a/packages/hoppscotch-cli/src/interfaces/response.ts b/packages/hoppscotch-cli/src/interfaces/response.ts
index 7c32e912..2ce16f21 100644
--- a/packages/hoppscotch-cli/src/interfaces/response.ts
+++ b/packages/hoppscotch-cli/src/interfaces/response.ts
@@ -2,6 +2,7 @@ import { TestResponse } from "@hoppscotch/js-sandbox";
 import { Method } from "axios";
 import { ExpectResult } from "../types/response";
 import { HoppEnvs } from "../types/request";
+import { HoppRESTRequest } from "@hoppscotch/data";
 
 /**
  * Defines column headers for table stream used to write table
@@ -34,13 +35,13 @@ export interface RequestRunnerResponse extends TestResponse {
 
 /**
  * Describes test script details.
- * @property {string} name Request name within collection.
- * @property {string} testScript Stringified hoppscotch testScript, used while
- * running testRunner.
+ * @property {HoppRESTRequest} request Supplied request.
  * @property {TestResponse} response Response structure for test script runner.
+ * @property {HoppEnvs} envs Environment variables for test script runner.
+ * @property {boolean} legacySandbox Whether to use the legacy sandbox.
  */
 export interface TestScriptParams {
-  testScript: string;
+  request: HoppRESTRequest;
   response: TestResponse;
   envs: HoppEnvs;
   legacySandbox: boolean;
diff --git a/packages/hoppscotch-cli/src/utils/pre-request.ts b/packages/hoppscotch-cli/src/utils/pre-request.ts
index 4837ff6f..40cbeb54 100644
--- a/packages/hoppscotch-cli/src/utils/pre-request.ts
+++ b/packages/hoppscotch-cli/src/utils/pre-request.ts
@@ -58,21 +58,37 @@ export const preRequestScriptRunner = (
   return pipe(
     TE.of(request),
     TE.chain(({ preRequestScript }) =>
-      runPreRequestScript(preRequestScript, envs, experimentalScriptingSandbox)
+      runPreRequestScript(preRequestScript, {
+        envs,
+        experimentalScriptingSandbox,
+        request,
+        cookies: null,
+      })
     ),
-    TE.map(
-      ({ selected, global }) =>
-        <Environment>{
+    TE.map(({ updatedEnvs, updatedRequest }) => {
+      const { selected, global } = updatedEnvs;
+
+      return {
+        updatedEnvs: <Environment>{
           name: "Env",
           variables: [...(selected ?? []), ...(global ?? [])],
-        }
-    ),
-    TE.chainW((env) =>
-      TE.tryCatch(
-        () => getEffectiveRESTRequest(request, env, collectionVariables),
+        },
+        updatedRequest: updatedRequest ?? {},
+      };
+    }),
+    TE.chainW(({ updatedEnvs, updatedRequest }) => {
+      const finalRequest = { ...request, ...updatedRequest };
+
+      return TE.tryCatch(
+        () =>
+          getEffectiveRESTRequest(
+            finalRequest,
+            updatedEnvs,
+            collectionVariables
+          ),
         (reason) => error({ code: "PRE_REQUEST_SCRIPT_ERROR", data: reason })
-      )
-    ),
+      );
+    }),
     TE.chainEitherKW((effectiveRequest) => effectiveRequest),
     TE.mapLeft((reason) =>
       isHoppCLIError(reason)
@@ -515,7 +531,7 @@ function getFinalBodyFromRequest(
       // we split array blobs into separate entries (FormData will then join them together during exec)
       arrayFlatMap((x) =>
         x.isFile
-          ? x.value.map((v) => ({
+          ? (x.value as (Blob | null)[]).map((v: Blob | null) => ({
               key: parseTemplateString(x.key, resolvedVariables),
               value: v as string | Blob,
               contentType: x.contentType,
diff --git a/packages/hoppscotch-cli/src/utils/request.ts b/packages/hoppscotch-cli/src/utils/request.ts
index 4f1611f2..9f2c866d 100644
--- a/packages/hoppscotch-cli/src/utils/request.ts
+++ b/packages/hoppscotch-cli/src/utils/request.ts
@@ -111,25 +111,39 @@ export const requestRunner =
       // NOTE: Temporary parsing check for request endpoint.
       requestConfig.url = new URL(requestConfig.url ?? "").toString();
 
-      let status: number;
       const baseResponse = await axios(requestConfig);
       const { config } = baseResponse;
-      // PR-COMMENT: type error
-      const runnerResponse: RequestRunnerResponse = {
-        ...baseResponse,
-        endpoint: getRequest.endpoint(config.url),
-        method: getRequest.method(config.method),
-        body: baseResponse.data,
-        duration: 0,
-      };
 
       const end = hrtime(start);
       const duration = getDurationInSeconds(end);
-      runnerResponse.duration = duration;
+      const responseTime = duration * 1000; // Convert seconds to milliseconds
+
+      // Transform axios headers to required format
+      const transformedHeaders: { key: string; value: string }[] = [];
+      if (baseResponse.headers) {
+        for (const [key, value] of Object.entries(baseResponse.headers)) {
+          if (value !== undefined) {
+            transformedHeaders.push({
+              key,
+              value: Array.isArray(value) ? value.join(", ") : String(value),
+            });
+          }
+        }
+      }
+
+      const runnerResponse: RequestRunnerResponse = {
+        endpoint: getRequest.endpoint(config.url),
+        method: getRequest.method(config.method),
+        body: baseResponse.data,
+        responseTime,
+        duration: duration,
+        status: baseResponse.status,
+        statusText: baseResponse.statusText,
+        headers: transformedHeaders,
+      };
 
       return E.right(runnerResponse);
     } catch (e) {
-      let status: number;
       const runnerResponse: RequestRunnerResponse = {
         endpoint: "",
         method: "GET",
@@ -138,6 +152,7 @@ export const requestRunner =
         status: 400,
         headers: [],
         duration: 0,
+        responseTime: 0,
       };
 
       if (axios.isAxiosError(e)) {
@@ -148,7 +163,22 @@ export const requestRunner =
           runnerResponse.body = data;
           runnerResponse.statusText = statusText;
           runnerResponse.status = status;
-          runnerResponse.headers = headers;
+
+          // Transform axios headers to required format
+          const transformedHeaders: { key: string; value: string }[] = [];
+          if (headers) {
+            for (const [key, value] of Object.entries(headers)) {
+              if (value !== undefined) {
+                transformedHeaders.push({
+                  key,
+                  value: Array.isArray(value)
+                    ? value.join(", ")
+                    : String(value),
+                });
+              }
+            }
+          }
+          runnerResponse.headers = transformedHeaders;
         } else if (e.request) {
           return E.left(error({ code: "REQUEST_ERROR", data: E.toError(e) }));
         }
@@ -237,7 +267,7 @@ export const processRequest =
     const preRequestRes = await preRequestScriptRunner(
       request,
       processedEnvs,
-      legacySandbox,
+      legacySandbox ?? false,
       collectionVariables
     )();
     if (E.isLeft(preRequestRes)) {
@@ -265,6 +295,7 @@ export const processRequest =
       headers: [],
       status: 400,
       statusText: "",
+      responseTime: 0,
       body: Object(null),
       duration: 0,
     };
@@ -289,9 +320,9 @@ export const processRequest =
     // Extracting test-script-runner parameters.
     const testScriptParams = getTestScriptParams(
       _requestRunnerRes,
-      request,
+      effectiveRequest,
       updatedEnvs,
-      legacySandbox
+      legacySandbox ?? false
     );
 
     // Executing test-runner.
diff --git a/packages/hoppscotch-cli/src/utils/test.ts b/packages/hoppscotch-cli/src/utils/test.ts
index 69815952..e20426f9 100644
--- a/packages/hoppscotch-cli/src/utils/test.ts
+++ b/packages/hoppscotch-cli/src/utils/test.ts
@@ -37,14 +37,25 @@ export const testRunner = (
     TE.bind("test_response", () =>
       pipe(
         TE.of(testScriptData),
-        TE.chain(({ testScript, response, envs, legacySandbox }) => {
+        TE.chain(({ request, response, envs, legacySandbox }) => {
+          const { status, statusText, headers, responseTime, body } = response;
+
+          const effectiveResponse = {
+            status,
+            statusText,
+            headers,
+            responseTime,
+            body,
+          };
+
           const experimentalScriptingSandbox = !legacySandbox;
-          return runTestScript(
-            testScript,
+
+          return runTestScript(request.testScript, {
             envs,
-            response,
-            experimentalScriptingSandbox
-          );
+            request,
+            response: effectiveResponse,
+            experimentalScriptingSandbox,
+          });
         })
       )
     ),
@@ -147,10 +158,12 @@ export const getTestScriptParams = (
   legacySandbox: boolean
 ) => {
   const testScriptParams: TestScriptParams = {
-    testScript: request.testScript,
+    request,
     response: {
       body: reqRunnerRes.body,
       status: reqRunnerRes.status,
+      statusText: reqRunnerRes.statusText,
+      responseTime: reqRunnerRes.responseTime,
       headers: reqRunnerRes.headers,
     },
     envs,
diff --git a/packages/hoppscotch-common/src/components/MonacoScriptEditor.vue b/packages/hoppscotch-common/src/components/MonacoScriptEditor.vue
index 0545d564..c6b43d22 100644
--- a/packages/hoppscotch-common/src/components/MonacoScriptEditor.vue
+++ b/packages/hoppscotch-common/src/components/MonacoScriptEditor.vue
@@ -13,10 +13,14 @@ import { VueMonacoEditor } from "@guolao/vue-monaco-editor"
 import { watchDebounced } from "@vueuse/core"
 import * as monaco from "monaco-editor"
 import { v4 as uuidv4 } from "uuid"
-import { computed, onMounted, ref } from "vue"
+import { computed, onMounted, onUnmounted, ref } from "vue"
 
 import { useColorMode } from "~/composables/theming"
 
+// Import type definitions as raw strings
+import preRequestTypes from "~/types/pre-request.d.ts?raw"
+import postRequestTypes from "~/types/post-request.d.ts?raw"
+
 const props = withDefaults(
   defineProps<{
     modelValue: string
@@ -53,6 +57,9 @@ const typeDefCache = new Map<string, string>()
 
 const extraLibRefs = new Map<string, monaco.IDisposable>()
 
+// Track context-specific type definition for this editor instance
+const contextTypeDefRef = ref<monaco.IDisposable | null>(null)
+
 const MODULE_PREFIX = "export {};\n" as const
 
 const ensureCompilerOptions = (() => {
@@ -108,6 +115,28 @@ onMounted(() => {
     "typescript",
     scriptFileURI
   )
+
+  // Load context-specific type definitions for this editor instance
+  const typeDefContent =
+    props.type === "pre-request" ? preRequestTypes : postRequestTypes
+  const typeDefUri = `inmemory://types/${props.type}-${uuid}.d.ts`
+
+  contextTypeDefRef.value =
+    monaco.languages.typescript.typescriptDefaults.addExtraLib(
+      typeDefContent,
+      typeDefUri
+    )
+})
+
+onUnmounted(() => {
+  // Clean up context-specific type definitions for this editor instance
+  contextTypeDefRef.value?.dispose()
+
+  // Clean up all extra libs for this editor
+  for (const disposable of extraLibRefs.values()) {
+    disposable.dispose()
+  }
+  extraLibRefs.clear()
 })
 
 const value = computed({
diff --git a/packages/hoppscotch-common/src/components/cookies/AllModal.vue b/packages/hoppscotch-common/src/components/cookies/AllModal.vue
index c0086ea7..6b9fa3b6 100644
--- a/packages/hoppscotch-common/src/components/cookies/AllModal.vue
+++ b/packages/hoppscotch-common/src/components/cookies/AllModal.vue
@@ -52,7 +52,7 @@
             class="flex flex-col"
           >
             <div class="flex flex-1 items-center justify-between">
-              <label for="cookiesList" class="p-4">
+              <label class="p-4">
                 {{ domain }}
               </label>
               <div class="flex">
@@ -81,14 +81,20 @@
                 <template v-else>
                   <div
                     v-for="(entry, entryIndex) in entries"
-                    :key="`${entry}-${entryIndex}`"
-                    class="flex divide-x divide-dividerLight"
+                    :key="`${entry.name}-${entryIndex}`"
+                    class="flex w-full divide-x divide-dividerLight items-center"
                   >
                     <input
                       class="flex flex-1 bg-transparent px-4 py-2"
-                      :value="entry"
+                      :value="`${entry.name} => ${entry.value}`"
                       readonly
                     />
+                    <HoppButtonSecondary
+                      v-tippy="{ theme: 'tooltip' }"
+                      :title="t('action.copy')"
+                      :icon="IconCopy"
+                      @click="copyCookie(entry)"
+                    />
                     <HoppButtonSecondary
                       v-tippy="{ theme: 'tooltip' }"
                       :title="t('action.edit')"
@@ -145,10 +151,12 @@
 import { useI18n } from "@composables/i18n"
 import { useService } from "dioc/vue"
 import { CookieJarService } from "~/services/cookie-jar.service"
+import { Cookie } from "@hoppscotch/data"
 import IconTrash from "~icons/lucide/trash"
 import IconEdit from "~icons/lucide/edit"
 import IconTrash2 from "~icons/lucide/trash-2"
 import IconPlus from "~icons/lucide/plus"
+import IconCopy from "~icons/lucide/copy"
 import { cloneDeep } from "lodash-es"
 import { ref, watch, computed } from "vue"
 import { EditCookieConfig } from "./EditCookie.vue"
@@ -156,38 +164,29 @@ import { useColorMode } from "@composables/theming"
 import { useToast } from "@composables/toast"
 import { KernelInterceptorService } from "~/services/kernel-interceptor.service"
 
-const props = defineProps<{
-  show: boolean
-}>()
-
-const emit = defineEmits<{
-  (e: "hide-modal"): void
-}>()
+const props = defineProps<{ show: boolean }>()
+const emit = defineEmits<{ (e: "hide-modal"): void }>()
 
 const t = useI18n()
 const colorMode = useColorMode()
 const toast = useToast()
 
 const newDomainText = ref("")
-
 const interceptorService = useService(KernelInterceptorService)
 const cookieJarService = useService(CookieJarService)
 
 const workingCookieJar = ref(cloneDeep(cookieJarService.cookieJar.value))
 
 const currentInterceptorSupportsCookies = computed(() => {
-  const capabilities = interceptorService.current.value?.capabilities
-  const supportsCookies = capabilities["advanced"].has("cookies")
-
-  return supportsCookies ?? false
+  const caps = interceptorService.current.value?.capabilities
+  return caps?.advanced?.has("cookies") ?? false
 })
 
 function addNewDomain() {
-  if (newDomainText.value === "" || /^\s+$/.test(newDomainText.value)) {
+  if (newDomainText.value.trim() === "") {
     toast.error(`${t("cookies.modal.empty_domain")}`)
     return
   }
-
   workingCookieJar.value.set(newDomainText.value, [])
   newDomainText.value = ""
 }
@@ -225,7 +224,7 @@ function cancelCookieChanges() {
   hideModal()
 }
 
-function editCookie(domain: string, entryIndex: number, cookieEntry: string) {
+function editCookie(domain: string, entryIndex: number, cookieEntry: Cookie) {
   showEditModalFor.value = {
     type: "edit",
     domain,
@@ -236,35 +235,42 @@ function editCookie(domain: string, entryIndex: number, cookieEntry: string) {
 
 function deleteCookie(domain: string, entryIndex: number) {
   const entry = workingCookieJar.value.get(domain)
+  if (entry) entry.splice(entryIndex, 1)
+}
 
-  if (entry) {
-    entry.splice(entryIndex, 1)
+function saveCookie(value: string) {
+  if (showEditModalFor.value?.type === "create") {
+    const { domain } = showEditModalFor.value
+    const entry = workingCookieJar.value.get(domain)!
+
+    const name = `Cookie-${entry.length}`
+    entry.push(makeUICookie(domain, value, name))
+    showEditModalFor.value = null
+    return
+  }
+  if (showEditModalFor.value?.type === "edit") {
+    const { domain, entryIndex } = showEditModalFor.value
+    const entry = workingCookieJar.value.get(domain)
+    if (entry) entry[entryIndex].value = value
+    showEditModalFor.value = null
   }
 }
 
-function saveCookie(cookie: string) {
-  if (showEditModalFor.value?.type === "create") {
-    const { domain } = showEditModalFor.value
-
-    const entry = workingCookieJar.value.get(domain)!
-    entry.push(cookie)
-
-    showEditModalFor.value = null
-
-    return
+function makeUICookie(domain: string, value: string, name: string): Cookie {
+  return {
+    name,
+    value,
+    domain,
+    path: "/",
+    httpOnly: false,
+    secure: false,
+    sameSite: "Lax",
   }
+}
 
-  if (showEditModalFor.value?.type !== "edit") return
-
-  const { domain, entryIndex } = showEditModalFor.value!
-
-  const entry = workingCookieJar.value.get(domain)
-
-  if (entry) {
-    entry[entryIndex] = cookie
-  }
-
-  showEditModalFor.value = null
+function copyCookie(cookie: Cookie) {
+  navigator.clipboard.writeText(`${cookie.name}=${cookie.value}`)
+  toast.success(t("state.copied"))
 }
 
 const hideModal = () => {
diff --git a/packages/hoppscotch-common/src/components/cookies/EditCookie.vue b/packages/hoppscotch-common/src/components/cookies/EditCookie.vue
index bd9503e0..9e2413e4 100644
--- a/packages/hoppscotch-common/src/components/cookies/EditCookie.vue
+++ b/packages/hoppscotch-common/src/components/cookies/EditCookie.vue
@@ -84,7 +84,7 @@ export type EditCookieConfig =
       type: "edit"
       domain: string
       entryIndex: number
-      currentCookieEntry: string
+      currentCookieEntry: Cookie
     }
 </script>
 
@@ -104,6 +104,7 @@ import {
 } from "~/composables/lens-actions"
 import { useNestedSetting } from "~/composables/settings"
 import { toggleNestedSetting } from "~/newstore/settings"
+import { Cookie } from "@hoppscotch/data"
 
 // TODO: Build Managed Mode!
 
@@ -156,7 +157,7 @@ watch(
       return
     }
 
-    rawCookieString.value = props.entry.currentCookieEntry
+    rawCookieString.value = `${props.entry.currentCookieEntry.name}=${props.entry.currentCookieEntry.value}`
   }
 )
 
diff --git a/packages/hoppscotch-common/src/components/http/RequestOptions.vue b/packages/hoppscotch-common/src/components/http/RequestOptions.vue
index 27d3f748..02db0982 100644
--- a/packages/hoppscotch-common/src/components/http/RequestOptions.vue
+++ b/packages/hoppscotch-common/src/components/http/RequestOptions.vue
@@ -104,16 +104,12 @@ import {
   HoppRESTResponseOriginalRequest,
 } from "@hoppscotch/data"
 import { useVModel } from "@vueuse/core"
-import * as monaco from "monaco-editor"
-import { computed, onUnmounted, watch } from "vue"
+import { computed } from "vue"
 
 import { defineActionHandler } from "~/helpers/actions"
 import { HoppInheritedProperty } from "~/helpers/types/HoppInheritedProperties"
 import { AggregateEnvironment } from "~/newstore/environments"
 
-import postRequestPWModDefn from "~/types/post-request.d.ts?raw"
-import preRequestPWModDefn from "~/types/pre-request.d.ts?raw"
-
 const VALID_OPTION_TABS = [
   "params",
   "bodyParams",
@@ -150,36 +146,6 @@ const emit = defineEmits<{
 const request = useVModel(props, "modelValue", emit)
 const selectedOptionTab = useVModel(props, "optionTab", emit)
 
-let extraLibRef: monaco.IDisposable | null = null
-
-const libDefs = {
-  "pre-request": preRequestPWModDefn,
-  "post-request": postRequestPWModDefn,
-}
-
-const scriptEditorTabs = ["preRequestScript", "tests"]
-
-onUnmounted(() => extraLibRef?.dispose())
-
-watch(
-  () => selectedOptionTab.value,
-  (newTab) => {
-    if (!scriptEditorTabs.includes(newTab)) {
-      return
-    }
-
-    extraLibRef?.dispose()
-
-    monaco.languages.typescript.typescriptDefaults.setExtraLibs([])
-
-    extraLibRef = monaco.languages.typescript.typescriptDefaults.addExtraLib(
-      libDefs[newTab === "preRequestScript" ? "pre-request" : "post-request"],
-      `inmemory://lib/pw-${newTab}.d.ts`
-    )
-  },
-  { immediate: true }
-)
-
 const showPreRequestScriptTab = computed(() => {
   return (
     props.properties?.includes("preRequestScript") ??
diff --git a/packages/hoppscotch-common/src/helpers/RequestRunner.ts b/packages/hoppscotch-common/src/helpers/RequestRunner.ts
index 067a5483..da914d1d 100644
--- a/packages/hoppscotch-common/src/helpers/RequestRunner.ts
+++ b/packages/hoppscotch-common/src/helpers/RequestRunner.ts
@@ -1,6 +1,8 @@
 import {
+  Cookie,
   Environment,
   HoppCollectionVariable,
+  HoppRESTHeader,
   HoppRESTHeaders,
   HoppRESTRequest,
   HoppRESTRequestVariable,
@@ -22,7 +24,8 @@ import { Ref } from "vue"
 
 import { map } from "fp-ts/Either"
 
-import { runTestScript } from "@hoppscotch/js-sandbox/web"
+import { runPreRequestScript, runTestScript } from "@hoppscotch/js-sandbox/web"
+import { useSetting } from "~/composables/settings"
 import { getService } from "~/modules/dioc"
 import {
   environmentsStore,
@@ -32,6 +35,12 @@ import {
   setGlobalEnvVariables,
   updateEnvironment,
 } from "~/newstore/environments"
+import { platform } from "~/platform"
+import { CookieJarService } from "~/services/cookie-jar.service"
+import {
+  CurrentValueService,
+  Variable,
+} from "~/services/current-environment-value.service"
 import {
   SecretEnvironmentService,
   SecretVariable,
@@ -39,27 +48,21 @@ import {
 import { HoppTab } from "~/services/tab"
 import { updateTeamEnvironment } from "./backend/mutations/TeamEnvironment"
 import { createRESTNetworkRequestStream } from "./network"
-import { getFinalEnvsFromPreRequest } from "./preRequest"
 import { HoppRequestDocument } from "./rest/document"
 import {
   getTemporaryVariables,
   setTemporaryVariables,
 } from "./runner/temp_envs"
-import {
-  CurrentValueService,
-  Variable,
-} from "~/services/current-environment-value.service"
 import { HoppRESTResponse } from "./types/HoppRESTResponse"
 import { HoppTestData, HoppTestResult } from "./types/HoppTestResult"
 import { getEffectiveRESTRequest } from "./utils/EffectiveURL"
-import { isJSONContentType } from "./utils/contenttypes"
 import { getCombinedEnvVariables } from "./utils/environments"
-import { useSetting } from "~/composables/settings"
 import {
   OutgoingSandboxPostRequestWorkerMessage,
   OutgoingSandboxPreRequestWorkerMessage,
 } from "./workers/sandbox.worker"
 import { transformInheritedCollectionVariablesToAggregateEnv } from "./utils/inheritedCollectionVarTransformer"
+import { isJSONContentType } from "./utils/contenttypes"
 
 const sandboxWorker = new Worker(
   new URL("./workers/sandbox.worker.ts", import.meta.url),
@@ -70,6 +73,7 @@ const sandboxWorker = new Worker(
 
 const secretEnvironmentService = getService(SecretEnvironmentService)
 const currentEnvironmentValueService = getService(CurrentValueService)
+const cookieJarService = getService(CookieJarService)
 
 const EXPERIMENTAL_SCRIPTING_SANDBOX = useSetting(
   "EXPERIMENTAL_SCRIPTING_SANDBOX"
@@ -79,7 +83,7 @@ export const getTestableBody = (
   res: HoppRESTResponse & { type: "success" | "fail" }
 ) => {
   const contentTypeHeader = res.headers.find(
-    (h) => h.key.toLowerCase() === "content-type"
+    (h: HoppRESTHeader) => h.key.toLowerCase() === "content-type"
   )
 
   const rawBody = new TextDecoder("utf-8")
@@ -277,16 +281,22 @@ const filterNonEmptyEnvironmentVariables = (
   return Array.from(envsMap.values())
 }
 
-const runPreRequestScript = (
-  script: string,
+const delegatePreRequestScriptRunner = (
+  request: HoppRESTRequest,
   envs: {
     global: Environment["variables"]
     selected: Environment["variables"]
     temp: Environment["variables"]
-  }
+  },
+  cookies: Cookie[] | null
 ): Promise<E.Either<string, SandboxPreRequestResult>> => {
+  const { preRequestScript } = request
+
   if (!EXPERIMENTAL_SCRIPTING_SANDBOX.value) {
-    return getFinalEnvsFromPreRequest(script, envs, false)
+    return runPreRequestScript(preRequestScript, {
+      envs,
+      experimentalScriptingSandbox: false,
+    })
   }
 
   return new Promise((resolve) => {
@@ -313,19 +323,27 @@ const runPreRequestScript = (
 
     sandboxWorker.postMessage({
       type: "pre",
-      script,
       envs,
+      request: JSON.stringify(request),
+      cookies: cookies ? JSON.stringify(cookies) : null,
     })
   })
 }
 
 const runPostRequestScript = (
-  script: string,
   envs: TestResult["envs"],
-  response: HoppRESTResponse
+  request: HoppRESTRequest,
+  response: HoppRESTResponse,
+  cookies: Cookie[] | null
 ): Promise<E.Either<string, SandboxTestResult>> => {
+  const { testScript } = request
+
   if (!EXPERIMENTAL_SCRIPTING_SANDBOX.value) {
-    return runTestScript(script, envs, response, false)
+    return runTestScript(testScript, {
+      envs,
+      response,
+      experimentalScriptingSandbox: false,
+    })
   }
 
   return new Promise((resolve) => {
@@ -352,9 +370,10 @@ const runPostRequestScript = (
 
     sandboxWorker.postMessage({
       type: "post",
-      script,
       envs,
+      request: JSON.stringify(request),
       response,
+      cookies: cookies ? JSON.stringify(cookies) : null,
     })
   })
 }
@@ -376,9 +395,12 @@ export function runRESTRequest$(
     cancelFunc?.()
   }
 
-  const res = runPreRequestScript(
-    tab.value.document.request.preRequestScript,
-    getCombinedEnvVariables()
+  const cookieJarEntries = getCookieJarEntries()
+
+  const res = delegatePreRequestScriptRunner(
+    tab.value.document.request,
+    getCombinedEnvVariables(),
+    cookieJarEntries
   ).then(async (preRequestScriptResult) => {
     if (cancelCalled) return E.left("cancellation" as const)
 
@@ -441,10 +463,14 @@ export function runRESTRequest$(
       ...tab.value.document.request,
       auth: requestAuth ?? { authType: "none", authActive: false },
       headers: requestHeaders as HoppRESTHeaders,
+      ...(preRequestScriptResult.right.updatedRequest ?? {}),
     }
 
+    // Propagate changes to request variables from the scripting context to the UI
+    tab.value.document.request.requestVariables = finalRequest.requestVariables
+
     const finalEnvs = {
-      environments: preRequestScriptResult.right.envs,
+      environments: preRequestScriptResult.right.updatedEnvs,
       requestVariables: finalRequestVariables as Environment["variables"],
       collectionVariables,
     }
@@ -471,13 +497,16 @@ export function runRESTRequest$(
           executedResponses$.next(res)
 
           const postRequestScriptResult = await runPostRequestScript(
-            res.req.testScript,
-            preRequestScriptResult.right.envs,
+            preRequestScriptResult.right.updatedEnvs,
+            res.req,
             {
               status: res.statusCode,
               body: getTestableBody(res),
               headers: res.headers,
-            }
+              statusText: res.statusText,
+              responseTime: res.meta.responseDuration,
+            },
+            preRequestScriptResult.right.updatedCookies ?? null
           )
 
           if (E.isRight(postRequestScriptResult)) {
@@ -500,6 +529,24 @@ export function runRESTRequest$(
               combinedResult.right
             )
             updateEnvsAfterTestScript(combinedResult)
+
+            const updatedCookies = postRequestScriptResult.right.updatedCookies
+
+            if (updatedCookies) {
+              const newCookieMap = new Map<string, Cookie[]>()
+
+              for (const cookie of updatedCookies) {
+                const domain = cookie.domain
+
+                if (!newCookieMap.has(domain)) {
+                  newCookieMap.set(domain, [])
+                }
+
+                newCookieMap.get(domain)!.push(cookie)
+              }
+
+              cookieJarService.cookieJar.value = newCookieMap
+            }
           } else {
             tab.value.document.testResults = {
               description: "",
@@ -575,6 +622,19 @@ function updateEnvsAfterTestScript(runResult: E.Right<SandboxTestResult>) {
   }
 }
 
+const getCookieJarEntries = () => {
+  // Exclusive to the Desktop App
+  if (!platform.platformFeatureFlags.cookiesEnabled) {
+    return null
+  }
+
+  const cookieJarEntries = Array.from(
+    cookieJarService.cookieJar.value.values()
+  ).flatMap((cookies) => cookies)
+
+  return cookieJarEntries
+}
+
 /**
  * Run the test runner request
  * @param request The request to run
@@ -591,12 +651,16 @@ export function runTestRunnerRequest(
   | E.Right<{
       response: HoppRESTResponse
       testResult: HoppTestResult
+      updatedRequest: HoppRESTRequest
     }>
   | undefined
 > {
-  return runPreRequestScript(
-    request.preRequestScript,
-    getCombinedEnvVariables()
+  const cookieJarEntries = getCookieJarEntries()
+
+  return delegatePreRequestScriptRunner(
+    request,
+    getCombinedEnvVariables(),
+    cookieJarEntries
   ).then(async (preRequestScriptResult) => {
     if (E.isLeft(preRequestScriptResult)) {
       console.error(preRequestScriptResult.left)
@@ -614,14 +678,20 @@ export function runTestRunnerRequest(
       }))
     )
 
-    const effectiveRequest = await getEffectiveRESTRequest(request, {
+    // Calculate the final updated request after pre-request script changes
+    const finalRequest = {
+      ...request,
+      ...(preRequestScriptResult.right.updatedRequest ?? {}),
+    }
+
+    const effectiveRequest = await getEffectiveRESTRequest(finalRequest, {
       id: "env-id",
       v: 2,
       name: "Env",
       variables: filterNonEmptyEnvironmentVariables(
         combineEnvVariables({
           environments: {
-            ...preRequestScriptResult.right.envs,
+            ...preRequestScriptResult.right.updatedEnvs,
             temp: !persistEnv ? getTemporaryVariables() : [],
           },
           requestVariables: finalRequestVariables,
@@ -640,13 +710,16 @@ export function runTestRunnerRequest(
           executedResponses$.next(res)
 
           const postRequestScriptResult = await runPostRequestScript(
-            res.req.testScript,
-            preRequestScriptResult.right.envs,
+            preRequestScriptResult.right.updatedEnvs,
+            res.req,
             {
               status: res.statusCode,
               body: getTestableBody(res),
               headers: res.headers,
-            }
+              statusText: res.statusText,
+              responseTime: res.meta.responseDuration,
+            },
+            preRequestScriptResult.right.updatedCookies ?? null
           )
 
           if (E.isRight(postRequestScriptResult)) {
@@ -678,6 +751,7 @@ export function runTestRunnerRequest(
             return E.right({
               response: res,
               testResult: sandboxTestResult,
+              updatedRequest: finalRequest,
             })
           }
           const sandboxTestResult = {
@@ -702,6 +776,7 @@ export function runTestRunnerRequest(
           return E.right({
             response: res,
             testResult: sandboxTestResult,
+            updatedRequest: finalRequest,
           })
         }
       })
diff --git a/packages/hoppscotch-common/src/helpers/preRequest.ts b/packages/hoppscotch-common/src/helpers/preRequest.ts
deleted file mode 100644
index 7bd6cbe7..00000000
--- a/packages/hoppscotch-common/src/helpers/preRequest.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { Environment } from "@hoppscotch/data"
-import { runPreRequestScript } from "@hoppscotch/js-sandbox/web"
-import * as E from "fp-ts/Either"
-
-import { SandboxPreRequestResult } from "@hoppscotch/js-sandbox"
-
-export const getFinalEnvsFromPreRequest = (
-  script: string,
-  envs: {
-    global: Environment["variables"]
-    selected: Environment["variables"]
-    temp: Environment["variables"]
-  },
-  experimentalScriptingSandbox = true
-): Promise<E.Either<string, SandboxPreRequestResult>> =>
-  runPreRequestScript(script, envs, experimentalScriptingSandbox)
diff --git a/packages/hoppscotch-common/src/helpers/workers/sandbox.worker.ts b/packages/hoppscotch-common/src/helpers/workers/sandbox.worker.ts
index a85e37a0..cee659c5 100644
--- a/packages/hoppscotch-common/src/helpers/workers/sandbox.worker.ts
+++ b/packages/hoppscotch-common/src/helpers/workers/sandbox.worker.ts
@@ -1,30 +1,33 @@
-import { Environment } from "@hoppscotch/data"
+import { Cookie, Environment, HoppRESTRequest } from "@hoppscotch/data"
 import {
+  RunPostRequestScriptOptions,
+  RunPreRequestScriptOptions,
   SandboxPreRequestResult,
   SandboxTestResult,
   TestResult,
 } from "@hoppscotch/js-sandbox"
-import { runTestScript } from "@hoppscotch/js-sandbox/web"
+import { runPreRequestScript, runTestScript } from "@hoppscotch/js-sandbox/web"
 import * as E from "fp-ts/Either"
 
-import { getFinalEnvsFromPreRequest } from "../preRequest"
 import { HoppRESTResponse } from "../types/HoppRESTResponse"
 
 interface PreRequestMessage {
   type: "pre"
-  script: string
   envs: {
     global: Environment["variables"]
     selected: Environment["variables"]
     temp: Environment["variables"]
   }
+  request: string // JSON stringified request
+  cookies: string | null // JSON stringified cookies subject to the feature flag
 }
 
 interface PostRequestMessage {
   type: "post"
-  script: string
   envs: TestResult["envs"]
+  request: string // JSON stringified request
   response: HoppRESTResponse
+  cookies: string | null // JSON stringified cookies subject to the feature flag
 }
 
 type IncomingSandboxWorkerMessage = PreRequestMessage | PostRequestMessage
@@ -60,13 +63,33 @@ export type OutgoingSandboxPostRequestWorkerMessage =
 self.addEventListener(
   "message",
   async (event: MessageEvent<IncomingSandboxWorkerMessage>) => {
-    const { type, script, envs } = event.data
+    const { type, envs, request, cookies } = event.data
+
+    const parsedRequest = JSON.parse(request) as HoppRESTRequest
+
+    const parsedRequestResult = HoppRESTRequest.safeParse(parsedRequest)
+
+    const parsedCookies = cookies ? (JSON.parse(cookies) as Cookie[]) : null
 
     if (type === "pre") {
+      if (parsedRequestResult.type === "err") {
+        const err: PreRequestScriptErrorMessage = {
+          type: "PRE_REQUEST_SCRIPT_ERROR",
+          data: parsedRequestResult.error,
+        }
+        self.postMessage(err)
+        return
+      }
+
       try {
-        const preRequestScriptResult = await getFinalEnvsFromPreRequest(
-          script,
-          envs
+        const preRequestScriptResult = await runPreRequestScript(
+          parsedRequestResult.value.preRequestScript,
+          {
+            envs,
+            request: parsedRequestResult.value,
+            experimentalScriptingSandbox: true,
+            cookies: parsedCookies as unknown as Cookie[],
+          } satisfies RunPreRequestScriptOptions
         )
         const result: PreRequestScriptResultMessage = {
           type: "PRE_REQUEST_SCRIPT_RESULT",
@@ -83,13 +106,27 @@ self.addEventListener(
     }
 
     if (type === "post") {
+      if (parsedRequestResult.type === "err") {
+        const err: PostRequestScriptErrorMessage = {
+          type: "POST_REQUEST_SCRIPT_ERROR",
+          data: parsedRequestResult.error,
+        }
+        self.postMessage(err)
+        return
+      }
+
       const { response } = event.data
 
       try {
         const postRequestScriptResult = await runTestScript(
-          script,
-          envs,
-          response
+          parsedRequestResult.value.testScript,
+          {
+            envs,
+            request: parsedRequestResult.value,
+            response,
+            experimentalScriptingSandbox: true,
+            cookies: parsedCookies as unknown as Cookie[],
+          } satisfies RunPostRequestScriptOptions
         )
         const result: PostRequestScriptResultMessage = {
           type: "POST_REQUEST_SCRIPT_RESULT",
diff --git a/packages/hoppscotch-common/src/services/cookie-jar.service.ts b/packages/hoppscotch-common/src/services/cookie-jar.service.ts
index 1c300030..902aac30 100644
--- a/packages/hoppscotch-common/src/services/cookie-jar.service.ts
+++ b/packages/hoppscotch-common/src/services/cookie-jar.service.ts
@@ -1,14 +1,7 @@
 import { Service } from "dioc"
 import { ref } from "vue"
 import { parseString as setCookieParse } from "set-cookie-parser-es"
-
-export type CookieDef = {
-  name: string
-  value: string
-  domain: string
-  path: string
-  expires: string
-}
+import { Cookie } from "@hoppscotch/data"
 
 export class CookieJarService extends Service {
   public static readonly ID = "COOKIE_JAR_SERVICE"
@@ -18,13 +11,13 @@ export class CookieJarService extends Service {
    * The keys correspond to the domain of the cookie.
    * The cookie strings are stored as an array of strings corresponding to the domain
    */
-  public cookieJar = ref(new Map<string, string[]>())
+  public cookieJar = ref(new Map<string, Cookie[]>())
 
   public parseSetCookieString(setCookieString: string) {
     return setCookieParse(setCookieString)
   }
 
-  public bulkApplyCookiesToDomain(cookies: string[], domain: string) {
+  public bulkApplyCookiesToDomain(cookies: Cookie[], domain: string) {
     const existingDomainEntries = this.cookieJar.value.get(domain) ?? []
     existingDomainEntries.push(...cookies)
 
@@ -43,7 +36,7 @@ export class CookieJarService extends Service {
         const cookieStrings = this.cookieJar.value.get(domain)! // We know not nullable from how we filter above
 
         return cookieStrings.map((cookieString) =>
-          this.parseSetCookieString(cookieString)
+          this.parseSetCookieString(cookieString.value)
         )
       })
       .filter((cookie) => {
diff --git a/packages/hoppscotch-common/src/services/test-runner/test-runner.service.ts b/packages/hoppscotch-common/src/services/test-runner/test-runner.service.ts
index ed54955c..cd9642fd 100644
--- a/packages/hoppscotch-common/src/services/test-runner/test-runner.service.ts
+++ b/packages/hoppscotch-common/src/services/test-runner/test-runner.service.ts
@@ -299,15 +299,16 @@ export class TestRunnerService extends Service {
       }
 
       if (results && E.isRight(results)) {
-        const { response, testResult } = results.right
+        const { response, testResult, updatedRequest } = results.right
         const { passed, failed } = this.getTestResultInfo(testResult)
 
         tab.value.document.testRunnerMeta.totalTests += passed + failed
         tab.value.document.testRunnerMeta.passedTests += passed
         tab.value.document.testRunnerMeta.failedTests += failed
 
-        // Update request with results in the result collection
+        // Update request with results and propagate pre-request script changes in the result collection
         this.updateRequestAtPath(tab.value.document.resultCollection!, path, {
+          ...updatedRequest,
           testResults: testResult,
           response: options.persistResponses ? response : null,
           isLoading: false,
diff --git a/packages/hoppscotch-common/src/types/post-request.d.ts b/packages/hoppscotch-common/src/types/post-request.d.ts
index f1bc84cd..1b5eafca 100644
--- a/packages/hoppscotch-common/src/types/post-request.d.ts
+++ b/packages/hoppscotch-common/src/types/post-request.d.ts
@@ -1,22 +1,235 @@
-declare namespace pw {
-  function test(name: string, func: () => void): void
-  function expect(value: any): Expectation
+type HoppRESTContentType =
+  | null
+  | "multipart/form-data"
+  | "application/json"
+  | "application/ld+json"
+  | "application/hal+json"
+  | "application/vnd.api+json"
+  | "application/xml"
+  | "text/xml"
+  | "application/x-www-form-urlencoded"
+  | "binary"
+  | "text/html"
+  | "text/plain"
+  | "application/octet-stream"
 
-  const response: {
-    status: number
-    headers: any
-    body: any
-  }
-
-  namespace env {
-    function set(key: string, value: string): void
-    function unset(key: string): void
-    function get(key: string): string
-    function getResolve(key: string): string
-    function resolve(value: string): string
-  }
+interface HoppRESTHeader {
+  key: string
+  value: string
+  active: boolean
+  description: string
 }
 
+interface HoppRESTResponseHeader {
+  key: string
+  value: string
+}
+
+interface HoppRESTParam {
+  key: string
+  value: string
+  active: boolean
+  description: string
+}
+
+// Form data key-value pair for multipart/form-data
+interface FormDataKeyValue {
+  key: string
+  active: boolean
+  isFile: boolean
+  value: string | Blob[] | null
+}
+
+interface HoppRESTReqBody {
+  contentType: HoppRESTContentType
+  body: string | null | File | FormDataKeyValue[]
+}
+
+interface Cookie {
+  name: string
+  value: string
+  domain: string
+  path: string
+  expires?: string
+  maxAge?: number
+  secure: boolean
+  httpOnly: boolean
+  sameSite: "None" | "Lax" | "Strict"
+}
+
+type AuthLocation = "HEADERS" | "QUERY_PARAMS"
+type DigestAlgorithm = "MD5" | "MD5-sess"
+type DigestQOP = "auth" | "auth-int"
+type JWTAlgorithm =
+  | "HS256"
+  | "HS384"
+  | "HS512"
+  | "RS256"
+  | "RS384"
+  | "RS512"
+  | "PS256"
+  | "PS384"
+  | "PS512"
+  | "ES256"
+  | "ES384"
+  | "ES512"
+type HAWKAlgorithm = "sha256" | "sha1"
+
+interface HoppRESTAuthNone {
+  authType: "none"
+  authActive: boolean
+}
+
+interface HoppRESTAuthInherit {
+  authType: "inherit"
+  authActive: boolean
+}
+
+interface HoppRESTAuthBasic {
+  authType: "basic"
+  authActive: boolean
+  username: string
+  password: string
+}
+
+interface HoppRESTAuthBearer {
+  authType: "bearer"
+  authActive: boolean
+  token: string
+}
+
+interface HoppRESTAuthAPIKey {
+  authType: "api-key"
+  authActive: boolean
+  key: string
+  value: string
+  addTo: AuthLocation
+}
+
+interface HoppRESTAuthOAuth2 {
+  authType: "oauth-2"
+  authActive: boolean
+  grantTypeInfo: OAuth2GrantTypeInfo
+  addTo: AuthLocation
+}
+
+type OAuth2GrantTypeInfo =
+  | {
+      grantType: "AUTHORIZATION_CODE"
+      authEndpoint: string
+      tokenEndpoint: string
+      clientID: string
+      clientSecret?: string
+      scopes?: string
+      isPKCE?: boolean
+      codeVerifierMethod?: "plain" | "S256"
+      token?: string
+    }
+  | {
+      grantType: "CLIENT_CREDENTIALS"
+      tokenEndpoint: string
+      clientID: string
+      clientSecret?: string
+      scopes?: string
+      clientAuthentication?: "AS_BASIC_AUTH_HEADERS" | "IN_BODY"
+    }
+  | {
+      grantType: "PASSWORD"
+      tokenEndpoint: string
+      clientID: string
+      clientSecret?: string
+      username: string
+      password: string
+      scopes?: string
+    }
+  | {
+      grantType: "IMPLICIT"
+      authEndpoint: string
+      clientID: string
+      scopes?: string
+    }
+interface HoppRESTAuthAWSSignature {
+  authType: "aws-signature"
+  authActive: boolean
+  accessKey: string
+  secretKey: string
+  region: string
+  serviceName: string
+  serviceToken?: string
+  addTo: AuthLocation
+}
+
+interface HoppRESTAuthDigest {
+  authType: "digest"
+  authActive: boolean
+  username: string
+  password: string
+  realm?: string
+  nonce?: string
+  algorithm: DigestAlgorithm
+  qop: DigestQOP
+  nc?: string
+  cnonce?: string
+  opaque?: string
+  disableRetry: boolean
+}
+
+interface HoppRESTAuthHAWK {
+  authType: "hawk"
+  authActive: boolean
+  authId: string
+  authKey: string
+  algorithm: HAWKAlgorithm
+  includePayloadHash: boolean
+  user?: string
+  nonce?: string
+  ext?: string
+  app?: string
+  dlg?: string
+  timestamp?: string
+}
+
+interface HoppRESTAuthAkamaiEdgeGrid {
+  authType: "akamai-eg"
+  authActive: boolean
+  accessToken: string
+  clientToken: string
+  clientSecret: string
+  nonce?: string
+  timestamp?: string
+  host?: string
+  headersToSign?: string
+  maxBodySize?: string
+}
+
+interface HoppRESTAuthJWT {
+  authType: "jwt"
+  authActive: boolean
+  secret: string
+  privateKey?: string
+  algorithm: JWTAlgorithm
+  payload: string
+  addTo: AuthLocation
+  isSecretBase64Encoded: boolean
+  headerPrefix: string
+  paramName: string
+  jwtHeaders: string
+}
+
+// Discriminated union for all auth types
+type HoppRESTAuth =
+  | HoppRESTAuthNone
+  | HoppRESTAuthInherit
+  | HoppRESTAuthBasic
+  | HoppRESTAuthBearer
+  | HoppRESTAuthAPIKey
+  | HoppRESTAuthOAuth2
+  | HoppRESTAuthAWSSignature
+  | HoppRESTAuthDigest
+  | HoppRESTAuthHAWK
+  | HoppRESTAuthAkamaiEdgeGrid
+  | HoppRESTAuthJWT
+
 interface Expectation extends ExpectationMethods {
   not: BaseExpectation
 }
@@ -33,3 +246,180 @@ interface ExpectationMethods {
   toHaveLength(length: number): void
   toInclude(value: any): void
 }
+
+declare namespace pw {
+  function test(name: string, func: () => void): void
+  function expect(value: any): Expectation
+  const response: Readonly<{
+    status: number
+    body: any
+    headers: HoppRESTResponseHeader[]
+  }>
+  namespace env {
+    function get(key: string): string
+    function getResolve(key: string): string
+    function resolve(key: string): string
+  }
+}
+
+declare namespace hopp {
+  const env: Readonly<{
+    get(key: string): string | null
+    getRaw(key: string): string | null
+    getInitialRaw(key: string): string | null
+    active: Readonly<{
+      get(key: string): string | null
+      getRaw(key: string): string | null
+      getInitialRaw(key: string): string | null
+    }>
+    global: Readonly<{
+      get(key: string): string | null
+      getRaw(key: string): string | null
+      getInitialRaw(key: string): string | null
+    }>
+  }>
+
+  const request: Readonly<{
+    readonly url: string
+    readonly method: string
+    readonly params: HoppRESTParam[]
+    readonly headers: HoppRESTHeader[]
+    readonly body: HoppRESTReqBody
+    readonly auth: HoppRESTAuth
+    variables: Readonly<{
+      get(key: string): string | null
+    }>
+  }>
+
+  const response: Readonly<{
+    readonly statusCode: number
+    readonly statusText: string
+    readonly headers: HoppRESTResponseHeader[]
+    readonly responseTime: number
+    body: Readonly<{
+      asText(): string
+      asJSON(): Record<string, any>
+      bytes(): Uint8Array
+    }>
+  }>
+
+  const cookies: Readonly<{
+    get(domain: string, name: string): Cookie | null
+    set(domain: string, cookie: Cookie): void
+    has(domain: string, name: string): boolean
+    getAll(domain: string): Cookie[]
+    delete(domain: string, name: string): void
+    clear(domain: string): void
+  }>
+
+  function test(name: string, testFunction: () => void): void
+  function expect(value: any): Expectation
+
+  const info: Readonly<{
+    readonly eventName: "post-request"
+    readonly requestName: string
+    readonly requestId: string
+    readonly iteration: never
+    readonly iterationCount: never
+  }>
+}
+
+declare namespace pm {
+  const environment: Readonly<{
+    get(key: string): string | null
+    set(key: string, value: string): void
+    unset(key: string): void
+    has(key: string): boolean
+    clear(): never
+    toObject(): never
+  }>
+
+  const globals: Readonly<{
+    get(key: string): string | null
+    set(key: string, value: string): void
+    unset(key: string): void
+    has(key: string): boolean
+    clear(): never
+    toObject(): never
+  }>
+
+  const variables: Readonly<{
+    get(key: string): string | null
+    set(key: string, value: string): void
+    has(key: string): boolean
+    replaceIn(template: string): string
+  }>
+
+  const request: Readonly<{
+    readonly url: { toString(): string }
+    readonly method: string
+    readonly headers: Readonly<{
+      get(name: string): string | null
+      has(name: string): boolean
+      all(): Record<string, string>
+    }>
+    readonly body: HoppRESTReqBody
+    readonly auth: HoppRESTAuth
+  }>
+
+  const response: Readonly<{
+    readonly code: number
+    readonly status: string
+    readonly responseTime: number
+    text(): string
+    json(): Record<string, any>
+    stream: Uint8Array
+    headers: Readonly<{
+      get(name: string): string | null
+      has(name: string): boolean
+      all(): HoppRESTResponseHeader[]
+    }>
+    cookies: Readonly<{
+      get(name: string): any
+      has(name: string): any
+      toObject(): any
+    }>
+  }>
+
+  const cookies: Readonly<{
+    get(name: string): any
+    set(name: string, value: string, options?: any): any
+    jar(): any
+  }>
+
+  function test(name: string, testFunction: () => void): void
+  function expect(value: any): Expectation
+
+  const info: Readonly<{
+    readonly eventName: "post-request"
+    readonly requestName: string
+    readonly requestId: string
+    readonly iteration: never
+    readonly iterationCount: never
+  }>
+
+  const sendRequest: () => never
+  const collectionVariables: Readonly<{
+    get(): never
+    set(): never
+    unset(): never
+    has(): never
+    clear(): never
+    toObject(): never
+  }>
+  const vault: Readonly<{
+    get(): never
+    set(): never
+    unset(): never
+  }>
+  const iterationData: Readonly<{
+    get(): never
+    set(): never
+    unset(): never
+    has(): never
+    toObject(): never
+  }>
+  const execution: Readonly<{
+    setNextRequest(): never
+  }>
+}
diff --git a/packages/hoppscotch-common/src/types/pre-request.d.ts b/packages/hoppscotch-common/src/types/pre-request.d.ts
index ade2613e..3842a89b 100644
--- a/packages/hoppscotch-common/src/types/pre-request.d.ts
+++ b/packages/hoppscotch-common/src/types/pre-request.d.ts
@@ -1,9 +1,419 @@
-declare const pw: {
-  env: {
-    get(key: string): string
-    set(key: string, value: string): void
-    unset(key: string): void
-    getResolve(key: string): string
-    resolve(value: string): string
+type HoppRESTContentType =
+  | null
+  | "multipart/form-data"
+  | "application/json"
+  | "application/ld+json"
+  | "application/hal+json"
+  | "application/vnd.api+json"
+  | "application/xml"
+  | "text/xml"
+  | "application/x-www-form-urlencoded"
+  | "binary"
+  | "text/html"
+  | "text/plain"
+  | "application/octet-stream"
+
+interface HoppRESTHeader {
+  key: string
+  value: string
+  active: boolean
+  description: string
+}
+
+interface HoppRESTParam {
+  key: string
+  value: string
+  active: boolean
+  description: string
+}
+
+// Form data key-value pair for multipart/form-data
+interface FormDataKeyValue {
+  key: string
+  active: boolean
+  isFile: boolean
+  value: string | Blob[] | null
+}
+
+interface HoppRESTReqBody {
+  contentType: HoppRESTContentType
+  body: string | null | File | FormDataKeyValue[]
+}
+
+interface Cookie {
+  name: string
+  value: string
+  domain: string
+  path: string
+  expires?: string
+  maxAge?: number
+  secure: boolean
+  httpOnly: boolean
+  sameSite: "None" | "Lax" | "Strict"
+}
+
+type AuthLocation = "HEADERS" | "QUERY_PARAMS"
+type DigestAlgorithm = "MD5" | "MD5-sess"
+type DigestQOP = "auth" | "auth-int"
+type JWTAlgorithm =
+  | "HS256"
+  | "HS384"
+  | "HS512"
+  | "RS256"
+  | "RS384"
+  | "RS512"
+  | "PS256"
+  | "PS384"
+  | "PS512"
+  | "ES256"
+  | "ES384"
+  | "ES512"
+type HAWKAlgorithm = "sha256" | "sha1"
+
+interface HoppRESTAuthNone {
+  authType: "none"
+  authActive: boolean
+}
+
+interface HoppRESTAuthInherit {
+  authType: "inherit"
+  authActive: boolean
+}
+
+interface HoppRESTAuthBasic {
+  authType: "basic"
+  authActive: boolean
+  username: string
+  password: string
+}
+
+interface HoppRESTAuthBearer {
+  authType: "bearer"
+  authActive: boolean
+  token: string
+}
+
+interface HoppRESTAuthAPIKey {
+  authType: "api-key"
+  authActive: boolean
+  key: string
+  value: string
+  addTo: AuthLocation
+}
+
+type OAuth2GrantTypeInfo =
+  | {
+      grantType: "AUTHORIZATION_CODE"
+      authEndpoint: string
+      tokenEndpoint: string
+      clientID: string
+      clientSecret?: string
+      scopes?: string
+      isPKCE?: boolean
+      codeVerifierMethod?: "plain" | "S256"
+      token?: string
+    }
+  | {
+      grantType: "CLIENT_CREDENTIALS"
+      tokenEndpoint: string
+      clientID: string
+      clientSecret?: string
+      scopes?: string
+      clientAuthentication?: "AS_BASIC_AUTH_HEADERS" | "IN_BODY"
+    }
+  | {
+      grantType: "PASSWORD"
+      tokenEndpoint: string
+      clientID: string
+      clientSecret?: string
+      username: string
+      password: string
+      scopes?: string
+    }
+  | {
+      grantType: "IMPLICIT"
+      authEndpoint: string
+      clientID: string
+      scopes?: string
+    }
+
+interface HoppRESTAuthOAuth2 {
+  authType: "oauth-2"
+  authActive: boolean
+  grantTypeInfo: OAuth2GrantTypeInfo
+  addTo: AuthLocation
+}
+
+interface HoppRESTAuthAWSSignature {
+  authType: "aws-signature"
+  authActive: boolean
+  accessKey: string
+  secretKey: string
+  region: string
+  serviceName: string
+  serviceToken?: string
+  addTo: AuthLocation
+}
+
+interface HoppRESTAuthDigest {
+  authType: "digest"
+  authActive: boolean
+  username: string
+  password: string
+  realm?: string
+  nonce?: string
+  algorithm: DigestAlgorithm
+  qop: DigestQOP
+  nc?: string
+  cnonce?: string
+  opaque?: string
+  disableRetry: boolean
+}
+
+interface HoppRESTAuthHAWK {
+  authType: "hawk"
+  authActive: boolean
+  authId: string
+  authKey: string
+  algorithm: HAWKAlgorithm
+  includePayloadHash: boolean
+  user?: string
+  nonce?: string
+  ext?: string
+  app?: string
+  dlg?: string
+  timestamp?: string
+}
+
+interface HoppRESTAuthAkamaiEdgeGrid {
+  authType: "akamai-eg"
+  authActive: boolean
+  accessToken: string
+  clientToken: string
+  clientSecret: string
+  nonce?: string
+  timestamp?: string
+  host?: string
+  headersToSign?: string
+  maxBodySize?: string
+}
+
+interface HoppRESTAuthJWT {
+  authType: "jwt"
+  authActive: boolean
+  secret: string
+  privateKey?: string
+  algorithm: JWTAlgorithm
+  payload: string
+  addTo: AuthLocation
+  isSecretBase64Encoded: boolean
+  headerPrefix: string
+  paramName: string
+  jwtHeaders: string
+}
+
+// Discriminated union for all auth types
+type HoppRESTAuth =
+  | HoppRESTAuthNone
+  | HoppRESTAuthInherit
+  | HoppRESTAuthBasic
+  | HoppRESTAuthBearer
+  | HoppRESTAuthAPIKey
+  | HoppRESTAuthOAuth2
+  | HoppRESTAuthAWSSignature
+  | HoppRESTAuthDigest
+  | HoppRESTAuthHAWK
+  | HoppRESTAuthAkamaiEdgeGrid
+  | HoppRESTAuthJWT
+
+declare namespace pw {
+  namespace env {
+    function get(key: string): string
+    function getResolve(key: string): string
+    function set(key: string, value: string): void
+    function unset(key: string): void
+    function resolve(key: string): string
   }
 }
+
+declare namespace hopp {
+  const env: Readonly<{
+    get(key: string): string | null
+    getRaw(key: string): string | null
+    set(key: string, value: string): void
+    delete(key: string): void
+    reset(key: string): void
+    getInitialRaw(key: string): string | null
+    setInitial(key: string, value: string): void
+    active: Readonly<{
+      get(key: string): string | null
+      getRaw(key: string): string | null
+      set(key: string, value: string): void
+      delete(key: string): void
+      reset(key: string): void
+      getInitialRaw(key: string): string | null
+      setInitial(key: string, value: string): void
+    }>
+    global: Readonly<{
+      get(key: string): string | null
+      getRaw(key: string): string | null
+      set(key: string, value: string): void
+      delete(key: string): void
+      reset(key: string): void
+      getInitialRaw(key: string): string | null
+      setInitial(key: string, value: string): void
+    }>
+  }>
+
+  const request: Readonly<{
+    readonly url: string
+    readonly method: string
+    readonly params: HoppRESTParam[]
+    readonly headers: HoppRESTHeader[]
+    readonly body: HoppRESTReqBody
+    readonly auth: HoppRESTAuth
+    setUrl(url: string): void
+    setMethod(method: string): void
+    setHeader(name: string, value: string): void
+    setHeaders(headers: HoppRESTHeader[]): void
+    removeHeader(key: string): void
+    setParam(name: string, value: string): void
+    setParams(params: HoppRESTParam[]): void
+    removeParam(key: string): void
+    /**
+     * Set or update request body with automatic merging
+     *
+     * This method supports both partial updates and complete replacement:
+     * - Partial updates: Merges provided fields with existing body configuration
+     * - Complete replacement: When all fields are provided, replaces entire body
+     *
+     * @param body - Partial or complete HoppRESTReqBody object
+     *
+     * @example
+     * // Partial update - just change content type
+     * hopp.request.setBody({ contentType: "application/xml" })
+     *
+     * // Partial update - just change body content
+     * hopp.request.setBody({ body: JSON.stringify({ updated: true }) })
+     *
+     * // Complete replacement
+     * hopp.request.setBody({
+     *   contentType: "application/json",
+     *   body: JSON.stringify({ name: "test", value: 123 })
+     * })
+     */
+    setBody(body: Partial<HoppRESTReqBody>): void
+    /**
+     * Set or update authentication configuration with automatic merging
+     *
+     * This method supports both partial updates and complete replacement:
+     * - Partial updates: Merges provided fields with existing auth configuration
+     * - Complete replacement: When switching auth types, resets type-specific fields
+     *
+     * @param auth - Partial or complete HoppRESTAuth object
+     *
+     * @example
+     * // Partial update - just change the token (merges with existing)
+     * hopp.request.setAuth({ bearerToken: "new-token" })
+     *
+     * // Complete replacement - switch auth types
+     * hopp.request.setAuth({
+     *   authType: "basic",
+     *   authActive: true,
+     *   username: "user",
+     *   password: "pass"
+     * })
+     *
+     * // Update multiple fields while preserving others
+     * hopp.request.setAuth({
+     *   accessToken: "updated-token"
+     * })
+     */
+    setAuth(auth: Partial<HoppRESTAuth>): void
+    variables: Readonly<{
+      get(key: string): string | null
+      set(key: string, value: string): void
+    }>
+  }>
+
+  const cookies: Readonly<{
+    get(domain: string, name: string): Cookie | null
+    set(domain: string, cookie: Cookie): void
+    has(domain: string, name: string): boolean
+    getAll(domain: string): Cookie[]
+    delete(domain: string, name: string): void
+    clear(domain: string): void
+  }>
+}
+
+declare namespace pm {
+  const environment: Readonly<{
+    get(key: string): string | null
+    set(key: string, value: string): void
+    unset(key: string): void
+    has(key: string): boolean
+    clear(): never
+    toObject(): never
+  }>
+
+  const globals: Readonly<{
+    get(key: string): string | null
+    set(key: string, value: string): void
+    unset(key: string): void
+    has(key: string): boolean
+    clear(): never
+    toObject(): never
+  }>
+
+  const variables: Readonly<{
+    get(key: string): string | null
+    set(key: string, value: string): void
+    has(key: string): boolean
+    replaceIn(template: string): string
+  }>
+
+  const request: Readonly<{
+    readonly url: { toString(): string }
+    readonly method: string
+    readonly headers: Readonly<{
+      get(name: string): string | null
+      has(name: string): boolean
+      all(): HoppRESTHeader[]
+    }>
+    readonly body: any
+    readonly auth: any
+  }>
+
+  const info: Readonly<{
+    readonly eventName: "pre-request"
+    readonly requestName: string
+    readonly requestId: string
+    readonly iteration: never
+    readonly iterationCount: never
+  }>
+
+  const sendRequest: () => never
+  const collectionVariables: Readonly<{
+    get(): never
+    set(): never
+    unset(): never
+    has(): never
+    clear(): never
+    toObject(): never
+  }>
+  const vault: Readonly<{
+    get(): never
+    set(): never
+    unset(): never
+  }>
+  const iterationData: Readonly<{
+    get(): never
+    set(): never
+    unset(): never
+    has(): never
+    toObject(): never
+  }>
+  const execution: Readonly<{
+    setNextRequest(): never
+  }>
+}
diff --git a/packages/hoppscotch-data/src/cookies.ts b/packages/hoppscotch-data/src/cookies.ts
new file mode 100644
index 00000000..d6a2cb78
--- /dev/null
+++ b/packages/hoppscotch-data/src/cookies.ts
@@ -0,0 +1,16 @@
+import { field } from "fp-ts"
+import { z } from "zod"
+
+export const CookieSchema = z.object({
+  name: z.string(), // Cookie name
+  value: z.string(), // Cookie value
+  domain: z.string(), // Domain the cookie belongs to
+  path: z.string(), // Path scope of the cookie (default: "/")
+  expires: z.string().optional(), // Expiration date in ISO format, null for session cookies
+  maxAge: z.number().optional(), // Maximum age in seconds, null if not set
+  httpOnly: z.boolean(), // Whether cookie is HTTP-only (not accessible via JavaScript)
+  secure: z.boolean(), // Whether cookie should only be sent over HTTPS
+  sameSite: z.enum(["None", "Lax", "Strict"]), // SameSite attribute for CSRF protection
+})
+
+export type Cookie = z.infer<typeof CookieSchema>
diff --git a/packages/hoppscotch-data/src/index.ts b/packages/hoppscotch-data/src/index.ts
index 37e6ae94..ecbfc8c0 100644
--- a/packages/hoppscotch-data/src/index.ts
+++ b/packages/hoppscotch-data/src/index.ts
@@ -10,3 +10,4 @@ export * from "./utils/hawk"
 export * from "./utils/akamai-eg"
 export * from "./utils/jwt"
 export * from "./rest-request-response"
+export * from "./cookies"
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/cookies.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/cookies.spec.ts
new file mode 100644
index 00000000..51e97bd3
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/cookies.spec.ts
@@ -0,0 +1,417 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import { describe, expect, test } from "vitest"
+
+import { Cookie, TestResponse } from "~/types"
+import { runPreRequestScript, runTestScript } from "~/web"
+
+const baseCookies: Cookie[] = [
+  {
+    name: "session_id",
+    value: "abc123",
+    domain: "example.com",
+    path: "/",
+    httpOnly: true,
+    secure: true,
+    sameSite: "Lax",
+  },
+  {
+    name: "pref",
+    value: "dark",
+    domain: "example.com",
+    path: "/",
+    httpOnly: false,
+    secure: false,
+    sameSite: "Strict",
+  },
+]
+
+const defaultRequest = getDefaultRESTRequest()
+
+describe("hopp.cookies", () => {
+  test("hopp.cookies.get should return a specific cookie", async () => {
+    await expect(
+      runPreRequestScript(
+        `console.log(hopp.cookies.get("example.com", "session_id"))`,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          cookies: baseCookies,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [
+          expect.objectContaining({
+            args: [
+              {
+                name: "session_id",
+                value: "abc123",
+                domain: "example.com",
+                path: "/",
+                httpOnly: true,
+                secure: true,
+                sameSite: "Lax",
+              },
+            ],
+          }),
+        ],
+      })
+    )
+  })
+
+  test("hopp.cookies.get should return null for missing cookie", async () => {
+    await expect(
+      runPreRequestScript(
+        `console.log(hopp.cookies.get("example.com", "unknown"))`,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          cookies: baseCookies,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [expect.objectContaining({ args: [null] })],
+      })
+    )
+  })
+
+  test("hopp.cookies.has should return true if cookie exists", async () => {
+    await expect(
+      runPreRequestScript(
+        `console.log(hopp.cookies.has("example.com", "session_id"))`,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          cookies: baseCookies,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [
+          expect.objectContaining({
+            args: [true],
+          }),
+        ],
+      })
+    )
+  })
+
+  test("hopp.cookies.has should return false if cookie does not exist", async () => {
+    await expect(
+      runPreRequestScript(
+        `console.log(hopp.cookies.has("example.com", "missing"))`,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          cookies: baseCookies,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [
+          expect.objectContaining({
+            args: [false],
+          }),
+        ],
+      })
+    )
+  })
+
+  test("hopp.cookies.getAll should return all cookies for a domain", () => {
+    return expect(
+      runPreRequestScript(`console.log(hopp.cookies.getAll("example.com"))`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        cookies: baseCookies,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [
+          expect.objectContaining({
+            args: [
+              [
+                {
+                  name: "session_id",
+                  value: "abc123",
+                  domain: "example.com",
+                  path: "/",
+                  httpOnly: true,
+                  secure: true,
+                  sameSite: "Lax",
+                },
+                {
+                  name: "pref",
+                  value: "dark",
+                  domain: "example.com",
+                  path: "/",
+                  httpOnly: false,
+                  secure: false,
+                  sameSite: "Strict",
+                },
+              ],
+            ],
+          }),
+        ],
+      })
+    )
+  })
+
+  test("hopp.cookies.set should add a new cookie", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          const newCookie = {
+          name: "new_cookie",
+          value: "new_value",
+          domain: "example.com",
+          path: "/",
+          httpOnly: false,
+          secure: false,
+          sameSite: "None",
+        }
+
+        hopp.cookies.set("example.com", newCookie)
+        `,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          cookies: baseCookies,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedCookies: expect.arrayContaining([
+          expect.objectContaining({
+            name: "new_cookie",
+            value: "new_value",
+            domain: "example.com",
+            path: "/",
+            httpOnly: false,
+            secure: false,
+            sameSite: "None",
+          }),
+        ]),
+      })
+    )
+  })
+
+  test("hopp.cookies.set should replace existing cookie with same domain+name", () => {
+    const updated = { ...baseCookies[0], value: "updated123" }
+    return expect(
+      runPreRequestScript(
+        `hopp.cookies.set("example.com", ${JSON.stringify(updated)})`,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          cookies: baseCookies,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedCookies: expect.arrayContaining([
+          expect.objectContaining({ value: "updated123" }),
+        ]),
+      })
+    )
+  })
+
+  test("hopp.cookies.delete should remove a specific cookie", () => {
+    return expect(
+      runPreRequestScript(`hopp.cookies.delete("example.com", "pref")`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        cookies: baseCookies,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedCookies: expect.not.arrayContaining([
+          expect.objectContaining({ name: "pref" }),
+        ]),
+      })
+    )
+  })
+
+  test("hopp.cookies.clear should remove all cookies for a domain", () => {
+    return expect(
+      runPreRequestScript(`hopp.cookies.clear("example.com")`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        cookies: baseCookies,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedCookies: expect.not.arrayContaining([
+          expect.objectContaining({ domain: "example.com" }),
+        ]),
+      })
+    )
+  })
+
+  test("hopp.cookies methods throw for non-string domain and/or name args", async () => {
+    const envs = { global: [], selected: [] }
+    const response: TestResponse = {
+      status: 200,
+      body: "OK",
+      headers: [],
+    }
+
+    await expect(
+      runPreRequestScript(`hopp.cookies.get(123, "test")`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        cookies: baseCookies,
+      })
+    ).resolves.toBeLeft()
+
+    await expect(
+      runPreRequestScript(`hopp.cookies.delete("example.com", 456)`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        cookies: baseCookies,
+      })
+    ).resolves.toBeLeft()
+
+    await expect(
+      runTestScript(`hopp.cookies.get(123, "test")`, {
+        envs,
+        request: defaultRequest,
+        cookies: undefined,
+        response,
+      })
+    ).resolves.toBeLeft()
+
+    await expect(
+      runTestScript(`hopp.cookies.delete("example.com", 456)`, {
+        envs,
+        request: defaultRequest,
+        cookies: undefined,
+        response,
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.cookies.set throw if attempting to set cookie not conforming to the expected shape", async () => {
+    const envs = { global: [], selected: [] }
+    const response: TestResponse = {
+      status: 200,
+      body: "OK",
+      headers: [],
+    }
+
+    const script = `hopp.cookies.set("example.com", "test")`
+
+    await expect(
+      runPreRequestScript(script, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        cookies: baseCookies,
+      })
+    ).resolves.toBeLeft()
+
+    await expect(
+      runTestScript(script, {
+        envs,
+        request: defaultRequest,
+        cookies: undefined,
+        response,
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.cookies throws an exception on unsupported platforms", async () => {
+    const envs = { global: [], selected: [] }
+    const response: TestResponse = {
+      status: 200,
+      body: "OK",
+      headers: [],
+    }
+
+    await expect(
+      runPreRequestScript(
+        `console.log(hopp.cookies.get("example.com", "session_id"))`,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          // `cookies` specified as `undefined` indicates unsupported platform
+          cookies: undefined,
+        }
+      )
+    ).resolves.toBeLeft()
+
+    await expect(
+      runTestScript(
+        `console.log(hopp.cookies.get("example.com", "session_id"))`,
+        {
+          envs,
+          request: defaultRequest,
+          cookies: undefined,
+          response,
+        }
+      )
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.cookies API should be available in post-request context", () => {
+    const envs = { global: [], selected: [] }
+    const response: TestResponse = {
+      status: 200,
+      body: "OK",
+      headers: [],
+    }
+
+    return expect(
+      runTestScript(
+        `
+        hopp.test("Cookies operations work correctly", () => {
+          hopp.expect(hopp.cookies.has("example.com", "session_id")).toBe(true)
+          hopp.expect(hopp.cookies.get("example.com", "pref").value).toBe("dark")
+
+          hopp.cookies.set("example.com", {
+            name: "post_cookie",
+            value: "post_value",
+            domain: "example.com",
+            path: "/",
+            httpOnly: false,
+            secure: false,
+            sameSite: "None",
+          })
+
+          hopp.expect(hopp.cookies.has("example.com", "post_cookie")).toBe(true)
+          hopp.expect(hopp.cookies.getAll("example.com").length).toBe(3)
+
+          hopp.cookies.delete("example.com", "session_id")
+
+          hopp.expect(hopp.cookies.has("example.com", "session_id")).toBe(false)
+        })
+        `,
+        {
+          envs,
+          request: defaultRequest,
+          cookies: baseCookies,
+          response,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        tests: expect.objectContaining({
+          children: [
+            expect.objectContaining({
+              descriptor: "Cookies operations work correctly",
+              expectResults: [
+                { status: "pass", message: "Expected 'true' to be 'true'" },
+                { status: "pass", message: "Expected 'dark' to be 'dark'" },
+                { status: "pass", message: "Expected 'true' to be 'true'" },
+                { status: "pass", message: "Expected '3' to be '3'" },
+                { status: "pass", message: "Expected 'false' to be 'false'" },
+              ],
+            }),
+          ],
+        }),
+        updatedCookies: expect.arrayContaining([
+          expect.objectContaining({ name: "post_cookie", value: "post_value" }),
+        ]),
+      })
+    )
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/delete.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/delete.spec.ts
new file mode 100644
index 00000000..d22f1371
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/delete.spec.ts
@@ -0,0 +1,354 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.envs)
+  )
+
+const funcTest = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("hopp.env.delete", () => {
+  test("removes variable from selected environment", () =>
+    expect(
+      func(`hopp.env.delete("baseUrl")`, {
+        global: [],
+        selected: [
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+      })()
+    ).resolves.toEqualRight(expect.objectContaining({ selected: [] })))
+
+  test("removes variable from global environment", () =>
+    expect(
+      func(`hopp.env.delete("baseUrl")`, {
+        global: [
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+        selected: [],
+      })()
+    ).resolves.toEqualRight(expect.objectContaining({ global: [] })))
+
+  test("removes only from selected if present in both", () =>
+    expect(
+      func(`hopp.env.delete("baseUrl")`, {
+        global: [
+          {
+            key: "baseUrl",
+            currentValue: "https://httpbin.org",
+            initialValue: "https://httpbin.org",
+            secret: false,
+          },
+        ],
+        selected: [
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "baseUrl",
+            currentValue: "https://httpbin.org",
+            initialValue: "https://httpbin.org",
+            secret: false,
+          },
+        ],
+        selected: [],
+      })
+    ))
+
+  test("removes only first matching entry if duplicates exist in selected", () =>
+    expect(
+      func(`hopp.env.delete("baseUrl")`, {
+        global: [
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+        selected: [
+          {
+            key: "baseUrl",
+            currentValue: "https://httpbin.org",
+            initialValue: "https://httpbin.org",
+            secret: false,
+          },
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+        selected: [
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+      })
+    ))
+
+  test("removes only first matching entry if duplicates exist in global", () =>
+    expect(
+      func(`hopp.env.delete("baseUrl")`, {
+        global: [
+          {
+            key: "baseUrl",
+            currentValue: "https://httpbin.org",
+            initialValue: "https://httpbin.org",
+            secret: false,
+          },
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+        selected: [],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "baseUrl",
+            currentValue: "https://echo.hoppscotch.io",
+            initialValue: "https://echo.hoppscotch.io",
+            secret: false,
+          },
+        ],
+        selected: [],
+      })
+    ))
+
+  test("no change if attempting to delete non-existent key", () =>
+    expect(
+      func(`hopp.env.delete("baseUrl")`, { global: [], selected: [] })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({ global: [], selected: [] })
+    ))
+
+  test("key must be a string", () =>
+    expect(
+      func(`hopp.env.delete(5)`, { global: [], selected: [] })()
+    ).resolves.toBeLeft())
+
+  test("reflected in script execution", () =>
+    expect(
+      funcTest(
+        `
+          hopp.env.delete("baseUrl")
+          hopp.expect(hopp.env.get("baseUrl")).toBe(null)
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "baseUrl",
+              currentValue: "https://echo.hoppscotch.io",
+              initialValue: "https://echo.hoppscotch.io",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ]))
+})
+
+describe("hopp.env.active.delete", () => {
+  test("removes variable from selected environment", () =>
+    expect(
+      func(`hopp.env.active.delete("foo")`, {
+        selected: [
+          {
+            key: "foo",
+            currentValue: "bar",
+            initialValue: "bar",
+            secret: false,
+          },
+        ],
+        global: [
+          {
+            key: "foo",
+            currentValue: "baz",
+            initialValue: "baz",
+            secret: false,
+          },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [],
+        global: [
+          {
+            key: "foo",
+            currentValue: "baz",
+            initialValue: "baz",
+            secret: false,
+          },
+        ],
+      })
+    ))
+
+  test("no effect if not present in selected", () =>
+    expect(
+      func(`hopp.env.active.delete("nope")`, {
+        selected: [],
+        global: [
+          {
+            key: "nope",
+            currentValue: "baz",
+            initialValue: "baz",
+            secret: false,
+          },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [],
+        global: [
+          {
+            key: "nope",
+            currentValue: "baz",
+            initialValue: "baz",
+            secret: false,
+          },
+        ],
+      })
+    ))
+
+  test("key must be a string", () =>
+    expect(
+      func(`hopp.env.active.delete({})`, { selected: [], global: [] })()
+    ).resolves.toBeLeft())
+})
+
+describe("hopp.env.global.delete", () => {
+  test("removes variable from global environment", () =>
+    expect(
+      func(`hopp.env.global.delete("foo")`, {
+        selected: [
+          {
+            key: "foo",
+            currentValue: "bar",
+            initialValue: "bar",
+            secret: false,
+          },
+        ],
+        global: [
+          {
+            key: "foo",
+            currentValue: "baz",
+            initialValue: "baz",
+            secret: false,
+          },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "foo",
+            currentValue: "bar",
+            initialValue: "bar",
+            secret: false,
+          },
+        ],
+        global: [],
+      })
+    ))
+
+  test("no effect if not present in global", () =>
+    expect(
+      func(`hopp.env.global.delete("missing")`, {
+        selected: [
+          {
+            key: "missing",
+            currentValue: "bar",
+            initialValue: "bar",
+            secret: false,
+          },
+        ],
+        global: [],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "missing",
+            currentValue: "bar",
+            initialValue: "bar",
+            secret: false,
+          },
+        ],
+        global: [],
+      })
+    ))
+
+  test("key must be a string", () =>
+    expect(
+      func(`hopp.env.global.delete([])`, { selected: [], global: [] })()
+    ).resolves.toBeLeft())
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/get.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/get.spec.ts
new file mode 100644
index 00000000..940a1f76
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/get.spec.ts
@@ -0,0 +1,339 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("hopp.env.get", () => {
+  test("returns the correct value for an existing selected environment value", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.get("a")
+          hopp.expect(data).toBe("b")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              currentValue: "b",
+              initialValue: "b",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected 'b' to be 'b'" }],
+      }),
+    ])
+  })
+
+  test("returns the correct value for an existing global environment value", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.get("a")
+          hopp.expect(data).toBe("b")
+        `,
+        {
+          global: [
+            {
+              key: "a",
+              currentValue: "b",
+              initialValue: "b",
+              secret: false,
+            },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected 'b' to be 'b'" }],
+      }),
+    ])
+  })
+
+  test("returns null for a key that is not present in both selected or global", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.get("a")
+          hopp.expect(data).toBe(null)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns the value defined in selected environment if also present in global", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.get("a")
+          hopp.expect(data).toBe("selected val")
+        `,
+        {
+          global: [
+            {
+              key: "a",
+              currentValue: "global val",
+              initialValue: "global val",
+              secret: false,
+            },
+          ],
+          selected: [
+            {
+              key: "a",
+              currentValue: "selected val",
+              initialValue: "selected val",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'selected val' to be 'selected val'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("resolves environment values recursively by default", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.get("a")
+          hopp.expect(data).toBe("hello")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              currentValue: "<<hello>>",
+              initialValue: "<<hello>>",
+              secret: false,
+            },
+            {
+              key: "hello",
+              currentValue: "hello",
+              initialValue: "hello",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'hello' to be 'hello'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors if the key is not a string", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.get(5)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.active.get", () => {
+  test("returns the value from selected environment if present", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.active.get("a")
+          hopp.expect(data).toBe("selectedVal")
+        `,
+        {
+          selected: [
+            {
+              key: "a",
+              currentValue: "selectedVal",
+              initialValue: "selectedVal",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "a",
+              currentValue: "globalVal",
+              initialValue: "globalVal",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'selectedVal' to be 'selectedVal'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("returns null if key does not exist in selected", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.active.get("absent")
+          hopp.expect(data).toBe(null)
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "absent",
+              currentValue: "globalVal",
+              initialValue: "globalVal",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors if the key is not a string", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.get({})
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.global.get", () => {
+  test("returns the value from global environment if present", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.global.get("foo")
+          hopp.expect(data).toBe("globalVal")
+        `,
+        {
+          selected: [
+            {
+              key: "foo",
+              currentValue: "selVal",
+              initialValue: "selVal",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "foo",
+              currentValue: "globalVal",
+              initialValue: "globalVal",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'globalVal' to be 'globalVal'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns null if key does not exist in global", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.global.get("not_here")
+          hopp.expect(data).toBe(null)
+        `,
+        {
+          selected: [
+            {
+              key: "not_here",
+              currentValue: "selVal",
+              initialValue: "selVal",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors if the key is not a string", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.get([])
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/getInitialRaw.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/getInitialRaw.spec.ts
new file mode 100644
index 00000000..76d64257
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/getInitialRaw.spec.ts
@@ -0,0 +1,463 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("hopp.env.getInitialRaw", () => {
+  test("returns initial value for existing selected env variable", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.getInitialRaw("foo")
+          hopp.expect(val).toBe("bar")
+        `,
+        {
+          selected: [
+            {
+              key: "foo",
+              currentValue: "baz",
+              initialValue: "bar",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'bar' to be 'bar'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns initial value from global if not in selected", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.getInitialRaw("foo")
+          hopp.expect(val).toBe("bar")
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "foo",
+              currentValue: "baz",
+              initialValue: "bar",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'bar' to be 'bar'" },
+        ],
+      }),
+    ])
+  })
+
+  test("selected shadows global when both present", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.getInitialRaw("foo")
+          hopp.expect(val).toBe("selVal")
+        `,
+        {
+          selected: [
+            {
+              key: "foo",
+              currentValue: "selCur",
+              initialValue: "selVal",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "foo",
+              currentValue: "globCur",
+              initialValue: "globVal",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'selVal' to be 'selVal'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns null for missing key", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.getInitialRaw("notFound")
+          hopp.expect(val).toBe(null)
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns empty string if initial value was empty", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.getInitialRaw("empty")
+          hopp.expect(val).toBe("")
+        `,
+        {
+          selected: [
+            { key: "empty", currentValue: "", initialValue: "", secret: false },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected '' to be ''" }],
+      }),
+    ])
+  })
+
+  test("returns literal template syntax, no resolution", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.getInitialRaw("templ")
+          hopp.expect(val).toBe("<<FOO>>")
+        `,
+        {
+          selected: [
+            {
+              key: "templ",
+              currentValue: "baz",
+              initialValue: "<<FOO>>",
+              secret: false,
+            },
+            {
+              key: "FOO",
+              currentValue: "bar",
+              initialValue: "bar",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected '<<FOO>>' to be '<<FOO>>'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors for non-string key", () => {
+    return expect(
+      func(
+        `
+          hopp.env.getInitialRaw(5)
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.active.getInitialRaw", () => {
+  test("returns initial value if present in selected env", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.active.getInitialRaw("alpha")
+          hopp.expect(val).toBe("a_value")
+        `,
+        {
+          selected: [
+            {
+              key: "alpha",
+              currentValue: "changed",
+              initialValue: "a_value",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "alpha",
+              currentValue: "global",
+              initialValue: "g_value",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'a_value' to be 'a_value'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns null if not present in selected env", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.active.getInitialRaw("missing")
+          hopp.expect(val).toBe(null)
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "missing",
+              currentValue: "glob",
+              initialValue: "g",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns '' if initial value was empty string", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.active.getInitialRaw("blank")
+          hopp.expect(val).toBe("")
+        `,
+        {
+          selected: [
+            { key: "blank", currentValue: "", initialValue: "", secret: false },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected '' to be ''" }],
+      }),
+    ])
+  })
+
+  test("returns literal template if present", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.active.getInitialRaw("tmpl")
+          hopp.expect(val).toBe("<<BAR>>")
+        `,
+        {
+          selected: [
+            {
+              key: "tmpl",
+              currentValue: "baz",
+              initialValue: "<<BAR>>",
+              secret: false,
+            },
+            {
+              key: "BAR",
+              currentValue: "qux",
+              initialValue: "qux",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected '<<BAR>>' to be '<<BAR>>'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors for non-string key", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.getInitialRaw({})
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.global.getInitialRaw", () => {
+  test("returns initial value if present in global env", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.global.getInitialRaw("gamma")
+          hopp.expect(val).toBe("g_val")
+        `,
+        {
+          selected: [
+            {
+              key: "gamma",
+              currentValue: "s_val",
+              initialValue: "s_val",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "gamma",
+              currentValue: "current",
+              initialValue: "g_val",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'g_val' to be 'g_val'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns null if not present in global env", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.global.getInitialRaw("none")
+          hopp.expect(val).toBe(null)
+        `,
+        {
+          selected: [
+            {
+              key: "none",
+              currentValue: "s",
+              initialValue: "s",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns '' if initial value was empty string", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.global.getInitialRaw("empty")
+          hopp.expect(val).toBe("")
+        `,
+        {
+          selected: [],
+          global: [
+            { key: "empty", currentValue: "", initialValue: "", secret: false },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected '' to be ''" }],
+      }),
+    ])
+  })
+
+  test("returns literal template value if present", () => {
+    return expect(
+      func(
+        `
+          const val = hopp.env.global.getInitialRaw("tmpl")
+          hopp.expect(val).toBe("<<ZED>>")
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "tmpl",
+              currentValue: "zed-cur",
+              initialValue: "<<ZED>>",
+              secret: false,
+            },
+            {
+              key: "ZED",
+              currentValue: "42",
+              initialValue: "42",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected '<<ZED>>' to be '<<ZED>>'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors for non-string key", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.getInitialRaw([])
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/getRaw.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/getRaw.spec.ts
new file mode 100644
index 00000000..5c98a5f7
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/getRaw.spec.ts
@@ -0,0 +1,361 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("hopp.env.getRaw", () => {
+  test("returns the correct value for an existing selected environment value", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.getRaw("a")
+          hopp.expect(data).toBe("b")
+        `,
+        {
+          global: [],
+          selected: [
+            { key: "a", currentValue: "b", initialValue: "b", secret: false },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected 'b' to be 'b'" }],
+      }),
+    ])
+  })
+
+  test("returns the correct value for an existing global environment value", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.getRaw("a")
+          hopp.expect(data).toBe("b")
+        `,
+        {
+          global: [
+            { key: "a", currentValue: "b", initialValue: "b", secret: false },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected 'b' to be 'b'" }],
+      }),
+    ])
+  })
+
+  test("returns null for a key that is not present in both selected and global", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.getRaw("a")
+          hopp.expect(data).toBe(null)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns the value defined in selected if also present in global", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.getRaw("a")
+          hopp.expect(data).toBe("selected val")
+        `,
+        {
+          global: [
+            {
+              key: "a",
+              currentValue: "global val",
+              initialValue: "global val",
+              secret: false,
+            },
+          ],
+          selected: [
+            {
+              key: "a",
+              currentValue: "selected val",
+              initialValue: "selected val",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'selected val' to be 'selected val'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("does not resolve values recursively", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.getRaw("a")
+          hopp.expect(data).toBe("<<hello>>")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              currentValue: "<<hello>>",
+              initialValue: "<<hello>>",
+              secret: false,
+            },
+            {
+              key: "hello",
+              currentValue: "there",
+              initialValue: "there",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected '<<hello>>' to be '<<hello>>'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns the value as is even if there is a potential recursion", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.getRaw("a")
+          hopp.expect(data).toBe("<<hello>>")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              currentValue: "<<hello>>",
+              initialValue: "<<hello>>",
+              secret: false,
+            },
+            {
+              key: "hello",
+              currentValue: "<<a>>",
+              initialValue: "<<a>>",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected '<<hello>>' to be '<<hello>>'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors if the key is not a string", () => {
+    return expect(
+      func(
+        `
+          const data = hopp.env.getRaw(5)
+        `,
+        { global: [], selected: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.active.getRaw", () => {
+  test("returns only from selected", () => {
+    return expect(
+      func(
+        `
+          hopp.expect(hopp.env.active.getRaw("a")).toBe("a-selected")
+          hopp.expect(hopp.env.active.getRaw("b")).toBe(null)
+        `,
+        {
+          selected: [
+            {
+              key: "a",
+              currentValue: "a-selected",
+              initialValue: "AS",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "a",
+              currentValue: "a-global",
+              initialValue: "AG",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'a-selected' to be 'a-selected'",
+          },
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns null if key absent in selected", () => {
+    return expect(
+      func(
+        `
+          hopp.expect(hopp.env.active.getRaw("missing")).toBe(null)
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "missing",
+              currentValue: "global",
+              initialValue: "global",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors if key is not a string", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.getRaw({})
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.global.getRaw", () => {
+  test("returns only from global", () => {
+    return expect(
+      func(
+        `
+          hopp.expect(hopp.env.global.getRaw("b")).toBe("b-global")
+          hopp.expect(hopp.env.global.getRaw("a")).toBe(null)
+        `,
+        {
+          selected: [
+            {
+              key: "a",
+              currentValue: "a-selected",
+              initialValue: "AS",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "b",
+              currentValue: "b-global",
+              initialValue: "BG",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'b-global' to be 'b-global'" },
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("returns null if key absent in global", () => {
+    return expect(
+      func(
+        `
+          hopp.expect(hopp.env.global.getRaw("missing")).toBe(null)
+        `,
+        {
+          selected: [
+            {
+              key: "missing",
+              currentValue: "sel",
+              initialValue: "sel",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors if key is not a string", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.getRaw([])
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/reset.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/reset.spec.ts
new file mode 100644
index 00000000..46036ad3
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/reset.spec.ts
@@ -0,0 +1,522 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.envs)
+  )
+
+const funcTest = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("hopp.env.reset", () => {
+  test("resets selected variable to its initial value", () =>
+    expect(
+      func(
+        `
+          hopp.env.set("foo", "changed")
+          hopp.env.reset("foo")
+        `,
+        {
+          selected: [
+            {
+              key: "foo",
+              currentValue: "bar",
+              initialValue: "bar",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "foo",
+            currentValue: "bar",
+            initialValue: "bar",
+            secret: false,
+          },
+        ],
+      })
+    ))
+
+  test("resets global variable to its initial value if not in selected", () =>
+    expect(
+      func(
+        `
+          hopp.env.set("bar", "override")
+          hopp.env.reset("bar")
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "bar",
+              currentValue: "baz",
+              initialValue: "baz",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "bar",
+            currentValue: "baz",
+            initialValue: "baz",
+            secret: false,
+          },
+        ],
+      })
+    ))
+
+  test("if variable exists in both, only selected variable is reset", () =>
+    expect(
+      func(
+        `
+          hopp.env.set("a", "S")
+          hopp.env.global.set("a", "G")
+          hopp.env.reset("a")
+        `,
+        {
+          selected: [
+            {
+              key: "a",
+              currentValue: "sel",
+              initialValue: "initSel",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "a",
+              currentValue: "glob",
+              initialValue: "initGlob",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "a",
+            currentValue: "initSel",
+            initialValue: "initSel",
+            secret: false,
+          },
+        ],
+        global: [
+          {
+            key: "a",
+            currentValue: "G",
+            initialValue: "initGlob",
+            secret: false,
+          },
+        ],
+      })
+    ))
+
+  test("resets only the first occurrence if duplicates exist in selected", () =>
+    expect(
+      func(
+        `
+          hopp.env.set("dup", "X")
+          hopp.env.reset("dup")
+        `,
+        {
+          selected: [
+            { key: "dup", currentValue: "A", initialValue: "A", secret: false },
+            { key: "dup", currentValue: "B", initialValue: "B", secret: false },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          { key: "dup", currentValue: "A", initialValue: "A", secret: false },
+          { key: "dup", currentValue: "B", initialValue: "B", secret: false },
+        ],
+      })
+    ))
+
+  test("resets only the first occurrence if duplicates exist in global", () =>
+    expect(
+      func(
+        `
+          hopp.env.global.set("gdup", "Y")
+          hopp.env.reset("gdup")
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "gdup",
+              currentValue: "G1",
+              initialValue: "I1",
+              secret: false,
+            },
+            {
+              key: "gdup",
+              currentValue: "G2",
+              initialValue: "I2",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "gdup",
+            currentValue: "I1",
+            initialValue: "I1",
+            secret: false,
+          },
+          {
+            key: "gdup",
+            currentValue: "G2",
+            initialValue: "I2",
+            secret: false,
+          },
+        ],
+      })
+    ))
+
+  test("no change if attempting to reset a non-existent key", () =>
+    expect(
+      func(`hopp.env.reset("none")`, { selected: [], global: [] })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({ selected: [], global: [] })
+    ))
+
+  test("keys should be a string", () =>
+    expect(
+      func(`hopp.env.reset(123)`, { selected: [], global: [] })()
+    ).resolves.toBeLeft())
+
+  test("reset reflected in subsequent get in the same script (selected)", () =>
+    expect(
+      funcTest(
+        `
+          hopp.env.set("foo", "override")
+          hopp.env.reset("foo")
+          hopp.expect(hopp.env.get("foo")).toBe("bar")
+        `,
+        {
+          selected: [
+            {
+              key: "foo",
+              currentValue: "bar",
+              initialValue: "bar",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'bar' to be 'bar'" },
+        ],
+      }),
+    ]))
+
+  test("reset works for secret variables", () =>
+    expect(
+      func(
+        `
+          hopp.env.set("secret", "newVal")
+          hopp.env.reset("secret")
+        `,
+        {
+          selected: [
+            {
+              key: "secret",
+              currentValue: "origi",
+              initialValue: "origi",
+              secret: true,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "secret",
+            currentValue: "origi",
+            initialValue: "origi",
+            secret: true,
+          },
+        ],
+      })
+    ))
+})
+
+describe("hopp.env.active.reset", () => {
+  test("resets variable only in selected environment", () =>
+    expect(
+      func(
+        `
+          hopp.env.active.set("xxx", "MUT")
+          hopp.env.active.reset("xxx")
+        `,
+        {
+          selected: [
+            { key: "xxx", currentValue: "A", initialValue: "A", secret: false },
+          ],
+          global: [
+            { key: "xxx", currentValue: "B", initialValue: "B", secret: false },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          { key: "xxx", currentValue: "A", initialValue: "A", secret: false },
+        ],
+        global: [
+          { key: "xxx", currentValue: "B", initialValue: "B", secret: false },
+        ],
+      })
+    ))
+
+  test("no effect if key not in selected", () =>
+    expect(
+      func(
+        `
+          hopp.env.active.reset("nonexistent")
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "nonexistent",
+              currentValue: "G",
+              initialValue: "G",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [],
+        global: [
+          {
+            key: "nonexistent",
+            currentValue: "G",
+            initialValue: "G",
+            secret: false,
+          },
+        ],
+      })
+    ))
+
+  test("key must be a string", () =>
+    expect(
+      func(`hopp.env.active.reset(123)`, { selected: [], global: [] })()
+    ).resolves.toBeLeft())
+})
+
+describe("hopp.env.global.reset", () => {
+  test("resets variable only in global environment", () =>
+    expect(
+      func(
+        `
+          hopp.env.global.set("yyy", "GGG")
+          hopp.env.global.reset("yyy")
+        `,
+        {
+          selected: [
+            { key: "yyy", currentValue: "S", initialValue: "S", secret: false },
+          ],
+          global: [
+            {
+              key: "yyy",
+              currentValue: "G",
+              initialValue: "GI",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          { key: "yyy", currentValue: "S", initialValue: "S", secret: false },
+        ],
+        global: [
+          { key: "yyy", currentValue: "GI", initialValue: "GI", secret: false },
+        ],
+      })
+    ))
+
+  test("no effect if key not in global", () =>
+    expect(
+      func(
+        `
+          hopp.env.global.reset("nonexistent")
+        `,
+        {
+          selected: [
+            {
+              key: "nonexistent",
+              currentValue: "S",
+              initialValue: "S",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "nonexistent",
+            currentValue: "S",
+            initialValue: "S",
+            secret: false,
+          },
+        ],
+        global: [],
+      })
+    ))
+
+  // Additional regression tests ensuring reset uses the latest state
+  describe("hopp.env.reset - regression cases", () => {
+    test("create via setInitial then set, and reset restores to initial (selected)", () =>
+      expect(
+        func(
+          `
+          // Variable does not exist initially
+          hopp.env.setInitial("AUTH_TOKEN", "seeded-v1")
+          hopp.env.set("AUTH_TOKEN", "overridden-v2")
+          hopp.env.reset("AUTH_TOKEN")
+        `,
+          {
+            selected: [],
+            global: [],
+          }
+        )()
+      ).resolves.toEqualRight(
+        expect.objectContaining({
+          selected: [
+            {
+              key: "AUTH_TOKEN",
+              currentValue: "seeded-v1",
+              initialValue: "seeded-v1",
+              secret: false,
+            },
+          ],
+          global: [],
+        })
+      ))
+
+    test("scope flip: remove from global, create in active, reset only affects active and not deleted global", () =>
+      expect(
+        func(
+          `
+          // Start by ensuring global is cleared
+          hopp.env.global.delete("API_KEY")
+          // Create in active with initial and then override
+          hopp.env.active.setInitial("API_KEY", "run-initial")
+          hopp.env.active.set("API_KEY", "run-override")
+          // Reset should restore to initial in active, global remains absent
+          hopp.env.active.reset("API_KEY")
+        `,
+          {
+            selected: [],
+            global: [
+              // Simulate global having had a value in the past; we delete within the script
+              {
+                key: "API_KEY",
+                currentValue: "old-glob",
+                initialValue: "old-glob",
+                secret: false,
+              },
+            ],
+          }
+        )()
+      ).resolves.toEqualRight(
+        expect.objectContaining({
+          selected: [
+            {
+              key: "API_KEY",
+              currentValue: "run-initial",
+              initialValue: "run-initial",
+              secret: false,
+            },
+          ],
+          // After delete, global should not contain API_KEY
+          global: [],
+        })
+      ))
+
+    test("delete then reset within same script should be a no-op (selected)", () =>
+      expect(
+        func(
+          `
+          hopp.env.active.delete("SESSION_ID")
+          // Reset after unset should not reintroduce or change anything
+          hopp.env.active.reset("SESSION_ID")
+        `,
+          {
+            selected: [
+              {
+                key: "SESSION_ID",
+                currentValue: "s-1",
+                initialValue: "s-1",
+                secret: false,
+              },
+            ],
+            global: [],
+          }
+        )()
+      ).resolves.toEqualRight(
+        expect.objectContaining({
+          selected: [],
+          global: [],
+        })
+      ))
+  })
+  test("key must be a string", () =>
+    expect(
+      func(`hopp.env.global.reset([])`, { selected: [], global: [] })()
+    ).resolves.toBeLeft())
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/set.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/set.spec.ts
new file mode 100644
index 00000000..54f08478
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/set.spec.ts
@@ -0,0 +1,388 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const execEnv = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.envs)
+  )
+
+const execTest = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("hopp.env.set", () => {
+  test("updates the selected environment variable correctly", () => {
+    return expect(
+      execEnv(`hopp.env.set("a", "c")`, {
+        global: [],
+        selected: [
+          { key: "a", currentValue: "b", initialValue: "b", secret: false },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          { key: "a", currentValue: "c", initialValue: "b", secret: false },
+        ],
+      })
+    )
+  })
+
+  test("updates the global environment variable correctly", () => {
+    return expect(
+      execEnv(`hopp.env.set("a", "c")`, {
+        global: [
+          { key: "a", currentValue: "b", initialValue: "b", secret: false },
+        ],
+        selected: [],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          { key: "a", currentValue: "c", initialValue: "b", secret: false },
+        ],
+      })
+    )
+  })
+
+  test("if env exists in both, updates only selected", () => {
+    return expect(
+      execEnv(`hopp.env.set("a", "selC")`, {
+        global: [
+          {
+            key: "a",
+            currentValue: "globB",
+            initialValue: "globB",
+            secret: false,
+          },
+        ],
+        selected: [
+          {
+            key: "a",
+            currentValue: "selD",
+            initialValue: "selD",
+            secret: false,
+          },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "a",
+            currentValue: "globB",
+            initialValue: "globB",
+            secret: false,
+          },
+        ],
+        selected: [
+          {
+            key: "a",
+            currentValue: "selC",
+            initialValue: "selD",
+            secret: false,
+          },
+        ],
+      })
+    )
+  })
+
+  test("creates non-existent key in selected environment", () => {
+    return expect(
+      execEnv(`hopp.env.set("a", "created")`, { global: [], selected: [] })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "a",
+            currentValue: "created",
+            initialValue: "created",
+            secret: false,
+          },
+        ],
+        global: [],
+      })
+    )
+  })
+
+  test("does not affect secret status for existing variable", () => {
+    return expect(
+      execEnv(`hopp.env.set("mysecret", "not-secret-anymore")`, {
+        selected: [
+          {
+            key: "mysecret",
+            currentValue: "secretvalue",
+            initialValue: "secretvalue",
+            secret: true,
+          },
+        ],
+        global: [],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "mysecret",
+            currentValue: "not-secret-anymore",
+            initialValue: "secretvalue",
+            secret: true,
+          },
+        ],
+      })
+    )
+  })
+
+  test("rejects non-string key", () => {
+    return expect(
+      execEnv(`hopp.env.set(7, "foo")`, { selected: [], global: [] })()
+    ).resolves.toBeLeft()
+  })
+
+  test("rejects non-string value", () => {
+    return expect(
+      execEnv(`hopp.env.set("key", 123)`, { selected: [], global: [] })()
+    ).resolves.toBeLeft()
+  })
+
+  test("both key and value must be strings", () => {
+    return expect(
+      execEnv(`hopp.env.set(5, 6)`, { selected: [], global: [] })()
+    ).resolves.toBeLeft()
+  })
+
+  test("set environment values are reflected immediately", () => {
+    return expect(
+      execTest(
+        `
+          hopp.env.set("foo", "bar")
+          hopp.expect(hopp.env.get("foo")).toBe("bar")
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'bar' to be 'bar'" },
+        ],
+      }),
+    ])
+  })
+})
+
+describe("hopp.env.active.set", () => {
+  test("sets in selected even if key exists in global", () => {
+    return expect(
+      execEnv(`hopp.env.active.set("b", "in-selected")`, {
+        selected: [],
+        global: [
+          {
+            key: "b",
+            currentValue: "in-global",
+            initialValue: "in-global",
+            secret: false,
+          },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "b",
+            currentValue: "in-selected",
+            initialValue: "in-selected",
+            secret: false,
+          },
+        ],
+        global: [
+          {
+            key: "b",
+            currentValue: "in-global",
+            initialValue: "in-global",
+            secret: false,
+          },
+        ],
+      })
+    )
+  })
+
+  test("updates existing selected variable", () => {
+    return expect(
+      execEnv(`hopp.env.active.set("foo", "bar")`, {
+        selected: [
+          {
+            key: "foo",
+            currentValue: "baz",
+            initialValue: "baz",
+            secret: false,
+          },
+        ],
+        global: [],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "foo",
+            currentValue: "bar",
+            initialValue: "baz",
+            secret: false,
+          },
+        ],
+      })
+    )
+  })
+
+  test("creates a new key in selected", () => {
+    return expect(
+      execEnv(`hopp.env.active.set("make", "new")`, {
+        selected: [],
+        global: [],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "make",
+            currentValue: "new",
+            initialValue: "new",
+            secret: false,
+          },
+        ],
+        global: [],
+      })
+    )
+  })
+
+  test("rejects non-string key", () => {
+    return expect(
+      execEnv(`hopp.env.active.set(null, "value")`, {
+        selected: [],
+        global: [],
+      })()
+    ).resolves.toBeLeft()
+  })
+
+  test("rejects non-string value", () => {
+    return expect(
+      execEnv(`hopp.env.active.set("key", {})`, { selected: [], global: [] })()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.global.set", () => {
+  test("creates in global, does not affect selected", () => {
+    return expect(
+      execEnv(`hopp.env.global.set("c", "in-global")`, {
+        selected: [
+          {
+            key: "c",
+            currentValue: "selected",
+            initialValue: "selected",
+            secret: false,
+          },
+        ],
+        global: [],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [
+          {
+            key: "c",
+            currentValue: "selected",
+            initialValue: "selected",
+            secret: false,
+          },
+        ],
+        global: [
+          {
+            key: "c",
+            currentValue: "in-global",
+            initialValue: "in-global",
+            secret: false,
+          },
+        ],
+      })
+    )
+  })
+
+  test("updates existing global variable", () => {
+    return expect(
+      execEnv(`hopp.env.global.set("d", "updated")`, {
+        selected: [],
+        global: [
+          { key: "d", currentValue: "old", initialValue: "old", secret: false },
+        ],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        global: [
+          {
+            key: "d",
+            currentValue: "updated",
+            initialValue: "old",
+            secret: false,
+          },
+        ],
+      })
+    )
+  })
+
+  test("creates new variable in global", () => {
+    return expect(
+      execEnv(`hopp.env.global.set("e", "new-value")`, {
+        selected: [],
+        global: [],
+      })()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        selected: [],
+        global: [
+          {
+            key: "e",
+            currentValue: "new-value",
+            initialValue: "new-value",
+            secret: false,
+          },
+        ],
+      })
+    )
+  })
+
+  test("rejects non-string key", () => {
+    return expect(
+      execEnv(`hopp.env.global.set([], "foo")`, { selected: [], global: [] })()
+    ).resolves.toBeLeft()
+  })
+
+  test("rejects non-string value", () => {
+    return expect(
+      execEnv(`hopp.env.global.set("key", true)`, {
+        selected: [],
+        global: [],
+      })()
+    ).resolves.toBeLeft()
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/setInitial.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/setInitial.spec.ts
new file mode 100644
index 00000000..83e8af56
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/env/setInitial.spec.ts
@@ -0,0 +1,526 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("hopp.env.setInitial", () => {
+  test("sets initial value in selected env when key doesn't exist", () => {
+    return expect(
+      func(
+        `
+          hopp.env.setInitial("newKey", "newValue")
+          const val = hopp.env.getInitialRaw("newKey")
+          hopp.expect(val).toBe("newValue")
+        `,
+        {
+          selected: [],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'newValue' to be 'newValue'" },
+        ],
+      }),
+    ])
+  })
+
+  test("updates initial value in selected env when key exists", () => {
+    return expect(
+      func(
+        `
+          hopp.env.setInitial("existing", "updated")
+          const val = hopp.env.getInitialRaw("existing")
+          hopp.expect(val).toBe("updated")
+        `,
+        {
+          selected: [
+            {
+              key: "existing",
+              currentValue: "current",
+              initialValue: "original",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'updated' to be 'updated'" },
+        ],
+      }),
+    ])
+  })
+
+  test("updates selected env when key exists in both selected and global", () => {
+    return expect(
+      func(
+        `
+          hopp.env.setInitial("shared", "selectedUpdate")
+          const val = hopp.env.getInitialRaw("shared")
+          hopp.expect(val).toBe("selectedUpdate")
+        `,
+        {
+          selected: [
+            {
+              key: "shared",
+              currentValue: "selCur",
+              initialValue: "selInit",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "shared",
+              currentValue: "globCur",
+              initialValue: "globInit",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'selectedUpdate' to be 'selectedUpdate'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("sets initial value in global env when only exists in global", () => {
+    return expect(
+      func(
+        `
+          hopp.env.setInitial("globalOnly", "globalUpdate")
+          const val = hopp.env.getInitialRaw("globalOnly")
+          hopp.expect(val).toBe("globalUpdate")
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "globalOnly",
+              currentValue: "current",
+              initialValue: "original",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'globalUpdate' to be 'globalUpdate'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("allows setting empty string as initial value", () => {
+    return expect(
+      func(
+        `
+          hopp.env.setInitial("empty", "")
+          const val = hopp.env.getInitialRaw("empty")
+          hopp.expect(val).toBe("")
+        `,
+        {
+          selected: [],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected '' to be ''" }],
+      }),
+    ])
+  })
+
+  test("allows setting template syntax as initial value", () => {
+    return expect(
+      func(
+        `
+          hopp.env.setInitial("template", "<<FOO>>")
+          const val = hopp.env.getInitialRaw("template")
+          hopp.expect(val).toBe("<<FOO>>")
+        `,
+        {
+          selected: [],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected '<<FOO>>' to be '<<FOO>>'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors for non-string key", () => {
+    return expect(
+      func(
+        `
+          hopp.env.setInitial(123, "value")
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("errors for non-string value", () => {
+    return expect(
+      func(
+        `
+          hopp.env.setInitial("key", 456)
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.active.setInitial", () => {
+  test("sets initial value in selected env only", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.setInitial("activeKey", "activeValue")
+          const activeVal = hopp.env.active.getInitialRaw("activeKey")
+          const globalVal = hopp.env.global.getInitialRaw("activeKey")
+          hopp.expect(activeVal).toBe("activeValue")
+          hopp.expect(globalVal).toBe(null)
+        `,
+        {
+          selected: [],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'activeValue' to be 'activeValue'",
+          },
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("updates existing selected env variable", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.setInitial("existing", "updated")
+          const val = hopp.env.active.getInitialRaw("existing")
+          hopp.expect(val).toBe("updated")
+        `,
+        {
+          selected: [
+            {
+              key: "existing",
+              currentValue: "current",
+              initialValue: "original",
+              secret: false,
+            },
+          ],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'updated' to be 'updated'" },
+        ],
+      }),
+    ])
+  })
+
+  test("does not affect global env even if key exists there", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.setInitial("shared", "activeUpdate")
+          const activeVal = hopp.env.active.getInitialRaw("shared")
+          const globalVal = hopp.env.global.getInitialRaw("shared")
+          hopp.expect(activeVal).toBe("activeUpdate")
+          hopp.expect(globalVal).toBe("globalOriginal")
+        `,
+        {
+          selected: [
+            {
+              key: "shared",
+              currentValue: "selCur",
+              initialValue: "selInit",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "shared",
+              currentValue: "globCur",
+              initialValue: "globalOriginal",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'activeUpdate' to be 'activeUpdate'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'globalOriginal' to be 'globalOriginal'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("allows setting empty string", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.setInitial("blank", "")
+          const val = hopp.env.active.getInitialRaw("blank")
+          hopp.expect(val).toBe("")
+        `,
+        {
+          selected: [],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected '' to be ''" }],
+      }),
+    ])
+  })
+
+  test("errors for non-string key", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.setInitial(null, "value")
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("errors for non-string value", () => {
+    return expect(
+      func(
+        `
+          hopp.env.active.setInitial("key", {})
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
+
+describe("hopp.env.global.setInitial", () => {
+  test("sets initial value in global env only", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.setInitial("globalKey", "globalValue")
+          const globalVal = hopp.env.global.getInitialRaw("globalKey")
+          const activeVal = hopp.env.active.getInitialRaw("globalKey")
+          hopp.expect(globalVal).toBe("globalValue")
+          hopp.expect(activeVal).toBe(null)
+        `,
+        {
+          selected: [],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'globalValue' to be 'globalValue'",
+          },
+          { status: "pass", message: "Expected 'null' to be 'null'" },
+        ],
+      }),
+    ])
+  })
+
+  test("updates existing global env variable", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.setInitial("existing", "updated")
+          const val = hopp.env.global.getInitialRaw("existing")
+          hopp.expect(val).toBe("updated")
+        `,
+        {
+          selected: [],
+          global: [
+            {
+              key: "existing",
+              currentValue: "current",
+              initialValue: "original",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'updated' to be 'updated'" },
+        ],
+      }),
+    ])
+  })
+
+  test("does not affect selected env even if key exists there", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.setInitial("shared", "globalUpdate")
+          const globalVal = hopp.env.global.getInitialRaw("shared")
+          const activeVal = hopp.env.active.getInitialRaw("shared")
+          hopp.expect(globalVal).toBe("globalUpdate")
+          hopp.expect(activeVal).toBe("activeOriginal")
+        `,
+        {
+          selected: [
+            {
+              key: "shared",
+              currentValue: "selCur",
+              initialValue: "activeOriginal",
+              secret: false,
+            },
+          ],
+          global: [
+            {
+              key: "shared",
+              currentValue: "globCur",
+              initialValue: "globInit",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'globalUpdate' to be 'globalUpdate'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'activeOriginal' to be 'activeOriginal'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("allows setting empty string", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.setInitial("empty", "")
+          const val = hopp.env.global.getInitialRaw("empty")
+          hopp.expect(val).toBe("")
+        `,
+        {
+          selected: [],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected '' to be ''" }],
+      }),
+    ])
+  })
+
+  test("allows setting template syntax", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.setInitial("template", "<<BAR>>")
+          const val = hopp.env.global.getInitialRaw("template")
+          hopp.expect(val).toBe("<<BAR>>")
+        `,
+        {
+          selected: [],
+          global: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected '<<BAR>>' to be '<<BAR>>'" },
+        ],
+      }),
+    ])
+  })
+
+  test("errors for non-string key", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.setInitial([], "value")
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("errors for non-string value", () => {
+    return expect(
+      func(
+        `
+          hopp.env.global.setInitial("key", true)
+        `,
+        { selected: [], global: [] }
+      )()
+    ).resolves.toBeLeft()
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/request.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/request.spec.ts
new file mode 100644
index 00000000..ccf73107
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/request.spec.ts
@@ -0,0 +1,725 @@
+import {
+  HoppRESTAuth,
+  HoppRESTReqBody,
+  HoppRESTRequest,
+} from "@hoppscotch/data"
+import { describe, expect, test } from "vitest"
+
+import { runPreRequestScript, runTestScript } from "~/web"
+import { TestResponse } from "~/types"
+
+const baseRequest: HoppRESTRequest = {
+  v: "15",
+  name: "Test Request",
+  endpoint: "https://example.com/api",
+  method: "GET",
+  headers: [{ key: "X-Test", value: "val1", active: true, description: "" }],
+  params: [{ key: "q", value: "search", active: true, description: "" }],
+  body: { contentType: null, body: null },
+  auth: { authType: "none", authActive: false },
+  preRequestScript: "",
+  testScript: "",
+  requestVariables: [{ key: "req-var-1", value: "value-1", active: true }],
+  responses: {},
+}
+
+const testResponse: TestResponse = {
+  status: 200,
+  body: "OK",
+  headers: [],
+  statusText: "OK",
+  responseTime: 200,
+}
+
+describe("hopp.request", () => {
+  test("hopp.request basic properties are accessible from pre-request script", () => {
+    const envs = { global: [], selected: [] }
+
+    return expect(
+      runPreRequestScript(
+        `
+        console.log("URL:", hopp.request.url);
+        console.log("Method:", hopp.request.method);
+        console.log("Params:", hopp.request.params);
+        console.log("Headers:", hopp.request.headers);
+        console.log("Body:", hopp.request.body);
+        console.log("Auth:", hopp.request.auth);`,
+        {
+          envs,
+          request: baseRequest,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [
+          expect.objectContaining({
+            args: ["URL:", "https://example.com/api"],
+          }),
+          expect.objectContaining({
+            args: ["Method:", "GET"],
+          }),
+          expect.objectContaining({
+            args: ["Params:", baseRequest.params],
+          }),
+          expect.objectContaining({
+            args: ["Headers:", baseRequest.headers],
+          }),
+          expect.objectContaining({
+            args: ["Body:", baseRequest.body],
+          }),
+          expect.objectContaining({
+            args: ["Auth:", baseRequest.auth],
+          }),
+        ],
+      })
+    )
+  })
+
+  test("hopp.request properties are read-only in both pre-request and test script contexts", () => {
+    const envs = { global: [], selected: [] }
+    const response: TestResponse = {
+      status: 200,
+      body: "test response",
+      headers: [],
+    }
+
+    // Properties that are read-only in both contexts
+    const basicReadOnlyTests = [
+      { property: "url", value: "'https://new-url.com'" },
+      { property: "method", value: "'PUT'" },
+      { property: "params", value: "[]" },
+      { property: "headers", value: "[]" },
+      { property: "body", value: "{}" },
+      { property: "auth", value: "{}" },
+    ]
+
+    // Properties that are read-only only in test script context
+    const testScriptOnlyReadOnlyTests = [{ property: "variables", value: "{}" }]
+
+    // Test basic properties in pre-request script context
+    const preRequestTests = basicReadOnlyTests.map(({ property, value }) =>
+      expect(
+        runPreRequestScript(`hopp.request.${property} = ${value}`, {
+          envs,
+          request: baseRequest,
+        })
+      ).resolves.toEqualLeft(
+        `Script execution failed: hopp.request.${property} is read-only`
+      )
+    )
+
+    // Test all properties in test script context
+    const allReadOnlyTests = [
+      ...basicReadOnlyTests,
+      ...testScriptOnlyReadOnlyTests,
+    ]
+    const testScriptTests = allReadOnlyTests.map(({ property, value }) =>
+      expect(
+        runTestScript(`hopp.request.${property} = ${value}`, {
+          envs,
+          request: baseRequest,
+          response,
+        })
+      ).resolves.toEqualLeft(
+        `Script execution failed: hopp.request.${property} is read-only`
+      )
+    )
+
+    return Promise.all([...preRequestTests, ...testScriptTests])
+  })
+
+  test("hopp.request.setUrl should update the URL", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setUrl("https://updated.com/api")`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          endpoint: "https://updated.com/api",
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setMethod should update and uppercase the method", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setMethod("post")`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          method: "POST",
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setHeader should update existing header case-insensitively", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setHeader("x-test", "updatedVal")`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          headers: [
+            expect.objectContaining({
+              key: "X-Test",
+              value: "updatedVal",
+            }),
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setHeader should add new header if not present", () => {
+    return expect(
+      runPreRequestScript(
+        `hopp.request.setHeader("X-New-Header", "newValue")`,
+        {
+          envs: { global: [], selected: [] },
+          request: baseRequest,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          headers: expect.arrayContaining([
+            expect.objectContaining({ key: "X-New-Header", value: "newValue" }),
+          ]),
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.removeHeader should remove a header", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.removeHeader("X-Test")`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          headers: [],
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setParam should update existing param case-insensitively", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setParam("Q", "updatedParam")`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          params: [
+            expect.objectContaining({ key: "q", value: "updatedParam" }),
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setParam should add new param if absent", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setParam("newParam", "value")`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          params: expect.arrayContaining([
+            expect.objectContaining({ key: "newParam", value: "value" }),
+          ]),
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.removeParam should remove a param", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.removeParam("q")`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          params: [],
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setBody should update the body with complete replacement", () => {
+    const newBody: HoppRESTReqBody = {
+      contentType: "application/json",
+      body: JSON.stringify({ changed: true }),
+    }
+    return expect(
+      runPreRequestScript(`hopp.request.setBody(${JSON.stringify(newBody)})`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          body: newBody,
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setBody should support partial merge", () => {
+    // Base request with existing JSON body
+    const requestWithBody: HoppRESTRequest = {
+      ...baseRequest,
+      body: {
+        contentType: "application/json",
+        body: JSON.stringify({ existing: "data", keep: true }),
+      },
+    }
+
+    // Script that only updates contentType, preserving body content
+    const partialUpdate = { contentType: "application/xml" }
+
+    return expect(
+      runPreRequestScript(
+        `hopp.request.setBody(${JSON.stringify(partialUpdate)})`,
+        {
+          envs: { global: [], selected: [] },
+          request: requestWithBody,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          body: {
+            contentType: "application/xml",
+            body: JSON.stringify({ existing: "data", keep: true }),
+          },
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setAuth should update the auth with complete replacement", () => {
+    const newAuth: HoppRESTAuth = {
+      authType: "basic",
+      username: "abc",
+      password: "123",
+      authActive: true,
+    }
+
+    return expect(
+      runPreRequestScript(`hopp.request.setAuth(${JSON.stringify(newAuth)})`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          auth: newAuth,
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setAuth should support partial merge", () => {
+    // Base request with existing basic auth
+    const requestWithAuth: HoppRESTRequest = {
+      ...baseRequest,
+      auth: {
+        authType: "basic",
+        username: "original-user",
+        password: "original-pass",
+        authActive: true,
+      },
+    }
+
+    // Script that only updates the username, preserving other fields
+    const partialUpdate = { username: "updated-user" }
+
+    return expect(
+      runPreRequestScript(
+        `hopp.request.setAuth(${JSON.stringify(partialUpdate)})`,
+        {
+          envs: { global: [], selected: [] },
+          request: requestWithAuth,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          auth: {
+            authType: "basic",
+            username: "updated-user",
+            password: "original-pass",
+            authActive: true,
+          },
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setAuth should handle auth type switching", () => {
+    // Base request with bearer auth
+    const requestWithBearerAuth: HoppRESTRequest = {
+      ...baseRequest,
+      auth: {
+        authType: "bearer",
+        token: "old-bearer-token",
+        authActive: true,
+      },
+    }
+
+    // Switch to basic auth (complete replacement)
+    const switchToBasic: HoppRESTAuth = {
+      authType: "basic",
+      username: "new-user",
+      password: "new-pass",
+      authActive: true,
+    }
+
+    return expect(
+      runPreRequestScript(
+        `hopp.request.setAuth(${JSON.stringify(switchToBasic)})`,
+        {
+          envs: { global: [], selected: [] },
+          request: requestWithBearerAuth,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          auth: switchToBasic,
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.setHeaders throws error on invalid input", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setHeaders(null)`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.request.setParams throws error on invalid input", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setParams(null)`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.request.setBody throws error on invalid input", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setBody("invalid_body")`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.request.setAuth throws error on invalid input", () => {
+    return expect(
+      runPreRequestScript(`hopp.request.setAuth({})`, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.request.variables.get should return the request variable", () => {
+    return expect(
+      runPreRequestScript(
+        `console.log(hopp.request.variables.get("req-var-1"))`,
+        {
+          envs: { global: [], selected: [] },
+          request: baseRequest,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [expect.objectContaining({ args: ["value-1"] })],
+      })
+    )
+  })
+
+  test("hopp.request.variables.set should update the request variable", () => {
+    return expect(
+      runPreRequestScript(
+        `hopp.request.variables.set("req-var-1", "new-value-1")`,
+        {
+          envs: { global: [], selected: [] },
+          request: baseRequest,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          requestVariables: [
+            {
+              key: "req-var-1",
+              value: "new-value-1",
+              active: true,
+            },
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.variables.set should add a new request variable if the supplied key does not exist", () => {
+    return expect(
+      runPreRequestScript(
+        `hopp.request.variables.set("req-var-2", "value-2")`,
+        {
+          envs: { global: [], selected: [] },
+          request: baseRequest,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedRequest: expect.objectContaining({
+          requestVariables: [
+            {
+              key: "req-var-1",
+              value: "value-1",
+              active: true,
+            },
+            {
+              key: "req-var-2",
+              value: "value-2",
+              active: true,
+            },
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.request.variables.set should not work in post-request script context", () => {
+    const envs = { global: [], selected: [] }
+
+    return expect(
+      runTestScript(
+        `hopp.request.variables.set("req-var-1", "new-value-from-test")`,
+        {
+          envs,
+          request: baseRequest,
+          response: testResponse,
+        }
+      )
+    ).resolves.toEqualLeft(`Script execution failed: not a function`)
+  })
+
+  test("hopp.request read-only properties are accessible from post-request script", () => {
+    const envs = { global: [], selected: [] }
+
+    const testRequest: HoppRESTRequest = {
+      ...baseRequest,
+      method: "POST",
+      endpoint: "https://api.example.com/users",
+      params: [{ key: "page", value: "1", active: true, description: "" }],
+      headers: [
+        {
+          key: "Authorization",
+          value: "Bearer token123",
+          active: true,
+          description: "",
+        },
+        {
+          key: "Content-Type",
+          value: "application/json",
+          active: true,
+          description: "",
+        },
+      ],
+      body: {
+        contentType: "application/json",
+        body: JSON.stringify({ name: "John", age: 30 }),
+      },
+      auth: {
+        authType: "bearer",
+        authActive: true,
+        token: "test-token-123",
+      },
+    }
+
+    return expect(
+      runTestScript(
+        `
+        hopp.expect(hopp.request.url).toBe("https://api.example.com/users")
+        hopp.expect(hopp.request.method).toBe("POST")
+        hopp.expect(hopp.request.params.length).toBe(1)
+        hopp.expect(hopp.request.params[0].key).toBe("page")
+        hopp.expect(hopp.request.params[0].value).toBe("1")
+        hopp.expect(hopp.request.headers.length).toBe(2)
+        hopp.expect(hopp.request.headers[0].key).toBe("Authorization")
+        hopp.expect(hopp.request.headers[0].value).toBe("Bearer token123")
+        hopp.expect(hopp.request.headers[1].key).toBe("Content-Type")
+        hopp.expect(hopp.request.headers[1].value).toBe("application/json")
+        hopp.expect(hopp.request.body.contentType).toBe("application/json")
+        hopp.expect(hopp.request.body.body).toBe('{"name":"John","age":30}')
+        hopp.expect(hopp.request.auth.authType).toBe("bearer")
+        hopp.expect(hopp.request.auth.token).toBe("test-token-123")
+        `,
+        {
+          envs,
+          request: testRequest,
+          response: testResponse,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        tests: expect.objectContaining({
+          expectResults: [
+            {
+              status: "pass",
+              message:
+                "Expected 'https://api.example.com/users' to be 'https://api.example.com/users'",
+            },
+            { status: "pass", message: "Expected 'POST' to be 'POST'" },
+            { status: "pass", message: "Expected '1' to be '1'" },
+            { status: "pass", message: "Expected 'page' to be 'page'" },
+            { status: "pass", message: "Expected '1' to be '1'" },
+            { status: "pass", message: "Expected '2' to be '2'" },
+            {
+              status: "pass",
+              message: "Expected 'Authorization' to be 'Authorization'",
+            },
+            {
+              status: "pass",
+              message: "Expected 'Bearer token123' to be 'Bearer token123'",
+            },
+            {
+              status: "pass",
+              message: "Expected 'Content-Type' to be 'Content-Type'",
+            },
+            {
+              status: "pass",
+              message: "Expected 'application/json' to be 'application/json'",
+            },
+            {
+              status: "pass",
+              message: "Expected 'application/json' to be 'application/json'",
+            },
+            {
+              status: "pass",
+              message:
+                'Expected \'{"name":"John","age":30}\' to be \'{"name":"John","age":30}\'',
+            },
+            { status: "pass", message: "Expected 'bearer' to be 'bearer'" },
+            {
+              status: "pass",
+              message: "Expected 'test-token-123' to be 'test-token-123'",
+            },
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.request setter methods should not be available in post-request", async () => {
+    const script = `
+        hopp.request.setUrl("http://modified.com")
+      `
+
+    await expect(
+      runTestScript(script, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+        response: testResponse,
+      })
+    ).resolves.toEqualLeft(expect.stringContaining("not a function"))
+  })
+
+  test("hopp.request.setHeader should not be available in post-request", async () => {
+    const script = `
+        hopp.request.setHeader("X-Test", "value")
+      `
+
+    await expect(
+      runTestScript(script, {
+        envs: { global: [], selected: [] },
+        request: baseRequest,
+        response: testResponse,
+      })
+    ).resolves.toEqualLeft(expect.stringContaining("not a function"))
+  })
+
+  // Request property immutability tests in post-request context
+  describe("property immutability in post-request context", () => {
+    test("hopp.request.url should be read-only", async () => {
+      const script = `
+        hopp.request.url = "http://modified.com"
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: baseRequest,
+          response: testResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.request.method should be read-only", async () => {
+      const script = `
+        hopp.request.method = "POST"
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: baseRequest,
+          response: testResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.request.headers should be read-only", async () => {
+      const script = `
+        hopp.request.headers = {}
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: baseRequest,
+          response: testResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.request.body should be read-only", async () => {
+      const script = `
+        hopp.request.body = "modified"
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: baseRequest,
+          response: testResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/response.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/response.spec.ts
new file mode 100644
index 00000000..cb57ee77
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/hopp-namespace/response.spec.ts
@@ -0,0 +1,465 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import { describe, expect, test } from "vitest"
+import { runTestScript } from "~/web"
+import { TestResponse } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+
+const sampleHeaders = [
+  { key: "content-type", value: "application/json" },
+  { key: "x-custom", value: "hello" },
+]
+
+const sampleJSONResponse: TestResponse = {
+  status: 201,
+  body: { ok: true, msg: "success" },
+  headers: sampleHeaders,
+  statusText: "Created",
+  responseTime: 123,
+}
+
+const sampleTextResponse: TestResponse = {
+  status: 200,
+  body: "Plaintext response",
+  headers: [{ key: "content-type", value: "text/plain" }],
+  statusText: "OK",
+  responseTime: 240,
+}
+
+describe("hopp.response", () => {
+  test("hopp.response.statusCode should return the status", async () => {
+    await expect(
+      runTestScript(`hopp.expect(hopp.response.statusCode).toBe(201)`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        response: sampleJSONResponse,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [],
+        envs: expect.objectContaining({
+          global: [],
+          selected: [],
+        }),
+        tests: expect.objectContaining({
+          children: [],
+          descriptor: "root",
+          expectResults: [
+            { status: "pass", message: "Expected '201' to be '201'" },
+          ],
+        }),
+        updatedCookies: null,
+      })
+    )
+  })
+
+  test("hopp.response.statusText should return the status text", async () => {
+    await expect(
+      runTestScript(`hopp.expect(hopp.response.statusText).toBe("Created")`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        response: sampleJSONResponse,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        tests: expect.objectContaining({
+          expectResults: [
+            { status: "pass", message: "Expected 'Created' to be 'Created'" },
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.response.responseTime should return the response time", async () => {
+    await expect(
+      runTestScript(`hopp.expect(hopp.response.responseTime).toBe(123)`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        response: sampleJSONResponse,
+      })
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [],
+        envs: expect.objectContaining({
+          global: [],
+          selected: [],
+        }),
+        tests: expect.objectContaining({
+          children: [],
+          descriptor: "root",
+          expectResults: [
+            { status: "pass", message: "Expected '123' to be '123'" },
+          ],
+        }),
+        updatedCookies: null,
+      })
+    )
+  })
+
+  test("hopp.response.headers should return all headers", async () => {
+    await expect(
+      runTestScript(
+        `
+        hopp.expect(hopp.response.headers.length).toBe(2)
+        hopp.expect(hopp.response.headers[0].key).toBe("content-type")
+        hopp.expect(hopp.response.headers[0].value).toBe("application/json")
+        hopp.expect(hopp.response.headers[1].key).toBe("x-custom")
+        hopp.expect(hopp.response.headers[1].value).toBe("hello")
+        `,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: sampleJSONResponse,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [],
+        envs: expect.objectContaining({
+          global: [],
+          selected: [],
+        }),
+        tests: expect.objectContaining({
+          children: [],
+          descriptor: "root",
+          expectResults: [
+            { status: "pass", message: "Expected '2' to be '2'" },
+            {
+              status: "pass",
+              message: "Expected 'content-type' to be 'content-type'",
+            },
+            {
+              status: "pass",
+              message: "Expected 'application/json' to be 'application/json'",
+            },
+            { status: "pass", message: "Expected 'x-custom' to be 'x-custom'" },
+            { status: "pass", message: "Expected 'hello' to be 'hello'" },
+          ],
+        }),
+        updatedCookies: null,
+      })
+    )
+  })
+
+  test("hopp.response.body.asText returns response text", async () => {
+    await expect(
+      runTestScript(
+        `hopp.expect(hopp.response.body.asText()).toBe("Plaintext response")`,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: sampleTextResponse,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        tests: expect.objectContaining({
+          expectResults: [
+            {
+              status: "pass",
+              message:
+                "Expected 'Plaintext response' to be 'Plaintext response'",
+            },
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.response.body.asJSON returns parsed object for JSON response", async () => {
+    await expect(
+      runTestScript(
+        `
+        const obj = hopp.response.body.asJSON()
+        hopp.expect(obj.ok).toBe(true)
+        hopp.expect(obj.msg).toBe("success")
+        `,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: sampleJSONResponse,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        tests: expect.objectContaining({
+          expectResults: [
+            {
+              status: "pass",
+              message: "Expected 'true' to be 'true'",
+            },
+            {
+              status: "pass",
+              message: "Expected 'success' to be 'success'",
+            },
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.response.body.asJSON throws for invalid JSON", async () => {
+    await expect(
+      runTestScript(`hopp.response.body.asJSON()`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        response: sampleTextResponse, // text, not JSON
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.response.body.asJSON throws error for invalid JSON body", async () => {
+    await expect(
+      runTestScript(`hopp.response.body.asJSON()`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        response: {
+          ...sampleJSONResponse,
+          body: "not a json!",
+          headers: [{ key: "content-type", value: "application/json" }],
+        },
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.response.body.bytes returns UTF-8 encoded data for JSON body", async () => {
+    await expect(
+      runTestScript(
+        `
+        const obj = hopp.response.body.bytes()
+        hopp.expect(obj["0"]).toBe(123)
+        hopp.expect(obj["1"]).toBe(34)
+        hopp.expect(obj["2"]).toBe(111)
+        hopp.expect(obj["26"]).toBe(125)
+        `,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: sampleJSONResponse,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        tests: expect.objectContaining({
+          expectResults: [
+            {
+              status: "pass",
+              message: "Expected '123' to be '123'",
+            },
+            {
+              status: "pass",
+              message: "Expected '34' to be '34'",
+            },
+            {
+              status: "pass",
+              message: "Expected '111' to be '111'",
+            },
+            {
+              status: "pass",
+              message: "Expected '125' to be '125'",
+            },
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.response.body.bytes throws error for unsupported body type", async () => {
+    await expect(
+      runTestScript(`hopp.response.body.bytes()`, {
+        envs: { global: [], selected: [] },
+        request: defaultRequest,
+        response: { ...sampleTextResponse, body: 1234 as any },
+      })
+    ).resolves.toBeLeft()
+  })
+
+  test("hopp.response.bytes returns UTF-8 encoded data for plain text", async () => {
+    await expect(
+      runTestScript(
+        `
+      const bytes = hopp.response.body.bytes()
+      hopp.expect(bytes["0"]).toBe(80)
+      hopp.expect(bytes["1"]).toBe(108)
+      hopp.expect(bytes["17"]).toBe(101)
+      `,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: sampleTextResponse,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        tests: expect.objectContaining({
+          expectResults: [
+            {
+              status: "pass",
+              message: "Expected '80' to be '80'",
+            },
+            {
+              status: "pass",
+              message: "Expected '108' to be '108'",
+            },
+            {
+              status: "pass",
+              message: "Expected '101' to be '101'",
+            },
+          ],
+        }),
+      })
+    )
+  })
+
+  test("hopp.response.bytes returns empty array for null/undefined body", async () => {
+    await expect(
+      runTestScript(
+        `
+      const bytes = hopp.response.body.bytes()
+      const bytesArray = Array.from(bytes)
+      hopp.expect(bytesArray.length).toBe(0)
+      `,
+        {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: { ...sampleTextResponse, body: null },
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        tests: expect.objectContaining({
+          expectResults: [
+            {
+              status: "pass",
+              message: "Expected '0' to be '0'",
+            },
+          ],
+        }),
+      })
+    )
+  })
+
+  // Response property immutability tests
+  describe("property immutability", () => {
+    const baseResponse: TestResponse = {
+      status: 200,
+      body: "OK",
+      headers: [],
+      statusText: "OK",
+      responseTime: 200,
+    }
+
+    test("hopp.response.statusCode should be read-only", async () => {
+      const script = `
+        hopp.response.statusCode = 500
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: baseResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.response.statusText should be read-only", async () => {
+      const script = `
+        hopp.response.statusText = "Modified"
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: baseResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.response.headers should be read-only", async () => {
+      const script = `
+        hopp.response.headers = {}
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: baseResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.response.responseTime should be read-only", async () => {
+      const script = `
+        hopp.response.responseTime = 1000
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: baseResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.response.body should be read-only", async () => {
+      const script = `
+        hopp.response.body = null
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: baseResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.response.body.asJSON should be read-only", async () => {
+      const script = `
+        hopp.response.body.asJSON = null
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: baseResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.response.body.asText should be read-only", async () => {
+      const script = `
+        hopp.response.body.asText = null
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: baseResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+
+    test("hopp.response.body.bytes should be read-only", async () => {
+      const script = `
+        hopp.response.body.bytes = null
+      `
+
+      await expect(
+        runTestScript(script, {
+          envs: { global: [], selected: [] },
+          request: defaultRequest,
+          response: baseResponse,
+        })
+      ).resolves.toEqualLeft(expect.stringContaining("read-only"))
+    })
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/environment.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/environment.spec.ts
new file mode 100644
index 00000000..050d6146
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/environment.spec.ts
@@ -0,0 +1,255 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("pm.environment additional coverage", () => {
+  test("pm.environment.set creates and retrieves environment variable", () => {
+    return expect(
+      func(
+        `
+          pm.environment.set("test_set", "set_value")
+          const retrieved = pm.environment.get("test_set")
+          pw.expect(retrieved).toBe("set_value")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'set_value' to be 'set_value'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.environment.has correctly identifies existing and non-existing variables", () => {
+    return expect(
+      func(
+        `
+          const hasExisting = pm.environment.has("existing_var")
+          const hasNonExisting = pm.environment.has("non_existing_var")
+          pw.expect(hasExisting.toString()).toBe("true")
+          pw.expect(hasNonExisting.toString()).toBe("false")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "existing_var",
+              currentValue: "existing_value",
+              initialValue: "existing_value",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'true' to be 'true'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'false' to be 'false'",
+          },
+        ],
+      }),
+    ])
+  })
+})
+
+describe("pm.globals additional coverage", () => {
+  test("pm.globals.set creates and retrieves global variable", () => {
+    return expect(
+      func(
+        `
+          pm.globals.set("test_global", "global_value")
+          const retrieved = pm.globals.get("test_global")
+          pw.expect(retrieved).toBe("global_value")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'global_value' to be 'global_value'",
+          },
+        ],
+      }),
+    ])
+  })
+})
+
+describe("pm.variables additional coverage", () => {
+  test("pm.variables.set creates and retrieves variable in active environment", () => {
+    return expect(
+      func(
+        `
+          pm.variables.set("test_var", "test_value")
+          const retrieved = pm.variables.get("test_var")
+          pw.expect(retrieved).toBe("test_value")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'test_value' to be 'test_value'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.variables.has correctly identifies existing and non-existing variables", () => {
+    return expect(
+      func(
+        `
+          const hasExisting = pm.variables.has("existing_var")
+          const hasNonExisting = pm.variables.has("non_existing_var")
+          pw.expect(hasExisting.toString()).toBe("true")
+          pw.expect(hasNonExisting.toString()).toBe("false")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "existing_var",
+              currentValue: "existing_value",
+              initialValue: "existing_value",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'true' to be 'true'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'false' to be 'false'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.variables.get returns the correct value from any scope", () => {
+    return expect(
+      func(
+        `
+          const data = pm.variables.get("scopedVar")
+          pw.expect(data).toBe("scopedValue")
+        `,
+        {
+          global: [
+            {
+              key: "scopedVar",
+              currentValue: "scopedValue",
+              initialValue: "scopedValue",
+              secret: false,
+            },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'scopedValue' to be 'scopedValue'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.variables.replaceIn handles multiple variables", () => {
+    return expect(
+      func(
+        `
+          const template = "User {{name}} has {{count}} items in {{location}}"
+          const result = pm.variables.replaceIn(template)
+          pw.expect(result).toBe("User Alice has 10 items in Cart")
+        `,
+        {
+          global: [
+            {
+              key: "location",
+              currentValue: "Cart",
+              initialValue: "Cart",
+              secret: false,
+            },
+          ],
+          selected: [
+            {
+              key: "name",
+              currentValue: "Alice",
+              initialValue: "Alice",
+              secret: false,
+            },
+            {
+              key: "count",
+              currentValue: "10",
+              initialValue: "10",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message:
+              "Expected 'User Alice has 10 items in Cart' to be 'User Alice has 10 items in Cart'",
+          },
+        ],
+      }),
+    ])
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/info.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/info.spec.ts
new file mode 100644
index 00000000..f987ca43
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/info.spec.ts
@@ -0,0 +1,114 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+import { runPreRequestScript } from "~/web"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "test response",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: { ...defaultRequest, name: "default-request", id: "test-id" },
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("pm.info context", () => {
+  test("pm.info.eventName returns 'pre-request' in pre-request context", () => {
+    const defaultRequest = getDefaultRESTRequest()
+
+    return expect(
+      runPreRequestScript(
+        `
+          console.log("Event name: ", pm.info.eventName)
+        `,
+        {
+          envs: {
+            global: [],
+            selected: [],
+          },
+          request: defaultRequest,
+        }
+      )
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        consoleEntries: [
+          expect.objectContaining({ args: ["Event name: ", "pre-request"] }),
+        ],
+      })
+    )
+  })
+
+  test("pm.info.eventName returns 'post-request' in post-request context", () => {
+    return expect(
+      func(
+        `
+          pm.test("Event name is correct", () => {
+            pm.expect(pm.info.eventName).toBe("post-request")
+          })
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Event name is correct",
+            expectResults: [
+              {
+                status: "pass",
+                message: "Expected 'post-request' to be 'post-request'",
+              },
+            ],
+          }),
+        ],
+      }),
+    ])
+  })
+
+  test("pm.info provides requestName and requestId", () => {
+    return expect(
+      func(
+        `
+          pm.test("Request info is available", () => {
+            pm.expect(pm.info.requestName).toBe("default-request")
+            pm.expect(pm.info.requestId).toBe("test-id")
+          })
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Request info is available",
+            expectResults: [
+              {
+                status: "pass",
+                message: "Expected 'default-request' to be 'default-request'",
+              },
+              { status: "pass", message: "Expected 'test-id' to be 'test-id'" },
+            ],
+          }),
+        ],
+      }),
+    ])
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/request.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/request.spec.ts
new file mode 100644
index 00000000..3967fb19
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/request.spec.ts
@@ -0,0 +1,126 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("pm.request coverage", () => {
+  test("pm.request object provides access to request data", () => {
+    return expect(
+      func(
+        `
+          pw.expect(pm.request.url.toString()).toBe("https://echo.hoppscotch.io")
+          pw.expect(pm.request.method).toBe("GET")
+          pw.expect(pm.request.headers.get("Content-Type")).toBe(null)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message:
+              "Expected 'https://echo.hoppscotch.io' to be 'https://echo.hoppscotch.io'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'GET' to be 'GET'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'null' to be 'null'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.request.url provides correct URL value", () => {
+    return expect(
+      func(
+        `
+          pw.expect(pm.request.url.toString()).toBe("https://echo.hoppscotch.io")
+          pw.expect(pm.request.url.toString().length).toBe(26)
+          pw.expect(pm.request.url.toString().includes("hoppscotch")).toBe(true)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message:
+              "Expected 'https://echo.hoppscotch.io' to be 'https://echo.hoppscotch.io'",
+          },
+          {
+            status: "pass",
+            message: "Expected '26' to be '26'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'true' to be 'true'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.request.headers functionality", () => {
+    return expect(
+      func(
+        `
+          pw.expect(pm.request.headers.get("Content-Type")).toBe(null)
+          pw.expect(pm.request.headers.has("Content-Type")).toBe(false)
+          pw.expect(pm.request.headers.has("User-Agent")).toBe(false)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'null' to be 'null'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'false' to be 'false'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'false' to be 'false'",
+          },
+        ],
+      }),
+    ])
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/response.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/response.spec.ts
new file mode 100644
index 00000000..bcd8f6d1
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/response.spec.ts
@@ -0,0 +1,199 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  statusText: "OK",
+  body: JSON.stringify({ message: "Hello, World!" }),
+  headers: [
+    { key: "Content-Type", value: "application/json" },
+    { key: "Authorization", value: "Bearer token123" },
+  ],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("pm.response", () => {
+  test("pm.response.code provides access to status code", () => {
+    return expect(
+      func(
+        `
+          const code = pm.response.code
+          pw.expect(code.toString()).toBe("200")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected '200' to be '200'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.response.status provides access to status text", () => {
+    return expect(
+      func(
+        `
+          const status = pm.response.status
+          pw.expect(status).toBe("OK")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'OK' to be 'OK'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.response.text() provides response body as text", () => {
+    return expect(
+      func(
+        `
+          const text = pm.response.text()
+          pw.expect(text).toBe('{"message":"Hello, World!"}')
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message:
+              'Expected \'{"message":"Hello, World!"}\' to be \'{"message":"Hello, World!"}\'',
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.response.json() provides parsed JSON response", () => {
+    return expect(
+      func(
+        `
+          const json = pm.response.json()
+          pw.expect(json.message).toBe("Hello, World!")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'Hello, World!' to be 'Hello, World!'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.response.headers provides access to response headers", () => {
+    return expect(
+      func(
+        `
+          const headers = pm.response.headers
+          pw.expect(headers.get("Content-Type")).toBe("application/json")
+          pw.expect(headers.get("Authorization")).toBe("Bearer token123")
+          pw.expect(headers.get("nonexistent")).toBe(null)
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'application/json' to be 'application/json'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'Bearer token123' to be 'Bearer token123'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'null' to be 'null'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.response object has correct structure and values", () => {
+    return expect(
+      func(
+        `
+          pw.expect(pm.response.code).toBe(200)
+          pw.expect(pm.response.status).toBe("OK")
+          pw.expect(pm.response.text()).toBe('{"message":"Hello, World!"}')
+          pw.expect(pm.response.json().message).toBe("Hello, World!")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected '200' to be '200'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'OK' to be 'OK'",
+          },
+          {
+            status: "pass",
+            message:
+              'Expected \'{"message":"Hello, World!"}\' to be \'{"message":"Hello, World!"}\'',
+          },
+          {
+            status: "pass",
+            message: "Expected 'Hello, World!' to be 'Hello, World!'",
+          },
+        ],
+      }),
+    ])
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/unsupported.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/unsupported.spec.ts
new file mode 100644
index 00000000..df509bb1
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/unsupported.spec.ts
@@ -0,0 +1,249 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+import { runTestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "test response",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("pm namespace - unsupported features", () => {
+  test("pm.info.iteration throws error", () => {
+    return expect(
+      func(
+        `
+          try {
+            const iteration = pm.info.iteration
+            pm.test("Should not reach here", () => {
+              pm.expect(true).toBe(false)
+            })
+          } catch (error) {
+            pm.test("Throws correct error", () => {
+              pm.expect(error.message).toInclude("pm.info.iteration is not supported")
+            })
+          }
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Throws correct error",
+            expectResults: [{ status: "pass", message: expect.any(String) }],
+          }),
+        ],
+      }),
+    ])
+  })
+
+  test("pm.info.iterationCount throws error", () => {
+    return expect(
+      func(
+        `
+          try {
+            const iterationCount = pm.info.iterationCount
+            pm.test("Should not reach here", () => {
+              pm.expect(true).toBe(false)
+            })
+          } catch (error) {
+            pm.test("Throws correct error", () => {
+              pm.expect(error.message).toInclude("pm.info.iterationCount is not supported")
+            })
+          }
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Throws correct error",
+            expectResults: [{ status: "pass", message: expect.any(String) }],
+          }),
+        ],
+      }),
+    ])
+  })
+
+  test("pm.collectionVariables.get() throws error", () => {
+    return expect(
+      func(
+        `
+          try {
+            pm.collectionVariables.get("test")
+            pm.test("Should not reach here", () => {
+              pm.expect(true).toBe(false)
+            })
+          } catch (error) {
+            pm.test("Throws correct error", () => {
+              pm.expect(error.message).toInclude("pm.collectionVariables.get() is not supported")
+            })
+          }
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Throws correct error",
+            expectResults: [{ status: "pass", message: expect.any(String) }],
+          }),
+        ],
+      }),
+    ])
+  })
+
+  test("pm.vault.get() throws error", () => {
+    return expect(
+      func(
+        `
+          try {
+            pm.vault.get("test")
+            pm.test("Should not reach here", () => {
+              pm.expect(true).toBe(false)
+            })
+          } catch (error) {
+            pm.test("Throws correct error", () => {
+              pm.expect(error.message).toInclude("pm.vault.get() is not supported")
+            })
+          }
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Throws correct error",
+            expectResults: [{ status: "pass", message: expect.any(String) }],
+          }),
+        ],
+      }),
+    ])
+  })
+
+  test("pm.iterationData.get() throws error", () => {
+    return expect(
+      func(
+        `
+          try {
+            pm.iterationData.get("test")
+            pm.test("Should not reach here", () => {
+              pm.expect(true).toBe(false)
+            })
+          } catch (error) {
+            pm.test("Throws correct error", () => {
+              pm.expect(error.message).toInclude("pm.iterationData.get() is not supported")
+            })
+          }
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Throws correct error",
+            expectResults: [{ status: "pass", message: expect.any(String) }],
+          }),
+        ],
+      }),
+    ])
+  })
+
+  test("pm.execution.setNextRequest() throws error", () => {
+    return expect(
+      func(
+        `
+          try {
+            pm.execution.setNextRequest("next-request")
+            pm.test("Should not reach here", () => {
+              pm.expect(true).toBe(false)
+            })
+          } catch (error) {
+            pm.test("Throws correct error", () => {
+              pm.expect(error.message).toInclude("pm.execution.setNextRequest() is not supported")
+            })
+          }
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Throws correct error",
+            expectResults: [{ status: "pass", message: expect.any(String) }],
+          }),
+        ],
+      }),
+    ])
+  })
+
+  test("pm.sendRequest() throws error", () => {
+    return expect(
+      func(
+        `
+          try {
+            pm.sendRequest("https://example.com", () => {})
+            pm.test("Should not reach here", () => {
+              pm.expect(true).toBe(false)
+            })
+          } catch (error) {
+            pm.test("Throws correct error", () => {
+              pm.expect(error.message).toInclude("pm.sendRequest() is not yet implemented")
+            })
+          }
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Throws correct error",
+            expectResults: [{ status: "pass", message: expect.any(String) }],
+          }),
+        ],
+      }),
+    ])
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/variables.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/variables.spec.ts
new file mode 100644
index 00000000..d9c8fe7d
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pm-namespace/variables.spec.ts
@@ -0,0 +1,492 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import * as TE from "fp-ts/TaskEither"
+import { pipe } from "fp-ts/function"
+import { describe, expect, test } from "vitest"
+import { runTestScript, runPreRequestScript } from "~/node"
+import { TestResponse, TestResult } from "~/types"
+
+const defaultRequest = getDefaultRESTRequest()
+const fakeResponse: TestResponse = {
+  status: 200,
+  body: "hoi",
+  headers: [],
+}
+
+const func = (script: string, envs: TestResult["envs"]) =>
+  pipe(
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
+    TE.map((x) => x.tests)
+  )
+
+describe("pm.environment", () => {
+  test("pm.environment.get returns the correct value for an existing active environment value", () => {
+    return expect(
+      func(
+        `
+          const data = pm.environment.get("a")
+          pm.expect(data).toBe("b")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "a",
+              currentValue: "b",
+              initialValue: "b",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [{ status: "pass", message: "Expected 'b' to be 'b'" }],
+      }),
+    ])
+  })
+
+  test("pm.environment.set creates and retrieves environment variable", () => {
+    return expect(
+      func(
+        `
+          pm.environment.set("test_set", "set_value")
+          const retrieved = pm.environment.get("test_set")
+          pw.expect(retrieved).toBe("set_value")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'set_value' to be 'set_value'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.environment.set works correctly", () => {
+    return expect(
+      func(
+        `
+          pm.environment.set("newVar", "newValue")
+          const data = pm.environment.get("newVar")
+          pm.expect(data).toBe("newValue")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          { status: "pass", message: "Expected 'newValue' to be 'newValue'" },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.environment.has correctly identifies existing and non-existing variables", () => {
+    return expect(
+      func(
+        `
+          const hasExisting = pm.environment.has("existing_var")
+          const hasNonExisting = pm.environment.has("non_existing_var")
+          pw.expect(hasExisting.toString()).toBe("true")
+          pw.expect(hasNonExisting.toString()).toBe("false")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "existing_var",
+              currentValue: "existing_value",
+              initialValue: "existing_value",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'true' to be 'true'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'false' to be 'false'",
+          },
+        ],
+      }),
+    ])
+  })
+})
+
+describe("pm.globals", () => {
+  test("pm.globals.get returns the correct value for an existing global environment value", () => {
+    return expect(
+      func(
+        `
+          const data = pm.globals.get("globalVar")
+          pm.expect(data).toBe("globalValue")
+        `,
+        {
+          global: [
+            {
+              key: "globalVar",
+              currentValue: "globalValue",
+              initialValue: "globalValue",
+              secret: false,
+            },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'globalValue' to be 'globalValue'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.globals.set creates and retrieves global variable", () => {
+    return expect(
+      func(
+        `
+          pm.globals.set("test_global", "global_value")
+          const retrieved = pm.globals.get("test_global")
+          pw.expect(retrieved).toBe("global_value")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'global_value' to be 'global_value'",
+          },
+        ],
+      }),
+    ])
+  })
+})
+
+describe("pm.variables", () => {
+  test("pm.variables.get returns the correct value from any scope", () => {
+    return expect(
+      func(
+        `
+          const data = pm.variables.get("scopedVar")
+          pm.expect(data).toBe("scopedValue")
+        `,
+        {
+          global: [
+            {
+              key: "scopedVar",
+              currentValue: "scopedValue",
+              initialValue: "scopedValue",
+              secret: false,
+            },
+          ],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'scopedValue' to be 'scopedValue'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.variables.set creates and retrieves variable in active environment", () => {
+    return expect(
+      func(
+        `
+          pm.variables.set("test_var", "test_value")
+          const retrieved = pm.variables.get("test_var")
+          pw.expect(retrieved).toBe("test_value")
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'test_value' to be 'test_value'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.variables.has correctly identifies existing and non-existing variables", () => {
+    return expect(
+      func(
+        `
+          const hasExisting = pm.variables.has("existing_var")
+          const hasNonExisting = pm.variables.has("non_existing_var")
+          pw.expect(hasExisting.toString()).toBe("true")
+          pw.expect(hasNonExisting.toString()).toBe("false")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "existing_var",
+              currentValue: "existing_value",
+              initialValue: "existing_value",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message: "Expected 'true' to be 'true'",
+          },
+          {
+            status: "pass",
+            message: "Expected 'false' to be 'false'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.variables.replaceIn works correctly", () => {
+    return expect(
+      func(
+        `
+          const template = "Hello {{name}}, welcome to {{place}}!"
+          const result = pm.variables.replaceIn(template)
+          pm.expect(result).toBe("Hello World, welcome to Hoppscotch!")
+        `,
+        {
+          global: [],
+          selected: [
+            {
+              key: "name",
+              currentValue: "World",
+              initialValue: "World",
+              secret: false,
+            },
+            {
+              key: "place",
+              currentValue: "Hoppscotch",
+              initialValue: "Hoppscotch",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message:
+              "Expected 'Hello World, welcome to Hoppscotch!' to be 'Hello World, welcome to Hoppscotch!'",
+          },
+        ],
+      }),
+    ])
+  })
+
+  test("pm.variables.replaceIn handles multiple variables", () => {
+    return expect(
+      func(
+        `
+          const template = "User {{name}} has {{count}} items in {{location}}"
+          const result = pm.variables.replaceIn(template)
+          pw.expect(result).toBe("User Alice has 10 items in Cart")
+        `,
+        {
+          global: [
+            {
+              key: "location",
+              currentValue: "Cart",
+              initialValue: "Cart",
+              secret: false,
+            },
+          ],
+          selected: [
+            {
+              key: "name",
+              currentValue: "Alice",
+              initialValue: "Alice",
+              secret: false,
+            },
+            {
+              key: "count",
+              currentValue: "10",
+              initialValue: "10",
+              secret: false,
+            },
+          ],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        expectResults: [
+          {
+            status: "pass",
+            message:
+              "Expected 'User Alice has 10 items in Cart' to be 'User Alice has 10 items in Cart'",
+          },
+        ],
+      }),
+    ])
+  })
+})
+
+describe("pm.test", () => {
+  test("pm.test works as expected", () => {
+    return expect(
+      func(
+        `
+          pm.test("Simple test", function() {
+            pm.expect(1 + 1).toBe(2)
+          })
+        `,
+        {
+          global: [],
+          selected: [],
+        }
+      )()
+    ).resolves.toEqualRight([
+      expect.objectContaining({
+        children: [
+          expect.objectContaining({
+            descriptor: "Simple test",
+            expectResults: [
+              { status: "pass", message: "Expected '2' to be '2'" },
+            ],
+          }),
+        ],
+      }),
+    ])
+  })
+})
+
+describe("pm namespace - pre-request scripts", () => {
+  const DEFAULT_REQUEST = getDefaultRESTRequest()
+
+  test("pm.environment works in pre-request scripts", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          pm.environment.set("preReqVar", "preReqValue")
+          const retrieved = pm.environment.get("preReqVar")
+          console.log("Retrieved:", retrieved)
+        `,
+        {
+          envs: {
+            global: [],
+            selected: [],
+          },
+          request: DEFAULT_REQUEST,
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedEnvs: expect.objectContaining({
+          selected: expect.arrayContaining([
+            expect.objectContaining({
+              key: "preReqVar",
+              currentValue: "preReqValue",
+            }),
+          ]),
+        }),
+      })
+    )
+  })
+
+  test("pm.globals works in pre-request scripts", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          pm.globals.set("globalPreReq", "globalPreValue")
+        `,
+        {
+          envs: {
+            global: [],
+            selected: [],
+          },
+          request: DEFAULT_REQUEST,
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedEnvs: expect.objectContaining({
+          global: expect.arrayContaining([
+            expect.objectContaining({
+              key: "globalPreReq",
+              currentValue: "globalPreValue",
+            }),
+          ]),
+        }),
+      })
+    )
+  })
+
+  test("pm.variables.set works in pre-request scripts", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          pm.variables.set("varPreReq", "varPreValue")
+        `,
+        {
+          envs: {
+            global: [],
+            selected: [],
+          },
+          request: DEFAULT_REQUEST,
+        }
+      )()
+    ).resolves.toEqualRight(
+      expect.objectContaining({
+        updatedEnvs: expect.objectContaining({
+          selected: expect.arrayContaining([
+            expect.objectContaining({
+              key: "varPreReq",
+              currentValue: "varPreValue",
+            }),
+          ]),
+        }),
+      })
+    )
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/pre-request.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pre-request.spec.ts
deleted file mode 100644
index cf2a93bc..00000000
--- a/packages/hoppscotch-js-sandbox/src/__tests__/pre-request.spec.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import { describe, expect, test } from "vitest"
-
-import { runPreRequestScript } from "~/node"
-
-describe("runPreRequestScript", () => {
-  test("returns the updated environment properly", () => {
-    return expect(
-      runPreRequestScript(
-        `
-          pw.env.set("bob", "newbob")
-        `,
-        {
-          global: [],
-          selected: [
-            {
-              key: "bob",
-              currentValue: "oldbob",
-              initialValue: "oldbob",
-              secret: false,
-            },
-            {
-              key: "foo",
-              currentValue: "bar",
-              initialValue: "bar",
-              secret: false,
-            },
-          ],
-        }
-      )()
-    ).resolves.toEqualRight({
-      global: [],
-      selected: [
-        {
-          key: "bob",
-          currentValue: "newbob",
-          initialValue: "oldbob",
-          secret: false,
-        },
-        {
-          key: "foo",
-          currentValue: "bar",
-          initialValue: "bar",
-          secret: false,
-        },
-      ],
-    })
-  })
-
-  test("fails if the key is not a string", () => {
-    return expect(
-      runPreRequestScript(
-        `
-          pw.env.set(10, "newbob")
-        `,
-        {
-          global: [],
-          selected: [
-            {
-              key: "bob",
-              currentValue: "oldbob",
-              initialValue: "oldbob",
-              secret: false,
-            },
-            {
-              key: "foo",
-              currentValue: "bar",
-              initialValue: "bar",
-              secret: false,
-            },
-          ],
-        }
-      )()
-    ).resolves.toBeLeft()
-  })
-
-  test("fails if the value is not a string", () => {
-    return expect(
-      runPreRequestScript(
-        `
-          pw.env.set("bob", 10)
-        `,
-        {
-          global: [],
-          selected: [
-            {
-              key: "bob",
-              currentValue: "oldbob",
-              initialValue: "oldbob",
-              secret: false,
-            },
-            {
-              key: "foo",
-              currentValue: "bar",
-              initialValue: "bar",
-              secret: false,
-            },
-          ],
-        }
-      )()
-    ).resolves.toBeLeft()
-  })
-
-  test("fails for invalid syntax", () => {
-    return expect(
-      runPreRequestScript(
-        `
-          pw.env.set("bob",
-        `,
-        {
-          global: [],
-          selected: [
-            {
-              key: "bob",
-              currentValue: "oldbob",
-              initialValue: "oldbob",
-              secret: false,
-            },
-            {
-              key: "foo",
-              currentValue: "bar",
-              initialValue: "bar",
-              secret: false,
-            },
-          ],
-        }
-      )()
-    ).resolves.toBeLeft()
-  })
-
-  test("creates new env variable if doesn't exist", () => {
-    return expect(
-      runPreRequestScript(
-        `
-          pw.env.set("foo", "bar")
-        `,
-        { selected: [], global: [] }
-      )()
-    ).resolves.toEqualRight({
-      global: [],
-      selected: [
-        { key: "foo", currentValue: "bar", initialValue: "bar", secret: false },
-      ],
-    })
-  })
-})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/base64-helper-functions.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/base64-helper-functions.spec.ts
similarity index 76%
rename from packages/hoppscotch-js-sandbox/src/__tests__/base64-helper-functions.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/base64-helper-functions.spec.ts
index 48eb95a4..e0003cec 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/base64-helper-functions.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/base64-helper-functions.spec.ts
@@ -3,14 +3,18 @@ import { pipe } from "fp-ts/function"
 
 import { describe, expect, test } from "vitest"
 
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import { runPreRequestScript, runTestScript } from "~/node"
 import { TestResponse, TestResult } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
+
 describe("Base64 helper functions", () => {
   const scriptExpectations = {
     atob: {
       script: `pw.env.set("atob", atob("SGVsbG8gV29ybGQ="))`,
       environment: {
+        global: [],
         selected: [
           {
             key: "atob",
@@ -24,6 +28,7 @@ describe("Base64 helper functions", () => {
     btoa: {
       script: `pw.env.set("btoa", btoa("Hello World"))`,
       environment: {
+        global: [],
         selected: [
           {
             key: "btoa",
@@ -41,11 +46,16 @@ describe("Base64 helper functions", () => {
       test("successfully decodes the input string", () => {
         return expect(
           runPreRequestScript(scriptExpectations.atob.script, {
-            global: [],
-            selected: [],
+            envs: {
+              global: [],
+              selected: [],
+            },
+            request: defaultRequest,
           })()
         ).resolves.toEqualRight(
-          expect.objectContaining(scriptExpectations.atob.environment)
+          expect.objectContaining({
+            updatedEnvs: scriptExpectations.atob.environment,
+          })
         )
       })
     })
@@ -54,11 +64,16 @@ describe("Base64 helper functions", () => {
       test("successfully encodes the input string", () => {
         return expect(
           runPreRequestScript(scriptExpectations.btoa.script, {
-            global: [],
-            selected: [],
+            envs: {
+              global: [],
+              selected: [],
+            },
+            request: defaultRequest,
           })()
         ).resolves.toEqualRight(
-          expect.objectContaining(scriptExpectations.btoa.environment)
+          expect.objectContaining({
+            updatedEnvs: scriptExpectations.btoa.environment,
+          })
         )
       })
     })
@@ -73,7 +88,11 @@ describe("Base64 helper functions", () => {
 
     const func = (script: string, envs: TestResult["envs"]) =>
       pipe(
-        runTestScript(script, envs, fakeResponse),
+        runTestScript(script, {
+          envs,
+          request: defaultRequest,
+          response: fakeResponse,
+        }),
         TE.map((x) => x.envs)
       )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/env/get.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/get.spec.ts
similarity index 95%
rename from packages/hoppscotch-js-sandbox/src/__tests__/env/get.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/get.spec.ts
index 8a79691c..4071efb3 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/env/get.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/get.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse, TestResult } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, envs: TestResult["envs"]) =>
   pipe(
-    runTestScript(script, envs, fakeResponse),
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/env/getResolve.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/getResolve.spec.ts
similarity index 96%
rename from packages/hoppscotch-js-sandbox/src/__tests__/env/getResolve.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/getResolve.spec.ts
index 00eb3d8d..0a9f78a4 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/env/getResolve.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/getResolve.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse, TestResult } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, envs: TestResult["envs"]) =>
   pipe(
-    runTestScript(script, envs, fakeResponse),
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/env/resolve.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/resolve.spec.ts
similarity index 94%
rename from packages/hoppscotch-js-sandbox/src/__tests__/env/resolve.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/resolve.spec.ts
index beb41363..d2c04759 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/env/resolve.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/resolve.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse, TestResult } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, envs: TestResult["envs"]) =>
   pipe(
-    runTestScript(script, envs, fakeResponse),
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/env/set.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/set.spec.ts
similarity index 93%
rename from packages/hoppscotch-js-sandbox/src/__tests__/env/set.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/set.spec.ts
index 84a2da32..01762bb2 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/env/set.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/set.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse, TestResult } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,13 +15,21 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, envs: TestResult["envs"]) =>
   pipe(
-    runTestScript(script, envs, fakeResponse),
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
     TE.map((x) => x.envs)
   )
 
 const funcTest = (script: string, envs: TestResult["envs"]) =>
   pipe(
-    runTestScript(script, envs, fakeResponse),
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/env/unset.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/unset.spec.ts
similarity index 95%
rename from packages/hoppscotch-js-sandbox/src/__tests__/env/unset.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/unset.spec.ts
index f2701950..c9c9f4bc 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/env/unset.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/env/unset.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse, TestResult } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,13 +15,21 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, envs: TestResult["envs"]) =>
   pipe(
-    runTestScript(script, envs, fakeResponse),
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
     TE.map((x) => x.envs)
   )
 
 const funcTest = (script: string, envs: TestResult["envs"]) =>
   pipe(
-    runTestScript(script, envs, fakeResponse),
+    runTestScript(script, {
+      envs,
+      request: defaultRequest,
+      response: fakeResponse,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toBe.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBe.spec.ts
similarity index 91%
rename from packages/hoppscotch-js-sandbox/src/__tests__/expect/toBe.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBe.spec.ts
index 079fc219..0bd6cfea 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toBe.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBe.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, res: TestResponse) =>
   pipe(
-    runTestScript(script, { global: [], selected: [] }, res),
+    runTestScript(script, {
+      envs: { global: [], selected: [] },
+      request: defaultRequest,
+      response: res,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toBeLevelxxx.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBeLevelxxx.spec.ts
similarity index 98%
rename from packages/hoppscotch-js-sandbox/src/__tests__/expect/toBeLevelxxx.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBeLevelxxx.spec.ts
index 17539ccd..e7417a1c 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toBeLevelxxx.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBeLevelxxx.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, res: TestResponse) =>
   pipe(
-    runTestScript(script, { global: [], selected: [] }, res),
+    runTestScript(script, {
+      envs: { global: [], selected: [] },
+      request: defaultRequest,
+      response: res,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toBeType.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBeType.spec.ts
similarity index 97%
rename from packages/hoppscotch-js-sandbox/src/__tests__/expect/toBeType.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBeType.spec.ts
index 228f623f..af1ded1c 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toBeType.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toBeType.spec.ts
@@ -1,11 +1,12 @@
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 
 import { runTestScript } from "~/node"
 import { TestResponse } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, res: TestResponse) =>
   pipe(
-    runTestScript(script, { global: [], selected: [] }, res),
+    runTestScript(script, {
+      envs: { global: [], selected: [] },
+      request: defaultRequest,
+      response: res,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toHaveLength.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toHaveLength.spec.ts
similarity index 95%
rename from packages/hoppscotch-js-sandbox/src/__tests__/expect/toHaveLength.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toHaveLength.spec.ts
index b05a0a49..7e2f9f87 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toHaveLength.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toHaveLength.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, res: TestResponse) =>
   pipe(
-    runTestScript(script, { global: [], selected: [] }, res),
+    runTestScript(script, {
+      envs: { global: [], selected: [] },
+      request: defaultRequest,
+      response: res,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toInclude.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toInclude.spec.ts
similarity index 95%
rename from packages/hoppscotch-js-sandbox/src/__tests__/expect/toInclude.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toInclude.spec.ts
index 7b68fe06..627d228e 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/expect/toInclude.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/expect/toInclude.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, res: TestResponse) =>
   pipe(
-    runTestScript(script, { global: [], selected: [] }, res),
+    runTestScript(script, {
+      envs: { global: [], selected: [] },
+      request: defaultRequest,
+      response: res,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/pre-request.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/pre-request.spec.ts
new file mode 100644
index 00000000..6a29dada
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/pre-request.spec.ts
@@ -0,0 +1,173 @@
+import { describe, expect, test } from "vitest"
+
+import { getDefaultRESTRequest } from "@hoppscotch/data"
+import { runPreRequestScript } from "~/node"
+
+const DEFAULT_REQUEST = getDefaultRESTRequest()
+
+describe("runPreRequestScript", () => {
+  test("returns the updated environment properly", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          pw.env.set("bob", "newbob")
+        `,
+        {
+          envs: {
+            global: [],
+            selected: [
+              {
+                key: "bob",
+                currentValue: "oldbob",
+                initialValue: "oldbob",
+                secret: false,
+              },
+              {
+                key: "foo",
+                currentValue: "bar",
+                initialValue: "bar",
+                secret: false,
+              },
+            ],
+          },
+          request: DEFAULT_REQUEST,
+        }
+      )()
+    ).resolves.toEqualRight({
+      updatedEnvs: {
+        global: [],
+        selected: [
+          {
+            key: "bob",
+            currentValue: "newbob",
+            initialValue: "oldbob",
+            secret: false,
+          },
+          {
+            key: "foo",
+            currentValue: "bar",
+            initialValue: "bar",
+            secret: false,
+          },
+        ],
+      },
+      updatedRequest: DEFAULT_REQUEST,
+      updatedCookies: null,
+    })
+  })
+
+  test("fails if the key is not a string", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          pw.env.set(10, "newbob")
+        `,
+        {
+          envs: {
+            global: [],
+            selected: [
+              {
+                key: "bob",
+                currentValue: "oldbob",
+                initialValue: "oldbob",
+                secret: false,
+              },
+              {
+                key: "foo",
+                currentValue: "bar",
+                initialValue: "bar",
+                secret: false,
+              },
+            ],
+          },
+          request: DEFAULT_REQUEST,
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("fails if the value is not a string", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          pw.env.set("bob", 10)
+        `,
+        {
+          envs: {
+            global: [],
+            selected: [
+              {
+                key: "bob",
+                currentValue: "oldbob",
+                initialValue: "oldbob",
+                secret: false,
+              },
+              {
+                key: "foo",
+                currentValue: "bar",
+                initialValue: "bar",
+                secret: false,
+              },
+            ],
+          },
+          request: DEFAULT_REQUEST,
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("fails for invalid syntax", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          pw.env.set("bob",
+        `,
+        {
+          envs: {
+            global: [],
+            selected: [
+              {
+                key: "bob",
+                currentValue: "oldbob",
+                initialValue: "oldbob",
+                secret: false,
+              },
+              {
+                key: "foo",
+                currentValue: "bar",
+                initialValue: "bar",
+                secret: false,
+              },
+            ],
+          },
+          request: DEFAULT_REQUEST,
+        }
+      )()
+    ).resolves.toBeLeft()
+  })
+
+  test("creates new env variable if doesn't exist", () => {
+    return expect(
+      runPreRequestScript(
+        `
+          pw.env.set("foo", "bar")
+        `,
+        { envs: { global: [], selected: [] }, request: DEFAULT_REQUEST }
+      )()
+    ).resolves.toEqualRight({
+      updatedEnvs: {
+        global: [],
+        selected: [
+          {
+            key: "foo",
+            currentValue: "bar",
+            initialValue: "bar",
+            secret: false,
+          },
+        ],
+      },
+      updatedRequest: DEFAULT_REQUEST,
+      updatedCookies: null,
+    })
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/test-runner.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/test-runner.spec.ts
similarity index 88%
rename from packages/hoppscotch-js-sandbox/src/__tests__/test-runner.spec.ts
rename to packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/test-runner.spec.ts
index 293e83d2..82c1f64d 100644
--- a/packages/hoppscotch-js-sandbox/src/__tests__/test-runner.spec.ts
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/pw-namespace/test-runner.spec.ts
@@ -1,11 +1,12 @@
+import { getDefaultRESTRequest } from "@hoppscotch/data"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
-
 import { describe, expect, test } from "vitest"
 
 import { runTestScript } from "~/node"
 import { TestResponse } from "~/types"
 
+const defaultRequest = getDefaultRESTRequest()
 const fakeResponse: TestResponse = {
   status: 200,
   body: "hoi",
@@ -14,7 +15,11 @@ const fakeResponse: TestResponse = {
 
 const func = (script: string, res: TestResponse) =>
   pipe(
-    runTestScript(script, { global: [], selected: [] }, res),
+    runTestScript(script, {
+      envs: { global: [], selected: [] },
+      request: defaultRequest,
+      response: res,
+    }),
     TE.map((x) => x.tests)
   )
 
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/shared-utils.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/shared-utils.spec.ts
deleted file mode 100644
index f016b891..00000000
--- a/packages/hoppscotch-js-sandbox/src/__tests__/shared-utils.spec.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { preventCyclicObjects } from "~/shared-utils"
-
-import { describe, expect, test } from "vitest"
-
-describe("preventCyclicObjects", () => {
-  test("succeeds with a simple object", () => {
-    const testObj = {
-      a: 1,
-    }
-
-    expect(preventCyclicObjects(testObj)).toBeRight()
-  })
-
-  test("fails with a cyclic object", () => {
-    const testObj = {
-      a: 1,
-      b: null as any,
-    }
-
-    testObj.b = testObj
-
-    expect(preventCyclicObjects(testObj)).toBeLeft()
-  })
-})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/utils/pre-request.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/utils/pre-request.spec.ts
new file mode 100644
index 00000000..2ee4b30e
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/utils/pre-request.spec.ts
@@ -0,0 +1,183 @@
+import {
+  HoppRESTAuth,
+  HoppRESTReqBody,
+  HoppRESTRequest,
+} from "@hoppscotch/data"
+import { describe, expect, test } from "vitest"
+
+import { getRequestSetterMethods } from "~/utils/pre-request"
+
+const baseRequest: HoppRESTRequest = {
+  v: "15",
+  name: "Test Request",
+  endpoint: "https://example.com/api",
+  method: "GET",
+  headers: [{ key: "X-Test", value: "val1", active: true, description: "" }],
+  params: [{ key: "q", value: "search", active: true, description: "" }],
+  body: { contentType: null, body: null },
+  auth: { authType: "none", authActive: false },
+  preRequestScript: "",
+  testScript: "",
+  requestVariables: [],
+  responses: {},
+}
+
+describe("getRequestSetterMethods", () => {
+  test("`setUrl` method", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    methods.setUrl("https://updated.com/api")
+
+    expect(updatedRequest.endpoint).toBe("https://updated.com/api")
+  })
+
+  test("`setMethod` should update and uppercase the method", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    methods.setMethod("post")
+
+    expect(updatedRequest.method).toBe("POST")
+  })
+
+  test("`setHeader` setter should update existing header case-insensitively", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    methods.setHeader("x-test", "updatedVal")
+
+    expect(
+      updatedRequest.headers.find((h) => h.key.toLowerCase() === "x-test")
+        ?.value
+    ).toBe("updatedVal")
+  })
+
+  test("`setHeader` setter should add new header if not present", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    methods.setHeader("X-New-Header", "newValue")
+
+    expect(updatedRequest.headers.some((h) => h.key === "X-New-Header")).toBe(
+      true
+    )
+    expect(
+      updatedRequest.headers.find((h) => h.key === "X-New-Header")?.value
+    ).toBe("newValue")
+  })
+
+  test("`removeHeader` setter should remove a header", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    methods.removeHeader("X-Test")
+
+    expect(
+      updatedRequest.headers.find((h) => h.key === "X-Test")
+    ).toBeUndefined()
+  })
+
+  test("`setParam` setter should update existing param case-insensitively", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    methods.setParam("Q", "updatedParam")
+
+    expect(
+      updatedRequest.params.find((p) => p.key.toLowerCase() === "q")?.value
+    ).toBe("updatedParam")
+  })
+
+  test("`setParam` setter should add new param if absent", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    methods.setParam("newParam", "value")
+
+    expect(updatedRequest.params.some((p) => p.key === "newParam")).toBe(true)
+  })
+
+  test("`removeParam` setter should remove a param", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    methods.removeParam("q")
+
+    expect(updatedRequest.params.find((p) => p.key === "q")).toBeUndefined()
+  })
+
+  test("`setBody` setter should update the body with complete replacement", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    const newBody: HoppRESTReqBody = {
+      contentType: "application/json",
+      body: JSON.stringify({ changed: true }),
+    }
+
+    methods.setBody(newBody)
+    expect(updatedRequest.body).toEqual(newBody)
+  })
+
+  test("`setBody` setter should support partial merge", () => {
+    // Set up a request with existing body
+    const requestWithBody: HoppRESTRequest = {
+      ...baseRequest,
+      body: {
+        contentType: "application/json",
+        body: JSON.stringify({ existing: "data" }),
+      },
+    }
+
+    const { methods, updatedRequest } = getRequestSetterMethods(requestWithBody)
+
+    // Only update contentType, preserving existing body
+    methods.setBody({ contentType: "application/xml" })
+
+    expect(updatedRequest.body).toEqual({
+      contentType: "application/xml",
+      body: JSON.stringify({ existing: "data" }),
+    })
+  })
+
+  test("`setAuth` setter should update the authorization properties with complete replacement", () => {
+    const { methods, updatedRequest } = getRequestSetterMethods(baseRequest)
+    const newAuth: HoppRESTAuth = {
+      authType: "basic",
+      username: "abc",
+      password: "123",
+      authActive: true,
+    }
+
+    methods.setAuth(newAuth)
+    expect(updatedRequest.auth).toEqual(newAuth)
+  })
+
+  test("`setAuth` setter should support partial merge", () => {
+    // Set up a request with existing auth
+    const requestWithAuth: HoppRESTRequest = {
+      ...baseRequest,
+      auth: {
+        authType: "basic",
+        username: "existing-user",
+        password: "existing-pass",
+        authActive: true,
+      },
+    }
+
+    const { methods, updatedRequest } = getRequestSetterMethods(requestWithAuth)
+
+    // Only update username, preserving other auth fields
+    methods.setAuth({ username: "updated-user" } as Partial<HoppRESTAuth>)
+
+    expect(updatedRequest.auth).toEqual({
+      authType: "basic",
+      username: "updated-user",
+      password: "existing-pass",
+      authActive: true,
+    })
+  })
+
+  test("`setHeaders` setter throws error on invalid input", () => {
+    const { methods } = getRequestSetterMethods(baseRequest)
+    expect(() => methods.setHeaders(null)).toThrow()
+  })
+
+  test("`setParams` setter throws error on invalid input", () => {
+    const { methods } = getRequestSetterMethods(baseRequest)
+    expect(() => methods.setParams(null)).toThrow()
+  })
+
+  test("`setBody` setter throws error on invalid input", () => {
+    const { methods } = getRequestSetterMethods(baseRequest)
+    expect(() => methods.setBody("invalid_body")).toThrow()
+  })
+
+  test("`setAuth` setter throws error on invalid input", () => {
+    const { methods } = getRequestSetterMethods(baseRequest)
+    expect(() => methods.setAuth([6])).toThrow()
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/__tests__/utils/shared.spec.ts b/packages/hoppscotch-js-sandbox/src/__tests__/utils/shared.spec.ts
new file mode 100644
index 00000000..631128c8
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/__tests__/utils/shared.spec.ts
@@ -0,0 +1,186 @@
+import {
+  getSharedCookieMethods,
+  getSharedRequestProps,
+  preventCyclicObjects,
+} from "~/utils/shared"
+
+import { Cookie, HoppRESTRequest } from "@hoppscotch/data"
+import { describe, expect, test } from "vitest"
+
+describe("preventCyclicObjects", () => {
+  test("succeeds with a simple object", () => {
+    const testObj = {
+      a: 1,
+    }
+
+    expect(preventCyclicObjects(testObj)).toBeRight()
+  })
+
+  test("fails with a cyclic object", () => {
+    const testObj = {
+      a: 1,
+      b: null as any,
+    }
+
+    testObj.b = testObj
+
+    expect(preventCyclicObjects(testObj)).toBeLeft()
+  })
+})
+
+describe("getSharedRequestProps", () => {
+  const baseRequest: HoppRESTRequest = {
+    v: "15",
+    name: "Test Request",
+    endpoint: "https://example.com/api",
+    method: "GET",
+    headers: [{ key: "X-Test", value: "val1", active: true, description: "" }],
+    params: [{ key: "q", value: "search", active: true, description: "" }],
+    body: { contentType: null, body: null },
+    auth: { authType: "none", authActive: false },
+    preRequestScript: "",
+    testScript: "",
+    requestVariables: [],
+    responses: {},
+  }
+
+  test("`url` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.url).toBe("https://example.com/api")
+  })
+
+  test("`method` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.method).toBe("GET")
+  })
+
+  test("`headers` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.headers).toEqual(baseRequest.headers)
+  })
+
+  test("`params` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.params).toEqual(baseRequest.params)
+  })
+
+  test("`body` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.body).toEqual(baseRequest.body)
+  })
+
+  test("`auth` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.auth).toEqual(baseRequest.auth)
+  })
+
+  test("`params` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.params).toEqual(baseRequest.params)
+  })
+
+  test("`body` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.body).toEqual(baseRequest.body)
+  })
+
+  test("`auth` getter", () => {
+    const request = getSharedRequestProps(baseRequest)
+    expect(request.auth).toEqual(baseRequest.auth)
+  })
+})
+
+describe("getSharedCookieMethods", () => {
+  const validCookie: Cookie = {
+    name: "session",
+    value: "abc123",
+    domain: "example.com",
+    path: "/",
+    httpOnly: true,
+    secure: true,
+    sameSite: "Lax",
+  }
+
+  test("get() should return existing cookie or null", () => {
+    const { methods } = getSharedCookieMethods([
+      validCookie,
+      { ...validCookie, name: "token", value: "xyz" },
+    ])
+
+    expect(methods.get("example.com", "session")).toEqual(validCookie)
+    expect(methods.get("example.com", "missing")).toBeNull()
+  })
+
+  test("get() should throw for non-string args", () => {
+    const { methods } = getSharedCookieMethods([validCookie])
+    expect(() => methods.get(123, "session")).toThrow(
+      "Expected domain and cookieName to be strings"
+    )
+  })
+
+  test("set() should add a new cookie", () => {
+    const { methods } = getSharedCookieMethods([])
+    methods.set("example.com", validCookie)
+
+    expect(methods.get("example.com", "session")).toEqual(validCookie)
+  })
+
+  test("set() should replace an existing cookie with same domain+name", () => {
+    const oldCookie = { ...validCookie, value: "old" }
+    const { methods } = getSharedCookieMethods([oldCookie])
+
+    methods.set("example.com", validCookie)
+
+    expect(methods.getAll("example.com")).toHaveLength(1)
+    expect(methods.get("example.com", "session")?.value).toBe("abc123")
+  })
+
+  test("set() should throw for invalid cookie per schema", () => {
+    const { methods } = getSharedCookieMethods([])
+    expect(() => methods.set("example.com", { bad: "cookie" })).toThrow(
+      "Invalid cookie"
+    )
+  })
+
+  test("has() should return true if cookie exists", () => {
+    const { methods } = getSharedCookieMethods([validCookie])
+
+    expect(methods.has("example.com", "session")).toBe(true)
+    expect(methods.has("example.com", "missing")).toBe(false)
+  })
+
+  test("getAll() should return all cookies for a domain", () => {
+    const cookies = [
+      validCookie,
+      { ...validCookie, name: "token", value: "x" },
+      { ...validCookie, domain: "other.com" },
+    ]
+    const { methods } = getSharedCookieMethods(cookies)
+
+    const result = methods.getAll("example.com")
+    expect(result).toHaveLength(2)
+    expect(result.every((c) => c.domain === "example.com")).toBe(true)
+  })
+
+  test("delete() should remove the specified cookie", () => {
+    const { methods } = getSharedCookieMethods([validCookie])
+    methods.delete("example.com", "session")
+    expect(methods.get("example.com", "session")).toBeNull()
+  })
+
+  test("clear() should remove all cookies for a domain", () => {
+    const cookies = [validCookie, { ...validCookie, name: "token", value: "x" }]
+    const { methods } = getSharedCookieMethods(cookies)
+
+    methods.clear("example.com")
+    expect(methods.getAll("example.com")).toHaveLength(0)
+  })
+
+  test("should throw for non-string args on has/delete/getAll/clear", () => {
+    const { methods } = getSharedCookieMethods([validCookie])
+    expect(() => methods.has(123 as any, "session")).toThrow()
+    expect(() => methods.delete(123 as any, "session")).toThrow()
+    expect(() => methods.getAll(123 as any)).toThrow()
+    expect(() => methods.clear(123 as any)).toThrow()
+  })
+})
diff --git a/packages/hoppscotch-js-sandbox/src/bootstrap-code/post-request.js b/packages/hoppscotch-js-sandbox/src/bootstrap-code/post-request.js
index a996d5d6..325f1c5a 100644
--- a/packages/hoppscotch-js-sandbox/src/bootstrap-code/post-request.js
+++ b/packages/hoppscotch-js-sandbox/src/bootstrap-code/post-request.js
@@ -1,5 +1,105 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions */
 ;(inputs) => {
+  // Keep strict mode scoped to this IIFE to avoid leaking strictness to concatenated/bootstrapped code
+  "use strict"
+  const toJSON = (input) => {
+    if (input == null) return null
+
+    if (typeof input === "string") {
+      try {
+        return JSON.parse(input)
+      } catch {
+        throw new Error("Invalid JSON string")
+      }
+    }
+
+    if (typeof input === "object") {
+      return input
+    }
+
+    throw new Error(
+      "Unsupported input type for hopp.response.asJSON(). Expected string or object."
+    )
+  }
+
+  /**
+   * Convert input into text (stringify objects, pass strings through).
+   */
+  const toText = (input) => {
+    if (input == null) return ""
+
+    if (typeof input === "string") return input
+
+    if (typeof input === "object") return JSON.stringify(input)
+
+    throw new Error("Unsupported input type for hopp.response.asText()")
+  }
+
+  /**
+   * Convert input into bytes (UTF-8 encode strings, stringify objects first).
+   */
+  const toBytes = (input) => {
+    if (input == null) return new Uint8Array()
+
+    if (typeof input === "string") return new TextEncoder().encode(input)
+
+    if (typeof input === "object")
+      return new TextEncoder().encode(JSON.stringify(input))
+
+    throw new Error("Unsupported input type for hopp.response.bytes()")
+  }
+
+  const { status, statusText, headers, responseTime, body } =
+    inputs.getResponse()
+
+  const pwResponse = {
+    status,
+    body,
+    headers,
+  }
+
+  // Create response body object with read-only methods
+  const responseBody = {
+    asJSON: () => toJSON(body),
+    asText: () => toText(body),
+    bytes: () => toBytes(body),
+  }
+
+  // Make body methods read-only using a loop
+  ;["asJSON", "asText", "bytes"].forEach((method) => {
+    Object.defineProperty(responseBody, method, {
+      value: responseBody[method],
+      writable: false,
+      configurable: false,
+    })
+  })
+  Object.freeze(responseBody)
+
+  // Create response object with read-only properties
+  const hoppResponse = {}
+
+  // Define response properties and their values
+  const responseProperties = {
+    statusCode: status,
+    statusText: statusText,
+    headers: headers,
+    responseTime: responseTime,
+    body: responseBody,
+  }
+
+  // Apply read-only protection to all response properties
+  Object.keys(responseProperties).forEach((prop) => {
+    Object.defineProperty(hoppResponse, prop, {
+      value: responseProperties[prop],
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    })
+  })
+
+  // Freeze the entire response object
+  Object.freeze(hoppResponse)
+
   globalThis.pw = {
     env: {
       get: (key) => inputs.envGet(key),
@@ -46,6 +146,401 @@
       testFn()
       inputs.postTest()
     },
-    response: inputs.getResponse(),
+    response: pwResponse,
+  }
+
+  // Immutable getters under the `request` namespace
+  const requestProps = {}
+
+  // Define all properties with unified read-only protection
+  ;["url", "method", "params", "headers", "body", "auth"].forEach((prop) => {
+    Object.defineProperty(requestProps, prop, {
+      enumerable: true,
+      configurable: false,
+      get() {
+        return inputs.getRequestProps()[prop]
+      },
+      set(_value) {
+        throw new TypeError(`hopp.request.${prop} is read-only`)
+      },
+    })
+  })
+
+  // Special handling for variables property
+  Object.defineProperty(requestProps, "variables", {
+    enumerable: true,
+    configurable: false,
+    get() {
+      return Object.freeze({
+        get: (key) => inputs.getRequestVariable(key),
+      })
+    },
+    set(_value) {
+      throw new TypeError(`hopp.request.variables is read-only`)
+    },
+  })
+
+  // Freeze the entire requestProps object for additional protection
+  Object.freeze(requestProps)
+
+  globalThis.hopp = {
+    env: {
+      get: (key) =>
+        inputs.envGetResolve(key, { fallbackToNull: true, source: "all" }),
+      getRaw: (key) =>
+        inputs.envGet(key, { fallbackToNull: true, source: "all" }),
+      set: (key, value) => inputs.envSet(key, value),
+      delete: (key) => inputs.envUnset(key),
+      reset: (key) => inputs.envReset(key),
+      getInitialRaw: (key) => inputs.envGetInitialRaw(key),
+      setInitial: (key, value) => inputs.envSetInitial(key, value),
+
+      active: {
+        get: (key) =>
+          inputs.envGetResolve(key, { fallbackToNull: true, source: "active" }),
+        getRaw: (key) =>
+          inputs.envGet(key, { fallbackToNull: true, source: "active" }),
+        set: (key, value) => inputs.envSet(key, value, { source: "active" }),
+        delete: (key) => inputs.envUnset(key, { source: "active" }),
+        reset: (key) => inputs.envReset(key, { source: "active" }),
+        getInitialRaw: (key) =>
+          inputs.envGetInitialRaw(key, { source: "active" }),
+        setInitial: (key, value) =>
+          inputs.envSetInitial(key, value, { source: "active" }),
+      },
+
+      global: {
+        get: (key) =>
+          inputs.envGetResolve(key, { fallbackToNull: true, source: "global" }),
+        getRaw: (key) =>
+          inputs.envGet(key, { fallbackToNull: true, source: "global" }),
+        set: (key, value) => inputs.envSet(key, value, { source: "global" }),
+        delete: (key) => inputs.envUnset(key, { source: "global" }),
+        reset: (key) => inputs.envReset(key, { source: "global" }),
+        getInitialRaw: (key) =>
+          inputs.envGetInitialRaw(key, { source: "global" }),
+        setInitial: (key, value) =>
+          inputs.envSetInitial(key, value, { source: "global" }),
+      },
+    },
+    request: requestProps,
+    cookies: {
+      get: (domain, name) => inputs.cookieGet(domain, name),
+      set: (domain, cookie) => inputs.cookieSet(domain, cookie),
+      has: (domain, name) => inputs.cookieHas(domain, name),
+      getAll: (domain) => inputs.cookieGetAll(domain),
+      delete: (domain, name) => inputs.cookieDelete(domain, name),
+      clear: (domain) => inputs.cookieClear(domain),
+    },
+    expect: (expectVal) => {
+      const isDateInstance = expectVal instanceof Date
+
+      const expectation = {
+        toBe: (expectedVal) => inputs.expectToBe(expectVal, expectedVal),
+        toBeLevel2xx: () => inputs.expectToBeLevel2xx(expectVal),
+        toBeLevel3xx: () => inputs.expectToBeLevel3xx(expectVal),
+        toBeLevel4xx: () => inputs.expectToBeLevel4xx(expectVal),
+        toBeLevel5xx: () => inputs.expectToBeLevel5xx(expectVal),
+        toBeType: (expectedType) =>
+          inputs.expectToBeType(expectVal, expectedType, isDateInstance),
+        toHaveLength: (expectedLength) =>
+          inputs.expectToHaveLength(expectVal, expectedLength),
+        toInclude: (needle) => inputs.expectToInclude(expectVal, needle),
+      }
+
+      Object.defineProperty(expectation, "not", {
+        get: () => ({
+          toBe: (expectedVal) => inputs.expectNotToBe(expectVal, expectedVal),
+          toBeLevel2xx: () => inputs.expectNotToBeLevel2xx(expectVal),
+          toBeLevel3xx: () => inputs.expectNotToBeLevel3xx(expectVal),
+          toBeLevel4xx: () => inputs.expectNotToBeLevel4xx(expectVal),
+          toBeLevel5xx: () => inputs.expectNotToBeLevel5xx(expectVal),
+          toBeType: (expectedType) =>
+            inputs.expectNotToBeType(expectVal, expectedType, isDateInstance),
+          toHaveLength: (expectedLength) =>
+            inputs.expectNotToHaveLength(expectVal, expectedLength),
+          toInclude: (needle) => inputs.expectNotToInclude(expectVal, needle),
+        }),
+      })
+
+      return expectation
+    },
+    test: (descriptor, testFn) => {
+      inputs.preTest(descriptor)
+      testFn()
+      inputs.postTest()
+    },
+    response: hoppResponse,
+  }
+
+  // PM Namespace - Postman Compatibility Layer
+  globalThis.pm = {
+    environment: {
+      get: (key) => globalThis.hopp.env.active.get(key),
+      set: (key, value) => globalThis.hopp.env.active.set(key, value),
+      unset: (key) => globalThis.hopp.env.active.delete(key),
+      has: (key) => globalThis.hopp.env.active.get(key) !== null,
+      clear: () => {
+        throw new Error("pm.environment.clear() not yet implemented")
+      },
+      toObject: () => {
+        throw new Error("pm.environment.toObject() not yet implemented")
+      },
+    },
+
+    globals: {
+      get: (key) => globalThis.hopp.env.global.get(key),
+      set: (key, value) => globalThis.hopp.env.global.set(key, value),
+      unset: (key) => globalThis.hopp.env.global.delete(key),
+      has: (key) => globalThis.hopp.env.global.get(key) !== null,
+      clear: () => {
+        throw new Error("pm.globals.clear() not yet implemented")
+      },
+      toObject: () => {
+        throw new Error("pm.globals.toObject() not yet implemented")
+      },
+    },
+
+    variables: {
+      get: (key) => globalThis.hopp.env.get(key),
+      set: (key, value) => globalThis.hopp.env.active.set(key, value),
+      has: (key) => globalThis.hopp.env.get(key) !== null,
+      replaceIn: (template) => {
+        if (typeof template !== "string") return template
+        return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+          const value = globalThis.hopp.env.get(key.trim())
+          return value !== null ? value : match
+        })
+      },
+    },
+
+    request: {
+      get url() {
+        const urlString = globalThis.hopp.request.url
+        return {
+          toString: () => urlString,
+        }
+      },
+
+      get method() {
+        return globalThis.hopp.request.method
+      },
+
+      get headers() {
+        return {
+          get: (name) => {
+            const headers = globalThis.hopp.request.headers
+            const header = headers.find(
+              (h) => h.key.toLowerCase() === name.toLowerCase()
+            )
+            return header ? header.value : null
+          },
+          has: (name) => {
+            const headers = globalThis.hopp.request.headers
+            return headers.some(
+              (h) => h.key.toLowerCase() === name.toLowerCase()
+            )
+          },
+          all: () => {
+            const result = {}
+            globalThis.hopp.request.headers.forEach((header) => {
+              result[header.key] = header.value
+            })
+            return result
+          },
+        }
+      },
+
+      get body() {
+        return globalThis.hopp.request.body
+      },
+
+      get auth() {
+        return globalThis.hopp.request.auth
+      },
+    },
+
+    response: {
+      get code() {
+        return globalThis.hopp.response.statusCode
+      },
+      get status() {
+        return globalThis.hopp.response.statusText
+      },
+      get responseTime() {
+        return globalThis.hopp.response.responseTime
+      },
+      text: () => globalThis.hopp.response.body.asText(),
+      json: () => globalThis.hopp.response.body.asJSON(),
+      stream: globalThis.hopp.response.body.bytes(),
+      headers: {
+        get: (name) => {
+          const headers = globalThis.hopp.response.headers
+          const header = headers.find(
+            (h) => h.key.toLowerCase() === name.toLowerCase()
+          )
+          return header ? header.value : null
+        },
+        has: (name) => {
+          const headers = globalThis.hopp.response.headers
+          return headers.some((h) => h.key.toLowerCase() === name.toLowerCase())
+        },
+        all: () => {
+          const result = {}
+          globalThis.hopp.response.headers.forEach((header) => {
+            result[header.key] = header.value
+          })
+          return result
+        },
+      },
+      cookies: {
+        get: (_name) => {
+          throw new Error("pm.response.cookies.get() not yet implemented")
+        },
+        has: (_name) => {
+          throw new Error("pm.response.cookies.has() not yet implemented")
+        },
+        toObject: () => {
+          throw new Error("pm.response.cookies.toObject() not yet implemented")
+        },
+      },
+    },
+
+    cookies: {
+      get: (_name) => {
+        throw new Error(
+          "pm.cookies.get() needs domain information - use hopp.cookies instead"
+        )
+      },
+      set: (_name, _value, _options) => {
+        throw new Error(
+          "pm.cookies.set() needs domain information - use hopp.cookies instead"
+        )
+      },
+      jar: () => {
+        throw new Error("pm.cookies.jar() not yet implemented")
+      },
+    },
+
+    test: (name, fn) => globalThis.hopp.test(name, fn),
+    expect: (value) => globalThis.hopp.expect(value),
+
+    // Script context information
+    info: {
+      eventName: "post-request", // post-request context
+      get requestName() {
+        return inputs.pmInfoRequestName()
+      },
+      get requestId() {
+        return inputs.pmInfoRequestId()
+      },
+      // Unsupported Collection Runner features
+      get iteration() {
+        throw new Error(
+          "pm.info.iteration is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      get iterationCount() {
+        throw new Error(
+          "pm.info.iterationCount is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+    },
+
+    // Unsupported APIs that throw errors
+    sendRequest: () => {
+      throw new Error("pm.sendRequest() is not yet implemented in Hoppscotch")
+    },
+
+    // Collection variables (unsupported)
+    collectionVariables: {
+      get: () => {
+        throw new Error(
+          "pm.collectionVariables.get() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      set: () => {
+        throw new Error(
+          "pm.collectionVariables.set() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      unset: () => {
+        throw new Error(
+          "pm.collectionVariables.unset() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      has: () => {
+        throw new Error(
+          "pm.collectionVariables.has() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      clear: () => {
+        throw new Error(
+          "pm.collectionVariables.clear() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      toObject: () => {
+        throw new Error(
+          "pm.collectionVariables.toObject() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+    },
+
+    // Postman Vault (unsupported)
+    vault: {
+      get: () => {
+        throw new Error(
+          "pm.vault.get() is not supported in Hoppscotch (Postman Vault feature)"
+        )
+      },
+      set: () => {
+        throw new Error(
+          "pm.vault.set() is not supported in Hoppscotch (Postman Vault feature)"
+        )
+      },
+      unset: () => {
+        throw new Error(
+          "pm.vault.unset() is not supported in Hoppscotch (Postman Vault feature)"
+        )
+      },
+    },
+
+    // Iteration data (unsupported)
+    iterationData: {
+      get: () => {
+        throw new Error(
+          "pm.iterationData.get() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      set: () => {
+        throw new Error(
+          "pm.iterationData.set() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      unset: () => {
+        throw new Error(
+          "pm.iterationData.unset() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      has: () => {
+        throw new Error(
+          "pm.iterationData.has() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      toObject: () => {
+        throw new Error(
+          "pm.iterationData.toObject() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+    },
+
+    // Execution control (unsupported)
+    execution: {
+      setNextRequest: () => {
+        throw new Error(
+          "pm.execution.setNextRequest() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+    },
   }
 }
diff --git a/packages/hoppscotch-js-sandbox/src/bootstrap-code/pre-request.js b/packages/hoppscotch-js-sandbox/src/bootstrap-code/pre-request.js
index 9e831b31..e8e341de 100644
--- a/packages/hoppscotch-js-sandbox/src/bootstrap-code/pre-request.js
+++ b/packages/hoppscotch-js-sandbox/src/bootstrap-code/pre-request.js
@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions */
 ;(inputs) => {
+  // Keep strict mode scoped to this IIFE to avoid leaking strictness to concatenated/bootstrapped code
+  "use strict"
   globalThis.pw = {
     env: {
       get: (key) => inputs.envGet(key),
@@ -9,4 +11,299 @@
       resolve: (key) => inputs.envResolve(key),
     },
   }
+
+  const requestProps = {
+    // Setter methods
+    setUrl: (url) => inputs.setRequestUrl(url),
+    setMethod: (method) => inputs.setRequestMethod(method),
+    setHeader: (name, value) => inputs.setRequestHeader(name, value),
+    setHeaders: (headers) => inputs.setRequestHeaders(headers),
+    removeHeader: (key) => inputs.removeRequestHeader(key),
+    setParam: (name, value) => inputs.setRequestParam(name, value),
+    setParams: (params) => inputs.setRequestParams(params),
+    removeParam: (key) => inputs.removeRequestParam(key),
+    setBody: (body) => inputs.setRequestBody(body),
+    setAuth: (auth) => inputs.setRequestAuth(auth),
+
+    // Request variables
+    variables: {
+      get: (key) => inputs.getRequestVariable(key),
+      set: (key, value) => inputs.setRequestVariable(key, value),
+    },
+  }
+
+  // Define all properties with unified read-only protection
+  ;["url", "method", "params", "headers", "body", "auth"].forEach((prop) => {
+    Object.defineProperty(requestProps, prop, {
+      enumerable: true,
+      configurable: false,
+      get() {
+        const currentValues = inputs.getRequestProps()
+        return currentValues[prop]
+      },
+      set(_value) {
+        throw new TypeError(`hopp.request.${prop} is read-only`)
+      },
+    })
+  })
+
+  // Freeze the entire requestProps object for additional protection
+  Object.freeze(requestProps)
+
+  globalThis.hopp = {
+    env: {
+      get: (key) =>
+        inputs.envGetResolve(key, { fallbackToNull: true, source: "all" }),
+      getRaw: (key) =>
+        inputs.envGet(key, { fallbackToNull: true, source: "all" }),
+      set: (key, value) => inputs.envSet(key, value),
+      delete: (key) => inputs.envUnset(key),
+      reset: (key) => inputs.envReset(key),
+      getInitialRaw: (key) => inputs.envGetInitialRaw(key),
+      setInitial: (key, value) => inputs.envSetInitial(key, value),
+
+      active: {
+        get: (key) =>
+          inputs.envGetResolve(key, { fallbackToNull: true, source: "active" }),
+        getRaw: (key) =>
+          inputs.envGet(key, { fallbackToNull: true, source: "active" }),
+        set: (key, value) => inputs.envSet(key, value, { source: "active" }),
+        delete: (key) => inputs.envUnset(key, { source: "active" }),
+        reset: (key) => inputs.envReset(key, { source: "active" }),
+        getInitialRaw: (key) =>
+          inputs.envGetInitialRaw(key, { source: "active" }),
+        setInitial: (key, value) =>
+          inputs.envSetInitial(key, value, { source: "active" }),
+      },
+
+      global: {
+        get: (key) =>
+          inputs.envGetResolve(key, { fallbackToNull: true, source: "global" }),
+        getRaw: (key) =>
+          inputs.envGet(key, { fallbackToNull: true, source: "global" }),
+        set: (key, value) => inputs.envSet(key, value, { source: "global" }),
+        delete: (key) => inputs.envUnset(key, { source: "global" }),
+        reset: (key) => inputs.envReset(key, { source: "global" }),
+        getInitialRaw: (key) =>
+          inputs.envGetInitialRaw(key, { source: "global" }),
+        setInitial: (key, value) =>
+          inputs.envSetInitial(key, value, { source: "global" }),
+      },
+    },
+    request: requestProps,
+    cookies: {
+      get: (domain, name) => inputs.cookieGet(domain, name),
+      set: (domain, cookie) => inputs.cookieSet(domain, cookie),
+      has: (domain, name) => inputs.cookieHas(domain, name),
+      getAll: (domain) => inputs.cookieGetAll(domain),
+      delete: (domain, name) => inputs.cookieDelete(domain, name),
+      clear: (domain) => inputs.cookieClear(domain),
+    },
+  }
+
+  // PM Namespace - Postman Compatibility Layer
+  globalThis.pm = {
+    environment: {
+      get: (key) => globalThis.hopp.env.active.get(key),
+      set: (key, value) => globalThis.hopp.env.active.set(key, value),
+      unset: (key) => globalThis.hopp.env.active.delete(key),
+      has: (key) => globalThis.hopp.env.active.get(key) !== null,
+      clear: () => {
+        throw new Error("pm.environment.clear() not yet implemented")
+      },
+      toObject: () => {
+        throw new Error("pm.environment.toObject() not yet implemented")
+      },
+    },
+
+    globals: {
+      get: (key) => globalThis.hopp.env.global.get(key),
+      set: (key, value) => globalThis.hopp.env.global.set(key, value),
+      unset: (key) => globalThis.hopp.env.global.delete(key),
+      has: (key) => globalThis.hopp.env.global.get(key) !== null,
+      clear: () => {
+        throw new Error("pm.globals.clear() not yet implemented")
+      },
+      toObject: () => {
+        throw new Error("pm.globals.toObject() not yet implemented")
+      },
+    },
+
+    variables: {
+      get: (key) => globalThis.hopp.env.get(key),
+      set: (key, value) => globalThis.hopp.env.active.set(key, value),
+      has: (key) => globalThis.hopp.env.get(key) !== null,
+      replaceIn: (template) => {
+        if (typeof template !== "string") return template
+        return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+          const value = globalThis.hopp.env.get(key.trim())
+          return value !== null ? value : match
+        })
+      },
+    },
+
+    request: {
+      get url() {
+        const urlString = globalThis.hopp.request.url
+        return {
+          toString: () => urlString,
+        }
+      },
+
+      get method() {
+        return globalThis.hopp.request.method
+      },
+
+      get headers() {
+        return {
+          get: (name) => {
+            const headers = globalThis.hopp.request.headers
+            const header = headers.find(
+              (h) => h.key.toLowerCase() === name.toLowerCase()
+            )
+            return header ? header.value : null
+          },
+          has: (name) => {
+            const headers = globalThis.hopp.request.headers
+            return headers.some(
+              (h) => h.key.toLowerCase() === name.toLowerCase()
+            )
+          },
+          all: () => {
+            const result = {}
+            globalThis.hopp.request.headers.forEach((header) => {
+              result[header.key] = header.value
+            })
+            return result
+          },
+        }
+      },
+
+      get body() {
+        return globalThis.hopp.request.body
+      },
+
+      get auth() {
+        return globalThis.hopp.request.auth
+      },
+    },
+
+    // Script context information
+    info: {
+      eventName: "pre-request",
+      get requestName() {
+        return inputs.pmInfoRequestName()
+      },
+      get requestId() {
+        return inputs.pmInfoRequestId()
+      },
+      // Unsupported Collection Runner features
+      get iteration() {
+        throw new Error(
+          "pm.info.iteration is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      get iterationCount() {
+        throw new Error(
+          "pm.info.iterationCount is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+    },
+
+    // Unsupported APIs that throw errors
+    sendRequest: () => {
+      throw new Error("pm.sendRequest() is not yet implemented in Hoppscotch")
+    },
+
+    // Collection variables (unsupported)
+    collectionVariables: {
+      get: () => {
+        throw new Error(
+          "pm.collectionVariables.get() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      set: () => {
+        throw new Error(
+          "pm.collectionVariables.set() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      unset: () => {
+        throw new Error(
+          "pm.collectionVariables.unset() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      has: () => {
+        throw new Error(
+          "pm.collectionVariables.has() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      clear: () => {
+        throw new Error(
+          "pm.collectionVariables.clear() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+      toObject: () => {
+        throw new Error(
+          "pm.collectionVariables.toObject() is not supported in Hoppscotch (use environment or request variables instead)"
+        )
+      },
+    },
+
+    // Postman Vault (unsupported)
+    vault: {
+      get: () => {
+        throw new Error(
+          "pm.vault.get() is not supported in Hoppscotch (Postman Vault feature)"
+        )
+      },
+      set: () => {
+        throw new Error(
+          "pm.vault.set() is not supported in Hoppscotch (Postman Vault feature)"
+        )
+      },
+      unset: () => {
+        throw new Error(
+          "pm.vault.unset() is not supported in Hoppscotch (Postman Vault feature)"
+        )
+      },
+    },
+
+    // Iteration data (unsupported)
+    iterationData: {
+      get: () => {
+        throw new Error(
+          "pm.iterationData.get() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      set: () => {
+        throw new Error(
+          "pm.iterationData.set() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      unset: () => {
+        throw new Error(
+          "pm.iterationData.unset() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      has: () => {
+        throw new Error(
+          "pm.iterationData.has() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+      toObject: () => {
+        throw new Error(
+          "pm.iterationData.toObject() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+    },
+
+    // Execution control (unsupported)
+    execution: {
+      setNextRequest: () => {
+        throw new Error(
+          "pm.execution.setNextRequest() is not supported in Hoppscotch (Collection Runner feature)"
+        )
+      },
+    },
+  }
 }
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/index.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/index.ts
index d8a9d08c..7afb4fb6 100644
--- a/packages/hoppscotch-js-sandbox/src/cage-modules/index.ts
+++ b/packages/hoppscotch-js-sandbox/src/cage-modules/index.ts
@@ -1,2 +1,2 @@
 export { defaultModules } from "./default"
-export { pwPostRequestModule, pwPreRequestModule } from "./pw"
+export { postRequestModule, preRequestModule } from "./scripting-modules"
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/hopp-namespace.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/hopp-namespace.ts
new file mode 100644
index 00000000..9686fce0
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/hopp-namespace.ts
@@ -0,0 +1,77 @@
+import { CageModuleCtx, defineSandboxFn } from "faraday-cage/modules"
+
+import type { EnvMethods, RequestProps, HoppNamespaceMethods } from "~/types"
+import type { EnvAPIOptions } from "~/utils/shared"
+
+/**
+ * Creates hopp namespace methods for the sandbox environment
+ * Includes environment operations with hopp-specific API
+ */
+export const createHoppNamespaceMethods = (
+  ctx: CageModuleCtx,
+  envMethods: EnvMethods,
+  requestProps: RequestProps
+): HoppNamespaceMethods => {
+  return {
+    // `hopp` namespace environment methods
+    envDelete: defineSandboxFn(
+      ctx,
+      "envDelete",
+      function (key: unknown, options?: unknown) {
+        return envMethods.hopp.delete(key as string, options as EnvAPIOptions)
+      }
+    ),
+    envReset: defineSandboxFn(
+      ctx,
+      "envReset",
+      function (key: unknown, options?: unknown) {
+        return envMethods.hopp.reset(key as string, options as EnvAPIOptions)
+      }
+    ),
+    envGetInitialRaw: defineSandboxFn(
+      ctx,
+      "envGetInitialRaw",
+      function (key: unknown, options?: unknown) {
+        return envMethods.hopp.getInitialRaw(
+          key as string,
+          options as EnvAPIOptions
+        )
+      }
+    ),
+    envSetInitial: defineSandboxFn(
+      ctx,
+      "envSetInitial",
+      function (key: unknown, value: unknown, options?: unknown) {
+        return envMethods.hopp.setInitial(
+          key as string,
+          value as string,
+          options as EnvAPIOptions
+        )
+      }
+    ),
+
+    // Request getter props
+    getRequestProps: defineSandboxFn(ctx, "getRequestProps", function () {
+      return {
+        get url() {
+          return requestProps.url
+        },
+        get method() {
+          return requestProps.method
+        },
+        get params() {
+          return requestProps.params
+        },
+        get headers() {
+          return requestProps.headers
+        },
+        get body() {
+          return requestProps.body
+        },
+        get auth() {
+          return requestProps.auth
+        },
+      }
+    }),
+  }
+}
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/pm-namespace.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/pm-namespace.ts
new file mode 100644
index 00000000..9737a89b
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/pm-namespace.ts
@@ -0,0 +1,23 @@
+import { HoppRESTRequest } from "@hoppscotch/data"
+import { CageModuleCtx, defineSandboxFn } from "faraday-cage/modules"
+
+import type { PmNamespaceMethods } from "~/types"
+
+/**
+ * Creates pm (Postman compatibility) namespace methods for the sandbox environment
+ * Provides Postman-compatible APIs for request information
+ */
+export const createPmNamespaceMethods = (
+  ctx: CageModuleCtx,
+  config: { request: HoppRESTRequest }
+): PmNamespaceMethods => {
+  return {
+    // `pm` namespace methods for Postman compatibility
+    pmInfoRequestName: defineSandboxFn(ctx, "pmInfoRequestName", () => {
+      return config.request.name
+    }),
+    pmInfoRequestId: defineSandboxFn(ctx, "pmInfoRequestId", () => {
+      return config.request.id
+    }),
+  }
+}
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/pw-namespace.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/pw-namespace.ts
new file mode 100644
index 00000000..7308c06a
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/cage-modules/namespaces/pw-namespace.ts
@@ -0,0 +1,56 @@
+import { CageModuleCtx, defineSandboxFn } from "faraday-cage/modules"
+
+import type { EnvMethods, RequestProps, PwNamespaceMethods } from "~/types"
+
+/**
+ * Creates pw namespace methods for the sandbox environment
+ * Includes environment operations and request variable management
+ */
+export const createPwNamespaceMethods = (
+  ctx: CageModuleCtx,
+  envMethods: EnvMethods,
+  requestProps: RequestProps
+): PwNamespaceMethods => {
+  return {
+    // `pw` namespace environment methods
+    envGet: defineSandboxFn(ctx, "envGet", function (key: any, options: any) {
+      return envMethods.pw.get(key, options)
+    }),
+    envGetResolve: defineSandboxFn(
+      ctx,
+      "envGetResolve",
+      function (key: any, options: any) {
+        return envMethods.pw.getResolve(key, options)
+      }
+    ),
+    envSet: defineSandboxFn(
+      ctx,
+      "envSet",
+      function (key: any, value: any, options: any) {
+        return envMethods.pw.set(key, value, options)
+      }
+    ),
+    envUnset: defineSandboxFn(
+      ctx,
+      "envUnset",
+      function (key: any, options: any) {
+        return envMethods.pw.unset(key, options)
+      }
+    ),
+    envResolve: defineSandboxFn(ctx, "envResolve", function (key: any) {
+      return envMethods.pw.resolve(key)
+    }),
+
+    // Request variable operations
+    getRequestVariable: defineSandboxFn(
+      ctx,
+      "getRequestVariable",
+      function (key: any) {
+        const reqVarEntry = requestProps.requestVariables.find(
+          (reqVar: any) => reqVar.key === key
+        )
+        return reqVarEntry ? reqVarEntry.value : null
+      }
+    ),
+  }
+}
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/pw.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/pw.ts
deleted file mode 100644
index 46a8125b..00000000
--- a/packages/hoppscotch-js-sandbox/src/cage-modules/pw.ts
+++ /dev/null
@@ -1,268 +0,0 @@
-import {
-  defineCageModule,
-  defineSandboxFn,
-  defineSandboxObject,
-} from "faraday-cage/modules"
-import { createExpectation, getSharedMethods } from "~/shared-utils"
-import { TestDescriptor, TestResponse, TestResult } from "~/types"
-
-import postRequestBootstrapCode from "../bootstrap-code/post-request?raw"
-import preRequestBootstrapCode from "../bootstrap-code/pre-request?raw"
-
-type PwPostRequestModuleConfig = {
-  envs: TestResult["envs"]
-  testRunStack: TestDescriptor[]
-  response: TestResponse
-  handleSandboxResults: ({
-    envs,
-    testRunStack,
-  }: {
-    envs: TestResult["envs"]
-    testRunStack: TestDescriptor[]
-  }) => void
-}
-
-type PwPreRequestModuleConfig = {
-  envs: TestResult["envs"]
-  handleSandboxResults: ({ envs }: { envs: TestResult["envs"] }) => void
-}
-
-type PwModuleType = "pre" | "post"
-type PwModuleConfig = PwPreRequestModuleConfig | PwPostRequestModuleConfig
-
-const createPwInputsObj = (
-  ctx: any,
-  methods: any,
-  type: PwModuleType,
-  config: PwModuleConfig
-) => {
-  const baseInputs = {
-    envGet: defineSandboxFn(ctx, "get", (key) => methods.env.get(key)),
-    envGetResolve: defineSandboxFn(ctx, "getResolve", (key) =>
-      methods.env.getResolve(key)
-    ),
-    envSet: defineSandboxFn(ctx, "set", (key, value) => {
-      return methods.env.set(key, value)
-    }),
-    envUnset: defineSandboxFn(ctx, "unset", (key) => methods.env.unset(key)),
-    envResolve: defineSandboxFn(ctx, "resolve", (key) =>
-      methods.env.resolve(key)
-    ),
-  }
-
-  if (type === "post") {
-    const postConfig = config as PwPostRequestModuleConfig
-    return {
-      ...baseInputs,
-      expectToBe: defineSandboxFn(ctx, "toBe", (expectVal, expectedVal) =>
-        createExpectation(expectVal, false, postConfig.testRunStack).toBe(
-          expectedVal
-        )
-      ),
-      expectToBeLevel2xx: defineSandboxFn(ctx, "toBeLevel2xx", (expectVal) =>
-        createExpectation(
-          expectVal,
-          false,
-          postConfig.testRunStack
-        ).toBeLevel2xx()
-      ),
-      expectToBeLevel3xx: defineSandboxFn(ctx, "toBeLevel3xx", (expectVal) =>
-        createExpectation(
-          expectVal,
-          false,
-          postConfig.testRunStack
-        ).toBeLevel3xx()
-      ),
-      expectToBeLevel4xx: defineSandboxFn(ctx, "toBeLevel4xx", (expectVal) =>
-        createExpectation(
-          expectVal,
-          false,
-          postConfig.testRunStack
-        ).toBeLevel4xx()
-      ),
-      expectToBeLevel5xx: defineSandboxFn(ctx, "toBeLevel5xx", (expectVal) =>
-        createExpectation(
-          expectVal,
-          false,
-          postConfig.testRunStack
-        ).toBeLevel5xx()
-      ),
-      expectToBeType: defineSandboxFn(
-        ctx,
-        "toBeType",
-        (expectVal, expectedType, isExpectValDateInstance) => {
-          // Supplying `new Date()` in the script gets serialized in the sandbox context
-          // Parse the string back to a date instance
-          const resolvedExpectVal =
-            isExpectValDateInstance && typeof expectVal === "string"
-              ? new Date(expectVal)
-              : expectVal
-
-          return createExpectation(
-            resolvedExpectVal,
-            false,
-            postConfig.testRunStack
-          ).toBeType(expectedType)
-        }
-      ),
-      expectToHaveLength: defineSandboxFn(
-        ctx,
-        "toHaveLength",
-        (expectVal, expectedLength) =>
-          createExpectation(
-            expectVal,
-            false,
-            postConfig.testRunStack
-          ).toHaveLength(expectedLength)
-      ),
-      expectToInclude: defineSandboxFn(ctx, "toInclude", (expectVal, needle) =>
-        createExpectation(expectVal, false, postConfig.testRunStack).toInclude(
-          needle
-        )
-      ),
-      expectNotToBe: defineSandboxFn(ctx, "notToBe", (expectVal, expectedVal) =>
-        createExpectation(expectVal, false, postConfig.testRunStack).not.toBe(
-          expectedVal
-        )
-      ),
-      expectNotToBeLevel2xx: defineSandboxFn(
-        ctx,
-        "notToBeLevel2xx",
-        (expectVal) =>
-          createExpectation(
-            expectVal,
-            false,
-            postConfig.testRunStack
-          ).not.toBeLevel2xx()
-      ),
-      expectNotToBeLevel3xx: defineSandboxFn(
-        ctx,
-        "notToBeLevel3xx",
-        (expectVal) =>
-          createExpectation(
-            expectVal,
-            false,
-            postConfig.testRunStack
-          ).not.toBeLevel3xx()
-      ),
-      expectNotToBeLevel4xx: defineSandboxFn(
-        ctx,
-        "notToBeLevel4xx",
-        (expectVal) =>
-          createExpectation(
-            expectVal,
-            false,
-            postConfig.testRunStack
-          ).not.toBeLevel4xx()
-      ),
-      expectNotToBeLevel5xx: defineSandboxFn(
-        ctx,
-        "notToBeLevel5xx",
-        (expectVal) =>
-          createExpectation(
-            expectVal,
-            false,
-            postConfig.testRunStack
-          ).not.toBeLevel5xx()
-      ),
-      expectNotToBeType: defineSandboxFn(
-        ctx,
-        "notToBeType",
-        (expectVal, expectedType, isExpectValDateInstance) => {
-          // Supplying `new Date()` in the script gets serialized in the sandbox context
-          // Parse the string back to a date instance
-          const resolvedExpectVal =
-            isExpectValDateInstance && typeof expectVal === "string"
-              ? new Date(expectVal)
-              : expectVal
-
-          return createExpectation(
-            resolvedExpectVal,
-            false,
-            postConfig.testRunStack
-          ).not.toBeType(expectedType)
-        }
-      ),
-      expectNotToHaveLength: defineSandboxFn(
-        ctx,
-        "notToHaveLength",
-        (expectVal, expectedLength) =>
-          createExpectation(
-            expectVal,
-            false,
-            postConfig.testRunStack
-          ).not.toHaveLength(expectedLength)
-      ),
-      expectNotToInclude: defineSandboxFn(
-        ctx,
-        "notToInclude",
-        (expectVal, needle) =>
-          createExpectation(
-            expectVal,
-            false,
-            postConfig.testRunStack
-          ).not.toInclude(needle)
-      ),
-      preTest: defineSandboxFn(ctx, "preTest", (descriptor: any) => {
-        postConfig.testRunStack.push({
-          descriptor,
-          expectResults: [],
-          children: [],
-        })
-      }),
-      postTest: defineSandboxFn(ctx, "postTest", () => {
-        const child = postConfig.testRunStack.pop() as TestDescriptor
-        postConfig.testRunStack[
-          postConfig.testRunStack.length - 1
-        ].children.push(child)
-      }),
-      getResponse: defineSandboxFn(
-        ctx,
-        "getResponse",
-        () => postConfig.response
-      ),
-    }
-  }
-
-  return baseInputs
-}
-
-const createPwModule = (
-  type: PwModuleType,
-  bootstrapCode: string,
-  config: PwModuleConfig
-) => {
-  return defineCageModule((ctx) => {
-    const funcHandle = ctx.scope.manage(ctx.vm.evalCode(bootstrapCode)).unwrap()
-
-    const { methods, updatedEnvs } = getSharedMethods(config.envs)
-
-    const inputsObj = defineSandboxObject(
-      ctx,
-      createPwInputsObj(ctx, methods, type, config)
-    )
-
-    ctx.vm.callFunction(funcHandle, ctx.vm.undefined, inputsObj)
-
-    ctx.afterScriptExecutionHooks.push(() => {
-      if (type === "post") {
-        const postConfig = config as PwPostRequestModuleConfig
-        postConfig.handleSandboxResults({
-          envs: updatedEnvs,
-          testRunStack: postConfig.testRunStack,
-        })
-      } else {
-        const preConfig = config as PwPreRequestModuleConfig
-        preConfig.handleSandboxResults({
-          envs: updatedEnvs,
-        })
-      }
-    })
-  })
-}
-
-export const pwPreRequestModule = (config: PwPreRequestModuleConfig) =>
-  createPwModule("pre", preRequestBootstrapCode, config)
-
-export const pwPostRequestModule = (config: PwPostRequestModuleConfig) =>
-  createPwModule("post", postRequestBootstrapCode, config)
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/scripting-modules.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/scripting-modules.ts
new file mode 100644
index 00000000..59db7e1c
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/cage-modules/scripting-modules.ts
@@ -0,0 +1,220 @@
+import { Cookie, HoppRESTRequest } from "@hoppscotch/data"
+import {
+  CageModuleCtx,
+  defineCageModule,
+  defineSandboxFn,
+  defineSandboxObject,
+} from "faraday-cage/modules"
+
+import { TestDescriptor, TestResponse, TestResult } from "~/types"
+import postRequestBootstrapCode from "../bootstrap-code/post-request?raw"
+import preRequestBootstrapCode from "../bootstrap-code/pre-request?raw"
+import { createBaseInputs } from "./utils/base-inputs"
+import { createExpectationMethods } from "./utils/expectation-helpers"
+import { createRequestSetterMethods } from "./utils/request-setters"
+
+type PostRequestModuleConfig = {
+  envs: TestResult["envs"]
+  testRunStack: TestDescriptor[]
+  request: HoppRESTRequest
+  response: TestResponse
+  cookies: Cookie[] | null
+  handleSandboxResults: ({
+    envs,
+    testRunStack,
+    cookies,
+  }: {
+    envs: TestResult["envs"]
+    testRunStack: TestDescriptor[]
+    cookies: Cookie[] | null
+  }) => void
+}
+
+type PreRequestModuleConfig = {
+  envs: TestResult["envs"]
+  request: HoppRESTRequest
+  cookies: Cookie[] | null
+  handleSandboxResults: ({
+    envs,
+    request,
+    cookies,
+  }: {
+    envs: TestResult["envs"]
+    request: HoppRESTRequest
+    cookies: Cookie[] | null
+  }) => void
+}
+
+type ModuleType = "pre" | "post"
+type ModuleConfig = PreRequestModuleConfig | PostRequestModuleConfig
+
+/**
+ * Additional results that may be required for hook registration
+ */
+type HookRegistrationAdditionalResults = {
+  getUpdatedRequest: () => HoppRESTRequest
+}
+
+/**
+ * Helper function to register after-script execution hooks with proper typing
+ * Overload for pre-request hooks (requires additionalResults)
+ */
+function registerAfterScriptExecutionHook(
+  ctx: CageModuleCtx,
+  type: "pre",
+  config: PreRequestModuleConfig,
+  baseInputs: ReturnType<typeof createBaseInputs>,
+  additionalResults: HookRegistrationAdditionalResults
+): void
+
+/**
+ * Overload for post-request hooks (no additionalResults needed)
+ */
+function registerAfterScriptExecutionHook(
+  ctx: CageModuleCtx,
+  type: "post",
+  config: PostRequestModuleConfig,
+  baseInputs: ReturnType<typeof createBaseInputs>
+): void
+
+/**
+ * Implementation of the hook registration function
+ */
+function registerAfterScriptExecutionHook(
+  ctx: CageModuleCtx,
+  type: ModuleType,
+  config: ModuleConfig,
+  baseInputs: ReturnType<typeof createBaseInputs>,
+  additionalResults?: HookRegistrationAdditionalResults
+) {
+  if (type === "pre") {
+    const preConfig = config as PreRequestModuleConfig
+    const getUpdatedRequest = additionalResults?.getUpdatedRequest
+
+    if (!getUpdatedRequest) {
+      throw new Error(
+        "getUpdatedRequest is required for pre-request hook registration"
+      )
+    }
+
+    ctx.afterScriptExecutionHooks.push(() => {
+      preConfig.handleSandboxResults({
+        envs: baseInputs.getUpdatedEnvs(),
+        request: getUpdatedRequest(),
+        cookies: baseInputs.getUpdatedCookies(),
+      })
+    })
+  } else if (type === "post") {
+    const postConfig = config as PostRequestModuleConfig
+
+    ctx.afterScriptExecutionHooks.push(() => {
+      postConfig.handleSandboxResults({
+        envs: baseInputs.getUpdatedEnvs(),
+        testRunStack: postConfig.testRunStack,
+        cookies: baseInputs.getUpdatedCookies(),
+      })
+    })
+  }
+}
+
+/**
+ * Creates input object for scripting modules with appropriate methods based on type
+ */
+const createScriptingInputsObj = (
+  ctx: CageModuleCtx,
+  type: ModuleType,
+  config: ModuleConfig
+) => {
+  // Create base inputs shared across all namespaces
+  const baseInputs = createBaseInputs(ctx, {
+    envs: config.envs,
+    request: config.request,
+    cookies: config.cookies,
+  })
+
+  if (type === "pre") {
+    const preConfig = config as PreRequestModuleConfig
+
+    // Create request setter methods for pre-request scripts
+    const { methods: requestSetterMethods, getUpdatedRequest } =
+      createRequestSetterMethods(ctx, preConfig.request)
+
+    // Register hook with helper function
+    registerAfterScriptExecutionHook(ctx, "pre", preConfig, baseInputs, {
+      getUpdatedRequest,
+    })
+
+    return {
+      ...baseInputs,
+      ...requestSetterMethods,
+    }
+  }
+
+  if (type === "post") {
+    const postConfig = config as PostRequestModuleConfig
+
+    // Create expectation methods for post-request scripts
+    const expectationMethods = createExpectationMethods(
+      ctx,
+      postConfig.testRunStack
+    )
+
+    // Register hook with helper function
+    registerAfterScriptExecutionHook(ctx, "post", postConfig, baseInputs)
+
+    return {
+      ...baseInputs,
+      ...expectationMethods,
+
+      // Test management methods
+      preTest: defineSandboxFn(
+        ctx,
+        "preTest",
+        function preTest(descriptor: any) {
+          postConfig.testRunStack.push({
+            descriptor,
+            expectResults: [],
+            children: [],
+          })
+        }
+      ),
+      postTest: defineSandboxFn(ctx, "postTest", function postTest() {
+        const child = postConfig.testRunStack.pop() as TestDescriptor
+        postConfig.testRunStack[
+          postConfig.testRunStack.length - 1
+        ].children.push(child)
+      }),
+      getResponse: defineSandboxFn(ctx, "getResponse", function getResponse() {
+        return postConfig.response
+      }),
+    }
+  }
+
+  return baseInputs
+}
+
+/**
+ * Creates a scripting module for pre or post request execution
+ */
+const createScriptingModule = (
+  type: ModuleType,
+  bootstrapCode: string,
+  config: ModuleConfig
+) => {
+  return defineCageModule((ctx) => {
+    const funcHandle = ctx.scope.manage(ctx.vm.evalCode(bootstrapCode)).unwrap()
+
+    const inputsObj = defineSandboxObject(
+      ctx,
+      createScriptingInputsObj(ctx, type, config)
+    )
+
+    ctx.vm.callFunction(funcHandle, ctx.vm.undefined, inputsObj)
+  })
+}
+
+export const preRequestModule = (config: PreRequestModuleConfig) =>
+  createScriptingModule("pre", preRequestBootstrapCode, config)
+
+export const postRequestModule = (config: PostRequestModuleConfig) =>
+  createScriptingModule("post", postRequestBootstrapCode, config)
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/utils/base-inputs.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/utils/base-inputs.ts
new file mode 100644
index 00000000..fa32f57a
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/cage-modules/utils/base-inputs.ts
@@ -0,0 +1,80 @@
+import { Cookie, HoppRESTRequest } from "@hoppscotch/data"
+import { CageModuleCtx, defineSandboxFn } from "faraday-cage/modules"
+
+import { TestResult, BaseInputs } from "~/types"
+import {
+  getSharedCookieMethods,
+  getSharedEnvMethods,
+  getSharedRequestProps,
+} from "~/utils/shared"
+import { createHoppNamespaceMethods } from "../namespaces/hopp-namespace"
+import { createPmNamespaceMethods } from "../namespaces/pm-namespace"
+import { createPwNamespaceMethods } from "../namespaces/pw-namespace"
+
+type BaseInputsConfig = {
+  envs: TestResult["envs"]
+  request: HoppRESTRequest
+  cookies: Cookie[] | null
+}
+
+/**
+ * Creates the base input object containing all shared methods across namespaces
+ */
+export const createBaseInputs = (
+  ctx: CageModuleCtx,
+  config: BaseInputsConfig
+): BaseInputs => {
+  // Get environment methods - Applicable to both hopp and pw namespaces
+  const { methods: envMethods, updatedEnvs } = getSharedEnvMethods(
+    config.envs,
+    true
+  )
+
+  const { methods: cookieMethods, getUpdatedCookies } = getSharedCookieMethods(
+    config.cookies
+  )
+
+  // Get request properties - shared across pre and post request contexts
+  const requestProps = getSharedRequestProps(config.request)
+
+  // Cookie accessors
+  const cookieProps = {
+    cookieGet: defineSandboxFn(ctx, "cookieGet", (domain: any, name: any) => {
+      return cookieMethods.get(domain, name) || null
+    }),
+    cookieSet: defineSandboxFn(ctx, "cookieSet", (domain: any, cookie: any) => {
+      return cookieMethods.set(domain, cookie)
+    }),
+    cookieHas: defineSandboxFn(ctx, "cookieHas", (domain: any, name: any) => {
+      return cookieMethods.has(domain, name)
+    }),
+    cookieGetAll: defineSandboxFn(ctx, "cookieGetAll", (domain: any) => {
+      return cookieMethods.getAll(domain)
+    }),
+    cookieDelete: defineSandboxFn(
+      ctx,
+      "cookieDelete",
+      (domain: any, name: any) => {
+        return cookieMethods.delete(domain, name)
+      }
+    ),
+    cookieClear: defineSandboxFn(ctx, "cookieClear", (domain: any) => {
+      return cookieMethods.clear(domain)
+    }),
+  }
+
+  // Combine all namespace methods
+  const pwMethods = createPwNamespaceMethods(ctx, envMethods, requestProps)
+  const hoppMethods = createHoppNamespaceMethods(ctx, envMethods, requestProps)
+  const pmMethods = createPmNamespaceMethods(ctx, config)
+
+  return {
+    ...pwMethods,
+    ...hoppMethods,
+    ...pmMethods,
+    ...cookieProps,
+    // Expose the updated state accessors
+    getUpdatedEnvs: () => updatedEnvs,
+    getUpdatedCookies,
+  }
+}
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/utils/expectation-helpers.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/utils/expectation-helpers.ts
new file mode 100644
index 00000000..5f369d1b
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/cage-modules/utils/expectation-helpers.ts
@@ -0,0 +1,144 @@
+import { CageModuleCtx, defineSandboxFn } from "faraday-cage/modules"
+
+import { TestDescriptor, ExpectationMethods } from "~/types"
+import { createExpectation } from "~/utils/shared"
+
+/**
+ * Creates expectation methods for test assertions in post-request scripts
+ */
+export const createExpectationMethods = (
+  ctx: CageModuleCtx,
+  testRunStack: TestDescriptor[]
+): ExpectationMethods => {
+  const createExpect = (expectVal: any) =>
+    createExpectation(expectVal, false, testRunStack)
+
+  return {
+    expectToBe: defineSandboxFn(
+      ctx,
+      "expectToBe",
+      (expectVal: any, expectedVal: any) => {
+        return createExpect(expectVal).toBe(expectedVal)
+      }
+    ),
+    expectToBeLevel2xx: defineSandboxFn(
+      ctx,
+      "expectToBeLevel2xx",
+      (expectVal: any) => {
+        return createExpect(expectVal).toBeLevel2xx()
+      }
+    ),
+    expectToBeLevel3xx: defineSandboxFn(
+      ctx,
+      "expectToBeLevel3xx",
+      (expectVal: any) => {
+        return createExpect(expectVal).toBeLevel3xx()
+      }
+    ),
+    expectToBeLevel4xx: defineSandboxFn(
+      ctx,
+      "expectToBeLevel4xx",
+      (expectVal: any) => {
+        return createExpect(expectVal).toBeLevel4xx()
+      }
+    ),
+    expectToBeLevel5xx: defineSandboxFn(
+      ctx,
+      "expectToBeLevel5xx",
+      (expectVal: any) => {
+        return createExpect(expectVal).toBeLevel5xx()
+      }
+    ),
+    expectToBeType: defineSandboxFn(
+      ctx,
+      "expectToBeType",
+      (expectVal: any, expectedType: any, isDate: any) => {
+        const resolved =
+          isDate && typeof expectVal === "string"
+            ? new Date(expectVal)
+            : expectVal
+        return createExpectation(resolved, false, testRunStack).toBeType(
+          expectedType
+        )
+      }
+    ),
+    expectToHaveLength: defineSandboxFn(
+      ctx,
+      "expectToHaveLength",
+      (expectVal: any, expectedLength: any) => {
+        return createExpect(expectVal).toHaveLength(expectedLength)
+      }
+    ),
+    expectToInclude: defineSandboxFn(
+      ctx,
+      "expectToInclude",
+      (expectVal: any, needle: any) => {
+        return createExpect(expectVal).toInclude(needle)
+      }
+    ),
+
+    // Negative expectations
+    expectNotToBe: defineSandboxFn(
+      ctx,
+      "expectNotToBe",
+      (expectVal: any, expectedVal: any) => {
+        return createExpect(expectVal).not.toBe(expectedVal)
+      }
+    ),
+    expectNotToBeLevel2xx: defineSandboxFn(
+      ctx,
+      "expectNotToBeLevel2xx",
+      (expectVal: any) => {
+        return createExpect(expectVal).not.toBeLevel2xx()
+      }
+    ),
+    expectNotToBeLevel3xx: defineSandboxFn(
+      ctx,
+      "expectNotToBeLevel3xx",
+      (expectVal: any) => {
+        return createExpect(expectVal).not.toBeLevel3xx()
+      }
+    ),
+    expectNotToBeLevel4xx: defineSandboxFn(
+      ctx,
+      "expectNotToBeLevel4xx",
+      (expectVal: any) => {
+        return createExpect(expectVal).not.toBeLevel4xx()
+      }
+    ),
+    expectNotToBeLevel5xx: defineSandboxFn(
+      ctx,
+      "expectNotToBeLevel5xx",
+      (expectVal: any) => {
+        return createExpect(expectVal).not.toBeLevel5xx()
+      }
+    ),
+    expectNotToBeType: defineSandboxFn(
+      ctx,
+      "expectNotToBeType",
+      (expectVal: any, expectedType: any, isDate: any) => {
+        const resolved =
+          isDate && typeof expectVal === "string"
+            ? new Date(expectVal)
+            : expectVal
+        return createExpectation(resolved, false, testRunStack).not.toBeType(
+          expectedType
+        )
+      }
+    ),
+    expectNotToHaveLength: defineSandboxFn(
+      ctx,
+      "expectNotToHaveLength",
+      (expectVal: any, expectedLength: any) => {
+        return createExpect(expectVal).not.toHaveLength(expectedLength)
+      }
+    ),
+    expectNotToInclude: defineSandboxFn(
+      ctx,
+      "expectNotToInclude",
+      (expectVal: any, needle: any) => {
+        return createExpect(expectVal).not.toInclude(needle)
+      }
+    ),
+  }
+}
diff --git a/packages/hoppscotch-js-sandbox/src/cage-modules/utils/request-setters.ts b/packages/hoppscotch-js-sandbox/src/cage-modules/utils/request-setters.ts
new file mode 100644
index 00000000..05273f5b
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/cage-modules/utils/request-setters.ts
@@ -0,0 +1,97 @@
+import {
+  HoppRESTAuth,
+  HoppRESTHeaders,
+  HoppRESTParams,
+  HoppRESTReqBody,
+  HoppRESTRequest,
+} from "@hoppscotch/data"
+import { CageModuleCtx, defineSandboxFn } from "faraday-cage/modules"
+
+import { getRequestSetterMethods } from "~/utils/pre-request"
+import { RequestSetterMethodsResult } from "~/types"
+
+/**
+ * Creates request setter methods for pre-request scripts
+ * These methods allow modification of request properties before execution
+ */
+export const createRequestSetterMethods = (
+  ctx: CageModuleCtx,
+  request: HoppRESTRequest
+): RequestSetterMethodsResult => {
+  const { methods: requestMethods, updatedRequest } =
+    getRequestSetterMethods(request)
+
+  const setterMethods = {
+    // Request setter methods
+    setRequestUrl: defineSandboxFn(ctx, "setRequestUrl", (url: any) => {
+      requestMethods.setUrl(url as string)
+    }),
+    setRequestMethod: defineSandboxFn(
+      ctx,
+      "setRequestMethod",
+      (method: any) => {
+        requestMethods.setMethod(method as string)
+      }
+    ),
+    setRequestHeader: defineSandboxFn(
+      ctx,
+      "setRequestHeader",
+      (name: any, value: any) => {
+        requestMethods.setHeader(name as string, value as string)
+      }
+    ),
+    setRequestHeaders: defineSandboxFn(
+      ctx,
+      "setRequestHeaders",
+      (headers: any) => {
+        requestMethods.setHeaders(headers as HoppRESTHeaders)
+      }
+    ),
+    removeRequestHeader: defineSandboxFn(
+      ctx,
+      "removeRequestHeader",
+      (key: any) => {
+        requestMethods.removeHeader(key as string)
+      }
+    ),
+    setRequestParam: defineSandboxFn(
+      ctx,
+      "setRequestParam",
+      (name: any, value: any) => {
+        requestMethods.setParam(name as string, value as string)
+      }
+    ),
+    setRequestParams: defineSandboxFn(
+      ctx,
+      "setRequestParams",
+      (params: any) => {
+        requestMethods.setParams(params as HoppRESTParams)
+      }
+    ),
+    removeRequestParam: defineSandboxFn(
+      ctx,
+      "removeRequestParam",
+      (key: any) => {
+        requestMethods.removeParam(key as string)
+      }
+    ),
+    setRequestBody: defineSandboxFn(ctx, "setRequestBody", (body: any) => {
+      requestMethods.setBody(body as HoppRESTReqBody)
+    }),
+    setRequestAuth: defineSandboxFn(ctx, "setRequestAuth", (auth: any) => {
+      requestMethods.setAuth(auth as HoppRESTAuth)
+    }),
+    setRequestVariable: defineSandboxFn(
+      ctx,
+      "setRequestVariable",
+      (key: any, value: any) => {
+        requestMethods.setRequestVariable(key as string, value as string)
+      }
+    ),
+  }
+
+  return {
+    methods: setterMethods,
+    getUpdatedRequest: () => updatedRequest,
+  }
+}
diff --git a/packages/hoppscotch-js-sandbox/src/node/pre-request/experimental.ts b/packages/hoppscotch-js-sandbox/src/node/pre-request/experimental.ts
index 51b0b22a..69af6552 100644
--- a/packages/hoppscotch-js-sandbox/src/node/pre-request/experimental.ts
+++ b/packages/hoppscotch-js-sandbox/src/node/pre-request/experimental.ts
@@ -1,29 +1,38 @@
+import { Cookie, HoppRESTRequest } from "@hoppscotch/data"
 import { FaradayCage } from "faraday-cage"
 import { pipe } from "fp-ts/function"
 import * as TE from "fp-ts/lib/TaskEither"
 import { cloneDeep } from "lodash"
 
-import { defaultModules, pwPreRequestModule } from "~/cage-modules"
-import { TestResult } from "~/types"
+import { defaultModules, preRequestModule } from "~/cage-modules"
+import { SandboxPreRequestResult, TestResult } from "~/types"
 
 export const runPreRequestScriptWithFaradayCage = (
   preRequestScript: string,
-  envs: TestResult["envs"]
-): TE.TaskEither<string, TestResult["envs"]> => {
+  envs: TestResult["envs"],
+  request: HoppRESTRequest,
+  cookies: Cookie[] | null
+): TE.TaskEither<string, SandboxPreRequestResult> => {
   return pipe(
     TE.tryCatch(
-      async (): Promise<TestResult["envs"]> => {
+      async (): Promise<SandboxPreRequestResult> => {
         let finalEnvs = envs
+        let finalRequest = request
+        let finalCookies = cookies
 
         const cage = await FaradayCage.create()
 
         const result = await cage.runCode(preRequestScript, [
           ...defaultModules(),
 
-          pwPreRequestModule({
+          preRequestModule({
             envs: cloneDeep(envs),
-            handleSandboxResults: ({ envs }) => {
+            request: cloneDeep(request),
+            cookies: cookies ? cloneDeep(cookies) : null,
+            handleSandboxResults: ({ envs, request, cookies }) => {
               finalEnvs = envs
+              finalRequest = request
+              finalCookies = cookies
             },
           }),
         ])
@@ -32,7 +41,11 @@ export const runPreRequestScriptWithFaradayCage = (
           throw result.err
         }
 
-        return finalEnvs
+        return {
+          updatedEnvs: finalEnvs,
+          updatedRequest: finalRequest,
+          updatedCookies: finalCookies,
+        }
       },
       (error) => {
         if (error !== null && typeof error === "object" && "message" in error) {
diff --git a/packages/hoppscotch-js-sandbox/src/node/pre-request/index.ts b/packages/hoppscotch-js-sandbox/src/node/pre-request/index.ts
index 4d087785..6449485e 100644
--- a/packages/hoppscotch-js-sandbox/src/node/pre-request/index.ts
+++ b/packages/hoppscotch-js-sandbox/src/node/pre-request/index.ts
@@ -1,14 +1,28 @@
 import * as TE from "fp-ts/lib/TaskEither"
-import { TestResult } from "~/types"
+import { RunPreRequestScriptOptions, SandboxPreRequestResult } from "~/types"
 
 import { runPreRequestScriptWithFaradayCage } from "./experimental"
 import { runPreRequestScriptWithIsolatedVm } from "./legacy"
 
 export const runPreRequestScript = (
   preRequestScript: string,
-  envs: TestResult["envs"],
-  experimentalScriptingSandbox = true
-): TE.TaskEither<string, TestResult["envs"]> =>
-  experimentalScriptingSandbox
-    ? runPreRequestScriptWithFaradayCage(preRequestScript, envs)
-    : runPreRequestScriptWithIsolatedVm(preRequestScript, envs)
+  options: RunPreRequestScriptOptions
+): TE.TaskEither<string, SandboxPreRequestResult> => {
+  const { envs, experimentalScriptingSandbox = true } = options
+
+  if (experimentalScriptingSandbox) {
+    const { request, cookies } = options as Extract<
+      RunPreRequestScriptOptions,
+      { experimentalScriptingSandbox: true }
+    >
+
+    return runPreRequestScriptWithFaradayCage(
+      preRequestScript,
+      envs,
+      request,
+      cookies
+    )
+  }
+
+  return runPreRequestScriptWithIsolatedVm(preRequestScript, envs)
+}
diff --git a/packages/hoppscotch-js-sandbox/src/node/pre-request/legacy.ts b/packages/hoppscotch-js-sandbox/src/node/pre-request/legacy.ts
index 13e5ed77..75e13c8c 100644
--- a/packages/hoppscotch-js-sandbox/src/node/pre-request/legacy.ts
+++ b/packages/hoppscotch-js-sandbox/src/node/pre-request/legacy.ts
@@ -3,8 +3,8 @@ import * as TE from "fp-ts/lib/TaskEither"
 import type ivmT from "isolated-vm"
 import { createRequire } from "module"
 
-import { getPreRequestScriptMethods } from "~/shared-utils"
-import { TestResult } from "~/types"
+import { getPreRequestScriptMethods } from "~/utils/shared"
+import { SandboxPreRequestResult, TestResult } from "~/types"
 import { getSerializedAPIMethods } from "../utils"
 
 const nodeRequire = createRequire(import.meta.url)
@@ -13,7 +13,7 @@ const ivm = nodeRequire("isolated-vm")
 export const runPreRequestScriptWithIsolatedVm = (
   preRequestScript: string,
   envs: TestResult["envs"]
-): TE.TaskEither<string, TestResult["envs"]> => {
+): TE.TaskEither<string, SandboxPreRequestResult> => {
   return pipe(
     TE.tryCatch(
       async () => {
@@ -59,7 +59,7 @@ export const runPreRequestScriptWithIsolatedVm = (
             const script = await isolate.compileScript(finalScript)
             // Run the pre-request script in the provided context
             await script.run(context)
-            return updatedEnvs
+            return { updatedEnvs, updatedCookies: null }
           },
           (reason) => reason
         ),
diff --git a/packages/hoppscotch-js-sandbox/src/node/test-runner/experimental.ts b/packages/hoppscotch-js-sandbox/src/node/test-runner/experimental.ts
index 0df5dd87..236c6001 100644
--- a/packages/hoppscotch-js-sandbox/src/node/test-runner/experimental.ts
+++ b/packages/hoppscotch-js-sandbox/src/node/test-runner/experimental.ts
@@ -1,14 +1,16 @@
+import { HoppRESTRequest } from "@hoppscotch/data"
 import { FaradayCage } from "faraday-cage"
 import * as TE from "fp-ts/TaskEither"
 import { pipe } from "fp-ts/function"
 import { cloneDeep } from "lodash"
 
-import { defaultModules, pwPostRequestModule } from "~/cage-modules"
+import { defaultModules, postRequestModule } from "~/cage-modules"
 import { TestDescriptor, TestResponse, TestResult } from "~/types"
 
-export const runTestScriptWithFaradayCage = (
+export const runPostRequestScriptWithFaradayCage = (
   testScript: string,
   envs: TestResult["envs"],
+  request: HoppRESTRequest,
   response: TestResponse
 ): TE.TaskEither<string, TestResult> => {
   return pipe(
@@ -26,10 +28,13 @@ export const runTestScriptWithFaradayCage = (
         const result = await cage.runCode(testScript, [
           ...defaultModules(),
 
-          pwPostRequestModule({
+          postRequestModule({
             envs: cloneDeep(envs),
             testRunStack: cloneDeep(testRunStack),
-            response,
+            request: cloneDeep(request),
+            response: cloneDeep(response),
+            // TODO: Post type update, accommodate for cookies although platform support is limited
+            cookies: null,
             handleSandboxResults: ({ envs, testRunStack }) => {
               finalEnvs = envs
               finalTestResults = testRunStack
diff --git a/packages/hoppscotch-js-sandbox/src/node/test-runner/index.ts b/packages/hoppscotch-js-sandbox/src/node/test-runner/index.ts
index 1f948982..6668e627 100644
--- a/packages/hoppscotch-js-sandbox/src/node/test-runner/index.ts
+++ b/packages/hoppscotch-js-sandbox/src/node/test-runner/index.ts
@@ -1,24 +1,39 @@
 import * as E from "fp-ts/Either"
 import * as TE from "fp-ts/TaskEither"
 
-import { preventCyclicObjects } from "~/shared-utils"
-import { TestResponse, TestResult } from "~/types"
-import { runTestScriptWithFaradayCage } from "./experimental"
-import { runTestScriptWithIsolatedVm } from "./legacy"
+import { RunPostRequestScriptOptions, TestResponse, TestResult } from "~/types"
+import { preventCyclicObjects } from "~/utils/shared"
+import { runPostRequestScriptWithFaradayCage } from "./experimental"
+import { runPostRequestScriptWithIsolatedVm } from "./legacy"
 
+// Future TODO: Update return type to be based on `SandboxTestResult` (unified with the web implementation)
+// No involvement of cookies in the CLI context currently
 export const runTestScript = (
   testScript: string,
-  envs: TestResult["envs"],
-  response: TestResponse,
-  experimentalScriptingSandbox = true
+  options: RunPostRequestScriptOptions
 ): TE.TaskEither<string, TestResult> => {
-  const responseObjHandle = preventCyclicObjects<TestResponse>(response)
+  const responseObjHandle = preventCyclicObjects<TestResponse>(options.response)
 
   if (E.isLeft(responseObjHandle)) {
     return TE.left(`Response marshalling failed: ${responseObjHandle.left}`)
   }
 
-  return experimentalScriptingSandbox
-    ? runTestScriptWithFaradayCage(testScript, envs, responseObjHandle.right)
-    : runTestScriptWithIsolatedVm(testScript, envs, responseObjHandle.right)
+  const resolvedResponse = responseObjHandle.right
+  const { envs, experimentalScriptingSandbox = true } = options
+
+  if (experimentalScriptingSandbox) {
+    const { request } = options as Extract<
+      RunPostRequestScriptOptions,
+      { experimentalScriptingSandbox: true }
+    >
+
+    return runPostRequestScriptWithFaradayCage(
+      testScript,
+      envs,
+      request,
+      resolvedResponse
+    )
+  }
+
+  return runPostRequestScriptWithIsolatedVm(testScript, envs, resolvedResponse)
 }
diff --git a/packages/hoppscotch-js-sandbox/src/node/test-runner/legacy.ts b/packages/hoppscotch-js-sandbox/src/node/test-runner/legacy.ts
index 279e85a2..73494a73 100644
--- a/packages/hoppscotch-js-sandbox/src/node/test-runner/legacy.ts
+++ b/packages/hoppscotch-js-sandbox/src/node/test-runner/legacy.ts
@@ -4,11 +4,11 @@ import { pipe } from "fp-ts/function"
 import type ivmT from "isolated-vm"
 import { createRequire } from "module"
 
+import { TestResponse, TestResult } from "~/types"
 import {
   getTestRunnerScriptMethods,
   preventCyclicObjects,
-} from "~/shared-utils"
-import { TestResponse, TestResult } from "~/types"
+} from "~/utils/shared"
 import { getSerializedAPIMethods } from "../utils"
 
 const nodeRequire = createRequire(import.meta.url)
@@ -176,7 +176,7 @@ const executeScriptInContext = (
   })
 }
 
-export const runTestScriptWithIsolatedVm = (
+export const runPostRequestScriptWithIsolatedVm = (
   testScript: string,
   envs: TestResult["envs"],
   response: TestResponse
diff --git a/packages/hoppscotch-js-sandbox/src/types/index.ts b/packages/hoppscotch-js-sandbox/src/types/index.ts
index c23d685e..4268538e 100644
--- a/packages/hoppscotch-js-sandbox/src/types/index.ts
+++ b/packages/hoppscotch-js-sandbox/src/types/index.ts
@@ -1,4 +1,10 @@
-import { ConsoleEntry } from "faraday-cage/modules"
+import { Cookie, HoppRESTRequest } from "@hoppscotch/data"
+import { ConsoleEntry, defineSandboxFn } from "faraday-cage/modules"
+
+import type { EnvAPIOptions } from "~/utils/shared"
+
+// Infer the return type of defineSandboxFn from faraday-cage
+type SandboxFunction = ReturnType<typeof defineSandboxFn>
 
 /**
  * The response object structure exposed to the test script
@@ -6,8 +12,16 @@ import { ConsoleEntry } from "faraday-cage/modules"
 export type TestResponse = {
   /** Status Code of the response */
   status: number
+
+  /** Status text of the response (e.g., "OK", "Not Found", "Internal Server Error") */
+  statusText: string
+
+  /** Time taken for the request to complete in milliseconds */
+  responseTime: number
+
   /** List of headers returned */
   headers: { key: string; value: string }[]
+
   /**
    * Body of the response, this will be the JSON object if it is a JSON content type, else body string
    */
@@ -68,11 +82,14 @@ export type SelectedEnvItem = TestResult["envs"]["selected"][number]
 
 export type SandboxTestResult = TestResult & { tests: TestDescriptor } & {
   consoleEntries?: ConsoleEntry[]
+  updatedCookies: Cookie[] | null
 }
 
 export type SandboxPreRequestResult = {
-  envs: TestResult["envs"]
+  updatedEnvs: TestResult["envs"]
   consoleEntries?: ConsoleEntry[]
+  updatedRequest?: HoppRESTRequest
+  updatedCookies: Cookie[] | null
 }
 
 export interface Expectation {
@@ -86,3 +103,156 @@ export interface Expectation {
   toInclude(needle: any): void
   readonly not: Expectation
 }
+
+export type RunPreRequestScriptOptions =
+  | {
+      envs: TestResult["envs"]
+      request: HoppRESTRequest
+      cookies: Cookie[] | null // Exclusive to the Desktop App
+      experimentalScriptingSandbox: true
+    }
+  | {
+      envs: TestResult["envs"]
+      experimentalScriptingSandbox?: false
+    }
+
+export type RunPostRequestScriptOptions =
+  | {
+      envs: TestResult["envs"]
+      request: HoppRESTRequest
+      response: TestResponse
+      cookies: Cookie[] | null // Exclusive to the Desktop App
+      experimentalScriptingSandbox: true
+    }
+  | {
+      envs: TestResult["envs"]
+      response: TestResponse
+      experimentalScriptingSandbox?: false
+    }
+
+/**
+ * Request properties structure exposed to sandbox
+ */
+export type RequestProps = {
+  readonly url: string
+  readonly method: string
+  readonly params: HoppRESTRequest["params"]
+  readonly headers: HoppRESTRequest["headers"]
+  readonly body: HoppRESTRequest["body"]
+  readonly auth: HoppRESTRequest["auth"]
+  readonly requestVariables: HoppRESTRequest["requestVariables"]
+}
+
+/**
+ * Environment methods structure returned by getSharedEnvMethods
+ */
+export type EnvMethods = {
+  pw: {
+    get: (key: string, options?: EnvAPIOptions) => string | null | undefined
+    getResolve: (
+      key: string,
+      options?: EnvAPIOptions
+    ) => string | null | undefined
+    set: (key: string, value: string, options?: EnvAPIOptions) => void
+    unset: (key: string, options?: EnvAPIOptions) => void
+    resolve: (key: string) => string
+  }
+  hopp: {
+    set: (key: string, value: string, options?: EnvAPIOptions) => void
+    delete: (key: string, options?: EnvAPIOptions) => void
+    reset: (key: string, options?: EnvAPIOptions) => void
+    getInitialRaw: (key: string, options?: EnvAPIOptions) => string | null
+    setInitial: (key: string, value: string, options?: EnvAPIOptions) => void
+  }
+}
+
+/**
+ * Return type for createHoppNamespaceMethods function
+ */
+export interface HoppNamespaceMethods {
+  envDelete: SandboxFunction
+  envReset: SandboxFunction
+  envGetInitialRaw: SandboxFunction
+  envSetInitial: SandboxFunction
+  getRequestProps: SandboxFunction
+}
+
+/**
+ * Return type for createPwNamespaceMethods function
+ */
+export interface PwNamespaceMethods {
+  envGet: SandboxFunction
+  envGetResolve: SandboxFunction
+  envSet: SandboxFunction
+  envUnset: SandboxFunction
+  envResolve: SandboxFunction
+  getRequestVariable: SandboxFunction
+}
+
+/**
+ * Return type for createPmNamespaceMethods function
+ */
+export interface PmNamespaceMethods {
+  pmInfoRequestName: SandboxFunction
+  pmInfoRequestId: SandboxFunction
+}
+
+/**
+ * Return type for createExpectationMethods function
+ */
+export interface ExpectationMethods {
+  expectToBe: SandboxFunction
+  expectToBeLevel2xx: SandboxFunction
+  expectToBeLevel3xx: SandboxFunction
+  expectToBeLevel4xx: SandboxFunction
+  expectToBeLevel5xx: SandboxFunction
+  expectToBeType: SandboxFunction
+  expectToHaveLength: SandboxFunction
+  expectToInclude: SandboxFunction
+  expectNotToBe: SandboxFunction
+  expectNotToBeLevel2xx: SandboxFunction
+  expectNotToBeLevel3xx: SandboxFunction
+  expectNotToBeLevel4xx: SandboxFunction
+  expectNotToBeLevel5xx: SandboxFunction
+  expectNotToBeType: SandboxFunction
+  expectNotToHaveLength: SandboxFunction
+  expectNotToInclude: SandboxFunction
+}
+
+/**
+ * Return type for createRequestSetterMethods function
+ */
+export interface RequestSetterMethodsResult {
+  methods: {
+    setRequestUrl: SandboxFunction
+    setRequestMethod: SandboxFunction
+    setRequestHeader: SandboxFunction
+    setRequestHeaders: SandboxFunction
+    setRequestParam: SandboxFunction
+    setRequestParams: SandboxFunction
+    removeRequestHeader: SandboxFunction
+    removeRequestParam: SandboxFunction
+    setRequestBody: SandboxFunction
+    setRequestAuth: SandboxFunction
+    setRequestVariable: SandboxFunction
+  }
+  getUpdatedRequest: () => HoppRESTRequest
+}
+
+/**
+ * Return type for createBaseInputs function
+ */
+export interface BaseInputs
+  extends PwNamespaceMethods,
+    HoppNamespaceMethods,
+    PmNamespaceMethods {
+  cookieGet: SandboxFunction
+  cookieSet: SandboxFunction
+  cookieHas: SandboxFunction
+  cookieGetAll: SandboxFunction
+  cookieDelete: SandboxFunction
+  cookieClear: SandboxFunction
+  getUpdatedEnvs: () => any
+  getUpdatedCookies: () => Cookie[] | null
+  [key: string]: any
+}
diff --git a/packages/hoppscotch-js-sandbox/src/utils/pre-request.ts b/packages/hoppscotch-js-sandbox/src/utils/pre-request.ts
new file mode 100644
index 00000000..ba4383ea
--- /dev/null
+++ b/packages/hoppscotch-js-sandbox/src/utils/pre-request.ts
@@ -0,0 +1,157 @@
+import {
+  HoppRESTAuth,
+  HoppRESTHeaders,
+  HoppRESTParams,
+  HoppRESTReqBody,
+  HoppRESTRequest,
+} from "@hoppscotch/data"
+import { cloneDeep } from "lodash"
+
+export const getRequestSetterMethods = (request: HoppRESTRequest) => {
+  // Clone to allow safe mutations internally
+  const updatedRequest = <HoppRESTRequest>cloneDeep(request)
+
+  // Mutation methods
+  const setUrl = (url: string) => {
+    updatedRequest.endpoint = url
+  }
+
+  const setMethod = (method: string) => {
+    updatedRequest.method = method.toUpperCase()
+  }
+  const setHeader = (name: string, value: string) => {
+    const headers = [...updatedRequest.headers]
+    const headerIndex = headers.findIndex(
+      (h) => h.key.toLowerCase() === name.toLowerCase()
+    )
+
+    if (headerIndex >= 0) {
+      headers[headerIndex].value = value
+    } else {
+      headers.push({ key: name, value, active: true, description: "" })
+    }
+
+    updatedRequest.headers = headers
+  }
+
+  const setHeaders = (headers: HoppRESTHeaders) => {
+    const parseResult = HoppRESTHeaders.safeParse(headers)
+
+    if (!parseResult.success) {
+      throw new Error("Invalid headers object")
+    }
+
+    updatedRequest.headers = parseResult.data
+  }
+
+  const removeHeader = (key: string) => {
+    updatedRequest.headers = updatedRequest.headers.filter((h) => h.key !== key)
+  }
+
+  const setParam = (name: string, value: string) => {
+    const params = [...updatedRequest.params]
+    const paramIndex = params.findIndex(
+      (p) => p.key.toLowerCase() === name.toLowerCase()
+    )
+
+    if (paramIndex >= 0) {
+      params[paramIndex].value = value
+    } else {
+      params.push({ key: name, value, active: true, description: "" })
+    }
+
+    updatedRequest.params = params
+  }
+
+  const setParams = (params: HoppRESTParams) => {
+    const parseResult = HoppRESTParams.safeParse(params)
+
+    if (!parseResult.success) {
+      throw new Error("Invalid params object")
+    }
+
+    updatedRequest.params = parseResult.data
+  }
+
+  const removeParam = (key: string) => {
+    updatedRequest.params = updatedRequest.params.filter((h) => h.key !== key)
+  }
+
+  const setBody = (newBody: Partial<HoppRESTReqBody>) => {
+    // Runtime validations given the input is user controlled
+    if (
+      typeof newBody !== "object" ||
+      newBody === null ||
+      Array.isArray(newBody) ||
+      Object.keys(newBody).length === 0
+    ) {
+      throw new Error(
+        "Invalid body object. Expected a non-empty object with valid body properties."
+      )
+    }
+
+    const mergedBody = { ...updatedRequest.body, ...newBody }
+
+    const parseResult = HoppRESTReqBody.safeParse(mergedBody)
+
+    if (!parseResult.success) {
+      throw new Error(
+        "Invalid body object. Expected a non-empty object with valid body properties."
+      )
+    }
+
+    updatedRequest.body = { ...parseResult.data }
+  }
+
+  const setAuth = (newAuth: HoppRESTAuth) => {
+    // Runtime validations given the input is user controlled
+    if (
+      typeof newAuth !== "object" ||
+      newAuth === null ||
+      Array.isArray(newAuth) ||
+      Object.keys(newAuth).length === 0
+    ) {
+      throw new Error("Invalid auth object")
+    }
+
+    const mergedAuth = { ...updatedRequest.auth, ...newAuth }
+
+    const parseResult = HoppRESTAuth.safeParse(mergedAuth)
+
+    if (!parseResult.success) {
+      throw new Error("Invalid auth object")
+    }
+
+    updatedRequest.auth = { ...parseResult.data }
+  }
+
+  const setRequestVariable = (key: string, value: string) => {
+    const reqVarIndex = updatedRequest.requestVariables.findIndex(
+      (reqVar) => reqVar.key === key
+    )
+
+    if (reqVarIndex >= 0) {
+      updatedRequest.requestVariables[reqVarIndex].value = value
+    } else {
+      updatedRequest.requestVariables.push({ key, value, active: true })
+    }
+  }
+
+  // Returns setter methods under the `request` namespace
+  return {
+    methods: {
+      setUrl,
+      setMethod,
+      setHeader,
+      setHeaders,
+      removeHeader,
+      setParam,
+      setParams,
+      removeParam,
+      setBody,
+      setAuth,
+      setRequestVariable,
+    },
+    updatedRequest,
+  }
+}
diff --git a/packages/hoppscotch-js-sandbox/src/shared-utils.ts b/packages/hoppscotch-js-sandbox/src/utils/shared.ts
similarity index 50%
rename from packages/hoppscotch-js-sandbox/src/shared-utils.ts
rename to packages/hoppscotch-js-sandbox/src/utils/shared.ts
index 802b6bfb..ac738d37 100644
--- a/packages/hoppscotch-js-sandbox/src/shared-utils.ts
+++ b/packages/hoppscotch-js-sandbox/src/utils/shared.ts
@@ -1,4 +1,9 @@
-import { parseTemplateStringE } from "@hoppscotch/data"
+import {
+  Cookie,
+  CookieSchema,
+  HoppRESTRequest,
+  parseTemplateStringE,
+} from "@hoppscotch/data"
 import * as E from "fp-ts/Either"
 import * as O from "fp-ts/Option"
 import { pipe } from "fp-ts/lib/function"
@@ -10,9 +15,31 @@ import {
   SelectedEnvItem,
   TestDescriptor,
   TestResult,
-} from "./types"
+} from "../types"
+
+export type EnvSource = "active" | "global" | "all"
+export type EnvAPIOptions = {
+  fallbackToNull?: boolean
+  source: EnvSource
+}
+
+const getEnv = (
+  envName: string,
+  envs: TestResult["envs"],
+  options = { source: "all" }
+) => {
+  if (options.source === "active") {
+    return O.fromNullable(
+      envs.selected.find((x: SelectedEnvItem) => x.key === envName)
+    )
+  }
+
+  if (options.source === "global") {
+    return O.fromNullable(
+      envs.global.find((x: GlobalEnvItem) => x.key === envName)
+    )
+  }
 
-const getEnv = (envName: string, envs: TestResult["envs"]) => {
   return O.fromNullable(
     envs.selected.find((x: SelectedEnvItem) => x.key === envName) ??
       envs.global.find((x: GlobalEnvItem) => x.key === envName)
@@ -31,29 +58,45 @@ const findEnvIndex = (
 const setEnv = (
   envName: string,
   envValue: string,
-  envs: TestResult["envs"]
+  envs: TestResult["envs"],
+  options: { setInitialValue?: boolean; source: EnvSource } = {
+    setInitialValue: false,
+    source: "all",
+  }
 ): TestResult["envs"] => {
   const { global, selected } = envs
 
   const indexInSelected = findEnvIndex(envName, selected)
   const indexInGlobal = findEnvIndex(envName, global)
 
-  if (indexInSelected >= 0) {
+  if (["all", "active"].includes(options.source) && indexInSelected >= 0) {
     const selectedEnv = selected[indexInSelected]
-    if ("currentValue" in selectedEnv) {
-      selectedEnv.currentValue = envValue
-    }
-  } else if (indexInGlobal >= 0) {
-    if ("currentValue" in global[indexInGlobal])
-      (global[indexInGlobal] as { currentValue: string }).currentValue =
-        envValue
-  } else {
+    const targetProperty = options.setInitialValue
+      ? "initialValue"
+      : "currentValue"
+
+    selectedEnv[targetProperty] = envValue
+  } else if (["all", "global"].includes(options.source) && indexInGlobal >= 0) {
+    const globalEnv = global[indexInGlobal]
+    const targetProperty = options.setInitialValue
+      ? "initialValue"
+      : "currentValue"
+
+    globalEnv[targetProperty] = envValue
+  } else if (["all", "active"].includes(options.source)) {
     selected.push({
       key: envName,
       currentValue: envValue,
       initialValue: envValue,
       secret: false,
     })
+  } else if (["all", "global"].includes(options.source)) {
+    global.push({
+      key: envName,
+      currentValue: envValue,
+      initialValue: envValue,
+      secret: false,
+    })
   }
 
   return {
@@ -64,16 +107,17 @@ const setEnv = (
 
 const unsetEnv = (
   envName: string,
-  envs: TestResult["envs"]
+  envs: TestResult["envs"],
+  options = { source: "all" }
 ): TestResult["envs"] => {
   const { global, selected } = envs
 
   const indexInSelected = findEnvIndex(envName, selected)
   const indexInGlobal = findEnvIndex(envName, global)
 
-  if (indexInSelected >= 0) {
+  if (["all", "active"].includes(options.source) && indexInSelected >= 0) {
     selected.splice(indexInSelected, 1)
-  } else if (indexInGlobal >= 0) {
+  } else if (["all", "global"].includes(options.source) && indexInGlobal >= 0) {
     global.splice(indexInGlobal, 1)
   }
 
@@ -83,19 +127,74 @@ const unsetEnv = (
   }
 }
 
-// Compiles shared scripting API methods for use in both pre and post request scripts
-export const getSharedMethods = (envs: TestResult["envs"]) => {
+/**
+ * Compiles shared scripting API methods (scoped to environments) for use in both pre and post request scripts
+ * Experimental sandbox version - Returns methods organized by namespace (`pw` and `hopp`)
+ */
+export function getSharedEnvMethods(
+  envs: TestResult["envs"],
+  isHoppNamespace: true
+): {
+  methods: {
+    pw: {
+      get: (key: string, options?: EnvAPIOptions) => string | null | undefined
+      getResolve: (
+        key: string,
+        options?: EnvAPIOptions
+      ) => string | null | undefined
+      set: (key: string, value: string, options?: EnvAPIOptions) => void
+      unset: (key: string, options?: EnvAPIOptions) => void
+      resolve: (key: string) => string
+    }
+    hopp: {
+      set: (key: string, value: string, options?: EnvAPIOptions) => void
+      delete: (key: string, options?: EnvAPIOptions) => void
+      reset: (key: string, options?: EnvAPIOptions) => void
+      getInitialRaw: (key: string, options?: EnvAPIOptions) => string | null
+      setInitial: (key: string, value: string, options?: EnvAPIOptions) => void
+    }
+  }
+  updatedEnvs: TestResult["envs"]
+}
+
+/**
+ * Legacy sandbox version - Returns flat methods for `pw` namespace only
+ */
+export function getSharedEnvMethods(
+  envs: TestResult["envs"],
+  isHoppNamespace?: false
+): {
+  methods: {
+    get: (key: string, options?: EnvAPIOptions) => string | null | undefined
+    getResolve: (
+      key: string,
+      options?: EnvAPIOptions
+    ) => string | null | undefined
+    set: (key: string, value: string, options?: EnvAPIOptions) => void
+    unset: (key: string, options?: EnvAPIOptions) => void
+    resolve: (key: string) => string
+  }
+  updatedEnvs: TestResult["envs"]
+}
+
+export function getSharedEnvMethods(
+  envs: TestResult["envs"],
+  isHoppNamespace = false
+): unknown {
   let updatedEnvs = envs
 
-  const envGetFn = (key: any) => {
+  const envGetFn = (
+    key: any,
+    options: EnvAPIOptions = { fallbackToNull: false, source: "all" }
+  ) => {
     if (typeof key !== "string") {
       throw new Error("Expected key to be a string")
     }
 
     const result = pipe(
-      getEnv(key, updatedEnvs),
+      getEnv(key, updatedEnvs, options),
       O.fold(
-        () => undefined,
+        () => (options.fallbackToNull ? null : undefined),
         (env) => String(env.currentValue)
       )
     )
@@ -103,33 +202,45 @@ export const getSharedMethods = (envs: TestResult["envs"]) => {
     return result
   }
 
-  const envGetResolveFn = (key: any) => {
+  const envGetResolveFn = (
+    key: any,
+    options: EnvAPIOptions = { fallbackToNull: false, source: "all" }
+  ) => {
     if (typeof key !== "string") {
       throw new Error("Expected key to be a string")
     }
 
+    const shouldIncludeSelected = ["all", "active"].includes(options.source)
+    const shouldIncludeGlobal = ["all", "global"].includes(options.source)
+
+    const envVars = [
+      ...(shouldIncludeSelected ? updatedEnvs.selected : []),
+      ...(shouldIncludeGlobal ? updatedEnvs.global : []),
+    ]
+
     const result = pipe(
-      getEnv(key, updatedEnvs),
+      getEnv(key, updatedEnvs, options),
       E.fromOption(() => "INVALID_KEY" as const),
 
       E.map((e) =>
         pipe(
-          parseTemplateStringE(e.currentValue, [
-            ...updatedEnvs.selected,
-            ...updatedEnvs.global,
-          ]), // If the recursive resolution failed, return the unresolved value
+          parseTemplateStringE(e.currentValue, envVars), // If the recursive resolution failed, return the unresolved value
           E.getOrElse(() => e.currentValue)
         )
       ),
       E.map((x) => String(x)),
 
-      E.getOrElseW(() => undefined)
+      E.getOrElseW(() => (options.fallbackToNull ? null : undefined))
     )
 
     return result
   }
 
-  const envSetFn = (key: any, value: any) => {
+  const envSetFn = (
+    key: any,
+    value: any,
+    options: EnvAPIOptions = { source: "all" }
+  ) => {
     if (typeof key !== "string") {
       throw new Error("Expected key to be a string")
     }
@@ -138,17 +249,17 @@ export const getSharedMethods = (envs: TestResult["envs"]) => {
       throw new Error("Expected value to be a string")
     }
 
-    updatedEnvs = setEnv(key, value, updatedEnvs)
+    updatedEnvs = setEnv(key, value, updatedEnvs, options)
 
     return undefined
   }
 
-  const envUnsetFn = (key: any) => {
+  const envUnsetFn = (key: any, options: EnvAPIOptions = { source: "all" }) => {
     if (typeof key !== "string") {
       throw new Error("Expected key to be a string")
     }
 
-    updatedEnvs = unsetEnv(key, updatedEnvs)
+    updatedEnvs = unsetEnv(key, updatedEnvs, options)
 
     return undefined
   }
@@ -169,20 +280,213 @@ export const getSharedMethods = (envs: TestResult["envs"]) => {
     return String(result)
   }
 
+  // Methods exclusive to the `hopp` namespace
+  const envResetFn = (
+    key: string,
+    options: EnvAPIOptions = { source: "all" }
+  ) => {
+    if (typeof key !== "string") {
+      throw new Error("Expected key to be a string")
+    }
+
+    // Always read from the live, mutated state. `updatedEnvs` is reassigned by setters,
+    // while `envs` may point to an older object (stale snapshot) even if arrays were mutated.
+    // Using `updatedEnvs` here avoids subtle drift if future changes replace arrays immutably.
+    const { global, selected } = updatedEnvs
+
+    const indexInSelected = findEnvIndex(key, selected)
+    const indexInGlobal = findEnvIndex(key, global)
+
+    if (["all", "active"].includes(options.source) && indexInSelected >= 0) {
+      const selectedEnv = selected[indexInSelected]
+
+      if ("currentValue" in selectedEnv) {
+        selectedEnv.currentValue = selectedEnv.initialValue
+      }
+    } else if (
+      ["all", "global"].includes(options.source) &&
+      indexInGlobal >= 0
+    ) {
+      if ("currentValue" in global[indexInGlobal]) {
+        global[indexInGlobal].currentValue = global[indexInGlobal].initialValue
+      }
+    }
+  }
+
+  const envGetInitialRawFn = (
+    key: any,
+    options: EnvAPIOptions = { source: "all" }
+  ) => {
+    if (typeof key !== "string") {
+      throw new Error("Expected key to be a string")
+    }
+
+    const result = pipe(
+      getEnv(key, updatedEnvs, options),
+      O.fold(
+        () => undefined,
+        (env) => String(env.initialValue)
+      )
+    )
+
+    return result ?? null
+  }
+
+  const envSetInitialFn = (
+    key: string,
+    value: string,
+    options: EnvAPIOptions = { source: "all" }
+  ) => {
+    if (typeof key !== "string") {
+      throw new Error("Expected key to be a string")
+    }
+
+    if (typeof value !== "string") {
+      throw new Error("Expected value to be a string")
+    }
+
+    updatedEnvs = setEnv(key, value, updatedEnvs, {
+      setInitialValue: true,
+      source: options.source,
+    })
+
+    return undefined
+  }
+
+  // Experimental scripting sandbox (Both `pw` and `hopp` namespaces)
+  if (isHoppNamespace) {
+    return {
+      methods: {
+        pw: {
+          get: envGetFn,
+          getResolve: envGetResolveFn,
+          set: envSetFn,
+          unset: envUnsetFn,
+          resolve: envResolveFn,
+        },
+        hopp: {
+          set: envSetFn,
+          delete: envUnsetFn,
+          reset: envResetFn,
+          getInitialRaw: envGetInitialRawFn,
+          setInitial: envSetInitialFn,
+        },
+      },
+
+      updatedEnvs,
+    }
+  }
+
+  // Legacy scripting sandbox (Only `pw` namespace)
   return {
     methods: {
-      env: {
-        get: envGetFn,
-        getResolve: envGetResolveFn,
-        set: envSetFn,
-        unset: envUnsetFn,
-        resolve: envResolveFn,
-      },
+      get: envGetFn,
+      getResolve: envGetResolveFn,
+      set: envSetFn,
+      unset: envUnsetFn,
+      resolve: envResolveFn,
     },
     updatedEnvs,
   }
 }
 
+export const getSharedCookieMethods = (cookies: Cookie[] | null) => {
+  // Incoming `cookies` specified as `null` indicates unsupported platform
+  const cookiesSupported = cookies !== null
+  let updatedCookies: Cookie[] = cookies ?? []
+
+  const throwIfCookiesUnsupported = () => {
+    if (cookies === null) {
+      throw new Error(
+        "Cookies are not supported in the current platform and are exclusive to the Desktop App."
+      )
+    }
+  }
+
+  const cookieGetFn = (domain: any, name: any): Cookie | null => {
+    throwIfCookiesUnsupported()
+
+    if (typeof domain !== "string" || typeof name !== "string") {
+      throw new Error("Expected domain and cookieName to be strings")
+    }
+
+    return (
+      updatedCookies.find((c) => c.domain === domain && c.name === name) ?? null
+    )
+  }
+
+  const cookieSetFn = (domain: string, cookie: Cookie): void => {
+    throwIfCookiesUnsupported()
+
+    if (typeof domain !== "string") {
+      throw new Error("Expected domain to be a string")
+    }
+
+    const result = CookieSchema.safeParse(cookie)
+
+    if (!result.success) {
+      throw new Error("Invalid cookie")
+    }
+
+    updatedCookies = updatedCookies.filter(
+      (c) => !(c.domain === domain && c.name === cookie.name)
+    )
+    updatedCookies.push(cookie)
+  }
+
+  const cookieHasFn = (domain: string, name: string): boolean => {
+    throwIfCookiesUnsupported()
+
+    if (typeof domain !== "string" || typeof name !== "string") {
+      throw new Error("Expected domain and cookieName to be strings")
+    }
+    return updatedCookies.some((c) => c.domain === domain && c.name === name)
+  }
+
+  const cookieGetAllFn = (domain: string): Cookie[] => {
+    throwIfCookiesUnsupported()
+
+    if (typeof domain !== "string") {
+      throw new Error("Expected domain to be a string")
+    }
+    return updatedCookies.filter((c) => c.domain === domain)
+  }
+
+  const cookieDeleteFn = (domain: string, name: string): void => {
+    throwIfCookiesUnsupported()
+
+    if (typeof domain !== "string" || typeof name !== "string") {
+      throw new Error("Expected domain and cookieName to be strings")
+    }
+    updatedCookies = updatedCookies.filter(
+      (c) => !(c.domain === domain && c.name === name)
+    )
+  }
+
+  const cookieClearFn = (domain: string): void => {
+    throwIfCookiesUnsupported()
+
+    if (typeof domain !== "string") {
+      throw new Error("Expected domain to be a string")
+    }
+    updatedCookies = updatedCookies.filter((c) => c.domain !== domain)
+  }
+
+  return {
+    methods: {
+      get: cookieGetFn,
+      set: cookieSetFn,
+      has: cookieHasFn,
+      getAll: cookieGetAllFn,
+      delete: cookieDeleteFn,
+      clear: cookieClearFn,
+    },
+    // Use a function so we always read the latest `updatedCookies` (not a stale snapshot)
+    getUpdatedCookies: () =>
+      cookiesSupported ? cloneDeep(updatedCookies) : null,
+  }
+}
+
 const getResolvedExpectValue = (expectVal: any) => {
   if (typeof expectVal !== "string") {
     return expectVal
@@ -470,7 +774,7 @@ export const createExpectation = (
  * @returns Object with methods in the `pw` namespace
  */
 export const getPreRequestScriptMethods = (envs: TestResult["envs"]) => {
-  const { methods, updatedEnvs } = getSharedMethods(cloneDeep(envs))
+  const { methods, updatedEnvs } = getSharedEnvMethods(cloneDeep(envs))
   return { pw: methods, updatedEnvs }
 }
 
@@ -500,7 +804,7 @@ export const getTestRunnerScriptMethods = (envs: TestResult["envs"]) => {
   const expectFn = (expectVal: any) =>
     createExpectation(expectVal, false, testRunStack)
 
-  const { methods, updatedEnvs } = getSharedMethods(cloneDeep(envs))
+  const { methods, updatedEnvs } = getSharedEnvMethods(cloneDeep(envs))
 
   const pw = {
     ...methods,
@@ -510,3 +814,35 @@ export const getTestRunnerScriptMethods = (envs: TestResult["envs"]) => {
 
   return { pw, testRunStack, updatedEnvs }
 }
+
+/**
+ * Compiles shared scripting API properties (scoped to requests) for use in both pre and post request scripts
+ * Extracts shared properties from a request object
+ * @param request The request object to extract shared properties from
+ * @returns An object containing the shared properties of the request
+ */
+export const getSharedRequestProps = (request: HoppRESTRequest) => {
+  return {
+    get url() {
+      return request.endpoint
+    },
+    get method() {
+      return request.method
+    },
+    get params() {
+      return request.params
+    },
+    get headers() {
+      return request.headers
+    },
+    get body() {
+      return request.body
+    },
+    get auth() {
+      return request.auth
+    },
+    get requestVariables() {
+      return request.requestVariables
+    },
+  }
+}
diff --git a/packages/hoppscotch-js-sandbox/src/web/pre-request/index.ts b/packages/hoppscotch-js-sandbox/src/web/pre-request/index.ts
index e12ac2d7..e60139c1 100644
--- a/packages/hoppscotch-js-sandbox/src/web/pre-request/index.ts
+++ b/packages/hoppscotch-js-sandbox/src/web/pre-request/index.ts
@@ -2,10 +2,15 @@ import { FaradayCage } from "faraday-cage"
 import { ConsoleEntry } from "faraday-cage/modules"
 import * as E from "fp-ts/Either"
 import { cloneDeep } from "lodash"
-import { SandboxPreRequestResult, TestResult } from "~/types"
+import {
+  RunPreRequestScriptOptions,
+  SandboxPreRequestResult,
+  TestResult,
+} from "~/types"
 
-import { defaultModules, pwPreRequestModule } from "~/cage-modules"
+import { defaultModules, preRequestModule } from "~/cage-modules"
 
+import { Cookie, HoppRESTRequest } from "@hoppscotch/data"
 import Worker from "./worker?worker&inline"
 
 const runPreRequestScriptWithWebWorker = (
@@ -31,10 +36,14 @@ const runPreRequestScriptWithWebWorker = (
 
 const runPreRequestScriptWithFaradayCage = async (
   preRequestScript: string,
-  envs: TestResult["envs"]
+  envs: TestResult["envs"],
+  request: HoppRESTRequest,
+  cookies: Cookie[] | null
 ): Promise<E.Either<string, SandboxPreRequestResult>> => {
   const consoleEntries: ConsoleEntry[] = []
   let finalEnvs = envs
+  let finalRequest = request
+  let finalCookies = cookies
 
   const cage = await FaradayCage.create()
 
@@ -43,9 +52,15 @@ const runPreRequestScriptWithFaradayCage = async (
       handleConsoleEntry: (consoleEntry) => consoleEntries.push(consoleEntry),
     }),
 
-    pwPreRequestModule({
+    preRequestModule({
       envs: cloneDeep(envs),
-      handleSandboxResults: ({ envs }) => (finalEnvs = envs),
+      request: cloneDeep(request),
+      cookies: cookies ? cloneDeep(cookies) : null,
+      handleSandboxResults: ({ envs, request, cookies }) => {
+        finalEnvs = envs
+        finalRequest = request
+        finalCookies = cookies
+      },
     }),
   ])
 
@@ -62,16 +77,32 @@ const runPreRequestScriptWithFaradayCage = async (
   }
 
   return E.right({
-    envs: finalEnvs,
+    updatedEnvs: finalEnvs,
     consoleEntries,
-  })
+    updatedRequest: finalRequest,
+    updatedCookies: finalCookies,
+  } satisfies SandboxPreRequestResult)
 }
 
-export const runPreRequestScript = async (
+export const runPreRequestScript = (
   preRequestScript: string,
-  envs: TestResult["envs"],
-  experimentalScriptingSandbox = true
-): Promise<E.Either<string, SandboxPreRequestResult>> =>
-  experimentalScriptingSandbox
-    ? runPreRequestScriptWithFaradayCage(preRequestScript, envs)
-    : runPreRequestScriptWithWebWorker(preRequestScript, envs)
+  options: RunPreRequestScriptOptions
+): Promise<E.Either<string, SandboxPreRequestResult>> => {
+  const { envs, experimentalScriptingSandbox = true } = options
+
+  if (experimentalScriptingSandbox) {
+    const { request, cookies } = options as Extract<
+      RunPreRequestScriptOptions,
+      { experimentalScriptingSandbox: true }
+    >
+
+    return runPreRequestScriptWithFaradayCage(
+      preRequestScript,
+      envs,
+      request,
+      cookies
+    )
+  }
+
+  return runPreRequestScriptWithWebWorker(preRequestScript, envs)
+}
diff --git a/packages/hoppscotch-js-sandbox/src/web/pre-request/worker.ts b/packages/hoppscotch-js-sandbox/src/web/pre-request/worker.ts
index c501f4d7..e48c622e 100644
--- a/packages/hoppscotch-js-sandbox/src/web/pre-request/worker.ts
+++ b/packages/hoppscotch-js-sandbox/src/web/pre-request/worker.ts
@@ -1,6 +1,6 @@
 import * as TE from "fp-ts/TaskEither"
 
-import { getPreRequestScriptMethods } from "~/shared-utils"
+import { getPreRequestScriptMethods } from "~/utils/shared"
 import { SandboxPreRequestResult, TestResult } from "~/types"
 
 const executeScriptInContext = (
@@ -17,7 +17,8 @@ const executeScriptInContext = (
     executeScript(pw)
 
     return TE.right({
-      envs: updatedEnvs,
+      updatedEnvs,
+      updatedCookies: null,
     })
   } catch (error) {
     return TE.left(`Script execution failed: ${(error as Error).message}`)
diff --git a/packages/hoppscotch-js-sandbox/src/web/test-runner/index.ts b/packages/hoppscotch-js-sandbox/src/web/test-runner/index.ts
index 30409122..040294b7 100644
--- a/packages/hoppscotch-js-sandbox/src/web/test-runner/index.ts
+++ b/packages/hoppscotch-js-sandbox/src/web/test-runner/index.ts
@@ -3,18 +3,20 @@ import { ConsoleEntry } from "faraday-cage/modules"
 import * as E from "fp-ts/Either"
 import { cloneDeep } from "lodash-es"
 
-import { defaultModules, pwPostRequestModule } from "~/cage-modules"
-import { preventCyclicObjects } from "~/shared-utils"
+import { defaultModules, postRequestModule } from "~/cage-modules"
 import {
+  RunPostRequestScriptOptions,
   SandboxTestResult,
   TestDescriptor,
   TestResponse,
   TestResult,
 } from "~/types"
+import { preventCyclicObjects } from "~/utils/shared"
 
+import { Cookie, HoppRESTRequest } from "@hoppscotch/data"
 import Worker from "./worker?worker&inline"
 
-const runTestScriptWithWebWorker = (
+const runPostRequestScriptWithWebWorker = (
   testScript: string,
   envs: TestResult["envs"],
   response: TestResponse
@@ -36,10 +38,12 @@ const runTestScriptWithWebWorker = (
   })
 }
 
-const runTestScriptWithFaradayCage = async (
+const runPostRequestScriptWithFaradayCage = async (
   testScript: string,
   envs: TestResult["envs"],
-  response: TestResponse
+  request: HoppRESTRequest,
+  response: TestResponse,
+  cookies: Cookie[] | null
 ): Promise<E.Either<string, SandboxTestResult>> => {
   const testRunStack: TestDescriptor[] = [
     { descriptor: "root", expectResults: [], children: [] },
@@ -48,6 +52,7 @@ const runTestScriptWithFaradayCage = async (
   let finalEnvs = envs
   let finalTestResults = testRunStack
   const consoleEntries: ConsoleEntry[] = []
+  let finalCookies = cookies
 
   const cage = await FaradayCage.create()
 
@@ -56,13 +61,16 @@ const runTestScriptWithFaradayCage = async (
       handleConsoleEntry: (consoleEntry) => consoleEntries.push(consoleEntry),
     }),
 
-    pwPostRequestModule({
+    postRequestModule({
       envs: cloneDeep(envs),
       testRunStack: cloneDeep(testRunStack),
-      response,
-      handleSandboxResults: ({ envs, testRunStack }) => {
+      request: cloneDeep(request),
+      response: cloneDeep(response),
+      cookies: cookies ? cloneDeep(cookies) : null,
+      handleSandboxResults: ({ envs, testRunStack, cookies }) => {
         finalEnvs = envs
         finalTestResults = testRunStack
+        finalCookies = cookies
       },
     }),
   ])
@@ -83,22 +91,38 @@ const runTestScriptWithFaradayCage = async (
     tests: finalTestResults[0],
     envs: finalEnvs,
     consoleEntries,
+    updatedCookies: finalCookies,
   })
 }
 
 export const runTestScript = async (
   testScript: string,
-  envs: TestResult["envs"],
-  response: TestResponse,
-  experimentalScriptingSandbox = true
+  options: RunPostRequestScriptOptions
 ): Promise<E.Either<string, SandboxTestResult>> => {
-  const responseObjHandle = preventCyclicObjects<TestResponse>(response)
+  const responseObjHandle = preventCyclicObjects<TestResponse>(options.response)
 
   if (E.isLeft(responseObjHandle)) {
     return E.left(`Response marshalling failed: ${responseObjHandle.left}`)
   }
 
-  return experimentalScriptingSandbox
-    ? runTestScriptWithFaradayCage(testScript, envs, responseObjHandle.right)
-    : runTestScriptWithWebWorker(testScript, envs, responseObjHandle.right)
+  const resolvedResponse = responseObjHandle.right
+
+  const { envs, experimentalScriptingSandbox = true } = options
+
+  if (experimentalScriptingSandbox) {
+    const { request, cookies } = options as Extract<
+      RunPostRequestScriptOptions,
+      { experimentalScriptingSandbox: true }
+    >
+
+    return runPostRequestScriptWithFaradayCage(
+      testScript,
+      envs,
+      request,
+      resolvedResponse,
+      cookies
+    )
+  }
+
+  return runPostRequestScriptWithWebWorker(testScript, envs, resolvedResponse)
 }
diff --git a/packages/hoppscotch-js-sandbox/src/web/test-runner/worker.ts b/packages/hoppscotch-js-sandbox/src/web/test-runner/worker.ts
index 56bd5ce0..8bd1f76e 100644
--- a/packages/hoppscotch-js-sandbox/src/web/test-runner/worker.ts
+++ b/packages/hoppscotch-js-sandbox/src/web/test-runner/worker.ts
@@ -1,11 +1,11 @@
 import * as E from "fp-ts/Either"
 import * as TE from "fp-ts/TaskEither"
 
+import { SandboxTestResult, TestResponse, TestResult } from "~/types"
 import {
   getTestRunnerScriptMethods,
   preventCyclicObjects,
-} from "~/shared-utils"
-import { SandboxTestResult, TestResponse, TestResult } from "~/types"
+} from "~/utils/shared"
 
 const executeScriptInContext = (
   testScript: string,