mqtt-plus 1.4.13 → 1.4.15

package/dst-stage2/mqtt-plus.esm.js

@@ -9,2168 +9,1971 @@ import * as sha256 from "@stablelib/sha256";
 import { EventEmitter } from "node:events";
 import * as v from "valibot";
 import * as CBOR from "cbor2";
-const PLazy = PLazyAPI.default ?? PLazyAPI;
-class CreditGate {
-  /*  initialization  */
-  constructor(initialCredit) {
-    this.waiters = [];
-    this.aborted = false;
-    this.remaining = initialCredit;
-  }
-  /*  acquire one unit of credit (wait if exhausted)  */
-  async acquire(abortSignal) {
-    if (this.aborted)
-      throw new Error("credit gate aborted");
-    if (abortSignal?.aborted)
-      throw abortSignal.reason ?? new Error("aborted");
-    if (this.remaining > 0)
-      this.remaining--;
-    else
-      await new Promise((resolve, reject) => {
-        const onAbort = () => {
-          const idx = this.waiters.indexOf(waiter);
-          if (idx !== -1)
-            this.waiters.splice(idx, 1);
-          reject(abortSignal?.reason ?? new Error("aborted"));
-        };
-        if (abortSignal)
-          abortSignal.addEventListener("abort", onAbort, { once: true });
-        const waiter = (aborted) => {
-          if (abortSignal)
-            abortSignal.removeEventListener("abort", onAbort);
-          if (aborted) {
-            reject(new Error("credit gate aborted"));
-            return;
-          }
-          this.remaining--;
-          resolve();
-        };
-        this.waiters.push(waiter);
-      });
-  }
-  /*  replenish credit (called when credit message received)  */
-  replenish(amount) {
-    this.remaining += amount;
-    while (this.waiters.length > 0 && this.remaining > 0)
-      this.waiters.shift()(false);
-  }
-  /*  release any waiting producer (for cleanup on error/abort)  */
-  abort() {
-    this.aborted = true;
-    while (this.waiters.length > 0)
-      this.waiters.shift()(true);
-  }
-}
-const textEncoder$1 = new TextEncoder();
+//#region dst-stage1/mqtt-plus-util.js
+var PLazy = PLazyAPI.default ?? PLazyAPI;
+var CreditGate = class {
+	constructor(initialCredit) {
+		this.waiters = [];
+		this.aborted = false;
+		this.remaining = initialCredit;
+	}
+	async acquire(abortSignal) {
+		if (this.aborted) throw new Error("credit gate aborted");
+		if (abortSignal?.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("aborted");
+		if (this.remaining > 0) this.remaining--;
+		else await new Promise((resolve, reject) => {
+			const onAbort = () => {
+				const idx = this.waiters.indexOf(waiter);
+				if (idx !== -1) this.waiters.splice(idx, 1);
+				reject(abortSignal?.reason ?? /* @__PURE__ */ new Error("aborted"));
+			};
+			if (abortSignal) abortSignal.addEventListener("abort", onAbort, { once: true });
+			const waiter = (aborted) => {
+				if (abortSignal) abortSignal.removeEventListener("abort", onAbort);
+				if (aborted) {
+					reject(/* @__PURE__ */ new Error("credit gate aborted"));
+					return;
+				}
+				this.remaining--;
+				resolve();
+			};
+			this.waiters.push(waiter);
+		});
+	}
+	replenish(amount) {
+		this.remaining += amount;
+		while (this.waiters.length > 0 && this.remaining > 0) this.waiters.shift()(false);
+	}
+	abort() {
+		this.aborted = true;
+		while (this.waiters.length > 0) this.waiters.shift()(true);
+	}
+};
+var textEncoder$1 = new TextEncoder();
 function uint8ArrayConcat(arrays) {
-  const totalLength = arrays.reduce((acc, value) => acc + value.byteLength, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const a of arrays) {
-    result.set(a, offset);
-    offset += a.byteLength;
-  }
-  return result;
+	const totalLength = arrays.reduce((acc, value) => acc + value.byteLength, 0);
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const a of arrays) {
+		result.set(a, offset);
+		offset += a.byteLength;
+	}
+	return result;
 }
 function chunkToBuffer(chunk) {
-  let buffer;
-  if (chunk instanceof Buffer$1)
-    buffer = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-  else if (chunk instanceof Uint8Array)
-    buffer = chunk;
-  else if (typeof chunk === "string")
-    buffer = textEncoder$1.encode(chunk);
-  else
-    throw new Error("invalid chunk type: expected Buffer, Uint8Array, or string");
-  return buffer;
+	let buffer;
+	if (chunk instanceof Buffer$1) buffer = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+	else if (chunk instanceof Uint8Array) buffer = chunk;
+	else if (typeof chunk === "string") buffer = textEncoder$1.encode(chunk);
+	else throw new Error("invalid chunk type: expected Buffer, Uint8Array, or string");
+	return buffer;
 }
 function streamToBuffer(stream) {
-  return new PLazy((resolve, reject) => {
-    const chunks = [];
-    stream.on("data", (raw) => {
-      const data = chunkToBuffer(raw);
-      chunks.push(data);
-    });
-    stream.on("end", () => {
-      resolve(uint8ArrayConcat(chunks));
-    });
-    stream.on("error", (err) => {
-      reject(err);
-    });
-  });
+	return new PLazy((resolve, reject) => {
+		const chunks = [];
+		stream.on("data", (raw) => {
+			const data = chunkToBuffer(raw);
+			chunks.push(data);
+		});
+		stream.on("end", () => {
+			resolve(uint8ArrayConcat(chunks));
+		});
+		stream.on("error", (err) => {
+			reject(err);
+		});
+	});
 }
 async function sendBufferAsChunks(buffer, chunkSize, sendChunk, creditGate, abortSignal) {
-  if (buffer.byteLength === 0)
-    await sendChunk(void 0, void 0, true);
-  else {
-    for (let i = 0; i < buffer.byteLength; i += chunkSize) {
-      if (abortSignal?.aborted)
-        throw abortSignal.reason ?? new Error("aborted");
-      const size = Math.min(buffer.byteLength - i, chunkSize);
-      const chunk = buffer.subarray(i, i + size);
-      const final = i + size >= buffer.byteLength;
-      if (creditGate)
-        await creditGate.acquire(abortSignal);
-      await sendChunk(chunk, void 0, final);
-    }
-  }
+	if (buffer.byteLength === 0) await sendChunk(void 0, void 0, true);
+	else for (let i = 0; i < buffer.byteLength; i += chunkSize) {
+		if (abortSignal?.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("aborted");
+		const size = Math.min(buffer.byteLength - i, chunkSize);
+		const chunk = buffer.subarray(i, i + size);
+		const final = i + size >= buffer.byteLength;
+		if (creditGate) await creditGate.acquire(abortSignal);
+		await sendChunk(chunk, void 0, final);
+	}
 }
 async function sendStreamAsChunks(readable, chunkSize, sendChunk, creditGate, abortSignal) {
-  let pending;
-  for await (const raw of readable) {
-    if (abortSignal?.aborted)
-      throw abortSignal.reason ?? new Error("aborted");
-    const buffer = chunkToBuffer(raw);
-    if (buffer.byteLength === 0)
-      continue;
-    for (let i = 0; i < buffer.byteLength; i += chunkSize) {
-      if (abortSignal?.aborted)
-        throw abortSignal.reason ?? new Error("aborted");
-      const size = Math.min(buffer.byteLength - i, chunkSize);
-      const chunk = buffer.subarray(i, i + size);
-      if (pending !== void 0) {
-        if (creditGate)
-          await creditGate.acquire(abortSignal);
-        await sendChunk(pending, void 0, false);
-      }
-      pending = chunk;
-    }
-  }
-  if (abortSignal?.aborted)
-    throw abortSignal.reason ?? new Error("aborted");
-  if (pending !== void 0) {
-    if (creditGate)
-      await creditGate.acquire(abortSignal);
-    await sendChunk(pending, void 0, true);
-  } else
-    await sendChunk(void 0, void 0, true);
+	let pending;
+	for await (const raw of readable) {
+		if (abortSignal?.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("aborted");
+		const buffer = chunkToBuffer(raw);
+		if (buffer.byteLength === 0) continue;
+		for (let i = 0; i < buffer.byteLength; i += chunkSize) {
+			if (abortSignal?.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("aborted");
+			const size = Math.min(buffer.byteLength - i, chunkSize);
+			const chunk = buffer.subarray(i, i + size);
+			if (pending !== void 0) {
+				if (creditGate) await creditGate.acquire(abortSignal);
+				await sendChunk(pending, void 0, false);
+			}
+			pending = chunk;
+		}
+	}
+	if (abortSignal?.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("aborted");
+	if (pending !== void 0) {
+		if (creditGate) await creditGate.acquire(abortSignal);
+		await sendChunk(pending, void 0, true);
+	} else await sendChunk(void 0, void 0, true);
 }
 function makeMutuallyExclusiveFields(obj, f1Name, f2Name) {
-  if (!(typeof obj === "object" && obj !== null))
-    throw new Error("invalid object");
-  let consumed;
-  const f1Value = obj[f1Name];
-  const f2Value = obj[f2Name];
-  Object.defineProperty(obj, f1Name, {
-    get: () => {
-      if (consumed === "f2")
-        throw new Error(`field "${f1Name}" is mutually exclusive with field "${f2Name}" and "${f2Name}" was already consumed`);
-      consumed = "f1";
-      return f1Value;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  Object.defineProperty(obj, f2Name, {
-    get: () => {
-      if (consumed === "f1")
-        throw new Error(`field "${f2Name}" is mutually exclusive with field "${f1Name}" and "${f1Name}" was already consumed`);
-      consumed = "f2";
-      return f2Value;
-    },
-    enumerable: true,
-    configurable: true
-  });
-}
-class Spool {
-  constructor() {
-    this.resources = [];
-  }
-  roll(...args) {
-    let resource;
-    let cleanup;
-    if (args.length === 1) {
-      resource = void 0;
-      cleanup = args[0];
-    } else if (args.length === 2) {
-      resource = args[0];
-      cleanup = args[1];
-    } else
-      throw new Error("invalid number of arguments");
-    this.resources.push({ resource, cleanup });
-  }
-  /*  roll a sub-spool onto spool  */
-  sub() {
-    const spool = new Spool();
-    this.roll(spool, () => {
-    });
-    return spool;
-  }
-  /*  unroll all cleanup procedures from spool  */
-  unroll(suppress = true) {
-    try {
-      let promise;
-      while (this.resources.length > 0) {
-        const entry = this.resources.pop();
-        const resource = entry.resource;
-        const cleanup = entry.cleanup;
-        if (promise) {
-          if (resource instanceof Spool)
-            promise = promise.then(
-              () => resource.unroll()
-              /* RECURSION */
-            );
-          else
-            promise = promise.then(() => cleanup(resource));
-        } else {
-          let result;
-          if (resource instanceof Spool)
-            result = resource.unroll();
-          else
-            result = cleanup(resource);
-          if (result instanceof Promise)
-            promise = result;
-        }
-      }
-      if (promise)
-        return suppress ? promise.catch(() => {
-        }) : promise;
-      else
-        return;
-    } catch (error) {
-      if (suppress)
-        return;
-      throw error;
-    }
-  }
+	if (!(typeof obj === "object" && obj !== null)) throw new Error("invalid object");
+	let consumed;
+	const f1Value = obj[f1Name];
+	const f2Value = obj[f2Name];
+	Object.defineProperty(obj, f1Name, {
+		get: () => {
+			if (consumed === "f2") throw new Error(`field "${f1Name}" is mutually exclusive with field "${f2Name}" and "${f2Name}" was already consumed`);
+			consumed = "f1";
+			return f1Value;
+		},
+		enumerable: true,
+		configurable: true
+	});
+	Object.defineProperty(obj, f2Name, {
+		get: () => {
+			if (consumed === "f1") throw new Error(`field "${f2Name}" is mutually exclusive with field "${f1Name}" and "${f1Name}" was already consumed`);
+			consumed = "f2";
+			return f2Value;
+		},
+		enumerable: true,
+		configurable: true
+	});
 }
+//#endregion
+//#region dst-stage1/mqtt-plus-error.js
+var Spool = class Spool {
+	constructor() {
+		this.resources = [];
+	}
+	roll(...args) {
+		let resource;
+		let cleanup;
+		if (args.length === 1) {
+			resource = void 0;
+			cleanup = args[0];
+		} else if (args.length === 2) {
+			resource = args[0];
+			cleanup = args[1];
+		} else throw new Error("invalid number of arguments");
+		this.resources.push({
+			resource,
+			cleanup
+		});
+	}
+	sub() {
+		const spool = new Spool();
+		this.roll(spool, () => {});
+		return spool;
+	}
+	unroll(suppress = true) {
+		try {
+			let promise;
+			while (this.resources.length > 0) {
+				const entry = this.resources.pop();
+				const resource = entry.resource;
+				const cleanup = entry.cleanup;
+				if (promise) if (resource instanceof Spool) promise = promise.then(() => resource.unroll());
+				else promise = promise.then(() => cleanup(resource));
+				else {
+					let result;
+					if (resource instanceof Spool) result = resource.unroll();
+					else result = cleanup(resource);
+					if (result instanceof Promise) promise = result;
+				}
+			}
+			if (promise) return suppress ? promise.catch(() => {}) : promise;
+			else return;
+		} catch (error) {
+			if (suppress) return;
+			throw error;
+		}
+	}
+};
 function ensureError(error, prefix, debug = false) {
-  if (error instanceof Error && prefix === void 0 && debug === false)
-    return error;
-  let msg = error instanceof Error ? error.message : String(error);
-  if (prefix)
-    msg = `${prefix}: ${msg}`;
-  if (debug && error instanceof Error)
-    msg = `${msg}
-${error.stack}`;
-  if (error instanceof Error) {
-    const err = new Error(msg, { cause: error });
-    err.stack = error.stack;
-    return err;
-  } else
-    return new Error(msg);
+	if (error instanceof Error && prefix === void 0 && debug === false) return error;
+	let msg = error instanceof Error ? error.message : String(error);
+	if (prefix) msg = `${prefix}: ${msg}`;
+	if (debug && error instanceof Error) msg = `${msg}\n${error.stack}`;
+	if (error instanceof Error) {
+		const err = new Error(msg, { cause: error });
+		err.stack = error.stack;
+		return err;
+	} else return new Error(msg);
 }
 function runFinally(isAsync, onfinally) {
-  if (!onfinally) {
-    if (isAsync)
-      return Promise.resolve();
-    else
-      return;
-  }
-  let result;
-  try {
-    result = onfinally();
-  } catch (error) {
-    if (isAsync)
-      return Promise.reject(error);
-    else
-      throw error;
-  }
-  if (!isAsync && result instanceof Promise)
-    throw new Error("onfinally callback returned Promise in non-async context");
-  if (isAsync && !(result instanceof Promise))
-    result = Promise.resolve(result);
-  return result;
+	if (!onfinally) if (isAsync) return Promise.resolve();
+	else return;
+	let result;
+	try {
+		result = onfinally();
+	} catch (error) {
+		if (isAsync) return Promise.reject(error);
+		else throw error;
+	}
+	if (!isAsync && result instanceof Promise) throw new Error("onfinally callback returned Promise in non-async context");
+	if (isAsync && !(result instanceof Promise)) result = Promise.resolve(result);
+	return result;
 }
 function runUnroll(isAsync, spool) {
-  if (!spool) {
-    if (isAsync)
-      return Promise.resolve();
-    else
-      return;
-  }
-  let result = spool.unroll();
-  if (!isAsync && result instanceof Promise)
-    throw new Error("spool unroll returned Promise in non-async context");
-  if (isAsync && !(result instanceof Promise))
-    result = Promise.resolve(result);
-  return result;
+	if (!spool) if (isAsync) return Promise.resolve();
+	else return;
+	let result = spool.unroll();
+	if (!isAsync && result instanceof Promise) throw new Error("spool unroll returned Promise in non-async context");
+	if (isAsync && !(result instanceof Promise)) result = Promise.resolve(result);
+	return result;
 }
 function run(...args) {
-  let description;
-  let spool;
-  let action;
-  let oncatch;
-  let onfinally;
-  let oncleanup;
-  if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
-    description = args[0].description;
-    spool = args[0].spool;
-    action = args[0].action;
-    oncatch = args[0].oncatch;
-    onfinally = args[0].onfinally;
-    oncleanup = args[0].oncleanup;
-  } else if (typeof args[0] === "string") {
-    description = args[0];
-    if (args[1] instanceof Spool || args[1] === void 0 && typeof args[2] === "function") {
-      spool = args[1];
-      action = args[2];
-      oncatch = args[3];
-      onfinally = args[4];
-      oncleanup = args[5];
-    } else {
-      action = args[1];
-      oncatch = args[2];
-      onfinally = args[3];
-      oncleanup = args[4];
-    }
-  } else {
-    if (args[0] instanceof Spool || args[0] === void 0 && typeof args[1] === "function") {
-      spool = args[0];
-      action = args[1];
-      oncatch = args[2];
-      onfinally = args[3];
-      oncleanup = args[4];
-    } else {
-      action = args[0];
-      oncatch = args[1];
-      onfinally = args[2];
-      oncleanup = args[3];
-    }
-  }
-  if (oncleanup && !spool)
-    throw new Error("oncleanup requires a spool");
-  let result;
-  try {
-    result = action();
-  } catch (arg) {
-    let error = ensureError(arg, description);
-    if (oncatch) {
-      try {
-        result = oncatch(error);
-      } catch (arg2) {
-        error = ensureError(arg2, description);
-        runFinally(false, onfinally);
-        runUnroll(false, spool);
-        throw error;
-      }
-      runFinally(false, onfinally);
-      return result;
-    }
-    runFinally(false, onfinally);
-    runUnroll(false, spool);
-    throw error;
-  }
-  if (result instanceof Promise) {
-    return result.then(async (result2) => {
-      await runFinally(true, onfinally);
-      if (spool && oncleanup)
-        spool.roll(result2, oncleanup);
-      return result2;
-    }, async (arg) => {
-      let error = ensureError(arg, description);
-      if (oncatch) {
-        try {
-          const result2 = oncatch(error);
-          await runFinally(true, onfinally);
-          return result2;
-        } catch (arg2) {
-          error = ensureError(arg2, description);
-          await runFinally(true, onfinally);
-          await runUnroll(true, spool);
-          throw error;
-        }
-      }
-      await runFinally(true, onfinally);
-      await runUnroll(true, spool);
-      throw error;
-    });
-  } else {
-    runFinally(false, onfinally);
-    if (spool && oncleanup)
-      spool.roll(result, oncleanup);
-    return result;
-  }
-}
-class OptionsTrait {
-  /*  construct API class  */
-  constructor(options = {}) {
-    this.options = {
-      id: nanoid(),
-      codec: "cbor",
-      timeout: 10 * 1e3,
-      share: "",
-      chunkSize: 16 * 1024,
-      chunkCredit: 4,
-      topicMake: (name, operation, peerId) => {
-        return `${name}/${operation}/${peerId ?? "any"}`;
-      },
-      topicMatch: (topic) => {
-        const m = topic.match(/^(.+)\/([^/]+)\/([^/]+)$/);
-        return m ? {
-          name: m[1],
-          operation: m[2],
-          peerId: m[3] === "any" ? void 0 : m[3]
-        } : null;
-      },
-      ...options
-    };
-  }
-}
-class JSONX {
-  static uint8ArrayToBase64(arr) {
-    return Buffer$1.from(arr.buffer, arr.byteOffset, arr.byteLength).toString("base64");
-  }
-  static base64ToUint8Array(base64) {
-    return new Uint8Array(Buffer$1.from(base64, "base64"));
-  }
-  static stringify(obj) {
-    return JSON.stringify(obj, (_, value) => value instanceof Uint8Array ? { __Uint8Array: this.uint8ArrayToBase64(value) } : value);
-  }
-  static parse(json) {
-    return JSON.parse(json, (_, value) => typeof value?.__Uint8Array === "string" ? this.base64ToUint8Array(value.__Uint8Array) : value);
-  }
-}
-class Codec {
-  constructor(format) {
-    this.format = format;
-    this.types = new CBOR.TypeEncoderMap();
-    this.tags = /* @__PURE__ */ new Map();
-    const TAG_BUFFER = 64e3;
-    this.types.registerEncoder(Buffer$1, (buffer) => {
-      return [TAG_BUFFER, new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)];
-    });
-    this.tags.set(TAG_BUFFER, (tag) => {
-      return Buffer$1.from(tag.contents);
-    });
-  }
-  encode(data) {
-    let result;
-    if (this.format === "cbor") {
-      try {
-        result = CBOR.encode(data, { types: this.types });
-      } catch (err) {
-        throw new Error("failed to encode CBOR format", { cause: err });
-      }
-    } else if (this.format === "json") {
-      try {
-        result = JSONX.stringify(data);
-      } catch (err) {
-        throw new Error("failed to encode JSON format", { cause: err });
-      }
-    } else
-      throw new Error(`invalid format "${this.format}"`);
-    return result;
-  }
-  decode(data) {
-    let result;
-    if (this.format === "cbor") {
-      if (!(data instanceof Uint8Array))
-        throw new Error("failed to decode CBOR format (data type is not Uint8Array)");
-      if (data.byteLength === 0)
-        throw new Error("failed to decode CBOR format (data is empty)");
-      try {
-        result = CBOR.decode(data, { tags: this.tags });
-      } catch (err) {
-        throw new Error("failed to decode CBOR format", { cause: err });
-      }
-    } else if (this.format === "json") {
-      if (typeof data !== "string")
-        throw new Error("failed to decode JSON format (data type is not string)");
-      if (data.length === 0)
-        throw new Error("failed to decode JSON format (data is empty)");
-      try {
-        result = JSONX.parse(data);
-      } catch (err) {
-        throw new Error("failed to decode JSON format", { cause: err });
-      }
-    } else
-      throw new Error(`invalid format "${this.format}"`);
-    return result;
-  }
-}
-class CodecTrait extends OptionsTrait {
-  /*  construct API class  */
-  constructor(options = {}) {
-    super(options);
-    this.codec = new Codec(this.options.codec);
-  }
-}
-class EncodeTrait extends CodecTrait {
-  static {
-    this.encoder = new TextEncoder();
-  }
-  static {
-    this.decoder = new TextDecoder();
-  }
-  /*  convert character string to buffer  */
-  str2buf(data) {
-    return EncodeTrait.encoder.encode(data);
-  }
-  /*  convert buffer to character string  */
-  buf2str(data) {
-    return EncodeTrait.decoder.decode(data);
-  }
-  /*  convert byte-based typed array to buffer  */
-  arr2buf(data) {
-    let buffer;
-    if (data instanceof Uint8Array)
-      buffer = data;
-    else
-      buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    return buffer;
-  }
-  buf2arr(data, cons) {
-    let arr;
-    const ctor = cons;
-    if (ctor === Buffer$1)
-      arr = Buffer$1.from(data.buffer, data.byteOffset, data.byteLength);
-    else if (ctor === Uint8Array)
-      arr = data;
-    else if (ctor === Int8Array)
-      arr = new Int8Array(data.buffer, data.byteOffset, data.byteLength);
-    else
-      throw new Error("invalid data type");
-    return arr;
-  }
+	let description;
+	let spool;
+	let action;
+	let oncatch;
+	let onfinally;
+	let oncleanup;
+	if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+		description = args[0].description;
+		spool = args[0].spool;
+		action = args[0].action;
+		oncatch = args[0].oncatch;
+		onfinally = args[0].onfinally;
+		oncleanup = args[0].oncleanup;
+	} else if (typeof args[0] === "string") {
+		description = args[0];
+		if (args[1] instanceof Spool || args[1] === void 0 && typeof args[2] === "function") {
+			spool = args[1];
+			action = args[2];
+			oncatch = args[3];
+			onfinally = args[4];
+			oncleanup = args[5];
+		} else {
+			action = args[1];
+			oncatch = args[2];
+			onfinally = args[3];
+			oncleanup = args[4];
+		}
+	} else if (args[0] instanceof Spool || args[0] === void 0 && typeof args[1] === "function") {
+		spool = args[0];
+		action = args[1];
+		oncatch = args[2];
+		onfinally = args[3];
+		oncleanup = args[4];
+	} else {
+		action = args[0];
+		oncatch = args[1];
+		onfinally = args[2];
+		oncleanup = args[3];
+	}
+	if (oncleanup && !spool) throw new Error("oncleanup requires a spool");
+	let result;
+	try {
+		result = action();
+	} catch (arg) {
+		let error = ensureError(arg, description);
+		if (oncatch) {
+			try {
+				result = oncatch(error);
+			} catch (arg) {
+				error = ensureError(arg, description);
+				runFinally(false, onfinally);
+				runUnroll(false, spool);
+				throw error;
+			}
+			runFinally(false, onfinally);
+			return result;
+		}
+		runFinally(false, onfinally);
+		runUnroll(false, spool);
+		throw error;
+	}
+	if (result instanceof Promise) return result.then(async (result) => {
+		await runFinally(true, onfinally);
+		if (spool && oncleanup) spool.roll(result, oncleanup);
+		return result;
+	}, async (arg) => {
+		let error = ensureError(arg, description);
+		if (oncatch) try {
+			const result = oncatch(error);
+			await runFinally(true, onfinally);
+			return result;
+		} catch (arg) {
+			error = ensureError(arg, description);
+			await runFinally(true, onfinally);
+			await runUnroll(true, spool);
+			throw error;
+		}
+		await runFinally(true, onfinally);
+		await runUnroll(true, spool);
+		throw error;
+	});
+	else {
+		runFinally(false, onfinally);
+		if (spool && oncleanup) spool.roll(result, oncleanup);
+		return result;
+	}
 }
-const versionToNum = (str) => {
-  const m = str.match(/^(\d+)\.(\d+)$/);
-  if (m === null)
-    throw new Error("invalid version string");
-  const minor = parseInt(m[2], 10);
-  if (minor > 99)
-    throw new Error("invalid version string: minor version exceeds 99");
-  return parseInt(m[1], 10) * 100 + minor;
+//#endregion
+//#region dst-stage1/mqtt-plus-options.js
+var OptionsTrait = class {
+	constructor(options = {}) {
+		this.options = {
+			id: nanoid(),
+			codec: "cbor",
+			timeout: 10 * 1e3,
+			share: "",
+			chunkSize: 16 * 1024,
+			chunkCredit: 4,
+			topicMake: (name, operation, peerId) => {
+				return `${name}/${operation}/${peerId ?? "any"}`;
+			},
+			topicMatch: (topic) => {
+				const m = topic.match(/^(.+)\/([^/]+)\/([^/]+)$/);
+				return m ? {
+					name: m[1],
+					operation: m[2],
+					peerId: m[3] === "any" ? void 0 : m[3]
+				} : null;
+			},
+			...options
+		};
+	}
 };
-const VERSION = "1.4";
-const version = versionToNum(VERSION);
-const MetaSchema = v.pipe(v.record(v.string(), v.unknown()), v.check((data) => !Array.isArray(data)));
-const AuthSchema = v.pipe(v.array(v.pipe(v.string(), v.maxLength(8192))), v.maxLength(8));
-class Base {
-  constructor(type, id, sender, receiver) {
-    this.type = type;
-    this.id = id;
-    this.sender = sender;
-    this.receiver = receiver;
-    this.version = `MQTT+/${VERSION}`;
-  }
-}
-const BaseSchema = {
-  version: v.pipe(v.string(), v.regex(/^MQTT\+\/\d+\.\d+$/)),
-  type: v.string(),
-  id: v.string(),
-  sender: v.optional(v.string()),
-  receiver: v.optional(v.string())
+//#endregion
+//#region dst-stage1/mqtt-plus-codec.js
+var JSONX = class {
+	static uint8ArrayToBase64(arr) {
+		return Buffer$1.from(arr.buffer, arr.byteOffset, arr.byteLength).toString("base64");
+	}
+	static base64ToUint8Array(base64) {
+		return new Uint8Array(Buffer$1.from(base64, "base64"));
+	}
+	static stringify(obj) {
+		return JSON.stringify(obj, (_, value) => value instanceof Uint8Array ? { __Uint8Array: this.uint8ArrayToBase64(value) } : value);
+	}
+	static parse(json) {
+		return JSON.parse(json, (_, value) => typeof value?.__Uint8Array === "string" ? this.base64ToUint8Array(value.__Uint8Array) : value);
+	}
 };
-class EventEmission extends Base {
-  constructor(id, name, params, sender, receiver, auth, meta) {
-    super("event-emission", id, sender, receiver);
-    this.name = name;
-    this.params = params;
-    this.auth = auth;
-    this.meta = meta;
-  }
-}
-const EventEmissionSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("event-emission"),
-  name: v.string(),
-  params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
-  auth: v.optional(AuthSchema),
-  meta: v.optional(MetaSchema)
+var Codec = class {
+	constructor(format) {
+		this.format = format;
+		this.types = new CBOR.TypeEncoderMap();
+		this.tags = /* @__PURE__ */ new Map();
+		const TAG_BUFFER = 64e3;
+		this.types.registerEncoder(Buffer$1, (buffer) => {
+			return [TAG_BUFFER, new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)];
+		});
+		this.tags.set(TAG_BUFFER, (tag) => {
+			return Buffer$1.from(tag.contents);
+		});
+	}
+	encode(data) {
+		let result;
+		if (this.format === "cbor") try {
+			result = CBOR.encode(data, { types: this.types });
+		} catch (err) {
+			throw new Error("failed to encode CBOR format", { cause: err });
+		}
+		else if (this.format === "json") try {
+			result = JSONX.stringify(data);
+		} catch (err) {
+			throw new Error("failed to encode JSON format", { cause: err });
+		}
+		else throw new Error(`invalid format "${this.format}"`);
+		return result;
+	}
+	decode(data) {
+		let result;
+		if (this.format === "cbor") {
+			if (!(data instanceof Uint8Array)) throw new Error("failed to decode CBOR format (data type is not Uint8Array)");
+			if (data.byteLength === 0) throw new Error("failed to decode CBOR format (data is empty)");
+			try {
+				result = CBOR.decode(data, { tags: this.tags });
+			} catch (err) {
+				throw new Error("failed to decode CBOR format", { cause: err });
+			}
+		} else if (this.format === "json") {
+			if (typeof data !== "string") throw new Error("failed to decode JSON format (data type is not string)");
+			if (data.length === 0) throw new Error("failed to decode JSON format (data is empty)");
+			try {
+				result = JSONX.parse(data);
+			} catch (err) {
+				throw new Error("failed to decode JSON format", { cause: err });
+			}
+		} else throw new Error(`invalid format "${this.format}"`);
+		return result;
+	}
+};
+var CodecTrait = class extends OptionsTrait {
+	constructor(options = {}) {
+		super(options);
+		this.codec = new Codec(this.options.codec);
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-encode.js
+var EncodeTrait = class EncodeTrait extends CodecTrait {
+	static {
+		this.encoder = new TextEncoder();
+	}
+	static {
+		this.decoder = new TextDecoder();
+	}
+	str2buf(data) {
+		return EncodeTrait.encoder.encode(data);
+	}
+	buf2str(data) {
+		return EncodeTrait.decoder.decode(data);
+	}
+	arr2buf(data) {
+		let buffer;
+		if (data instanceof Uint8Array) buffer = data;
+		else buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		return buffer;
+	}
+	buf2arr(data, cons) {
+		let arr;
+		const ctor = cons;
+		if (ctor === Buffer$1) arr = Buffer$1.from(data.buffer, data.byteOffset, data.byteLength);
+		else if (ctor === Uint8Array) arr = data;
+		else if (ctor === Int8Array) arr = new Int8Array(data.buffer, data.byteOffset, data.byteLength);
+		else throw new Error("invalid data type");
+		return arr;
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-version.js
+var versionToNum = (str) => {
+	const m = str.match(/^(\d+)\.(\d+)$/);
+	if (m === null) throw new Error("invalid version string");
+	const minor = parseInt(m[2], 10);
+	if (minor > 99) throw new Error("invalid version string: minor version exceeds 99");
+	return parseInt(m[1], 10) * 100 + minor;
+};
+var version = versionToNum("1.4");
+//#endregion
+//#region dst-stage1/mqtt-plus-msg.js
+var MetaSchema = v.pipe(v.record(v.string(), v.unknown()), v.check((data) => !Array.isArray(data)));
+var AuthSchema = v.pipe(v.array(v.pipe(v.string(), v.maxLength(8192))), v.maxLength(8));
+var Base = class {
+	constructor(type, id, sender, receiver) {
+		this.type = type;
+		this.id = id;
+		this.sender = sender;
+		this.receiver = receiver;
+		this.version = `MQTT+/1.4`;
+	}
+};
+var BaseSchema = {
+	version: v.pipe(v.string(), v.regex(/^MQTT\+\/\d+\.\d+$/)),
+	type: v.string(),
+	id: v.string(),
+	sender: v.optional(v.string()),
+	receiver: v.optional(v.string())
+};
+var EventEmission = class extends Base {
+	constructor(id, name, params, sender, receiver, auth, meta) {
+		super("event-emission", id, sender, receiver);
+		this.name = name;
+		this.params = params;
+		this.auth = auth;
+		this.meta = meta;
+	}
+};
+var EventEmissionSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("event-emission"),
+	name: v.string(),
+	params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
+	auth: v.optional(AuthSchema),
+	meta: v.optional(MetaSchema)
 });
-class ServiceCallRequest extends Base {
-  constructor(id, name, params, sender, receiver, auth, meta) {
-    super("service-call-request", id, sender, receiver);
-    this.name = name;
-    this.params = params;
-    this.auth = auth;
-    this.meta = meta;
-  }
-}
-const ServiceCallRequestSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("service-call-request"),
-  name: v.string(),
-  params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
-  auth: v.optional(AuthSchema),
-  meta: v.optional(MetaSchema)
+var ServiceCallRequest = class extends Base {
+	constructor(id, name, params, sender, receiver, auth, meta) {
+		super("service-call-request", id, sender, receiver);
+		this.name = name;
+		this.params = params;
+		this.auth = auth;
+		this.meta = meta;
+	}
+};
+var ServiceCallRequestSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("service-call-request"),
+	name: v.string(),
+	params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
+	auth: v.optional(AuthSchema),
+	meta: v.optional(MetaSchema)
 });
-class ServiceCallResponse extends Base {
-  constructor(id, result, error, sender, receiver) {
-    super("service-call-response", id, sender, receiver);
-    this.result = result;
-    this.error = error;
-  }
-}
-const ServiceCallResponseSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("service-call-response"),
-  result: v.optional(v.unknown()),
-  error: v.optional(v.string())
+var ServiceCallResponse = class extends Base {
+	constructor(id, result, error, sender, receiver) {
+		super("service-call-response", id, sender, receiver);
+		this.result = result;
+		this.error = error;
+	}
+};
+var ServiceCallResponseSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("service-call-response"),
+	result: v.optional(v.unknown()),
+	error: v.optional(v.string())
 });
-class SinkPushRequest extends Base {
-  constructor(id, name, params, sender, receiver, auth, meta) {
-    super("sink-push-request", id, sender, receiver);
-    this.name = name;
-    this.params = params;
-    this.auth = auth;
-    this.meta = meta;
-  }
-}
-const SinkPushRequestSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("sink-push-request"),
-  name: v.string(),
-  params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
-  auth: v.optional(AuthSchema),
-  meta: v.optional(MetaSchema)
+var SinkPushRequest = class extends Base {
+	constructor(id, name, params, sender, receiver, auth, meta) {
+		super("sink-push-request", id, sender, receiver);
+		this.name = name;
+		this.params = params;
+		this.auth = auth;
+		this.meta = meta;
+	}
+};
+var SinkPushRequestSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("sink-push-request"),
+	name: v.string(),
+	params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
+	auth: v.optional(AuthSchema),
+	meta: v.optional(MetaSchema)
 });
-class SinkPushResponse extends Base {
-  constructor(id, name, error, sender, receiver, credit) {
-    super("sink-push-response", id, sender, receiver);
-    this.name = name;
-    this.error = error;
-    this.credit = credit;
-  }
-}
-const SinkPushResponseSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("sink-push-response"),
-  name: v.string(),
-  error: v.optional(v.string()),
-  credit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
+var SinkPushResponse = class extends Base {
+	constructor(id, name, error, sender, receiver, credit) {
+		super("sink-push-response", id, sender, receiver);
+		this.name = name;
+		this.error = error;
+		this.credit = credit;
+	}
+};
+var SinkPushResponseSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("sink-push-response"),
+	name: v.string(),
+	error: v.optional(v.string()),
+	credit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
 });
