From 5a0ebcb929f029358e1d06843601a4738f354edb Mon Sep 17 00:00:00 2001
From: Brian LeRoux <brian.leroux@sanity.io>
Date: Thu, 25 Sep 2025 12:54:43 -0700
Subject: [PATCH 1/4] fix: lint

---
 test/unit/src/http/csrf/create-and-verify-test.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/unit/src/http/csrf/create-and-verify-test.js b/test/unit/src/http/csrf/create-and-verify-test.js
index 72690c17..7bac1e4c 100644
--- a/test/unit/src/http/csrf/create-and-verify-test.js
+++ b/test/unit/src/http/csrf/create-and-verify-test.js
@@ -21,13 +21,13 @@ test('verify a value', t => {
 
 test('tampered token is falsy', t => {
   t.plan(1)
-  let tamperedToken = "3d879d515ab241429c97dfea6d1e1927.1584118407000.b0b34563d569030cbe9a4ea63312f23729813b838478420e3811c0bfeaf3add1"
+  let tamperedToken = '3d879d515ab241429c97dfea6d1e1927.1584118407000.b0b34563d569030cbe9a4ea63312f23729813b838478420e3811c0bfeaf3add1'
   t.ok(http.csrf.verify(tamperedToken) === false, 'value falsy')
 })
 
 test('token expired is falsy', t  => {
   t.plan(1)
-  let expiredToken = "3d879d515ab241419c97dfea6d1e1927.1584118407000.b0b34563d569030cbe9a4ea63312f23729813b838478420e3811c0bfeaf3add1"
+  let expiredToken = '3d879d515ab241419c97dfea6d1e1927.1584118407000.b0b34563d569030cbe9a4ea63312f23729813b838478420e3811c0bfeaf3add1'
   t.ok(http.csrf.verify(expiredToken) === false, 'value falsy')
 })
 

From bad5396f483d1bf0048dcd18aa8d6d37a9ac27ab Mon Sep 17 00:00:00 2001
From: Brian LeRoux <brian.leroux@sanity.io>
Date: Thu, 25 Sep 2025 12:58:29 -0700
Subject: [PATCH 2/4] chore: bump to latest node

---
 .github/workflows/build.yml |  9 +--------
 package.json                | 14 +++++++-------
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index fedce9b6..2327deb9 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -15,7 +15,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        node-version: [ 16.x, 18.x, 20.x, 22.x ]
+        node-version: [ 20.x, 22.x, 24.x ]
         os: [ windows-latest, ubuntu-latest, macOS-latest ]
 
     # Go
@@ -40,14 +40,7 @@ jobs:
     - name: Install
       run: npm install
 
-    - name: Test (Node.js <= 16.x)
-      if: matrix.node-version <= '16.x'
-      run: npm run test:nolint
-      env:
-        CI: true
-
     - name: Test
-      if: matrix.node-version > '16.x'
       run: npm test
       env:
         CI: true
diff --git a/package.json b/package.json
index 2969f641..5a742ec6 100644
--- a/package.json
+++ b/package.json
@@ -22,13 +22,13 @@
     "rc": "npm version prerelease --preid RC"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "author": "Brian LeRoux <b@brian.io>",
   "license": "Apache-2.0",
   "dependencies": {
     "@aws-lite/apigatewaymanagementapi": "^0.0.10",
-    "@aws-lite/client": "^0.22.4",
+    "@aws-lite/client": "^0.23.2",
     "@aws-lite/dynamodb": "^0.3.9",
     "@aws-lite/sns": "^0.0.8",
     "@aws-lite/sqs": "^0.2.4",
@@ -45,22 +45,22 @@
     "@architect/asap": "^7.0.10",
     "@architect/eslint-config": "^3.0.0",
     "@architect/req-res-fixtures": "git+https://github.com/architect/req-res-fixtures.git",
-    "@architect/sandbox": "^6.0.5",
+    "@architect/sandbox": "^8.0.0-RC.2",
     "@aws-lite/apigatewaymanagementapi-types": "^0.0.13",
     "@aws-lite/dynamodb-types": "^0.3.11",
     "@aws-lite/sns-types": "^0.0.10",
     "@aws-lite/sqs-types": "^0.2.6",
     "@types/aws-lambda": "^8.10.147",
-    "@types/node": "18",
-    "cross-env": "~7.0.3",
+    "@types/node": "^24.5.2",
+    "cross-env": "^10.0.0",
     "eslint": "^9.19.0",
     "nyc": "~17.1.0",
     "proxyquire": "~2.1.3",
-    "sinon": "^19.0.2",
+    "sinon": "^21.0.0",
     "tap-arc": "^1.3.2",
     "tape": "^5.9.0",
     "tiny-json-http": "^7.5.1",
-    "tsd": "^0.31.2"
+    "tsd": "^0.33.0"
   },
   "files": [
     "types/*",

From 6fda49a145d64f66a18eba39665c4c7892aca6e8 Mon Sep 17 00:00:00 2001
From: Brian LeRoux <brian.leroux@sanity.io>
Date: Thu, 25 Sep 2025 12:58:36 -0700
Subject: [PATCH 3/4] 8.1.10-RC.0

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 5a742ec6..feb6d6b7 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@architect/functions",
-  "version": "8.1.9",
+  "version": "8.1.10-RC.0",
   "description": "Runtime utility library for Functional Web Apps (FWAs) built with Architect (https://arc.codes)",
   "homepage": "https://github.com/architect/functions",
   "repository": {

From 9878bb304205d10dcf96f844f349bea458f366cc Mon Sep 17 00:00:00 2001
From: Brian LeRoux <brian.leroux@sanity.io>
Date: Thu, 25 Sep 2025 15:02:03 -0700
Subject: [PATCH 4/4] chore: investigate migrating to biome

---
 .gitignore                                    |   1 +
 biome.json                                    |  56 +++
 eslint.config.js                              |  10 +-
 package.json                                  |   9 +-
 src/discovery/index.js                        |  47 ++-
 src/events/index.js                           |  10 +-
 src/events/publish.js                         | 131 +++----
 src/events/subscribe.js                       |  71 ++--
 src/http/_res-fmt.js                          | 135 ++++---
 src/http/csrf/create.js                       |   2 +-
 src/http/csrf/verify.js                       |   6 +-
 src/http/errors/index.js                      |  12 +-
 src/http/helpers/body-parser.js               |  83 ++--
 src/http/helpers/csrf.js                      |   9 +-
 src/http/helpers/params.js                    |  22 +-
 src/http/helpers/url.js                       |  13 +-
 src/http/index.js                             | 121 +++---
 src/http/session/providers/_get-idx.js        |   8 +-
 .../session/providers/ddb/_week-from-now.js   |   2 +-
 src/http/session/providers/ddb/create.js      |  66 ++--
 src/http/session/providers/ddb/find.js        |  37 +-
 src/http/session/providers/ddb/index.js       |  98 +++--
 src/http/session/providers/ddb/update.js      |  22 +-
 src/http/session/providers/jwe.js             |  71 ++--
 src/http/session/read.js                      |  10 +-
 src/http/session/write.js                     |  10 +-
 src/index.js                                  |  38 +-
 src/lib/_get-ports.js                         |  12 +-
 src/lib/_sandbox-version.js                   |  21 +-
 src/lib/index.js                              |  29 +-
 src/static/index.js                           |  31 +-
 src/tables/factory.js                         | 156 ++++----
 src/tables/index.js                           |  60 +--
 src/tables/legacy.js                          |  53 ++-
 src/tables/old.js                             |  31 +-
 src/ws/index.js                               | 177 +++++----
 test/integration/discovery-test.js            |  24 +-
 test/integration/events-queues-test.js        |  72 ++--
 test/integration/http-assets.js               |  32 +-
 test/integration/http-session-dynamo-test.js  |  67 ++--
 test/integration/http-session-jwe-test.js     |  54 +--
 test/integration/static-fingerprinted-test.js |  32 +-
 test/integration/static-plain-test.js         |  36 +-
 test/integration/tables-test.js               |  78 ++--
 test/integration/version-check.js             |  33 +-
 test/integration/ws-test.js                   |  34 +-
 test/mock/mock-sns-event.json                 |  16 +-
 test/mock/mock-sqs-event.json                 |  34 +-
 .../project/src/events/async-event/index.js   |   8 +-
 .../mock/project/src/events/cb-event/index.js |   8 +-
 .../project/src/http/get-catchall/index.js    |   4 +-
 .../src/http/get-http_async_session/index.js  |   5 +-
 .../src/http/get-http_session/index.js        |   4 +-
 .../http/get-incompatible_version/index.js    |   4 +-
 .../http/post-publish_event-catchall/index.js |  14 +-
 .../project/src/queues/async-queue/index.js   |   8 +-
 .../mock/project/src/queues/cb-queue/index.js |   8 +-
 test/mock/project/src/ws/connect/index.js     |   3 +-
 test/mock/project/src/ws/default/index.js     |   6 +-
 test/mock/project/src/ws/disconnect/index.js  |   3 +-
 test/unit/src/events/publish-test.js          |  28 +-
 test/unit/src/events/subscribe-test.js        |  60 +--
 .../src/http/csrf/create-and-verify-test.js   |  26 +-
 .../unit/src/http/helpers/body-parser-test.js |  50 ++-
 test/unit/src/http/helpers/url-test.js        |  26 +-
 test/unit/src/http/index-async-req-test.js    | 362 +++++++++---------
 test/unit/src/http/index-async-res-test.js    | 292 ++++++++------
 test/unit/src/http/index-cb-req-test.js       | 328 ++++++++--------
 test/unit/src/http/index-cb-res-test.js       | 269 ++++++++-----
 test/unit/src/http/session/get-idx-test.js    |  16 +-
 test/unit/src/http/session/session-test.js    |  88 +++--
 test/unit/src/lib/_sandbox-version-test.js    |  10 +-
 test/unit/src/queues/publish-test.js          |  28 +-
 test/unit/src/queues/subscribe-test.js        |  31 +-
 test/unit/src/static/index-test.js            |  43 ++-
 test/unit/src/tables/factory-test.js          |  33 +-
 76 files changed, 2087 insertions(+), 1860 deletions(-)
 create mode 100644 biome.json

diff --git a/.gitignore b/.gitignore
index 8a93bbb1..e0f04581 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ scratch/
 test/mock/*/src/*/*/vendor/
 test/mock/tmp/
 yarn.lock
+.kiro
diff --git a/biome.json b/biome.json
new file mode 100644
index 00000000..fc8c42aa
--- /dev/null
+++ b/biome.json
@@ -0,0 +1,56 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "ignore": [
+      ".nyc_output/",
+      "arc-proxy-*",
+      "coverage/",
+      "dist.js",
+      "scratch/",
+      "src/http/get-index",
+      "types/",
+      "node_modules/",
+      "test/mock/*/src/*/*/vendor/",
+      "test/mock/tmp/"
+    ]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 120
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "style": {
+        "noVar": "error",
+        "useConst": "error",
+        "noParameterAssign": "off",
+        "useDefaultParameterLast": "off"
+      },
+      "complexity": {
+        "noForEach": "off"
+      },
+      "performance": {
+        "noDelete": "off"
+      },
+      "suspicious": {
+        "noExplicitAny": "off"
+      }
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "semicolons": "asNeeded",
+      "quoteStyle": "single"
+    }
+  }
+}
diff --git a/eslint.config.js b/eslint.config.js
index 7beb01c9..99f5b75a 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -3,14 +3,6 @@ const arc = require('@architect/eslint-config')
 module.exports = [
   ...arc,
   {
-    ignores: [
-      '.nyc_output/',
-      'arc-proxy-*',
-      'coverage/',
-      'dist.js',
-      'scratch/',
-      'src/http/get-index',
-      'types/',
-    ],
+    ignores: ['.nyc_output/', 'arc-proxy-*', 'coverage/', 'dist.js', 'scratch/', 'src/http/get-index', 'types/'],
   },
 ]
diff --git a/package.json b/package.json
index feb6d6b7..a9dcfd3d 100644
--- a/package.json
+++ b/package.json
@@ -12,7 +12,8 @@
   "types": "types/index.d.ts",
   "scripts": {
     "test:one": "cross-env tape 'test/unit/src/http/csrf/*-test.js' | tap-arc",
-    "lint": "eslint --fix .",
+    "lint": "biome check --write .",
+    "lint:fmt": "biome format --write .",
     "test": "npm run lint && npm run test:integration && npm run coverage && npm run test:types",
     "test:nolint": "npm run test:integration && npm run coverage && npm run test:types",
     "test:unit": "cross-env tape 'test/unit/**/*-test.js' | tap-arc",
@@ -50,6 +51,7 @@
     "@aws-lite/dynamodb-types": "^0.3.11",
     "@aws-lite/sns-types": "^0.0.10",
     "@aws-lite/sqs-types": "^0.2.6",
+    "@biomejs/biome": "^1.9.4",
     "@types/aws-lambda": "^8.10.147",
     "@types/node": "^24.5.2",
     "cross-env": "^10.0.0",
@@ -62,10 +64,7 @@
     "tiny-json-http": "^7.5.1",
     "tsd": "^0.33.0"
   },
-  "files": [
-    "types/*",
-    "src/*"
-  ],
+  "files": ["types/*", "src/*"],
   "keywords": [
     "aws",
     "lambda",
diff --git a/src/discovery/index.js b/src/discovery/index.js
index e7ed5b2f..72ac592c 100644
--- a/src/discovery/index.js
+++ b/src/discovery/index.js
@@ -1,14 +1,13 @@
-let { getAwsClient, useAWS } = require('../lib')
+const { getAwsClient, useAWS } = require('../lib')
 
 /**
  * @param {string} type - events, queues, or tables
  * @returns {object} {name: value}
  */
-module.exports = function lookup (callback) {
-
+module.exports = function lookup(callback) {
   let { ARC_APP_NAME: app, ARC_ENV: env, ARC_SANDBOX, ARC_STACK_NAME: stack } = process.env
 
-  let local = !useAWS()
+  const local = !useAWS()
 
   if (!local && !app && !stack) {
     return callback(ReferenceError('ARC_APP_NAME and ARC_STACK_NAME env vars not found'))
@@ -18,12 +17,12 @@ module.exports = function lookup (callback) {
     app = 'arc-app'
   }
 
-  let plugins = [ import('@aws-lite/ssm') ]
-  let config = { plugins }
+  const plugins = [import('@aws-lite/ssm')]
+  const config = { plugins }
   if (local) {
     let port = 2222
     if (ARC_SANDBOX) {
-      let { ports } = JSON.parse(ARC_SANDBOX)
+      const { ports } = JSON.parse(ARC_SANDBOX)
       if (!ports._arc) {
         return callback(ReferenceError('Sandbox internal port not found'))
       }
@@ -35,19 +34,22 @@ module.exports = function lookup (callback) {
   getAwsClient(config, (err, client) => {
     if (err) callback(err)
     else {
-      let Path = `/${stack || toLogicalID(`${app}-${env}`)}`
-      client.ssm.GetParametersByPath({ Path, Recursive: true, paginate: true })
-        .then(result => {
-          let services = result.Parameters.reduce((a, b) => {
-            let hierarchy = b.Name.split('/')
+      const Path = `/${stack || toLogicalID(`${app}-${env}`)}`
+      client.ssm
+        .GetParametersByPath({ Path, Recursive: true, paginate: true })
+        .then((result) => {
+          const services = result.Parameters.reduce((a, b) => {
+            const hierarchy = b.Name.split('/')
             hierarchy.shift() // leading slash
             hierarchy.shift() // stack name
-            let type = hierarchy.shift() // i.e. tables, events, queues, plugins
+            const type = hierarchy.shift() // i.e. tables, events, queues, plugins
             if (!a[type]) a[type] = {}
             let parent = a[type]
-            let child, lastChild, lastParent
-            /* eslint-disable-next-line */
-            while (child = hierarchy.shift()) {
+            let child
+            let lastChild
+            let lastParent
+            // biome-ignore lint/suspicious/noAssignInExpressions: we know what we are doing here
+            while ((child = hierarchy.shift())) {
               if (!parent[child]) parent[child] = {}
               lastParent = parent
               parent = parent[child]
@@ -58,14 +60,11 @@ module.exports = function lookup (callback) {
           }, {})
           callback(null, services)
         })
-        .catch(err => {
-          if (err && local &&
-              err.message.includes('Inaccessible host') &&
-              err.message.includes('localhost')) {
-            let msg = 'Sandbox internal services are unavailable, please ensure Sandbox is running'
+        .catch((err) => {
+          if (err && local && err.message.includes('Inaccessible host') && err.message.includes('localhost')) {
+            const msg = 'Sandbox internal services are unavailable, please ensure Sandbox is running'
             callback(ReferenceError(msg))
-          }
-          else {
+          } else {
             callback(err)
           }
         })
@@ -73,7 +72,7 @@ module.exports = function lookup (callback) {
   })
 }
 
-function toLogicalID (str) {
+function toLogicalID(str) {
   str = str.replace(/([A-Z])/g, ' $1')
   if (str.length === 1) {
     return str.toUpperCase()
diff --git a/src/events/index.js b/src/events/index.js
index c3c2e48d..4f572599 100644
--- a/src/events/index.js
+++ b/src/events/index.js
@@ -1,8 +1,8 @@
-let pubFactory = require('./publish')
-let subFactory = require('./subscribe')
+const pubFactory = require('./publish')
+const subFactory = require('./subscribe')
 
-module.exports = function eventsAndQueuesFactory (arc, type) {
-  let publish = pubFactory(arc, type)
-  let subscribe = subFactory(type)
+module.exports = function eventsAndQueuesFactory(arc, type) {
+  const publish = pubFactory(arc, type)
+  const subscribe = subFactory(type)
   return { publish, subscribe }
 }
diff --git a/src/events/publish.js b/src/events/publish.js
index d32a2656..4cef8af8 100644
--- a/src/events/publish.js
+++ b/src/events/publish.js
@@ -1,16 +1,17 @@
-let http = require('http')
-let { getAwsClient, getPorts, useAWS } = require('../lib')
-let ledger = { events: {}, queues: {} }
-let client, port
+const http = require('node:http')
+const { getAwsClient, getPorts, useAWS } = require('../lib')
+const ledger = { events: {}, queues: {} }
+let client
+let port
 
 /**
  * Invoke
  * - `@events` Lambdas by EventBridge topic name
  * - `@queues` Lambdas by SQS queue name
  */
-module.exports = function publishFactory (arc, type) {
-  let factory = type === 'events' ? eventFactory : queueFactory
-  return function publish (params, callback) {
+module.exports = function publishFactory(arc, type) {
+  const factory = type === 'events' ? eventFactory : queueFactory
+  return function publish(params, callback) {
     if (!params.name) {
       throw ReferenceError('missing params.name')
     }
@@ -21,17 +22,16 @@ module.exports = function publishFactory (arc, type) {
     let promise
     if (!callback) {
       promise = new Promise((resolve, reject) => {
-        callback = function errback (err, result) {
+        callback = function errback(err, result) {
           err ? reject(err) : resolve(result)
         }
       })
     }
 
-    let local = !useAWS()
+    const local = !useAWS()
     if (local && port) {
       _publishSandbox(type, params, callback)
-    }
-    else if (local) {
+    } else if (local) {
       getPorts((err, ports) => {
         if (err) callback(err)
         else {
@@ -42,62 +42,65 @@ module.exports = function publishFactory (arc, type) {
           _publishSandbox(type, params, callback)
         }
       })
-    }
-    else if (client) {
-      let publishAWS = factory(arc)
+    } else if (client) {
+      const publishAWS = factory(arc)
       publishAWS(params, callback)
-    }
-    else {
-      getAwsClient({
-        plugins: [ import('@aws-lite/sns'), import('@aws-lite/sqs') ],
-      }, (err, _client) => {
-        if (err) callback(err)
-        else {
-          client = _client
-          let publishAWS = factory(arc)
-          publishAWS(params, callback)
-        }
-      })
+    } else {
+      getAwsClient(
+        {
+          plugins: [import('@aws-lite/sns'), import('@aws-lite/sqs')],
+        },
+        (err, _client) => {
+          if (err) callback(err)
+          else {
+            client = _client
+            const publishAWS = factory(arc)
+            publishAWS(params, callback)
+          }
+        },
+      )
     }
 
     return promise
   }
 }
 
-function _publishSandbox (type, params, callback) {
-  let req = http.request({
-    method: 'POST',
-    port,
-    path: '/' + type,
-  },
-  function done (res) {
-    let data = []
-    res.resume()
-    res.on('data', chunk => data.push(chunk))
-    res.on('end', () => {
-      let body = Buffer.concat(data).toString()
-      let code = `${res.statusCode}`
-      if (!code.startsWith(2)) callback(Error(`${body} (${code})`))
-      else callback(null, body)
-    })
-  })
+function _publishSandbox(type, params, callback) {
+  const req = http.request(
+    {
+      method: 'POST',
+      port,
+      path: `/${type}`,
+    },
+    function done(res) {
+      const data = []
+      res.resume()
+      res.on('data', (chunk) => data.push(chunk))
+      res.on('end', () => {
+        const body = Buffer.concat(data).toString()
+        const code = `${res.statusCode}`
+        if (!code.startsWith(2)) callback(Error(`${body} (${code})`))
+        else callback(null, body)
+      })
+    },
+  )
   req.write(JSON.stringify(params))
   req.end('\n')
 }
 
-function eventFactory (arc) {
-  return function live ({ name, payload }, callback) {
-
-    function publish (arn, payload, callback) {
-      client.sns.Publish({
-        TopicArn: arn,
-        Message: JSON.stringify(payload),
-      })
-        .then(result => callback(null, result))
+function eventFactory(arc) {
+  return function live({ name, payload }, callback) {
+    function publish(arn, payload, callback) {
+      client.sns
+        .Publish({
+          TopicArn: arn,
+          Message: JSON.stringify(payload),
+        })
+        .then((result) => callback(null, result))
         .catch(callback)
     }
 
-    function cacheLedgerAndPublish (serviceMap) {
+    function cacheLedgerAndPublish(serviceMap) {
       ledger.events = serviceMap.events
       arn = ledger.events[name]
       if (!arn) callback(ReferenceError(`${name} event not found`))
@@ -107,18 +110,16 @@ function eventFactory (arc) {
     let arn = ledger.events[name]
     if (arn) {
       publish(arn, payload, callback)
-    }
-    else {
+    } else {
       arc.services().then(cacheLedgerAndPublish).catch(callback)
     }
   }
 }
 
-function queueFactory (arc) {
-  return function live ({ name, payload, delaySeconds, groupID }, callback) {
-
-    function publish (url, payload, callback) {
-      let params = {
+function queueFactory(arc) {
+  return function live({ name, payload, delaySeconds, groupID }, callback) {
+    function publish(url, payload, callback) {
+      const params = {
         QueueUrl: url,
         DelaySeconds: delaySeconds || 0,
         MessageBody: JSON.stringify(payload),
@@ -126,12 +127,13 @@ function queueFactory (arc) {
       if (url.endsWith('.fifo')) {
         params.MessageGroupId = groupID || name
       }
-      client.sqs.SendMessage(params)
-        .then(result => callback(null, result))
+      client.sqs
+        .SendMessage(params)
+        .then((result) => callback(null, result))
         .catch(callback)
     }
 
-    function cacheLedgerAndPublish (serviceMap) {
+    function cacheLedgerAndPublish(serviceMap) {
       ledger.queues = serviceMap.queues
       url = ledger.queues[name]
       if (!url) callback(ReferenceError(`${name} queue not found`))
@@ -141,8 +143,7 @@ function queueFactory (arc) {
     let url = ledger.queues[name]
     if (url) {
       publish(url, payload, callback)
-    }
-    else {
+    } else {
       arc.services().then(cacheLedgerAndPublish).catch(callback)
     }
   }
diff --git a/src/events/subscribe.js b/src/events/subscribe.js
index 6310940d..3ace2142 100644
--- a/src/events/subscribe.js
+++ b/src/events/subscribe.js
@@ -1,9 +1,7 @@
-let parallel = require('run-parallel')
+const parallel = require('run-parallel')
 
-let fallback = {
-  Records: [
-    { Sns: { Message: JSON.stringify({}) } },
-  ],
+const fallback = {
+  Records: [{ Sns: { Message: JSON.stringify({}) } }],
 }
 
 /**
@@ -18,50 +16,51 @@ let fallback = {
  * exports.handler = arc.events.subscribe(signup)
  * ```
  */
-module.exports = function _subscribe (type) {
-  return function subscribe (fn) {
-    let isEvents = type === 'events'
+module.exports = function _subscribe(type) {
+  return function subscribe(fn) {
+    const isEvents = type === 'events'
     // Async interface
     if (fn.constructor.name === 'AsyncFunction') {
-      return async function lambda (event) {
+      return async function lambda(event) {
         if (isEvents) {
           event = event && Object.keys(event).length ? event : fallback
         }
-        return Promise.all(event.Records.map(async record => {
-          try {
-            let payload = isEvents ? record.Sns.Message : record.body
-            let result = JSON.parse(payload)
-            return await fn(result)
-          }
-          catch (err) {
-            console.log('Subscribe error:', err)
-            throw err
-          }
-        }))
+        return Promise.all(
+          event.Records.map(async (record) => {
+            try {
+              const payload = isEvents ? record.Sns.Message : record.body
+              const result = JSON.parse(payload)
+              return await fn(result)
+            } catch (err) {
+              console.log('Subscribe error:', err)
+              throw err
+            }
+          }),
+        )
       }
     }
-    else {
-      // Callback interface
-      return function lambda (event, context, callback) {
-        if (isEvents) {
-          event = event && Object.keys(event).length ? event : fallback
-        }
-        // sns triggers send batches of records
-        // so we're going to create a handler for each one
-        // and execute them in parallel
-        parallel(event.Records.map(function _iterator (record) {
+    // Callback interface
+    return function lambda(event, context, callback) {
+      if (isEvents) {
+        event = event && Object.keys(event).length ? event : fallback
+      }
+      // sns triggers send batches of records
+      // so we're going to create a handler for each one
+      // and execute them in parallel
+      parallel(
+        event.Records.map(function _iterator(record) {
           // Construct a handler function for each record
-          return function _actualHandler (callback) {
+          return function _actualHandler(callback) {
             try {
-              let payload = isEvents ? record.Sns.Message : record.body
+              const payload = isEvents ? record.Sns.Message : record.body
               fn(JSON.parse(payload), callback)
-            }
-            catch (e) {
+            } catch (e) {
               callback(e)
             }
           }
-        }), callback)
-      }
+        }),
+        callback,
+      )
     }
   }
 }
diff --git a/src/http/_res-fmt.js b/src/http/_res-fmt.js
index fc75d6d7..c4dd25c8 100644
--- a/src/http/_res-fmt.js
+++ b/src/http/_res-fmt.js
@@ -1,45 +1,46 @@
-let httpError = require('./errors')
-let binaryTypes = require('./helpers/binary-types')
-let { brotliCompressSync: br, gzipSync: gzip } = require('zlib')
-let compressionTypes = { br, gzip }
+const httpError = require('./errors')
+const binaryTypes = require('./helpers/binary-types')
+const { brotliCompressSync: br, gzipSync: gzip } = require('node:zlib')
+const compressionTypes = { br, gzip }
 
-module.exports = function responseFormatter (req, params) {
-  let isError = params instanceof Error
+module.exports = function responseFormatter(req, params) {
+  const isError = params instanceof Error
 
   // Handle HTTP API v2.0 payload scenarios, which have some very strange edges
   if (req?.version === '2.0') {
     // New school AWS
-    let knownParams = [ 'statusCode', 'body', 'headers', 'isBase64Encoded', 'cookies' ]
-    let hasKnownParams = p => knownParams.some(k => k === p)
+    const knownParams = ['statusCode', 'body', 'headers', 'isBase64Encoded', 'cookies']
+    const hasKnownParams = (p) => knownParams.some((k) => k === p)
     // Old school Arc
-    let tidyParams = [ 'code', 'cookie', 'cors', 'location', 'session', 'status' ]
-    let hasTidyParams = p => tidyParams.some(k => k === p)
+    const tidyParams = ['code', 'cookie', 'cors', 'location', 'session', 'status']
+    const hasTidyParams = (p) => tidyParams.some((k) => k === p)
     // Older school Arc
-    let staticallyBound = [ 'html', 'css', 'js', 'text', 'json', 'xml' ]
-    let isStaticallyBound = p => staticallyBound.some(k => k === p)
+    const staticallyBound = ['html', 'css', 'js', 'text', 'json', 'xml']
+    const isStaticallyBound = (p) => staticallyBound.some((k) => k === p)
 
-    let is = t => typeof params === t
-    let keys = (params && is('object') && Object.keys(params)) || []
+    // biome-ignore lint/suspicious/useValidTypeof: we know what we are doing here
+    const is = (t) => typeof params === t
+    const keys = (params && is('object') && Object.keys(params)) || []
 
     // Handle scenarios where we have a known parameter returned
-    if (is('object') &&
-        !Array.isArray(params) &&
-        (keys.some(hasKnownParams) ||
-         keys.some(hasTidyParams) ||
-         keys.some(isStaticallyBound))) {
+    if (
+      is('object') &&
+      !Array.isArray(params) &&
+      (keys.some(hasKnownParams) || keys.some(hasTidyParams) || keys.some(isStaticallyBound))
+    ) {
       /* noop */
-    }
-
-    else if (isError) {
+    } else if (isError) {
       /* noop */
     }
 
     // Handle scenarios where arbitrary stuff is returned to be JSONified
-    else if (is('object') ||
-             is('number') ||
-             (is('string') && params.length) ||
-             Array.isArray(params) ||
-             params instanceof Buffer) {
+    else if (
+      is('object') ||
+      is('number') ||
+      (is('string') && params.length) ||
+      Array.isArray(params) ||
+      params instanceof Buffer
+    ) {
       params = { body: JSON.stringify(params) }
     }
 
@@ -50,7 +51,7 @@ module.exports = function responseFormatter (req, params) {
   }
 
   let buffer
-  let bodyIsBuffer = params?.body instanceof Buffer
+  const bodyIsBuffer = params?.body instanceof Buffer
   if (bodyIsBuffer) buffer = params.body // Back up buffer
   if (!isError) params = JSON.parse(JSON.stringify(params)) // Deep copy to aid testing mutation
   if (bodyIsBuffer) params.body = buffer // Restore non-JSON-encoded buffer
@@ -63,64 +64,57 @@ module.exports = function responseFormatter (req, params) {
   let body = params.body || ''
 
   // Headers: cache-control
-  let cacheControl = params.cacheControl ||
-                     params.headers?.['cache-control'] ||
-                     params.headers?.['Cache-Control'] || ''
+  const cacheControl =
+    params.cacheControl || params.headers?.['cache-control'] || params.headers?.['Cache-Control'] || ''
   if (params.headers?.['Cache-Control']) {
     delete params.headers['Cache-Control'] // Clean up improper casing
   }
 
   // Headers: content-type
-  let type = params.type ||
-             params.headers?.['content-type'] ||
-             params.headers?.['Content-Type'] ||
-             'application/json; charset=utf8'
+  let type =
+    params.type ||
+    params.headers?.['content-type'] ||
+    params.headers?.['Content-Type'] ||
+    'application/json; charset=utf8'
   if (params.headers?.['Content-Type']) {
     delete params.headers['Content-Type'] // Clean up improper casing
   }
 
   // Headers: content-encoding
-  let encoding = params.headers?.['content-encoding'] ||
-                 params.headers?.['Content-Encoding']
+  const encoding = params.headers?.['content-encoding'] || params.headers?.['Content-Encoding']
   if (params.headers?.['Content-Encoding']) {
     delete params.headers['Content-Encoding'] // Clean up improper casing
   }
-  let acceptEncoding = (req.headers?.['accept-encoding'] ||
-                        req.headers?.['Accept-Encoding'])
+  const acceptEncoding = req.headers?.['accept-encoding'] || req.headers?.['Accept-Encoding']
 
   // Cross-origin ritual sacrifice
-  let cors = params.cors
+  const cors = params.cors
 
   // Old school convenience response params
   // As of Functions v4 we will keep these around for all eternity
   if (params.html) {
     type = 'text/html; charset=utf8'
     body = params.html
-  }
-  else if (params.css) {
+  } else if (params.css) {
     type = 'text/css; charset=utf8'
     body = params.css
-  }
-  else if (params.js) {
+  } else if (params.js) {
     type = 'text/javascript; charset=utf8'
     body = params.js
-  }
-  else if (params.text) {
+  } else if (params.text) {
     type = 'text/plain; charset=utf8'
     body = params.text
-  }
-  else if (params.json) {
+  } else if (params.json) {
     type = 'application/json; charset=utf8'
     body = JSON.stringify(params.json)
-  }
-  else if (params.xml) {
+  } else if (params.xml) {
     type = 'application/xml; charset=utf8'
     body = params.xml
   }
 
   // Status
-  let providedStatus = params.status || params.code || params.statusCode
-  let statusCode = providedStatus || 200
+  const providedStatus = params.status || params.code || params.statusCode
+  const statusCode = providedStatus || 200
 
   let res = {
     headers: Object.assign({}, { 'content-type': type }, params.headers || {}),
@@ -139,9 +133,9 @@ module.exports = function responseFormatter (req, params) {
 
   // Error override
   if (isError) {
-    let statusCode = providedStatus || 500
-    let title = params.name
-    let message = `
+    const statusCode = providedStatus || 500
+    const title = params.name
+    const message = `
       ${params.message}<br>
       <pre>${params.stack}<pre>
     `
@@ -149,16 +143,16 @@ module.exports = function responseFormatter (req, params) {
   }
 
   // Set and/or update headers
-  let headers = res.headers
+  const headers = res.headers
   if (cacheControl) headers['cache-control'] = cacheControl
-  let antiCache = type.includes('text/html') ||
-                  type.includes('application/json') ||
-                  type.includes('application/vnd.api+json') ||
-                  params.location // Ensure CDNs don't cache location responses
+  const antiCache =
+    type.includes('text/html') ||
+    type.includes('application/json') ||
+    type.includes('application/vnd.api+json') ||
+    params.location // Ensure CDNs don't cache location responses
   if (headers && !headers['cache-control'] && antiCache) {
     headers['cache-control'] = 'no-cache, no-store, must-revalidate, max-age=0, s-maxage=0'
-  }
-  else if (headers && !headers['cache-control']) {
+  } else if (headers && !headers['cache-control']) {
     headers['cache-control'] = 'max-age=86400' // Default cache to one day unless otherwise specified
   }
   if (cors) headers['access-control-allow-origin'] = '*'
@@ -169,20 +163,21 @@ module.exports = function responseFormatter (req, params) {
   }
 
   // Handle body encoding (if necessary)
-  let [ contentType ] = (res.headers['content-type'] || '').split(';')
-  let isBinary = binaryTypes.includes(contentType)
-  let bodyIsString = typeof res.body === 'string'
-  let b64enc = i => new Buffer.from(i).toString('base64')
-  function compress (body, type) {
+  const [contentType] = (res.headers['content-type'] || '').split(';')
+  const isBinary = binaryTypes.includes(contentType)
+  const bodyIsString = typeof res.body === 'string'
+  const b64enc = (i) => new Buffer.from(i).toString('base64')
+  function compress(body, type) {
     res.headers['content-encoding'] = type
     return compressionTypes[type](body)
   }
 
   // Compress, encode, and flag buffer responses
   // Legacy API Gateway (REST, i.e. !req.version) and ASAP (which sets isBase64Encoded) handle their own compression, so don't double-compress / encode
-  let shouldCompress = req.version && !params.isBase64Encoded && !encoding && acceptEncoding && params.compression !== false
+  const shouldCompress =
+    req.version && !params.isBase64Encoded && !encoding && acceptEncoding && params.compression !== false
   if (bodyIsBuffer) {
-    let body = shouldCompress ? compress(res.body) : res.body
+    const body = shouldCompress ? compress(res.body) : res.body
     res.body = b64enc(body)
     res.isBase64Encoded = true
   }
@@ -192,7 +187,7 @@ module.exports = function responseFormatter (req, params) {
   }
   // Compress, encode, and flag string responses
   else if (bodyIsString && shouldCompress) {
-    let accepted = acceptEncoding.split(', ')
+    const accepted = acceptEncoding.split(', ')
     let compression
     /**/ if (accepted.includes('br')) compression = 'br'
     else if (accepted.includes('gzip')) compression = 'gzip'
diff --git a/src/http/csrf/create.js b/src/http/csrf/create.js
index b070b264..53a1b421 100644
--- a/src/http/csrf/create.js
+++ b/src/http/csrf/create.js
@@ -2,7 +2,7 @@ const crypto = require('node:crypto')
 const fiveMinutes = 300000
 
 /** creates a signed token [rando].[timestamp].[sig] */
-module.exports = function create (data, ts) {
+module.exports = function create(data, ts) {
   data = data || Buffer.from(crypto.randomUUID().replace(/-/g, ''))
   ts = ts || Date.now() + fiveMinutes
   const secret = process.env.ARC_APP_SECRET || process.env.ARC_APP_NAME || 'fallback'
diff --git a/src/http/csrf/verify.js b/src/http/csrf/verify.js
index ea4f6b1d..18a173c5 100644
--- a/src/http/csrf/verify.js
+++ b/src/http/csrf/verify.js
@@ -1,8 +1,8 @@
-let create = require('./create')
+const create = require('./create')
 
 /** ensures payload is valid token that hasn't expired */
-module.exports = function verify (payload) {
-  const [ data, ts, sig ] = payload.split('.')
+module.exports = function verify(payload) {
+  const [data, ts, sig] = payload.split('.')
   if (Date.now() > ts) return false
   const gen = create(data, ts)
   const sig2 = gen.split('.').pop()
diff --git a/src/http/errors/index.js b/src/http/errors/index.js
index 4638a543..21df3c75 100644
--- a/src/http/errors/index.js
+++ b/src/http/errors/index.js
@@ -1,15 +1,9 @@
 /**
  * HTTP error response generator and template
  */
-module.exports = function httpError (params) {
-  let {
-    statusCode = 502,
-    title = 'Unknown error',
-    message = '',
-  } = params
-  title = title === 'Error'
-    ? `${statusCode} error`
-    : `${statusCode} error: ${title}`
+module.exports = function httpError(params) {
+  let { statusCode = 502, title = 'Unknown error', message = '' } = params
+  title = title === 'Error' ? `${statusCode} error` : `${statusCode} error: ${title}`
   return {
     statusCode,
     headers: {
diff --git a/src/http/helpers/body-parser.js b/src/http/helpers/body-parser.js
index b374cc51..4406837f 100644
--- a/src/http/helpers/body-parser.js
+++ b/src/http/helpers/body-parser.js
@@ -1,58 +1,51 @@
-let qs = require('querystring')
+const qs = require('node:querystring')
 
 /**
  * Arc 6 bodies are always base64 encoded strings with req.isBase64Encoded = true (or null, which we interpolate into `{}`)
  * <Arc 6 bodies are always objects
  */
-module.exports = function parseBody (req) {
-  let ctype = req.headers['content-type'] || req.headers['Content-Type']
-  let passthru = !req.body || !req.headers || !ctype || (typeof req.body !== 'string' && !Object.keys(req.body).length)
+module.exports = function parseBody(req) {
+  const ctype = req.headers['content-type'] || req.headers['Content-Type']
+  const passthru =
+    !req.body || !req.headers || !ctype || (typeof req.body !== 'string' && !Object.keys(req.body).length)
   if (passthru) {
     return req.body
   }
-  else {
-    // Paranoid deep copy
-    let request = JSON.parse(JSON.stringify(req))
-    let headers = request.headers
-    // Note: content-type header may have multiple, comma-separated values. matching w/ includes may match to multiple different types
-    let contentType = type => headers?.['content-type']?.includes(type) || headers?.['Content-Type']?.includes(type)
+  // Paranoid deep copy
+  const request = JSON.parse(JSON.stringify(req))
+  const headers = request.headers
+  // Note: content-type header may have multiple, comma-separated values. matching w/ includes may match to multiple different types
+  const contentType = (type) => headers?.['content-type']?.includes(type) || headers?.['Content-Type']?.includes(type)
 
-    let isString = typeof request.body === 'string'
-    let isBase64 = request.isBase64Encoded
-    let isParsing = isString && isBase64
-    let isJSON = (contentType('application/json') || contentType('application/vnd.api+json')) && isString
-    let isFormURLEncoded = contentType('application/x-www-form-urlencoded') && isParsing
-    let isMultiPartFormData = contentType('multipart/form-data') && isParsing
-    let isOctetStream = contentType('application/octet-stream') && isParsing
-    let isPlainText = contentType('text/plain') && isParsing
-    let isXml = (contentType('text/xml') || contentType('application/xml')) && isParsing
+  const isString = typeof request.body === 'string'
+  const isBase64 = request.isBase64Encoded
+  const isParsing = isString && isBase64
+  const isJSON = (contentType('application/json') || contentType('application/vnd.api+json')) && isString
+  const isFormURLEncoded = contentType('application/x-www-form-urlencoded') && isParsing
+  const isMultiPartFormData = contentType('multipart/form-data') && isParsing
+  const isOctetStream = contentType('application/octet-stream') && isParsing
+  const isPlainText = contentType('text/plain') && isParsing
+  const isXml = (contentType('text/xml') || contentType('application/xml')) && isParsing
 
-    if (isJSON) {
-      try {
-        let data = isBase64
-          // Base64 + JSON-encoded payloads (>Arc 6 REST)
-          ? Buffer.from(request.body, 'base64').toString()
-          // Raw JSON (HTTP API + Lambda v2.0 payload)
-          : request.body
-        request.body = JSON.parse(data) || {}
-      }
-      catch {
-        throw Error('Invalid request body encoding or invalid JSON')
-      }
+  if (isJSON) {
+    try {
+      const data = isBase64
+        ? // Base64 + JSON-encoded payloads (>Arc 6 REST)
+          Buffer.from(request.body, 'base64').toString()
+        : // Raw JSON (HTTP API + Lambda v2.0 payload)
+          request.body
+      request.body = JSON.parse(data) || {}
+    } catch {
+      throw Error('Invalid request body encoding or invalid JSON')
     }
-    else if (isPlainText || isXml) {
-      request.body = new Buffer.from(request.body, 'base64').toString()
-    }
-    else if (isFormURLEncoded) {
-      let data = new Buffer.from(request.body, 'base64').toString()
-      request.body = qs.parse(data)
-    }
-    else if (isMultiPartFormData || isOctetStream) {
-      request.body = request.body.base64
-        ? request.body
-        : { base64: request.body }
-    }
-
-    return request.body
+  } else if (isPlainText || isXml) {
+    request.body = new Buffer.from(request.body, 'base64').toString()
+  } else if (isFormURLEncoded) {
+    const data = new Buffer.from(request.body, 'base64').toString()
+    request.body = qs.parse(data)
+  } else if (isMultiPartFormData || isOctetStream) {
+    request.body = request.body.base64 ? request.body : { base64: request.body }
   }
+
+  return request.body
 }
diff --git a/src/http/helpers/csrf.js b/src/http/helpers/csrf.js
index 95f17798..0b74dadf 100644
--- a/src/http/helpers/csrf.js
+++ b/src/http/helpers/csrf.js
@@ -1,10 +1,9 @@
-module.exports = function _csrf (req, res, next) {
-  var token = req.body?.csrf ? req.body.csrf : ''
-  var valid = req._verify(token)
+module.exports = function _csrf(req, res, next) {
+  const token = req.body?.csrf ? req.body.csrf : ''
+  const valid = req._verify(token)
   if (valid) {
     next()
-  }
-  else {
+  } else {
     res({
       status: 403,
       html: 'invalid csrf token',
diff --git a/src/http/helpers/params.js b/src/http/helpers/params.js
index f1e7ad7d..8cf72f25 100644
--- a/src/http/helpers/params.js
+++ b/src/http/helpers/params.js
@@ -1,18 +1,18 @@
-let unUndefined = [ 'body', 'pathParameters', 'queryStringParameters' ]
-let unNulled = [ 'body', 'pathParameters', 'queryStringParameters', 'multiValueQueryStringParameters' ]
-let pathParams = /\{\w+\}/g
+const unUndefined = ['body', 'pathParameters', 'queryStringParameters']
+const unNulled = ['body', 'pathParameters', 'queryStringParameters', 'multiValueQueryStringParameters']
+const pathParams = /\{\w+\}/g
 
-module.exports = function interpolateParams (req) {
+module.exports = function interpolateParams(req) {
   // Make the raw body accessible, handy for use with external libraries
   if (req.body) req.rawBody = req.body
 
   // Handle HTTP API v2.0 payload scenarios, which omit params instead of passing them as null
   if (req?.version === '2.0') {
-    let { requestContext: context } = req
+    const { requestContext: context } = req
     if (context?.http?.method) {
       req.httpMethod = context.http.method
     }
-    unUndefined.forEach(i => {
+    unUndefined.forEach((i) => {
       if (req[i] === undefined) req[i] = {}
     })
     // Expect 'GET /foo' or '$default'
@@ -22,21 +22,21 @@ module.exports = function interpolateParams (req) {
   }
 
   // Un-null APIG-proxy-Lambda params in 6+
-  unNulled.forEach(i => {
+  unNulled.forEach((i) => {
     if (req[i] === null) req[i] = {}
   })
 
   // Convenient params commonplace in other web servers
   if (!req.method) req.method = req.httpMethod
   if (!req.params) req.params = req.pathParameters
-  if (!req.query)  req.query  = req.queryStringParameters
+  if (!req.query) req.query = req.queryStringParameters
 
   // Convenient path parameter interpolation; 6+ REST gets this for free in `req.path`
   if (pathParams.test(req.path)) {
-    let matches = req.path.match(pathParams)
-    let vars = matches.map(a => a.replace(/\{|\}/g, ''))
+    const matches = req.path.match(pathParams)
+    const vars = matches.map((a) => a.replace(/\{|\}/g, ''))
     let idx = 0
-    matches.forEach(m => {
+    matches.forEach((m) => {
       req.path = req.path.replace(m, req.params[vars[idx]])
       idx += 1
     })
diff --git a/src/http/helpers/url.js b/src/http/helpers/url.js
index 42eab8b8..f60942d2 100644
--- a/src/http/helpers/url.js
+++ b/src/http/helpers/url.js
@@ -6,11 +6,10 @@
  * - `/staging` if ARC_ENV === staging
  * - `/production` if ARC_ENV === production
  */
-module.exports = function url (url) {
-  let { ARC_ENV, ARC_LOCAL } = process.env
-  let staging = ARC_ENV === 'staging'
-  let production = ARC_ENV === 'production'
-  if (!ARC_LOCAL && (staging || production))
-    return `/${ARC_ENV}${url}`
-  return url // fallthru for ARC_ENV=testing
+module.exports = function url(_url) {
+  const { ARC_ENV, ARC_LOCAL } = process.env
+  const staging = ARC_ENV === 'staging'
+  const production = ARC_ENV === 'production'
+  if (!ARC_LOCAL && (staging || production)) return `/${ARC_ENV}${_url}`
+  return _url // fallthru for ARC_ENV=testing
 }
diff --git a/src/http/index.js b/src/http/index.js
index 7a6480a1..f15b23d8 100644
--- a/src/http/index.js
+++ b/src/http/index.js
@@ -1,28 +1,27 @@
-let read = require('./session/read')
-let write = require('./session/write')
-let bodyParser = require('./helpers/body-parser')
-let interpolate = require('./helpers/params')
-let url = require('./helpers/url')
-let responseFormatter = require('./_res-fmt')
-let create = require('./csrf/create')
-let verify = require('./csrf/verify')
+const read = require('./session/read')
+const write = require('./session/write')
+const bodyParser = require('./helpers/body-parser')
+const interpolate = require('./helpers/params')
+const url = require('./helpers/url')
+const responseFormatter = require('./_res-fmt')
+const create = require('./csrf/create')
+const verify = require('./csrf/verify')
 
 // Unified async / callback HTTP handler
-function httpHandler (isAsync, ...fns) {
-
+function httpHandler(isAsync, ...fns) {
   // Ensure we've been passed only functions
-  fns.forEach(fn => {
-    if (typeof fn !== 'function') throw TypeError(fn + ' not a function')
+  fns.forEach((fn) => {
+    if (typeof fn !== 'function') throw TypeError(`${fn} not a function`)
   })
   // Override arc.http using callbacks by passing async functions
   isAsync = isAsync || fns[0].constructor.name === 'AsyncFunction'
 
   if (isAsync) {
     // Return an AWS Lambda async function signature
-    return async function lambda (request, context) {
+    return async function lambda(request, context) {
       let params
       let first = true
-      for (let fn of fns) {
+      for (const fn of fns) {
         if (fn.constructor.name !== 'AsyncFunction') {
           throw TypeError('All arc.http middleware functions must be async')
         }
@@ -30,14 +29,14 @@ function httpHandler (isAsync, ...fns) {
         // Only parse the request obj of the first function
         if (first) {
           first = false
-          let session = await read(request)
-          let req = interpolate(Object.assign(request, { session }))
+          const session = await read(request)
+          const req = interpolate(Object.assign(request, { session }))
           req.body = bodyParser(req)
           request = req
         }
         // Run the function
-        let result = await fn(request, context)
-        let isRequest = result?.httpMethod
+        const result = await fn(request, context)
+        const isRequest = result?.httpMethod
         // Function returned a modified request, continuing...
         if (isRequest) request = result
         else {
@@ -49,46 +48,45 @@ function httpHandler (isAsync, ...fns) {
           // Did not get a result from, continuing...
         }
       }
-      let isHTTPv2 = request?.version === '2.0'
+      const isHTTPv2 = request?.version === '2.0'
       // Finished combined function!
       if (!params && !isHTTPv2) {
-        throw new Error(`Finished all functions without returning a response.`)
+        throw new Error('Finished all functions without returning a response.')
       }
       return asyncResponse(request, params)
     }
   }
-  else {
-    // Return an AWS Lambda continuation passing function signature
-    return function lambda (request, context, callback) {
-
-      // Cache the functions
-      let cache = fns.slice()
-
-      // read the session
-      read(request, function _read (err, session) {
-        // Fail loudly if the session isn't set up correctly
-        if (err) throw err
-
-        // Construct a response function
-        let req = interpolate(Object.assign(request, { session }))
-        req.body = bodyParser(req)
-        let res = response.bind({}, req, callback)
-
-        // Loop through middleware
-        function fail () { throw Error('next() called from last function') }
-        (function iterator (fn) {
-          if (fn.constructor.name !== 'Function') {
-            throw TypeError('All arc.http middleware functions must be continuation passing (callback)')
-          }
+  // Return an AWS Lambda continuation passing function signature
+  return function lambda(request, context, callback) {
+    // Cache the functions
+    const cache = fns.slice()
+
+    // read the session
+    read(request, function _read(err, session) {
+      // Fail loudly if the session isn't set up correctly
+      if (err) throw err
+
+      // Construct a response function
+      const req = interpolate(Object.assign(request, { session }))
+      req.body = bodyParser(req)
+      const res = response.bind({}, req, callback)
+
+      // Loop through middleware
+      function fail() {
+        throw Error('next() called from last function')
+      }
+      ;(function iterator(fn) {
+        if (fn.constructor.name !== 'Function') {
+          throw TypeError('All arc.http middleware functions must be continuation passing (callback)')
+        }
 
-          let next = iterator.bind({}, cache.shift() || fail)
-          fn.call({}, req, res, next)
-        })(cache.shift())
-      })
-    }
+        const next = iterator.bind({}, cache.shift() || fail)
+        fn.call({}, req, res, next)
+      })(cache.shift())
+    })
   }
 }
-let http = httpHandler.bind({}, false)
+const http = httpHandler.bind({}, false)
 http.async = httpHandler.bind({}, true)
 
 // Helpers
@@ -105,29 +103,29 @@ module.exports = http
 /**
  * Response formatter & session helpers
  */
-async function asyncResponse (req, params) {
+async function asyncResponse(req, params) {
   // Format the response
-  let res = responseFormatter(req, params)
+  const res = responseFormatter(req, params)
 
   // Legacy 'cookie' parameter, used after direct session writes
-  if (params && params.cookie) {
+  if (params?.cookie) {
     res.headers['set-cookie'] = params.cookie
   }
 
   // Save the passed session
   if (params?.session) {
     // Tag the session data with _idx, secret, ttl, from req.session
-    let { _idx, _secret, _ttl } = req.session
-    let session = { _idx, _secret, _ttl, ...params.session }
-    let cookie = await write(session)
+    const { _idx, _secret, _ttl } = req.session
+    const session = { _idx, _secret, _ttl, ...params.session }
+    const cookie = await write(session)
     res.headers['set-cookie'] = cookie
   }
   return res
 }
 
-function response (req, callback, params) {
+function response(req, callback, params) {
   // Format the response
-  let res = responseFormatter(req, params)
+  const res = responseFormatter(req, params)
 
   // Legacy 'cookie' parameter, used after direct session writes
   if (params?.cookie) {
@@ -137,17 +135,16 @@ function response (req, callback, params) {
   // Save the passed session
   if (params?.session) {
     // Tag the session data with _idx, secret, ttl, from req.session
-    let { _idx, _secret, _ttl } = req.session
-    let session = { _idx, _secret, _ttl, ...params.session }
-    write(session, function _write (err, cookie) {
+    const { _idx, _secret, _ttl } = req.session
+    const session = { _idx, _secret, _ttl, ...params.session }
+    write(session, function _write(err, cookie) {
       if (err) callback(err)
       else {
         res.headers['set-cookie'] = cookie
         callback(null, res)
       }
     })
-  }
-  else {
+  } else {
     // Just pass it through
     callback(null, res)
   }
diff --git a/src/http/session/providers/_get-idx.js b/src/http/session/providers/_get-idx.js
index e830baf1..286716ab 100644
--- a/src/http/session/providers/_get-idx.js
+++ b/src/http/session/providers/_get-idx.js
@@ -1,9 +1,9 @@
 // Takes a client cookie string and finds the last _idx key/value
-module.exports = function getIdx (cookie = '') {
-  let cookies = cookie
+module.exports = function getIdx(cookie = '') {
+  const cookies = cookie
     .split(';')
-    .map(c => c.trim())
+    .map((c) => c.trim())
     .filter(Boolean)
-  let session = cookies.reverse().find(c => c.startsWith('_idx='))
+  const session = cookies.reverse().find((c) => c.startsWith('_idx='))
   return session || ''
 }
diff --git a/src/http/session/providers/ddb/_week-from-now.js b/src/http/session/providers/ddb/_week-from-now.js
index 1e6551a9..08a543b7 100644
--- a/src/http/session/providers/ddb/_week-from-now.js
+++ b/src/http/session/providers/ddb/_week-from-now.js
@@ -1,6 +1,6 @@
 // epoch + one week IN SECONDS
 // - Date.now() returns ms
 // - DynamoDB TTL is an integer in seconds
-module.exports = function _weekFromNow () {
+module.exports = function _weekFromNow() {
   return Math.floor(Date.now() / 1000) + 604800
 }
diff --git a/src/http/session/providers/ddb/create.js b/src/http/session/providers/ddb/create.js
index fd4d9029..4a637d13 100644
--- a/src/http/session/providers/ddb/create.js
+++ b/src/http/session/providers/ddb/create.js
@@ -1,36 +1,42 @@
-let uid = require('uid-safe')
-let week = require('./_week-from-now')
-let crsf = require('csrf')
-let parallel = require('run-parallel')
+const uid = require('uid-safe')
+const week = require('./_week-from-now')
+const crsf = require('csrf')
+const parallel = require('run-parallel')
 
-module.exports = function _create (name, payload, callback) {
-  let { tables } = require('../../../../')
+module.exports = function _create(name, payload, callback) {
+  const { tables } = require('../../../../')
 
-  parallel([
-    function _key (callback) {
-      uid(18, function _uid (err, val) {
+  parallel(
+    [
+      function _key(callback) {
+        uid(18, function _uid(err, val) {
+          if (err) callback(err)
+          else callback(null, { _idx: val })
+        })
+      },
+      function _secret(callback) {
+        new crsf().secret(function _uid(err, val) {
+          if (err) callback(err)
+          else callback(null, { _secret: val })
+        })
+      },
+    ],
+    function _put(err, results) {
+      if (err) throw err
+      results.push({ _ttl: week() })
+      const keys = results.reduce((a, b) => Object.assign(a, b))
+      const session = Object.assign(payload, keys)
+      tables({}, (err, data) => {
         if (err) callback(err)
-        else callback(null, { _idx: val })
+        else
+          data._client
+            .PutItem({
+              TableName: name,
+              Item: session,
+            })
+            .then(() => callback(null, session))
+            .catch(callback)
       })
     },
-    function _secret (callback) {
-      (new crsf).secret(function _uid (err, val) {
-        if (err) callback(err)
-        else callback(null, { _secret: val })
-      })
-    },
-  ],
-  function _put (err, results) {
-    if (err) throw err
-    results.push({ _ttl: week() })
-    let keys = results.reduce((a, b) => Object.assign(a, b))
-    let session = Object.assign(payload, keys)
-    tables({}, (err, data) => {
-      if (err) callback(err)
-      else data._client.PutItem({
-        TableName: name,
-        Item: session,
-      }).then(() => callback(null, session)).catch(callback)
-    })
-  })
+  )
 }
diff --git a/src/http/session/providers/ddb/find.js b/src/http/session/providers/ddb/find.js
index 0d663824..cf4db9cc 100644
--- a/src/http/session/providers/ddb/find.js
+++ b/src/http/session/providers/ddb/find.js
@@ -1,24 +1,25 @@
-let create = require('./create')
+const create = require('./create')
 
-module.exports = function _find (name, _idx, callback) {
-  let { tables } = require('../../../../')
+module.exports = function _find(name, _idx, callback) {
+  const { tables } = require('../../../../')
 
   tables({}, (err, data) => {
     if (err) callback(err)
-    else data._client.GetItem({
-      TableName: name,
-      ConsistentRead: true,
-      Key: { _idx },
-    })
-      .then(item => {
-        let result = typeof item === 'undefined' ? false : item.Item
-        if (result?._secret) {
-          callback(null, result)
-        }
-        else {
-          create(name, {}, callback)
-        }
-      })
-      .catch(callback)
+    else
+      data._client
+        .GetItem({
+          TableName: name,
+          ConsistentRead: true,
+          Key: { _idx },
+        })
+        .then((item) => {
+          const result = typeof item === 'undefined' ? false : item.Item
+          if (result?._secret) {
+            callback(null, result)
+          } else {
+            create(name, {}, callback)
+          }
+        })
+        .catch(callback)
   })
 }
diff --git a/src/http/session/providers/ddb/index.js b/src/http/session/providers/ddb/index.js
index 3e5fa04e..abd76f2a 100644
--- a/src/http/session/providers/ddb/index.js
+++ b/src/http/session/providers/ddb/index.js
@@ -1,11 +1,11 @@
-let cookie = require('cookie')
-let getIdx = require('../_get-idx')
-let { unsign, sign } = require('cookie-signature')
-
-let discovery = require('../../../../discovery')
-let find = require('./find')
-let create = require('./create')
-let update = require('./update')
+const cookie = require('cookie')
+const getIdx = require('../_get-idx')
+const { unsign, sign } = require('cookie-signature')
+
+const discovery = require('../../../../discovery')
+const find = require('./find')
+const create = require('./create')
+const update = require('./update')
 let sessionTable
 
 module.exports = { read, write }
@@ -13,50 +13,45 @@ module.exports = { read, write }
 /**
  * reads request for session cookie and looks it up in dynamo
  */
-function read (request, callback) {
-  let {
-    ARC_APP_NAME,
-    ARC_APP_SECRET,
-    ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME,
-  } = process.env
+function read(request, callback) {
+  const { ARC_APP_NAME, ARC_APP_SECRET, ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME } = process.env
 
   // be async/await friendly
   let promise
   if (!callback) {
-    promise = new Promise(function (res, rej) {
-      callback = function (err, result) {
+    promise = new Promise((res, rej) => {
+      callback = (err, result) => {
         err ? rej(err) : res(result)
       }
     })
   }
 
   // read dynamo session table
-  let name = ARC_SESSION_TABLE_NAME || SESSION_TABLE_NAME
+  const name = ARC_SESSION_TABLE_NAME || SESSION_TABLE_NAME
   if (name) {
-    let secret = ARC_APP_SECRET || ARC_APP_NAME || 'fallback'
+    const secret = ARC_APP_SECRET || ARC_APP_NAME || 'fallback'
     let rawCookie = request.headers?.cookie || request.headers?.Cookie
     // Lambda payload version 2 puts the cookies in an array on the request
     if (!rawCookie && request.cookies) {
       rawCookie = request.cookies.join(';')
     }
 
-    let idx = getIdx(rawCookie)
-    let sesh = cookie.parse(idx)._idx
-    let valid = unsign(sesh || '', secret)
+    const idx = getIdx(rawCookie)
+    const sesh = cookie.parse(idx)._idx
+    const valid = unsign(sesh || '', secret)
 
-    function findOrCreate (err) {
+    function findOrCreate(err) {
       if (err) return callback(err)
 
       // Find or create a new session
-      let exec = sesh && valid ? find.bind({}, sessionTable) : create.bind({}, sessionTable)
-      let params = sesh && valid ? valid : {}
+      const exec = sesh && valid ? find.bind({}, sessionTable) : create.bind({}, sessionTable)
+      const params = sesh && valid ? valid : {}
 
       exec(params, callback)
     }
     if (sessionTable) findOrCreate()
     else getSessionTable(name, findOrCreate)
-  }
-  else callback()
+  } else callback()
 
   return promise
 }
@@ -66,44 +61,47 @@ function read (request, callback) {
  * - _idx
  * - _secret
  */
-function write (params, callback) {
-  let {
+function write(params, callback) {
+  const {
     ARC_APP_NAME,
     ARC_APP_SECRET,
     ARC_ENV,
-    ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME,
-    ARC_SESSION_DOMAIN, SESSION_DOMAIN,
+    ARC_SESSION_TABLE_NAME,
+    SESSION_TABLE_NAME,
+    ARC_SESSION_DOMAIN,
+    SESSION_DOMAIN,
     ARC_SESSION_SAME_SITE,
-    ARC_SESSION_TTL, SESSION_TTL,
+    ARC_SESSION_TTL,
+    SESSION_TTL,
   } = process.env
 
   // be async/await friendly
   let promise
   if (!callback) {
-    promise = new Promise(function (res, rej) {
-      callback = function (err, result) {
+    promise = new Promise((res, rej) => {
+      callback = (err, result) => {
         err ? rej(err) : res(result)
       }
     })
   }
 
   // Read DynamoDB session table
-  let name = ARC_SESSION_TABLE_NAME || SESSION_TABLE_NAME
+  const name = ARC_SESSION_TABLE_NAME || SESSION_TABLE_NAME
   if (name) {
-    let secret = ARC_APP_SECRET || ARC_APP_NAME || 'fallback'
+    const secret = ARC_APP_SECRET || ARC_APP_NAME || 'fallback'
 
-    function updateSession (err) {
+    function updateSession(err) {
       if (err) return callback(err)
 
-      update(sessionTable, params, function _update (err) {
+      update(sessionTable, params, function _update(err) {
         if (err) return callback(err)
 
-        let twentyFiveYears = 7.884e+8
-        let maxAge = Number(ARC_SESSION_TTL || SESSION_TTL || twentyFiveYears)
-        let sameSite = ARC_SESSION_SAME_SITE || 'lax'
-        let options = {
+        const twentyFiveYears = 7.884e8
+        const maxAge = Number(ARC_SESSION_TTL || SESSION_TTL || twentyFiveYears)
+        const sameSite = ARC_SESSION_SAME_SITE || 'lax'
+        const options = {
           maxAge,
-          expires: new Date(Date.now() + (maxAge * 1000)),
+          expires: new Date(Date.now() + maxAge * 1000),
           secure: true,
           httpOnly: true,
           path: '/',
@@ -115,32 +113,30 @@ function write (params, callback) {
         if (ARC_ENV === 'testing') {
           delete options.secure
         }
-        let result = cookie.serialize('_idx', sign(params._idx, secret), options)
+        const result = cookie.serialize('_idx', sign(params._idx, secret), options)
         callback(null, result)
       })
     }
 
     if (sessionTable) updateSession()
     else getSessionTable(name, updateSession)
-  }
-  else callback()
+  } else callback()
 
   return promise
 }
 
-function getSessionTable (name, callback) {
+function getSessionTable(name, callback) {
   discovery((err, services) => {
     if (err) callback(err)
     else {
-      let { tables = {} } = services
+      const { tables = {} } = services
       // Tables services: key would be logical table name, value would be physical
-      sessionTable = tables[name] || Object.values(tables).find(v => v === name)
+      sessionTable = tables[name] || Object.values(tables).find((v) => v === name)
 
       if (!sessionTable) {
-        let err = ReferenceError(`Session table name '${name}' could not be found`)
+        const err = ReferenceError(`Session table name '${name}' could not be found`)
         callback(err)
-      }
-      else callback()
+      } else callback()
     }
   })
 }
diff --git a/src/http/session/providers/ddb/update.js b/src/http/session/providers/ddb/update.js
index dacaed45..6c9ff166 100644
--- a/src/http/session/providers/ddb/update.js
+++ b/src/http/session/providers/ddb/update.js
@@ -1,14 +1,18 @@
-let week = require('./_week-from-now')
+const week = require('./_week-from-now')
 
-module.exports = function _update (name, payload, callback) {
-  let { tables } = require('../../../../')
-  let _ttl = week()
-  let session = Object.assign(payload, { _ttl })
+module.exports = function _update(name, payload, callback) {
+  const { tables } = require('../../../../')
+  const _ttl = week()
+  const session = Object.assign(payload, { _ttl })
   tables({}, (err, data) => {
     if (err) callback(err)
-    else data._client.PutItem({
-      TableName: name,
-      Item: session,
-    }).then(() => callback(null, session)).catch(callback)
+    else
+      data._client
+        .PutItem({
+          TableName: name,
+          Item: session,
+        })
+        .then(() => callback(null, session))
+        .catch(callback)
   })
 }
diff --git a/src/http/session/providers/jwe.js b/src/http/session/providers/jwe.js
index 106ab2c9..3b57dc05 100644
--- a/src/http/session/providers/jwe.js
+++ b/src/http/session/providers/jwe.js
@@ -1,8 +1,8 @@
-let getIdx = require('./_get-idx')
-let cookie = require('cookie')
-let jwt = require('node-webtokens')
-let alg = 'dir'
-let algos = {
+const getIdx = require('./_get-idx')
+const cookie = require('cookie')
+const jwt = require('node-webtokens')
+const alg = 'dir'
+const algos = {
   // 256 bit (32 octet) key size
   A256GCM: '12345678901234567890123456789012',
   // 192 bit (24 octet) key size
@@ -10,39 +10,38 @@ let algos = {
   // 128 bit (16 octet) key size
   A128GCM: '1234567890123456',
 }
-let enc, key
+let enc
+let key
 
-function setupCrypto () {
-  let { ARC_APP_SECRET, ARC_APP_SECRET_ALGO, ARC_FORCE_LEGACY_JWE_SECRET } = process.env
+function setupCrypto() {
+  const { ARC_APP_SECRET, ARC_APP_SECRET_ALGO, ARC_FORCE_LEGACY_JWE_SECRET } = process.env
 
   enc = ARC_APP_SECRET_ALGO || 'A256GCM'
   if (!algos[enc]) {
-    let err = `Invalid token algorithm, must be one of: ${Object.keys(algos).join(', ')}`
+    const err = `Invalid token algorithm, must be one of: ${Object.keys(algos).join(', ')}`
     throw ReferenceError(err)
   }
 
   // Strongly encourage setting ARC_APP_SECRET, fall back to something dumb and compatible
-  let secret = ARC_APP_SECRET ? ARC_APP_SECRET.substring(0, algos[enc].length) : algos[enc]
+  const secret = ARC_APP_SECRET ? ARC_APP_SECRET.substring(0, algos[enc].length) : algos[enc]
   key = Buffer.from(secret).toString('base64')
 
   // Backward compat for legacy <7 code path
   if (ARC_FORCE_LEGACY_JWE_SECRET) {
     enc = 'A128GCM'
     key = ARC_APP_SECRET /* ← known boog */ || Buffer.from(algos[enc]).toString('base64')
-  }
-  else if (secret.length !== algos[enc].length) {
+  } else if (secret.length !== algos[enc].length) {
     throw ReferenceError(`Invalid secret length, ${enc} must supply a ${algos[enc].length} bit ascii key`)
   }
 }
 
-
 // wrapper for jwe.create/jwe.parse
-let jwe = {
-  create (payload) {
+const jwe = {
+  create(payload) {
     setupCrypto()
     return jwt.generate(alg, enc, payload, key)
   },
-  parse (token) {
+  parse(token) {
     setupCrypto()
     const WEEK = 604800
     return jwt.parse(token).setTokenLifetime(WEEK).verify(key)
@@ -52,11 +51,11 @@ let jwe = {
 /**
  * reads req cookie and returns token payload or an empty object
  */
-function read (req, callback) {
+function read(req, callback) {
   let promise
   if (!callback) {
-    promise = new Promise(function argh (res, rej) {
-      callback = function errback (err, result) {
+    promise = new Promise(function argh(res, rej) {
+      callback = function errback(err, result) {
         err ? rej(err) : res(result)
       }
     })
@@ -67,9 +66,9 @@ function read (req, callback) {
     rawCookie = req.cookies.join(';')
   }
 
-  let idx = getIdx(rawCookie)
-  let sesh = cookie.parse(idx)._idx
-  let token = jwe.parse(sesh)
+  const idx = getIdx(rawCookie)
+  const sesh = cookie.parse(idx)._idx
+  const token = jwe.parse(sesh)
   callback(null, token.valid ? token.payload : {})
   return promise
 }
@@ -77,29 +76,25 @@ function read (req, callback) {
 /**
  * creates a Set-Cookie header with token payload encrypted
  */
-function write (payload, callback) {
-  let {
-    ARC_ENV,
-    ARC_SESSION_DOMAIN, SESSION_DOMAIN,
-    ARC_SESSION_SAME_SITE,
-    ARC_SESSION_TTL, SESSION_TTL,
-  } = process.env
+function write(payload, callback) {
+  const { ARC_ENV, ARC_SESSION_DOMAIN, SESSION_DOMAIN, ARC_SESSION_SAME_SITE, ARC_SESSION_TTL, SESSION_TTL } =
+    process.env
   let promise
   if (!callback) {
-    promise = new Promise(function ugh (res, rej) {
-      callback = function errback (err, result) {
+    promise = new Promise(function ugh(res, rej) {
+      callback = function errback(err, result) {
         err ? rej(err) : res(result)
       }
     })
   }
-  let key = '_idx'
-  let val = jwe.create(payload)
-  let twentyFiveYears = 7.884e+8
-  let maxAge = Number(ARC_SESSION_TTL || SESSION_TTL || twentyFiveYears)
-  let sameSite = ARC_SESSION_SAME_SITE || 'lax'
-  let options = {
+  const key = '_idx'
+  const val = jwe.create(payload)
+  const twentyFiveYears = 7.884e8
+  const maxAge = Number(ARC_SESSION_TTL || SESSION_TTL || twentyFiveYears)
+  const sameSite = ARC_SESSION_SAME_SITE || 'lax'
+  const options = {
     maxAge,
-    expires: new Date(Date.now() + (maxAge * 1000)),
+    expires: new Date(Date.now() + maxAge * 1000),
     secure: true,
     httpOnly: true,
     path: '/',
diff --git a/src/http/session/read.js b/src/http/session/read.js
index 3cd49e30..5ac73c55 100644
--- a/src/http/session/read.js
+++ b/src/http/session/read.js
@@ -1,9 +1,9 @@
-let jwe = require('./providers/jwe')
-let ddb = require('./providers/ddb')
+const jwe = require('./providers/jwe')
+const ddb = require('./providers/ddb')
 
-module.exports = function read (request, callback) {
-  let { ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME } = process.env
-  if ([ ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME ].includes('jwe')) {
+module.exports = function read(request, callback) {
+  const { ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME } = process.env
+  if ([ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME].includes('jwe')) {
     return jwe.read(request, callback)
   }
   return ddb.read(request, callback)
diff --git a/src/http/session/write.js b/src/http/session/write.js
index ce6265d9..aa8d1d69 100644
--- a/src/http/session/write.js
+++ b/src/http/session/write.js
@@ -1,9 +1,9 @@
-let jwe = require('./providers/jwe')
-let ddb = require('./providers/ddb')
+const jwe = require('./providers/jwe')
+const ddb = require('./providers/ddb')
 
-module.exports = function write (params, callback) {
-  let { ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME } = process.env
-  if ([ ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME ].includes('jwe')) {
+module.exports = function write(params, callback) {
+  const { ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME } = process.env
+  if ([ARC_SESSION_TABLE_NAME, SESSION_TABLE_NAME].includes('jwe')) {
     return jwe.write(params, callback)
   }
   return ddb.write(params, callback)
diff --git a/src/index.js b/src/index.js
index b02ca20b..af54ebc2 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,44 +1,44 @@
-let { sandboxVersionAtLeast } = require('./lib')
+const { sandboxVersionAtLeast } = require('./lib')
 
 /**
  * Ensure env is one of: 'testing', 'staging', or 'production'
  * If in Sandbox, meet version requirements
  */
 let { ARC_ENV, ARC_SANDBOX } = process.env
-let validEnvs = [ 'testing', 'staging', 'production' ]
+const validEnvs = ['testing', 'staging', 'production']
 // Backfill ARC_ENV if Functions is running outside of Sandbox in a test suite
 if (!ARC_ENV) {
   process.env.ARC_ENV = ARC_ENV = 'testing'
 }
 if (!validEnvs.includes(ARC_ENV)) {
-  throw ReferenceError(`ARC_ENV env var is required for use with @architect/functions`)
+  throw ReferenceError('ARC_ENV env var is required for use with @architect/functions')
 }
 if (ARC_SANDBOX && !sandboxVersionAtLeast('5.0.0')) {
   throw ReferenceError('Incompatible version: please upgrade to Sandbox >=5.x or Architect >=10.x')
 }
 
-let http = require('./http')
-let _static = require('./static')
-let serviceDiscovery = require('./discovery')
-let ws = require('./ws')
+const http = require('./http')
+const _static = require('./static')
+const serviceDiscovery = require('./discovery')
+const ws = require('./ws')
 
 let services
-let arc = {
+const arc = {
   http,
   static: _static,
   ws,
-  services: function () {
-    return new Promise(function (resolve, reject) {
+  services: () =>
+    new Promise((resolve, reject) => {
       if (services) resolve(services)
-      else serviceDiscovery(function (err, serviceMap) {
-        if (err) reject(err)
-        else {
-          services = serviceMap
-          resolve(services)
-        }
-      })
-    })
-  },
+      else
+        serviceDiscovery((err, serviceMap) => {
+          if (err) reject(err)
+          else {
+            services = serviceMap
+            resolve(services)
+          }
+        })
+    }),
 }
 arc.events = require('./events')(arc, 'events')
 arc.queues = require('./events')(arc, 'queues')
diff --git a/src/lib/_get-ports.js b/src/lib/_get-ports.js
index ccfb2f0b..53bfdb18 100644
--- a/src/lib/_get-ports.js
+++ b/src/lib/_get-ports.js
@@ -1,13 +1,13 @@
 let cache
-module.exports = function getPorts (callback) {
-  let { ARC_SANDBOX } = process.env
-  let notFound = ReferenceError('Sandbox internal port not found')
+module.exports = function getPorts(callback) {
+  const { ARC_SANDBOX } = process.env
+  const notFound = ReferenceError('Sandbox internal port not found')
   if (cache) {
     return callback(null, cache)
   }
   // Sandbox env var is the happy path for Lambda runs
   if (ARC_SANDBOX) {
-    let { ports } = JSON.parse(ARC_SANDBOX)
+    const { ports } = JSON.parse(ARC_SANDBOX)
     if (!ports) {
       return callback(notFound)
     }
@@ -18,14 +18,14 @@ module.exports = function getPorts (callback) {
   else {
     // Require in here or circular dep warnings may occur
 
-    let discovery = require('../discovery')
+    const discovery = require('../discovery')
     discovery((err, services) => {
       if (err) callback(err)
       else {
         if (!services.ARC_SANDBOX || !services.ARC_SANDBOX.ports) {
           return callback(notFound)
         }
-        let ports = JSON.parse(services.ARC_SANDBOX.ports)
+        const ports = JSON.parse(services.ARC_SANDBOX.ports)
         cache = ports
         callback(null, ports)
       }
diff --git a/src/lib/_sandbox-version.js b/src/lib/_sandbox-version.js
index 725993d7..a9718097 100644
--- a/src/lib/_sandbox-version.js
+++ b/src/lib/_sandbox-version.js
@@ -1,10 +1,11 @@
-function sandboxVersionAtLeast (version) {
+function sandboxVersionAtLeast(version) {
   if (!process.env.ARC_SANDBOX) return false
   try {
-    var sandboxData = JSON.parse(process.env.ARC_SANDBOX)
-  }
-  catch (e) {
-    console.error(`Unable to parse ARC_SANDBOX "${process.env.ARC_SANDBOX}" failed with "${e.message}" please report this bug.`)
+    const sandboxData = JSON.parse(process.env.ARC_SANDBOX)
+  } catch (e) {
+    console.error(
+      `Unable to parse ARC_SANDBOX "${process.env.ARC_SANDBOX}" failed with "${e.message}" please report this bug.`,
+    )
   }
 
   if (!sandboxData.version) {
@@ -13,17 +14,17 @@ function sandboxVersionAtLeast (version) {
   return versionGTE(sandboxData.version, version)
 }
 
-let versionGTE = (left, right) => {
+const versionGTE = (left, right) => {
   if (left === right) {
     return true
   }
-  let leftVersions = left.split('.')
-  let rightVersions = right.split('.')
-  for (let [ index, version ] of leftVersions.entries()) {
+  const leftVersions = left.split('.')
+  const rightVersions = right.split('.')
+  for (const [index, version] of leftVersions.entries()) {
     if (version > rightVersions[index]) {
       return true
     }
-    else if (version < rightVersions[index]) {
+    if (version < rightVersions[index]) {
       return false
     }
   }
diff --git a/src/lib/index.js b/src/lib/index.js
index eb0b7691..236931be 100644
--- a/src/lib/index.js
+++ b/src/lib/index.js
@@ -1,29 +1,28 @@
-let getPorts = require('./_get-ports')
-let sandboxVersionAtLeast = require('./_sandbox-version')
+const getPorts = require('./_get-ports')
+const sandboxVersionAtLeast = require('./_sandbox-version')
 
-let isNode18 = Number(process.version.replace('v', '').split('.')[0]) >= 18
+const isNode18 = Number(process.version.replace('v', '').split('.')[0]) >= 18
 
-let nonLocalEnvs = [ 'staging', 'production' ]
+const nonLocalEnvs = ['staging', 'production']
 
-function getAwsClient (params, callback) {
-  let awsLite = require('@aws-lite/client')
+function getAwsClient(params, callback) {
+  const awsLite = require('@aws-lite/client')
   params.region = process.env.AWS_REGION || 'us-west-2'
   awsLite(params)
-    .then(client => callback(null, client))
-    .catch(err => {
+    .then((client) => callback(null, client))
+    .catch((err) => {
       if (err.message.includes('AWS credentials') && !useAWS()) {
-        let accessKeyId = 'arcDummyAccessKey'
-        let secretAccessKey = 'arcDummySecretKey'
+        const accessKeyId = 'arcDummyAccessKey'
+        const secretAccessKey = 'arcDummySecretKey'
         awsLite({ ...params, accessKeyId, secretAccessKey })
-          .then(client => callback(null, client))
+          .then((client) => callback(null, client))
           .catch(callback)
-      }
-      else callback(err)
+      } else callback(err)
     })
 }
 
-function useAWS () {
-  let { ARC_ENV, ARC_LOCAL, ARC_SANDBOX } = process.env
+function useAWS() {
+  const { ARC_ENV, ARC_LOCAL, ARC_SANDBOX } = process.env
   // Testing is always local
   if (ARC_ENV === 'testing') return false
   // Local, but using !testing environments
diff --git a/src/static/index.js b/src/static/index.js
index 5994df1c..3370fc57 100644
--- a/src/static/index.js
+++ b/src/static/index.js
@@ -1,5 +1,5 @@
-let { readFileSync, existsSync } = require('fs')
-let { join } = require('path')
+const { readFileSync, existsSync } = require('node:fs')
+const { join } = require('node:path')
 
 /**
  * Architect static asset helper
@@ -11,21 +11,20 @@ let { join } = require('path')
  * @param {string} asset - the path to the asset (eg. /index.js)
  * @returns {string} path - the resolved asset path (eg. /_static/index-xxx.js)
  */
-module.exports = function _static (asset, options = {}) {
-  let { ARC_ENV, ARC_LOCAL } = process.env
-  let key = asset[0] === '/' ? asset.substring(1) : asset
-  let isIndex = asset === '/'
-  let manifest = join(process.cwd(), 'node_modules', '@architect', 'shared', 'static.json')
-  let exists = existsSync(manifest)
-  let local = ARC_ENV === 'testing' || ARC_LOCAL
-  let stagePath = options.stagePath && !local ? '/' + ARC_ENV : ''
-  let path = `${stagePath}/_static`
+module.exports = function _static(asset, options = {}) {
+  const { ARC_ENV, ARC_LOCAL } = process.env
+  const key = asset[0] === '/' ? asset.substring(1) : asset
+  const isIndex = asset === '/'
+  const manifest = join(process.cwd(), 'node_modules', '@architect', 'shared', 'static.json')
+  const exists = existsSync(manifest)
+  const local = ARC_ENV === 'testing' || ARC_LOCAL
+  const stagePath = options.stagePath && !local ? `/${ARC_ENV}` : ''
+  const path = `${stagePath}/_static`
   if (!local && exists && !isIndex) {
-    let read = p => readFileSync(p).toString()
-    let pkg = JSON.parse(read(manifest))
-    let asset = pkg[key]
-    if (!asset)
-      return `${path}/${key}`
+    const read = (p) => readFileSync(p).toString()
+    const pkg = JSON.parse(read(manifest))
+    const asset = pkg[key]
+    if (!asset) return `${path}/${key}`
     return `${path}/${asset}`
   }
   return `${path}/${isIndex ? '' : key}`
diff --git a/src/tables/factory.js b/src/tables/factory.js
index 2c48eaf8..1d222441 100644
--- a/src/tables/factory.js
+++ b/src/tables/factory.js
@@ -1,34 +1,33 @@
-let { getAwsClient, getPorts, useAWS } = require('../lib')
-let getAwsSdkClient = require('./legacy')
-let enumerable = false
-let paginate = true
+const { getAwsClient, getPorts, useAWS } = require('../lib')
+const getAwsSdkClient = require('./legacy')
+const enumerable = false
+const paginate = true
 
 /**
  * returns a data client
  */
-module.exports = function factory ({ services, options = {} }, callback) {
-  let { tables } = services
-  let { ARC_ENV, AWS_REGION } = process.env
-  let local = ARC_ENV === 'testing'
-  let region = AWS_REGION || 'us-west-2'
-  let plugins = [ import('@aws-lite/dynamodb') ]
-  let { awsjsonMarshall, awsjsonUnmarshall } = options
+module.exports = function factory({ services, options = {} }, callback) {
+  const { tables } = services
+  const { ARC_ENV, AWS_REGION } = process.env
+  const local = ARC_ENV === 'testing'
+  const region = AWS_REGION || 'us-west-2'
+  const plugins = [import('@aws-lite/dynamodb')]
+  const { awsjsonMarshall, awsjsonUnmarshall } = options
 
   if (useAWS()) {
     getAwsClient({ region, plugins, awsjsonMarshall, awsjsonUnmarshall }, (err, aws) => {
       if (err) callback(err)
       else dynamoConstructor({ aws, local, options, tables }, callback)
     })
-  }
-  else {
+  } else {
     getPorts((err, ports) => {
       if (err) callback(err)
       else {
-        let port = ports.tables
+        const port = ports.tables
         if (!port) {
           return callback(ReferenceError('Sandbox tables port not found'))
         }
-        let config = {
+        const config = {
           endpoint: `http://localhost:${port}`,
           region,
           plugins,
@@ -44,98 +43,111 @@ module.exports = function factory ({ services, options = {} }, callback) {
   }
 }
 
-function dynamoConstructor (params, callback) {
-  let { aws, local, options, tables } = params
-  let data = Object.keys(tables)
-    .filter(name => {
+function dynamoConstructor(params, callback) {
+  const { aws, local, options, tables } = params
+  const data = Object.keys(tables)
+    .filter((name) => {
       if (local && !name.includes('-production-')) return name
       return name
     })
     .reduce((client, fullName) => {
-      let name = local ? fullName.replace(/.+-staging-/, '') : fullName
+      const name = local ? fullName.replace(/.+-staging-/, '') : fullName
       client[name] = factory(tables[name])
       return client
     }, {})
 
   data.reflect = async () => tables
-  let _name = name => tables[name]
+  const _name = (name) => tables[name]
   data.name = _name
   data._name = _name
 
-  Object.defineProperty(data, '_client',  { enumerable, value: aws.dynamodb })
+  Object.defineProperty(data, '_client', { enumerable, value: aws.dynamodb })
 
   if (options.awsSdkClient) {
-    let { db, doc } = getAwsSdkClient(params)
-    Object.defineProperty(data, '_db',  { enumerable, value: db })
+    const { db, doc } = getAwsSdkClient(params)
+    Object.defineProperty(data, '_db', { enumerable, value: db })
     Object.defineProperty(data, '_doc', { enumerable, value: doc })
   }
 
-  function go (method, params, callback) {
-    if (callback) method(params)
-      .then(result => callback(null, result))
-      .catch(err => callback(err))
+  function go(method, params, callback) {
+    if (callback)
+      method(params)
+        .then((result) => callback(null, result))
+        .catch((err) => callback(err))
     else return method(params)
   }
 
-  function factory (TableName) {
+  function factory(TableName) {
     return {
-      delete (Key, callback) {
-        if (callback) aws.dynamodb.DeleteItem({ TableName, Key })
-          .then(result => callback(null, result))
-          .catch(err => callback(err))
-
-        else return new Promise((res, rej) => {
-          aws.dynamodb.DeleteItem({ TableName, Key })
-            .then(result => res(result))
-            .catch(rej)
-        })
+      delete(Key, callback) {
+        if (callback)
+          aws.dynamodb
+            .DeleteItem({ TableName, Key })
+            .then((result) => callback(null, result))
+            .catch((err) => callback(err))
+        else
+          return new Promise((res, rej) => {
+            aws.dynamodb
+              .DeleteItem({ TableName, Key })
+              .then((result) => res(result))
+              .catch(rej)
+          })
       },
 
-      get (Key, callback) {
-        if (callback) aws.dynamodb.GetItem({ TableName, Key })
-          .then(({ Item }) => callback(null, Item))
-          .catch(err => callback(err))
-
-        else return new Promise((res, rej) => {
-          aws.dynamodb.GetItem({ TableName, Key })
-            .then(({ Item }) => res(Item))
-            .catch(rej)
-        })
+      get(Key, callback) {
+        if (callback)
+          aws.dynamodb
+            .GetItem({ TableName, Key })
+            .then(({ Item }) => callback(null, Item))
+            .catch((err) => callback(err))
+        else
+          return new Promise((res, rej) => {
+            aws.dynamodb
+              .GetItem({ TableName, Key })
+              .then(({ Item }) => res(Item))
+              .catch(rej)
+          })
       },
 
-      put (Item, callback) {
-        if (callback) aws.dynamodb.PutItem({ TableName, Item })
-          .then(() => callback(null, Item))
-          .catch(err => callback(err))
-
-        else return new Promise((res, rej) => {
-          aws.dynamodb.PutItem({ TableName, Item })
-            .then(() => res(Item))
-            .catch(rej)
-        })
+      put(Item, callback) {
+        if (callback)
+          aws.dynamodb
+            .PutItem({ TableName, Item })
+            .then(() => callback(null, Item))
+            .catch((err) => callback(err))
+        else
+          return new Promise((res, rej) => {
+            aws.dynamodb
+              .PutItem({ TableName, Item })
+              .then(() => res(Item))
+              .catch(rej)
+          })
       },
 
-      query (params = {}, callback) {
+      query(params = {}, callback) {
         return go(aws.dynamodb.Query, { ...params, TableName }, callback)
       },
 
-      scan (params = {}, callback) {
+      scan(params = {}, callback) {
         return go(aws.dynamodb.Scan, { ...params, TableName }, callback)
       },
 
-      scanAll (params = {}, callback) {
-        if (callback) aws.dynamodb.Scan({ ...params, TableName, paginate })
-          .then(({ Items }) => callback(null, Items))
-          .catch(err => callback(err))
-
-        else return new Promise((res, rej) => {
-          aws.dynamodb.Scan({ ...params, TableName, paginate })
-            .then(({ Items }) => res(Items))
-            .catch(rej)
-        })
+      scanAll(params = {}, callback) {
+        if (callback)
+          aws.dynamodb
+            .Scan({ ...params, TableName, paginate })
+            .then(({ Items }) => callback(null, Items))
+            .catch((err) => callback(err))
+        else
+          return new Promise((res, rej) => {
+            aws.dynamodb
+              .Scan({ ...params, TableName, paginate })
+              .then(({ Items }) => res(Items))
+              .catch(rej)
+          })
       },
 
-      update (params, callback) {
+      update(params, callback) {
         return go(aws.dynamodb.UpdateItem, { ...params, TableName }, callback)
       },
     }
diff --git a/src/tables/index.js b/src/tables/index.js
index 86ed690f..60a5b600 100644
--- a/src/tables/index.js
+++ b/src/tables/index.js
@@ -1,6 +1,6 @@
-let waterfall = require('run-waterfall')
-let old = require('./old')
-let factory = require('./factory')
+const waterfall = require('run-waterfall')
+const old = require('./old')
+const factory = require('./factory')
 
 // cheap client cache
 let client = false
@@ -16,13 +16,12 @@ let client = false
  * }
  * ```
  */
-module.exports = function tables (arc) {
-
-  function api (options = {}, callback) {
+module.exports = function tables(arc) {
+  function api(options = {}, callback) {
     let promise
     if (!callback) {
-      promise = new Promise(function ugh (res, rej) {
-        callback = function errback (err, result) {
+      promise = new Promise(function ugh(res, rej) {
+        callback = function errback(err, result) {
           if (err) rej(err)
           else res(result)
         }
@@ -31,33 +30,36 @@ module.exports = function tables (arc) {
 
     if (client) {
       callback(null, client)
-    }
-    else {
-      waterfall([
-        function (callback) {
-          arc.services()
-            .then(services => callback(null, { services, options }))
-            .catch(callback)
-        },
-        factory,
-        function (created, callback) {
-          client = created
-          callback(null, client)
-        },
-      ], callback)
+    } else {
+      waterfall(
+        [
+          (callback) => {
+            arc
+              .services()
+              .then((services) => callback(null, { services, options }))
+              .catch(callback)
+          },
+          factory,
+          (created, callback) => {
+            client = created
+            callback(null, client)
+          },
+        ],
+        callback,
+      )
     }
     return promise
   }
 
   // Legacy compat methods
-  api.insert =  old.insert
-  api.modify =  old.modify
-  api.update =  old.update
-  api.remove =  old.remove
+  api.insert = old.insert
+  api.modify = old.modify
+  api.update = old.update
+  api.remove = old.remove
   api.destroy = old.destroy
-  api.all =     old.all
-  api.save =    old.save
-  api.change =  old.change
+  api.all = old.all
+  api.save = old.save
+  api.change = old.change
 
   return api
 }
diff --git a/src/tables/legacy.js b/src/tables/legacy.js
index 45f4096e..22506178 100644
--- a/src/tables/legacy.js
+++ b/src/tables/legacy.js
@@ -1,27 +1,24 @@
-let { isNode18, useAWS } = require('../lib')
+const { isNode18, useAWS } = require('../lib')
 
-let client = {}
+const client = {}
 
 /**
  * Instantiates legacy AWS SDK DynamoDB service interfaces
  */
-module.exports = function getLegacyDynamoClients ({ port, region }) {
-
+module.exports = function getLegacyDynamoClients({ port, region }) {
   if (client.db && client.doc) return client
 
-  let DB, Doc
+  let DB
+  let Doc
 
   if (isNode18) {
+    const dynamo = require('@aws-sdk/client-dynamodb')
 
-    let dynamo = require('@aws-sdk/client-dynamodb')
-
-    let docclient = require('@aws-sdk/lib-dynamodb')
+    const docclient = require('@aws-sdk/lib-dynamodb')
     DB = dynamo.DynamoDB
     Doc = docclient.DynamoDBDocument
-  }
-  else {
-
-    let dynamo = require('aws-sdk/clients/dynamodb')
+  } else {
+    const dynamo = require('aws-sdk/clients/dynamodb')
     DB = dynamo
     Doc = dynamo.DocumentClient
   }
@@ -30,7 +27,7 @@ module.exports = function getLegacyDynamoClients ({ port, region }) {
     let config
     // SDK v2 (Node <=16) does not have keep-alive enabled by default, whereas v3 (>=18) does
     if (!isNode18) {
-      let https = require('https')
+      const https = require('node:https')
       config = {
         httpOptions: {
           agent: new https.Agent({
@@ -45,22 +42,20 @@ module.exports = function getLegacyDynamoClients ({ port, region }) {
     client.doc = isNode18 ? Doc.from(client.db) : new Doc(config)
     return client
   }
-  else {
-    let config = {
-      endpoint: `http://localhost:${port}`,
-      region,
-    }
-    if (isNode18) {
-      // Disable keep-alive locally (or wait Node's default 5s for sockets to time out)
-      let http = require('http')
+  const config = {
+    endpoint: `http://localhost:${port}`,
+    region,
+  }
+  if (isNode18) {
+    // Disable keep-alive locally (or wait Node's default 5s for sockets to time out)
+    const http = require('node:http')
 
-      let { NodeHttpHandler } = require('@smithy/node-http-handler')
-      config.requestHandler = new NodeHttpHandler({
-        httpAgent: new http.Agent({ keepAlive: false }),
-      })
-    }
-    client.db = new DB(config)
-    client.doc = isNode18 ? Doc.from(client.db) : new Doc(config)
-    return client
+    const { NodeHttpHandler } = require('@smithy/node-http-handler')
+    config.requestHandler = new NodeHttpHandler({
+      httpAgent: new http.Agent({ keepAlive: false }),
+    })
   }
+  client.db = new DB(config)
+  client.doc = isNode18 ? Doc.from(client.db) : new Doc(config)
+  return client
 }
diff --git a/src/tables/old.js b/src/tables/old.js
index 122d3bae..6b0ea830 100644
--- a/src/tables/old.js
+++ b/src/tables/old.js
@@ -1,4 +1,4 @@
-let parallel = require('run-parallel')
+const parallel = require('run-parallel')
 
 /**
  * Example usage:
@@ -11,34 +11,33 @@ let parallel = require('run-parallel')
  * module.exports = trigger.insert(onInsert)
  * ```
  */
-function __trigger (types, handler) {
-  return function __lambdaSignature (evt, ctx) {
+function __trigger(types, handler) {
+  return function __lambdaSignature(evt, ctx) {
     // DynamoDB triggers send batches of records, so create a handler for each
-    let handlers = evt.Records.map(function (record) {
+    const handlers = evt.Records.map((record) => {
       // Construct a handler function for each record
-      return function __actualHandler (callback) {
+      return function __actualHandler(callback) {
         // If isInvoking we invoke the handler with the record
-        let isInvoking = types.indexOf(record.eventName) > -1
+        const isInvoking = types.indexOf(record.eventName) > -1
         if (isInvoking) handler(record, callback)
         else callback() // If not we just call the continuation (callback)
       }
     })
     // Execute the handlers in parallel
-    parallel(handlers, function __processedRecords (err, results) {
+    parallel(handlers, function __processedRecords(err, results) {
       if (err) ctx.fail(err)
       else ctx.succeed(results)
     })
   }
 }
 
-
 module.exports = {
-  insert: __trigger.bind({}, [ 'INSERT' ]),
-  modify: __trigger.bind({}, [ 'MODIFY' ]),
-  update: __trigger.bind({}, [ 'MODIFY' ]),
-  remove: __trigger.bind({}, [ 'REMOVE' ]),
-  destroy: __trigger.bind({}, [ 'REMOVE' ]),
-  all: __trigger.bind({}, [ 'INSERT', 'MODIFY', 'REMOVE' ]),
-  save: __trigger.bind({}, [ 'INSERT', 'MODIFY' ]),
-  change: __trigger.bind({}, [ 'INSERT', 'REMOVE' ]),
+  insert: __trigger.bind({}, ['INSERT']),
+  modify: __trigger.bind({}, ['MODIFY']),
+  update: __trigger.bind({}, ['MODIFY']),
+  remove: __trigger.bind({}, ['REMOVE']),
+  destroy: __trigger.bind({}, ['REMOVE']),
+  all: __trigger.bind({}, ['INSERT', 'MODIFY', 'REMOVE']),
+  save: __trigger.bind({}, ['INSERT', 'MODIFY']),
+  change: __trigger.bind({}, ['INSERT', 'REMOVE']),
 }
diff --git a/src/ws/index.js b/src/ws/index.js
index b88947ab..59057a55 100644
--- a/src/ws/index.js
+++ b/src/ws/index.js
@@ -1,123 +1,130 @@
-let { getAwsClient, useAWS } = require('../lib')
-let client, ApiUrl
+const { getAwsClient, useAWS } = require('../lib')
+let client
+let ApiUrl
 
-function instantiateAPI () {
+function instantiateAPI() {
   return new Promise((res, rej) => {
     if (client) res(client)
 
-    getAwsClient({
-      plugins: [ import('@aws-lite/apigatewaymanagementapi') ],
-    }, (err, _client) => {
-      if (err) rej(err)
-      else {
-        client = _client
-        let { ARC_WSS_URL, ARC_SANDBOX } = process.env
-
-        if (useAWS()) {
-          ApiUrl = ARC_WSS_URL
-        }
+    getAwsClient(
+      {
+        plugins: [import('@aws-lite/apigatewaymanagementapi')],
+      },
+      (err, _client) => {
+        if (err) rej(err)
         else {
-          let { ports } = JSON.parse(ARC_SANDBOX)
-          let port = ports._arc
-          if (!port) throw ReferenceError('Architect internal port not found')
-          ApiUrl = `http://localhost:${port}/_arc/ws`
+          client = _client
+          const { ARC_WSS_URL, ARC_SANDBOX } = process.env
+
+          if (useAWS()) {
+            ApiUrl = ARC_WSS_URL
+          } else {
+            const { ports } = JSON.parse(ARC_SANDBOX)
+            const port = ports._arc
+            if (!port) throw ReferenceError('Architect internal port not found')
+            ApiUrl = `http://localhost:${port}/_arc/ws`
+          }
+          res(client)
         }
-        res(client)
-      }
-    })
+      },
+    )
   })
 }
 
-function _api (callback) {
-  if (callback) instantiateAPI()
-    .then(client => callback(null, client.ApiGatewayManagementApi))
-    .catch(callback)
-
-  else return new Promise((res, rej) => {
+function _api(callback) {
+  if (callback)
     instantiateAPI()
-      .then(client => res(client.ApiGatewayManagementApi))
-      .catch(rej)
-  })
-}
-
-function send ({ id, payload }, callback) {
-  if (callback) instantiateAPI()
-    .then(client => {
-      client.ApiGatewayManagementApi.PostToConnection({
-        ApiUrl,
-        ConnectionId: id,
-        Data: payload,
-      })
-        .then(result => callback(null, result))
-        .catch(callback)
+      .then((client) => callback(null, client.ApiGatewayManagementApi))
+      .catch(callback)
+  else
+    return new Promise((res, rej) => {
+      instantiateAPI()
+        .then((client) => res(client.ApiGatewayManagementApi))
+        .catch(rej)
     })
-    .catch(callback)
+}
 
-  else return new Promise((res, rej) => {
+function send({ id, payload }, callback) {
+  if (callback)
     instantiateAPI()
-      .then(client => {
+      .then((client) => {
         client.ApiGatewayManagementApi.PostToConnection({
           ApiUrl,
           ConnectionId: id,
           Data: payload,
         })
-          .then(result => res(result))
-          .catch(rej)
+          .then((result) => callback(null, result))
+          .catch(callback)
       })
-      .catch(rej)
-  })
-}
-
-function close ({ id }, callback) {
-  if (callback) instantiateAPI()
-    .then(client => {
-      client.ApiGatewayManagementApi.DeleteConnection({
-        ApiUrl,
-        ConnectionId: id,
-      })
-        .then(result => callback(null, result))
-        .catch(callback)
+      .catch(callback)
+  else
+    return new Promise((res, rej) => {
+      instantiateAPI()
+        .then((client) => {
+          client.ApiGatewayManagementApi.PostToConnection({
+            ApiUrl,
+            ConnectionId: id,
+            Data: payload,
+          })
+            .then((result) => res(result))
+            .catch(rej)
+        })
+        .catch(rej)
     })
-    .catch(callback)
+}
 
-  else return new Promise((res, rej) => {
+function close({ id }, callback) {
+  if (callback)
     instantiateAPI()
-      .then(client => {
+      .then((client) => {
         client.ApiGatewayManagementApi.DeleteConnection({
           ApiUrl,
           ConnectionId: id,
         })
-          .then(result => res(result))
-          .catch(rej)
-      })
-      .catch(rej)
-  })
-}
-
-function info ({ id }, callback) {
-  if (callback) instantiateAPI()
-    .then(client => {
-      client.ApiGatewayManagementApi.GetConnection({
-        ApiUrl,
-        ConnectionId: id,
+          .then((result) => callback(null, result))
+          .catch(callback)
       })
-        .then(result => callback(null, result))
-        .catch(callback)
+      .catch(callback)
+  else
+    return new Promise((res, rej) => {
+      instantiateAPI()
+        .then((client) => {
+          client.ApiGatewayManagementApi.DeleteConnection({
+            ApiUrl,
+            ConnectionId: id,
+          })
+            .then((result) => res(result))
+            .catch(rej)
+        })
+        .catch(rej)
     })
-    .catch(callback)
+}
 
-  else return new Promise((res, rej) => {
+function info({ id }, callback) {
+  if (callback)
     instantiateAPI()
-      .then(client => {
+      .then((client) => {
         client.ApiGatewayManagementApi.GetConnection({
           ApiUrl,
           ConnectionId: id,
         })
-          .then(result => res(result))
-          .catch(rej)
+          .then((result) => callback(null, result))
+          .catch(callback)
       })
-      .catch(rej)
-  })
+      .catch(callback)
+  else
+    return new Promise((res, rej) => {
+      instantiateAPI()
+        .then((client) => {
+          client.ApiGatewayManagementApi.GetConnection({
+            ApiUrl,
+            ConnectionId: id,
+          })
+            .then((result) => res(result))
+            .catch(rej)
+        })
+        .catch(rej)
+    })
 }
 
 module.exports = {
diff --git a/test/integration/discovery-test.js b/test/integration/discovery-test.js
index 9fe08858..51adebfd 100644
--- a/test/integration/discovery-test.js
+++ b/test/integration/discovery-test.js
@@ -1,21 +1,25 @@
-let { join } = require('path')
-let test = require('tape')
-let sandbox = require('@architect/sandbox')
-let cwd = process.cwd()
-let mock = join(cwd, 'test', 'mock', 'project')
-let discovery = require('../../src/discovery')
+const { join } = require('node:path')
+const test = require('tape')
+const sandbox = require('@architect/sandbox')
+const cwd = process.cwd()
+const mock = join(cwd, 'test', 'mock', 'project')
+const discovery = require('../../src/discovery')
 
-test('Set up env', async t => {
+test('Set up env', async (t) => {
   t.plan(1)
   await sandbox.start({ cwd: mock, quiet: true })
   t.pass('Sandbox started')
 })
 
-test('discovery should parse hierarchical SSM parameters into a service map object', t => {
+test('discovery should parse hierarchical SSM parameters into a service map object', (t) => {
   t.plan(6)
   discovery((err, services) => {
     t.notOk(err, 'No error passed to callback')
-    t.equal(services.tables['arc-sessions'], 'test-only-staging-arc-sessions', 'Table value set up in correct place of service map')
+    t.equal(
+      services.tables['arc-sessions'],
+      'test-only-staging-arc-sessions',
+      'Table value set up in correct place of service map',
+    )
     t.equal(services.tables.things, 'test-only-staging-things', 'Table value set up in correct place of service map')
 
     // Check deeper depths
@@ -25,7 +29,7 @@ test('discovery should parse hierarchical SSM parameters into a service map obje
   })
 })
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
   await sandbox.end()
   t.pass('Sandbox ended')
diff --git a/test/integration/events-queues-test.js b/test/integration/events-queues-test.js
index 8433ffc9..3a25ab90 100644
--- a/test/integration/events-queues-test.js
+++ b/test/integration/events-queues-test.js
@@ -1,16 +1,16 @@
-let { join } = require('path')
-let http = require('http')
-let sandbox = require('@architect/sandbox')
-let test = require('tape')
-let tiny = require('tiny-json-http')
-let cwd = process.cwd()
-let mock = join(cwd, 'test', 'mock', 'project')
+const { join } = require('node:path')
+const http = require('node:http')
+const sandbox = require('@architect/sandbox')
+const test = require('tape')
+const tiny = require('tiny-json-http')
+const cwd = process.cwd()
+const mock = join(cwd, 'test', 'mock', 'project')
 let server
-let port = 1111
-let url = path => `http://localhost:3333/publish-event/${path}`
-let sane = encodeURI(JSON.stringify({ ok: true }))
+const port = 1111
+const url = (path) => `http://localhost:3333/publish-event/${path}`
+const sane = encodeURI(JSON.stringify({ ok: true }))
 
-function createServer () {
+function createServer() {
   server = http.createServer((req, res) => {
     res.writeHead(200)
     res.end()
@@ -18,19 +18,19 @@ function createServer () {
   server.listen(port)
   console.log('Started test server')
 }
-function closeServer () {
+function closeServer() {
   return new Promise((res, rej) => {
-    server.close(err => {
+    server.close((err) => {
       if (err) rej(err)
       else {
-        console.log(`Test server ended`)
+        console.log('Test server ended')
         res()
       }
     })
   })
 }
 
-test('Set up env', async t => {
+test('Set up env', async (t) => {
   t.plan(2)
   await sandbox.start({ cwd: mock, quiet: true })
   t.pass('Sandbox started')
@@ -39,67 +39,67 @@ test('Set up env', async t => {
 })
 
 // These can almost certainly be dried up, but they should be good enough for now
-test('@events pub/sub (continuation-passing handler)', t => {
+test('@events pub/sub (continuation-passing handler)', (t) => {
   t.plan(2)
-  let path = '/events/cb-event'
-  let check = req => {
-    let posted = req.url.split('?')
+  const path = '/events/cb-event'
+  const check = (req) => {
+    const posted = req.url.split('?')
     t.equal(posted[0], path, 'Published callback event through the event bus')
     t.equal(posted[1], sane, 'Got payload')
     server.removeListener('request', check)
   }
   server.on('request', check)
-  tiny.post({ url: url(path) }, err => {
+  tiny.post({ url: url(path) }, (err) => {
     if (err) t.fail(err)
   })
 })
 
-test('@events pub/sub (async handler)', t => {
+test('@events pub/sub (async handler)', (t) => {
   t.plan(2)
-  let path = '/events/async-event'
-  let check = req => {
-    let posted = req.url.split('?')
+  const path = '/events/async-event'
+  const check = (req) => {
+    const posted = req.url.split('?')
     t.equal(posted[0], path, 'Published async event through the event bus')
     t.equal(posted[1], sane, 'Got payload')
     server.removeListener('request', check)
   }
   server.on('request', check)
-  tiny.post({ url: url(path) }, err => {
+  tiny.post({ url: url(path) }, (err) => {
     if (err) t.fail(err)
   })
 })
 
-test('@queues pub/sub (continuation-passing handler)', t => {
+test('@queues pub/sub (continuation-passing handler)', (t) => {
   t.plan(2)
-  let path = '/queues/cb-queue'
-  let check = req => {
-    let posted = req.url.split('?')
+  const path = '/queues/cb-queue'
+  const check = (req) => {
+    const posted = req.url.split('?')
     t.equal(posted[0], path, 'Published callback queue through the queue bus')
     t.equal(posted[1], sane, 'Got payload')
     server.removeListener('request', check)
   }
   server.on('request', check)
-  tiny.post({ url: url(path) }, err => {
+  tiny.post({ url: url(path) }, (err) => {
     if (err) t.fail(err)
   })
 })
 
-test('@queues pub/sub (async handler)', t => {
+test('@queues pub/sub (async handler)', (t) => {
   t.plan(2)
-  let path = '/queues/async-queue'
-  let check = req => {
-    let posted = req.url.split('?')
+  const path = '/queues/async-queue'
+  const check = (req) => {
+    const posted = req.url.split('?')
     t.equal(posted[0], path, 'Published async queue through the queue bus')
     t.equal(posted[1], sane, 'Got payload')
     server.removeListener('request', check)
   }
   server.on('request', check)
-  tiny.post({ url: url(path) }, err => {
+  tiny.post({ url: url(path) }, (err) => {
     if (err) t.fail(err)
   })
 })
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
   await closeServer()
   await sandbox.end()
diff --git a/test/integration/http-assets.js b/test/integration/http-assets.js
index 8b173733..2336d4ae 100644
--- a/test/integration/http-assets.js
+++ b/test/integration/http-assets.js
@@ -1,24 +1,24 @@
-let sandbox = require('@architect/sandbox')
-let test = require('tape')
-let { join } = require('path')
-let tiny = require('tiny-json-http')
-
-let port = process.env.PORT ? process.env.PORT : '3333'
-let url = s => `http://localhost:${port}${s ? s : ''}`
-let mock = join(__dirname, '..', 'mock', 'project')
-let compress = {
+const sandbox = require('@architect/sandbox')
+const test = require('tape')
+const { join } = require('node:path')
+const tiny = require('tiny-json-http')
+
+const port = process.env.PORT ? process.env.PORT : '3333'
+const url = (s) => `http://localhost:${port}${s ? s : ''}`
+const mock = join(__dirname, '..', 'mock', 'project')
+const compress = {
   'accept-encoding': 'br',
 }
-let css = `/* css here! */\n`
-let js = `/* js here! */\n`
+const css = '/* css here! */\n'
+const js = '/* js here! */\n'
 
-test('Set up env', async t => {
+test('Set up env', async (t) => {
   t.plan(1)
-  let result = await sandbox.start({ quiet: true, cwd: mock })
+  const result = await sandbox.start({ quiet: true, cwd: mock })
   t.equal(result, 'Sandbox successfully started', result)
 })
 
-test('Get uncompressed assets', async t => {
+test('Get uncompressed assets', async (t) => {
   t.plan(4)
   let result
 
@@ -39,8 +39,8 @@ test('Get uncompressed assets', async t => {
 
 // TODO could probably stand to do a compressed test set, but that would require building local compression support for ASAP, which we did not yet bother with
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
-  let result = await sandbox.end()
+  const result = await sandbox.end()
   t.equal(result, 'Sandbox successfully shut down', result)
 })
diff --git a/test/integration/http-session-dynamo-test.js b/test/integration/http-session-dynamo-test.js
index 392e8340..bccad994 100644
--- a/test/integration/http-session-dynamo-test.js
+++ b/test/integration/http-session-dynamo-test.js
@@ -1,64 +1,65 @@
-let sandbox = require('@architect/sandbox')
-let test = require('tape')
-let { join } = require('path')
-let tiny = require('tiny-json-http')
+const sandbox = require('@architect/sandbox')
+const test = require('tape')
+const { join } = require('node:path')
+const tiny = require('tiny-json-http')
 
-let port = process.env.PORT ? process.env.PORT : '3333'
-let url = s => `http://localhost:${port}${s ? s : ''}`
+const port = process.env.PORT ? process.env.PORT : '3333'
+const url = (s) => `http://localhost:${port}${s ? s : ''}`
 
-async function getSession (url) {
-  let headers = { cookie }
-  let result = await tiny.get({ url, headers })
+async function getSession(url) {
+  const headers = { cookie }
+  const result = await tiny.get({ url, headers })
   return JSON.parse(result.body)
 }
 
-function checkKeys (session, t) {
-  let { _idx, _secret, _ttl } = session
-  if (!_idx || !_secret || !_ttl) t.fail(`Did not get back all internal session keys: ${JSON.stringify(session, null, 2)}`)
+function checkKeys(session, t) {
+  const { _idx, _secret, _ttl } = session
+  if (!_idx || !_secret || !_ttl)
+    t.fail(`Did not get back all internal session keys: ${JSON.stringify(session, null, 2)}`)
   else t.pass('Got back internal session keys: _idx, _secret, _ttl')
 }
 
 let cookie // Assigned at setup
-let mock = join(__dirname, '..', 'mock', 'project')
+const mock = join(__dirname, '..', 'mock', 'project')
 
-test('Set up env to test physical table name', async t => {
+test('Set up env to test physical table name', async (t) => {
   t.plan(1)
   process.env.ARC_SESSION_TABLE_NAME = 'test-only-staging-arc-sessions' // Use logical, not physical name
-  let result = await sandbox.start({ quiet: true, cwd: mock })
+  const result = await sandbox.start({ quiet: true, cwd: mock })
   t.equal(result, 'Sandbox successfully started', result)
 })
 
-test('Create an initial session', async t => {
+test('Create an initial session', async (t) => {
   t.plan(1)
-  let dest = url('/http-session')
-  let result = await tiny.get({ url: dest })
+  const dest = url('/http-session')
+  const result = await tiny.get({ url: dest })
   cookie = result.headers['set-cookie'][0]
   t.ok(cookie, `Got cookie to use in sessions: ${cookie.substr(0, 50)}...`)
 })
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
   delete process.env.ARC_SESSION_TABLE_NAME
-  let result = await sandbox.end()
+  const result = await sandbox.end()
   t.equal(result, 'Sandbox successfully shut down', result)
 })
 
-test('Set up env to test logical table name', async t => {
+test('Set up env to test logical table name', async (t) => {
   t.plan(1)
   process.env.ARC_SESSION_TABLE_NAME = 'arc-sessions' // Use logical, not physical name
-  let result = await sandbox.start({ quiet: true, cwd: mock })
+  const result = await sandbox.start({ quiet: true, cwd: mock })
   t.equal(result, 'Sandbox successfully started', result)
 })
 
-test('Create an initial session', async t => {
+test('Create an initial session', async (t) => {
   t.plan(1)
-  let dest = url('/http-session')
-  let result = await tiny.get({ url: dest })
+  const dest = url('/http-session')
+  const result = await tiny.get({ url: dest })
   cookie = result.headers['set-cookie'][0]
   t.ok(cookie, `Got cookie to use in sessions: ${cookie.substr(0, 50)}...`)
 })
 
-test('Do session stuff (continuation passing)', async t => {
+test('Do session stuff (continuation passing)', async (t) => {
   t.plan(14)
   let session
 
@@ -70,14 +71,14 @@ test('Do session stuff (continuation passing)', async t => {
   // Add a data point
   session = await getSession(url('/http-session?session=create'))
   t.equal(Object.keys(session).length, 4, 'Got back a populated session')
-  let unique = session.unique
+  const unique = session.unique
   t.ok(unique, `Got a unique data point created from session, ${unique}`)
   checkKeys(session, t)
 
   // Persist it across requests
   session = await getSession(url('/http-session'))
   t.equal(Object.keys(session).length, 4, 'Got back a populated session')
-  t.equal(session.unique, unique, `Unique data point persisted in session across requests`)
+  t.equal(session.unique, unique, 'Unique data point persisted in session across requests')
   checkKeys(session, t)
 
   // Update the session
@@ -96,7 +97,7 @@ test('Do session stuff (continuation passing)', async t => {
   checkKeys(session, t)
 })
 
-test('Do session stuff (async)', async t => {
+test('Do session stuff (async)', async (t) => {
   t.plan(14)
   let session
 
@@ -108,14 +109,14 @@ test('Do session stuff (async)', async t => {
   // Add a data point
   session = await getSession(url('/http-async-session?session=create'))
   t.equal(Object.keys(session).length, 4, 'Got back a populated session')
-  let unique = session.unique
+  const unique = session.unique
   t.ok(unique, `Got a unique data point created from session, ${unique}`)
   checkKeys(session, t)
 
   // Persist it across requests
   session = await getSession(url('/http-async-session'))
   t.equal(Object.keys(session).length, 4, 'Got back a populated session')
-  t.equal(session.unique, unique, `Unique data point persisted in session across requests`)
+  t.equal(session.unique, unique, 'Unique data point persisted in session across requests')
   checkKeys(session, t)
 
   // Update the session
@@ -134,9 +135,9 @@ test('Do session stuff (async)', async t => {
   checkKeys(session, t)
 })
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
   delete process.env.ARC_SESSION_TABLE_NAME
-  let result = await sandbox.end()
+  const result = await sandbox.end()
   t.equal(result, 'Sandbox successfully shut down', result)
 })
diff --git a/test/integration/http-session-jwe-test.js b/test/integration/http-session-jwe-test.js
index 67fd1ba5..83c57164 100644
--- a/test/integration/http-session-jwe-test.js
+++ b/test/integration/http-session-jwe-test.js
@@ -1,43 +1,43 @@
-let sandbox = require('@architect/sandbox')
-let test = require('tape')
-let { join } = require('path')
-let tiny = require('tiny-json-http')
-
-let port = process.env.PORT ? process.env.PORT : '3333'
-let url = s => `http://localhost:${port}${s ? s : ''}`
-
-async function getSession (url) {
-  let headers = { cookie }
-  let result = await tiny.get({ url, headers })
-  let newCookie = result.headers['set-cookie'][0]
+const sandbox = require('@architect/sandbox')
+const test = require('tape')
+const { join } = require('node:path')
+const tiny = require('tiny-json-http')
+
+const port = process.env.PORT ? process.env.PORT : '3333'
+const url = (s) => `http://localhost:${port}${s ? s : ''}`
+
+async function getSession(url) {
+  const headers = { cookie }
+  const result = await tiny.get({ url, headers })
+  const newCookie = result.headers['set-cookie'][0]
   cookie = newCookie
   return JSON.parse(result.body)
 }
 
-function checkKeys (session, t) {
-  let { iat } = session
+function checkKeys(session, t) {
+  const { iat } = session
   if (!iat) t.fail(`Did not get back all internal session keys: ${JSON.stringify(session, null, 2)}`)
   else t.pass('Got back internal session key: iat')
 }
 
 let cookie // Assigned at setup
-let mock = join(__dirname, '..', 'mock', 'project')
+const mock = join(__dirname, '..', 'mock', 'project')
 
-test('Set up env', async t => {
+test('Set up env', async (t) => {
   t.plan(1)
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
-  let result = await sandbox.start({ quiet: true, cwd: mock })
+  const result = await sandbox.start({ quiet: true, cwd: mock })
   t.equal(result, 'Sandbox successfully started', result)
 })
 
-test('Create an initial session', async t => {
+test('Create an initial session', async (t) => {
   t.plan(1)
-  let result = await tiny.get({ url: url('/http-session') })
+  const result = await tiny.get({ url: url('/http-session') })
   cookie = result.headers['set-cookie'][0]
   t.ok(cookie, `Got cookie to use in sessions: ${cookie.substr(0, 50)}...`)
 })
 
-test('Do session stuff (continuation passing)', async t => {
+test('Do session stuff (continuation passing)', async (t) => {
   t.plan(14)
   let session
 
@@ -49,14 +49,14 @@ test('Do session stuff (continuation passing)', async t => {
   // Add a data point
   session = await getSession(url('/http-session?session=create'))
   t.equal(Object.keys(session).length, 2, 'Got back a populated session')
-  let unique = session.unique
+  const unique = session.unique
   t.ok(unique, `Got a unique data point created from session, ${unique}`)
   checkKeys(session, t)
 
   // Persist it across requests
   session = await getSession(url('/http-session'))
   t.equal(Object.keys(session).length, 2, 'Got back a populated session')
-  t.equal(session.unique, unique, `Unique data point persisted in session across requests`)
+  t.equal(session.unique, unique, 'Unique data point persisted in session across requests')
   checkKeys(session, t)
 
   // Update the session
@@ -75,7 +75,7 @@ test('Do session stuff (continuation passing)', async t => {
   checkKeys(session, t)
 })
 
-test('Do session stuff (async)', async t => {
+test('Do session stuff (async)', async (t) => {
   t.plan(14)
   let session
 
@@ -87,14 +87,14 @@ test('Do session stuff (async)', async t => {
   // Add a data point
   session = await getSession(url('/http-async-session?session=create'))
   t.equal(Object.keys(session).length, 2, 'Got back a populated session')
-  let unique = session.unique
+  const unique = session.unique
   t.ok(unique, `Got a unique data point created from session, ${unique}`)
   checkKeys(session, t)
 
   // Persist it across requests
   session = await getSession(url('/http-async-session'))
   t.equal(Object.keys(session).length, 2, 'Got back a populated session')
-  t.equal(session.unique, unique, `Unique data point persisted in session across requests`)
+  t.equal(session.unique, unique, 'Unique data point persisted in session across requests')
   checkKeys(session, t)
 
   // Update the session
@@ -113,9 +113,9 @@ test('Do session stuff (async)', async t => {
   checkKeys(session, t)
 })
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
   delete process.env.ARC_SESSION_TABLE_NAME
-  let result = await sandbox.end()
+  const result = await sandbox.end()
   t.equal(result, 'Sandbox successfully shut down', result)
 })
diff --git a/test/integration/static-fingerprinted-test.js b/test/integration/static-fingerprinted-test.js
index d635cdd2..d6cd3fa5 100644
--- a/test/integration/static-fingerprinted-test.js
+++ b/test/integration/static-fingerprinted-test.js
@@ -1,17 +1,17 @@
-let { execSync: exec } = require('child_process')
-let { copyFileSync, existsSync: exists, mkdirSync: mkdir } = require('fs')
-let { join } = require('path')
-let test = require('tape')
+const { execSync: exec } = require('node:child_process')
+const { copyFileSync, existsSync: exists, mkdirSync: mkdir } = require('node:fs')
+const { join } = require('node:path')
+const test = require('tape')
 
 let arc
-let mock = join(__dirname, '..', 'mock')
-let tmp = join(mock, 'tmp')
-let shared = join(tmp, 'node_modules', '@architect', 'shared')
+const mock = join(__dirname, '..', 'mock')
+const tmp = join(mock, 'tmp')
+const shared = join(tmp, 'node_modules', '@architect', 'shared')
 
-let origCwd = process.cwd()
-let static
+const origCwd = process.cwd()
+let staticManifest
 
-test('Set up mocked arc', t => {
+test('Set up mocked arc', (t) => {
   t.plan(2)
   process.env.AWS_REGION = 'us-west-1'
   mkdir(shared, { recursive: true })
@@ -24,22 +24,22 @@ test('Set up mocked arc', t => {
   arc = require('../..') // module globally inspects arc file so need to require after chdir
 })
 
-test('Fingerprinting only enabled if static manifest is found', t => {
+test('Fingerprinting only enabled if static manifest is found', (t) => {
   t.plan(1)
   arc.static('index.html', { reload: true })
-  t.equals(arc.static('index.html'), `/_static/index.html`)
+  t.equals(arc.static('index.html'), '/_static/index.html')
 })
 
-test('Set up mocked static manifest', t => {
+test('Set up mocked static manifest', (t) => {
   t.plan(2)
   copyFileSync(join(mock, 'mock-static'), join(shared, 'static.json'))
   t.ok(exists(join(shared, 'static.json')), 'Mock static.json file ready')
 
-  static = require(join(shared, 'static.json'))
-  t.ok(static['index.html'], 'Static manifest loaded')
+  staticManifest = require(join(shared, 'static.json'))
+  t.ok(staticManifest['index.html'], 'Static manifest loaded')
 })
 
-test('Clean up env', t => {
+test('Clean up env', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   delete process.env.AWS_REGION
diff --git a/test/integration/static-plain-test.js b/test/integration/static-plain-test.js
index 348aa23d..a9178059 100644
--- a/test/integration/static-plain-test.js
+++ b/test/integration/static-plain-test.js
@@ -1,20 +1,20 @@
-let { execSync: exec } = require('child_process')
-let { copyFileSync, existsSync: exists, mkdirSync: mkdir } = require('fs')
-let { join } = require('path')
-let test = require('tape')
+const { execSync: exec } = require('node:child_process')
+const { copyFileSync, existsSync: exists, mkdirSync: mkdir } = require('node:fs')
+const { join } = require('node:path')
+const test = require('tape')
 
 let arc
-let mock = join(__dirname, '..', 'mock')
-let tmp = join(mock, 'tmp')
-let shared = join(tmp, 'node_modules', '@architect', 'shared')
+const mock = join(__dirname, '..', 'mock')
+const tmp = join(mock, 'tmp')
+const shared = join(tmp, 'node_modules', '@architect', 'shared')
 
-let origCwd = process.cwd()
+const origCwd = process.cwd()
 
-let resetEnv = () => {
+const resetEnv = () => {
   delete process.env.ARC_ENV
 }
 
-test('Set up mocked files', t => {
+test('Set up mocked files', (t) => {
   t.plan(2)
   process.env.ARC_ENV = 'testing'
   mkdir(shared, { recursive: true })
@@ -27,7 +27,7 @@ test('Set up mocked files', t => {
   arc = require('../..') // module globally inspects arc file so need to require after chdir
 })
 
-test('Local URL tests', t => {
+test('Local URL tests', (t) => {
   t.plan(6)
   t.equal(arc.static('index.html'), '/_static/index.html', 'Basic local static path')
   t.equal(arc.static('/index.html'), '/_static/index.html', 'Basic local static path with leading slash')
@@ -40,15 +40,23 @@ test('Local URL tests', t => {
 
   delete process.env.ARC_ENV // Run it "locally"
   process.env.ARC_STATIC_PREFIX = 'foo'
-  t.equal(arc.static('index.html'), '/_static/index.html', 'Basic local static path unaffected by ARC_STATIC_PREFIX env var')
+  t.equal(
+    arc.static('index.html'),
+    '/_static/index.html',
+    'Basic local static path unaffected by ARC_STATIC_PREFIX env var',
+  )
   delete process.env.ARC_STATIC_PREFIX
 
   process.env.ARC_STATIC_FOLDER = 'foo'
-  t.equal(arc.static('index.html'), '/_static/index.html', 'Basic local static path unaffected by ARC_STATIC_FOLDER env var')
+  t.equal(
+    arc.static('index.html'),
+    '/_static/index.html',
+    'Basic local static path unaffected by ARC_STATIC_FOLDER env var',
+  )
   resetEnv()
 })
 
-test('Clean up env', t => {
+test('Clean up env', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   process.chdir(origCwd)
diff --git a/test/integration/tables-test.js b/test/integration/tables-test.js
index 972f915c..f5718c12 100644
--- a/test/integration/tables-test.js
+++ b/test/integration/tables-test.js
@@ -1,17 +1,17 @@
-let sandbox = require('@architect/sandbox')
-let { execSync: exec } = require('child_process')
-let test = require('tape')
-let { join } = require('path')
-let { copyFileSync, existsSync: exists, mkdirSync: mkdir  } = require('fs')
+const sandbox = require('@architect/sandbox')
+const { execSync: exec } = require('node:child_process')
+const test = require('tape')
+const { join } = require('node:path')
+const { copyFileSync, existsSync: exists, mkdirSync: mkdir } = require('node:fs')
 
 let arc
 let data
 
-let mock = join(__dirname, '..', 'mock')
-let tmp = join(mock, 'tmp')
-let shared = join(tmp, 'node_modules', '@architect', 'shared')
+const mock = join(__dirname, '..', 'mock')
+const tmp = join(mock, 'tmp')
+const shared = join(tmp, 'node_modules', '@architect', 'shared')
 
-test('Set up mocked files', t => {
+test('Set up mocked files', (t) => {
   t.plan(3)
   process.env.ARC_APP_NAME = 'test-app-name'
   mkdir(shared, { recursive: true })
@@ -25,15 +25,15 @@ test('Set up mocked files', t => {
   arc = require('../..') // module globally inspects arc file so need to require after chdir
 })
 
-test('starts the db server', t => {
+test('starts the db server', (t) => {
   t.plan(1)
-  sandbox.start({ quiet: true, cwd: tmp }, err => {
+  sandbox.start({ quiet: true, cwd: tmp }, (err) => {
     if (err) t.fail(err)
     else t.pass('Sandbox started')
   })
 })
 
-test('tables() returns table object', async t => {
+test('tables() returns table object', async (t) => {
   t.plan(3)
   data = await arc.tables()
   t.ok(data.accounts, 'accounts table object exists')
@@ -41,7 +41,7 @@ test('tables() returns table object', async t => {
   t.ok(data['accounts-messages'], 'accounts-messages table object exists')
 })
 
-test('tables().name() returns the table\'s name', async t => {
+test("tables().name() returns the table's name", async (t) => {
   t.plan(3)
   const { name } = await arc.tables()
   t.equal(name('accounts'), 'test-app-name-staging-accounts', 'accounts table returns correct logical id')
@@ -49,18 +49,22 @@ test('tables().name() returns the table\'s name', async t => {
   t.equal(name('accounts-messages'), 'test-app-name-staging-accounts-messages')
 })
 
-test('tables().reflect() returns the table map', async t => {
+test('tables().reflect() returns the table map', async (t) => {
   t.plan(1)
   const { reflect } = await arc.tables()
   const tables = await reflect()
-  t.deepEqual(tables, {
-    accounts: 'test-app-name-staging-accounts',
-    messages: 'test-app-name-staging-messages',
-    'accounts-messages': 'test-app-name-staging-accounts-messages',
-  }, 'map of table names to table logical ids should be correct')
+  t.deepEqual(
+    tables,
+    {
+      accounts: 'test-app-name-staging-accounts',
+      messages: 'test-app-name-staging-messages',
+      'accounts-messages': 'test-app-name-staging-accounts-messages',
+    },
+    'map of table names to table logical ids should be correct',
+  )
 })
 
-test('tables put()', async t => {
+test('tables put()', async (t) => {
   t.plan(2)
   let item = await data.accounts.put({
     accountID: 'fake',
@@ -77,10 +81,10 @@ test('tables put()', async t => {
     msgID: 'alsofake',
     extra: true,
   })
-  t.ok(item, `returned item`)
+  t.ok(item, 'returned item')
 })
 
-test('tables get()', async t => {
+test('tables get()', async (t) => {
   t.plan(4)
   let result = await data.accounts.get({
     accountID: 'fake',
@@ -96,13 +100,13 @@ test('tables get()', async t => {
   t.ok(result.extra, 'result.extra deserialized')
 })
 
-test('tables delete()', async t => {
+test('tables delete()', async (t) => {
   t.plan(4)
   await data.accounts.delete({
     accountID: 'fake',
   })
   t.ok(true, 'deleted')
-  let result = await data.accounts.get({
+  const result = await data.accounts.get({
     accountID: 'fake',
   })
   t.equal(result, undefined, 'could not get deleted accounts item')
@@ -111,16 +115,16 @@ test('tables delete()', async t => {
     msgID: 'alsofake',
   })
   t.ok(true, 'deleted')
-  let otherResult = await data['accounts-messages'].get({
+  const otherResult = await data['accounts-messages'].get({
     accountID: 'fake',
     msgID: 'alsofake',
   })
   t.equal(otherResult, undefined, 'could not get deleted accounts-messages item')
 })
 
-test('tables query()', async t => {
+test('tables query()', async (t) => {
   t.plan(3)
-  let items = await Promise.all([
+  const items = await Promise.all([
     data.accounts.put({ accountID: 'one' }),
     data.accounts.put({ accountID: 'two' }),
     data.accounts.put({ accountID: 'three' }),
@@ -128,7 +132,7 @@ test('tables query()', async t => {
 
   t.ok(items, 'got items')
 
-  let result = await data.accounts.query({
+  const result = await data.accounts.query({
     KeyConditionExpression: 'accountID = :id',
     ExpressionAttributeValues: {
       ':id': 'one',
@@ -139,9 +143,9 @@ test('tables query()', async t => {
   t.equal(result.Count, 1, 'got count of one')
 })
 
-test('tables scan()', async t => {
+test('tables scan()', async (t) => {
   t.plan(1)
-  let result = await data.accounts.scan({
+  const result = await data.accounts.scan({
     FilterExpression: 'accountID = :id',
     ExpressionAttributeValues: {
       ':id': 'two',
@@ -150,14 +154,14 @@ test('tables scan()', async t => {
   t.ok(result, 'got a result')
 })
 
-test('tables scanAll()', async t => {
+test('tables scanAll()', async (t) => {
   t.plan(2)
-  let result = await data.accounts.scanAll({ Limit: 1 })
+  const result = await data.accounts.scanAll({ Limit: 1 })
   t.ok(result, 'got a result')
   t.equal(result.length, 3, 'Got back all rows')
 })
 
-test('tables update()', async t => {
+test('tables update()', async (t) => {
   t.plan(3)
   await data.accounts.update({
     Key: {
@@ -174,7 +178,7 @@ test('tables update()', async t => {
 
   t.ok(true, 'updated without error')
 
-  let result = await data.accounts.get({
+  const result = await data.accounts.get({
     accountID: 'three',
   })
 
@@ -182,15 +186,15 @@ test('tables update()', async t => {
   t.equal(result.hits, 20, 'property updated')
 })
 
-test('server closes', t => {
+test('server closes', (t) => {
   t.plan(1)
-  sandbox.end(err => {
+  sandbox.end((err) => {
     if (err) t.fail(err)
     else t.pass('Sandbox ended')
   })
 })
 
-test('Clean up env', t => {
+test('Clean up env', (t) => {
   t.plan(1)
   delete process.env.ARC_APP_NAME
   delete process.env.ARC_ENV
diff --git a/test/integration/version-check.js b/test/integration/version-check.js
index 21dddf42..19c0671d 100644
--- a/test/integration/version-check.js
+++ b/test/integration/version-check.js
@@ -1,34 +1,33 @@
-let sandbox = require('@architect/sandbox')
-let test = require('tape')
-let { join } = require('path')
-let tiny = require('tiny-json-http')
+const sandbox = require('@architect/sandbox')
+const test = require('tape')
+const { join } = require('node:path')
+const tiny = require('tiny-json-http')
 
-let port = process.env.PORT ? process.env.PORT : '3333'
-let url = s => `http://localhost:${port}${s ? s : ''}`
-let cwd = process.cwd()
-let mock = join(cwd, 'test', 'mock', 'project')
+const port = process.env.PORT ? process.env.PORT : '3333'
+const url = (s) => `http://localhost:${port}${s ? s : ''}`
+const cwd = process.cwd()
+const mock = join(cwd, 'test', 'mock', 'project')
 
-test('Set up env', async t => {
+test('Set up env', async (t) => {
   t.plan(1)
-  let result = await sandbox.start({ quiet: true, cwd: mock })
+  const result = await sandbox.start({ quiet: true, cwd: mock })
   t.equal(result, 'Sandbox successfully started', result)
 })
 
-test('Check for incompatible versions', async t => {
+test('Check for incompatible versions', async (t) => {
   t.plan(1)
-  let dest = url('/incompatible-version')
+  const dest = url('/incompatible-version')
   try {
-    let result = await tiny.get({ url: dest })
+    const result = await tiny.get({ url: dest })
     t.fail('Should not have responded with 2xx')
     console.log(result.body)
-  }
-  catch (err) {
+  } catch (err) {
     t.match(err.body, /Incompatible version: please upgrade/, 'Got incompatible version error')
   }
 })
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
-  let result = await sandbox.end()
+  const result = await sandbox.end()
   t.equal(result, 'Sandbox successfully shut down', result)
 })
diff --git a/test/integration/ws-test.js b/test/integration/ws-test.js
index 841e48fb..30d49926 100644
--- a/test/integration/ws-test.js
+++ b/test/integration/ws-test.js
@@ -1,34 +1,36 @@
-let sandbox = require('@architect/sandbox')
-let test = require('tape')
-let { join } = require('path')
-let WebSocket = require('ws')
+const sandbox = require('@architect/sandbox')
+const test = require('tape')
+const { join } = require('node:path')
+const WebSocket = require('ws')
 
-let port = process.env.PORT ? process.env.PORT : '3333'
-let url = `ws://localhost:${port}`
+const port = process.env.PORT ? process.env.PORT : '3333'
+const url = `ws://localhost:${port}`
 
-let mock = join(__dirname, '..', 'mock', 'project')
+const mock = join(__dirname, '..', 'mock', 'project')
 
-test('Set up env', async t => {
+test('Set up env', async (t) => {
   t.plan(1)
-  let result = await sandbox.start({ quiet: true, cwd: mock })
+  const result = await sandbox.start({ quiet: true, cwd: mock })
   t.equal(result, 'Sandbox successfully started', result)
 })
 
-test('Connect, get message, send message, get message, send disconnect, be disconnected', async t => {
+test('Connect, get message, send message, get message, send disconnect, be disconnected', async (t) => {
   t.plan(3)
-  let ws = new WebSocket(url)
+  const ws = new WebSocket(url)
 
-  await new Promise(resolve => ws.once('open', resolve))
+  await new Promise((resolve) => ws.once('open', resolve))
   ws.send(JSON.stringify({ message: 'hi' }))
 
-  let infoMessage = await new Promise(resolve => ws.once('message', data => resolve(JSON.parse(data.toString('utf8')))))
+  const infoMessage = await new Promise((resolve) =>
+    ws.once('message', (data) => resolve(JSON.parse(data.toString('utf8')))),
+  )
 
   t.equal(infoMessage.message, 'hi back')
   t.equal(typeof infoMessage.info.ConnectedAt, 'string')
 
   ws.send(JSON.stringify({ message: 'disconnect me' }))
 
-  await new Promise(resolve => ws.once('close', resolve))
+  await new Promise((resolve) => ws.once('close', resolve))
 
   // At this point, it may be normal to see Sandbox errors in the console, like 'WebSocket is not open: readyState 3 (CLOSED)'
   // At this point in the test the @ws disconnect Lambda is just firing up, but we're about to shut down Sandbox, thereby creating a Lambda execution race condition
@@ -37,8 +39,8 @@ test('Connect, get message, send message, get message, send disconnect, be disco
   t.pass('Disconnected')
 })
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
-  let result = await sandbox.end()
+  const result = await sandbox.end()
   t.equal(result, 'Sandbox successfully shut down', result)
 })
diff --git a/test/mock/mock-sns-event.json b/test/mock/mock-sns-event.json
index 88fdcdec..3b18076b 100644
--- a/test/mock/mock-sns-event.json
+++ b/test/mock/mock-sns-event.json
@@ -1,9 +1,10 @@
 {
-  "Records": [{
-    "EventSource":"aws:sns",
-    "EventVersion": "1.0",
-    "EventSubscriptionArn": "arn:aws:sns:us-east-1:123456789012:lambda_topic:xxx",
-    "Sns": {
+  "Records": [
+    {
+      "EventSource": "aws:sns",
+      "EventVersion": "1.0",
+      "EventSubscriptionArn": "arn:aws:sns:us-east-1:123456789012:lambda_topic:xxx",
+      "Sns": {
         "Type": "Notification",
         "MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
         "TopicArn": "arn:aws:sns:us-east-1:123456789012:lambda_topic",
@@ -14,7 +15,8 @@
         "Signature": "xxx",
         "SigningCertUrl": "..",
         "UnsubscribeUrl": "..",
-        "MessageAttributes": {"key":{"Type":"String","Value":"value"}}
+        "MessageAttributes": { "key": { "Type": "String", "Value": "value" } }
+      }
     }
-  }]
+  ]
 }
diff --git a/test/mock/mock-sqs-event.json b/test/mock/mock-sqs-event.json
index b33878c5..2e270283 100644
--- a/test/mock/mock-sqs-event.json
+++ b/test/mock/mock-sqs-event.json
@@ -1,18 +1,20 @@
 {
-  "Records": [{ 
-    "messageId": "xxx", 
-    "receiptHandle": "xxx", 
-    "body": "{\"msg\":true}", 
-    "attributes": { 
-      "ApproximateReceiveCount": "1", 
-      "SentTimestamp": "1534811942701", 
-      "SenderId": "xxx", 
-      "ApproximateFirstReceiveTimestamp": "1534811942713" 
-    }, 
-    "messageAttributes": {}, 
-    "md5OfBody": "xxx", 
-    "eventSource": "aws:sqs", 
-    "eventSourceARN": "arn:aws:sqs:us-east-1:555555555555:testapp-staging-test-q", 
-    "awsRegion": "us-east-1" 
-  }]
+  "Records": [
+    {
+      "messageId": "xxx",
+      "receiptHandle": "xxx",
+      "body": "{\"msg\":true}",
+      "attributes": {
+        "ApproximateReceiveCount": "1",
+        "SentTimestamp": "1534811942701",
+        "SenderId": "xxx",
+        "ApproximateFirstReceiveTimestamp": "1534811942713"
+      },
+      "messageAttributes": {},
+      "md5OfBody": "xxx",
+      "eventSource": "aws:sqs",
+      "eventSourceARN": "arn:aws:sqs:us-east-1:555555555555:testapp-staging-test-q",
+      "awsRegion": "us-east-1"
+    }
+  ]
 }
diff --git a/test/mock/project/src/events/async-event/index.js b/test/mock/project/src/events/async-event/index.js
index 746ee909..82b0cae9 100644
--- a/test/mock/project/src/events/async-event/index.js
+++ b/test/mock/project/src/events/async-event/index.js
@@ -1,8 +1,8 @@
-let arc = require('../../../../../../')
-let tiny = require('tiny-json-http')
+const arc = require('../../../../../../')
+const tiny = require('tiny-json-http')
 
-async function handler (payload) {
-  let url = `http://localhost:1111/events/async-event?${encodeURI(JSON.stringify(payload))}`
+async function handler(payload) {
+  const url = `http://localhost:1111/events/async-event?${encodeURI(JSON.stringify(payload))}`
   await tiny.post({ url })
 }
 
diff --git a/test/mock/project/src/events/cb-event/index.js b/test/mock/project/src/events/cb-event/index.js
index c1ac9ba8..42fae971 100644
--- a/test/mock/project/src/events/cb-event/index.js
+++ b/test/mock/project/src/events/cb-event/index.js
@@ -1,8 +1,8 @@
-let arc = require('../../../../../../')
-let tiny = require('tiny-json-http')
+const arc = require('../../../../../../')
+const tiny = require('tiny-json-http')
 
-function handler (payload, callback) {
-  let url = `http://localhost:1111/events/cb-event?${encodeURI(JSON.stringify(payload))}`
+function handler(payload, callback) {
+  const url = `http://localhost:1111/events/cb-event?${encodeURI(JSON.stringify(payload))}`
   tiny.post({ url }, callback)
 }
 
diff --git a/test/mock/project/src/http/get-catchall/index.js b/test/mock/project/src/http/get-catchall/index.js
index 61b27ce4..39252f2c 100644
--- a/test/mock/project/src/http/get-catchall/index.js
+++ b/test/mock/project/src/http/get-catchall/index.js
@@ -1,4 +1,4 @@
-let arc = require('../../../../../../src')
-let asap = require('@architect/asap')
+const arc = require('../../../../../../src')
+const asap = require('@architect/asap')
 
 exports.handler = arc.http(asap())
diff --git a/test/mock/project/src/http/get-http_async_session/index.js b/test/mock/project/src/http/get-http_async_session/index.js
index 5c87a0e1..b9ec1955 100644
--- a/test/mock/project/src/http/get-http_async_session/index.js
+++ b/test/mock/project/src/http/get-http_async_session/index.js
@@ -1,7 +1,6 @@
-let arc = require('../../../../../../src')
+const arc = require('../../../../../../src')
 
-
-async function handler (req) {
+async function handler(req) {
   let { query, session } = req
   if (query.session === 'create') {
     session.unique = new Date().toISOString()
diff --git a/test/mock/project/src/http/get-http_session/index.js b/test/mock/project/src/http/get-http_session/index.js
index b8fce6f0..f814bdc8 100644
--- a/test/mock/project/src/http/get-http_session/index.js
+++ b/test/mock/project/src/http/get-http_session/index.js
@@ -1,6 +1,6 @@
-let arc = require('../../../../../../src')
+const arc = require('../../../../../../src')
 
-function handler (req, res) {
+function handler(req, res) {
   let { query, session } = req
   if (query.session === 'create') {
     session.unique = new Date().toISOString()
diff --git a/test/mock/project/src/http/get-incompatible_version/index.js b/test/mock/project/src/http/get-incompatible_version/index.js
index ec50dbda..ac49bf22 100644
--- a/test/mock/project/src/http/get-incompatible_version/index.js
+++ b/test/mock/project/src/http/get-incompatible_version/index.js
@@ -1,7 +1,7 @@
 // eslint-disable-next-line
-exports.handler = async event => {
+exports.handler = async (event) => {
   process.env.ARC_SANDBOX = JSON.stringify({ version: '4.0.0' })
   // eslint-disable-next-line
-  let arc = require('../../../../../../src')
+  const arc = require('../../../../../../src')
   return { ok: true }
 }
diff --git a/test/mock/project/src/http/post-publish_event-catchall/index.js b/test/mock/project/src/http/post-publish_event-catchall/index.js
index d20abcbe..ab180f96 100644
--- a/test/mock/project/src/http/post-publish_event-catchall/index.js
+++ b/test/mock/project/src/http/post-publish_event-catchall/index.js
@@ -1,11 +1,11 @@
-let arc = require('../../../../../../')
+const arc = require('../../../../../../')
 
-exports.handler = async function (req) {
-  let { rawPath } = req
-  let parts = rawPath.split('/').filter(p => p)
-  let type = parts[1]
-  let name = parts[2]
-  let payload = { ok: true }
+exports.handler = async (req) => {
+  const { rawPath } = req
+  const parts = rawPath.split('/').filter((p) => p)
+  const type = parts[1]
+  const name = parts[2]
+  const payload = { ok: true }
   await arc[type].publish({
     name,
     payload,
diff --git a/test/mock/project/src/queues/async-queue/index.js b/test/mock/project/src/queues/async-queue/index.js
index d834d42a..767f8547 100644
--- a/test/mock/project/src/queues/async-queue/index.js
+++ b/test/mock/project/src/queues/async-queue/index.js
@@ -1,8 +1,8 @@
-let arc = require('../../../../../../')
-let tiny = require('tiny-json-http')
+const arc = require('../../../../../../')
+const tiny = require('tiny-json-http')
 
-async function handler (payload) {
-  let url = `http://localhost:1111/queues/async-queue?${encodeURI(JSON.stringify(payload))}`
+async function handler(payload) {
+  const url = `http://localhost:1111/queues/async-queue?${encodeURI(JSON.stringify(payload))}`
   await tiny.post({ url })
 }
 
diff --git a/test/mock/project/src/queues/cb-queue/index.js b/test/mock/project/src/queues/cb-queue/index.js
index 26468324..406d0b84 100644
--- a/test/mock/project/src/queues/cb-queue/index.js
+++ b/test/mock/project/src/queues/cb-queue/index.js
@@ -1,8 +1,8 @@
-let arc = require('../../../../../../')
-let tiny = require('tiny-json-http')
+const arc = require('../../../../../../')
+const tiny = require('tiny-json-http')
 
-function handler (payload, callback) {
-  let url = `http://localhost:1111/queues/cb-queue?${encodeURI(JSON.stringify(payload))}`
+function handler(payload, callback) {
+  const url = `http://localhost:1111/queues/cb-queue?${encodeURI(JSON.stringify(payload))}`
   tiny.post({ url }, callback)
 }
 
diff --git a/test/mock/project/src/ws/connect/index.js b/test/mock/project/src/ws/connect/index.js
index 15ef8e3c..709aabdd 100644
--- a/test/mock/project/src/ws/connect/index.js
+++ b/test/mock/project/src/ws/connect/index.js
@@ -1,5 +1,4 @@
-
-async function handler () {
+async function handler() {
   console.log('connect')
   return {
     statusCode: 200,
diff --git a/test/mock/project/src/ws/default/index.js b/test/mock/project/src/ws/default/index.js
index fe0793ab..d71df496 100644
--- a/test/mock/project/src/ws/default/index.js
+++ b/test/mock/project/src/ws/default/index.js
@@ -1,12 +1,12 @@
-let arc = require('../../../../../../src')
+const arc = require('../../../../../../src')
 
-async function handler (event) {
+async function handler(event) {
   console.log({ body: event.body })
   const { connectionId } = event.requestContext
   const message = JSON.parse(event.body)
   if (message.message === 'hi') {
     console.log('hi')
-    let info = await arc.ws.info({ id: connectionId })
+    const info = await arc.ws.info({ id: connectionId })
     await arc.ws.send({ id: connectionId, payload: { message: 'hi back', info } })
   }
   if (message.message === 'disconnect me') {
diff --git a/test/mock/project/src/ws/disconnect/index.js b/test/mock/project/src/ws/disconnect/index.js
index 8cef62ca..c5c5fa60 100644
--- a/test/mock/project/src/ws/disconnect/index.js
+++ b/test/mock/project/src/ws/disconnect/index.js
@@ -1,5 +1,4 @@
-
-async function handler () {
+async function handler() {
   console.log('disconnect')
   return {
     statusCode: 200,
diff --git a/test/unit/src/events/publish-test.js b/test/unit/src/events/publish-test.js
index d6496c1e..6c0cc46a 100644
--- a/test/unit/src/events/publish-test.js
+++ b/test/unit/src/events/publish-test.js
@@ -1,25 +1,37 @@
-let test = require('tape')
+const test = require('tape')
 let publish
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
 
-  let arc = require('../../../..')
+  const arc = require('../../../..')
   publish = arc.events.publish
   t.ok(publish, 'Got events.publish method')
 })
 
-test('events.publish should throw if there is no parameter name', t => {
+test('events.publish should throw if there is no parameter name', (t) => {
   t.plan(1)
-  t.throws(() => { publish({}) }, /missing params.name/, 'throws missing name parameter exception')
+  t.throws(
+    () => {
+      publish({})
+    },
+    /missing params.name/,
+    'throws missing name parameter exception',
+  )
 })
 
-test('events.publish should throw if there is no parameter payload', t => {
+test('events.publish should throw if there is no parameter payload', (t) => {
   t.plan(1)
-  t.throws(() => { publish({ name: 'batman' }) }, /missing params.payload/, 'throws missing payload parameter exception')
+  t.throws(
+    () => {
+      publish({ name: 'batman' })
+    },
+    /missing params.payload/,
+    'throws missing payload parameter exception',
+  )
 })
 
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   t.pass('Done!')
diff --git a/test/unit/src/events/subscribe-test.js b/test/unit/src/events/subscribe-test.js
index 2663821e..a095a8d6 100644
--- a/test/unit/src/events/subscribe-test.js
+++ b/test/unit/src/events/subscribe-test.js
@@ -1,48 +1,52 @@
-let test = require('tape')
-let sinon = require('sinon')
+const test = require('tape')
+const sinon = require('sinon')
 let subscribe
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
 
-  let arc = require('../../../..')
+  const arc = require('../../../..')
   subscribe = arc.events.subscribe
   t.ok(subscribe, 'Got events.subscribe method')
 })
 
-test('events.subscribe should invoke provided handler for each SNS event Record', t => {
+test('events.subscribe should invoke provided handler for each SNS event Record', (t) => {
   t.plan(2)
-  let fake = sinon.fake.yields()
-  let handler = subscribe(fake)
-  handler({
-    Records: [ { Sns: { Message: '{"hey":"there"}' } }, { Sns: { Message: '{"sup":"bud"}' } } ],
-  }, {}, function (err) {
-    if (err) t.fail(err)
-    else {
-      t.ok(fake.calledWith({ hey: 'there' }), 'subscribe handler called with first SNS record')
-      t.ok(fake.calledWith({ sup: 'bud' }), 'subscribe handler called with second SNS record')
-    }
-  })
+  const fake = sinon.fake.yields()
+  const handler = subscribe(fake)
+  handler(
+    {
+      Records: [{ Sns: { Message: '{"hey":"there"}' } }, { Sns: { Message: '{"sup":"bud"}' } }],
+    },
+    {},
+    (err) => {
+      if (err) t.fail(err)
+      else {
+        t.ok(fake.calledWith({ hey: 'there' }), 'subscribe handler called with first SNS record')
+        t.ok(fake.calledWith({ sup: 'bud' }), 'subscribe handler called with second SNS record')
+      }
+    },
+  )
 })
 
-test('events.subscribe should invoke provided handler for each SNS event Record when handler is async', async t => {
+test('events.subscribe should invoke provided handler for each SNS event Record when handler is async', async (t) => {
   t.plan(2)
-  let fake = sinon.fake()
-  let handler = subscribe(async function (json) {
+  const fake = sinon.fake()
+  const handler = subscribe(async (json) => {
     await fake(json)
   })
   await handler({
-    Records: [ { Sns: { Message: '{"hey":"there"}' } }, { Sns: { Message: '{"sup":"bud"}' } } ],
+    Records: [{ Sns: { Message: '{"hey":"there"}' } }, { Sns: { Message: '{"sup":"bud"}' } }],
   })
   t.ok(fake.calledWith({ hey: 'there' }), 'subscribe handler called with first SNS record')
   t.ok(fake.calledWith({ sup: 'bud' }), 'subscribe handler called with second SNS record')
 })
 
-test('events.subscribe should fall back to an empty event if one is not provided', t => {
+test('events.subscribe should fall back to an empty event if one is not provided', (t) => {
   t.plan(1)
-  let fake = sinon.fake.yields()
-  let handler = subscribe(fake)
-  handler(null, {}, function (err) {
+  const fake = sinon.fake.yields()
+  const handler = subscribe(fake)
+  handler(null, {}, (err) => {
     if (err) t.fail(err)
     else {
       t.ok(fake.calledWith({}), 'subscribe handler called with empty SNS record')
@@ -50,17 +54,17 @@ test('events.subscribe should fall back to an empty event if one is not provided
   })
 })
 
-test('events.subscribe should fall back to an empty event if one is not provided (async)', async t => {
+test('events.subscribe should fall back to an empty event if one is not provided (async)', async (t) => {
   t.plan(1)
-  let fake = sinon.fake()
-  let handler = subscribe(async function (json) {
+  const fake = sinon.fake()
+  const handler = subscribe(async (json) => {
     await fake(json)
   })
   await handler()
   t.ok(fake.calledWith({}), 'subscribe handler called with empty SNS record')
 })
 
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   t.pass('Done!')
diff --git a/test/unit/src/http/csrf/create-and-verify-test.js b/test/unit/src/http/csrf/create-and-verify-test.js
index 7bac1e4c..f32562d6 100644
--- a/test/unit/src/http/csrf/create-and-verify-test.js
+++ b/test/unit/src/http/csrf/create-and-verify-test.js
@@ -1,34 +1,34 @@
-let http = require('../../../../../src/http')
-let test = require('tape')
+const http = require('../../../../../src/http')
+const test = require('tape')
 
-test('exists', t => {
+test('exists', (t) => {
   t.plan(2)
   t.ok(http.csrf.create, 'create')
   t.ok(http.csrf.verify, 'verify')
 })
 
-test('create a value', t => {
+test('create a value', (t) => {
   t.plan(1)
-  let val = http.csrf.create()
+  const val = http.csrf.create()
   t.ok(val, 'created value')
 })
 
-test('verify a value', t => {
+test('verify a value', (t) => {
   t.plan(1)
-  let val = http.csrf.create()
+  const val = http.csrf.create()
   t.ok(http.csrf.verify(val), 'value verified')
 })
 
-test('tampered token is falsy', t => {
+test('tampered token is falsy', (t) => {
   t.plan(1)
-  let tamperedToken = '3d879d515ab241429c97dfea6d1e1927.1584118407000.b0b34563d569030cbe9a4ea63312f23729813b838478420e3811c0bfeaf3add1'
+  const tamperedToken =
+    '3d879d515ab241429c97dfea6d1e1927.1584118407000.b0b34563d569030cbe9a4ea63312f23729813b838478420e3811c0bfeaf3add1'
   t.ok(http.csrf.verify(tamperedToken) === false, 'value falsy')
 })
 
-test('token expired is falsy', t  => {
+test('token expired is falsy', (t) => {
   t.plan(1)
-  let expiredToken = '3d879d515ab241419c97dfea6d1e1927.1584118407000.b0b34563d569030cbe9a4ea63312f23729813b838478420e3811c0bfeaf3add1'
+  const expiredToken =
+    '3d879d515ab241419c97dfea6d1e1927.1584118407000.b0b34563d569030cbe9a4ea63312f23729813b838478420e3811c0bfeaf3add1'
   t.ok(http.csrf.verify(expiredToken) === false, 'value falsy')
 })
-
-
diff --git a/test/unit/src/http/helpers/body-parser-test.js b/test/unit/src/http/helpers/body-parser-test.js
index 9d36a7a1..b05a8280 100644
--- a/test/unit/src/http/helpers/body-parser-test.js
+++ b/test/unit/src/http/helpers/body-parser-test.js
@@ -1,40 +1,39 @@
-let parseBody = require('../../../../../src/http/helpers/body-parser')
-let test = require('tape')
+const parseBody = require('../../../../../src/http/helpers/body-parser')
+const test = require('tape')
 
-let str = i => JSON.stringify(i)
-let b64encode = i => new Buffer.from(i).toString('base64')
+const str = (i) => JSON.stringify(i)
+const b64encode = (i) => new Buffer.from(i).toString('base64')
 
 // Bodies
-let hi = { hi: 'there' }
-let hiBase64 = { base64: b64encode('hi there') } // Arc 5
-let hiBase64file = b64encode('hi there\n') // text file style
-let hiFormURL = b64encode('hi=there')
-let hiText = 'hi there'
-let hiXml = '<?xml version="1.0"?><hi>there</hi>'
+const hi = { hi: 'there' }
+const hiBase64 = { base64: b64encode('hi there') } // Arc 5
+const hiBase64file = b64encode('hi there\n') // text file style
+const hiFormURL = b64encode('hi=there')
+const hiText = 'hi there'
+const hiXml = '<?xml version="1.0"?><hi>there</hi>'
 
 // Content types
-let json = { 'Content-Type': 'application/json' }
-let formURLencoded = { 'Content-Type': 'application/x-www-form-urlencoded' }
-let multiPartFormData = { 'Content-Type': 'multipart/form-data' }
-let octetStream = { 'Content-Type': 'application/octet-stream' }
-let text = { 'Content-Type': 'text/plain' }
-let xmlText = { 'Content-Type': 'text/xml' }
-let xmlApp = { 'Content-Type': 'application/xml' }
-let multipleTypes = { 'Content-Type': 'application/json, text/plain' }
-
-test('Borked requests', t => {
+const json = { 'Content-Type': 'application/json' }
+const formURLencoded = { 'Content-Type': 'application/x-www-form-urlencoded' }
+const multiPartFormData = { 'Content-Type': 'multipart/form-data' }
+const octetStream = { 'Content-Type': 'application/octet-stream' }
+const text = { 'Content-Type': 'text/plain' }
+const xmlText = { 'Content-Type': 'text/xml' }
+const xmlApp = { 'Content-Type': 'application/xml' }
+const multipleTypes = { 'Content-Type': 'application/json, text/plain' }
+
+test('Borked requests', (t) => {
   t.plan(1)
 
-  let req = {
+  const req = {
     body: str(hi),
     headers: multipleTypes,
     isBase64Encoded: false,
   }
   t.equals(str(parseBody(req)), str(hi), `body matches ${str(req.body)}`)
-
 })
 
-test('Architect v10+ requests', t => {
+test('Architect v10+ requests', (t) => {
   t.plan(6)
 
   // Plain text
@@ -82,7 +81,7 @@ test('Architect v10+ requests', t => {
   t.equals(parseBody(req), hiXml, `body matches ${str(req.body)}`)
 })
 
-test('Architect v6+ requests', t => {
+test('Architect v6+ requests', (t) => {
   t.plan(9)
   // HTTP + Lambda v2.0 payloads pass in raw JSON
   let req = {
@@ -139,10 +138,9 @@ test('Architect v6+ requests', t => {
   // Pass through octet stream / base64
   req.headers = octetStream
   t.equals(str(parseBody(req)), str({ base64: hiBase64file }), `body matches ${str(req.body)}`)
-
 })
 
-test('Architect v5 requests', t => {
+test('Architect v5 requests', (t) => {
   t.plan(5)
   // Pass through empty body
   let req = {
diff --git a/test/unit/src/http/helpers/url-test.js b/test/unit/src/http/helpers/url-test.js
index 7a44a3e3..31f26040 100644
--- a/test/unit/src/http/helpers/url-test.js
+++ b/test/unit/src/http/helpers/url-test.js
@@ -1,51 +1,51 @@
-let test = require('tape')
-let url = require('../../../../../src/http/helpers/url')
+const test = require('tape')
+const url = require('../../../../../src/http/helpers/url')
 
-function reset () {
+function reset() {
   delete process.env.ARC_ENV
   delete process.env.ARC_LOCAL
   if (process.env.ARC_ENV) throw ReferenceError('ARC_ENV not unset')
 }
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
   t.ok(url, 'url helper found')
 })
 
-test('Local (ARC_ENV=testing) env returns unmodified URL', t => {
+test('Local (ARC_ENV=testing) env returns unmodified URL', (t) => {
   t.plan(1)
   reset()
   process.env.ARC_ENV = 'testing'
-  let asset = url('foo.png')
+  const asset = url('foo.png')
   t.equal(asset, 'foo.png', 'Returned unmodified path')
 })
 
-test('Staging env returns staging-prefixed URL', t => {
+test('Staging env returns staging-prefixed URL', (t) => {
   t.plan(1)
   reset()
   process.env.ARC_ENV = 'staging'
-  let asset = url('/')
+  const asset = url('/')
   t.equal(asset, '/staging/', 'Returned staging path')
 })
 
-test('Local env with staging mask (ARC_ENV=staging, ARC_LOCAL=1) returns unmodified path', t => {
+test('Local env with staging mask (ARC_ENV=staging, ARC_LOCAL=1) returns unmodified path', (t) => {
   t.plan(1)
   reset()
   process.env.ARC_ENV = 'staging'
   process.env.ARC_LOCAL = '1'
-  let asset = url('bar.png')
+  const asset = url('bar.png')
   t.equal(asset, 'bar.png', 'Returned staging path')
 })
 
-test('Production env returns production-prefixed URL', t => {
+test('Production env returns production-prefixed URL', (t) => {
   t.plan(1)
   reset()
   process.env.ARC_ENV = 'production'
-  let asset = url('/')
+  const asset = url('/')
   t.equal(asset, '/production/', 'Returned staging path')
 })
 
-test('Reset', t => {
+test('Reset', (t) => {
   reset()
   t.end()
 })
diff --git a/test/unit/src/http/index-async-req-test.js b/test/unit/src/http/index-async-req-test.js
index 4e79e8e6..14f5f487 100644
--- a/test/unit/src/http/index-async-req-test.js
+++ b/test/unit/src/http/index-async-req-test.js
@@ -1,53 +1,50 @@
-
-let { join } = require('path')
-let { deepStrictEqual } = require('assert')
-let sut = join(process.cwd(), 'src')
-let test = require('tape')
+const { join } = require('node:path')
+const { deepStrictEqual } = require('node:assert')
+const sut = join(process.cwd(), 'src')
+const test = require('tape')
 let arc
 
-let reqs = require('@architect/req-res-fixtures').http.req
+const reqs = require('@architect/req-res-fixtures').http.req
 
-let str = i => JSON.stringify(i)
-let isObject = t => typeof t === 'object' && !!(t)
-let unNulled = (before, after) => before === null && isObject(after)
-let match = (copy, item) => `${copy} matches: ${item}`
-let basicResponse = { statusCode: 200 }
+const str = (i) => JSON.stringify(i)
+const isObject = (t) => typeof t === 'object' && !!t
+const unNulled = (before, after) => before === null && isObject(after)
+const match = (copy, item) => `${copy} matches: ${item}`
+const basicResponse = { statusCode: 200 }
 
-let arc6RestNull = [ 'body', 'pathParameters', 'queryStringParameters', 'multiValueQueryStringParameters' ]
-let isNulled = key => arc6RestNull.some(v => v === key)
+const arc6RestNull = ['body', 'pathParameters', 'queryStringParameters', 'multiValueQueryStringParameters']
+const isNulled = (key) => arc6RestNull.some((v) => v === key)
 
-let arc6RestPrettyParams = {
+const arc6RestPrettyParams = {
   method: 'httpMethod',
   params: 'pathParameters',
   query: 'queryStringParameters',
 }
 
-let requestsTested = []
+const requestsTested = []
 
-let copy = obj => JSON.parse(JSON.stringify(obj))
+const copy = (obj) => JSON.parse(JSON.stringify(obj))
 
-function check ({ req, request, t }) {
-  console.log(`Got request:`, req)
+function check({ req, request, t }) {
+  console.log('Got request:', req)
   requestsTested.push(request)
 
   // Make sure all original keys are present and accounted for
-  Object.keys(request).forEach(key => {
+  Object.keys(request).forEach((key) => {
     // eslint-disable-next-line
-    if (!req.hasOwnProperty(key)) t.fail(`Original request param missing from interpolated request: ${key}`)
+    if (!Object.hasOwn(req, key)) t.fail(`Original request param missing from interpolated request: ${key}`)
   })
-  Object.entries(req).forEach(([ key, val ]) => {
+  Object.entries(req).forEach(([key, val]) => {
     // Make sure we don't have any false positives matching undefined tests
     if (req[key] === undefined) t.fail(`Property is undefined: ${key}`)
     // Compare mutation of nulls into objects
     if (isNulled(key) && request[key] === null) {
       if (unNulled(request[key], val)) {
         t.pass(match(`req.${key}`, req[key]))
-      }
-      else {
+      } else {
         t.fail(`Param not un-nulled: ${key}: ${val}`)
       }
-    }
-    else {
+    } else {
       t.equal(str(val), str(req[key]), match(`req.${key}`, str(req[key])))
     }
     // Compare interpolation to nicer, backwards compat req params
@@ -58,7 +55,7 @@ function check ({ req, request, t }) {
   t.ok(req.session, 'req.session is present')
 }
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(2)
   // Set env var to keep from stalling on db reads in CI
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
@@ -68,223 +65,223 @@ test('Set up env', t => {
   t.ok(arc.http.async, 'Loaded legacy async method')
 })
 
-test('Architect v7 (HTTP): get /', async t => {
+test('Architect v7 (HTTP): get /', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getIndex
+  const request = reqs.arc7.getIndex
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get /?whats=up', async t => {
+test('Architect v7 (HTTP): get /?whats=up', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getWithQueryString
+  const request = reqs.arc7.getWithQueryString
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get /?whats=up&whats=there', async t => {
+test('Architect v7 (HTTP): get /?whats=up&whats=there', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getWithQueryStringDuplicateKey
+  const request = reqs.arc7.getWithQueryStringDuplicateKey
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get /nature/hiking', async t => {
+test('Architect v7 (HTTP): get /nature/hiking', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getWithParam
+  const request = reqs.arc7.getWithParam
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get /{proxy+} (/nature/hiking)', async t => {
+test('Architect v7 (HTTP): get /{proxy+} (/nature/hiking)', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getProxyPlus
+  const request = reqs.arc7.getProxyPlus
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get /$default', async t => {
+test('Architect v7 (HTTP): get /$default', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.get$default
+  const request = reqs.arc7.get$default
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get /path/* (/path/hi/there)', async t => {
+test('Architect v7 (HTTP): get /path/* (/path/hi/there)', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getCatchall
+  const request = reqs.arc7.getCatchall
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get /:activities/{proxy+} (/nature/hiking/wilderness)', async t => {
+test('Architect v7 (HTTP): get /:activities/{proxy+} (/nature/hiking/wilderness)', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getWithParamAndCatchall
+  const request = reqs.arc7.getWithParamAndCatchall
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get / with brotli compression', async t => {
+test('Architect v7 (HTTP): get / with brotli compression', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getWithBrotli
+  const request = reqs.arc7.getWithBrotli
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): get / with gzip compression', async t => {
+test('Architect v7 (HTTP): get / with gzip compression', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getWithGzip
+  const request = reqs.arc7.getWithGzip
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): post /form (JSON)', async t => {
+test('Architect v7 (HTTP): post /form (JSON)', async (t) => {
   t.plan(23)
-  let request = reqs.arc7.postJson
+  const request = reqs.arc7.postJson
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): post /form (form URL encoded)', async t => {
+test('Architect v7 (HTTP): post /form (form URL encoded)', async (t) => {
   t.plan(23)
-  let request = reqs.arc7.postFormURL
+  const request = reqs.arc7.postFormURL
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): post /form (multipart form data)', async t => {
+test('Architect v7 (HTTP): post /form (multipart form data)', async (t) => {
   t.plan(23)
-  let request = reqs.arc7.postMultiPartFormData
+  const request = reqs.arc7.postMultiPartFormData
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): post /form (octet stream)', async t => {
+test('Architect v7 (HTTP): post /form (octet stream)', async (t) => {
   t.plan(23)
-  let request = reqs.arc7.postOctetStream
+  const request = reqs.arc7.postOctetStream
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): put /form (JSON)', async t => {
+test('Architect v7 (HTTP): put /form (JSON)', async (t) => {
   t.plan(23)
-  let request = reqs.arc7.putJson
+  const request = reqs.arc7.putJson
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): patch /form (JSON)', async t => {
+test('Architect v7 (HTTP): patch /form (JSON)', async (t) => {
   t.plan(23)
-  let request = reqs.arc7.patchJson
+  const request = reqs.arc7.patchJson
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v7 (HTTP): delete /form (JSON)', async t => {
+test('Architect v7 (HTTP): delete /form (JSON)', async (t) => {
   t.plan(23)
-  let request = reqs.arc7.deleteJson
+  const request = reqs.arc7.deleteJson
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
@@ -294,257 +291,260 @@ test('Architect v7 (HTTP): delete /form (JSON)', async t => {
  * - `nulls` passed instead of empty objects
  * - All bodies are base64 encoded
  */
-test('Architect v6 (REST): get /', async t => {
+test('Architect v6 (REST): get /', async (t) => {
   t.plan(19)
-  let request = reqs.arc6.getIndex
+  const request = reqs.arc6.getIndex
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): get /?whats=up', async t => {
+test('Architect v6 (REST): get /?whats=up', async (t) => {
   t.plan(19)
-  let request = reqs.arc6.getWithQueryString
+  const request = reqs.arc6.getWithQueryString
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): get /?whats=up&whats=there', async t => {
+test('Architect v6 (REST): get /?whats=up&whats=there', async (t) => {
   t.plan(19)
-  let request = reqs.arc6.getWithQueryStringDuplicateKey
+  const request = reqs.arc6.getWithQueryStringDuplicateKey
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): get /nature/hiking', async t => {
+test('Architect v6 (REST): get /nature/hiking', async (t) => {
   t.plan(19)
-  let request = reqs.arc6.getWithParam
+  const request = reqs.arc6.getWithParam
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): get /{proxy+}', async t => {
+test('Architect v6 (REST): get /{proxy+}', async (t) => {
   t.plan(19)
-  let request = reqs.arc6.getProxyPlus
+  const request = reqs.arc6.getProxyPlus
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): get /path/* (/path/hi/there)', async t => {
+test('Architect v6 (REST): get /path/* (/path/hi/there)', async (t) => {
   t.plan(19)
-  let request = reqs.arc6.getCatchall
+  const request = reqs.arc6.getCatchall
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): get /:activities/{proxy+} (/nature/hiking/wilderness)', async t => {
+test('Architect v6 (REST): get /:activities/{proxy+} (/nature/hiking/wilderness)', async (t) => {
   t.plan(19)
-  let request = reqs.arc6.getWithParamAndCatchall
+  const request = reqs.arc6.getWithParamAndCatchall
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): post /form (JSON)', async t => {
+test('Architect v6 (REST): post /form (JSON)', async (t) => {
   t.plan(20)
-  let request = reqs.arc6.postJson
+  const request = reqs.arc6.postJson
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): post /form (form URL encoded)', async t => {
+test('Architect v6 (REST): post /form (form URL encoded)', async (t) => {
   t.plan(20)
-  let request = reqs.arc6.postFormURL
+  const request = reqs.arc6.postFormURL
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): post /form (multipart form data)', async t => {
+test('Architect v6 (REST): post /form (multipart form data)', async (t) => {
   t.plan(20)
-  let request = reqs.arc6.postMultiPartFormData
+  const request = reqs.arc6.postMultiPartFormData
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): post /form (octet stream)', async t => {
+test('Architect v6 (REST): post /form (octet stream)', async (t) => {
   t.plan(20)
-  let request = reqs.arc6.postOctetStream
+  const request = reqs.arc6.postOctetStream
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): put /form (JSON)', async t => {
+test('Architect v6 (REST): put /form (JSON)', async (t) => {
   t.plan(20)
-  let request = reqs.arc6.putJson
+  const request = reqs.arc6.putJson
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): patch /form (JSON)', async t => {
+test('Architect v6 (REST): patch /form (JSON)', async (t) => {
   t.plan(20)
-  let request = reqs.arc6.patchJson
+  const request = reqs.arc6.patchJson
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('Architect v6 (REST): delete /form (JSON)', async t => {
+test('Architect v6 (REST): delete /form (JSON)', async (t) => {
   t.plan(20)
-  let request = reqs.arc6.deleteJson
+  const request = reqs.arc6.deleteJson
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http(fn)
+  const handler = arc.http(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-test('arc.http should allow the mutation of request object between middleware functions', t => {
+test('arc.http should allow the mutation of request object between middleware functions', (t) => {
   t.plan(1)
-  let request = reqs.arc7.getIndex
-  let req = copy(request)
-  async function one (req) {
+  const request = reqs.arc7.getIndex
+  const req = copy(request)
+  async function one(req) {
     req.body = req.body || {}
     req.body.munge = true
     return req
   }
-  async function two (req) {
+  async function two(req) {
     t.ok(req.body.munge, 'request object was mutated in middleware')
     return { statusCode: 200, body: req.body }
   }
-  let handler = arc.http(one, two)
+  const handler = arc.http(one, two)
   handler(req)
 })
 
-test('arc.http should pass along original request if function does not return', async t => {
+test('arc.http should pass along original request if function does not return', async (t) => {
   t.plan(1)
-  let request = reqs.arc7.getIndex
+  const request = reqs.arc7.getIndex
   let gotOne
-  async function one (req) {
+  async function one(req) {
     gotOne = req
     return
   }
   let gotTwo
-  async function two (req) {
+  async function two(req) {
     gotTwo = req
     return { statusCode: 200 }
   }
-  let req = copy(request)
-  let handler = arc.http(one, two)
+  const req = copy(request)
+  const handler = arc.http(one, two)
   await handler(req)
   t.equal(str(gotOne), str(gotTwo), match('second function request', `${str(gotTwo).substr(0, 50)}...`))
 })
 
-test('Verify all Arc v7 (HTTP) + Arc v6 (REST) request fixtures were tested', t => {
-  let totalReqs = Object.keys(reqs.arc7).length + Object.keys(reqs.arc6).length
+test('Verify all Arc v7 (HTTP) + Arc v6 (REST) request fixtures were tested', (t) => {
+  const totalReqs = Object.keys(reqs.arc7).length + Object.keys(reqs.arc6).length
   t.plan(totalReqs)
-  let tester = ([ name, req ]) => {
-    t.ok(requestsTested.some(tested => {
-      try {
-        deepStrictEqual(req, tested)
-        return true
-      }
-      catch { /* noop */ }
-    }), `Tested req: ${name}`)
-  }
-  console.log(`Arc 7 requests`)
+  const tester = ([name, req]) => {
+    t.ok(
+      requestsTested.some((tested) => {
+        try {
+          deepStrictEqual(req, tested)
+          return true
+        } catch {
+          /* noop */
+        }
+      }),
+      `Tested req: ${name}`,
+    )
+  }
+  console.log('Arc 7 requests')
   Object.entries(reqs.arc7).forEach(tester)
-  console.log(`Arc 6 requests`)
+  console.log('Arc 6 requests')
   Object.entries(reqs.arc6).forEach(tester)
 })
 
-test('Verify legacy arc.http.async method still works', async t => {
+test('Verify legacy arc.http.async method still works', async (t) => {
   t.plan(22)
-  let request = reqs.arc7.getIndex
+  const request = reqs.arc7.getIndex
   let req
-  let fn = async event => {
+  const fn = async (event) => {
     req = event
     return basicResponse
   }
-  let handler = arc.http.async(fn)
+  const handler = arc.http.async(fn)
   await handler(copy(request))
   check({ req, request: copy(request), t })
 })
 
-
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   delete process.env.ARC_SESSION_TABLE_NAME
diff --git a/test/unit/src/http/index-async-res-test.js b/test/unit/src/http/index-async-res-test.js
index 439db4ae..93c37650 100644
--- a/test/unit/src/http/index-async-res-test.js
+++ b/test/unit/src/http/index-async-res-test.js
@@ -1,34 +1,33 @@
-
-let { join } = require('path')
-let { brotliDecompressSync, gunzipSync } = require('zlib')
-let { deepStrictEqual } = require('assert')
-let sut = join(process.cwd(), 'src')
-let test = require('tape')
-let sinon = require('sinon')
+const { join } = require('node:path')
+const { brotliDecompressSync, gunzipSync } = require('node:zlib')
+const { deepStrictEqual } = require('node:assert')
+const sut = join(process.cwd(), 'src')
+const test = require('tape')
+const sinon = require('sinon')
 let arc
 
-let { http: httpFixtures } = require('@architect/req-res-fixtures')
-let requests = httpFixtures.req
-let responses = httpFixtures.res
-let legacyResponses = httpFixtures.legacy.res
-let antiCache = 'no-cache, no-store, must-revalidate, max-age=0, s-maxage=0'
+const { http: httpFixtures } = require('@architect/req-res-fixtures')
+const requests = httpFixtures.req
+const responses = httpFixtures.res
+const legacyResponses = httpFixtures.legacy.res
+const antiCache = 'no-cache, no-store, must-revalidate, max-age=0, s-maxage=0'
 
-let b64dec = i => new Buffer.from(i, 'base64').toString()
-let str = i => JSON.stringify(i)
-let match = (copy, item) => `${copy} matches: ${item}`
+const b64dec = (i) => new Buffer.from(i, 'base64').toString()
+const str = (i) => JSON.stringify(i)
+const match = (copy, item) => `${copy} matches: ${item}`
 
-let responsesTested = []
+const responsesTested = []
 
-let copy = obj => JSON.parse(JSON.stringify(obj))
+const copy = (obj) => JSON.parse(JSON.stringify(obj))
 
-let run = async (response, request) => {
+const run = async (response, request) => {
   responsesTested.push(response)
-  let fn = async () => response
-  let handler = arc.http(fn)
+  const fn = async () => response
+  const handler = arc.http(fn)
   return handler(request)
 }
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
   // Set env var to keep from stalling on db reads in CI
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
@@ -37,9 +36,9 @@ test('Set up env', t => {
   t.ok(arc.http, 'Loaded HTTP')
 })
 
-test('Architect v7 (HTTP)', async t => {
+test('Architect v7 (HTTP)', async (t) => {
   t.plan(81)
-  let request = requests.arc7.getIndex
+  const request = requests.arc7.getIndex
 
   let res = await run(responses.arc7.noReturn, copy(request))
   t.equal(res.body, '', 'Empty body passed')
@@ -119,7 +118,11 @@ test('Architect v7 (HTTP)', async t => {
   res = await run(responses.arc7.secureCookieHeader, copy(request))
   t.equal(responses.arc7.secureCookieHeader.body, res.body, match('res.body', res.body))
   t.match(res.headers['content-type'], /application\/json/, 'Unspecified content type defaults to JSON')
-  t.equal(responses.arc7.secureCookieHeader.headers['set-cookie'], res.headers['set-cookie'], match(`res.headers['set-cookie']`, res.headers['set-cookie']))
+  t.equal(
+    responses.arc7.secureCookieHeader.headers['set-cookie'],
+    res.headers['set-cookie'],
+    match(`res.headers['set-cookie']`, res.headers['set-cookie']),
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(responses.arc7.invalid, copy(request))
@@ -178,9 +181,9 @@ test('Architect v7 (HTTP)', async t => {
   t.equal(res.statusCode, 200, 'Responded with 200')
 })
 
-test('Architect v6 (REST): dependency-free responses', async t => {
+test('Architect v6 (REST): dependency-free responses', async (t) => {
   t.plan(35)
-  let request = requests.arc6.getIndex
+  const request = requests.arc6.getIndex
 
   let res = await run(responses.arc6.body, copy(request))
   t.equal(responses.arc6.body.body, res.body, match('res.body', res.body))
@@ -213,53 +216,93 @@ test('Architect v6 (REST): dependency-free responses', async t => {
   res = await run(responses.arc6.secureCookieHeader, copy(request))
   t.equal(responses.arc6.secureCookieHeader.body, res.body, match('res.body', res.body))
   t.notOk(res.isBase64Encoded, 'isBase64Encoded param not passed through')
-  t.equal(responses.arc6.secureCookieHeader.headers['set-cookie'], res.headers['set-cookie'], match(`res.headers['set-cookie']`, res.headers['set-cookie']))
+  t.equal(
+    responses.arc6.secureCookieHeader.headers['set-cookie'],
+    res.headers['set-cookie'],
+    match(`res.headers['set-cookie']`, res.headers['set-cookie']),
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(responses.arc6.secureCookieMultiValueHeader, copy(request))
   t.equal(responses.arc6.secureCookieMultiValueHeader.body, res.body, match('res.body', res.body))
   t.notOk(res.isBase64Encoded, 'isBase64Encoded param not passed through')
-  t.equal(str(responses.arc6.secureCookieMultiValueHeader.multiValueHeaders), str(res.multiValueHeaders), match(`res.multiValueHeaders`, str(res.multiValueHeaders)))
+  t.equal(
+    str(responses.arc6.secureCookieMultiValueHeader.multiValueHeaders),
+    str(res.multiValueHeaders),
+    match('res.multiValueHeaders', str(res.multiValueHeaders)),
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(responses.arc6.multiValueHeaders, copy(request))
   t.equal(res.body, '', 'Empty body passed')
   t.notOk(res.isBase64Encoded, 'isBase64Encoded param not passed through')
   // Headers object gets mutated, so let's just ensure a header we set is there
-  t.equal(str(responses.arc6.multiValueHeaders.headers['Set-Cookie']), str(res.headers['Set-Cookie']), match(`res.headers['Set-Cookie']`, str(res.headers['Set-Cookie'])))
-  t.equal(str(responses.arc6.multiValueHeaders.multiValueHeaders), str(res.multiValueHeaders), match(`res.multiValueHeaders`, str(res.multiValueHeaders)))
+  t.equal(
+    str(responses.arc6.multiValueHeaders.headers['Set-Cookie']),
+    str(res.headers['Set-Cookie']),
+    match(`res.headers['Set-Cookie']`, str(res.headers['Set-Cookie'])),
+  )
+  t.equal(
+    str(responses.arc6.multiValueHeaders.multiValueHeaders),
+    str(res.multiValueHeaders),
+    match('res.multiValueHeaders', str(res.multiValueHeaders)),
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(responses.arc6.invalidMultiValueHeaders, copy(request))
   t.equal(res.body, '', 'Empty body passed')
   t.notOk(res.isBase64Encoded, 'isBase64Encoded param not passed through')
   // Headers object gets mutated, so let's just ensure a header we set is there
-  t.equal(str(responses.arc6.invalidMultiValueHeaders.invalidMultiValueHeaders), str(res.invalidMultiValueHeaders), match(`res.invalidMultiValueHeaders`, str(res.invalidMultiValueHeaders)))
+  t.equal(
+    str(responses.arc6.invalidMultiValueHeaders.invalidMultiValueHeaders),
+    str(res.invalidMultiValueHeaders),
+    match('res.invalidMultiValueHeaders', str(res.invalidMultiValueHeaders)),
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 })
 
-test('Architect v5 (REST): dependency-free responses', async t => {
+test('Architect v5 (REST): dependency-free responses', async (t) => {
   t.plan(21)
-  let request = requests.arc7.getIndex
+  const request = requests.arc7.getIndex
 
   let res = await run(legacyResponses.arc5.type, copy(request))
-  t.equal(legacyResponses.arc5.type.type, res.headers['content-type'], `type matches res.headers['content-type']: ${res.headers['content-type']}`)
+  t.equal(
+    legacyResponses.arc5.type.type,
+    res.headers['content-type'],
+    `type matches res.headers['content-type']: ${res.headers['content-type']}`,
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(legacyResponses.arc5.cookie, copy(request))
-  t.equal(res.headers['set-cookie'], legacyResponses.arc5.cookie.cookie, `Cookie set: ${legacyResponses.arc5.cookie.cookie}...`)
+  t.equal(
+    res.headers['set-cookie'],
+    legacyResponses.arc5.cookie.cookie,
+    `Cookie set: ${legacyResponses.arc5.cookie.cookie}...`,
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(legacyResponses.arc5.secureCookie, copy(request))
-  t.equal(res.headers['set-cookie'], legacyResponses.arc5.secureCookie.cookie, `Cookie set: ${legacyResponses.arc5.secureCookie.cookie}...`)
+  t.equal(
+    res.headers['set-cookie'],
+    legacyResponses.arc5.secureCookie.cookie,
+    `Cookie set: ${legacyResponses.arc5.secureCookie.cookie}...`,
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(legacyResponses.arc5.secureCookieHeader, copy(request))
-  t.equal(legacyResponses.arc5.secureCookieHeader.headers['set-cookie'], res.headers['set-cookie'], match(`res.headers['set-cookie']`, res.headers['set-cookie']))
+  t.equal(
+    legacyResponses.arc5.secureCookieHeader.headers['set-cookie'],
+    res.headers['set-cookie'],
+    match(`res.headers['set-cookie']`, res.headers['set-cookie']),
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(legacyResponses.arc5.cors, copy(request))
-  t.equal(res.headers['access-control-allow-origin'], '*', `CORS boolean set res.headers['access-control-allow-origin'] === '*'`)
+  t.equal(
+    res.headers['access-control-allow-origin'],
+    '*',
+    `CORS boolean set res.headers['access-control-allow-origin'] === '*'`,
+  )
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(legacyResponses.arc5.isBase64Encoded, copy(request))
@@ -269,28 +312,40 @@ test('Architect v5 (REST): dependency-free responses', async t => {
 
   res = await run(legacyResponses.arc5.isBase64EncodedType, copy(request))
   t.equal(legacyResponses.arc5.isBase64EncodedType.body, res.body, match('res.body', res.body))
-  t.equal(legacyResponses.arc5.isBase64EncodedType.type, res.headers['content-type'], `type matches res.headers['content-type']: ${res.headers['content-type']}`)
+  t.equal(
+    legacyResponses.arc5.isBase64EncodedType.type,
+    res.headers['content-type'],
+    `type matches res.headers['content-type']: ${res.headers['content-type']}`,
+  )
   t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(legacyResponses.arc5.isBase64EncodedUnknownCT, copy(request))
   t.equal(legacyResponses.arc5.isBase64EncodedUnknownCT.body, res.body, match('res.body', res.body))
-  t.equal(legacyResponses.arc5.isBase64EncodedUnknownCT.headers['content-type'], res.headers['content-type'], match(`res.headers['content-type']`, res.headers['content-type']))
+  t.equal(
+    legacyResponses.arc5.isBase64EncodedUnknownCT.headers['content-type'],
+    res.headers['content-type'],
+    match(`res.headers['content-type']`, res.headers['content-type']),
+  )
   t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
   t.equal(res.statusCode, 200, 'Responded with 200')
 })
 
-test('Architect v5 (REST) + Functions', async t => {
+test('Architect v5 (REST) + Functions', async (t) => {
   // Arc 5 `arc.http()` functionality backported to `arc.http()`
   t.plan(15)
-  let request = requests.arc7.getIndex
+  const request = requests.arc7.getIndex
 
   let res = await run(legacyResponses.arc5.body, copy(request))
   t.equal(str(legacyResponses.arc5.body.body), str(res.body), match('res.body', res.body))
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(legacyResponses.arc5.cacheControl, copy(request))
-  t.equal(legacyResponses.arc5.cacheControl.cacheControl, res.headers['cache-control'], match(`res.headers['cache-control']`, str(res.headers['cache-control'])))
+  t.equal(
+    legacyResponses.arc5.cacheControl.cacheControl,
+    res.headers['cache-control'],
+    match(`res.headers['cache-control']`, str(res.headers['cache-control'])),
+  )
   if (legacyResponses.arc5.cacheControl.headers['cache-control'] && !res.headers['Cache-Control'])
     t.pass(`Headers normalized and de-duped: ${str(res.headers)}`)
   t.equal(res.statusCode, 200, 'Responded with 200')
@@ -308,7 +363,7 @@ test('Architect v5 (REST) + Functions', async t => {
   t.equal(res.statusCode, 200, 'Responded with 200')
 
   res = await run(legacyResponses.arc5.noCacheControlOther, copy(request))
-  let def = 'max-age=86400'
+  const def = 'max-age=86400'
   t.equal(res.headers['cache-control'], def, 'Default caching headers set for non-HTML/JSON response')
   t.equal(res.statusCode, 200, 'Responded with 200')
 
@@ -323,29 +378,28 @@ test('Architect v5 (REST) + Functions', async t => {
  * - `!process.env.ARC_CLOUDFORMATION && (!process.env.ARC_HTTP || process.env.ARC_HTTP === 'aws')`
  * - And also not a proxy request: `!req.resource || req?.resource !== '/{proxy+}'`
  */
-test('Architect v5 (REST) + Functions do not send res.type', async t => {
+test('Architect v5 (REST) + Functions do not send res.type', async (t) => {
   t.plan(4)
-  let request = requests.arc6.getIndex
+  const request = requests.arc6.getIndex
   t.ok(request.resource, 'Request a Lambda proxy request')
 
-  let res = await run(legacyResponses.arc5.body, copy(request))
+  const res = await run(legacyResponses.arc5.body, copy(request))
   t.equal(legacyResponses.arc5.body.body, res.body, match('res.body', res.body))
   t.equal(res.statusCode, 200, 'Responded with 200')
-  t.notOk(res.type, 'Responded without res.type')  // This used to be t.ok, but we removed res.type in v4
+  t.notOk(res.type, 'Responded without res.type') // This used to be t.ok, but we removed res.type in v4
 })
 
-test('Architect v4 + Functions statically-bound content type responses (HTTP)', async t => {
+test('Architect v4 + Functions statically-bound content type responses (HTTP)', async (t) => {
   t.plan(18)
-  let request = requests.arc7.getIndex
-  let r = legacyResponses.arc4
-  let go = async (response, data, contentType) => {
+  const request = requests.arc7.getIndex
+  const r = legacyResponses.arc4
+  const go = async (response, data, contentType) => {
     responsesTested.push(response)
-    let res = await run(response, copy(request))
+    const res = await run(response, copy(request))
     // Don't double-encode JSON
     if (res.headers['content-type'].includes('json')) {
       t.equal(str(data), res.body, match('res.body', res.body))
-    }
-    else {
+    } else {
       t.equal(str(data), str(res.body), match('res.body', res.body))
     }
     t.match(res.headers['content-type'], new RegExp(contentType), `Correct content-type header sent: ${contentType}`)
@@ -359,19 +413,18 @@ test('Architect v4 + Functions statically-bound content type responses (HTTP)',
   await go(r.xml, r.xml.xml, 'application/xml')
 })
 
-test('Architect v4 + Functions statically-bound content type responses (REST)', async t => {
+test('Architect v4 + Functions statically-bound content type responses (REST)', async (t) => {
   t.plan(18)
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
-  let request = requests.arc6.getIndex
-  let r = legacyResponses.arc4
-  let go = async (response, data, contentType) => {
+  const request = requests.arc6.getIndex
+  const r = legacyResponses.arc4
+  const go = async (response, data, contentType) => {
     responsesTested.push(response)
-    let res = await run(response, copy(request))
+    const res = await run(response, copy(request))
     // Don't double-encode JSON
     if (res.headers['content-type'].includes('json')) {
       t.equal(str(data), res.body, match('res.body', res.body))
-    }
-    else {
+    } else {
       t.equal(str(data), str(res.body), match('res.body', res.body))
     }
     t.match(res.headers['content-type'], new RegExp(contentType), `Correct content-type header sent: ${contentType}`)
@@ -385,9 +438,9 @@ test('Architect v4 + Functions statically-bound content type responses (REST)',
   await go(r.xml, r.xml.xml, 'application/xml')
 })
 
-test('Architect <6 + Functions old school response params (HTTP)', async t => {
+test('Architect <6 + Functions old school response params (HTTP)', async (t) => {
   t.plan(6)
-  let request = requests.arc7.getIndex
+  const request = requests.arc7.getIndex
 
   let res = await run(legacyResponses.arc.location, copy(request))
   t.equal(legacyResponses.arc.location.location, res.headers.location, match('location', res.headers.location))
@@ -406,9 +459,9 @@ test('Architect <6 + Functions old school response params (HTTP)', async t => {
   t.match(res.headers['set-cookie'], /_idx=/, `Cookie set: ${res.headers['set-cookie'].substr(0, 75)}...`)
 })
 
-test('Architect <6 + Functions old school response params (REST)', async t => {
+test('Architect <6 + Functions old school response params (REST)', async (t) => {
   t.plan(6)
-  let request = requests.arc6.getIndex
+  const request = requests.arc6.getIndex
 
   let res = await run(legacyResponses.arc.location, copy(request))
   t.equal(legacyResponses.arc.location.location, res.headers.location, match('location', res.headers.location))
@@ -427,92 +480,105 @@ test('Architect <6 + Functions old school response params (REST)', async t => {
   t.match(res.headers['set-cookie'], /_idx=/, `Cookie set: ${res.headers['set-cookie'].substr(0, 75)}...`)
 })
 
-test('Return an error (HTTP)', async t => {
+test('Return an error (HTTP)', async (t) => {
   t.plan(2)
-  let request = requests.arc7.getIndex
-  let error = Error('something bad happened')
-  let res = await run(error, copy(request))
+  const request = requests.arc7.getIndex
+  const error = Error('something bad happened')
+  const res = await run(error, copy(request))
   t.equal(res.statusCode, 500, 'Error response, 500 returned')
   t.match(res.body, new RegExp(error.message), `Error response included error message: ${error.message}`)
 })
 
-test('Return an error (REST)', async t => {
+test('Return an error (REST)', async (t) => {
   t.plan(2)
-  let request = requests.arc6.getIndex
-  let error = Error('something bad happened')
-  let res = await run(error, copy(request))
+  const request = requests.arc6.getIndex
+  const error = Error('something bad happened')
+  const res = await run(error, copy(request))
   t.equal(res.statusCode, 500, 'Error response, 500 returned')
   t.match(res.body, new RegExp(error.message), `Error response included error message: ${error.message}`)
 })
 
-test('Prevent further middleware from running when a response is returned', t => {
+test('Prevent further middleware from running when a response is returned', (t) => {
   t.plan(1)
-  let request = requests.arc7.getIndex
-  async function one () { return { statusCode: 200 } }
-  let two = sinon.fake()
-  let handler = arc.http(one, two)
+  const request = requests.arc7.getIndex
+  async function one() {
+    return { statusCode: 200 }
+  }
+  const two = sinon.fake()
+  const handler = arc.http(one, two)
   handler(copy(request))
   t.notOk(two.callCount, 'second middleware not called')
 })
 
-test('Do not throw if middleware does not return a response (HTTP)', async t => {
+test('Do not throw if middleware does not return a response (HTTP)', async (t) => {
   t.plan(1)
-  let request = requests.arc7.getIndex
-  async function one (req) { return req }
-  async function two (req) { return req }
-  let handler = arc.http(one, two)
+  const request = requests.arc7.getIndex
+  async function one(req) {
+    return req
+  }
+  async function two(req) {
+    return req
+  }
+  const handler = arc.http(one, two)
   try {
     await handler(copy(request))
     t.ok('No exception thrown')
-  }
-  catch (err) {
+  } catch (err) {
     t.fail(err)
   }
 })
 
-test('Throw if middleware does not return a response (REST)', async t => {
+test('Throw if middleware does not return a response (REST)', async (t) => {
   t.plan(1)
-  let request = requests.arc6.getIndex
-  async function one (req) { return req }
-  async function two (req) { return req }
-  let handler = arc.http(one, two)
+  const request = requests.arc6.getIndex
+  async function one(req) {
+    return req
+  }
+  async function two(req) {
+    return req
+  }
+  const handler = arc.http(one, two)
   try {
     await handler(copy(request))
-  }
-  catch (err) {
+  } catch (err) {
     t.ok(err, 'exception thrown')
   }
 })
 
-test('Verify all Arc v7 (HTTP) + Arc v6 (REST) + legacy response fixtures were tested', t => {
-  let totalReqs = Object.keys(responses.arc7).length +
-                  Object.keys(responses.arc6).length +
-                  Object.keys(legacyResponses.arc5).length +
-                  Object.keys(legacyResponses.arc4).length +
-                  Object.keys(legacyResponses.arc).length
+test('Verify all Arc v7 (HTTP) + Arc v6 (REST) + legacy response fixtures were tested', (t) => {
+  const totalReqs =
+    Object.keys(responses.arc7).length +
+    Object.keys(responses.arc6).length +
+    Object.keys(legacyResponses.arc5).length +
+    Object.keys(legacyResponses.arc4).length +
+    Object.keys(legacyResponses.arc).length
   t.plan(totalReqs)
-  let tester = ([ name, req ]) => {
-    t.ok(responsesTested.some(tested => {
-      try {
-        deepStrictEqual(req, tested)
-        return true
-      }
-      catch { /* noop */ }
-    }), `Tested res: ${name}`)
+  const tester = ([name, req]) => {
+    t.ok(
+      responsesTested.some((tested) => {
+        try {
+          deepStrictEqual(req, tested)
+          return true
+        } catch {
+          /* noop */
+        }
+      }),
+      `Tested res: ${name}`,
+    )
   }
-  console.log(`Arc 7 responses`)
+  console.log('Arc 7 responses')
   Object.entries(responses.arc7).forEach(tester)
-  console.log(`Arc 6 responses`)
+  console.log('Arc 6 responses')
   Object.entries(responses.arc6).forEach(tester)
-  console.log(`Legacy Arc 5 responses`)
+  console.log('Legacy Arc 5 responses')
   Object.entries(legacyResponses.arc5).forEach(tester)
-  console.log(`Legacy Arc 4 responses`)
+  console.log('Legacy Arc 4 responses')
   Object.entries(legacyResponses.arc4).forEach(tester)
-  console.log(`Legacy Arc responses`)
+  console.log('Legacy Arc responses')
   Object.entries(legacyResponses.arc).forEach(tester)
 })
 
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   delete process.env.ARC_SESSION_TABLE_NAME
diff --git a/test/unit/src/http/index-cb-req-test.js b/test/unit/src/http/index-cb-req-test.js
index 5d9a05d9..1c850d7e 100644
--- a/test/unit/src/http/index-cb-req-test.js
+++ b/test/unit/src/http/index-cb-req-test.js
@@ -1,56 +1,54 @@
-let { join } = require('path')
-let { deepStrictEqual } = require('assert')
-let sut = join(process.cwd(), 'src')
-let test = require('tape')
+const { join } = require('node:path')
+const { deepStrictEqual } = require('node:assert')
+const sut = join(process.cwd(), 'src')
+const test = require('tape')
 let http
 
-let reqs = require('@architect/req-res-fixtures').http.req
+const reqs = require('@architect/req-res-fixtures').http.req
 
-let str = i => JSON.stringify(i)
-let isObject = t => typeof t === 'object' && !!(t)
-let unNulled = (before, after) => before === null && isObject(after)
-let match = (copy, item) => `${copy} matches: ${str(item)}`
-let basicResponse = { statusCode: 200 }
+const str = (i) => JSON.stringify(i)
+const isObject = (t) => typeof t === 'object' && !!t
+const unNulled = (before, after) => before === null && isObject(after)
+const match = (copy, item) => `${copy} matches: ${str(item)}`
+const basicResponse = { statusCode: 200 }
 
-let arc6RestNull = [ 'body', 'pathParameters', 'queryStringParameters', 'multiValueQueryStringParameters' ]
-let isNulled = key => arc6RestNull.some(v => v === key)
+const arc6RestNull = ['body', 'pathParameters', 'queryStringParameters', 'multiValueQueryStringParameters']
+const isNulled = (key) => arc6RestNull.some((v) => v === key)
 
-let arc6RestPrettyParams = {
+const arc6RestPrettyParams = {
   method: 'httpMethod',
   params: 'pathParameters',
   query: 'queryStringParameters',
 }
 
-let requestsTested = []
+const requestsTested = []
 
-let copy = obj => JSON.parse(JSON.stringify(obj))
+const copy = (obj) => JSON.parse(JSON.stringify(obj))
 
-function check ({ req, request, res, t }) {
-  console.log(`Got request:`, req)
+function check({ req, request, res, t }) {
+  console.log('Got request:', req)
   requestsTested.push(request)
 
   // Make sure all original keys are present and accounted for
-  Object.keys(request).forEach(key => {
+  Object.keys(request).forEach((key) => {
     // eslint-disable-next-line
-    if (!req.hasOwnProperty(key)) t.fail(`Original request param missing from interpolated request: ${key}`)
+    if (!Object.hasOwn(req, key)) t.fail(`Original request param missing from interpolated request: ${key}`)
   })
 
   if (request.body) t.ok(req.rawBody, 'Body property also created rawBody')
   else t.notOk(req.rawBody, 'Did not populate rawBody without a body present')
 
-  Object.entries(req).forEach(([ key, val ]) => {
+  Object.entries(req).forEach(([key, val]) => {
     // Make sure we don't have any false positives matching undefined tests
     if (req[key] === undefined) t.fail(`Property is undefined: ${key}`)
     // Compare mutation of nulls into objects
     if (isNulled(key) && request[key] === null) {
       if (unNulled(request[key], val)) {
         t.pass(match(`req.${key}`, req[key]))
-      }
-      else {
+      } else {
         t.fail(`Param not un-nulled: ${key}: ${val}`)
       }
-    }
-    else {
+    } else {
       t.equal(str(val), str(req[key]), match(`req.${key}`, str(req[key])))
     }
     // Compare interpolation to nicer, backwards compat req params
@@ -62,181 +60,181 @@ function check ({ req, request, res, t }) {
   res(basicResponse)
 }
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
   // Set env var to keep from stalling on db reads in CI
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
 
-  let arc = require(sut)
+  const arc = require(sut)
   http = arc.http
   t.ok(http, 'Loaded HTTP')
 })
 
-test('Architect v7 (HTTP): get /', t => {
+test('Architect v7 (HTTP): get /', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getIndex
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getIndex
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get /?whats=up', t => {
+test('Architect v7 (HTTP): get /?whats=up', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getWithQueryString
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getWithQueryString
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get /?whats=up&whats=there', t => {
+test('Architect v7 (HTTP): get /?whats=up&whats=there', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getWithQueryStringDuplicateKey
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getWithQueryStringDuplicateKey
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get /nature/hiking', t => {
+test('Architect v7 (HTTP): get /nature/hiking', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getWithParam
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getWithParam
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get /{proxy+} (/nature/hiking)', t => {
+test('Architect v7 (HTTP): get /{proxy+} (/nature/hiking)', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getProxyPlus
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getProxyPlus
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get /$default', t => {
+test('Architect v7 (HTTP): get /$default', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.get$default
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.get$default
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get /path/* (/path/hi/there)', t => {
+test('Architect v7 (HTTP): get /path/* (/path/hi/there)', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getCatchall
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getCatchall
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get /:activities/{proxy+} (/nature/hiking/wilderness)', t => {
+test('Architect v7 (HTTP): get /:activities/{proxy+} (/nature/hiking/wilderness)', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getWithParamAndCatchall
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getWithParamAndCatchall
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get / with brotli compression', t => {
+test('Architect v7 (HTTP): get / with brotli compression', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getWithBrotli
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getWithBrotli
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): get / with gzip compression', t => {
+test('Architect v7 (HTTP): get / with gzip compression', (t) => {
   t.plan(24)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.getWithGzip
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.getWithGzip
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): post /form (JSON)', t => {
+test('Architect v7 (HTTP): post /form (JSON)', (t) => {
   t.plan(25)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.postJson
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.postJson
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): post /form (form URL encoded)', t => {
+test('Architect v7 (HTTP): post /form (form URL encoded)', (t) => {
   t.plan(25)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.postFormURL
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.postFormURL
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): post /form (multipart form data)', t => {
+test('Architect v7 (HTTP): post /form (multipart form data)', (t) => {
   t.plan(25)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.postMultiPartFormData
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.postMultiPartFormData
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): post /form (octet stream)', t => {
+test('Architect v7 (HTTP): post /form (octet stream)', (t) => {
   t.plan(25)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.postOctetStream
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.postOctetStream
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): put /form (JSON)', t => {
+test('Architect v7 (HTTP): put /form (JSON)', (t) => {
   t.plan(25)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.putJson
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.putJson
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): patch /form (JSON)', t => {
+test('Architect v7 (HTTP): patch /form (JSON)', (t) => {
   t.plan(25)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.patchJson
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.patchJson
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v7 (HTTP): delete /form (JSON)', t => {
+test('Architect v7 (HTTP): delete /form (JSON)', (t) => {
   t.plan(25)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc7.deleteJson
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc7.deleteJson
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
@@ -247,165 +245,169 @@ test('Architect v7 (HTTP): delete /form (JSON)', t => {
  * - `nulls` passed instead of empty objects
  * - All bodies are base64 encoded
  */
-test('Architect v6 (REST): get /', t => {
+test('Architect v6 (REST): get /', (t) => {
   t.plan(21)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.getIndex
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.getIndex
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): get /?whats=up', t => {
+test('Architect v6 (REST): get /?whats=up', (t) => {
   t.plan(21)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.getWithQueryString
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.getWithQueryString
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): get /?whats=up&whats=there', t => {
+test('Architect v6 (REST): get /?whats=up&whats=there', (t) => {
   t.plan(21)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.getWithQueryStringDuplicateKey
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.getWithQueryStringDuplicateKey
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): get /nature/hiking', t => {
+test('Architect v6 (REST): get /nature/hiking', (t) => {
   t.plan(21)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.getWithParam
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.getWithParam
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): get /{proxy+}', t => {
+test('Architect v6 (REST): get /{proxy+}', (t) => {
   t.plan(21)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.getProxyPlus
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.getProxyPlus
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): get /path/* (/path/hi/there)', t => {
+test('Architect v6 (REST): get /path/* (/path/hi/there)', (t) => {
   t.plan(21)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.getCatchall
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.getCatchall
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): get /:activities/{proxy+} (/nature/hiking/wilderness)', t => {
+test('Architect v6 (REST): get /:activities/{proxy+} (/nature/hiking/wilderness)', (t) => {
   t.plan(21)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.getWithParamAndCatchall
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.getWithParamAndCatchall
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): post /form (JSON)', t => {
+test('Architect v6 (REST): post /form (JSON)', (t) => {
   t.plan(22)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.postJson
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.postJson
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): post /form (form URL encoded)', t => {
+test('Architect v6 (REST): post /form (form URL encoded)', (t) => {
   t.plan(22)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.postFormURL
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.postFormURL
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): post /form (multipart form data)', t => {
+test('Architect v6 (REST): post /form (multipart form data)', (t) => {
   t.plan(22)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.postMultiPartFormData
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.postMultiPartFormData
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): post /form (octet stream)', t => {
+test('Architect v6 (REST): post /form (octet stream)', (t) => {
   t.plan(22)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.postOctetStream
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.postOctetStream
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): put /form (JSON)', t => {
+test('Architect v6 (REST): put /form (JSON)', (t) => {
   t.plan(22)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.putJson
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.putJson
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): patch /form (JSON)', t => {
+test('Architect v6 (REST): patch /form (JSON)', (t) => {
   t.plan(22)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.patchJson
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.patchJson
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Architect v6 (REST): delete /form (JSON)', t => {
+test('Architect v6 (REST): delete /form (JSON)', (t) => {
   t.plan(22)
-  let end = () => t.pass('Final callback called')
-  let request = reqs.arc6.deleteJson
-  let handler = http((req, res) => {
+  const end = () => t.pass('Final callback called')
+  const request = reqs.arc6.deleteJson
+  const handler = http((req, res) => {
     check({ req, request: copy(request), res, t })
   })
   handler(copy(request), {}, end)
 })
 
-test('Verify all Arc v7 (HTTP) + Arc v6 (REST) request fixtures were tested', t => {
-  let totalReqs = Object.keys(reqs.arc7).length + Object.keys(reqs.arc6).length
+test('Verify all Arc v7 (HTTP) + Arc v6 (REST) request fixtures were tested', (t) => {
+  const totalReqs = Object.keys(reqs.arc7).length + Object.keys(reqs.arc6).length
   t.plan(totalReqs)
-  let tester = ([ name, req ]) => {
-    t.ok(requestsTested.some(tested => {
-      try {
-        deepStrictEqual(req, tested)
-        return true
-      }
-      catch { /* noop */ }
-    }), `Tested req: ${name}`)
+  const tester = ([name, req]) => {
+    t.ok(
+      requestsTested.some((tested) => {
+        try {
+          deepStrictEqual(req, tested)
+          return true
+        } catch {
+          /* noop */
+        }
+      }),
+      `Tested req: ${name}`,
+    )
   }
-  console.log(`Arc 7 requests`)
+  console.log('Arc 7 requests')
   Object.entries(reqs.arc7).forEach(tester)
-  console.log(`Arc 6 requests`)
+  console.log('Arc 6 requests')
   Object.entries(reqs.arc6).forEach(tester)
 })
 
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   delete process.env.ARC_SESSION_TABLE_NAME
diff --git a/test/unit/src/http/index-cb-res-test.js b/test/unit/src/http/index-cb-res-test.js
index f32a23b6..fb8f7fbb 100644
--- a/test/unit/src/http/index-cb-res-test.js
+++ b/test/unit/src/http/index-cb-res-test.js
@@ -1,43 +1,43 @@
-let { join } = require('path')
-let { brotliDecompressSync, gunzipSync } = require('zlib')
-let { deepStrictEqual } = require('assert')
-let sut = join(process.cwd(), 'src')
-let test = require('tape')
+const { join } = require('node:path')
+const { brotliDecompressSync, gunzipSync } = require('node:zlib')
+const { deepStrictEqual } = require('node:assert')
+const sut = join(process.cwd(), 'src')
+const test = require('tape')
 let http
 
-let { http: httpFixtures } = require('@architect/req-res-fixtures')
-let requests = httpFixtures.req
-let responses = httpFixtures.res
-let legacyResponses = httpFixtures.legacy.res
-let antiCache = 'no-cache, no-store, must-revalidate, max-age=0, s-maxage=0'
+const { http: httpFixtures } = require('@architect/req-res-fixtures')
+const requests = httpFixtures.req
+const responses = httpFixtures.res
+const legacyResponses = httpFixtures.legacy.res
+const antiCache = 'no-cache, no-store, must-revalidate, max-age=0, s-maxage=0'
 
-let b64dec = i => new Buffer.from(i, 'base64').toString()
-let str = i => JSON.stringify(i)
-let match = (copy, item) => `${copy} matches: ${item}`
+const b64dec = (i) => new Buffer.from(i, 'base64').toString()
+const str = (i) => JSON.stringify(i)
+const match = (copy, item) => `${copy} matches: ${item}`
 
-let responsesTested = []
+const responsesTested = []
 
-let copy = obj => JSON.parse(JSON.stringify(obj))
+const copy = (obj) => JSON.parse(JSON.stringify(obj))
 
-let run = (response, request, callback) => {
+const run = (response, request, callback) => {
   responsesTested.push(response)
-  let handler = http((req, res) => res(response))
+  const handler = http((req, res) => res(response))
   handler(request, {}, callback)
 }
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
   // Init env var to keep from stalling on db reads in CI
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
 
-  let arc = require(sut)
+  const arc = require(sut)
   http = arc.http
   t.ok(http, 'Loaded HTTP')
 })
 
-test('Architect v7 (HTTP)', t => {
+test('Architect v7 (HTTP)', (t) => {
   t.plan(103)
-  let request = requests.arc7.getIndex
+  const request = requests.arc7.getIndex
   run(responses.arc7.noReturn, copy(request), (err, res) => {
     t.notOk(err, 'No error')
     t.equal(res.body, '', 'Empty body passed')
@@ -107,7 +107,11 @@ test('Architect v7 (HTTP)', t => {
   })
   run(responses.arc7.encodedWithCompression, copy(request), (err, res) => {
     t.notOk(err, 'No error')
-    t.deepEqual(responses.arc7.encodedWithCompression.body, Buffer.from(res.body, 'base64'), match('res.body', res.body))
+    t.deepEqual(
+      responses.arc7.encodedWithCompression.body,
+      Buffer.from(res.body, 'base64'),
+      match('res.body', res.body),
+    )
     t.match(res.headers['content-type'], /application\/pdf/, 'Passed correct content-type')
     t.match(res.headers['content-encoding'], /^br$/, 'Content encoding set to brotli')
     t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
@@ -131,7 +135,11 @@ test('Architect v7 (HTTP)', t => {
     t.notOk(err, 'No error')
     t.equal(responses.arc7.secureCookieHeader.body, res.body, match('res.body', res.body))
     t.match(res.headers['content-type'], /application\/json/, 'Unspecified content type defaults to JSON')
-    t.equal(responses.arc7.secureCookieHeader.headers['set-cookie'], res.headers['set-cookie'], match(`res.headers['set-cookie']`, res.headers['set-cookie']))
+    t.equal(
+      responses.arc7.secureCookieHeader.headers['set-cookie'],
+      res.headers['set-cookie'],
+      match(`res.headers['set-cookie']`, res.headers['set-cookie']),
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(responses.arc7.invalid, copy(request), (err, res) => {
@@ -143,7 +151,7 @@ test('Architect v7 (HTTP)', t => {
   // br by default
   run(responses.arc7.bodyWithStatus, copy(requests.arc7.getWithBrotli), (err, res) => {
     t.notOk(err, 'No error')
-    let buf = new Buffer.from(res.body, 'base64')
+    const buf = new Buffer.from(res.body, 'base64')
     t.equal(responses.arc7.bodyWithStatus.body, brotliDecompressSync(buf).toString(), match('res.body', res.body))
     t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
     t.match(res.headers['content-type'], /application\/json/, 'Unspecified content type defaults to JSON')
@@ -153,7 +161,7 @@ test('Architect v7 (HTTP)', t => {
   // Allow manual preference of br
   run(responses.arc7.preferBrCompression, copy(requests.arc7.getWithBrotli), (err, res) => {
     t.notOk(err, 'No error')
-    let buf = new Buffer.from(res.body, 'base64')
+    const buf = new Buffer.from(res.body, 'base64')
     t.equal(responses.arc7.bodyWithStatus.body, brotliDecompressSync(buf).toString(), match('res.body', res.body))
     t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
     t.match(res.headers['content-type'], /application\/json/, 'Unspecified content type defaults to JSON')
@@ -163,7 +171,7 @@ test('Architect v7 (HTTP)', t => {
   // Allow preference of gzip over br
   run(responses.arc7.preferGzipCompression, copy(requests.arc7.getWithBrotli), (err, res) => {
     t.notOk(err, 'No error')
-    let buf = new Buffer.from(res.body, 'base64')
+    const buf = new Buffer.from(res.body, 'base64')
     t.equal(responses.arc7.preferGzipCompression.body, gunzipSync(buf).toString(), match('res.body', res.body))
     t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
     t.match(res.headers['content-type'], /application\/json/, 'Unspecified content type defaults to JSON')
@@ -180,7 +188,7 @@ test('Architect v7 (HTTP)', t => {
   // Client only supports gzip
   run(responses.arc7.bodyWithStatus, copy(requests.arc7.getWithGzip), (err, res) => {
     t.notOk(err, 'No error')
-    let buf = new Buffer.from(res.body, 'base64')
+    const buf = new Buffer.from(res.body, 'base64')
     t.equal(responses.arc7.bodyWithStatus.body, gunzipSync(buf).toString(), match('res.body', res.body))
     t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
     t.match(res.headers['content-type'], /application\/json/, 'Unspecified content type defaults to JSON')
@@ -198,9 +206,9 @@ test('Architect v7 (HTTP)', t => {
   })
 })
 
-test('Architect v6 (REST): dependency-free responses', t => {
+test('Architect v6 (REST): dependency-free responses', (t) => {
   t.plan(44)
-  let request = requests.arc6.getIndex
+  const request = requests.arc6.getIndex
 
   run(responses.arc6.body, copy(request), (err, res) => {
     t.notOk(err, 'No error')
@@ -239,14 +247,22 @@ test('Architect v6 (REST): dependency-free responses', t => {
     t.notOk(err, 'No error')
     t.equal(responses.arc6.secureCookieHeader.body, res.body, match('res.body', res.body))
     t.notOk(res.isBase64Encoded, 'isBase64Encoded param not passed through')
-    t.equal(responses.arc6.secureCookieHeader.headers['set-cookie'], res.headers['set-cookie'], match(`res.headers['set-cookie']`, res.headers['set-cookie']))
+    t.equal(
+      responses.arc6.secureCookieHeader.headers['set-cookie'],
+      res.headers['set-cookie'],
+      match(`res.headers['set-cookie']`, res.headers['set-cookie']),
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(responses.arc6.secureCookieMultiValueHeader, copy(request), (err, res) => {
     t.notOk(err, 'No error')
     t.equal(responses.arc6.secureCookieMultiValueHeader.body, res.body, match('res.body', res.body))
     t.notOk(res.isBase64Encoded, 'isBase64Encoded param not passed through')
-    t.equal(str(responses.arc6.secureCookieMultiValueHeader.multiValueHeaders), str(res.multiValueHeaders), match(`res.multiValueHeaders`, str(res.multiValueHeaders)))
+    t.equal(
+      str(responses.arc6.secureCookieMultiValueHeader.multiValueHeaders),
+      str(res.multiValueHeaders),
+      match('res.multiValueHeaders', str(res.multiValueHeaders)),
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(responses.arc6.multiValueHeaders, copy(request), (err, res) => {
@@ -254,8 +270,16 @@ test('Architect v6 (REST): dependency-free responses', t => {
     t.equal(res.body, '', 'Empty body passed')
     t.notOk(res.isBase64Encoded, 'isBase64Encoded param not passed through')
     // Headers object gets mutated, so let's just ensure a header we set is there
-    t.equal(str(responses.arc6.multiValueHeaders.headers['set-cookie']), str(res.headers['set-cookie']), match(`res.headers['set-cookie']`, str(res.headers['set-cookie'])))
-    t.equal(str(responses.arc6.multiValueHeaders.multiValueHeaders), str(res.multiValueHeaders), match(`res.multiValueHeaders`, str(res.multiValueHeaders)))
+    t.equal(
+      str(responses.arc6.multiValueHeaders.headers['set-cookie']),
+      str(res.headers['set-cookie']),
+      match(`res.headers['set-cookie']`, str(res.headers['set-cookie'])),
+    )
+    t.equal(
+      str(responses.arc6.multiValueHeaders.multiValueHeaders),
+      str(res.multiValueHeaders),
+      match('res.multiValueHeaders', str(res.multiValueHeaders)),
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(responses.arc6.invalidMultiValueHeaders, copy(request), (err, res) => {
@@ -263,38 +287,62 @@ test('Architect v6 (REST): dependency-free responses', t => {
     t.equal(res.body, '', 'Empty body passed')
     t.notOk(res.isBase64Encoded, 'isBase64Encoded param not passed through')
     // Headers object gets mutated, so let's just ensure a header we set is there
-    t.equal(str(responses.arc6.invalidMultiValueHeaders.invalidMultiValueHeaders), str(res.invalidMultiValueHeaders), match(`res.invalidMultiValueHeaders`, str(res.invalidMultiValueHeaders)))
+    t.equal(
+      str(responses.arc6.invalidMultiValueHeaders.invalidMultiValueHeaders),
+      str(res.invalidMultiValueHeaders),
+      match('res.invalidMultiValueHeaders', str(res.invalidMultiValueHeaders)),
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
 })
 
-test('Architect v5 (REST): dependency-free responses', t => {
+test('Architect v5 (REST): dependency-free responses', (t) => {
   t.plan(29)
-  let request = requests.arc7.getIndex
+  const request = requests.arc7.getIndex
 
   run(legacyResponses.arc5.type, copy(request), (err, res) => {
     t.notOk(err, 'No error')
-    t.equal(legacyResponses.arc5.type.type, res.headers['content-type'], `type matches res.headers['content-type']: ${res.headers['content-type']}`)
+    t.equal(
+      legacyResponses.arc5.type.type,
+      res.headers['content-type'],
+      `type matches res.headers['content-type']: ${res.headers['content-type']}`,
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(legacyResponses.arc5.cookie, copy(request), (err, res) => {
     t.notOk(err, 'No error')
-    t.equal(res.headers['set-cookie'], legacyResponses.arc5.cookie.cookie, `Cookie set: ${legacyResponses.arc5.cookie.cookie}...`)
+    t.equal(
+      res.headers['set-cookie'],
+      legacyResponses.arc5.cookie.cookie,
+      `Cookie set: ${legacyResponses.arc5.cookie.cookie}...`,
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(legacyResponses.arc5.secureCookie, copy(request), (err, res) => {
     t.notOk(err, 'No error')
-    t.equal(res.headers['set-cookie'], legacyResponses.arc5.secureCookie.cookie, `Cookie set: ${legacyResponses.arc5.secureCookie.cookie}...`)
+    t.equal(
+      res.headers['set-cookie'],
+      legacyResponses.arc5.secureCookie.cookie,
+      `Cookie set: ${legacyResponses.arc5.secureCookie.cookie}...`,
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(legacyResponses.arc5.secureCookieHeader, copy(request), (err, res) => {
     t.notOk(err, 'No error')
-    t.equal(legacyResponses.arc5.secureCookieHeader.headers['set-cookie'], res.headers['set-cookie'], match(`res.headers['set-cookie']`, res.headers['set-cookie']))
+    t.equal(
+      legacyResponses.arc5.secureCookieHeader.headers['set-cookie'],
+      res.headers['set-cookie'],
+      match(`res.headers['set-cookie']`, res.headers['set-cookie']),
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(legacyResponses.arc5.cors, copy(request), (err, res) => {
     t.notOk(err, 'No error')
-    t.equal(res.headers['access-control-allow-origin'], '*', `CORS boolean set res.headers['access-control-allow-origin'] === '*'`)
+    t.equal(
+      res.headers['access-control-allow-origin'],
+      '*',
+      `CORS boolean set res.headers['access-control-allow-origin'] === '*'`,
+    )
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(legacyResponses.arc5.isBase64Encoded, copy(request), (err, res) => {
@@ -306,22 +354,30 @@ test('Architect v5 (REST): dependency-free responses', t => {
   run(legacyResponses.arc5.isBase64EncodedType, copy(request), (err, res) => {
     t.notOk(err, 'No error')
     t.equal(legacyResponses.arc5.isBase64EncodedType.body, res.body, match('res.body', res.body))
-    t.equal(legacyResponses.arc5.isBase64EncodedType.type, res.headers['content-type'], `type matches res.headers['content-type']: ${res.headers['content-type']}`)
+    t.equal(
+      legacyResponses.arc5.isBase64EncodedType.type,
+      res.headers['content-type'],
+      `type matches res.headers['content-type']: ${res.headers['content-type']}`,
+    )
     t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
   run(legacyResponses.arc5.isBase64EncodedUnknownCT, copy(request), (err, res) => {
     t.notOk(err, 'No error')
     t.equal(legacyResponses.arc5.isBase64EncodedUnknownCT.body, res.body, match('res.body', res.body))
-    t.equal(legacyResponses.arc5.isBase64EncodedUnknownCT.headers['content-type'], res.headers['content-type'], match(`res.headers['content-type']`, res.headers['content-type']))
+    t.equal(
+      legacyResponses.arc5.isBase64EncodedUnknownCT.headers['content-type'],
+      res.headers['content-type'],
+      match(`res.headers['content-type']`, res.headers['content-type']),
+    )
     t.ok(res.isBase64Encoded, 'isBase64Encoded param passed through')
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
 })
 
-test('Architect v5 (REST) + Functions', t => {
+test('Architect v5 (REST) + Functions', (t) => {
   t.plan(23)
-  let request = requests.arc7.getIndex
+  const request = requests.arc7.getIndex
 
   run(legacyResponses.arc5.body, copy(request), (err, res) => {
     t.notOk(err, 'No error')
@@ -331,7 +387,11 @@ test('Architect v5 (REST) + Functions', t => {
   })
   run(legacyResponses.arc5.cacheControl, copy(request), (err, res) => {
     t.notOk(err, 'No error')
-    t.equal(legacyResponses.arc5.cacheControl.cacheControl, res.headers['cache-control'], match(`res.headers['cache-control']`, str(res.headers['cache-control'])))
+    t.equal(
+      legacyResponses.arc5.cacheControl.cacheControl,
+      res.headers['cache-control'],
+      match(`res.headers['cache-control']`, str(res.headers['cache-control'])),
+    )
     if (legacyResponses.arc5.cacheControl.headers['cache-control'] && !res.headers['Cache-Control'])
       t.pass(`Headers normalized and de-duped: ${str(res.headers)}`)
     t.equal(res.statusCode, 200, 'Responded with 200')
@@ -353,7 +413,7 @@ test('Architect v5 (REST) + Functions', t => {
   })
   run(legacyResponses.arc5.noCacheControlOther, copy(request), (err, res) => {
     t.notOk(err, 'No error')
-    let def = 'max-age=86400'
+    const def = 'max-age=86400'
     t.equal(res.headers['cache-control'], def, 'Default caching headers set for non-HTML/JSON response')
     t.equal(res.statusCode, 200, 'Responded with 200')
   })
@@ -370,13 +430,13 @@ test('Architect v5 (REST) + Functions', t => {
  * - `!process.env.ARC_CLOUDFORMATION && (!process.env.ARC_HTTP || process.env.ARC_HTTP === 'aws')`
  * - And also not a proxy request: `!req.resource || req?.resource !== '/{proxy+}'`
  */
-test('Architect v5 (REST) + Functions do not send res.type', t => {
+test('Architect v5 (REST) + Functions do not send res.type', (t) => {
   t.plan(5)
-  let request = requests.arc6.getIndex
+  const request = requests.arc6.getIndex
   t.ok(request.resource, 'Request a Lambda proxy request')
 
-  let run = (response, callback) => {
-    let handler = http((req, res) => res(response))
+  const run = (response, callback) => {
+    const handler = http((req, res) => res(response))
     handler(copy(request), {}, (err, res) => {
       callback(err, res)
     })
@@ -389,20 +449,19 @@ test('Architect v5 (REST) + Functions do not send res.type', t => {
   })
 })
 
-test('Architect v4 + Functions statically-bound content type responses (HTTP)', t => {
+test('Architect v4 + Functions statically-bound content type responses (HTTP)', (t) => {
   t.plan(24)
-  let request = requests.arc7.getIndex
-  let r = legacyResponses.arc4
-  let run = (response, data, contentType) => {
-    let handler = http((req, res) => res(response))
+  const request = requests.arc7.getIndex
+  const r = legacyResponses.arc4
+  const run = (response, data, contentType) => {
+    const handler = http((req, res) => res(response))
     responsesTested.push(response)
     handler(copy(request), {}, (err, res) => {
       t.notOk(err, 'No error')
       // Don't double-encode JSON
       if (res.headers['content-type'].includes('json')) {
         t.equal(str(data), res.body, match('res.body', res.body))
-      }
-      else {
+      } else {
         t.equal(str(data), str(res.body), match('res.body', res.body))
       }
       t.match(res.headers['content-type'], new RegExp(contentType), `Correct content-type header sent: ${contentType}`)
@@ -417,20 +476,19 @@ test('Architect v4 + Functions statically-bound content type responses (HTTP)',
   run(r.xml, r.xml.xml, 'application/xml')
 })
 
-test('Architect v4 + Functions statically-bound content type responses (REST)', t => {
+test('Architect v4 + Functions statically-bound content type responses (REST)', (t) => {
   t.plan(24)
-  let request = requests.arc6.getIndex
-  let r = legacyResponses.arc4
-  let run = (response, data, contentType) => {
-    let handler = http((req, res) => res(response))
+  const request = requests.arc6.getIndex
+  const r = legacyResponses.arc4
+  const run = (response, data, contentType) => {
+    const handler = http((req, res) => res(response))
     responsesTested.push(response)
     handler(copy(request), {}, (err, res) => {
       t.notOk(err, 'No error')
       // Don't double-encode JSON
       if (res.headers['content-type'].includes('json')) {
         t.equal(str(data), res.body, match('res.body', res.body))
-      }
-      else {
+      } else {
         t.equal(str(data), str(res.body), match('res.body', res.body))
       }
       t.match(res.headers['content-type'], new RegExp(contentType), `Correct content-type header sent: ${contentType}`)
@@ -445,14 +503,18 @@ test('Architect v4 + Functions statically-bound content type responses (REST)',
   run(r.xml, r.xml.xml, 'application/xml')
 })
 
-test('Architect <6 + Functions old school response params (HTTP)', t => {
+test('Architect <6 + Functions old school response params (HTTP)', (t) => {
   t.plan(12)
-  let request = requests.arc7.getIndex
+  const request = requests.arc7.getIndex
 
   run(legacyResponses.arc.location, copy(request), (err, res) => {
     t.notOk(err, 'No error')
     t.equal(res.statusCode, 302, match('res.statusCode', res.statusCode))
-    t.equal(legacyResponses.arc.location.location, res.headers.location, match('res.headers.location', res.headers.location))
+    t.equal(
+      legacyResponses.arc.location.location,
+      res.headers.location,
+      match('res.headers.location', res.headers.location),
+    )
     t.equal(res.headers['cache-control'], antiCache, match('cache-control', res.headers['cache-control']))
   })
   run(legacyResponses.arc.status, copy(request), (err, res) => {
@@ -473,14 +535,18 @@ test('Architect <6 + Functions old school response params (HTTP)', t => {
   })
 })
 
-test('Architect <6 + Functions old school response params (REST)', t => {
+test('Architect <6 + Functions old school response params (REST)', (t) => {
   t.plan(12)
-  let request = requests.arc6.getIndex
+  const request = requests.arc6.getIndex
 
   run(legacyResponses.arc.location, copy(request), (err, res) => {
     t.notOk(err, 'No error')
     t.equal(res.statusCode, 302, match('res.statusCode', res.statusCode))
-    t.equal(legacyResponses.arc.location.location, res.headers.location, match('res.headers.location', res.headers.location))
+    t.equal(
+      legacyResponses.arc.location.location,
+      res.headers.location,
+      match('res.headers.location', res.headers.location),
+    )
     t.equal(res.headers['cache-control'], antiCache, match('cache-control', res.headers['cache-control']))
   })
   run(legacyResponses.arc.status, copy(request), (err, res) => {
@@ -501,11 +567,11 @@ test('Architect <6 + Functions old school response params (REST)', t => {
   })
 })
 
-test('Return an error (HTTP)', t => {
+test('Return an error (HTTP)', (t) => {
   t.plan(3)
-  let request = requests.arc7.getIndex
-  let error = Error('something bad happened')
-  let handler = http((req, res) => res(error))
+  const request = requests.arc7.getIndex
+  const error = Error('something bad happened')
+  const handler = http((req, res) => res(error))
   handler(copy(request), {}, (err, res) => {
     t.notOk(err, 'No error')
     t.equal(res.statusCode, 500, 'Error response, 500 returned')
@@ -513,11 +579,11 @@ test('Return an error (HTTP)', t => {
   })
 })
 
-test('Return an error (REST)', t => {
+test('Return an error (REST)', (t) => {
   t.plan(3)
-  let request = requests.arc6.getIndex
-  let error = Error('something bad happened')
-  let handler = http((req, res) => res(error))
+  const request = requests.arc6.getIndex
+  const error = Error('something bad happened')
+  const handler = http((req, res) => res(error))
   handler(copy(request), {}, (err, res) => {
     t.notOk(err, 'No error')
     t.equal(res.statusCode, 500, 'Error response, 500 returned')
@@ -525,35 +591,40 @@ test('Return an error (REST)', t => {
   })
 })
 
-test('Verify all Arc v7 (HTTP) + Arc v6 (REST) + legacy response fixtures were tested', t => {
-  let totalReqs = Object.keys(responses.arc7).length +
-                  Object.keys(responses.arc6).length +
-                  Object.keys(legacyResponses.arc5).length +
-                  Object.keys(legacyResponses.arc4).length +
-                  Object.keys(legacyResponses.arc).length
+test('Verify all Arc v7 (HTTP) + Arc v6 (REST) + legacy response fixtures were tested', (t) => {
+  const totalReqs =
+    Object.keys(responses.arc7).length +
+    Object.keys(responses.arc6).length +
+    Object.keys(legacyResponses.arc5).length +
+    Object.keys(legacyResponses.arc4).length +
+    Object.keys(legacyResponses.arc).length
   t.plan(totalReqs)
-  let tester = ([ name, req ]) => {
-    t.ok(responsesTested.some(tested => {
-      try {
-        deepStrictEqual(req, tested)
-        return true
-      }
-      catch { /* noop */ }
-    }), `Tested res: ${name}`)
+  const tester = ([name, req]) => {
+    t.ok(
+      responsesTested.some((tested) => {
+        try {
+          deepStrictEqual(req, tested)
+          return true
+        } catch {
+          /* noop */
+        }
+      }),
+      `Tested res: ${name}`,
+    )
   }
-  console.log(`Arc 7 responses`)
+  console.log('Arc 7 responses')
   Object.entries(responses.arc7).forEach(tester)
-  console.log(`Arc 6 responses`)
+  console.log('Arc 6 responses')
   Object.entries(responses.arc6).forEach(tester)
-  console.log(`Legacy Arc 5 responses`)
+  console.log('Legacy Arc 5 responses')
   Object.entries(legacyResponses.arc5).forEach(tester)
-  console.log(`Legacy Arc 4 responses`)
+  console.log('Legacy Arc 4 responses')
   Object.entries(legacyResponses.arc4).forEach(tester)
-  console.log(`Legacy Arc responses`)
+  console.log('Legacy Arc responses')
   Object.entries(legacyResponses.arc).forEach(tester)
 })
 
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   delete process.env.ARC_SESSION_TABLE_NAME
diff --git a/test/unit/src/http/session/get-idx-test.js b/test/unit/src/http/session/get-idx-test.js
index 33dbf87a..1f5078a2 100644
--- a/test/unit/src/http/session/get-idx-test.js
+++ b/test/unit/src/http/session/get-idx-test.js
@@ -1,19 +1,19 @@
-let test = require('tape')
-let { join } = require('path')
-let sut = join(process.cwd(), 'src', 'http', 'session', 'providers', '_get-idx')
-let getIdx = require(sut)
+const test = require('tape')
+const { join } = require('node:path')
+const sut = join(process.cwd(), 'src', 'http', 'session', 'providers', '_get-idx')
+const getIdx = require(sut)
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
   t.ok(getIdx, 'Got getIdx module')
 })
 
-test('Test some cookies', t => {
+test('Test some cookies', (t) => {
   t.plan(7)
   let result
   let cookie
-  let random = Math.random() + ''
-  let idx = `_idx=${random}`
+  const random = `${Math.random()}`
+  const idx = `_idx=${random}`
 
   result = getIdx()
   t.equal(result, '', 'Passing nothing returns empty string')
diff --git a/test/unit/src/http/session/session-test.js b/test/unit/src/http/session/session-test.js
index f91b9936..accfa1c3 100644
--- a/test/unit/src/http/session/session-test.js
+++ b/test/unit/src/http/session/session-test.js
@@ -1,39 +1,40 @@
-let { join } = require('path')
-let sandbox = require('@architect/sandbox')
-let test = require('tape')
-let http = require('../../../../../src/http')
-let { read, write } = http.session
+const { join } = require('node:path')
+const sandbox = require('@architect/sandbox')
+const test = require('tape')
+const http = require('../../../../../src/http')
+const { read, write } = http.session
 
-test('http.session apis exist', t => {
+test('http.session apis exist', (t) => {
   t.plan(2)
   t.ok(read, 'http.session.read')
   t.ok(write, 'http.session.write')
 })
 
-test('JWE read + write', async t => {
+test('JWE read + write', async (t) => {
   t.plan(5)
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
   process.env.ARC_SESSION_TTL = 14400
-  let fakerequest = {}
-  let session = await read(fakerequest)
+  const fakerequest = {}
+  const session = await read(fakerequest)
   t.ok(session, 'read session cookie')
   session.one = 1
-  let cookie = await write(session)
+  const cookie = await write(session)
   t.ok(cookie, 'wrote session cookie')
-  let inception = await read({ headers: { Cookie: cookie } })
+  const inception = await read({ headers: { Cookie: cookie } })
   console.log({ session, cookie, inception })
   t.equal(inception.one, 1, 'read back again')
   // Lambda payload version 2
-  let inception2 = await read({ cookies: [ cookie ] })
+  const inception2 = await read({ cookies: [cookie] })
   t.equal(inception2.one, 1, 'read back again from payload version 2')
   t.match(cookie, new RegExp(`Max-Age=${process.env.ARC_SESSION_TTL}`), 'cookie max-age is set correctly')
 })
 
-test('JWE configuration', async t => {
+test('JWE configuration', async (t) => {
   t.plan(6)
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
   process.env.ARC_SESSION_TTL = 14400
-  let session = {}, cookie
+  const session = {}
+  let cookie
 
   // Default
   process.env.ARC_ENV = 'testing'
@@ -46,7 +47,11 @@ test('JWE configuration', async t => {
   // Configure SameSite
   process.env.ARC_SESSION_SAME_SITE = 'None'
   cookie = await write(session)
-  t.match(cookie, new RegExp(`SameSite=${process.env.ARC_SESSION_SAME_SITE}`), 'SameSite is set correctly to configured value')
+  t.match(
+    cookie,
+    new RegExp(`SameSite=${process.env.ARC_SESSION_SAME_SITE}`),
+    'SameSite is set correctly to configured value',
+  )
   console.log(cookie)
 
   // Configure Domain
@@ -63,44 +68,45 @@ test('JWE configuration', async t => {
   // Configure secure
   process.env.ARC_ENV = 'staging'
   cookie = await write(session)
-  t.match(cookie, new RegExp(`Secure`), 'Secure is set')
+  t.match(cookie, /Secure/, 'Secure is set')
   console.log(cookie)
   delete process.env.ARC_ENV
 })
 
-test('JWE algo / secret configuration', async t => {
+test('JWE algo / secret configuration', async (t) => {
   t.plan(8)
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
   process.env.ARC_SESSION_TTL = 14400
-  let payload = { one: 1 }
-  let session, cookie
+  const payload = { one: 1 }
+  let session
+  let cookie
 
   // Default algo / secret
   cookie = await write(payload)
   t.ok(cookie, `Wrote session cookie: ${cookie}`)
   session = await read({ headers: { cookie } })
-  console.log(`Current session:`, session)
+  console.log('Current session:', session)
   t.equal(session.one, 1, 'Returned session using default algorithm and secret')
 
   // Default algo + custom secret
   process.env.ARC_APP_SECRET = 'abcdefghijklmnopqrstuvwxyz012345'
   session = await read({ headers: { cookie } })
-  console.log(`Current session:`, session)
+  console.log('Current session:', session)
   t.deepEqual(session, {}, 'Returned empty session (because secret changed)')
   cookie = await write(payload)
   session = await read({ headers: { cookie } })
-  console.log(`Current session:`, session)
+  console.log('Current session:', session)
   t.equal(session.one, 1, 'Returned session using default algorithm and custom secret')
 
   // Custom algo + custom secret
   process.env.ARC_APP_SECRET = 'abcdefghijklmnopqrstuvwx'
   process.env.ARC_APP_SECRET_ALGO = 'A192GCM'
   session = await read({ headers: { cookie } })
-  console.log(`Current session:`, session)
+  console.log('Current session:', session)
   t.deepEqual(session, {}, 'Returned empty session (because secret changed)')
   cookie = await write(payload)
   session = await read({ headers: { cookie } })
-  console.log(`Current session:`, session)
+  console.log('Current session:', session)
   t.equal(session.one, 1, 'Returned session using custom algorithm and secret')
 
   // Legacy mode
@@ -108,16 +114,16 @@ test('JWE algo / secret configuration', async t => {
   delete process.env.ARC_APP_SECRET
   delete process.env.ARC_APP_SECRET_ALGO
   session = await read({ headers: { cookie } })
-  console.log(`Current session:`, session)
+  console.log('Current session:', session)
   t.deepEqual(session, {}, 'Returned empty session (because secret changed)')
   cookie = await write(payload)
   session = await read({ headers: { cookie } })
-  console.log(`Current session:`, session)
+  console.log('Current session:', session)
   t.equal(session.one, 1, 'Returned session using default algorithm and custom secret')
   delete process.env.ARC_FORCE_LEGACY_JWE_SECRET
 })
 
-test('JWE errors', async t => {
+test('JWE errors', async (t) => {
   t.plan(2)
   process.env.ARC_SESSION_TABLE_NAME = 'jwe'
   process.env.ARC_SESSION_TTL = 14400
@@ -125,8 +131,7 @@ test('JWE errors', async t => {
   try {
     process.env.ARC_APP_SECRET_ALGO = 'foo'
     await write({})
-  }
-  catch (err) {
+  } catch (err) {
     t.ok(err.message.includes('Invalid token algorithm'), 'Threw invalid token algo error')
     delete process.env.ARC_APP_SECRET_ALGO
   }
@@ -134,42 +139,41 @@ test('JWE errors', async t => {
   try {
     process.env.ARC_APP_SECRET = 'abc123'
     await write({})
-  }
-  catch (err) {
+  } catch (err) {
     t.ok(err.message.includes('Invalid secret length'), 'Threw invalid secret length error')
     delete process.env.ARC_APP_SECRET
   }
 })
 
-test('Start Sandbox for DynamoDB-backed sessions', t => {
+test('Start Sandbox for DynamoDB-backed sessions', (t) => {
   t.plan(1)
-  let cwd = join(process.cwd(), 'test', 'mock', 'project')
-  sandbox.start({ cwd, quiet: true }, err => {
+  const cwd = join(process.cwd(), 'test', 'mock', 'project')
+  sandbox.start({ cwd, quiet: true }, (err) => {
     if (err) t.fail(err)
     else t.pass('Sandbox started')
   })
 })
 
-test('DDB read + write', async t => {
+test('DDB read + write', async (t) => {
   t.plan(5)
   process.env.ARC_SESSION_TABLE_NAME = 'test-only-staging-arc-sessions'
   process.env.ARC_SESSION_TTL = 14400
-  let fakerequest = {}
-  let session = await read(fakerequest)
+  const fakerequest = {}
+  const session = await read(fakerequest)
   t.ok(session, 'read session cookie')
   session.one = 1
-  let cookie = await write(session)
+  const cookie = await write(session)
   t.ok(cookie, 'wrote modified session cookie')
-  let inception = await read({ headers: { Cookie: cookie } })
+  const inception = await read({ headers: { Cookie: cookie } })
   console.log({ session, cookie, inception })
   t.equals(inception.one, 1, 'read back modified cookie')
   // Lambda payload version 2
-  let inception2 = await read({ cookies: [ cookie ] })
+  const inception2 = await read({ cookies: [cookie] })
   t.equals(inception2.one, 1, 'read back again from payload version 2')
   t.match(cookie, new RegExp(`Max-Age=${process.env.ARC_SESSION_TTL}`), 'cookie max-age is set correctly')
 })
 
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_APP_SECRET
   delete process.env.ARC_APP_SECRET_ALGO
@@ -180,7 +184,7 @@ test('Teardown', t => {
   delete process.env.ARC_SESSION_TABLE_NAME
   delete process.env.ARC_SESSION_TTL
   delete process.env.SESSION_DOMAIN
-  sandbox.end(err => {
+  sandbox.end((err) => {
     if (err) t.fail(err)
     else t.pass('Sandbox started')
   })
diff --git a/test/unit/src/lib/_sandbox-version-test.js b/test/unit/src/lib/_sandbox-version-test.js
index 26723b8b..e129816a 100644
--- a/test/unit/src/lib/_sandbox-version-test.js
+++ b/test/unit/src/lib/_sandbox-version-test.js
@@ -1,9 +1,9 @@
-let { join } = require('path')
-let test = require('tape')
-let sut = join(process.cwd(), 'src', 'lib', '_sandbox-version')
-let { versionGTE } = require(sut)
+const { join } = require('node:path')
+const test = require('tape')
+const sut = join(process.cwd(), 'src', 'lib', '_sandbox-version')
+const { versionGTE } = require(sut)
 
-test('versionGTE', t => {
+test('versionGTE', (t) => {
   t.plan(7)
   t.true(versionGTE('1.0.0', '1.0.0'), 'equal')
   t.false(versionGTE('1.0.0', '1.0.1'), 'less than patch')
diff --git a/test/unit/src/queues/publish-test.js b/test/unit/src/queues/publish-test.js
index 7364940a..e891a1e1 100644
--- a/test/unit/src/queues/publish-test.js
+++ b/test/unit/src/queues/publish-test.js
@@ -1,25 +1,37 @@
-let test = require('tape')
+const test = require('tape')
 let publish
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
 
-  let arc = require('../../../..')
+  const arc = require('../../../..')
   publish = arc.queues.publish
   t.ok(publish, 'Got queues.publish method')
 })
 
-test('queues.publish should throw if there is no parameter name', t => {
+test('queues.publish should throw if there is no parameter name', (t) => {
   t.plan(1)
-  t.throws(() => { publish({}) }, /missing params.name/, 'throws missing name parameter exception')
+  t.throws(
+    () => {
+      publish({})
+    },
+    /missing params.name/,
+    'throws missing name parameter exception',
+  )
 })
 
-test('queues.publish should throw if there is no parameter payload', t => {
+test('queues.publish should throw if there is no parameter payload', (t) => {
   t.plan(1)
-  t.throws(() => { publish({ name: 'batman' }) }, /missing params.payload/, 'throws missing payload parameter exception')
+  t.throws(
+    () => {
+      publish({ name: 'batman' })
+    },
+    /missing params.payload/,
+    'throws missing payload parameter exception',
+  )
 })
 
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   t.pass('Done!')
diff --git a/test/unit/src/queues/subscribe-test.js b/test/unit/src/queues/subscribe-test.js
index 4c32bb61..a17e2ae1 100644
--- a/test/unit/src/queues/subscribe-test.js
+++ b/test/unit/src/queues/subscribe-test.js
@@ -1,44 +1,43 @@
-let test = require('tape')
-let sinon = require('sinon')
-let mockSqsEvent = require('../../../mock/mock-sqs-event.json')
+const test = require('tape')
+const sinon = require('sinon')
+const mockSqsEvent = require('../../../mock/mock-sqs-event.json')
 let subscribe
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
 
-  let arc = require('../../../..')
+  const arc = require('../../../..')
   subscribe = arc.queues.subscribe
   t.ok(subscribe, 'Got queues.subscribe method')
 })
 
-test('queues.subscribe calls handler', t => {
+test('queues.subscribe calls handler', (t) => {
   t.plan(1)
 
-  let eventHandler = sinon.fake.yields()
+  const eventHandler = sinon.fake.yields()
 
   // get a lambda signature from the handler
-  let handler = subscribe(eventHandler)
+  const handler = subscribe(eventHandler)
 
   // invoke the lambda handler with mock payloads
-  let mockContext = {}
-  handler(mockSqsEvent, mockContext, function _handler (err) {
+  const mockContext = {}
+  handler(mockSqsEvent, mockContext, function _handler(err) {
     if (err) {
       t.fail(err)
-    }
-    else {
+    } else {
       t.ok(eventHandler.calledOnce, 'event handler called once')
     }
   })
 })
 
-test('queues.subscribe calls async handler', async t => {
+test('queues.subscribe calls async handler', async (t) => {
   t.plan(1)
 
-  let fake = sinon.fake()
+  const fake = sinon.fake()
 
   // get a lambda signature from the handler
 
-  let handler = subscribe(async function (json) {
+  const handler = subscribe(async (json) => {
     fake(json)
   })
 
@@ -47,7 +46,7 @@ test('queues.subscribe calls async handler', async t => {
   t.ok(fake.calledOnce, 'event handler called once')
 })
 
-test('Teardown', t => {
+test('Teardown', (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   t.pass('Done!')
diff --git a/test/unit/src/static/index-test.js b/test/unit/src/static/index-test.js
index 984034df..907de2bd 100644
--- a/test/unit/src/static/index-test.js
+++ b/test/unit/src/static/index-test.js
@@ -1,26 +1,27 @@
-let test = require('tape')
-let proxyquire = require('proxyquire')
+const test = require('tape')
+const proxyquire = require('proxyquire')
 
 let manifestExists = true
-let fs = {
-  readFileSync: () => (JSON.stringify({
-    'foo.png': 'foo-1a2b3d.png',
-  })),
+const fs = {
+  readFileSync: () =>
+    JSON.stringify({
+      'foo.png': 'foo-1a2b3d.png',
+    }),
   existsSync: () => manifestExists,
 }
-let arcStatic = proxyquire('../../../../src/static', { fs })
+const arcStatic = proxyquire('../../../../src/static', { fs })
 
-function reset () {
+function reset() {
   delete process.env.ARC_ENV
   if (process.env.ARC_ENV) throw ReferenceError('ARC_ENV not unset')
 }
 
-test('Set up env', t => {
+test('Set up env', (t) => {
   t.plan(1)
   t.ok(arcStatic, 'Static helper found')
 })
 
-test('Local env returns non-fingerprinted path', t => {
+test('Local env returns non-fingerprinted path', (t) => {
   t.plan(3)
   reset()
   manifestExists = true
@@ -33,52 +34,52 @@ test('Local env returns non-fingerprinted path', t => {
   t.equal(asset, '/_static/foo.png', 'Returned non-fingerprinted path with stagePath option present')
 })
 
-test('Staging env returns _static path if root is requested', t => {
+test('Staging env returns _static path if root is requested', (t) => {
   t.plan(1)
   reset()
   manifestExists = false
   process.env.ARC_ENV = 'staging'
-  let asset = arcStatic('/')
+  const asset = arcStatic('/')
   t.equal(asset, '/_static/', 'Returned _static path')
 })
 
-test('Staging env returns non-fingerprinted path if static manifest is not present', t => {
+test('Staging env returns non-fingerprinted path if static manifest is not present', (t) => {
   t.plan(1)
   reset()
   manifestExists = false
   process.env.ARC_ENV = 'staging'
-  let asset = arcStatic('foo.png')
+  const asset = arcStatic('foo.png')
   t.equal(asset, '/_static/foo.png', 'Returned non-fingerprinted path')
 })
 
-test('Staging env returns fingerprinted path if static manifest is present', t => {
+test('Staging env returns fingerprinted path if static manifest is present', (t) => {
   t.plan(1)
   reset()
   manifestExists = true
   process.env.ARC_ENV = 'staging'
-  let asset = arcStatic('foo.png')
+  const asset = arcStatic('foo.png')
   t.equal(asset, '/_static/foo-1a2b3d.png', 'Returned fingerprinted path')
 })
 
-test('Staging env returns non-fingerprinted path if file is not present in static manifest mapping', t => {
+test('Staging env returns non-fingerprinted path if file is not present in static manifest mapping', (t) => {
   t.plan(1)
   reset()
   manifestExists = true
   process.env.ARC_ENV = 'staging'
-  let asset = arcStatic('bar.png')
+  const asset = arcStatic('bar.png')
   t.equal(asset, '/_static/bar.png', 'Returned non-fingerprinted path')
 })
 
-test('Passing stagePath option adds API Gateway /staging or /production to path', t => {
+test('Passing stagePath option adds API Gateway /staging or /production to path', (t) => {
   t.plan(1)
   reset()
   manifestExists = true
   process.env.ARC_ENV = 'staging'
-  let asset = arcStatic('foo.png', { stagePath: true })
+  const asset = arcStatic('foo.png', { stagePath: true })
   t.equal(asset, '/staging/_static/foo-1a2b3d.png', 'Returned fingerprinted path with API Gateway stage')
 })
 
-test('Reset', t => {
+test('Reset', (t) => {
   reset()
   t.end()
 })
diff --git a/test/unit/src/tables/factory-test.js b/test/unit/src/tables/factory-test.js
index a274c15f..c6db3580 100644
--- a/test/unit/src/tables/factory-test.js
+++ b/test/unit/src/tables/factory-test.js
@@ -1,26 +1,25 @@
-let { join } = require('path')
-let test = require('tape')
-let proxyquire = require('proxyquire')
-let sandbox = require('@architect/sandbox')
-let cwd = process.cwd()
-let mock = join(cwd, 'test', 'mock', 'project')
-
-let noop = () => {}
-let factory = proxyquire('../../../../src/tables/factory', {
+const { join } = require('node:path')
+const test = require('tape')
+const proxyquire = require('proxyquire')
+const sandbox = require('@architect/sandbox')
+const cwd = process.cwd()
+const mock = join(cwd, 'test', 'mock', 'project')
+
+const noop = () => {}
+const factory = proxyquire('../../../../src/tables/factory', {
   './legacy': () => ({ db: noop, doc: noop }),
 })
 
-let services = { tables: { hi: 'there' } }
+const services = { tables: { hi: 'there' } }
 
-test('Set up env', async t => {
+test('Set up env', async (t) => {
   t.plan(2)
   await sandbox.start({ cwd: mock, quiet: true })
   t.pass('Sandbox started')
   t.ok(factory, 'Tables factory ready')
 })
 
-
-test('tables.factory main client', t => {
+test('tables.factory main client', (t) => {
   t.plan(4)
   factory({ services }, (err, client) => {
     if (err) t.fail(err)
@@ -31,7 +30,7 @@ test('tables.factory main client', t => {
   })
 })
 
-test('tables.factory AWS SDK properties', t => {
+test('tables.factory AWS SDK properties', (t) => {
   t.plan(4)
   factory({ services, options: { awsSdkClient: true } }, (err, client) => {
     if (err) t.fail(err)
@@ -42,9 +41,9 @@ test('tables.factory AWS SDK properties', t => {
   })
 })
 
-test('tables.factory client static methods', t => {
+test('tables.factory client static methods', (t) => {
   t.plan(2)
-  let services = { tables: { quart: 'tequila' } }
+  const services = { tables: { quart: 'tequila' } }
   factory({ services }, async (err, client) => {
     if (err) t.fail(err)
     t.equals(await client.reflect(), services.tables, 'reflect() returns tables object')
@@ -52,7 +51,7 @@ test('tables.factory client static methods', t => {
   })
 })
 
-test('Teardown', async t => {
+test('Teardown', async (t) => {
   t.plan(1)
   delete process.env.ARC_ENV
   await sandbox.end()