@plexspaces/sdk 0.1.9 → 0.1.11

package/dist/wire/shard-group-proto-wire.js

@@ -158,10 +158,13 @@ function ulid() {
     return id;
 }
 function encodeMessage(query) {
+    const op = query['op'] || query['message_type'] || 'call';
     let buf = new Uint8Array(0);
     buf = appendString(buf, 1, ulid());
-    buf = appendString(buf, 5, 'call');
-    const payloadBytes = new Uint8Array(encW.encode(JSON.stringify(query)));
+    buf = appendString(buf, 5, op);
+    // inject message_type into payload so the receiver can read it
+    const payloadObj = { ...query, message_type: op };
+    const payloadBytes = new Uint8Array(encW.encode(JSON.stringify(payloadObj)));
     buf = appendBytes(buf, 6, payloadBytes);
     return buf;
 }
@@ -169,14 +172,17 @@ function encodeMessage(query) {
 // CreateShardGroupRequest encoder
 //
 // message CreateShardGroupRequest {
-//   DataParallelConfig config = 1;   (embedded)
-//   string actor_type = 2;
-//   ActorConfig shard_config = 3;    (not used here)
-//   bytes initial_state = 4;
+//   string request_id = 1;
+//   DataParallelConfig config = 2;   (embedded)
+//   string actor_type = 3;
+//   ActorConfig shard_config = 4;    (not used here)
+//   bytes initial_state = 5;
+//   map<string, string> metadata = 6;
 // }
 // ---------------------------------------------------------------------------
 export function encodeCreateShardGroupRequest(req) {
     let buf = new Uint8Array(0);
+    buf = appendString(buf, 1, ulid());
     // config = DataParallelConfig (fields: group_id, shard_count, partition_strategy, rebalance_policy, placement)
     const cfgFields = {
         group_id: req.group_id,
@@ -186,13 +192,22 @@ export function encodeCreateShardGroupRequest(req) {
         placement: req.placement,
     };
     const cfgBytes = encodeDataParallelConfig(cfgFields);
-    buf = appendLengthDelimited(buf, 1, cfgBytes);
-    buf = appendString(buf, 2, req.actor_type ?? '');
+    buf = appendLengthDelimited(buf, 2, cfgBytes);
+    buf = appendString(buf, 3, req.actor_type ?? '');
     const initialState = req.initial_state;
     if (initialState !== undefined && initialState !== null) {
         const stateBytes = new Uint8Array(encW.encode(JSON.stringify(initialState)));
         if (stateBytes.length > 0) {
-            buf = appendBytes(buf, 4, stateBytes);
+            buf = appendBytes(buf, 5, stateBytes);
+        }
+    }
+    const metadata = req.metadata;
+    if (metadata && typeof metadata === 'object') {
+        for (const [k, v] of Object.entries(metadata)) {
+            let entry = new Uint8Array(0);
+            entry = appendString(entry, 1, k);
+            entry = appendString(entry, 2, String(v));
+            buf = appendLengthDelimited(buf, 6, entry);
         }
     }
     return buf;
@@ -201,11 +216,12 @@ export function encodeCreateShardGroupRequest(req) {
 // ScatterGatherRequest encoder
 //
 // message ScatterGatherRequest {
-//   string group_id = 1;
-//   Message query = 2;                              (embedded)
-//   google.protobuf.Duration timeout = 3;           (embedded)
-//   ShardGroupAggregationStrategy aggregation = 4;  (varint)
-//   uint32 min_responses = 5;
+//   string request_id = 1;
+//   string group_id = 2;
+//   Message query = 3;                              (embedded)
+//   google.protobuf.Duration timeout = 4;           (embedded)
+//   ShardGroupAggregationStrategy aggregation = 5;  (varint)
+//   uint32 min_responses = 6;
 // }
 //
 // google.protobuf.Duration { int64 seconds=1, int32 nanos=2 }
@@ -228,24 +244,25 @@ function encodeDurationMs(ms) {
 }
 export function encodeScatterGatherRequest(req) {
     let buf = new Uint8Array(0);
-    buf = appendString(buf, 1, req.group_id ?? '');
+    buf = appendString(buf, 1, ulid());
+    buf = appendString(buf, 2, req.group_id ?? '');
     const query = req.query;
     if (query && typeof query === 'object') {
         const msgBytes = encodeMessage(query);
-        buf = appendLengthDelimited(buf, 2, msgBytes);
+        buf = appendLengthDelimited(buf, 3, msgBytes);
     }
     const timeoutMs = Number(req.timeout_ms ?? 30000);
     if (timeoutMs > 0) {
         const durBytes = encodeDurationMs(timeoutMs);
         if (durBytes.length > 0)
-            buf = appendLengthDelimited(buf, 3, durBytes);
+            buf = appendLengthDelimited(buf, 4, durBytes);
     }
     const agg = aggregationStrategyEnum(req.aggregation);
     if (agg !== 0)
-        buf = appendUint32(buf, 4, agg);
+        buf = appendUint32(buf, 5, agg);
     const minResponses = Number(req.min_responses ?? 0) >>> 0;
     if (minResponses > 0)
-        buf = appendUint32(buf, 5, minResponses);
+        buf = appendUint32(buf, 6, minResponses);
     return buf;
 }
 // ---------------------------------------------------------------------------
@@ -347,7 +364,7 @@ export function decodeCreateShardGroupResponse(data) {
         pos += tn;
         const fn = Number(tag >> 3n);
         const wt = Number(tag & 7n);
-        if (fn === 1 && wt === 2) {
+        if (fn === 2 && wt === 2) {
             const { slice, nextPos } = readLengthDelimited(data, pos);
             pos = nextPos;
             group = decodeShardGroup(slice);
@@ -362,17 +379,25 @@ export function decodeCreateShardGroupResponse(data) {
 // ScatterGatherResponse decoder
 //
 // message ScatterGatherResponse {
-//   Message result = 1;
-//   repeated ShardQueryResponse shard_responses = 2;
-//   ScatterGatherStats stats = 3;
+//   string request_id = 1;
+//   Message result = 2;
+//   repeated ShardQueryResponse shard_responses = 3;
+//   ScatterGatherStats stats = 4;
 // }
 // message ShardQueryResponse {
-//   uint32 shard_id = 1;
-//   string shard_actor_id = 2;
-//   Message response = 3;
-//   Duration latency = 4;
-//   bool success = 5;
-//   string error = 6;
+//   string request_id = 1;
+//   uint32 shard_id = 2;
+//   string shard_actor_id = 3;
+//   Message response = 4;
+//   Duration latency = 5;
+//   bool success = 6;
+//   string error = 7;
+// }
+// message ScatterGatherStats {
+//   uint32 shards_queried = 1;
+//   uint32 shards_responded = 2;
+//   uint32 shards_failed = 3;
+//   Duration max_latency = 4;
 // }
 // message Message { ... bytes payload = 6; ... }
 // ---------------------------------------------------------------------------
@@ -403,6 +428,37 @@ function decodeMessagePayload(data) {
         return text;
     }
 }
+function decodeScatterGatherStats(data) {
+    const result = {
+        shards_queried: 0, shards_responded: 0, shards_failed: 0, max_latency_ms: 0,
+    };
+    let pos = 0;
+    while (pos < data.length) {
+        const { value: tag, n: tn } = readVarint(data, pos);
+        pos += tn;
+        const fn = Number(tag >> 3n);
+        const wt = Number(tag & 7n);
+        if (fn === 1 && wt === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.shards_queried = value;
+            pos = nextPos;
+        }
+        else if (fn === 2 && wt === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.shards_responded = value;
+            pos = nextPos;
+        }
+        else if (fn === 3 && wt === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.shards_failed = value;
+            pos = nextPos;
+        }
+        else {
+            pos = skipField(data, pos, wt);
+        }
+    }
+    return result;
+}
 function decodeShardQueryResponse(data) {
     const result = {
         shard_id: 0,
@@ -417,28 +473,27 @@ function decodeShardQueryResponse(data) {
         pos += tn;
         const fn = Number(tag >> 3n);
         const wt = Number(tag & 7n);
-        if (fn === 1 && wt === 0) {
+        if (fn === 2 && wt === 0) {
             const { value, nextPos } = readUint32(data, pos);
             pos = nextPos;
             result.shard_id = value;
         }
-        else if (fn === 2 && wt === 2) {
+        else if (fn === 3 && wt === 2) {
             const { value, nextPos } = readString(data, pos);
             pos = nextPos;
             result.shard_actor_id = value;
         }
-        else if (fn === 3 && wt === 2) {
+        else if (fn === 4 && wt === 2) {
             const { slice, nextPos } = readLengthDelimited(data, pos);
             pos = nextPos;
-            // Expose the message payload directly so normalizeWorkerPayload can find it
             result.payload = decodeMessagePayload(slice);
         }
-        else if (fn === 5 && wt === 0) {
+        else if (fn === 6 && wt === 0) {
             const { value, nextPos } = readUint32(data, pos);
             pos = nextPos;
             result.success = value !== 0;
         }
-        else if (fn === 6 && wt === 2) {
+        else if (fn === 7 && wt === 2) {
             const { value, nextPos } = readString(data, pos);
             pos = nextPos;
             result.error = value;
@@ -451,6 +506,34 @@ function decodeShardQueryResponse(data) {
 }
 export function decodeScatterGatherResponse(data) {
     const shardResponses = [];
+    let stats = null;
+    let pos = 0;
+    while (pos < data.length) {
+        const { value: tag, n: tn } = readVarint(data, pos);
+        pos += tn;
+        const fn = Number(tag >> 3n);
+        const wt = Number(tag & 7n);
+        if (fn === 3 && wt === 2) {
+            const { slice, nextPos } = readLengthDelimited(data, pos);
+            pos = nextPos;
+            shardResponses.push(decodeShardQueryResponse(slice));
+        }
+        else if (fn === 4 && wt === 2) {
+            const { slice, nextPos } = readLengthDelimited(data, pos);
+            pos = nextPos;
+            stats = decodeScatterGatherStats(slice);
+        }
+        else {
+            pos = skipField(data, pos, wt);
+        }
+    }
+    return { shard_responses: shardResponses, stats: stats ?? {} };
+}
+// BroadcastShardGroupResponse and BarrierShardGroupResponse have shard_responses at field 2
+// (not field 3 like ScatterGatherResponse) — they lack the aggregated result field.
+function decodeBroadcastLikeResponse(data) {
+    const shardResponses = [];
+    let stats = null;
     let pos = 0;
     while (pos < data.length) {
         const { value: tag, n: tn } = readVarint(data, pos);
@@ -462,11 +545,16 @@ export function decodeScatterGatherResponse(data) {
             pos = nextPos;
             shardResponses.push(decodeShardQueryResponse(slice));
         }
+        else if (fn === 3 && wt === 2) {
+            const { slice, nextPos } = readLengthDelimited(data, pos);
+            pos = nextPos;
+            stats = decodeScatterGatherStats(slice);
+        }
         else {
             pos = skipField(data, pos, wt);
         }
     }
-    return { shard_responses: shardResponses };
+    return { shard_responses: shardResponses, stats: stats ?? {} };
 }
 // ---------------------------------------------------------------------------
 // GetApplicationStatusResponse decoder
@@ -689,6 +777,415 @@ function encodeUint64MapEntry(key, value) {
     entry = appendUint64(entry, 2, value);
     return entry;
 }
+// ---------------------------------------------------------------------------
+// BulkUpdateShardGroupRequest encoder
+//
+// BulkUpdateShardGroupRequest {
+//   string request_id = 1;
+//   string group_id = 2;
+//   map<string, Message> updates = 3;  // partition_key -> message
+//   ConsistencyLevel consistency_level = 4;
+//   Duration timeout = 5;
+//   bool wait_for_responses = 6;
+// }
+// ---------------------------------------------------------------------------
+export function encodeBulkUpdateShardGroupRequest(req) {
+    let buf = new Uint8Array(0);
+    buf = appendString(buf, 1, req.request_id ?? '');
+    buf = appendString(buf, 2, req.group_id ?? '');
+    const rawUpdates = req.updates;
+    let items;
+    if (Array.isArray(rawUpdates)) {
+        items = rawUpdates;
+    }
+    else if (rawUpdates && typeof rawUpdates === 'object') {
+        items = Object.entries(rawUpdates).map(([k, v]) => ({
+            key: k,
+            payload: v,
+        }));
+    }
+    else {
+        items = [];
+    }
+    for (const entry of items) {
+        const partitionKey = String(entry.key ?? '');
+        const payload = entry.payload && typeof entry.payload === 'object' ? entry.payload : {};
+        const msgBytes = encodeMessage(payload);
+        let mapEntry = new Uint8Array(0);
+        mapEntry = appendString(mapEntry, 1, partitionKey);
+        mapEntry = appendLengthDelimited(mapEntry, 2, msgBytes);
+        buf = appendLengthDelimited(buf, 3, mapEntry);
+    }
+    const consistencyLevel = Number(req.consistency_level ?? 0) >>> 0;
+    if (consistencyLevel !== 0)
+        buf = appendUint32(buf, 4, consistencyLevel);
+    const timeoutMs = Number(req.timeout_ms ?? 5000);
+    if (timeoutMs > 0) {
+        const durBytes = encodeDurationMs(timeoutMs);
+        if (durBytes.length > 0)
+            buf = appendLengthDelimited(buf, 5, durBytes);
+    }
+    const waitForResponses = req.wait_for_responses !== false; // default true
+    if (waitForResponses) {
+        buf = appendUint32(buf, 6, 1);
+    }
+    return buf;
+}
+// ---------------------------------------------------------------------------
+// BulkUpdateShardGroupResponse decoder
+//
+// BulkUpdateShardGroupResponse {
+//   string request_id = 1;
+//   uint32 updates_sent = 2;
+//   uint32 updates_succeeded = 3;
+//   uint32 updates_failed = 4;
+//   repeated ShardUpdateStats shard_stats = 5;
+//   repeated string errors = 6;
+// }
+// ---------------------------------------------------------------------------
+export function decodeBulkUpdateShardGroupResponse(data) {
+    const result = {
+        request_id: '',
+        updates_sent: 0,
+        updates_succeeded: 0,
+        updates_failed: 0,
+        shard_stats: [],
+        errors: [],
+    };
+    if (!data || data.length === 0)
+        return result;
+    let pos = 0;
+    while (pos < data.length) {
+        const { value: tagVal, n: tagN } = readVarint(data, pos);
+        pos += tagN;
+        const fieldNum = Number(tagVal >> BigInt(3));
+        const wireType = Number(tagVal & BigInt(7));
+        if (fieldNum === 1 && wireType === 2) {
+            const { value, nextPos } = readString(data, pos);
+            result.request_id = value;
+            pos = nextPos;
+        }
+        else if (fieldNum === 2 && wireType === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.updates_sent = value;
+            pos = nextPos;
+        }
+        else if (fieldNum === 3 && wireType === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.updates_succeeded = value;
+            pos = nextPos;
+        }
+        else if (fieldNum === 4 && wireType === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.updates_failed = value;
+            pos = nextPos;
+        }
+        else if (fieldNum === 5 && wireType === 2) {
+            const { slice, nextPos } = readLengthDelimited(data, pos);
+            result.shard_stats.push(decodeShardUpdateStats(slice));
+            pos = nextPos;
+        }
+        else if (fieldNum === 6 && wireType === 2) {
+            const { value, nextPos } = readString(data, pos);
+            result.errors.push(value);
+            pos = nextPos;
+        }
+        else {
+            pos = skipField(data, pos, wireType);
+        }
+    }
+    return result;
+}
+function decodeShardUpdateStats(data) {
+    const result = {
+        shard_id: 0, shard_actor_id: '', updates_sent: 0, updates_succeeded: 0, updates_failed: 0,
+    };
+    if (!data || data.length === 0)
+        return result;
+    let pos = 0;
+    while (pos < data.length) {
+        const { value: tagVal, n: tagN } = readVarint(data, pos);
+        pos += tagN;
+        const fieldNum = Number(tagVal >> BigInt(3));
+        const wireType = Number(tagVal & BigInt(7));
+        if (fieldNum === 1 && wireType === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.shard_id = value;
+            pos = nextPos;
+        }
+        else if (fieldNum === 2 && wireType === 2) {
+            const { value, nextPos } = readString(data, pos);
+            result.shard_actor_id = value;
+            pos = nextPos;
+        }
+        else if (fieldNum === 3 && wireType === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.updates_sent = value;
+            pos = nextPos;
+        }
+        else if (fieldNum === 4 && wireType === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.updates_succeeded = value;
+            pos = nextPos;
+        }
+        else if (fieldNum === 5 && wireType === 0) {
+            const { value, nextPos } = readUint32(data, pos);
+            result.updates_failed = value;
+            pos = nextPos;
+        }
+        else {
+            pos = skipField(data, pos, wireType);
+        }
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// collectiveReductionEnum — maps JS string names to proto CollectiveReduction values
+// sum=1, min=2, max=3, product=4, concat=5, bool_and=6, bool_or=7
+// ---------------------------------------------------------------------------
+function collectiveReductionEnum(s) {
+    switch ((s ?? '').toLowerCase()) {
+        case 'sum': return 1;
+        case 'min': return 2;
+        case 'max': return 3;
+        case 'product': return 4;
+        case 'concat': return 5;
+        case 'bool_and': return 6;
+        case 'bool_or': return 7;
+        default: return 0;
+    }
+}
+// ---------------------------------------------------------------------------
+// BroadcastShardGroupRequest encoder
+//
+// message BroadcastShardGroupRequest {
+//   string request_id = 1;
+//   string group_id = 2;
+//   Message message = 3;
+//   google.protobuf.Duration timeout = 4;
+//   uint32 min_acks = 5;
+// }
+// ---------------------------------------------------------------------------
+export function encodeBroadcastShardGroupRequest(req) {
+    let buf = new Uint8Array(0);
+    buf = appendString(buf, 1, ulid());
+    buf = appendString(buf, 2, req.group_id ?? '');
+    const message = req.message;
+    if (message && typeof message === 'object') {
+        buf = appendLengthDelimited(buf, 3, encodeMessage(message));
+    }
+    const timeoutMs = Number(req.timeout_ms ?? 30000);
+    if (timeoutMs > 0) {
+        const durBytes = encodeDurationMs(timeoutMs);
+        if (durBytes.length > 0)
+            buf = appendLengthDelimited(buf, 4, durBytes);
+    }
+    const minAcks = Number(req.min_acks ?? 0) >>> 0;
+    if (minAcks > 0)
+        buf = appendUint32(buf, 5, minAcks);
+    return buf;
+}
+// ---------------------------------------------------------------------------
+// ReduceShardGroupRequest encoder
+//
+// message ReduceShardGroupRequest {
+//   string request_id = 1;
+//   string group_id = 2;
+//   Message map_function = 3;
+//   google.protobuf.Duration timeout = 4;
+//   uint32 min_responses = 5;
+//   CollectiveReduction reduction = 6;  (varint)
+//   CollectiveTargetField target = 7;   (embedded: string value_path = 1)
+// }
+// ---------------------------------------------------------------------------
+export function encodeReduceShardGroupRequest(req) {
+    let buf = new Uint8Array(0);
+    buf = appendString(buf, 1, ulid());
+    buf = appendString(buf, 2, req.group_id ?? '');
+    const mapFn = req.map_function;
+    if (mapFn && typeof mapFn === 'object') {
+        buf = appendLengthDelimited(buf, 3, encodeMessage(mapFn));
+    }
+    const timeoutMs = Number(req.timeout_ms ?? 30000);
+    if (timeoutMs > 0) {
+        const durBytes = encodeDurationMs(timeoutMs);
+        if (durBytes.length > 0)
+            buf = appendLengthDelimited(buf, 4, durBytes);
+    }
+    const minResponses = Number(req.min_responses ?? 0) >>> 0;
+    if (minResponses > 0)
+        buf = appendUint32(buf, 5, minResponses);
+    const reduction = collectiveReductionEnum(req.reduction);
+    if (reduction !== 0)
+        buf = appendUint32(buf, 6, reduction);
+    const target = req.target;
+    if (target) {
+        let targetField = new Uint8Array(0);
+        targetField = appendString(targetField, 1, target);
+        buf = appendLengthDelimited(buf, 7, targetField);
+    }
+    return buf;
+}
+// ---------------------------------------------------------------------------
+// AllReduceShardGroupRequest encoder — identical shape to ReduceShardGroupRequest
+// ---------------------------------------------------------------------------
+export function encodeAllReduceShardGroupRequest(req) {
+    return encodeReduceShardGroupRequest(req);
+}
+// ---------------------------------------------------------------------------
+// BarrierShardGroupRequest encoder
+//
+// message BarrierShardGroupRequest {
+//   string request_id = 1;
+//   string group_id = 2;
+//   string barrier_id = 3;
+//   uint64 round = 4;  (varint)
+//   google.protobuf.Duration timeout = 5;
+//   uint32 min_acks = 6;
+// }
+// ---------------------------------------------------------------------------
+export function encodeBarrierShardGroupRequest(req) {
+    let buf = new Uint8Array(0);
+    buf = appendString(buf, 1, ulid());
+    buf = appendString(buf, 2, req.group_id ?? '');
+    buf = appendString(buf, 3, req.barrier_id ?? '');
+    const round = Number(req.round ?? 0);
+    if (round > 0) {
+        buf = appendVarint(buf, (4 << 3) | 0);
+        buf = appendVarint(buf, round);
+    }
+    const timeoutMs = Number(req.timeout_ms ?? 30000);
+    if (timeoutMs > 0) {
+        const durBytes = encodeDurationMs(timeoutMs);
+        if (durBytes.length > 0)
+            buf = appendLengthDelimited(buf, 5, durBytes);
+    }
+    const minAcks = Number(req.min_acks ?? 0) >>> 0;
+    if (minAcks > 0)
+        buf = appendUint32(buf, 6, minAcks);
+    return buf;
+}
+// ---------------------------------------------------------------------------
+// MapShardGroupRequest encoder
+//
+// message MapShardGroupRequest {
+//   string request_id = 1;
+//   string group_id = 2;
+//   Message map_function = 3;
+//   google.protobuf.Duration timeout = 4;
+//   uint32 min_responses = 5;
+// }
+// ---------------------------------------------------------------------------
+export function encodeMapShardGroupRequest(req) {
+    let buf = new Uint8Array(0);
+    buf = appendString(buf, 1, ulid());
+    buf = appendString(buf, 2, req.group_id ?? '');
+    const mapFn = req.map_function;
+    if (mapFn && typeof mapFn === 'object') {
+        buf = appendLengthDelimited(buf, 3, encodeMessage(mapFn));
+    }
+    const timeoutMs = Number(req.timeout_ms ?? 30000);
+    if (timeoutMs > 0) {
+        const durBytes = encodeDurationMs(timeoutMs);
+        if (durBytes.length > 0)
+            buf = appendLengthDelimited(buf, 4, durBytes);
+    }
+    const minResponses = Number(req.min_responses ?? 0) >>> 0;
+    if (minResponses > 0)
+        buf = appendUint32(buf, 5, minResponses);
+    return buf;
+}
+// ---------------------------------------------------------------------------
+// BroadcastShardGroupResponse decoder
+//
+// message BroadcastShardGroupResponse {
+//   string request_id = 1;
+//   repeated ShardQueryResponse shard_responses = 2;
+//   ScatterGatherStats stats = 3;
+// }
+// ---------------------------------------------------------------------------
+export function decodeBroadcastShardGroupResponse(data) {
+    return decodeBroadcastLikeResponse(data);
+}
+// ---------------------------------------------------------------------------
+// ReduceShardGroupResponse decoder
+//
+// message ReduceShardGroupResponse {
+//   string request_id = 1;
+//   Message result = 2;
+//   repeated ShardQueryResponse shard_responses = 3;
+// }
+// ---------------------------------------------------------------------------
+export function decodeReduceShardGroupResponse(data) {
+    const shardResponses = [];
+    let result = {};
+    let pos = 0;
+    while (pos < data.length) {
+        const { value: tag, n: tn } = readVarint(data, pos);
+        pos += tn;
+        const fn = Number(tag >> 3n);
+        const wt = Number(tag & 7n);
+        if (fn === 2 && wt === 2) {
+            const { slice, nextPos } = readLengthDelimited(data, pos);
+            pos = nextPos;
+            result = decodeMessagePayload(slice);
+        }
+        else if (fn === 3 && wt === 2) {
+            const { slice, nextPos } = readLengthDelimited(data, pos);
+            pos = nextPos;
+            shardResponses.push(decodeShardQueryResponse(slice));
+        }
+        else {
+            pos = skipField(data, pos, wt);
+        }
+    }
+    return { result, shard_responses: shardResponses };
+}
+// ---------------------------------------------------------------------------
+// AllReduceShardGroupResponse decoder — same shape as ReduceShardGroupResponse
+// ---------------------------------------------------------------------------
+export function decodeAllReduceShardGroupResponse(data) {
+    return decodeReduceShardGroupResponse(data);
+}
+// ---------------------------------------------------------------------------
+// BarrierShardGroupResponse decoder — same shape as BroadcastShardGroupResponse
+//
+// message BarrierShardGroupResponse {
+//   string request_id = 1;
+//   repeated ShardQueryResponse shard_responses = 2;
+//   ScatterGatherStats stats = 3;
+// }
+// ---------------------------------------------------------------------------
+export function decodeBarrierShardGroupResponse(data) {
+    return decodeBroadcastLikeResponse(data);
+}
+// ---------------------------------------------------------------------------
+// MapShardGroupResponse decoder
+//
+// message MapShardGroupResponse {
+//   string request_id = 1;
+//   repeated ShardQueryResponse shard_results = 2;
+// }
+// ---------------------------------------------------------------------------
+export function decodeMapShardGroupResponse(data) {
+    const shardResults = [];
+    let pos = 0;
+    while (pos < data.length) {
+        const { value: tag, n: tn } = readVarint(data, pos);
+        pos += tn;
+        const fn = Number(tag >> 3n);
+        const wt = Number(tag & 7n);
+        if (fn === 2 && wt === 2) {
+            const { slice, nextPos } = readLengthDelimited(data, pos);
+            pos = nextPos;
+            shardResults.push(decodeShardQueryResponse(slice));
+        }
+        else {
+            pos = skipField(data, pos, wt);
+        }
+    }
+    return { shard_results: shardResults };
+}
 export function encodeApplicationMetrics(metrics) {
     let buf = new Uint8Array(0);
     const counterMetrics = metrics.counter_metrics;