-class SinkPushChunk extends Base {
-  constructor(id, name, chunk, error, final, sender, receiver) {
-    super("sink-push-chunk", id, sender, receiver);
-    this.name = name;
-    this.chunk = chunk;
-    this.error = error;
-    this.final = final;
-  }
-}
-const SinkPushChunkSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("sink-push-chunk"),
-  name: v.string(),
-  chunk: v.optional(v.instance(Uint8Array)),
-  error: v.optional(v.string()),
-  final: v.optional(v.boolean())
+var SinkPushChunk = class extends Base {
+	constructor(id, name, chunk, error, final, sender, receiver) {
+		super("sink-push-chunk", id, sender, receiver);
+		this.name = name;
+		this.chunk = chunk;
+		this.error = error;
+		this.final = final;
+	}
+};
+var SinkPushChunkSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("sink-push-chunk"),
+	name: v.string(),
+	chunk: v.optional(v.instance(Uint8Array)),
+	error: v.optional(v.string()),
+	final: v.optional(v.boolean())
 });
-class SinkPushCredit extends Base {
-  constructor(id, name, credit, sender, receiver) {
-    super("sink-push-credit", id, sender, receiver);
-    this.name = name;
-    this.credit = credit;
-  }
-}
-const SinkPushCreditSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("sink-push-credit"),
-  name: v.string(),
-  credit: v.pipe(v.number(), v.integer(), v.minValue(1))
+var SinkPushCredit = class extends Base {
+	constructor(id, name, credit, sender, receiver) {
+		super("sink-push-credit", id, sender, receiver);
+		this.name = name;
+		this.credit = credit;
+	}
+};
+var SinkPushCreditSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("sink-push-credit"),
+	name: v.string(),
+	credit: v.pipe(v.number(), v.integer(), v.minValue(1))
 });
