mqtt-plus 1.4.25 → 1.4.26

package/etc/stx.conf

@@ -24,10 +24,11 @@
 
 #   make patches
 patch-make
-    npm shrinkwrap && \
+    npm install --package-lock-only --save && \
+    cross-env npm_config_allow_remote=all \
     patch-package --patch-dir package.d \
         "vite" "@typescript-eslint/typescript-estree" && \
-    shx rm -f npm-shrinkwrap.json
+    shx rm -f package-lock.json
 
 #   (internal) apply patches
 patch-apply

package/package.d/@typescript-eslint+typescript-estree+8.66.0.patch

@@ -0,0 +1,12 @@
+diff --git a/node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/warnAboutTSVersion.js b/node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/warnAboutTSVersion.js
+index 0961c74..b76d468 100644
+--- a/node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/warnAboutTSVersion.js
++++ b/node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/warnAboutTSVersion.js
+@@ -84,7 +84,6 @@ function handleUnsupportedTSVersion(parseSettings, behavior, passedLoggerFn) {
+         // See https://github.com/typescript-eslint/typescript-eslint/issues/7896
+         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+         (typeof process === 'undefined' ? false : process.stdout?.isTTY)) {
+-        parseSettings.log(buildUnsupportedTSVersionMessage('warn'));
+     }
+     warnedAboutTSVersion = true;
+ }

package/package.d/{vite+8.1.4.patch → vite+8.2.1.patch}

@@ -1,8 +1,8 @@
 diff --git a/node_modules/vite/dist/node/chunks/node.js b/node_modules/vite/dist/node/chunks/node.js
-index 69b9f8c..f661ab9 100644
+index 6aae7ee..0d52252 100644
 --- a/node_modules/vite/dist/node/chunks/node.js
 +++ b/node_modules/vite/dist/node/chunks/node.js
