Handle Promises via duck typing

index.js

@@ -128,7 +128,7 @@ export function wrap(middleware, callback) {
     }
 
     if (!fnExpectsCallback) {
-      if (result instanceof Promise) {
+      if (result && result.then && typeof result.then === 'function') {
         result.then(then, done)
       } else if (result instanceof Error) {
         done(result)

test.js

@@ -123,6 +123,47 @@ test('promise middleware', async function () {
       })
   })
 
+  await new Promise((resolve) => {
+    trough()
+      .use((/** @type {string} */ value) => {
+        assert.equal(value, 'some', 'should pass values to `fn`s')
+
+        /**
+         * @callback resolveCallback
+         * @param {string} value
+         */
+        return {
+          then: (/** @type {resolveCallback} */ resolve) => {
+            resolve(value + 'thing')
+          }
+        }
+      })
+      .run('some', (/** @type {void} */ error, /** @type {string} */ value) => {
+        assert.ifError(error)
+        assert.equal(value, 'something', 'should pass values to `done`')
+        resolve(undefined)
+      })
+  })
+
+  await new Promise((resolve) => {
+    trough()
+      .use((/** @type {string} */ value) => {
+        assert.equal(value, 'some', 'should pass values to `fn`s')
+
+        return {
+          then: 'something'
+        }
+      })
+      .run(
+        'some',
+        (/** @type {void} */ error, /** @type {{ then: string }} */ value) => {
+          assert.ifError(error)
+          assert.equal(value.then, 'something', 'should pass values to `done`')
+          resolve(undefined)
+        }
+      )
+  })
+
   await new Promise((resolve) => {
     trough()
       .use((/** @type {string} */ value) => {