-class SourceFetchRequest extends Base {
-  constructor(id, name, params, sender, receiver, auth, meta, credit) {
-    super("source-fetch-request", id, sender, receiver);
-    this.name = name;
-    this.params = params;
-    this.auth = auth;
-    this.meta = meta;
-    this.credit = credit;
-  }
-}
-const SourceFetchRequestSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("source-fetch-request"),
-  name: v.string(),
-  params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
-  auth: v.optional(AuthSchema),
-  meta: v.optional(MetaSchema),
-  credit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
+var SourceFetchRequest = class extends Base {
+	constructor(id, name, params, sender, receiver, auth, meta, credit) {
+		super("source-fetch-request", id, sender, receiver);
+		this.name = name;
+		this.params = params;
+		this.auth = auth;
+		this.meta = meta;
+		this.credit = credit;
+	}
+};
+var SourceFetchRequestSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("source-fetch-request"),
+	name: v.string(),
+	params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
+	auth: v.optional(AuthSchema),
+	meta: v.optional(MetaSchema),
+	credit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
 });
-class SourceFetchResponse extends Base {
-  constructor(id, name, error, sender, receiver, meta) {
-    super("source-fetch-response", id, sender, receiver);
-    this.name = name;
-    this.error = error;
-    this.meta = meta;
-  }
-}
-const SourceFetchResponseSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("source-fetch-response"),
-  name: v.string(),
-  error: v.optional(v.string()),
-  meta: v.optional(MetaSchema)
+var SourceFetchResponse = class extends Base {
+	constructor(id, name, error, sender, receiver, meta) {
+		super("source-fetch-response", id, sender, receiver);
+		this.name = name;
+		this.error = error;
+		this.meta = meta;
+	}
+};
+var SourceFetchResponseSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("source-fetch-response"),
+	name: v.string(),
+	error: v.optional(v.string()),
+	meta: v.optional(MetaSchema)
 });
-class SourceFetchChunk extends Base {
-  constructor(id, name, chunk, error, final, sender, receiver) {
-    super("source-fetch-chunk", id, sender, receiver);
-    this.name = name;
-    this.chunk = chunk;
-    this.error = error;
-    this.final = final;
-  }
-}
-const SourceFetchChunkSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("source-fetch-chunk"),
-  name: v.string(),
-  chunk: v.optional(v.instance(Uint8Array)),
-  error: v.optional(v.string()),
-  final: v.optional(v.boolean())
+var SourceFetchChunk = class extends Base {
+	constructor(id, name, chunk, error, final, sender, receiver) {
+		super("source-fetch-chunk", id, sender, receiver);
+		this.name = name;
+		this.chunk = chunk;
+		this.error = error;
+		this.final = final;
+	}
+};
+var SourceFetchChunkSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("source-fetch-chunk"),
+	name: v.string(),
+	chunk: v.optional(v.instance(Uint8Array)),
+	error: v.optional(v.string()),
+	final: v.optional(v.boolean())
 });
