mqtt-plus 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 ChangeLog
 =========
 
+1.3.0 (2026-02-07)
+------------------
+
+- IMPROVEMENT: add credit-based flow control to sink/source facility
+- IMPROVEMENT: make "buffer" and "stream" fields always mutual-exlusive
+- IMPROVEMENT: provide version field in protocol messages
+
+1.2.1 (2026-02-07)
+------------------
+
+- REFACTOR: use a reference counting subscription class
+- CLEANUP: improve internal validation logic
+- CLEANUP: various code cleanups
+
 1.2.0 (2026-02-06)
 ------------------
 

package/dst-stage1/mqtt-plus-auth.js

@@ -41,9 +41,9 @@ export class AuthTrait extends MetaTrait {
         if (credential.length === 0)
             throw new Error("credential must not be empty");
         /*  use a derived key with minimum length of 32 for JWT HS256  */
-        const pw = new TextEncoder().encode(credential);
-        const st = new TextEncoder().encode("mqtt-plus");
-        this._credential = pbkdf2.deriveKey(sha256.SHA256, pw, st, 100000, 32);
+        const pass = new TextEncoder().encode(credential);
+        const salt = new TextEncoder().encode("mqtt-plus");
+        this._credential = pbkdf2.deriveKey(sha256.SHA256, pass, salt, 600000, 32);
     }
     /*  issue client-side token on server-side  */
     async issue(payload) {
@@ -93,6 +93,10 @@ export class AuthTrait extends MetaTrait {
                     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;

package/dst-stage1/mqtt-plus-base.js

@@ -37,8 +37,14 @@ export class BaseTrait extends TraceTrait {
                 get(_target, prop, _receiver) {
                     if (prop === "isFakeProxy")
                         return true;
-                    else
+                    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");
+                        };
                 }
             });
         }

package/dst-stage1/mqtt-plus-codec.d.ts

@@ -7,10 +7,10 @@ export declare class JSONX {
     static parse(json: string): unknown;
 }
 declare class Codec {
-    private type;
+    private format;
     private types;
     private tags;
-    constructor(type: "cbor" | "json");
+    constructor(format: "cbor" | "json");
     encode(data: unknown): Uint8Array | string;
     decode(data: Uint8Array | string): unknown;
 }

package/dst-stage1/mqtt-plus-codec.js