-@@ -36150,7 +36150,6 @@ async function runConfigHook(config, plugins, configEnv) {
+@@ -37094,7 +37094,6 @@ async function runConfigHook(config, plugins, configEnv) {
  		const res = await getHookHandler(hook).call(context, conf, configEnv);
  		if (res && res !== conf) {
  			if (hasBothRollupOptionsAndRolldownOptions(res)) context.warn(`Both \`rollupOptions\` and \`rolldownOptions\` were specified by ${JSON.stringify(p.name)} plugin. \`rollupOptions\` specified by that plugin will be ignored.`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":                           "mqtt-plus",
-    "version":                        "1.4.25",
+    "version":                        "1.4.26",
     "description":                    "MQTT Communication Patterns",
     "keywords":                       [   "mqtt",
                                           "event", "emit",
@@ -33,37 +33,37 @@
         "patch-package":              "8.0.1",
         "@rse/stx":                   "1.1.6",
         "shx":                        "0.4.0",
-        "eslint":                     "10.7.0",
-        "globals":                    "17.7.0",
+        "eslint":                     "10.8.0",
+        "globals":                    "17.9.0",
         "@eslint/js":                 "10.0.1",
         "@eslint/eslintrc":           "3.3.6",
-        "knip":                       "6.26.0",
+        "knip":                       "6.32.0",
         "jiti":                       "2.7.0",
-        "tsx":                        "4.23.0",
-        "mocha":                      "11.7.6",
+        "tsx":                        "4.23.9",
+        "mocha":                      "11.8.0",
         "chai":                       "6.2.2",
         "sinon-chai":                 "4.0.1",
-        "sinon":                      "22.0.0",
-        "c8":                         "11.0.0",
+        "sinon":                      "22.1.0",
+        "c8":                         "12.0.0",
         "source-map-support":         "0.5.21",
         "typescript":                 "6.0.3",
-        "typescript-eslint":          "8.63.0",
-        "@typescript-eslint/parser":  "8.63.0",
+        "typescript-eslint":          "8.66.0",
+        "@typescript-eslint/parser":  "8.66.0",
         "mqtt":                       "5.15.2",
         "aedes":                      "1.1.1",
         "mosquitto":                  "1.1.0",
         "textframe":                  "1.2.1",
-        "vite":                       "8.1.4",
+        "vite":                       "8.2.1",
         "vite-plugin-node-polyfills": "0.28.0",
         "@rollup/plugin-replace":     "6.0.3",
         "@wroud/vite-plugin-tsc":     "0.12.3",
         "@terrastruct/d2":            "0.1.33",
         "chokidar-cli":               "3.0.0",
-        "chalk":                      "5.6.2",
+        "chalk":                      "6.0.0",
         "open-cli":                   "9.0.0",
         "cross-env":                  "10.1.0",
 
-        "@types/node":                "26.1.1",
+        "@types/node":                "26.1.2",
         "@types/mocha":               "10.0.10",
         "@types/chai":                "5.2.3",
         "@types/sinon-chai":          "4.0.0",
@@ -76,14 +76,15 @@
         "vite-plugin-node-polyfills":           { "vite": ">=7.0.0" }
     },
     "allowScripts": {
+        "fsevents":                   true,
         "esbuild":                    true
     },
     "dependencies": {
-        "nanoid":                     "5.1.16",
+        "nanoid":                     "6.0.1",
         "cbor2":                      "2.3.0",
         "p-lazy":                     "5.0.0",
         "valibot":                    "1.4.2",
-        "jose":                       "6.2.3",
+        "jose":                       "6.2.8",
         "@stablelib/pbkdf2":          "2.0.1",
         "@stablelib/sha256":          "2.0.1"
     },

package/src/mqtt-plus-base.ts

@@ -40,8 +40,8 @@ import { PLazy }                        from "./mqtt-plus-util"
 
 /*  MQTTp Base class with shared infrastructure  */
 export class BaseTrait<T extends APISchema = APISchema> extends TraceTrait<T> {
-    private mqtt: MqttClient
-    private messageHandler: OnMessageCallback
+    private _mqtt:           MqttClient
+    private _messageHandler: OnMessageCallback
 
     /*  lifecycle state  */
     protected destroyed = false
@@ -78,7 +78,7 @@ export class BaseTrait<T extends APISchema = APISchema> extends TraceTrait<T> {
         }
 
         /*  store MQTT client  */
-        this.mqtt = mqtt
+        this._mqtt = mqtt
 
         /*  resolve the instance "id": if the user did not provide an
             explicit one, fetch the "clientId" from the underlying MQTT
@@ -95,7 +95,7 @@ export class BaseTrait<T extends APISchema = APISchema> extends TraceTrait<T> {
 
         /*  hook into the MQTT message processing  */
         this.log("info", "hooking into MQTT client")
-        this.messageHandler = (topic, message, packet) => {
+        this._messageHandler = (topic, message, packet) => {
             if (this.destroyed)
                 return
 
@@ -116,14 +116,14 @@ export class BaseTrait<T extends APISchema = APISchema> extends TraceTrait<T> {
             }
             this._onMessage(topic, input, packet)
         }
-        this.mqtt.on("message", this.messageHandler)
+        this._mqtt.on("message", this._messageHandler)
     }
 
     /*  destroy API class  */
     async destroy () {
         this.destroyed = true
         this.log("info", "un-hooking from MQTT client")
-        this.mqtt.off("message", this.messageHandler)
+        this._mqtt.off("message", this._messageHandler)
         this.onRequest.clear()
         this.onResponse.clear()
     }
@@ -149,7 +149,7 @@ export class BaseTrait<T extends APISchema = APISchema> extends TraceTrait<T> {
     protected async subscribeTopic (topic: string, options: Partial<IClientSubscribeOptions> = {}): Promise<void> {
         this.log("info", `subscribing to MQTT topic "${topic}"`)
         return new Promise<void>((resolve, reject) => {
-            this.mqtt.subscribe(topic, { qos: 2, ...options }, (err: Error | null, granted: any) => {
+            this._mqtt.subscribe(topic, { qos: 2, ...options }, (err: Error | null, granted: any) => {
                 if (err) {
                     this.error(err, `subscribing to MQTT topic "${topic}" failed`)
                     reject(err)
@@ -172,7 +172,7 @@ export class BaseTrait<T extends APISchema = APISchema> extends TraceTrait<T> {
     protected async unsubscribeTopic (topic: string): Promise<void> {
         this.log("info", `unsubscribing from MQTT topic "${topic}"`)
         return new Promise<void>((resolve, reject) => {
-            this.mqtt.unsubscribe(topic, (err?: Error, _packet?: any) => {
+            this._mqtt.unsubscribe(topic, (err?: Error, _packet?: any) => {
                 if (err) {
                     this.error(err, `unsubscribing from MQTT topic "${topic}" failed`)
                     reject(err)
@@ -215,7 +215,7 @@ export class BaseTrait<T extends APISchema = APISchema> extends TraceTrait<T> {
             const messageData = typeof message === "string"
                 ? message
                 : Buffer.from(message.buffer, message.byteOffset, message.byteLength)
-            this.mqtt.publish(topic, messageData, options, (err?: Error) => {
+            this._mqtt.publish(topic, messageData, options, (err?: Error) => {
                 if (err) {
                     this.error(err, `publishing to MQTT topic "${topic}" failed`)
                     reject(err)
@@ -268,12 +268,15 @@ export class BaseTrait<T extends APISchema = APISchema> extends TraceTrait<T> {
         }
         this.log("debug", `received from MQTT topic "${topic}"`, { message })
 
-        /*  warn on receiver mismatch on direct topics  */
+        /*  drop message on receiver mismatch on direct topics, as it is
+            addressed to a foreign peer and hence must not be processed here  */
         if (topicMatch.peerId !== undefined
             && message.receiver !== undefined
-            && message.receiver !== topicMatch.peerId)
-            this.log("warning", `receiver mismatch on direct topic "${topic}"` +
+            && message.receiver !== topicMatch.peerId) {
+            this.log("warning", `receiver mismatch -- dropped message from direct topic "${topic}"` +
                 ` (expected "${topicMatch.peerId}", got "${message.receiver}")`)
+            return
+        }
 
         /*  dispatch MQTT+ message  */
         if (this.msg.isRequest(message)) {

package/src/mqtt-plus-error.ts

@@ -201,11 +201,15 @@ function runUnroll (isAsync: boolean, spool?: Spool): Promise<void> | void {
     return result
 }
 
-/*  helper function for settling the epilog of "run": run the finally
-    code isolated, unroll the spool, and preserve a pending error  */
-function runSettle (isAsync: false,   pending: boolean, spool?: Spool, onfinally?: () => void,                  description?: string): void
-function runSettle (isAsync: true,    pending: boolean, spool?: Spool, onfinally?: () => Promise<void> | void,  description?: string): Promise<void>
-function runSettle (isAsync: boolean, pending: boolean, spool?: Spool, onfinally?: () => Promise<void> | void,  description?: string): Promise<void> | void {
+/*  helper type for an error carrying an attached, secondary error  */
+type ErrorSuppressing = Error & { suppressed?: Error }
+
+/*  helper function for settling the epilog of "run": run the finally code
+    isolated, unroll the spool, and preserve a pending error by attaching a
+    failing finally code to it as a suppressed error instead of discarding it  */
+function runSettle (isAsync: false,   pending: ErrorSuppressing | undefined, spool?: Spool, onfinally?: () => void,                  description?: string): void
+function runSettle (isAsync: true,    pending: ErrorSuppressing | undefined, spool?: Spool, onfinally?: () => Promise<void> | void,  description?: string): Promise<void>
+function runSettle (isAsync: boolean, pending: ErrorSuppressing | undefined, spool?: Spool, onfinally?: () => Promise<void> | void,  description?: string): Promise<void> | void {
     if (!isAsync) {
         let failure: Error | undefined
         try {
@@ -214,10 +218,14 @@ function runSettle (isAsync: boolean, pending: boolean, spool?: Spool, onfinally
         catch (arg: unknown) {
             failure = ensureError(arg, description)
         }
-        if (pending || failure !== undefined) {
+        if (pending !== undefined || failure !== undefined) {
             runUnroll(false, spool)
-            if (!pending && failure !== undefined)
-                throw failure
+            if (failure !== undefined) {
+                if (pending !== undefined)
+                    pending.suppressed = failure
+                else
+                    throw failure
+            }
         }
     }
     else {
@@ -229,15 +237,41 @@ function runSettle (isAsync: boolean, pending: boolean, spool?: Spool, onfinally
             catch (arg: unknown) {
                 failure = ensureError(arg, description)
             }
-            if (pending || failure !== undefined) {
+            if (pending !== undefined || failure !== undefined) {
                 await runUnroll(true, spool)
-                if (!pending && failure !== undefined)
-                    throw failure
+                if (failure !== undefined) {
+                    if (pending !== undefined)
+                        pending.suppressed = failure
+                    else
+                        throw failure
+                }
             }
         })()
     }
 }
 
+/*  helper function for settling the epilog of "run" and then failing with
+    a pending error in a still unknown synchronous/asynchronous context:
+    operate synchronously as long as possible and continue asynchronously as
+    soon as a callback returns a Promise. As the pending error always takes
+    precedence, a failing finally code is attached to it as a suppressed error.  */
+function runFail (error: ErrorSuppressing, spool?: Spool, onfinally?: () => Promise<void> | void, description?: string): Promise<never> {
+    const attach = (arg: unknown) => { error.suppressed = ensureError(arg, description) }
+    let result: Promise<void> | void = undefined
+    try {
+        result = onfinally?.()
+    }
+    catch (arg: unknown) {
+        attach(arg)
+    }
+    if (result instanceof Promise)
+        return result.catch(attach).then(() => spool?.unroll()).then(() => { throw error })
+    const unrolled = spool?.unroll()
+    if (unrolled instanceof Promise)
+        return unrolled.then(() => { throw error })
+    throw error
+}
+
 /*  helper type for ensuring T contains no Promise  */
 type RunNoPromise<T> =
     [ T ] extends [ Promise<any> ] ? never : T
@@ -379,31 +413,29 @@ export function run<T> (
         result = action()
     }
     catch (arg: unknown) {
-        /*  synchronous case (error branch)  */
-        let error = ensureError(arg, description)
-        if (oncatch) {
-            try {
-                result = oncatch(error)
-            }
-            catch (arg: unknown) {
-                error = ensureError(arg, description)
-                runSettle(false, true, spool, onfinally, description)
-                throw error
-            }
-            if (spool && oncleanup)
-                spool.roll(result, oncleanup as SpoolCleanup<unknown>)
-            runSettle(false, false, spool, onfinally, description)
-            return result
+        /*  synchronous case (error branch): as the action failed before
+            returning its potentially asynchronous result, the context is
+            still unknown here and hence has to be probed  */
+        const error = ensureError(arg, description)
+        if (!oncatch)
+            return runFail(error, spool, onfinally, description)
+        try {
+            result = oncatch(error)
         }
-        runSettle(false, true, spool, onfinally, description)
-        throw error
+        catch (arg: unknown) {
+            return runFail(ensureError(arg, description), spool, onfinally, description)
+        }
+
+        /*  the recovery already ran, so let the common epilog below settle
+            its potentially asynchronous result without re-entering it  */
+        oncatch = undefined
     }
     if (result instanceof Promise) {
         /*  asynchronous case (result or error branch)  */
         return result.then(async (result) => {
             if (spool && oncleanup)
                 spool.roll(result, oncleanup as SpoolCleanup<unknown>)
-            await runSettle(true, false, spool, onfinally, description)
+            await runSettle(true, undefined, spool, onfinally, description)
             return result
         }, async (arg: unknown) => {
             /*  asynchronous case (error branch)  */
@@ -415,15 +447,15 @@ export function run<T> (
                 }
                 catch (arg: unknown) {
                     error = ensureError(arg, description)
-                    await runSettle(true, true, spool, onfinally, description)
+                    await runSettle(true, error, spool, onfinally, description)
                     throw error
                 }
                 if (spool && oncleanup)
                     spool.roll(result, oncleanup as SpoolCleanup<unknown>)
-                await runSettle(true, false, spool, onfinally, description)
+                await runSettle(true, undefined, spool, onfinally, description)
                 return result
             }
-            await runSettle(true, true, spool, onfinally, description)
+            await runSettle(true, error, spool, onfinally, description)
             throw error
         })
     }
@@ -431,7 +463,7 @@ export function run<T> (
         /*  synchronous case (result branch)  */
         if (spool && oncleanup)
             spool.roll(result, oncleanup as SpoolCleanup<unknown>)
-        runSettle(false, false, spool, onfinally, description)
+        runSettle(false, undefined, spool, onfinally, description)
         return result
     }
 }

package/src/mqtt-plus-event.ts

@@ -28,6 +28,7 @@ import type { IClientPublishOptions,
 import { nanoid }                     from "nanoid"
 
 /*  internal requirements  */
+import { alignHandlerParams }         from "./mqtt-plus-util"
 import type { EventEmission }         from "./mqtt-plus-msg"
 import type { APISchema, EventKeys,
     Registration }                    from "./mqtt-plus-api"
@@ -142,7 +143,7 @@ export class EventTrait<T extends APISchema = APISchema> extends AuthTrait<T> {
                     ` (topic: "${topicName}", payload: "${request.name}")`, { requestId })
                 return
             }
-            const params   = request.params ?? []
+            const params   = alignHandlerParams(request.params ?? [], callback)
 
             /*  sanity check request id  */
             if (this.eventControllers.has(requestId)) {

package/src/mqtt-plus-options.ts

@@ -71,5 +71,13 @@ export class OptionsTrait<_T extends APISchema = APISchema> {
             },
             ...options
         }
+
+        /*  sanity check numeric option ranges  */
+        if (!(Number.isFinite(this.options.timeout) && this.options.timeout > 0))
+            throw new Error("options: \"timeout\" must be a positive number")
+        if (!(Number.isInteger(this.options.chunkSize) && this.options.chunkSize > 0))
+            throw new Error("options: \"chunkSize\" must be a positive integer")
+        if (!(Number.isInteger(this.options.chunkCredit) && this.options.chunkCredit >= 0))
+            throw new Error("options: \"chunkCredit\" must be a non-negative integer")
     }
 }

package/src/mqtt-plus-service.ts

@@ -28,6 +28,7 @@ import type { IClientPublishOptions,
 import { nanoid }                     from "nanoid"
 
 /*  internal requirements  */
+import { alignHandlerParams }         from "./mqtt-plus-util"
 import { run, Spool, ensureError }    from "./mqtt-plus-error"
 import type { ServiceCallRequest,
     ServiceCallResponse }             from "./mqtt-plus-msg"
@@ -138,7 +139,7 @@ export class ServiceTrait<T extends APISchema = APISchema> extends EventTrait<T>
             /*  determine request information  */
             const requestId = request.id
             const senderId  = request.sender
-            const params    = request.params ?? []
+            const params    = alignHandlerParams(request.params ?? [], callback)
             if (senderId === undefined || senderId === "") {
                 this.error(new Error("invalid request: missing sender"))
                 return
@@ -325,11 +326,13 @@ export class ServiceTrait<T extends APISchema = APISchema> extends EventTrait<T>
                 return false
             settled = true
 
-            /*  unroll fire-and-forget: the "settled" boolean guard is the
-                primary protection against concurrent/duplicate responses,
-                while cleanup errors are suppressed and the async MQTT
-                unsubscription is handled by reference-counting/linger  */
-            spool.unroll()
+            /*  unroll fire-and-forget: the "settled" boolean guard protects
+                against concurrent/duplicate responses and the async MQTT
+                unsubscription is handled by reference-counting/linger, while
+                cleanup failures are surfaced as "error" events  */
+            spool.unroll(false)?.catch((err: unknown) => {
+                this.error(ensureError(err, `cleanup after call of service "${name}" failed`))
+            })
             return true
         }
         const promise: Promise<ReturnType<T[K]>> = new Promise((resolve, reject) => {

package/src/mqtt-plus-sink.ts

@@ -33,7 +33,7 @@ import { nanoid }                                         from "nanoid"
 /*  internal requirements  */
 import { CreditGate, ReadableTee,
     sendBufferAsChunks, sendStreamAsChunks,
-    makeMutuallyExclusiveFields }                         from "./mqtt-plus-util"
+    makeMutuallyExclusiveFields, alignHandlerParams }     from "./mqtt-plus-util"
 import { run, Spool, ensureError }                        from "./mqtt-plus-error"
 import type { SinkPushRequest, SinkPushResponse,
     SinkPushChunk, SinkPushCredit }                       from "./mqtt-plus-msg"
@@ -163,7 +163,7 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
 
             /*  determine information  */
             const requestId = request.id
-            const params    = request.params ?? []
+            const params    = alignHandlerParams(request.params ?? [], callback)
             const sender    = request.sender
             const receiver  = request.receiver
 
@@ -603,9 +603,14 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
         /*  ensure stream gets destroyed on abort  */
         if (data instanceof Readable) {
             const stream = data
+            const noopError = () => {} /*  prevent unhandled error exception  */
             abortSignal.addEventListener("abort", () => {
-                if (!stream.destroyed)
+                if (!stream.destroyed) {
+                    /*  guard the caller's stream, as it still carries no "error"
+                        listener when the abort precedes the chunk sending phase  */
+                    stream.on("error", noopError)
                     stream.destroy(ensureError(abortSignal.reason))
+                }
             }, { once: true })
         }
 
@@ -645,20 +650,25 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
         })
         pushFinalize.catch(() => {})  /*  avoid unhandled promise rejection  */
 
+        /*  abort the push and settle the pending initial/finalize promises  */
+        const failPush = (error: Error) => {
+            abortController.abort(error)
+            if (!pushAcked) {
+                pushInitialSettled = true
+                pushInitialReject(error)
+            }
+            else if (!pushFinalized) {
+                pushFinalized = true
+                pushFinalizeReject(error)
+            }
+        }
+
         /*  lock the responder for this communication  */
         const lockResponder = (kind: string, sender?: string): boolean => {
             if (sender === undefined || sender === "") {
                 const error = new Error(`received ${kind} without sender`)
                 remoteErrorObject = error
-                abortController.abort(error)
-                if (!pushAcked) {
-                    pushInitialSettled = true
-                    pushInitialReject(error)
-                }
-                else if (!pushFinalized) {
-                    pushFinalized = true
-                    pushFinalizeReject(error)
-                }
+                failPush(error)
                 return false
             }
             if (responderId === undefined)
@@ -680,15 +690,7 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
             if (response.name !== name) {
                 const error = new Error(`sink response name mismatch (expected "${name}", got "${response.name}")`)
                 remoteErrorObject = error
-                abortController.abort(error)
-                if (!pushAcked) {
-                    pushInitialSettled = true
-                    pushInitialReject(error)
-                }
-                else if (!pushFinalized) {
-                    pushFinalized = true
-                    pushFinalizeReject(error)
-                }
+                failPush(error)
                 return
             }
             if (!lockResponder("sink response", response.sender))
@@ -696,15 +698,7 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
             if (response.error) {
                 const error = new Error(response.error)
                 remoteErrorObject = error
-                abortController.abort(error)
-                if (!pushAcked) {
-                    pushInitialSettled = true
-                    pushInitialReject(error)
-                }
-                else if (!pushFinalized) {
-                    pushFinalized = true
-                    pushFinalizeReject(error)
-                }
+                failPush(error)
             }
             else if (!pushAcked) {
                 initialCredit = response.credit
@@ -730,15 +724,7 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
             if (response.name !== name) {
                 const error = new Error(`sink credit name mismatch (expected "${name}", got "${response.name}")`)
                 remoteErrorObject = error
-                abortController.abort(error)
-                if (!pushAcked) {
-                    pushInitialSettled = true
-                    pushInitialReject(error)
-                }
-                else if (!pushFinalized) {
-                    pushFinalized = true
-                    pushFinalizeReject(error)
-                }
+                failPush(error)
                 return
             }
             if (!lockResponder("sink credit", response.sender))
@@ -747,15 +733,7 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
                 /*  cancel signal from receiver  */
                 cancelledByReceiver = true
                 const error = new Error(`push to sink "${name}" cancelled by receiver`)
-                abortController.abort(error)
-                if (!pushAcked) {
-                    pushInitialSettled = true
-                    pushInitialReject(error)
-                }
-                else if (!pushFinalized) {
-                    pushFinalized = true
-                    pushFinalizeReject(error)
-                }
+                failPush(error)
                 return
             }
             if (creditGate !== undefined) {
@@ -767,11 +745,7 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
                     not granting initial credit during ack  */
                 const error = new Error(`push to sink "${name}" received unsolicited credit (credit-flow disabled)`)
                 remoteErrorObject = error
-                abortController.abort(error)
-                if (!pushFinalized) {
-                    pushFinalized = true
-                    pushFinalizeReject(error)
-                }
+                failPush(error)
             }
             else
                 pendingCredit += response.credit
@@ -897,7 +871,7 @@ export class SinkTrait<T extends APISchema = APISchema> extends SourceTrait<T> {
                 response from the receiver to be processed, making the
                 error outcome deterministic (only when race is possible)  */
             if (pushAcked && !remoteErrorObject)
-                await new Promise<void>((resolve) => { setImmediate(resolve) })
+                await new Promise<void>((resolve) => { setTimeout(resolve, 0) })
 
             if (remoteErrorObject)
                 throw remoteErrorObject

package/src/mqtt-plus-source.ts

@@ -33,7 +33,7 @@ import { nanoid }                                         from "nanoid"
 /*  internal requirements  */
 import { CreditGate, ReadableTee,
     sendBufferAsChunks, sendStreamAsChunks,
-    makeMutuallyExclusiveFields }                         from "./mqtt-plus-util"
+    makeMutuallyExclusiveFields, alignHandlerParams }     from "./mqtt-plus-util"
 import { run, Spool, ensureError }                        from "./mqtt-plus-error"
 import type { SourceFetchRequest, SourceFetchResponse,
     SourceFetchChunk, SourceFetchCredit }                 from "./mqtt-plus-msg"
@@ -143,7 +143,7 @@ export class SourceTrait<T extends APISchema = APISchema> extends ServiceTrait<T
 
             /*  determine information  */
             const requestId = request.id
-            const params    = request.params ?? []
+            const params    = alignHandlerParams(request.params ?? [], callback)
             const sender    = request.sender
             const receiver  = request.receiver
 
@@ -211,16 +211,20 @@ export class SourceTrait<T extends APISchema = APISchema> extends ServiceTrait<T
             })
 
             /*  ensure stream gets destroyed on abort  */
-            abortSignal.addEventListener("abort", () => {
-                if (info.stream instanceof Readable && !info.stream.destroyed)
+            const noopError = () => {} /*  prevent unhandled error exception  */
+            const destroyStream = () => {
+                if (info.stream instanceof Readable && !info.stream.destroyed) {
+                    /*  guard the handler's stream, as it still carries no "error"
+                        listener when the abort precedes the chunk sending phase  */
+                    info.stream.on("error", noopError)
                     info.stream.destroy(ensureError(abortSignal.reason))
-            }, { once: true })
+                }
+            }
+            abortSignal.addEventListener("abort", destroyStream, { once: true })
             /*  safety net: destroy a stream assigned after the abort event fired  */
             reqSpool.roll(() => {
-                if (abortSignal.aborted
-                    && info.stream instanceof Readable
-                    && !info.stream.destroyed)
-                    info.stream.destroy(ensureError(abortSignal.reason))
+                if (abortSignal.aborted)
+                    destroyStream()
             })
             let abortReject!: (reason?: any) => void
             const abortPromise = new Promise<never>((_resolve, reject) => {