-class SourceFetchCredit extends Base {
-  constructor(id, name, credit, sender, receiver) {
-    super("source-fetch-credit", id, sender, receiver);
-    this.name = name;
-    this.credit = credit;
-  }
-}
-const SourceFetchCreditSchema = v.strictObject({
-  ...BaseSchema,
-  type: v.literal("source-fetch-credit"),
-  name: v.string(),
-  credit: v.pipe(v.number(), v.integer(), v.minValue(0))
+var SourceFetchCredit = class extends Base {
+	constructor(id, name, credit, sender, receiver) {
+		super("source-fetch-credit", id, sender, receiver);
+		this.name = name;
+		this.credit = credit;
+	}
+};
+var SourceFetchCreditSchema = v.strictObject({
+	...BaseSchema,
+	type: v.literal("source-fetch-credit"),
+	name: v.string(),
+	credit: v.pipe(v.number(), v.integer(), v.minValue(0))
 });
-class Msg {
-  /*  factories for creating objects  */
-  makeEventEmission(id, name, params, sender, receiver, auth, meta) {
-    return new EventEmission(id, name, params, sender, receiver, auth, meta);
-  }
-  makeServiceCallRequest(id, name, params, sender, receiver, auth, meta) {
-    return new ServiceCallRequest(id, name, params, sender, receiver, auth, meta);
-  }
-  makeServiceCallResponse(id, result, error, sender, receiver) {
-    return new ServiceCallResponse(id, result, error, sender, receiver);
-  }
-  makeSinkPushRequest(id, name, params, sender, receiver, auth, meta) {
-    return new SinkPushRequest(id, name, params, sender, receiver, auth, meta);
-  }
-  makeSinkPushResponse(id, name, error, sender, receiver, credit) {
-    return new SinkPushResponse(id, name, error, sender, receiver, credit);
-  }
-  makeSinkPushChunk(id, name, chunk, error, final, sender, receiver) {
-    return new SinkPushChunk(id, name, chunk, error, final, sender, receiver);
-  }
-  makeSinkPushCredit(id, name, credit, sender, receiver) {
-    return new SinkPushCredit(id, name, credit, sender, receiver);
-  }
-  makeSourceFetchRequest(id, name, params, sender, receiver, auth, meta, credit) {
-    return new SourceFetchRequest(id, name, params, sender, receiver, auth, meta, credit);
-  }
-  makeSourceFetchResponse(id, name, error, sender, receiver, meta) {
-    return new SourceFetchResponse(id, name, error, sender, receiver, meta);
-  }
-  makeSourceFetchChunk(id, name, chunk, error, final, sender, receiver) {
-    return new SourceFetchChunk(id, name, chunk, error, final, sender, receiver);
-  }
-  makeSourceFetchCredit(id, name, credit, sender, receiver) {
-    return new SourceFetchCredit(id, name, credit, sender, receiver);
-  }
-  /*  parse any object into typed object  */
-  parse(obj) {
-    if (typeof obj !== "object" || obj === null)
-      throw new Error("invalid argument: not an object");
-    if (typeof obj.version !== "string")
-      throw new Error('invalid object: missing or invalid "version" field');
-    const match = obj.version.match(/^MQTT\+\/(\d+\.\d+)$/);
-    const versionNum = match !== null ? versionToNum(match[1]) : 0;
-    if (versionNum !== version)
-      throw new Error(`protocol version mismatch (expected version ${VERSION}, got version ${obj.version})`);
-    const parseObject = (obj2, name, schema) => {
-      const res = v.safeParse(schema, obj2);
-      if (!res.success) {
-        const issues = res.issues.map((issue) => issue.message).join("; ");
-        throw new Error(`invalid ${name} object: ${issues}`);
-      }
-      return res.output;
-    };
-    if (typeof obj.type !== "string")
-      throw new Error('invalid object: missing or invalid "type" field');
-    if (obj.type === "event-emission") {
-      const out = parseObject(obj, "EventEmission", EventEmissionSchema);
-      return this.makeEventEmission(out.id, out.name, out.params, out.sender, out.receiver, out.auth, out.meta);
-    } else if (obj.type === "service-call-request") {
-      const out = parseObject(obj, "ServiceCallRequest", ServiceCallRequestSchema);
-      return this.makeServiceCallRequest(out.id, out.name, out.params, out.sender, out.receiver, out.auth, out.meta);
-    } else if (obj.type === "service-call-response") {
-      const out = parseObject(obj, "ServiceCallResponse", ServiceCallResponseSchema);
-      return this.makeServiceCallResponse(out.id, out.result, out.error, out.sender, out.receiver);
-    } else if (obj.type === "sink-push-request") {
-      const out = parseObject(obj, "SinkPushRequest", SinkPushRequestSchema);
-      return this.makeSinkPushRequest(out.id, out.name, out.params, out.sender, out.receiver, out.auth, out.meta);
-    } else if (obj.type === "sink-push-response") {
-      const out = parseObject(obj, "SinkPushResponse", SinkPushResponseSchema);
-      return this.makeSinkPushResponse(out.id, out.name, out.error, out.sender, out.receiver, out.credit);
-    } else if (obj.type === "sink-push-chunk") {
-      const out = parseObject(obj, "SinkPushChunk", SinkPushChunkSchema);
-      return this.makeSinkPushChunk(out.id, out.name, out.chunk, out.error, out.final, out.sender, out.receiver);
-    } else if (obj.type === "sink-push-credit") {
-      const out = parseObject(obj, "SinkPushCredit", SinkPushCreditSchema);
-      return this.makeSinkPushCredit(out.id, out.name, out.credit, out.sender, out.receiver);
-    } else if (obj.type === "source-fetch-request") {
-      const out = parseObject(obj, "SourceFetchRequest", SourceFetchRequestSchema);
-      return this.makeSourceFetchRequest(out.id, out.name, out.params, out.sender, out.receiver, out.auth, out.meta, out.credit);
-    } else if (obj.type === "source-fetch-response") {
-      const out = parseObject(obj, "SourceFetchResponse", SourceFetchResponseSchema);
-      return this.makeSourceFetchResponse(out.id, out.name, out.error, out.sender, out.receiver, out.meta);
-    } else if (obj.type === "source-fetch-chunk") {
-      const out = parseObject(obj, "SourceFetchChunk", SourceFetchChunkSchema);
-      return this.makeSourceFetchChunk(out.id, out.name, out.chunk, out.error, out.final, out.sender, out.receiver);
-    } else if (obj.type === "source-fetch-credit") {
-      const out = parseObject(obj, "SourceFetchCredit", SourceFetchCreditSchema);
-      return this.makeSourceFetchCredit(out.id, out.name, out.credit, out.sender, out.receiver);
-    } else
-      throw new Error("invalid object: not of any known type");
-  }
-  /*  guard for request messages  */
-  isRequest(msg) {
-    return msg instanceof EventEmission || msg instanceof ServiceCallRequest || msg instanceof SourceFetchRequest || msg instanceof SinkPushRequest;
-  }
-  /*  guard for response messages  */
-  isResponse(msg) {
-    return msg instanceof ServiceCallResponse || msg instanceof SinkPushResponse || msg instanceof SinkPushChunk || msg instanceof SinkPushCredit || msg instanceof SourceFetchResponse || msg instanceof SourceFetchChunk || msg instanceof SourceFetchCredit;
-  }
-}
-class MsgTrait extends EncodeTrait {
-  constructor() {
-    super(...arguments);
-    this.msg = new Msg();
-  }
-}
-class LogEvent {
-  constructor(timestamp, level, msg, data) {
-    this.timestamp = timestamp;
-    this.level = level;
-    this.msg = msg;
-    this.data = data;
-  }
-  /*  resolve all pending promises in the log event  */
-  async resolve() {
-    if (this.msg instanceof Promise)
-      this.msg = await this.msg.catch(() => "<resolve-failed>");
-    if (this.data) {
-      for (const k of Object.keys(this.data))
-        if (this.data[k] instanceof Promise)
-          this.data[k] = await this.data[k].catch(() => "<resolve-failed>");
-    }
-  }
-  /*  render log event as string  */
-  toString() {
-    const timestamp = new Date(this.timestamp);
-    const year = timestamp.getFullYear();
-    const month = (timestamp.getMonth() + 1).toString().padStart(2, "0");
-    const day = timestamp.getDate().toString().padStart(2, "0");
-    const hours = timestamp.getHours().toString().padStart(2, "0");
-    const minutes = timestamp.getMinutes().toString().padStart(2, "0");
-    const seconds = timestamp.getSeconds().toString().padStart(2, "0");
-    const ms = timestamp.getMilliseconds().toString().padStart(3, "0");
-    const time = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
-    const msg = this.msg instanceof Promise ? "<unresolved>" : this.msg;
-    let extra = "";
-    if (this.data !== void 0) {
-      const data = this.data;
-      const kv = Object.keys(data).map((key) => {
-        const value = data[key] instanceof Promise ? "<unresolved>" : data[key];
-        return `${key}: ${JSONX.stringify(value)}`;
-      }).join(", ");
-      extra = ` (${kv})`;
-    }
-    return `[${time}] ${this.level}: ${msg}${extra}`;
-  }
-}
-class TraceTrait extends MsgTrait {
-  constructor() {
-    super(...arguments);
-    this._events = new EventEmitter();
-  }
-  on(...args) {
-    this._events.on(...args);
-  }
-  off(...args) {
-    this._events.off(...args);
-  }
-  emitEvent(...args) {
-    if (this._events.listenerCount(args[0]) === 0)
-      return false;
-    return this._events.emit(...args);
-  }
-  /*  log an event  */
-  log(level, msg, data) {
-    const event = new LogEvent(Date.now(), level, msg, data);
-    this.emitEvent("log", event);
-  }
-  /*  raise an error event  */
-  error(error, msg) {
-    let err = error;
-    if (msg !== void 0)
-      err = new Error(`${msg}: ${error.message}`, { cause: error });
-    this.emitEvent("error", err);
-    this.log("error", err.message);
-  }
-}
-class BaseTrait extends TraceTrait {
-  /*  construct API class  */
-  constructor(mqtt, options = {}) {
-    super(options);
-    this.onRequest = /* @__PURE__ */ new Map();
-    this.onResponse = /* @__PURE__ */ new Map();
-    if (mqtt === null) {
-      this.log("info", "establishing proxy MQTT client");
-      mqtt = new Proxy({}, {
-        get(_target, prop, _receiver) {
-          if (prop === "isFakeProxy")
-            return true;
-          else if (typeof prop === "string" && ["on", "off", "once"].includes(prop))
-            return () => {
-            };
-          else
-            return () => {
-              throw new Error(`Underlying MQTT operation "${String(prop)}" called on a null MQTT client -- only MQTT+ "emit({ ..., dry: true })" is supported in this special operation mode`);
-            };
-        }
-      });
-    }
-    this.mqtt = mqtt;
-    this.log("info", "hooking into MQTT client");
-    this.messageHandler = (topic, message, packet) => {
-      let input;
-      if (this.options.codec === "json")
-        input = message.toString();
-      else if (this.options.codec === "cbor")
-        input = Buffer.isBuffer(message) ? new Uint8Array(message.buffer, message.byteOffset, message.byteLength) : message;
-      else
-        throw new Error("invalid codec configured");
-      this._onMessage(topic, input, packet);
-    };
-    this.mqtt.on("message", this.messageHandler);
-  }
-  /*  destroy API class  */
-  async destroy() {
-    this.log("info", "un-hooking from MQTT client");
-    this.mqtt.off("message", this.messageHandler);
-    this.onRequest.clear();
-    this.onResponse.clear();
-  }
-  /*  create a registration for subsequent destruction  */
-  makeRegistration(spool, kind, name, key) {
-    return {
-      destroy: async () => {
-        if (!this.onRequest.has(key))
-          throw new Error(`destroy: ${kind} "${name}" not registered`);
-        await spool.unroll(false)?.catch((err) => {
-          const error = ensureError(err, `destroy: ${kind} "${name}" failed to cleanup`);
-          this.error(error);
-          throw error;
-        });
-      }
-    };
-  }
-  /*  subscribe to an MQTT topic (Promise-based)  */
-  async subscribeTopic(topic, options = {}) {
-    this.log("info", `subscribing to MQTT topic "${topic}"`);
-    return new Promise((resolve, reject) => {
-      this.mqtt.subscribe(topic, { qos: 2, ...options }, (err, _granted) => {
-        if (err) {
-          this.error(err, `subscribing to MQTT topic "${topic}" failed`);
-          reject(err);
-        } else
-          resolve();
-      });
-    });
-  }
-  /*  unsubscribe from an MQTT topic (Promise-based)  */
-  async unsubscribeTopic(topic) {
-    this.log("info", `unsubscribing from MQTT topic "${topic}"`);
-    return new Promise((resolve, reject) => {
-      this.mqtt.unsubscribe(topic, (err, _packet) => {
-        if (err) {
-          this.error(err, `unsubscribing from MQTT topic "${topic}" failed`);
-          reject(err);
-        } else
-          resolve();
-      });
-    });
-  }
-  /*  publish to an MQTT topic (Promise-based)  */
-  async publishToTopic(topic, message, options = {}) {
-    if (typeof message === "string")
-      this.log("info", `publishing to MQTT topic "${topic}" (type: string, length: ${message.length} chars)`);
-    else
-      this.log("info", `publishing to MQTT topic "${topic}" (type: buffer, length: ${message.byteLength} bytes)`);
-    const messageOnDemand = new PLazy((resolve, reject) => {
-      let parsed;
-      try {
-        const payload = this.codec.decode(message);
-        parsed = this.msg.parse(payload);
-      } catch (err) {
-        return reject(err);
-      }
-      resolve(parsed);
-    });
-    this.log("debug", `publishing to MQTT topic "${topic}"`, { message: messageOnDemand });
-    return new Promise((resolve, reject) => {
-      const messageData = typeof message === "string" ? message : Buffer.from(message.buffer, message.byteOffset, message.byteLength);
-      this.mqtt.publish(topic, messageData, options, (err) => {
-        if (err) {
-          this.error(err, `publishing to MQTT topic "${topic}" failed`);
-          reject(err);
-        } else
-          resolve();
-      });
-    });
-  }
-  /*  handle incoming MQTT message  */
-  _onMessage(topic, data, _packet) {
-    const topicMatch = this.options.topicMatch(topic);
-    if (topicMatch === null)
-      return;
-    if (typeof data === "string")
-      this.log("info", `received from MQTT topic "${topic}" (type: string, length: ${data.length} chars)`);
-    else
-      this.log("info", `received from MQTT topic "${topic}" (type: buffer, length: ${data.byteLength} bytes)`);
-    let payload;
-    try {
-      payload = this.codec.decode(data);
-    } catch (err) {
-      this.error(ensureError(err, "failed to parse message into object"));
-      return;
-    }
-    let message;
-    try {
-      message = this.msg.parse(payload);
-    } catch (err) {
-      this.error(ensureError(err, "failed to parse object into typed message object"));
-      return;
-    }
-    this.log("debug", `received from MQTT topic "${topic}"`, { message });
-    if (this.msg.isRequest(message)) {
-      const handler = this.onRequest.get(`${message.type}:${message.name}`);
-      if (handler !== void 0) {
-        Promise.resolve().then(() => handler(message, topicMatch.name)).catch((err) => {
-          this.error(ensureError(err, `dispatching request message from MQTT topic "${topic}" failed`));
-        });
-      }
-    } else if (this.msg.isResponse(message)) {
-      const handler = this.onResponse.get(`${message.type}:${message.id}`);
-      if (handler !== void 0) {
-        Promise.resolve().then(() => handler(message, topicMatch.name)).catch((err) => {
-          this.error(ensureError(err, `dispatching response message from MQTT topic "${topic}" failed`));
-        });
-      }
-    }
-  }
-}
-class RefCountedSubscription {
-  /*  initial construction with configuration  */
-  constructor(subscribeFn, unsubscribeFn, lingerMs = 30 * 1e3) {
-    this.subscribeFn = subscribeFn;
-    this.unsubscribeFn = unsubscribeFn;
-    this.lingerMs = lingerMs;
-    this.counts = /* @__PURE__ */ new Map();
-    this.pending = /* @__PURE__ */ new Map();
-    this.lingers = /* @__PURE__ */ new Map();
-    this.unsubbing = /* @__PURE__ */ new Map();
-  }
-  /*  increment reference count for a topic  */
-  incrementCount(topic) {
-    const count = this.counts.get(topic) ?? 0;
-    this.counts.set(topic, count + 1);
-    return count;
-  }
-  /*  decrement reference count for a topic  */
-  decrementCount(topic) {
-    const count = this.counts.get(topic);
-    if (count !== void 0) {
-      if (count <= 1) {
-        this.counts.delete(topic);
-        return 0;
-      } else {
-        this.counts.set(topic, count - 1);
-        return count - 1;
-      }
-    }
-    return void 0;
-  }
-  /*  subscribe to a topic (reference-counted)  */
-  async subscribe(topic, options = { qos: 2 }) {
-    const count = this.incrementCount(topic);
-    const linger = this.lingers.get(topic);
-    if (linger) {
-      clearTimeout(linger);
-      this.lingers.delete(topic);
-      return;
-    }
-    if (count === 0) {
-      let resolve;
-      let reject;
-      const deferred = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-      });
-      deferred.catch(() => {
-      });
-      this.pending.set(topic, deferred);
-      const inflight = this.unsubbing.get(topic);
-      if (inflight)
-        await inflight;
-      const promise = this.subscribeFn(topic, options).then(() => {
-        this.pending.delete(topic);
-        resolve();
-      }).catch((err) => {
-        this.pending.delete(topic);
-        this.decrementCount(topic);
-        reject(err);
-        throw err;
-      });
-      return promise;
-    } else {
-      const pending = this.pending.get(topic);
-      if (pending)
-        return pending.catch((err) => {
-          this.decrementCount(topic);
-          throw err;
-        });
-    }
-  }
-  /*  unsubscribe from a topic (reference-counted)  */
-  async unsubscribe(topic) {
-    const count = this.decrementCount(topic);
-    if (count === 0) {
-      if (this.lingerMs > 0) {
-        const timer = setTimeout(() => {
-          this.lingers.delete(topic);
-          const promise = this.unsubscribeFn(topic).catch(() => {
-          }).finally(() => {
-            this.unsubbing.delete(topic);
-          });
-          this.unsubbing.set(topic, promise);
-        }, this.lingerMs);
-        this.lingers.set(topic, timer);
-      } else {
-        const promise = this.unsubscribeFn(topic).catch(() => {
-        }).finally(() => {
-          this.unsubbing.delete(topic);
-        });
-        this.unsubbing.set(topic, promise);
-        await promise;
-      }
-    }
-  }
-  /*  flush all pending linger timers and unsubscribe  */
-  async flush() {
-    const topics = /* @__PURE__ */ new Set([
-      ...this.counts.keys(),
-      ...this.lingers.keys(),
-      ...this.pending.keys(),
-      ...this.unsubbing.keys()
-    ]);
-    for (const timer of this.lingers.values())
-      clearTimeout(timer);
-    this.lingers.clear();
-    this.counts.clear();
-    await Promise.allSettled([...this.pending.values(), ...this.unsubbing.values()]);
-    await Promise.allSettled([...topics].map((topic) => this.unsubscribeFn(topic).catch(() => {
-    })));
-    this.pending.clear();
-    this.unsubbing.clear();
-  }
-}
-class SubscriptionTrait extends BaseTrait {
-  constructor() {
-    super(...arguments);
-    this.subscriptions = new RefCountedSubscription((topic, options) => this.subscribeTopic(topic, options), (topic) => this.unsubscribeTopic(topic));
-  }
-  /*  subscribe to an MQTT topic (reference-counted) and spool the unsubscription  */
-  async subscribeTopicAndSpool(spool, topic, options = {}) {
-    await run(`subscribe to MQTT topic "${topic}"`, spool, () => this.subscriptions.subscribe(topic, { qos: 2, ...options }));
-    spool.roll(() => this.subscriptions.unsubscribe(topic));
-  }
-  /*  destroy subscription trait  */
-  async destroy() {
-    await this.subscriptions.flush();
-    await super.destroy();
-  }
-}
-class TimerTrait extends SubscriptionTrait {
-  constructor() {
-    super(...arguments);
-    this.timers = /* @__PURE__ */ new Map();
-  }
-  /*  destroy timer trait  */
-  async destroy() {
-    for (const timer of this.timers.values())
-      clearTimeout(timer);
-    this.timers.clear();
-    await super.destroy();
-  }
-  /*  refresh (or start) a named timer  */
-  timerRefresh(id, onTimeout) {
-    const timer = this.timers.get(id);
-    if (timer !== void 0)
-      clearTimeout(timer);
-    this.timers.set(id, setTimeout(async () => {
-      this.timers.delete(id);
-      try {
-        await onTimeout();
-      } catch (err) {
-        this.error(ensureError(err), `timer "${id}" failed`);
-      }
-    }, this.options.timeout));
-  }
-  /*  clear a named timer  */
-  timerClear(id) {
-    const timer = this.timers.get(id);
-    if (timer !== void 0) {
-      clearTimeout(timer);
-      this.timers.delete(id);
-    }
-  }
-}
-class MetaTrait extends TimerTrait {
-  constructor() {
-    super(...arguments);
-    this._meta = /* @__PURE__ */ new Map();
-  }
-  meta(...args) {
-    const [key, value] = args;
-    if (args.length === 0)
-      return Object.fromEntries(this._meta);
-    else if (args.length === 1)
-      return this._meta.get(key);
-    else if (value === void 0 || value === null)
-      this._meta.delete(key);
-    else
-      this._meta.set(key, value);
-  }
-  /*  determine meta store  */
-  metaStore(extra) {
-    const extraEmpty = extra === void 0 || Object.keys(extra).length === 0;
-    if (this._meta.size === 0 && extraEmpty)
-      return void 0;
-    else if (this._meta.size > 0 && extraEmpty)
-      return Object.fromEntries(this._meta);
-    else if (this._meta.size === 0 && !extraEmpty)
-      return extra;
-    else
-      return { ...Object.fromEntries(this._meta), ...extra };
-  }
-}
-const textEncoder = new TextEncoder();
-class AuthTrait extends MetaTrait {
-  constructor() {
-    super(...arguments);
-    this._credential = null;
-    this._tokens = /* @__PURE__ */ new Set();
-  }
-  /*  store server-side secret credential  */
-  credential(credential) {
-    if (credential.length === 0)
-      throw new Error("credential must not be empty");
-    const pass = textEncoder.encode(credential);
-    const salt = textEncoder.encode("mqtt-plus");
-    this._credential = pbkdf2.deriveKey(sha256.SHA256, pass, salt, 6e5, 32);
-  }
-  /*  issue client-side token on server-side  */
-  async issue(payload) {
-    if (this._credential === null)
-      throw new Error("credential has to be provided before issuing tokens");
-    if (payload.roles.length === 0)
-      throw new Error("payload.roles must be a non-empty array");
-    if (payload.roles.length > 64)
-      throw new Error("payload.roles must not exceed 64 roles");
-    const jwt = new SignJWT(payload);
-    jwt.setProtectedHeader({ alg: "HS256", typ: "JWT" });
-    const token = await jwt.sign(this._credential);
-    return token;
-  }
-  authenticate(token, remove) {
-    if (token === void 0) {
-      const tokens = Array.from(this._tokens).filter((token2) => token2.length <= 8192).slice(0, 8);
-      return tokens.length > 0 ? tokens : void 0;
-    } else if (remove === true)
-      this._tokens.delete(token);
-    else {
-      if (token.length > 8192)
-        throw new Error("token must not exceed 8192 characters");
-      if (!this._tokens.has(token) && this._tokens.size >= 8)
-        throw new Error("at most 8 tokens can be authenticated at once");
-      this._tokens.add(token);
-    }
-  }
-  /*  validate client-side token on server-side  */
-  async validateToken(token) {
-    if (this._credential === null)
-      throw new Error("credential has to be provided before validating tokens");
-    const result = await jwtVerify(token, this._credential).catch(() => null);
-    return result?.payload ?? null;
-  }
-  /*  check whether request is authenticated  */
-  async authenticated(clientId, tokens, option) {
-    let authenticated = false;
-    let mode;
-    let roles;
-    if (typeof option === "string") {
-      mode = "require";
-      roles = [option];
-    } else {
-      mode = option.mode;
-      roles = option.roles;
-    }
-    if (tokens !== void 0) {
-      for (const token of tokens.slice(0, 8)) {
-        if (token.length > 8192)
-          continue;
-        const payload = await this.validateToken(token);
-        if (payload === null)
-          continue;
-        if (payload.id && payload.id !== clientId)
-          continue;
-        if (!Array.isArray(payload.roles))
-          continue;
-        if (payload.roles.length > 64)
-          continue;
-        for (const role of roles) {
-          if (payload.roles.includes(role)) {
-            authenticated = true;
-            break;
-          }
-        }
-        if (authenticated)
-          break;
-      }
-    }
-    if (!authenticated && mode === "optional")
-      authenticated = true;
-    return authenticated;
-  }
-}
-class EventTrait extends AuthTrait {
-  async event(nameOrConfig, ...args) {
-    let name;
-    let callback;
-    let options = {};
-    let share = this.options.share;
-    let auth;
-    if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
-      name = nameOrConfig.name;
-      callback = nameOrConfig.callback;
-      options = nameOrConfig.options ?? {};
-      share = nameOrConfig.share ?? this.options.share;
-      auth = nameOrConfig.auth;
-    } else {
-      name = nameOrConfig;
-      callback = args[0];
-    }
-    const spool = new Spool();
-    if (this.onRequest.has(`event-emission:${name}`))
-      throw new Error(`event: event "${name}" already registered`);
-    const topicS = share !== "" ? `$share/${share}/${name}` : name;
-    const topicB = this.options.topicMake(topicS, "event-emission");
-    const topicD = this.options.topicMake(name, "event-emission", this.options.id);
-    this.onRequest.set(`event-emission:${name}`, async (request, topicName) => {
-      const senderId = request.sender;
-      if (senderId === void 0 || senderId === "")
-        throw new Error("invalid request: missing sender");
-      const params = request.params ?? [];
-      const info = { sender: senderId };
-      if (request.receiver)
-        info.receiver = request.receiver;
-      if (request.meta)
-        info.meta = request.meta;
-      try {
-        if (topicName !== request.name)
-          throw new Error(`event name mismatch (topic: "${topicName}", payload: "${request.name}")`);
-        if (auth)
-          info.authenticated = await this.authenticated(senderId, request.auth, auth);
-        if (info.authenticated !== void 0 && !info.authenticated)
-          throw new Error(`event "${name}" failed authentication`);
-        await callback(...params, info);
-      } catch (result) {
-        const error = ensureError(result);
-        this.error(error, `handler for event "${name}" failed`);
-      }
-    });
-    spool.roll(() => {
-      this.onRequest.delete(`event-emission:${name}`);
-    });
-    await this.subscribeTopicAndSpool(spool, topicB, options);
-    await this.subscribeTopicAndSpool(spool, topicD, options);
-    return this.makeRegistration(spool, "event", name, `event-emission:${name}`);
-  }
-  emit(nameOrConfig, ...args) {
-    let name;
-    let params;
-    let receiver;
-    let options = {};
-    let meta;
-    let dry;
-    if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
-      name = nameOrConfig.name;
-      params = nameOrConfig.params;
-      receiver = nameOrConfig.receiver;
-      options = nameOrConfig.options ?? {};
-      meta = nameOrConfig.meta;
-      dry = nameOrConfig.dry;
-    } else {
-      name = nameOrConfig;
-      params = args;
-    }
-    const requestId = nanoid();
-    const auth = this.authenticate();
-    const metaStore = this.metaStore(meta);
-    const request = this.msg.makeEventEmission(requestId, name, params, this.options.id, receiver, auth, metaStore);
-    const message = this.codec.encode(request);
-    const topic = this.options.topicMake(name, "event-emission", receiver);
-    if (dry)
-      return { topic, payload: message, options: { qos: 2, ...options } };
-    else
-      this.publishToTopic(topic, message, { qos: 2, ...options }).catch((err) => {
-        this.error(err, `emitting event "${name}" failed`);
-      });
-  }
-}
-class ServiceTrait extends EventTrait {
-  async service(nameOrConfig, ...args) {
-    let name;
-    let callback;
-    let options = {};
-    let share = this.options.share;
-    let auth;
-    if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
-      name = nameOrConfig.name;
-      callback = nameOrConfig.callback;
-      options = nameOrConfig.options ?? {};
-      share = nameOrConfig.share ?? this.options.share;
-      auth = nameOrConfig.auth;
-    } else {
-      name = nameOrConfig;
-      callback = args[0];
-    }
-    const spool = new Spool();
-    if (this.onRequest.has(`service-call-request:${name}`))
-      throw new Error(`service: service "${name}" already registered`);
-    const topicS = share !== "" ? `$share/${share}/${name}` : name;
-    const topicB = this.options.topicMake(topicS, "service-call-request");
-    const topicD = this.options.topicMake(name, "service-call-request", this.options.id);
-    this.onRequest.set(`service-call-request:${name}`, async (request, topicName) => {
-      const requestId = request.id;
-      const senderId = request.sender;
-      if (senderId === void 0 || senderId === "")
-        throw new Error("invalid request: missing sender");
-      const params = request.params ?? [];
-      const info = { sender: senderId };
-      if (request.receiver)
-        info.receiver = request.receiver;
-      if (request.meta)
-        info.meta = request.meta;
-      try {
-        if (topicName !== request.name)
-          throw new Error(`service name mismatch (topic: "${topicName}", payload: "${request.name}")`);
-        if (auth)
-          info.authenticated = await this.authenticated(senderId, request.auth, auth);
-        if (info.authenticated !== void 0 && !info.authenticated)
-          throw new Error(`service "${name}" failed authentication`);
-        const result = await callback(...params, info);
-        const rpcResponse = this.msg.makeServiceCallResponse(requestId, result, void 0, this.options.id, senderId);
-        const encoded = this.codec.encode(rpcResponse);
-        const topic = this.options.topicMake(name, "service-call-response", senderId);
-        await this.publishToTopic(topic, encoded, { qos: options.qos ?? 2 });
-      } catch (err) {
-        const error = ensureError(err);
-        this.error(error, `handler for service "${name}" failed`);
-        const rpcResponse = this.msg.makeServiceCallResponse(requestId, void 0, error.message, this.options.id, senderId);
-        try {
-          const encoded = this.codec.encode(rpcResponse);
-          const topic = this.options.topicMake(name, "service-call-response", senderId);
-          await this.publishToTopic(topic, encoded, { qos: options.qos ?? 2 });
-        } catch (err2) {
-          this.error(ensureError(err2), `sending error response for service "${name}" failed`);
-        }
-      }
-    });
-    spool.roll(() => {
-      this.onRequest.delete(`service-call-request:${name}`);
-    });
-    await this.subscribeTopicAndSpool(spool, topicB, options);
-    await this.subscribeTopicAndSpool(spool, topicD, options);
-    return this.makeRegistration(spool, "service", name, `service-call-request:${name}`);
-  }
-  async call(nameOrConfig, ...args) {
-    let name;
-    let params;
-    let receiver;
-    let options = {};
-    let meta;
-    if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
-      name = nameOrConfig.name;
-      params = nameOrConfig.params;
-      receiver = nameOrConfig.receiver;
-      options = nameOrConfig.options ?? {};
-      meta = nameOrConfig.meta;
-    } else {
-      name = nameOrConfig;
-      params = args;
-    }
-    const spool = new Spool();
-    let requestId = nanoid();
-    while (this.onResponse.has(`service-call-response:${requestId}`))
-      requestId = nanoid();
-    const responseTopic = this.options.topicMake(name, "service-call-response", this.options.id);
-    await this.subscribeTopicAndSpool(spool, responseTopic, { qos: options.qos ?? 2 });
-    const timerId = `service-call:${requestId}`;
-    let rejectPromise;
-    const promise = new Promise((resolve, reject) => {
-      rejectPromise = reject;
-      this.timerRefresh(timerId, async () => {
-        await spool.unroll();
-        reject(new Error("communication timeout"));
-      });
-      spool.roll(() => {
-        this.timerClear(timerId);
-      });
-      this.onResponse.set(`service-call-response:${requestId}`, async (response) => {
-        await spool.unroll();
-        if (response.error !== void 0)
-          reject(new Error(response.error));
-        else
-          resolve(response.result);
-      });
-      spool.roll(() => {
-        this.onResponse.delete(`service-call-response:${requestId}`);
-      });
-    });
-    const auth = this.authenticate();
-    const metaStore = this.metaStore(meta);
-    const request = this.msg.makeServiceCallRequest(requestId, name, params, this.options.id, receiver, auth, metaStore);
-    const message = this.codec.encode(request);
-    const topic = this.options.topicMake(name, "service-call-request", receiver);
-    try {
-      await run(`publish service request as MQTT message to topic "${topic}"`, spool, () => this.publishToTopic(topic, message, { qos: 2, ...options }));
-    } catch (err) {
-      rejectPromise(err);
-      return promise;
-    }
-    return promise;
-  }
-}
-class SourceTrait extends ServiceTrait {
-  constructor() {
-    super(...arguments);
-    this.sourceCreditGates = /* @__PURE__ */ new Map();
-    this.sourceControllers = /* @__PURE__ */ new Map();
-  }
-  /*  destroy source trait  */
-  async destroy() {
-    for (const controller of this.sourceControllers.values())
-      controller.abort(new Error("source destroyed"));
-    this.sourceControllers.clear();
-    for (const gate of this.sourceCreditGates.values())
-      gate.abort();
-    this.sourceCreditGates.clear();
-    await super.destroy();
-  }
-  async source(nameOrConfig, ...args) {
-    let name;
-    let callback;
-    let options = {};
-    let share = this.options.share;
-    let auth;
-    if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
-      name = nameOrConfig.name;
-      callback = nameOrConfig.callback;
-      options = nameOrConfig.options ?? {};
-      share = nameOrConfig.share ?? this.options.share;
-      auth = nameOrConfig.auth;
-    } else {
-      name = nameOrConfig;
-      callback = args[0];
-    }
-    const spool = new Spool();
-    if (this.onRequest.has(`source-fetch-request:${name}`))
-      throw new Error(`source: source "${name}" already registered`);
-    const topicS = share !== "" ? `$share/${share}/${name}` : name;
-    const topicReqB = this.options.topicMake(topicS, "source-fetch-request");
-    const topicReqD = this.options.topicMake(name, "source-fetch-request", this.options.id);
-    this.onRequest.set(`source-fetch-request:${name}`, async (request, topicName) => {
-      const requestId = request.id;
-      const params = request.params ?? [];
-      const sender = request.sender;
-      if (sender === void 0 || sender === "")
-        throw new Error("invalid request: missing sender");
-      const receiver = request.receiver;
-      const info = { sender };
-      if (receiver)
-        info.receiver = receiver;
-      if (request.meta)
-        info.meta = request.meta;
-      const responseTopic = this.options.topicMake(name, "source-fetch-response", sender);
-      const sendResponse = async (error) => {
-        const metaStore = this.metaStore(info.meta);
-        const response = this.msg.makeSourceFetchResponse(requestId, name, error, this.options.id, sender, metaStore);
-        const message = this.codec.encode(response);
-        await this.publishToTopic(responseTopic, message, { qos: options.qos ?? 2 });
-      };
-      const abortController = new AbortController();
-      this.sourceControllers.set(requestId, abortController);
-      const abortSignal = abortController.signal;
-      abortSignal.addEventListener("abort", () => {
-        if (info.stream instanceof Readable && !info.stream.destroyed)
-          info.stream.destroy(ensureError(abortSignal.reason));
-      }, { once: true });
-      const sourceTimerId = `source-fetch-send:${requestId}`;
-      const refreshSourceTimeout = () => this.timerRefresh(sourceTimerId, () => {
-        const error = new Error(`source fetch "${name}" timed out`);
-        abortController.abort(error);
-        const gate = this.sourceCreditGates.get(requestId);
-        if (gate !== void 0) {
-          gate.abort();
-          this.sourceCreditGates.delete(requestId);
-        }
-        this.sourceControllers.delete(requestId);
-        this.onResponse.delete(`source-fetch-credit:${requestId}`);
-      });
-      const clearSourceTimeout = () => this.timerClear(sourceTimerId);
-      refreshSourceTimeout();
-      const sendChunk = async (chunk, error, final) => {
-        refreshSourceTimeout();
-        const chunkMsg = this.msg.makeSourceFetchChunk(requestId, name, chunk, error, final, this.options.id, sender);
-        const message = this.codec.encode(chunkMsg);
-        await this.publishToTopic(responseTopic, message, { qos: options.qos ?? 2 });
-      };
-      let ackSent = false;
-      let creditGate;
-      try {
-        if (topicName !== request.name)
-          throw new Error(`source name mismatch (topic: "${topicName}", payload: "${request.name}")`);
-        if (auth)
-          info.authenticated = await this.authenticated(sender, request.auth, auth);
-        if (info.authenticated !== void 0 && !info.authenticated)
-          throw new Error(`source "${name}" failed authentication`);
-        const initialCredit = request.credit;
-        creditGate = initialCredit !== void 0 && initialCredit > 0 ? new CreditGate(initialCredit) : void 0;
-        if (creditGate)
-          this.sourceCreditGates.set(requestId, creditGate);
-        this.onResponse.set(`source-fetch-credit:${requestId}`, (creditParsed) => {
-          if (creditParsed.credit === 0) {
-            abortController.abort(new Error(`source fetch "${name}" cancelled by fetcher`));
-            return;
-          }
-          if (creditGate) {
-            creditGate.replenish(creditParsed.credit);
-            refreshSourceTimeout();
-          }
-        });
-        await callback(...params, info);
-        if (!(info.stream instanceof Readable) && !(info.buffer instanceof Promise))
-          throw new Error("handler did not provide data via info.stream or info.buffer fields");
-        if (info.stream instanceof Readable && info.buffer instanceof Promise)
-          throw new Error("handler has set both info.stream and info.buffer fields");
-        await sendResponse();
-        ackSent = true;
-        if (info.stream instanceof Readable)
-          await sendStreamAsChunks(info.stream, this.options.chunkSize, sendChunk, creditGate, abortSignal);
-        else if (info.buffer instanceof Promise)
-          await sendBufferAsChunks(await info.buffer, this.options.chunkSize, sendChunk, creditGate, abortSignal);
-      } catch (err) {
-        const error = ensureError(err, `handler for source "${name}" failed`);
-        abortController.abort(error);
-        this.error(error);
-        if (ackSent)
-          await sendChunk(void 0, error.message, true).catch(() => {
-          });
-        else
-          await sendResponse(error.message).catch(() => {
-          });
-      } finally {
-        clearSourceTimeout();
-        if (creditGate) {
-          creditGate.abort();
-          this.sourceCreditGates.delete(requestId);
-        }
-        this.sourceControllers.delete(requestId);
-        this.onResponse.delete(`source-fetch-credit:${requestId}`);
-      }
-    });
-    spool.roll(() => {
-      this.onRequest.delete(`source-fetch-request:${name}`);
-    });
-    await this.subscribeTopicAndSpool(spool, topicReqB, options);
-    await this.subscribeTopicAndSpool(spool, topicReqD, options);
-    return this.makeRegistration(spool, "source", name, `source-fetch-request:${name}`);
-  }
-  async fetch(nameOrConfig, ...args) {
-    let name;
-    let params;
-    let receiver;
-    let options = {};
-    let meta;
-    if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
-      name = nameOrConfig.name;
-      params = nameOrConfig.params;
-      receiver = nameOrConfig.receiver;
-      options = nameOrConfig.options ?? {};
-      meta = nameOrConfig.meta;
-    } else {
-      name = nameOrConfig;
-      params = args;
-    }
-    const spool = new Spool();
-    let requestId = nanoid();
-    while (this.onResponse.has(`source-fetch-response:${requestId}`) || this.onResponse.has(`source-fetch-chunk:${requestId}`))
-      requestId = nanoid();
-    const responseTopic = this.options.topicMake(name, "source-fetch-response", this.options.id);
-    await this.subscribeTopicAndSpool(spool, responseTopic, { qos: options.qos ?? 2 });
-    const chunkCredit = this.options.chunkCredit;
-    let chunksReceived = 0;
-    let creditGranted = chunkCredit;
-    let serverId;
-    let streamEnded = false;
-    const timerId = `source-fetch:${requestId}`;
-    let stream = void 0;
-    const refreshTimeout = () => {
-      this.timerRefresh(timerId, () => {
-        stream?.destroy(new Error("communication timeout"));
-        spool.unroll();
-      });
-    };
-    spool.roll(() => {
-      this.timerClear(timerId);
-    });
-    stream = new Readable({
-      highWaterMark: chunkCredit > 0 ? chunkCredit * this.options.chunkSize : 16 * 1024,
-      read: (_size) => {
-        if (chunkCredit <= 0 || !this.onResponse.has(`source-fetch-response:${requestId}`))
-          return;
-        const targetId = serverId ?? receiver;
-        if (!targetId)
-          return;
-        const creditToGrant = Math.max(0, chunksReceived + chunkCredit - creditGranted);
-        if (creditToGrant > 0) {
-          creditGranted += creditToGrant;
-          const creditMsg = this.msg.makeSourceFetchCredit(requestId, name, creditToGrant, this.options.id, targetId);
-          const encoded = this.codec.encode(creditMsg);
-          const creditTopic = this.options.topicMake(name, "source-fetch-request", targetId);
-          this.publishToTopic(creditTopic, encoded, { qos: options.qos ?? 2 }).catch((err) => {
-            this.error(err, `sending credit for fetch "${name}" failed`);
-          });
-          refreshTimeout();
-        }
-      }
-    });
-    const buffer = streamToBuffer(stream);
-    let metaResolve;
-    const metaP = new Promise((resolve) => {
-      metaResolve = resolve;
-    });
-    spool.roll(() => {
-      metaResolve(void 0);
-    });
-    refreshTimeout();
-    let cancelled = false;
-    const cancelAndUnroll = () => {
-      if (!cancelled && !streamEnded) {
-        cancelled = true;
-        const targetId = serverId ?? receiver;
-        if (targetId) {
-          const cancelMsg = this.msg.makeSourceFetchCredit(requestId, name, 0, this.options.id, targetId);
-          const encoded = this.codec.encode(cancelMsg);
-          const cancelTopic = this.options.topicMake(name, "source-fetch-request", targetId);
-          this.publishToTopic(cancelTopic, encoded, { qos: options.qos ?? 2 }).catch(() => {
-          });
-        }
-      }
-      spool.unroll();
-    };
-    stream.once("close", cancelAndUnroll);
-    stream.once("error", cancelAndUnroll);
-    this.onResponse.set(`source-fetch-response:${requestId}`, (response) => {
-      if (streamEnded)
-        return;
-      if (response.name !== name) {
-        streamEnded = true;
-        stream.destroy(new Error(`source name mismatch (expected "${name}", got "${response.name}")`));
-        spool.unroll();
-        return;
-      }
-      if (response.sender)
-        serverId = response.sender;
-      if (response.error) {
-        streamEnded = true;
-        stream.destroy(new Error(response.error));
-        spool.unroll();
-      } else {
-        metaResolve(response.meta);
-        refreshTimeout();
-      }
-    });
-    this.onResponse.set(`source-fetch-chunk:${requestId}`, (response) => {
-      if (streamEnded)
-        return;
-      if (response.error) {
-        streamEnded = true;
-        stream.destroy(new Error(response.error));
-        spool.unroll();
-      } else {
-        refreshTimeout();
-        if (response.chunk !== void 0) {
-          chunksReceived++;
-          stream.push(response.chunk);
-        }
-        if (response.final) {
-          streamEnded = true;
-          stream.push(null);
-          spool.unroll();
-        }
-      }
-    });
-    spool.roll(() => {
-      this.onResponse.delete(`source-fetch-response:${requestId}`);
-      this.onResponse.delete(`source-fetch-chunk:${requestId}`);
-    });
-    const auth = this.authenticate();
-    const metaStore = this.metaStore(meta);
-    const credit = chunkCredit > 0 ? chunkCredit : void 0;
-    const request = this.msg.makeSourceFetchRequest(requestId, name, params, this.options.id, receiver, auth, metaStore, credit);
-    const message = this.codec.encode(request);
-    const topic = this.options.topicMake(name, "source-fetch-request", receiver);
-    run(`publish fetch request as MQTT message to topic "${topic}"`, () => this.publishToTopic(topic, message, { qos: 2, ...options })).catch((err) => {
-      stream.destroy(ensureError(err));
-    });
-    const result = { stream, buffer, meta: metaP };
-    makeMutuallyExclusiveFields(result, "stream", "buffer");
-    return result;
-  }
-}
-class SinkTrait extends SourceTrait {
-  constructor() {
-    super(...arguments);
-    this.pushStreams = /* @__PURE__ */ new Map();
-    this.pushSpools = /* @__PURE__ */ new Map();
-  }
-  /*  destroy trait  */
-  async destroy() {
-    for (const stream of this.pushStreams.values())
-      stream.destroy(new Error("sink destroyed"));
-    this.pushStreams.clear();
-    for (const spool of this.pushSpools.values())
-      await spool.unroll();
-    this.pushSpools.clear();
-    await super.destroy();
-  }
-  async sink(nameOrConfig, ...args) {
-    let name;
-    let callback;
-    let options = {};
-    let share = this.options.share;
-    let auth;
-    if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
-      name = nameOrConfig.name;
-      callback = nameOrConfig.callback;
-      options = nameOrConfig.options ?? {};
-      share = nameOrConfig.share ?? this.options.share;
-      auth = nameOrConfig.auth;
-    } else {
-      name = nameOrConfig;
-      callback = args[0];
-    }
-    const spool = new Spool();
-    if (this.onRequest.has(`sink-push-request:${name}`))
-      throw new Error(`sink: sink "${name}" already registered`);
-    const topicS = share !== "" ? `$share/${share}/${name}` : name;
-    const topicReqB = this.options.topicMake(topicS, "sink-push-request");
-    const topicReqD = this.options.topicMake(name, "sink-push-request", this.options.id);
-    this.onRequest.set(`sink-push-request:${name}`, async (request, topicName) => {
-      const requestId = request.id;
-      const params = request.params ?? [];
-      const sender = request.sender;
-      if (sender === void 0 || sender === "")
-        throw new Error("invalid request: missing sender");
-      const receiver = request.receiver;
-      const responseTopic = this.options.topicMake(name, "sink-push-response", sender);
-      const chunkCredit = this.options.chunkCredit;
-      const sendResponse = async (error, withCredit = false) => {
-        const credit = error === void 0 && withCredit && chunkCredit > 0 ? chunkCredit : void 0;
-        const response = this.msg.makeSinkPushResponse(requestId, name, error, this.options.id, sender, credit);
-        const message = this.codec.encode(response);
-        await this.publishToTopic(responseTopic, message, { qos: options.qos ?? 2 });
-      };
-      const reqSpool = new Spool();
-      this.pushSpools.set(requestId, reqSpool);
-      reqSpool.roll(() => {
-        this.pushSpools.delete(requestId);
-      });
-      try {
-        if (topicName !== request.name)
-          throw new Error(`sink name mismatch (topic: "${topicName}", payload: "${request.name}")`);
-        let authenticated = void 0;
-        if (auth)
-          authenticated = await this.authenticated(sender, request.auth, auth);
-        if (authenticated !== void 0 && !authenticated)
-          throw new Error(`sink "${name}" failed authentication`);
-        const creditState = chunkCredit > 0 ? {
-          chunksReceived: 0,
-          creditGranted: chunkCredit
-        } : void 0;
-        const pushTimerId = `sink-push-recv:${requestId}`;
-        const refreshPushTimeout = () => this.timerRefresh(pushTimerId, () => {
-          const stream = this.pushStreams.get(requestId);
-          if (stream !== void 0)
-            stream.destroy(new Error("push stream timeout"));
-          const spool2 = this.pushSpools.get(requestId);
-          spool2?.unroll();
-        });
-        const clearPushTimeout = () => this.timerClear(pushTimerId);
-        const readable = new Readable({
-          highWaterMark: chunkCredit > 0 ? chunkCredit * this.options.chunkSize : 16 * 1024,
-          read: (_size) => {
-            if (!creditState || !this.pushSpools.has(requestId))
-              return;
-            const creditToGrant = Math.max(0, creditState.chunksReceived + chunkCredit - creditState.creditGranted);
-            if (creditToGrant > 0) {
-              creditState.creditGranted += creditToGrant;
-              const creditMsg = this.msg.makeSinkPushCredit(requestId, name, creditToGrant, this.options.id, sender);
-              const encoded = this.codec.encode(creditMsg);
-              this.publishToTopic(responseTopic, encoded, { qos: options.qos ?? 2 }).catch((err) => {
-                this.error(err, `sending credit for push "${name}" failed`);
-              });
-              refreshPushTimeout();
-            }
-          }
-        });
-        this.pushStreams.set(requestId, readable);
-        reqSpool.roll(() => {
-          this.pushStreams.delete(requestId);
-        });
-        readable.once("error", () => {
-        });
-        let streamEnded = false;
-        this.onResponse.set(`sink-push-chunk:${requestId}`, async (chunkParsed) => {
-          if (streamEnded)
-            return;
-          if (chunkParsed.error !== void 0) {
-            streamEnded = true;
-            readable.destroy(new Error(chunkParsed.error));
-          } else {
-            refreshPushTimeout();
-            if (chunkParsed.chunk !== void 0) {
-              if (creditState)
-                creditState.chunksReceived++;
-              readable.push(chunkParsed.chunk);
-            }
-            if (chunkParsed.final) {
-              streamEnded = true;
-              readable.push(null);
-            }
-          }
-        });
-        reqSpool.roll(() => {
-          this.onResponse.delete(`sink-push-chunk:${requestId}`);
-        });
-        refreshPushTimeout();
-        reqSpool.roll(() => {
-          clearPushTimeout();
-        });
-        const promise = streamToBuffer(readable);
-        const streamDone = new Promise((resolve, reject) => {
-          readable.once("end", () => {
-            resolve();
-          });
-          readable.once("error", (err) => {
-            reject(err);
-          });
-        });
-        streamDone.catch(() => {
-        });
-        const info = {
-          sender,
-          stream: readable,
-          buffer: promise
-        };
-        if (receiver)
-          info.receiver = receiver;
-        if (authenticated !== void 0)
-          info.authenticated = authenticated;
-        if (request.meta)
-          info.meta = request.meta;
-        makeMutuallyExclusiveFields(info, "stream", "buffer");
-        await sendResponse(void 0, true);
-        await callback(...params, info);
-        await streamDone;
-        try {
-          await sendResponse();
-        } catch (err2) {
-          this.error(ensureError(err2), `sending terminal response for sink "${name}" failed`);
-        }
-      } catch (err) {
-        const error = ensureError(err, `handler for sink "${name}" failed`);
-        this.error(error);
-        await sendResponse(error.message).catch(() => {
-        });
-      } finally {
-        const stream = this.pushStreams.get(requestId);
-        if (stream !== void 0 && !stream.destroyed)
-          stream.destroy();
-        await reqSpool.unroll();
-      }
-    });
-    spool.roll(() => {
-      this.onRequest.delete(`sink-push-request:${name}`);
-    });
-    await this.subscribeTopicAndSpool(spool, topicReqB, options);
-    await this.subscribeTopicAndSpool(spool, topicReqD, options);
-    return this.makeRegistration(spool, "sink", name, `sink-push-request:${name}`);
-  }
-  async push(nameOrConfig, ...args) {
-    let name;
-    let data;
-    let params;
-    let receiver;
-    let options = {};
-    let meta;
-    if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
-      name = nameOrConfig.name;
-      data = nameOrConfig.data;
-      params = nameOrConfig.params;
-      receiver = nameOrConfig.receiver;
-      options = nameOrConfig.options ?? {};
-      meta = nameOrConfig.meta;
-    } else {
-      name = nameOrConfig;
-      data = args[0];
-      params = args.slice(1);
-    }
-    if (!(data instanceof Readable) && !(data instanceof Uint8Array))
-      throw new Error("invalid data type: expected Readable or Uint8Array");
-    const spool = new Spool();
-    let requestId = nanoid();
-    while (this.onResponse.has(`sink-push-response:${requestId}`) || this.onResponse.has(`sink-push-credit:${requestId}`))
-      requestId = nanoid();
-    const responseTopic = this.options.topicMake(name, "sink-push-response", this.options.id);
-    await this.subscribeTopicAndSpool(spool, responseTopic, { qos: options.qos ?? 2 });
-    const abortController = new AbortController();
-    const abortSignal = abortController.signal;
-    if (data instanceof Readable) {
-      const stream = data;
-      abortSignal.addEventListener("abort", () => {
-        if (!stream.destroyed)
-          stream.destroy(ensureError(abortSignal.reason));
-      }, { once: true });
-    }
-    const pushTimerId = `sink-push-send:${requestId}`;
-    const refreshTimeout = () => this.timerRefresh(pushTimerId, () => {
-      const error = new Error(`push to sink "${name}" timed out`);
-      abortController.abort(error);
-      spool.unroll();
-    });
-    spool.roll(() => {
-      this.timerClear(pushTimerId);
-    });
-    refreshTimeout();
-    let initialCredit;
-    let creditGate;
-    let remoteError = false;
-    let pushAcked = false;
-    let pushFinalized = false;
-    let pushFinalizeResolve;
-    let pushFinalizeReject;
-    const pushFinalize = new Promise((resolve, reject) => {
-      pushFinalizeResolve = resolve;
-      pushFinalizeReject = reject;
-    });
-    pushFinalize.catch(() => {
-    });
-    try {
-      await new Promise((resolve, reject) => {
-        const onAbort = () => {
-          reject(abortSignal.reason);
-        };
-        abortSignal.addEventListener("abort", onAbort, { once: true });
-        spool.roll(() => {
-          abortSignal.removeEventListener("abort", onAbort);
-        });
-        this.onResponse.set(`sink-push-response:${requestId}`, (response) => {
-          if (response.error)
-            reject(new Error(response.error));
-          else {
-            if (response.sender)
-              receiver = response.sender;
-            initialCredit = response.credit;
-            pushAcked = true;
-            resolve();
-          }
-        });
-        spool.roll(() => {
-          this.onResponse.delete(`sink-push-response:${requestId}`);
-        });
-        const auth = this.authenticate();
-        const metaStore = this.metaStore(meta);
-        const request = this.msg.makeSinkPushRequest(requestId, name, params, this.options.id, receiver, auth, metaStore);
-        const message = this.codec.encode(request);
-        const requestTopic = this.options.topicMake(name, "sink-push-request", receiver);
-        run(`publish push request as MQTT message to topic "${requestTopic}"`, spool, () => this.publishToTopic(requestTopic, message, { qos: 2, ...options })).catch((err) => {
-          reject(err);
-        });
-      });
-      this.onResponse.set(`sink-push-response:${requestId}`, (response) => {
-        if (response.error) {
-          remoteError = true;
-          pushFinalizeReject(new Error(response.error));
-          abortController.abort(new Error(response.error));
-        } else if (pushAcked && !pushFinalized) {
-          pushFinalized = true;
-          pushFinalizeResolve();
-        }
-      });
-      if (initialCredit !== void 0 && initialCredit > 0)
-        creditGate = new CreditGate(initialCredit);
-      if (creditGate) {
-        const gate = creditGate;
-        spool.roll(() => {
-          gate.abort();
-        });
-        this.onResponse.set(`sink-push-credit:${requestId}`, (response) => {
-          gate.replenish(response.credit);
-          refreshTimeout();
-        });
-        spool.roll(() => {
-          this.onResponse.delete(`sink-push-credit:${requestId}`);
-        });
-      }
-      const chunkTopic = this.options.topicMake(name, "sink-push-request", receiver);
-      const sendChunk = async (chunk, error, final) => {
-        refreshTimeout();
-        const chunkMsg = this.msg.makeSinkPushChunk(requestId, name, chunk, error, final, this.options.id, receiver);
-        const message = this.codec.encode(chunkMsg);
-        await this.publishToTopic(chunkTopic, message, { qos: 2, ...options });
-      };
-      if (data instanceof Readable)
-        await sendStreamAsChunks(data, this.options.chunkSize, sendChunk, creditGate, abortSignal);
-      else if (data instanceof Uint8Array)
-        await sendBufferAsChunks(data, this.options.chunkSize, sendChunk, creditGate, abortSignal);
-      if (!pushFinalized) {
-        await new Promise((resolve, reject) => {
-          const onAbort = () => {
-            reject(abortSignal.reason);
-          };
-          abortSignal.addEventListener("abort", onAbort, { once: true });
-          pushFinalize.then(resolve, reject).finally(() => {
-            abortSignal.removeEventListener("abort", onAbort);
-          });
-        });
-      }
-    } catch (err) {
-      const error = ensureError(err);
-      abortController.abort(error);
-      if (pushAcked && !remoteError) {
-        const chunkTopic = this.options.topicMake(name, "sink-push-request", receiver);
-        const chunkMsg = this.msg.makeSinkPushChunk(requestId, name, void 0, error.message, true, this.options.id, receiver);
-        const message = this.codec.encode(chunkMsg);
-        await this.publishToTopic(chunkTopic, message, { qos: 2, ...options }).catch(() => {
-        });
-      }
-      throw err;
-    } finally {
-      await spool.unroll();
-    }
-  }
-}
-class MQTTp extends SinkTrait {
-}
-export {
-  MQTTp as default
+var Msg = class {
+	makeEventEmission(id, name, params, sender, receiver, auth, meta) {
+		return new EventEmission(id, name, params, sender, receiver, auth, meta);
+	}
+	makeServiceCallRequest(id, name, params, sender, receiver, auth, meta) {
+		return new ServiceCallRequest(id, name, params, sender, receiver, auth, meta);
+	}
+	makeServiceCallResponse(id, result, error, sender, receiver) {
+		return new ServiceCallResponse(id, result, error, sender, receiver);
+	}
+	makeSinkPushRequest(id, name, params, sender, receiver, auth, meta) {
+		return new SinkPushRequest(id, name, params, sender, receiver, auth, meta);
+	}
+	makeSinkPushResponse(id, name, error, sender, receiver, credit) {
+		return new SinkPushResponse(id, name, error, sender, receiver, credit);
+	}
+	makeSinkPushChunk(id, name, chunk, error, final, sender, receiver) {
+		return new SinkPushChunk(id, name, chunk, error, final, sender, receiver);
+	}
+	makeSinkPushCredit(id, name, credit, sender, receiver) {
+		return new SinkPushCredit(id, name, credit, sender, receiver);
+	}
+	makeSourceFetchRequest(id, name, params, sender, receiver, auth, meta, credit) {
+		return new SourceFetchRequest(id, name, params, sender, receiver, auth, meta, credit);
+	}
+	makeSourceFetchResponse(id, name, error, sender, receiver, meta) {
+		return new SourceFetchResponse(id, name, error, sender, receiver, meta);
+	}
+	makeSourceFetchChunk(id, name, chunk, error, final, sender, receiver) {
+		return new SourceFetchChunk(id, name, chunk, error, final, sender, receiver);
+	}
+	makeSourceFetchCredit(id, name, credit, sender, receiver) {
+		return new SourceFetchCredit(id, name, credit, sender, receiver);
+	}
+	parse(obj) {
+		if (typeof obj !== "object" || obj === null) throw new Error("invalid argument: not an object");
+		if (typeof obj.version !== "string") throw new Error("invalid object: missing or invalid \"version\" field");
+		const match = obj.version.match(/^MQTT\+\/(\d+\.\d+)$/);
+		if ((match !== null ? versionToNum(match[1]) : 0) !== version) throw new Error(`protocol version mismatch (expected version 1.4, got version ${obj.version})`);
+		const parseObject = (obj, name, schema) => {
+			const res = v.safeParse(schema, obj);
+			if (!res.success) {
+				const issues = res.issues.map((issue) => issue.message).join("; ");
+				throw new Error(`invalid ${name} object: ${issues}`);
+			}
+			return res.output;
+		};
+		if (typeof obj.type !== "string") throw new Error("invalid object: missing or invalid \"type\" field");
+		if (obj.type === "event-emission") {
+			const out = parseObject(obj, "EventEmission", EventEmissionSchema);
+			return this.makeEventEmission(out.id, out.name, out.params, out.sender, out.receiver, out.auth, out.meta);
+		} else if (obj.type === "service-call-request") {
+			const out = parseObject(obj, "ServiceCallRequest", ServiceCallRequestSchema);
+			return this.makeServiceCallRequest(out.id, out.name, out.params, out.sender, out.receiver, out.auth, out.meta);
+		} else if (obj.type === "service-call-response") {
+			const out = parseObject(obj, "ServiceCallResponse", ServiceCallResponseSchema);
+			return this.makeServiceCallResponse(out.id, out.result, out.error, out.sender, out.receiver);
+		} else if (obj.type === "sink-push-request") {
+			const out = parseObject(obj, "SinkPushRequest", SinkPushRequestSchema);
+			return this.makeSinkPushRequest(out.id, out.name, out.params, out.sender, out.receiver, out.auth, out.meta);
+		} else if (obj.type === "sink-push-response") {
+			const out = parseObject(obj, "SinkPushResponse", SinkPushResponseSchema);
+			return this.makeSinkPushResponse(out.id, out.name, out.error, out.sender, out.receiver, out.credit);
+		} else if (obj.type === "sink-push-chunk") {
+			const out = parseObject(obj, "SinkPushChunk", SinkPushChunkSchema);
+			return this.makeSinkPushChunk(out.id, out.name, out.chunk, out.error, out.final, out.sender, out.receiver);
+		} else if (obj.type === "sink-push-credit") {
+			const out = parseObject(obj, "SinkPushCredit", SinkPushCreditSchema);
+			return this.makeSinkPushCredit(out.id, out.name, out.credit, out.sender, out.receiver);
+		} else if (obj.type === "source-fetch-request") {
+			const out = parseObject(obj, "SourceFetchRequest", SourceFetchRequestSchema);
+			return this.makeSourceFetchRequest(out.id, out.name, out.params, out.sender, out.receiver, out.auth, out.meta, out.credit);
+		} else if (obj.type === "source-fetch-response") {
+			const out = parseObject(obj, "SourceFetchResponse", SourceFetchResponseSchema);
+			return this.makeSourceFetchResponse(out.id, out.name, out.error, out.sender, out.receiver, out.meta);
+		} else if (obj.type === "source-fetch-chunk") {
+			const out = parseObject(obj, "SourceFetchChunk", SourceFetchChunkSchema);
+			return this.makeSourceFetchChunk(out.id, out.name, out.chunk, out.error, out.final, out.sender, out.receiver);
+		} else if (obj.type === "source-fetch-credit") {
+			const out = parseObject(obj, "SourceFetchCredit", SourceFetchCreditSchema);
+			return this.makeSourceFetchCredit(out.id, out.name, out.credit, out.sender, out.receiver);
+		} else throw new Error("invalid object: not of any known type");
+	}
+	isRequest(msg) {
+		return msg instanceof EventEmission || msg instanceof ServiceCallRequest || msg instanceof SourceFetchRequest || msg instanceof SinkPushRequest;
+	}
+	isResponse(msg) {
+		return msg instanceof ServiceCallResponse || msg instanceof SinkPushResponse || msg instanceof SinkPushChunk || msg instanceof SinkPushCredit || msg instanceof SourceFetchResponse || msg instanceof SourceFetchChunk || msg instanceof SourceFetchCredit;
+	}
+};
+var MsgTrait = class extends EncodeTrait {
+	constructor() {
+		super(...arguments);
+		this.msg = new Msg();
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-trace.js
+var LogEvent = class {
+	constructor(timestamp, level, msg, data) {
+		this.timestamp = timestamp;
+		this.level = level;
+		this.msg = msg;
+		this.data = data;
+	}
+	async resolve() {
+		if (this.msg instanceof Promise) this.msg = await this.msg.catch(() => "<resolve-failed>");
+		if (this.data) {
+			for (const k of Object.keys(this.data)) if (this.data[k] instanceof Promise) this.data[k] = await this.data[k].catch(() => "<resolve-failed>");
+		}
+	}
+	toString() {
+		const timestamp = new Date(this.timestamp);
+		const time = `${timestamp.getFullYear()}-${(timestamp.getMonth() + 1).toString().padStart(2, "0")}-${timestamp.getDate().toString().padStart(2, "0")} ${timestamp.getHours().toString().padStart(2, "0")}:${timestamp.getMinutes().toString().padStart(2, "0")}:${timestamp.getSeconds().toString().padStart(2, "0")}.${timestamp.getMilliseconds().toString().padStart(3, "0")}`;
+		const msg = this.msg instanceof Promise ? "<unresolved>" : this.msg;
+		let extra = "";
+		if (this.data !== void 0) {
+			const data = this.data;
+			extra = ` (${Object.keys(data).map((key) => {
+				const value = data[key] instanceof Promise ? "<unresolved>" : data[key];
+				return `${key}: ${JSONX.stringify(value)}`;
+			}).join(", ")})`;
+		}
+		return `[${time}] ${this.level}: ${msg}${extra}`;
+	}
+};
+var TraceTrait = class extends MsgTrait {
+	constructor() {
+		super(...arguments);
+		this._events = new EventEmitter();
+	}
+	on(...args) {
+		this._events.on(...args);
+	}
+	off(...args) {
+		this._events.off(...args);
+	}
+	emitEvent(...args) {
+		if (this._events.listenerCount(args[0]) === 0) return false;
+		return this._events.emit(...args);
+	}
+	log(level, msg, data) {
+		const event = new LogEvent(Date.now(), level, msg, data);
+		this.emitEvent("log", event);
+	}
+	error(error, msg) {
+		let err = error;
+		if (msg !== void 0) err = new Error(`${msg}: ${error.message}`, { cause: error });
+		this.emitEvent("error", err);
+		this.log("error", err.message);
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-base.js
+var BaseTrait = class extends TraceTrait {
+	constructor(mqtt, options = {}) {
+		super(options);
+		this.onRequest = /* @__PURE__ */ new Map();
+		this.onResponse = /* @__PURE__ */ new Map();
+		if (mqtt === null) {
+			this.log("info", "establishing proxy MQTT client");
+			mqtt = new Proxy({}, { get(_target, prop, _receiver) {
+				if (prop === "isFakeProxy") return true;
+				else if (typeof prop === "string" && [
+					"on",
+					"off",
+					"once"
+				].includes(prop)) return () => {};
+				else return () => {
+					throw new Error(`Underlying MQTT operation "${String(prop)}" called on a null MQTT client -- only MQTT+ "emit({ ..., dry: true })" is supported in this special operation mode`);
+				};
+			} });
+		}
+		this.mqtt = mqtt;
+		this.log("info", "hooking into MQTT client");
+		this.messageHandler = (topic, message, packet) => {
+			let input;
+			if (this.options.codec === "json") input = message.toString();
+			else if (this.options.codec === "cbor") input = Buffer.isBuffer(message) ? new Uint8Array(message.buffer, message.byteOffset, message.byteLength) : message;
+			else throw new Error("invalid codec configured");
+			this._onMessage(topic, input, packet);
+		};
+		this.mqtt.on("message", this.messageHandler);
+	}
+	async destroy() {
+		this.log("info", "un-hooking from MQTT client");
+		this.mqtt.off("message", this.messageHandler);
+		this.onRequest.clear();
+		this.onResponse.clear();
+	}
+	makeRegistration(spool, kind, name, key) {
+		return { destroy: async () => {
+			if (!this.onRequest.has(key)) throw new Error(`destroy: ${kind} "${name}" not registered`);
+			await spool.unroll(false)?.catch((err) => {
+				const error = ensureError(err, `destroy: ${kind} "${name}" failed to cleanup`);
+				this.error(error);
+				throw error;
+			});
+		} };
+	}
+	async subscribeTopic(topic, options = {}) {
+		this.log("info", `subscribing to MQTT topic "${topic}"`);
+		return new Promise((resolve, reject) => {
+			this.mqtt.subscribe(topic, {
+				qos: 2,
+				...options
+			}, (err, _granted) => {
+				if (err) {
+					this.error(err, `subscribing to MQTT topic "${topic}" failed`);
+					reject(err);
+				} else resolve();
+			});
+		});
+	}
+	async unsubscribeTopic(topic) {
+		this.log("info", `unsubscribing from MQTT topic "${topic}"`);
+		return new Promise((resolve, reject) => {
+			this.mqtt.unsubscribe(topic, (err, _packet) => {
+				if (err) {
+					this.error(err, `unsubscribing from MQTT topic "${topic}" failed`);
+					reject(err);
+				} else resolve();
+			});
+		});
+	}
+	async publishToTopic(topic, message, options = {}) {
+		if (typeof message === "string") this.log("info", `publishing to MQTT topic "${topic}" (type: string, length: ${message.length} chars)`);
+		else this.log("info", `publishing to MQTT topic "${topic}" (type: buffer, length: ${message.byteLength} bytes)`);
+		const messageOnDemand = new PLazy((resolve, reject) => {
+			let parsed;
+			try {
+				const payload = this.codec.decode(message);
+				parsed = this.msg.parse(payload);
+			} catch (err) {
+				return reject(err);
+			}
+			resolve(parsed);
+		});
+		this.log("debug", `publishing to MQTT topic "${topic}"`, { message: messageOnDemand });
+		return new Promise((resolve, reject) => {
+			const messageData = typeof message === "string" ? message : Buffer.from(message.buffer, message.byteOffset, message.byteLength);
+			this.mqtt.publish(topic, messageData, options, (err) => {
+				if (err) {
+					this.error(err, `publishing to MQTT topic "${topic}" failed`);
+					reject(err);
+				} else resolve();
+			});
+		});
+	}
+	_onMessage(topic, data, _packet) {
+		const topicMatch = this.options.topicMatch(topic);
+		if (topicMatch === null) return;
+		if (typeof data === "string") this.log("info", `received from MQTT topic "${topic}" (type: string, length: ${data.length} chars)`);
+		else this.log("info", `received from MQTT topic "${topic}" (type: buffer, length: ${data.byteLength} bytes)`);
+		let payload;
+		try {
+			payload = this.codec.decode(data);
+		} catch (err) {
+			this.error(ensureError(err, "failed to parse message into object"));
+			return;
+		}
+		let message;
+		try {
+			message = this.msg.parse(payload);
+		} catch (err) {
+			this.error(ensureError(err, "failed to parse object into typed message object"));
+			return;
+		}
+		this.log("debug", `received from MQTT topic "${topic}"`, { message });
+		if (this.msg.isRequest(message)) {
+			const handler = this.onRequest.get(`${message.type}:${message.name}`);
+			if (handler !== void 0) Promise.resolve().then(() => handler(message, topicMatch.name)).catch((err) => {
+				this.error(ensureError(err, `dispatching request message from MQTT topic "${topic}" failed`));
+			});
+		} else if (this.msg.isResponse(message)) {
+			const handler = this.onResponse.get(`${message.type}:${message.id}`);
+			if (handler !== void 0) Promise.resolve().then(() => handler(message, topicMatch.name)).catch((err) => {
+				this.error(ensureError(err, `dispatching response message from MQTT topic "${topic}" failed`));
+			});
+		}
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-subscription.js
+var RefCountedSubscription = class {
+	constructor(subscribeFn, unsubscribeFn, lingerMs = 30 * 1e3) {
+		this.subscribeFn = subscribeFn;
+		this.unsubscribeFn = unsubscribeFn;
+		this.lingerMs = lingerMs;
+		this.counts = /* @__PURE__ */ new Map();
+		this.pending = /* @__PURE__ */ new Map();
+		this.lingers = /* @__PURE__ */ new Map();
+		this.unsubbing = /* @__PURE__ */ new Map();
+	}
+	incrementCount(topic) {
+		const count = this.counts.get(topic) ?? 0;
+		this.counts.set(topic, count + 1);
+		return count;
+	}
+	decrementCount(topic) {
+		const count = this.counts.get(topic);
+		if (count !== void 0) if (count <= 1) {
+			this.counts.delete(topic);
+			return 0;
+		} else {
+			this.counts.set(topic, count - 1);
+			return count - 1;
+		}
+	}
+	async subscribe(topic, options = { qos: 2 }) {
+		const count = this.incrementCount(topic);
+		const linger = this.lingers.get(topic);
+		if (linger) {
+			clearTimeout(linger);
+			this.lingers.delete(topic);
+			return;
+		}
+		if (count === 0) {
+			let resolve;
+			let reject;
+			const deferred = new Promise((res, rej) => {
+				resolve = res;
+				reject = rej;
+			});
+			deferred.catch(() => {});
+			this.pending.set(topic, deferred);
+			const inflight = this.unsubbing.get(topic);
+			if (inflight) await inflight;
+			return this.subscribeFn(topic, options).then(() => {
+				this.pending.delete(topic);
+				resolve();
+			}).catch((err) => {
+				this.pending.delete(topic);
+				this.decrementCount(topic);
+				reject(err);
+				throw err;
+			});
+		} else {
+			const pending = this.pending.get(topic);
+			if (pending) return pending.catch((err) => {
+				this.decrementCount(topic);
+				throw err;
+			});
+		}
+	}
+	async unsubscribe(topic) {
+		if (this.decrementCount(topic) === 0) if (this.lingerMs > 0) {
+			const timer = setTimeout(() => {
+				this.lingers.delete(topic);
+				const promise = this.unsubscribeFn(topic).catch(() => {}).finally(() => {
+					this.unsubbing.delete(topic);
+				});
+				this.unsubbing.set(topic, promise);
+			}, this.lingerMs);
+			this.lingers.set(topic, timer);
+		} else {
+			const promise = this.unsubscribeFn(topic).catch(() => {}).finally(() => {
+				this.unsubbing.delete(topic);
+			});
+			this.unsubbing.set(topic, promise);
+			await promise;
+		}
+	}
+	async flush() {
+		const topics = new Set([
+			...this.counts.keys(),
+			...this.lingers.keys(),
+			...this.pending.keys(),
+			...this.unsubbing.keys()
+		]);
+		for (const timer of this.lingers.values()) clearTimeout(timer);
+		this.lingers.clear();
+		this.counts.clear();
+		await Promise.allSettled([...this.pending.values(), ...this.unsubbing.values()]);
+		await Promise.allSettled([...topics].map((topic) => this.unsubscribeFn(topic).catch(() => {})));
+		this.pending.clear();
+		this.unsubbing.clear();
+	}
+};
+var SubscriptionTrait = class extends BaseTrait {
+	constructor() {
+		super(...arguments);
+		this.subscriptions = new RefCountedSubscription((topic, options) => this.subscribeTopic(topic, options), (topic) => this.unsubscribeTopic(topic));
+	}
+	async subscribeTopicAndSpool(spool, topic, options = {}) {
+		await run(`subscribe to MQTT topic "${topic}"`, spool, () => this.subscriptions.subscribe(topic, {
+			qos: 2,
+			...options
+		}));
+		spool.roll(() => this.subscriptions.unsubscribe(topic));
+	}
+	async destroy() {
+		await this.subscriptions.flush();
+		await super.destroy();
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-timer.js
+var TimerTrait = class extends SubscriptionTrait {
+	constructor() {
+		super(...arguments);
+		this.timers = /* @__PURE__ */ new Map();
+	}
+	async destroy() {
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+		await super.destroy();
+	}
+	timerRefresh(id, onTimeout) {
+		const timer = this.timers.get(id);
+		if (timer !== void 0) clearTimeout(timer);
+		this.timers.set(id, setTimeout(async () => {
+			this.timers.delete(id);
+			try {
+				await onTimeout();
+			} catch (err) {
+				this.error(ensureError(err), `timer "${id}" failed`);
+			}
+		}, this.options.timeout));
+	}
+	timerClear(id) {
+		const timer = this.timers.get(id);
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			this.timers.delete(id);
+		}
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-meta.js
+var MetaTrait = class extends TimerTrait {
+	constructor() {
+		super(...arguments);
+		this._meta = /* @__PURE__ */ new Map();
+	}
+	meta(...args) {
+		const [key, value] = args;
+		if (args.length === 0) return Object.fromEntries(this._meta);
+		else if (args.length === 1) return this._meta.get(key);
+		else if (value === void 0 || value === null) this._meta.delete(key);
+		else this._meta.set(key, value);
+	}
+	metaStore(extra) {
+		const extraEmpty = extra === void 0 || Object.keys(extra).length === 0;
+		if (this._meta.size === 0 && extraEmpty) return void 0;
+		else if (this._meta.size > 0 && extraEmpty) return Object.fromEntries(this._meta);
+		else if (this._meta.size === 0 && !extraEmpty) return extra;
+		else return {
+			...Object.fromEntries(this._meta),
+			...extra
+		};
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-auth.js
+var textEncoder = new TextEncoder();
+var AuthTrait = class extends MetaTrait {
+	constructor() {
+		super(...arguments);
+		this._credential = null;
+		this._tokens = /* @__PURE__ */ new Set();
+	}
+	credential(credential) {
+		if (credential.length === 0) throw new Error("credential must not be empty");
+		const pass = textEncoder.encode(credential);
+		const salt = textEncoder.encode("mqtt-plus");
+		this._credential = pbkdf2.deriveKey(sha256.SHA256, pass, salt, 6e5, 32);
+	}
+	async issue(payload) {
+		if (this._credential === null) throw new Error("credential has to be provided before issuing tokens");
+		if (payload.roles.length === 0) throw new Error("payload.roles must be a non-empty array");
+		if (payload.roles.length > 64) throw new Error("payload.roles must not exceed 64 roles");
+		const jwt = new SignJWT(payload);
+		jwt.setProtectedHeader({
+			alg: "HS256",
+			typ: "JWT"
+		});
+		return await jwt.sign(this._credential);
+	}
+	authenticate(token, remove) {
+		if (token === void 0) {
+			const tokens = Array.from(this._tokens).filter((token) => token.length <= 8192).slice(0, 8);
+			return tokens.length > 0 ? tokens : void 0;
+		} else if (remove === true) this._tokens.delete(token);
+		else {
+			if (token.length > 8192) throw new Error("token must not exceed 8192 characters");
+			if (!this._tokens.has(token) && this._tokens.size >= 8) throw new Error("at most 8 tokens can be authenticated at once");
+			this._tokens.add(token);
+		}
+	}
+	async validateToken(token) {
+		if (this._credential === null) throw new Error("credential has to be provided before validating tokens");
+		return (await jwtVerify(token, this._credential).catch(() => null))?.payload ?? null;
+	}
+	async authenticated(clientId, tokens, option) {
+		let authenticated = false;
+		let mode;
+		let roles;
+		if (typeof option === "string") {
+			mode = "require";
+			roles = [option];
+		} else {
+			mode = option.mode;
+			roles = option.roles;
+		}
+		if (tokens !== void 0) for (const token of tokens.slice(0, 8)) {
+			if (token.length > 8192) continue;
+			const payload = await this.validateToken(token);
+			if (payload === null) continue;
+			if (payload.id && payload.id !== clientId) continue;
+			if (!Array.isArray(payload.roles)) continue;
+			if (payload.roles.length > 64) continue;
+			for (const role of roles) if (payload.roles.includes(role)) {
+				authenticated = true;
+				break;
+			}
+			if (authenticated) break;
+		}
+		if (!authenticated && mode === "optional") authenticated = true;
+		return authenticated;
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-event.js
+var EventTrait = class extends AuthTrait {
+	async event(nameOrConfig, ...args) {
+		let name;
+		let callback;
+		let options = {};
+		let share = this.options.share;
+		let auth;
+		if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
+			name = nameOrConfig.name;
+			callback = nameOrConfig.callback;
+			options = nameOrConfig.options ?? {};
+			share = nameOrConfig.share ?? this.options.share;
+			auth = nameOrConfig.auth;
+		} else {
+			name = nameOrConfig;
+			callback = args[0];
+		}
+		const spool = new Spool();
+		if (this.onRequest.has(`event-emission:${name}`)) throw new Error(`event: event "${name}" already registered`);
+		const topicS = share !== "" ? `$share/${share}/${name}` : name;
+		const topicB = this.options.topicMake(topicS, "event-emission");
+		const topicD = this.options.topicMake(name, "event-emission", this.options.id);
+		this.onRequest.set(`event-emission:${name}`, async (request, topicName) => {
+			const senderId = request.sender;
+			if (senderId === void 0 || senderId === "") throw new Error("invalid request: missing sender");
+			const params = request.params ?? [];
+			const info = { sender: senderId };
+			if (request.receiver) info.receiver = request.receiver;
+			if (request.meta) info.meta = request.meta;
+			try {
+				if (topicName !== request.name) throw new Error(`event name mismatch (topic: "${topicName}", payload: "${request.name}")`);
+				if (auth) info.authenticated = await this.authenticated(senderId, request.auth, auth);
+				if (info.authenticated !== void 0 && !info.authenticated) throw new Error(`event "${name}" failed authentication`);
+				await callback(...params, info);
+			} catch (result) {
+				const error = ensureError(result);
+				this.error(error, `handler for event "${name}" failed`);
+			}
+		});
+		spool.roll(() => {
+			this.onRequest.delete(`event-emission:${name}`);
+		});
+		await this.subscribeTopicAndSpool(spool, topicB, options);
+		await this.subscribeTopicAndSpool(spool, topicD, options);
+		return this.makeRegistration(spool, "event", name, `event-emission:${name}`);
+	}
+	emit(nameOrConfig, ...args) {
+		let name;
+		let params;
+		let receiver;
+		let options = {};
+		let meta;
+		let dry;
+		if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
+			name = nameOrConfig.name;
+			params = nameOrConfig.params;
+			receiver = nameOrConfig.receiver;
+			options = nameOrConfig.options ?? {};
+			meta = nameOrConfig.meta;
+			dry = nameOrConfig.dry;
+		} else {
+			name = nameOrConfig;
+			params = args;
+		}
+		const requestId = nanoid();
+		const auth = this.authenticate();
+		const metaStore = this.metaStore(meta);
+		const request = this.msg.makeEventEmission(requestId, name, params, this.options.id, receiver, auth, metaStore);
+		const message = this.codec.encode(request);
+		const topic = this.options.topicMake(name, "event-emission", receiver);
+		if (dry) return {
+			topic,
+			payload: message,
+			options: {
+				qos: 2,
+				...options
+			}
+		};
+		else this.publishToTopic(topic, message, {
+			qos: 2,
+			...options
+		}).catch((err) => {
+			this.error(err, `emitting event "${name}" failed`);
+		});
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-service.js
+var ServiceTrait = class extends EventTrait {
+	async service(nameOrConfig, ...args) {
+		let name;
+		let callback;
+		let options = {};
+		let share = this.options.share;
+		let auth;
+		if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
+			name = nameOrConfig.name;
+			callback = nameOrConfig.callback;
+			options = nameOrConfig.options ?? {};
+			share = nameOrConfig.share ?? this.options.share;
+			auth = nameOrConfig.auth;
+		} else {
+			name = nameOrConfig;
+			callback = args[0];
+		}
+		const spool = new Spool();
+		if (this.onRequest.has(`service-call-request:${name}`)) throw new Error(`service: service "${name}" already registered`);
+		const topicS = share !== "" ? `$share/${share}/${name}` : name;
+		const topicB = this.options.topicMake(topicS, "service-call-request");
+		const topicD = this.options.topicMake(name, "service-call-request", this.options.id);
+		this.onRequest.set(`service-call-request:${name}`, async (request, topicName) => {
+			const requestId = request.id;
+			const senderId = request.sender;
+			if (senderId === void 0 || senderId === "") throw new Error("invalid request: missing sender");
+			const params = request.params ?? [];
+			const info = { sender: senderId };
+			if (request.receiver) info.receiver = request.receiver;
+			if (request.meta) info.meta = request.meta;
+			try {
+				if (topicName !== request.name) throw new Error(`service name mismatch (topic: "${topicName}", payload: "${request.name}")`);
+				if (auth) info.authenticated = await this.authenticated(senderId, request.auth, auth);
+				if (info.authenticated !== void 0 && !info.authenticated) throw new Error(`service "${name}" failed authentication`);
+				const result = await callback(...params, info);
+				const rpcResponse = this.msg.makeServiceCallResponse(requestId, result, void 0, this.options.id, senderId);
+				const encoded = this.codec.encode(rpcResponse);
+				const topic = this.options.topicMake(name, "service-call-response", senderId);
+				await this.publishToTopic(topic, encoded, { qos: options.qos ?? 2 });
+			} catch (err) {
+				const error = ensureError(err);
+				this.error(error, `handler for service "${name}" failed`);
+				const rpcResponse = this.msg.makeServiceCallResponse(requestId, void 0, error.message, this.options.id, senderId);
+				try {
+					const encoded = this.codec.encode(rpcResponse);
+					const topic = this.options.topicMake(name, "service-call-response", senderId);
+					await this.publishToTopic(topic, encoded, { qos: options.qos ?? 2 });
+				} catch (err2) {
+					this.error(ensureError(err2), `sending error response for service "${name}" failed`);
+				}
+			}
+		});
+		spool.roll(() => {
+			this.onRequest.delete(`service-call-request:${name}`);
+		});
+		await this.subscribeTopicAndSpool(spool, topicB, options);
+		await this.subscribeTopicAndSpool(spool, topicD, options);
+		return this.makeRegistration(spool, "service", name, `service-call-request:${name}`);
+	}
+	async call(nameOrConfig, ...args) {
+		let name;
+		let params;
+		let receiver;
+		let options = {};
+		let meta;
+		if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
+			name = nameOrConfig.name;
+			params = nameOrConfig.params;
+			receiver = nameOrConfig.receiver;
+			options = nameOrConfig.options ?? {};
+			meta = nameOrConfig.meta;
+		} else {
+			name = nameOrConfig;
+			params = args;
+		}
+		const spool = new Spool();
+		let requestId = nanoid();
+		while (this.onResponse.has(`service-call-response:${requestId}`)) requestId = nanoid();
+		const responseTopic = this.options.topicMake(name, "service-call-response", this.options.id);
+		await this.subscribeTopicAndSpool(spool, responseTopic, { qos: options.qos ?? 2 });
+		const timerId = `service-call:${requestId}`;
+		let rejectPromise;
+		const promise = new Promise((resolve, reject) => {
+			rejectPromise = reject;
+			this.timerRefresh(timerId, async () => {
+				await spool.unroll();
+				reject(/* @__PURE__ */ new Error("communication timeout"));
+			});
+			spool.roll(() => {
+				this.timerClear(timerId);
+			});
+			this.onResponse.set(`service-call-response:${requestId}`, async (response) => {
+				await spool.unroll();
+				if (response.error !== void 0) reject(new Error(response.error));
+				else resolve(response.result);
+			});
+			spool.roll(() => {
+				this.onResponse.delete(`service-call-response:${requestId}`);
+			});
+		});
+		const auth = this.authenticate();
+		const metaStore = this.metaStore(meta);
+		const request = this.msg.makeServiceCallRequest(requestId, name, params, this.options.id, receiver, auth, metaStore);
+		const message = this.codec.encode(request);
+		const topic = this.options.topicMake(name, "service-call-request", receiver);
+		try {
+			await run(`publish service request as MQTT message to topic "${topic}"`, spool, () => this.publishToTopic(topic, message, {
+				qos: 2,
+				...options
+			}));
+		} catch (err) {
+			rejectPromise(err);
+			return promise;
+		}
+		return promise;
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-source.js
+var SourceTrait = class extends ServiceTrait {
+	constructor() {
+		super(...arguments);
+		this.sourceCreditGates = /* @__PURE__ */ new Map();
+		this.sourceControllers = /* @__PURE__ */ new Map();
+	}
+	async destroy() {
+		for (const controller of this.sourceControllers.values()) controller.abort(/* @__PURE__ */ new Error("source destroyed"));
+		this.sourceControllers.clear();
+		for (const gate of this.sourceCreditGates.values()) gate.abort();
+		this.sourceCreditGates.clear();
+		await super.destroy();
+	}
+	async source(nameOrConfig, ...args) {
+		let name;
+		let callback;
+		let options = {};
+		let share = this.options.share;
+		let auth;
+		if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
+			name = nameOrConfig.name;
+			callback = nameOrConfig.callback;
+			options = nameOrConfig.options ?? {};
+			share = nameOrConfig.share ?? this.options.share;
+			auth = nameOrConfig.auth;
+		} else {
+			name = nameOrConfig;
+			callback = args[0];
+		}
+		const spool = new Spool();
+		if (this.onRequest.has(`source-fetch-request:${name}`)) throw new Error(`source: source "${name}" already registered`);
+		const topicS = share !== "" ? `$share/${share}/${name}` : name;
+		const topicReqB = this.options.topicMake(topicS, "source-fetch-request");
+		const topicReqD = this.options.topicMake(name, "source-fetch-request", this.options.id);
+		this.onRequest.set(`source-fetch-request:${name}`, async (request, topicName) => {
+			const requestId = request.id;
+			const params = request.params ?? [];
+			const sender = request.sender;
+			if (sender === void 0 || sender === "") throw new Error("invalid request: missing sender");
+			const receiver = request.receiver;
+			const info = { sender };
+			if (receiver) info.receiver = receiver;
+			if (request.meta) info.meta = request.meta;
+			const responseTopic = this.options.topicMake(name, "source-fetch-response", sender);
+			const sendResponse = async (error) => {
+				const metaStore = this.metaStore(info.meta);
+				const response = this.msg.makeSourceFetchResponse(requestId, name, error, this.options.id, sender, metaStore);
+				const message = this.codec.encode(response);
+				await this.publishToTopic(responseTopic, message, { qos: options.qos ?? 2 });
+			};
+			const reqSpool = new Spool();
+			reqSpool.roll(() => {
+				this.onResponse.delete(`source-fetch-credit:${requestId}`);
+				this.sourceControllers.delete(requestId);
+			});
+			const abortController = new AbortController();
+			this.sourceControllers.set(requestId, abortController);
+			const abortSignal = abortController.signal;
+			abortSignal.addEventListener("abort", () => {
+				if (info.stream instanceof Readable && !info.stream.destroyed) info.stream.destroy(ensureError(abortSignal.reason));
+			}, { once: true });
+			const sourceTimerId = `source-fetch-send:${requestId}`;
+			const refreshSourceTimeout = () => this.timerRefresh(sourceTimerId, () => {
+				const error = /* @__PURE__ */ new Error(`source fetch "${name}" timed out`);
+				abortController.abort(error);
+				const gate = this.sourceCreditGates.get(requestId);
+				if (gate !== void 0) {
+					gate.abort();
+					this.sourceCreditGates.delete(requestId);
+				}
+				reqSpool.unroll();
+			});
+			const clearSourceTimeout = () => this.timerClear(sourceTimerId);
+			refreshSourceTimeout();
+			reqSpool.roll(() => {
+				clearSourceTimeout();
+			});
+			const sendChunk = async (chunk, error, final) => {
+				refreshSourceTimeout();
+				const chunkMsg = this.msg.makeSourceFetchChunk(requestId, name, chunk, error, final, this.options.id, sender);
+				const message = this.codec.encode(chunkMsg);
+				await this.publishToTopic(responseTopic, message, { qos: options.qos ?? 2 });
+			};
+			let ackSent = false;
+			let creditGate;
+			let cancelledByFetcher = false;
+			try {
+				if (topicName !== request.name) throw new Error(`source name mismatch (topic: "${topicName}", payload: "${request.name}")`);
+				if (auth) info.authenticated = await this.authenticated(sender, request.auth, auth);
+				if (info.authenticated !== void 0 && !info.authenticated) throw new Error(`source "${name}" failed authentication`);
+				const initialCredit = request.credit;
+				creditGate = initialCredit !== void 0 && initialCredit > 0 ? new CreditGate(initialCredit) : void 0;
+				if (creditGate) {
+					this.sourceCreditGates.set(requestId, creditGate);
+					reqSpool.roll(() => {
+						creditGate.abort();
+						this.sourceCreditGates.delete(requestId);
+					});
+				}
+				this.onResponse.set(`source-fetch-credit:${requestId}`, (creditParsed) => {
+					if (creditParsed.credit === 0) {
+						cancelledByFetcher = true;
+						abortController.abort(/* @__PURE__ */ new Error(`source fetch "${name}" cancelled by fetcher`));
+						return;
+					}
+					if (creditGate) {
+						creditGate.replenish(creditParsed.credit);
+						refreshSourceTimeout();
+					}
+				});
+				await callback(...params, info);
+				if (!(info.stream instanceof Readable) && !(info.buffer instanceof Promise)) throw new Error("handler did not provide data via info.stream or info.buffer fields");
+				if (info.stream instanceof Readable && info.buffer instanceof Promise) throw new Error("handler has set both info.stream and info.buffer fields");
+				await sendResponse();
+				ackSent = true;
+				if (info.stream instanceof Readable) await sendStreamAsChunks(info.stream, this.options.chunkSize, sendChunk, creditGate, abortSignal);
+				else if (info.buffer instanceof Promise) await sendBufferAsChunks(await info.buffer, this.options.chunkSize, sendChunk, creditGate, abortSignal);
+			} catch (err) {
+				const error = ensureError(err, `handler for source "${name}" failed`);
+				abortController.abort(error);
+				if (!cancelledByFetcher) {
+					this.error(error);
+					if (ackSent) await sendChunk(void 0, error.message, true).catch(() => {});
+					else await sendResponse(error.message).catch(() => {});
+				}
+			} finally {
+				await reqSpool.unroll();
+			}
+		});
+		spool.roll(() => {
+			this.onRequest.delete(`source-fetch-request:${name}`);
+		});
+		await this.subscribeTopicAndSpool(spool, topicReqB, options);
+		await this.subscribeTopicAndSpool(spool, topicReqD, options);
+		return this.makeRegistration(spool, "source", name, `source-fetch-request:${name}`);
+	}
+	async fetch(nameOrConfig, ...args) {
+		let name;
+		let params;
+		let receiver;
+		let options = {};
+		let meta;
+		if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
+			name = nameOrConfig.name;
+			params = nameOrConfig.params;
+			receiver = nameOrConfig.receiver;
+			options = nameOrConfig.options ?? {};
+			meta = nameOrConfig.meta;
+		} else {
+			name = nameOrConfig;
+			params = args;
+		}
+		const spool = new Spool();
+		let requestId = nanoid();
+		while (this.onResponse.has(`source-fetch-response:${requestId}`) || this.onResponse.has(`source-fetch-chunk:${requestId}`)) requestId = nanoid();
+		const responseTopic = this.options.topicMake(name, "source-fetch-response", this.options.id);
+		await this.subscribeTopicAndSpool(spool, responseTopic, { qos: options.qos ?? 2 });
+		const chunkCredit = this.options.chunkCredit;
+		let chunksReceived = 0;
+		let creditGranted = chunkCredit;
+		let serverId;
+		let streamEnded = false;
+		const timerId = `source-fetch:${requestId}`;
+		let stream = void 0;
+		const refreshTimeout = () => {
+			this.timerRefresh(timerId, () => {
+				stream?.destroy(/* @__PURE__ */ new Error("communication timeout"));
+				spool.unroll();
+			});
+		};
+		spool.roll(() => {
+			this.timerClear(timerId);
+		});
+		stream = new Readable({
+			highWaterMark: chunkCredit > 0 ? chunkCredit * this.options.chunkSize : 16 * 1024,
+			read: (_size) => {
+				if (chunkCredit <= 0 || !this.onResponse.has(`source-fetch-response:${requestId}`)) return;
+				const targetId = serverId ?? receiver;
+				if (!targetId) return;
+				const creditToGrant = Math.max(0, chunksReceived + chunkCredit - creditGranted);
+				if (creditToGrant > 0) {
+					creditGranted += creditToGrant;
+					const creditMsg = this.msg.makeSourceFetchCredit(requestId, name, creditToGrant, this.options.id, targetId);
+					const encoded = this.codec.encode(creditMsg);
+					const creditTopic = this.options.topicMake(name, "source-fetch-request", targetId);
+					this.publishToTopic(creditTopic, encoded, { qos: options.qos ?? 2 }).catch((err) => {
+						this.error(err, `sending credit for fetch "${name}" failed`);
+					});
+					refreshTimeout();
+				}
+			}
+		});
+		const buffer = streamToBuffer(stream);
+		let metaResolve;
+		const metaP = new Promise((resolve) => {
+			metaResolve = resolve;
+		});
+		spool.roll(() => {
+			metaResolve(void 0);
+		});
+		refreshTimeout();
+		let cancelled = false;
+		const cancelAndUnroll = () => {
+			if (!cancelled && !streamEnded) {
+				cancelled = true;
+				const targetId = serverId ?? receiver;
+				if (targetId) {
+					const cancelMsg = this.msg.makeSourceFetchCredit(requestId, name, 0, this.options.id, targetId);
+					const encoded = this.codec.encode(cancelMsg);
+					const cancelTopic = this.options.topicMake(name, "source-fetch-request", targetId);
+					this.publishToTopic(cancelTopic, encoded, { qos: options.qos ?? 2 }).catch(() => {});
+				}
+			}
+			spool.unroll();
+		};
+		stream.once("close", cancelAndUnroll);
+		stream.once("error", cancelAndUnroll);
+		this.onResponse.set(`source-fetch-response:${requestId}`, (response) => {
+			if (streamEnded) return;
+			if (response.name !== name) {
+				streamEnded = true;
+				stream.destroy(/* @__PURE__ */ new Error(`source name mismatch (expected "${name}", got "${response.name}")`));
+				spool.unroll();
+				return;
+			}
+			if (response.sender) serverId = response.sender;
+			if (response.error) {
+				streamEnded = true;
+				stream.destroy(new Error(response.error));
+				spool.unroll();
+			} else {
+				metaResolve(response.meta);
+				refreshTimeout();
+			}
+		});
+		this.onResponse.set(`source-fetch-chunk:${requestId}`, (response) => {
+			if (streamEnded) return;
+			if (response.error) {
+				streamEnded = true;
+				stream.destroy(new Error(response.error));
+				spool.unroll();
+			} else {
+				refreshTimeout();
+				if (response.chunk !== void 0) {
+					chunksReceived++;
+					stream.push(response.chunk);
+				}
+				if (response.final) {
+					streamEnded = true;
+					stream.push(null);
+					spool.unroll();
+				}
+			}
+		});
+		spool.roll(() => {
+			this.onResponse.delete(`source-fetch-response:${requestId}`);
+			this.onResponse.delete(`source-fetch-chunk:${requestId}`);
+		});
+		const auth = this.authenticate();
+		const metaStore = this.metaStore(meta);
+		const credit = chunkCredit > 0 ? chunkCredit : void 0;
+		const request = this.msg.makeSourceFetchRequest(requestId, name, params, this.options.id, receiver, auth, metaStore, credit);
+		const message = this.codec.encode(request);
+		const topic = this.options.topicMake(name, "source-fetch-request", receiver);
+		run(`publish fetch request as MQTT message to topic "${topic}"`, () => this.publishToTopic(topic, message, {
+			qos: 2,
+			...options
+		})).catch((err) => {
+			stream.destroy(ensureError(err));
+		});
+		const result = {
+			stream,
+			buffer,
+			meta: metaP
+		};
+		makeMutuallyExclusiveFields(result, "stream", "buffer");
+		return result;
+	}
+};
+//#endregion
+//#region dst-stage1/mqtt-plus-sink.js
+var SinkTrait = class extends SourceTrait {
+	constructor() {
+		super(...arguments);
+		this.pushStreams = /* @__PURE__ */ new Map();
+		this.pushSpools = /* @__PURE__ */ new Map();
+	}
+	async destroy() {
+		for (const stream of this.pushStreams.values()) stream.destroy(/* @__PURE__ */ new Error("sink destroyed"));
+		this.pushStreams.clear();
+		for (const spool of this.pushSpools.values()) await spool.unroll();
+		this.pushSpools.clear();
+		await super.destroy();
+	}
+	async sink(nameOrConfig, ...args) {
+		let name;
+		let callback;
+		let options = {};
+		let share = this.options.share;
+		let auth;
+		if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
+			name = nameOrConfig.name;
+			callback = nameOrConfig.callback;
+			options = nameOrConfig.options ?? {};
+			share = nameOrConfig.share ?? this.options.share;
+			auth = nameOrConfig.auth;
+		} else {
+			name = nameOrConfig;
+			callback = args[0];
+		}
+		const spool = new Spool();
+		if (this.onRequest.has(`sink-push-request:${name}`)) throw new Error(`sink: sink "${name}" already registered`);
+		const topicS = share !== "" ? `$share/${share}/${name}` : name;
+		const topicReqB = this.options.topicMake(topicS, "sink-push-request");
+		const topicReqD = this.options.topicMake(name, "sink-push-request", this.options.id);
+		this.onRequest.set(`sink-push-request:${name}`, async (request, topicName) => {
+			const requestId = request.id;
+			const params = request.params ?? [];
+			const sender = request.sender;
+			if (sender === void 0 || sender === "") throw new Error("invalid request: missing sender");
+			const receiver = request.receiver;
+			const responseTopic = this.options.topicMake(name, "sink-push-response", sender);
+			const chunkCredit = this.options.chunkCredit;
+			const sendResponse = async (error, withCredit = false) => {
+				const credit = error === void 0 && withCredit && chunkCredit > 0 ? chunkCredit : void 0;
+				const response = this.msg.makeSinkPushResponse(requestId, name, error, this.options.id, sender, credit);
+				const message = this.codec.encode(response);
+				await this.publishToTopic(responseTopic, message, { qos: options.qos ?? 2 });
+			};
+			const reqSpool = new Spool();
+			this.pushSpools.set(requestId, reqSpool);
+			reqSpool.roll(() => {
+				this.pushSpools.delete(requestId);
+			});
+			try {
+				if (topicName !== request.name) throw new Error(`sink name mismatch (topic: "${topicName}", payload: "${request.name}")`);
+				let authenticated = void 0;
+				if (auth) authenticated = await this.authenticated(sender, request.auth, auth);
+				if (authenticated !== void 0 && !authenticated) throw new Error(`sink "${name}" failed authentication`);
+				const creditState = chunkCredit > 0 ? {
+					chunksReceived: 0,
+					creditGranted: chunkCredit
+				} : void 0;
+				const pushTimerId = `sink-push-recv:${requestId}`;
+				const refreshPushTimeout = () => this.timerRefresh(pushTimerId, () => {
+					if (streamEnded) return;
+					const stream = this.pushStreams.get(requestId);
+					if (stream !== void 0) stream.destroy(/* @__PURE__ */ new Error("push stream timeout"));
+					this.pushSpools.get(requestId)?.unroll();
+				});
+				const clearPushTimeout = () => this.timerClear(pushTimerId);
+				const readable = new Readable({
+					highWaterMark: chunkCredit > 0 ? chunkCredit * this.options.chunkSize : 16 * 1024,
+					read: (_size) => {
+						if (!creditState || !this.pushSpools.has(requestId)) return;
+						const creditToGrant = Math.max(0, creditState.chunksReceived + chunkCredit - creditState.creditGranted);
+						if (creditToGrant > 0) {
+							creditState.creditGranted += creditToGrant;
+							const creditMsg = this.msg.makeSinkPushCredit(requestId, name, creditToGrant, this.options.id, sender);
+							const encoded = this.codec.encode(creditMsg);
+							this.publishToTopic(responseTopic, encoded, { qos: options.qos ?? 2 }).catch((err) => {
+								this.error(err, `sending credit for push "${name}" failed`);
+							});
+							refreshPushTimeout();
+						}
+					}
+				});
+				this.pushStreams.set(requestId, readable);
+				reqSpool.roll(() => {
+					this.pushStreams.delete(requestId);
+				});
+				readable.once("error", () => {});
+				let streamEnded = false;
+				this.onResponse.set(`sink-push-chunk:${requestId}`, async (chunkParsed) => {
+					if (streamEnded) return;
+					if (chunkParsed.error !== void 0) {
+						streamEnded = true;
+						clearPushTimeout();
+						readable.destroy(new Error(chunkParsed.error));
+					} else {
+						refreshPushTimeout();
+						if (chunkParsed.chunk !== void 0) {
+							if (creditState) creditState.chunksReceived++;
+							readable.push(chunkParsed.chunk);
+						}
+						if (chunkParsed.final) {
+							streamEnded = true;
+							clearPushTimeout();
+							readable.push(null);
+						}
+					}
+				});
+				reqSpool.roll(() => {
+					this.onResponse.delete(`sink-push-chunk:${requestId}`);
+				});
+				refreshPushTimeout();
+				reqSpool.roll(() => {
+					clearPushTimeout();
+				});
+				const promise = streamToBuffer(readable);
+				const streamDone = new Promise((resolve, reject) => {
+					readable.once("end", () => {
+						resolve();
+					});
+					readable.once("error", (err) => {
+						reject(err);
+					});
+				});
+				streamDone.catch(() => {});
+				const info = {
+					sender,
+					stream: readable,
+					buffer: promise
+				};
+				if (receiver) info.receiver = receiver;
+				if (authenticated !== void 0) info.authenticated = authenticated;
+				if (request.meta) info.meta = request.meta;
+				makeMutuallyExclusiveFields(info, "stream", "buffer");
+				await sendResponse(void 0, true);
+				await callback(...params, info);
+				if (readable.readableFlowing !== true && !readable.destroyed) readable.resume();
+				await streamDone;
+				try {
+					await sendResponse();
+				} catch (err2) {
+					this.error(ensureError(err2), `sending terminal response for sink "${name}" failed`);
+				}
+			} catch (err) {
+				const error = ensureError(err, `handler for sink "${name}" failed`);
+				this.error(error);
+				await sendResponse(error.message).catch(() => {});
+			} finally {
+				const stream = this.pushStreams.get(requestId);
+				if (stream !== void 0 && !stream.destroyed) stream.destroy();
+				await reqSpool.unroll();
+			}
+		});
+		spool.roll(() => {
+			this.onRequest.delete(`sink-push-request:${name}`);
+		});
+		await this.subscribeTopicAndSpool(spool, topicReqB, options);
+		await this.subscribeTopicAndSpool(spool, topicReqD, options);
+		return this.makeRegistration(spool, "sink", name, `sink-push-request:${name}`);
+	}
+	async push(nameOrConfig, ...args) {
+		let name;
+		let data;
+		let params;
+		let receiver;
+		let options = {};
+		let meta;
+		if (typeof nameOrConfig === "object" && nameOrConfig !== null) {
+			name = nameOrConfig.name;
+			data = nameOrConfig.data;
+			params = nameOrConfig.params;
+			receiver = nameOrConfig.receiver;
+			options = nameOrConfig.options ?? {};
+			meta = nameOrConfig.meta;
+		} else {
+			name = nameOrConfig;
+			data = args[0];
+			params = args.slice(1);
+		}
+		if (!(data instanceof Readable) && !(data instanceof Uint8Array)) throw new Error("invalid data type: expected Readable or Uint8Array");
+		const spool = new Spool();
+		let requestId = nanoid();
+		while (this.onResponse.has(`sink-push-response:${requestId}`) || this.onResponse.has(`sink-push-credit:${requestId}`)) requestId = nanoid();
+		const responseTopic = this.options.topicMake(name, "sink-push-response", this.options.id);
+		await this.subscribeTopicAndSpool(spool, responseTopic, { qos: options.qos ?? 2 });
+		const abortController = new AbortController();
+		const abortSignal = abortController.signal;
+		if (data instanceof Readable) {
+			const stream = data;
+			abortSignal.addEventListener("abort", () => {
+				if (!stream.destroyed) stream.destroy(ensureError(abortSignal.reason));
+			}, { once: true });
+		}
+		const pushTimerId = `sink-push-send:${requestId}`;
+		const refreshTimeout = () => this.timerRefresh(pushTimerId, () => {
+			const error = /* @__PURE__ */ new Error(`push to sink "${name}" timed out`);
+			abortController.abort(error);
+			spool.unroll();
+		});
+		spool.roll(() => {
+			this.timerClear(pushTimerId);
+		});
+		refreshTimeout();
+		let initialCredit;
+		let creditGate;
+		let remoteError = false;
+		let pushAcked = false;
+		let pushFinalized = false;
+		let pushDataFinalSent = false;
+		let pushFinalizeResolve;
+		let pushFinalizeReject;
+		const pushFinalize = new Promise((resolve, reject) => {
+			pushFinalizeResolve = resolve;
+			pushFinalizeReject = reject;
+		});
+		pushFinalize.catch(() => {});
+		try {
+			await new Promise((resolve, reject) => {
+				const onAbort = () => {
+					reject(abortSignal.reason);
+				};
+				abortSignal.addEventListener("abort", onAbort, { once: true });
+				spool.roll(() => {
+					abortSignal.removeEventListener("abort", onAbort);
+				});
+				this.onResponse.set(`sink-push-response:${requestId}`, (response) => {
+					if (response.error) reject(new Error(response.error));
+					else {
+						if (response.sender) receiver = response.sender;
+						initialCredit = response.credit;
+						pushAcked = true;
+						resolve();
+					}
+				});
+				spool.roll(() => {
+					this.onResponse.delete(`sink-push-response:${requestId}`);
+				});
+				const auth = this.authenticate();
+				const metaStore = this.metaStore(meta);
+				const request = this.msg.makeSinkPushRequest(requestId, name, params, this.options.id, receiver, auth, metaStore);
+				const message = this.codec.encode(request);
+				const requestTopic = this.options.topicMake(name, "sink-push-request", receiver);
+				run(`publish push request as MQTT message to topic "${requestTopic}"`, spool, () => this.publishToTopic(requestTopic, message, {
+					qos: 2,
+					...options
+				})).catch((err) => {
+					reject(err);
+				});
+			});
+			this.onResponse.set(`sink-push-response:${requestId}`, (response) => {
+				if (response.error) {
+					remoteError = true;
+					pushFinalizeReject(new Error(response.error));
+					abortController.abort(new Error(response.error));
+				} else if (pushAcked && !pushFinalized) {
+					pushFinalized = true;
+					pushFinalizeResolve();
+				}
+			});
+			if (initialCredit !== void 0 && initialCredit > 0) creditGate = new CreditGate(initialCredit);
+			if (creditGate) {
+				const gate = creditGate;
+				spool.roll(() => {
+					gate.abort();
+				});
+				this.onResponse.set(`sink-push-credit:${requestId}`, (response) => {
+					gate.replenish(response.credit);
+					refreshTimeout();
+				});
+				spool.roll(() => {
+					this.onResponse.delete(`sink-push-credit:${requestId}`);
+				});
+			}
+			const chunkTopic = this.options.topicMake(name, "sink-push-request", receiver);
+			const sendChunk = async (chunk, error, final) => {
+				refreshTimeout();
+				const chunkMsg = this.msg.makeSinkPushChunk(requestId, name, chunk, error, final, this.options.id, receiver);
+				const message = this.codec.encode(chunkMsg);
+				await this.publishToTopic(chunkTopic, message, {
+					qos: 2,
+					...options
+				});
+				if (error === void 0 && final) pushDataFinalSent = true;
+			};
+			if (data instanceof Readable) await sendStreamAsChunks(data, this.options.chunkSize, sendChunk, creditGate, abortSignal);
+			else if (data instanceof Uint8Array) await sendBufferAsChunks(data, this.options.chunkSize, sendChunk, creditGate, abortSignal);
+			if (!pushFinalized) await new Promise((resolve, reject) => {
+				const onAbort = () => {
+					reject(abortSignal.reason);
+				};
+				abortSignal.addEventListener("abort", onAbort, { once: true });
+				pushFinalize.then(resolve, reject).finally(() => {
+					abortSignal.removeEventListener("abort", onAbort);
+				});
+			});
+		} catch (err) {
+			const error = ensureError(err);
+			abortController.abort(error);
+			if (pushAcked && !remoteError && !pushDataFinalSent) {
+				const chunkTopic = this.options.topicMake(name, "sink-push-request", receiver);
+				const chunkMsg = this.msg.makeSinkPushChunk(requestId, name, void 0, error.message, true, this.options.id, receiver);
+				const message = this.codec.encode(chunkMsg);
+				await this.publishToTopic(chunkTopic, message, {
+					qos: 2,
+					...options
+				}).catch(() => {});
+			}
+			throw err;
+		} finally {
+			await spool.unroll();
+		}
+	}
 };
+//#endregion
+//#region dst-stage1/mqtt-plus.js
+var MQTTp = class extends SinkTrait {};
+//#endregion
+export { MQTTp as default };