@@ -46,8 +46,8 @@ export class JSONX {
 }
 /*  the encoder/decoder abstraction  */
 class Codec {
-    constructor(type) {
-        this.type = type;
+    constructor(format) {
+        this.format = format;
         this.types = new CBOR.TypeEncoderMap();
         this.tags = new Map();
         /*  support direct encoding/decoding of Buffer  */
@@ -61,7 +61,7 @@ class Codec {
     }
     encode(data) {
         let result;
-        if (this.type === "cbor") {
+        if (this.format === "cbor") {
             try {
                 result = CBOR.encode(data, { types: this.types });
             }
@@ -69,7 +69,7 @@ class Codec {
                 throw new Error("failed to encode CBOR format", { cause: ex });
             }
         }
-        else if (this.type === "json") {
+        else if (this.format === "json") {
             try {
                 result = JSONX.stringify(data);
             }
@@ -78,12 +78,12 @@ class Codec {
             }
         }
         else
-            throw new Error(`invalid format "${this.type}"`);
+            throw new Error(`invalid format "${this.format}"`);
         return result;
     }
     decode(data) {
         let result;
-        if (this.type === "cbor") {
+        if (this.format === "cbor") {
             if (!(data instanceof Uint8Array))
                 throw new Error("failed to decode CBOR format (data type is not Uint8Array)");
             try {
@@ -93,7 +93,7 @@ class Codec {
                 throw new Error("failed to decode CBOR format", { cause: ex });
             }
         }
-        else if (this.type === "json") {
+        else if (this.format === "json") {
             if (typeof data !== "string")
                 throw new Error("failed to decode JSON format (data type is not string)");
             try {
@@ -104,7 +104,7 @@ class Codec {
             }
         }
         else
-            throw new Error(`invalid format "${this.type}"`);
+            throw new Error(`invalid format "${this.format}"`);
         return result;
     }
 }

package/dst-stage1/mqtt-plus-encode.js

@@ -45,7 +45,7 @@ export class EncodeTrait extends CodecTrait {
     }
     buf2arr(data, cons) {
         let arr;
-        if (typeof Buffer !== "undefined" && cons === Buffer)
+        if (cons === Buffer)
             arr = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
         else if (cons === Uint8Array)
             arr = data;

package/dst-stage1/mqtt-plus-event.js

@@ -25,7 +25,7 @@ import { nanoid } from "nanoid";
 /*  internal requirements  */
 import { EventEmission } from "./mqtt-plus-msg";
 import { AuthTrait } from "./mqtt-plus-auth";
-/*  Event Communication Trait  */
+/*  Event Emission Trait  */
 export class EventTrait extends AuthTrait {
     constructor() {
         super(...arguments);
@@ -56,35 +56,36 @@ export class EventTrait extends AuthTrait {
         if (this.events.has(name))
             throw new Error(`event: event "${name}" already registered`);
         /*  generate the corresponding MQTT topics for broadcast and direct use  */
-        const topic = share ? `$share/${share}/${name}` : name;
-        const topicB = this.options.topicMake(topic, "event-emission");
-        const topicD = this.options.topicMake(topic, "event-emission", this.options.id);
+        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);
+        /*  remember the registration  */
+        this.events.set(name, {
+            callback: callback,
+            auth
+        });
         /*  subscribe to MQTT topics  */
         await Promise.all([
             this._subscribeTopic(topicB, { qos: 0, ...options }),
             this._subscribeTopic(topicD, { qos: 0, ...options })
         ]).catch((err) => {
+            this.events.delete(name);
             this._unsubscribeTopic(topicB).catch(() => { });
             this._unsubscribeTopic(topicD).catch(() => { });
             throw err;
         });
-        /*  remember the registration  */
-        this.events.set(name, {
-            callback: callback,
-            auth
-        });
         /*  provide a registration for subsequent destruction  */
         const registration = {
             destroy: async () => {
                 if (!this.events.has(name))
                     throw new Error(`destroy: event "${name}" not registered`);
-                this.events.delete(name);
-                return Promise.all([
+                await Promise.all([
                     this._unsubscribeTopic(topicB),
                     this._unsubscribeTopic(topicD)
                 ]).then(() => { }).catch((err) => {
                     this.error(err, `destroy: failed to unsubscribe from topics for event "${name}"`);
                 });
+                this.events.delete(name);
             }
         };
         return registration;
@@ -142,14 +143,14 @@ export class EventTrait extends AuthTrait {
             if (topicMatch.name !== name)
                 throw new Error(`event name mismatch between topic "${topicMatch.name}" and payload "${name}"`);
             const handler = this.events.get(name);
+            if (handler === undefined)
+                throw new Error(`handler for event "${name}" not found`);
             const params = parsed.params ?? [];
             const info = { sender: parsed.sender ?? "" };
             if (parsed.receiver)
                 info.receiver = parsed.receiver;
             if (parsed.meta)
                 info.meta = parsed.meta;
-            if (handler === undefined)
-                throw new Error(`handler for event "${name}" not found`);
             if (handler.auth)
                 info.authenticated = await this.authenticated(parsed.sender, parsed.auth, handler.auth);
             Promise.resolve().then(() => {

package/dst-stage1/mqtt-plus-msg.d.ts

@@ -1,11 +1,12 @@
 import { APISchema } from "./mqtt-plus-api";
 import { EncodeTrait } from "./mqtt-plus-encode";
-type MessageType = "event-emission" | "service-call-request" | "service-call-response" | "sink-push-request" | "sink-push-response" | "sink-push-chunk" | "source-fetch-request" | "source-fetch-response" | "source-fetch-chunk";
+type MessageType = "event-emission" | "service-call-request" | "service-call-response" | "sink-push-request" | "sink-push-response" | "sink-push-chunk" | "sink-push-credit" | "source-fetch-request" | "source-fetch-response" | "source-fetch-chunk" | "source-fetch-credit";
 declare class Base {
     type: MessageType;
     id: string;
     sender?: string | undefined;
     receiver?: string | undefined;
+    version: string;
     constructor(type: MessageType, id: string, sender?: string | undefined, receiver?: string | undefined);
 }
 export declare class EventEmission extends Base {
@@ -39,7 +40,8 @@ export declare class SinkPushResponse extends Base {
     error?: string | undefined;
     auth?: string[] | undefined;
     meta?: Record<string, any> | undefined;
-    constructor(id: string, name: string, error?: string | undefined, sender?: string, receiver?: string, auth?: string[] | undefined, meta?: Record<string, any> | undefined);
+    credit?: number | undefined;
+    constructor(id: string, name: string, error?: string | undefined, sender?: string, receiver?: string, auth?: string[] | undefined, meta?: Record<string, any> | undefined, credit?: number | undefined);
 }
 export declare class SinkPushChunk extends Base {
     name: string;
@@ -48,12 +50,18 @@ export declare class SinkPushChunk extends Base {
     final?: boolean | undefined;
     constructor(id: string, name: string, chunk?: Uint8Array | undefined, error?: string | undefined, final?: boolean | undefined, sender?: string, receiver?: string);
 }
+export declare class SinkPushCredit extends Base {
+    name: string;
+    credit: number;
+    constructor(id: string, name: string, credit: number, sender?: string, receiver?: string);
+}
 export declare class SourceFetchRequest extends Base {
     name: string;
     params?: any[] | undefined;
     auth?: string[] | undefined;
     meta?: Record<string, any> | undefined;
-    constructor(id: string, name: string, params?: any[] | undefined, sender?: string, receiver?: string, auth?: string[] | undefined, meta?: Record<string, any> | undefined);
+    credit?: number | undefined;
+    constructor(id: string, name: string, params?: any[] | undefined, sender?: string, receiver?: string, auth?: string[] | undefined, meta?: Record<string, any> | undefined, credit?: number | undefined);
 }
 export declare class SourceFetchResponse extends Base {
     name: string;
@@ -69,17 +77,24 @@ export declare class SourceFetchChunk extends Base {
     final?: boolean | undefined;
     constructor(id: string, name: string, chunk?: Uint8Array | undefined, error?: string | undefined, final?: boolean | undefined, sender?: string, receiver?: string);
 }
+export declare class SourceFetchCredit extends Base {
+    name: string;
+    credit: number;
+    constructor(id: string, name: string, credit: number, sender?: string, receiver?: string);
+}
 declare class Msg {
     makeEventEmission(id: string, name: string, params?: any[], sender?: string, receiver?: string, auth?: string[], meta?: Record<string, any>): EventEmission;
     makeServiceCallRequest(id: string, name: string, params?: any[], sender?: string, receiver?: string, auth?: string[], meta?: Record<string, any>): ServiceCallRequest;
     makeServiceCallResponse(id: string, result?: any, error?: string, sender?: string, receiver?: string): ServiceCallResponse;
     makeSinkPushRequest(id: string, name: string, params?: any[], sender?: string, receiver?: string, auth?: string[], meta?: Record<string, any>): SinkPushRequest;
-    makeSinkPushResponse(id: string, name: string, error?: string, sender?: string, receiver?: string, auth?: string[], meta?: Record<string, any>): SinkPushResponse;
+    makeSinkPushResponse(id: string, name: string, error?: string, sender?: string, receiver?: string, auth?: string[], meta?: Record<string, any>, credit?: number): SinkPushResponse;
     makeSinkPushChunk(id: string, name: string, chunk?: Uint8Array, error?: string, final?: boolean, sender?: string, receiver?: string): SinkPushChunk;
-    makeSourceFetchRequest(id: string, name: string, params?: any[], sender?: string, receiver?: string, auth?: string[], meta?: Record<string, any>): SourceFetchRequest;
+    makeSinkPushCredit(id: string, name: string, credit: number, sender?: string, receiver?: string): SinkPushCredit;
+    makeSourceFetchRequest(id: string, name: string, params?: any[], sender?: string, receiver?: string, auth?: string[], meta?: Record<string, any>, credit?: number): SourceFetchRequest;
     makeSourceFetchResponse(id: string, name: string, error?: string, sender?: string, receiver?: string, auth?: string[], meta?: Record<string, any>): SourceFetchResponse;
     makeSourceFetchChunk(id: string, name: string, chunk?: Uint8Array, error?: string, final?: boolean, sender?: string, receiver?: string): SourceFetchChunk;
-    parse(obj: any): EventEmission | ServiceCallRequest | ServiceCallResponse | SinkPushRequest | SinkPushResponse | SinkPushChunk | SourceFetchRequest | SourceFetchResponse | SourceFetchChunk;
+    makeSourceFetchCredit(id: string, name: string, credit: number, sender?: string, receiver?: string): SourceFetchCredit;
+    parse(obj: any): EventEmission | ServiceCallRequest | ServiceCallResponse | SinkPushRequest | SinkPushResponse | SinkPushChunk | SinkPushCredit | SourceFetchRequest | SourceFetchResponse | SourceFetchChunk | SourceFetchCredit;
 }
 export declare class MsgTrait<T extends APISchema = APISchema> extends EncodeTrait<T> {
     protected msg: Msg;

package/dst-stage1/mqtt-plus-msg.js

@@ -24,10 +24,11 @@
 /*  external requirements  */
 import * as v from "valibot";
 import { EncodeTrait } from "./mqtt-plus-encode";
+import { version, VERSION, versionToNum } from "./mqtt-plus-version";
 /*  meta validation schema (non-array plain object)  */
 const MetaSchema = v.pipe(v.record(v.string(), v.unknown()), v.check((data) => !Array.isArray(data)));
-/*  reusable object schema (any non-null object)  */
-const ObjectSchema = v.custom((input) => typeof input === "object" && input !== null);
+/*  reusable auth validation schema (max 8 tokens, max 8192 chars each)  */
+const AuthSchema = v.pipe(v.array(v.pipe(v.string(), v.maxLength(8192))), v.maxLength(8));
 /*  base class  */
 class Base {
     constructor(type, id, sender, receiver) {
@@ -35,9 +36,11 @@ class Base {
         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()),
@@ -57,8 +60,8 @@ const EventEmissionSchema = v.strictObject({
     ...BaseSchema,
     type: v.literal("event-emission"),
     name: v.string(),
-    params: v.optional(v.array(v.unknown())),
-    auth: v.optional(v.array(v.string())),
+    params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
+    auth: v.optional(AuthSchema),
     meta: v.optional(MetaSchema)
 });
 /*  service request  */
@@ -75,8 +78,8 @@ const ServiceCallRequestSchema = v.strictObject({
     ...BaseSchema,
     type: v.literal("service-call-request"),
     name: v.string(),
-    params: v.optional(v.array(v.unknown())),
-    auth: v.optional(v.array(v.string())),
+    params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
+    auth: v.optional(AuthSchema),
     meta: v.optional(MetaSchema)
 });
 /*  service response  */
@@ -107,18 +110,19 @@ const SinkPushRequestSchema = v.strictObject({
     ...BaseSchema,
     type: v.literal("sink-push-request"),
     name: v.string(),
-    params: v.optional(v.array(v.unknown())),
-    auth: v.optional(v.array(v.string())),
+    params: v.optional(v.pipe(v.array(v.unknown()), v.maxLength(64))),
+    auth: v.optional(AuthSchema),
     meta: v.optional(MetaSchema)
 });
 /*  sink push response (ack/nak)  */
 export class SinkPushResponse extends Base {
-    constructor(id, name, error, sender, receiver, auth, meta) {
+    constructor(id, name, error, sender, receiver, auth, meta, credit) {
         super("sink-push-response", id, sender, receiver);
         this.name = name;
         this.error = error;
         this.auth = auth;
         this.meta = meta;
+        this.credit = credit;
     }
 }
 const SinkPushResponseSchema = v.strictObject({
@@ -126,8 +130,9 @@ const SinkPushResponseSchema = v.strictObject({
     type: v.literal("sink-push-response"),
     name: v.string(),
     error: v.optional(v.string()),
-    auth: v.optional(v.array(v.string())),
-    meta: v.optional(MetaSchema)
+    auth: v.optional(AuthSchema),
+    meta: v.optional(MetaSchema),
+    credit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0)))
 });
 /*  sink push chunk (actual data transfer)  */
 export class SinkPushChunk extends Base {
@@ -143,27 +148,43 @@ const SinkPushChunkSchema = v.strictObject({
     ...BaseSchema,
     type: v.literal("sink-push-chunk"),
     name: v.string(),
-    chunk: v.optional(ObjectSchema),
+    chunk: v.optional(v.instance(Uint8Array)),
     error: v.optional(v.string()),
     final: v.optional(v.boolean())
 });
+/*  sink push credit (credit replenishment for push flow control)  */
+export 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))
+});
 /*  source fetch request  */
 export class SourceFetchRequest extends Base {
-    constructor(id, name, params, sender, receiver, auth, meta) {
+    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.array(v.unknown())),
-    auth: v.optional(v.array(v.string())),
-    meta: v.optional(MetaSchema)
+    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(0)))
 });
 /*  source fetch response (ack/nak)  */
 export class SourceFetchResponse extends Base {
@@ -180,7 +201,7 @@ const SourceFetchResponseSchema = v.strictObject({
     type: v.literal("source-fetch-response"),
     name: v.string(),
     error: v.optional(v.string()),
-    auth: v.optional(v.array(v.string())),
+    auth: v.optional(AuthSchema),
     meta: v.optional(MetaSchema)
 });
 /*  source fetch chunk (actual data transfer)  */
@@ -197,55 +218,73 @@ const SourceFetchChunkSchema = v.strictObject({
     ...BaseSchema,
     type: v.literal("source-fetch-chunk"),
     name: v.string(),
-    chunk: v.optional(ObjectSchema),
+    chunk: v.optional(v.instance(Uint8Array)),
     error: v.optional(v.string()),
     final: v.optional(v.boolean())
 });
+/*  source fetch credit (credit replenishment for fetch flow control)  */
+export 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(1))
+});
 /*  utility class  */
 class Msg {
-    /*  factory for event emission  */
+    /*  factories for creating objects  */
     makeEventEmission(id, name, params, sender, receiver, auth, meta) {
         return new EventEmission(id, name, params, sender, receiver, auth, meta);
     }
-    /*  factory for service request  */
     makeServiceCallRequest(id, name, params, sender, receiver, auth, meta) {
         return new ServiceCallRequest(id, name, params, sender, receiver, auth, meta);
     }
-    /*  factory for service response  */
     makeServiceCallResponse(id, result, error, sender, receiver) {
         return new ServiceCallResponse(id, result, error, sender, receiver);
     }
-    /*  factory for sink push request  */
     makeSinkPushRequest(id, name, params, sender, receiver, auth, meta) {
         return new SinkPushRequest(id, name, params, sender, receiver, auth, meta);
     }
-    /*  factory for sink push response  */
-    makeSinkPushResponse(id, name, error, sender, receiver, auth, meta) {
-        return new SinkPushResponse(id, name, error, sender, receiver, auth, meta);
+    makeSinkPushResponse(id, name, error, sender, receiver, auth, meta, credit) {
+        return new SinkPushResponse(id, name, error, sender, receiver, auth, meta, credit);
     }
-    /*  factory for sink push chunk  */
     makeSinkPushChunk(id, name, chunk, error, final, sender, receiver) {
         return new SinkPushChunk(id, name, chunk, error, final, sender, receiver);
     }
-    /*  factory for source fetch request  */
-    makeSourceFetchRequest(id, name, params, sender, receiver, auth, meta) {
-        return new SourceFetchRequest(id, name, params, sender, receiver, auth, meta);
+    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);
     }
-    /*  factory for source fetch response  */
     makeSourceFetchResponse(id, name, error, sender, receiver, auth, meta) {
         return new SourceFetchResponse(id, name, error, sender, receiver, auth, meta);
     }
-    /*  factory for source fetch chunk  */
     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) {
+        /*  sanity check input  */
         if (typeof obj !== "object" || obj === null)
             throw new Error("invalid argument: not an object");
-        if (typeof obj.type !== "string")
-            throw new Error("invalid object: missing or invalid \"type\" field");
-        /*  dispatch according to type indication by field  */
+        /*  sanity check version  */
+        if (typeof obj.version !== "string")
+            throw new Error("invalid object: missing or invalid \"version\" field");
+        const m = obj.version.match(/^MQTT\+\/(\d+\.\d+)$/);
+        const V = m !== null ? versionToNum(m[1]) : 0.0;
+        if (V !== version)
+            throw new Error(`protocol version mismatch (expected version ${VERSION}, got version ${obj.version})`);
+        /*  helper function for Valibot-based validation  */
         const parseObject = (obj, name, schema) => {
             const res = v.safeParse(schema, obj);
             if (!res.success) {
@@ -254,6 +293,9 @@ class Msg {
             }
             return res.output;
         };
+        /*  dispatch according to type indication by field  */
+        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);
@@ -272,15 +314,19 @@ class Msg {
         }
         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.auth, out.meta);
+            return this.makeSinkPushResponse(out.id, out.name, out.error, out.sender, out.receiver, out.auth, out.meta, 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);
+            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);
@@ -290,6 +336,10 @@ class Msg {
             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");
     }

package/dst-stage1/mqtt-plus-options.d.ts

@@ -11,6 +11,7 @@ export interface APIOptions {
     codec: "cbor" | "json";
     timeout: number;
     chunkSize: number;
+    chunkCredit: number;
     topicMake: TopicMake;
     topicMatch: TopicMatch;
 }

package/dst-stage1/mqtt-plus-options.js

@@ -33,6 +33,7 @@ export class OptionsTrait {
             codec: "cbor",
             timeout: 10 * 1000,
             chunkSize: 16 * 1024,
+            chunkCredit: 4,
             topicMake: (name, operation, peerId) => {
                 return `${name}/${operation}/${peerId ?? "any"}`;
             },

package/dst-stage1/mqtt-plus-service.d.ts

@@ -23,7 +23,5 @@ export declare class ServiceTrait<T extends APISchema = APISchema> extends Event
         options?: IClientPublishOptions;
         meta?: Record<string, any>;
     }): Promise<ReturnType<T[K]>>;
-    private callSubscribe;
-    private callUnsubscribe;
     protected _dispatchMessage(topic: string, parsed: any): Promise<void>;
 }