starpc 0.52.0 → 0.52.2

package/dist/rpcstream/rpcstream.js

@@ -1,4 +1,5 @@
 import { pushable } from 'it-pushable';
+import { closeIterator, sourceIterator, TerminationGate, } from '../srpc/termination.js';
 // openRpcStream attempts to open a stream over a RPC call.
 // if waitAck is set, waits for the remote to ack the stream before returning.
 export async function openRpcStream(componentId, caller, waitAck) {
@@ -33,7 +34,7 @@ export async function openRpcStream(componentId, caller, waitAck) {
         }
     }
     // build & return the data stream
-    return new RpcStream(packetTx, packetIt);
+    return new RpcStream(packetTx, packetIt, () => closeIterator(packetIt));
 }
 // buildRpcStreamOpenStream builds a OpenStream func with a RpcStream.
 export function buildRpcStreamOpenStream(componentId, caller) {
@@ -87,7 +88,7 @@ export async function* handleRpcStream(packetRx, getter) {
     // build the outgoing packet sink & the packet source
     const packetTx = pushable({ objectMode: true });
     // start the handler
-    const rpcStream = new RpcStream(packetTx, packetRx);
+    const rpcStream = new RpcStream(packetTx, packetRx, () => closeIterator(packetRx));
     handler(rpcStream)
         .catch((err) => packetTx.end(err))
         .then(() => packetTx.end());
@@ -107,54 +108,100 @@ export class RpcStream {
     _packetRx;
     // _packetTx writes packets to the remote.
     _packetTx;
+    _termination = new TerminationGate();
+    _cancelRpc;
     // packetTx writes packets to the remote.
     // packetRx receives packets from the remote.
-    constructor(packetTx, packetRx) {
+    constructor(packetTx, packetRx, cancelRpc = () => closeIterator(packetRx)) {
         this._packetTx = packetTx;
         this._packetRx = packetRx;
+        this._cancelRpc = cancelRpc;
         this.sink = this._createSink();
         this.source = this._createSource();
     }
+    // close cleanly ends both directions of the stream.
+    async close() {
+        if (this._termination.terminate()) {
+            this._packetTx.end();
+            this._cancelRpc();
+        }
+    }
+    // abort ends both directions of the stream with err.
+    abort(err) {
+        if (this._termination.terminate(err)) {
+            this._packetTx.end(err);
+            this._cancelRpc();
+        }
+    }
     // _createSink initializes the sink field.
     _createSink() {
         return async (source) => {
+            const iterator = sourceIterator(source);
             try {
-                for await (const arr of source) {
+                while (true) {
+                    const next = await this._termination.next(iterator);
+                    if ('terminated' in next) {
+                        if (next.error)
+                            throw next.error;
+                        return;
+                    }
+                    if ('error' in next)
+                        throw next.error;
+                    if (next.result.done) {
+                        this._packetTx.end();
+                        return;
+                    }
+                    if (this._termination.terminated)
+                        return;
                     this._packetTx.push({
-                        body: { case: 'data', value: arr },
+                        body: { case: 'data', value: next.result.value },
                     });
                 }
-                this._packetTx.end();
             }
             catch (err) {
-                this._packetTx.end(err);
+                const error = err instanceof Error ? err : new Error(String(err));
+                this.abort(error);
+                throw error;
+            }
+            finally {
+                closeIterator(iterator);
             }
         };
     }
     // _createSource initializes the source field.
     _createSource() {
-        return (async function* (packetRx) {
-            while (true) {
-                const msgIt = await packetRx.next();
-                if (msgIt.done) {
-                    return;
-                }
-                const value = msgIt.value;
-                const body = value?.body;
-                if (!body) {
-                    continue;
-                }
-                switch (body.case) {
-                    case 'ack':
-                        if (body.value.error?.length) {
-                            throw new Error(body.value.error);
-                        }
-                        break;
-                    case 'data':
-                        yield body.value;
-                        break;
+        const packetRx = this._packetRx;
+        const termination = this._termination;
+        return (async function* () {
+            try {
+                while (true) {
+                    const next = await termination.next(packetRx);
+                    if ('terminated' in next) {
+                        if (next.error)
+                            throw next.error;
+                        return;
+                    }
+                    if ('error' in next)
+                        throw next.error;
+                    if (next.result.done)
+                        return;
+                    const body = next.result.value?.body;
+                    if (!body)
+                        continue;
+                    switch (body.case) {
+                        case 'ack':
+                            if (body.value.error?.length)
+                                throw new Error(body.value.error);
+                            break;
+                        case 'data':
+                            yield body.value;
+                            break;
+                    }
                 }
             }
-        })(this._packetRx);
+            finally {
+                closeIterator(packetRx);
+            }
+        })();
     }
 }

package/dist/rpcstream/rpcstream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rpcstream/rpcstream.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from 'vitest';
+import { pushable } from 'it-pushable';
+import { RpcStream } from './rpcstream.js';
+describe('RpcStream lifecycle', () => {
+    it('closes while its source is blocked', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.source.next();
+        await stream.close();
+        await expect(pending).resolves.toEqual({ done: true, value: undefined });
+        await expect(tx.next()).resolves.toEqual({ done: true, value: undefined });
+    });
+    it('aborts while its source is blocked', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.source.next();
+        const error = new Error('stopped');
+        stream.abort(error);
+        await expect(pending).rejects.toBe(error);
+        await expect(tx.next()).rejects.toBe(error);
+    });
+    it('closes while its sink source is blocked', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const input = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.sink(input);
+        await stream.close();
+        await expect(pending).resolves.toBeUndefined();
+        await expect(tx.next()).resolves.toEqual({ done: true, value: undefined });
+    });
+    it('aborts while its sink source is blocked', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const input = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.sink(input);
+        const error = new Error('stopped');
+        stream.abort(error);
+        await expect(pending).rejects.toBe(error);
+        await expect(tx.next()).rejects.toBe(error);
+    });
+    it('does not write input that becomes ready as the stream closes', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const input = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        input.push(new Uint8Array([1]));
+        const pending = stream.sink(input);
+        await stream.close();
+        await expect(pending).resolves.toBeUndefined();
+        await expect(tx.next()).resolves.toEqual({ done: true, value: undefined });
+    });
+    it('does not close when its sink completes', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        await stream.sink((async function* () { })());
+        rx.push({ body: { case: 'data', value: new Uint8Array([1]) } });
+        await expect(stream.source.next()).resolves.toMatchObject({ done: false });
+    });
+    it('finalizes a sink input iterator when closed', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const returned = vi.fn(() => Promise.resolve({ done: true, value: undefined }));
+        const input = {
+            [Symbol.asyncIterator]: () => ({
+                next: () => new Promise(() => { }),
+                return: returned,
+            }),
+        };
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.sink(input);
+        await stream.close();
+        await pending;
+        expect(returned).toHaveBeenCalledOnce();
+    });
+    it('cancels the outer RPC when aborted after sink completion', async () => {
+        const tx = pushable({ objectMode: true });
+        const returned = vi.fn(() => Promise.resolve({ done: true, value: undefined }));
+        const rx = {
+            next: () => new Promise(() => { }),
+            return: returned,
+        };
+        const stream = new RpcStream(tx, rx);
+        await stream.sink((async function* () { })());
+        stream.abort(new Error('stopped'));
+        expect(returned).toHaveBeenCalledOnce();
+    });
+});

package/dist/srpc/client-rpc.d.ts

@@ -4,4 +4,5 @@ export declare class ClientRPC extends CommonRPC {
     constructor(service: string, method: string);
     writeCallStart(data?: Uint8Array): Promise<void>;
     handleCallStart(packet: CallStart): Promise<void>;
+    protected handleSourceEnd(): Promise<void>;
 }

package/dist/srpc/client-rpc.js

@@ -1,4 +1,5 @@
 import { CommonRPC } from './common-rpc.js';
+import { ERR_CLOSED_BEFORE_COMPLETION } from './errors.js';
 // ClientRPC is an ongoing RPC from the client side.
 export class ClientRPC extends CommonRPC {
     constructor(service, method) {
@@ -30,4 +31,12 @@ export class ClientRPC extends CommonRPC {
         // we do not implement server -> client RPCs.
         throw new Error(`unexpected server to client rpc: ${packet.rpcService || '<empty>'}/${packet.rpcMethod || '<empty>'}`);
     }
+    // handleSourceEnd fails the call when the transport ends before the remote
+    // sent a completion or an error, so a truncated stream does not read as a
+    // complete one.
+    async handleSourceEnd() {
+        if (!this.isRemoteCompleted) {
+            await this.close(new Error(ERR_CLOSED_BEFORE_COMPLETION));
+        }
+    }
 }

package/dist/srpc/client-rpc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/srpc/client-rpc.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { ClientRPC } from './client-rpc.js';
+import { isClosedBeforeCompletionError } from './errors.js';
+import { Packet } from './rpcproto.pb.js';
+describe('ClientRPC', () => {
+    it('fails a call whose transport ends before the remote completes it', async () => {
+        const call = new ClientRPC('svc', 'method');
+        await call.sink(packetSource(callDataPacket(new Uint8Array([1]))));
+        const received = new Array();
+        const read = async () => {
+            for await (const data of call.rpcDataSource) {
+                received.push(data[0]);
+            }
+        };
+        const err = await read().then(() => undefined, (err) => err);
+        expect(received).toEqual([1]);
+        expect(isClosedBeforeCompletionError(err)).toBe(true);
+        expect(isClosedBeforeCompletionError(call.isClosed)).toBe(true);
+    });
+    it('ends a call cleanly when the remote completes it before the transport ends', async () => {
+        const call = new ClientRPC('svc', 'method');
+        await call.sink(packetSource(callDataPacket(new Uint8Array([1])), callDataPacket(undefined, true)));
+        const received = new Array();
+        for await (const data of call.rpcDataSource) {
+            received.push(data[0]);
+        }
+        expect(received).toEqual([1]);
+        expect(call.isClosed).toBe(false);
+    });
+});
+// callDataPacket builds an incoming call-data packet.
+function callDataPacket(data, complete = false) {
+    return Packet.create({
+        body: {
+            case: 'callData',
+            value: {
+                data: data ?? new Uint8Array(0),
+                dataIsZero: false,
+                complete,
+                error: '',
+            },
+        },
+    });
+}
+// packetSource yields packets and then ends like a closed transport.
+async function* packetSource(...packets) {
+    for (const packet of packets) {
+        yield packet;
+    }
+}

package/dist/srpc/client.js

@@ -82,13 +82,27 @@ export class Client {
         const stream = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         const onAbort = () => {
+            if (call.isClosed)
+                return;
+            const error = new Error(ERR_RPC_ABORT);
             void call.writeCallCancel().catch(() => undefined);
-            void call.close(new Error(ERR_RPC_ABORT)).catch(() => undefined);
+            stream.abort(error);
+            void call.close(error).catch(() => undefined);
         };
         abortSignal?.addEventListener('abort', onAbort, { once: true });
-        pipe(stream, decodePacketSource, call, encodePacketSource, stream)
-            .catch((err) => call.close(err))
-            .then(() => call.close())
+        void pipe(stream, decodePacketSource, call, encodePacketSource, stream)
+            .then(async () => {
+            if (call.isClosed instanceof Error) {
+                stream.abort(call.isClosed);
+                return;
+            }
+            await stream.close();
+            await call.close();
+        }, async (err) => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            stream.abort(error);
+            await call.close(error);
+        })
             .finally(() => {
             abortSignal?.removeEventListener('abort', onAbort);
         });

package/dist/srpc/common-rpc.d.ts

@@ -10,10 +10,12 @@ export declare class CommonRPC {
     protected method?: string;
     private closed?;
     private remoteError?;
+    private remoteCompleted;
     private readonly invocationController;
     private readonly writeDrainAbort;
     constructor();
     get isClosed(): boolean | Error;
+    protected get isRemoteCompleted(): boolean;
     protected get invocationSignal(): AbortSignal;
     writeCallData(data?: Uint8Array, complete?: boolean, error?: string): Promise<void>;
     private writeCallDataPacket;
@@ -27,6 +29,9 @@ export declare class CommonRPC {
     handleCallData(packet: Partial<CallData>): Promise<void>;
     handleCallCancel(): Promise<void>;
     close(err?: Error): Promise<void>;
+    private endRpcData;
+    private readRpcData;
+    protected handleSourceEnd(): Promise<void>;
     private _createSink;
 }
 interface WritePacketOptions {

package/dist/srpc/common-rpc.js

@@ -14,7 +14,9 @@ export class CommonRPC {
     _source = pushable({
         objectMode: true,
     });
-    // _rpcDataSource is used to write to the rpc message source.
+    // _rpcDataSource queues incoming rpc messages and the terminal error.
+    // The error is queued as an item because ending a pushable with an error
+    // discards the messages it buffered.
     _rpcDataSource = pushable({
         objectMode: true,
     });
@@ -26,6 +28,8 @@ export class CommonRPC {
     closed;
     // remoteError records a remote error or transport failure.
     remoteError;
+    // remoteCompleted records that the remote sent a completion or an error.
+    remoteCompleted = false;
     // invocationController cancels the server invocation when the RPC closes.
     invocationController = new AbortController();
     // writeDrainAbort wakes writers waiting for outbound stream drain on close.
@@ -33,12 +37,16 @@ export class CommonRPC {
     constructor() {
         this.sink = this._createSink();
         this.source = this._source;
-        this.rpcDataSource = this._rpcDataSource;
+        this.rpcDataSource = this.readRpcData();
     }
     // isClosed returns one of: true (closed w/o error), Error (closed w/ error), or false (not closed).
     get isClosed() {
         return this.closed ?? false;
     }
+    // isRemoteCompleted reports whether the remote sent a completion or an error.
+    get isRemoteCompleted() {
+        return this.remoteCompleted;
+    }
     // invocationSignal is canceled when the RPC closes.
     get invocationSignal() {
         return this.invocationController.signal;
@@ -171,11 +179,9 @@ export class CommonRPC {
             this.remoteError ??= remoteError;
             this.invocationController.abort();
         }
-        if (packet.complete && !remoteError) {
-            this._rpcDataSource.end(remoteError);
-        }
-        else if (remoteError) {
-            this._rpcDataSource.end(remoteError);
+        if (packet.complete || remoteError) {
+            this.remoteCompleted = true;
+            this.endRpcData(remoteError);
         }
     }
     // handleCallCancel aborts the invocation and closes the call.
@@ -201,7 +207,29 @@ export class CommonRPC {
         }
         this.writeDrainAbort.abort();
         this._source.end();
-        this._rpcDataSource.end(err);
+        this.endRpcData(err);
+    }
+    // endRpcData ends the rpc message source after its buffered messages,
+    // optionally with an error.
+    endRpcData(err) {
+        if (err) {
+            this._rpcDataSource.push(err);
+        }
+        this._rpcDataSource.end();
+    }
+    // readRpcData yields the buffered rpc messages, then throws the terminal
+    // error, if any.
+    async *readRpcData() {
+        for await (const item of this._rpcDataSource) {
+            if (item instanceof Error) {
+                throw item;
+            }
+            yield item;
+        }
+    }
+    // handleSourceEnd handles the end of the incoming packet source.
+    async handleSourceEnd() {
+        // no-op
     }
     _createSink() {
         return async (source) => {
@@ -216,6 +244,7 @@ export class CommonRPC {
                         await this.handlePacket(msg);
                     }
                 }
+                await this.handleSourceEnd();
             }
             catch (err) {
                 this.close(err);

package/dist/srpc/common-rpc.test.js

@@ -101,6 +101,8 @@ describe('CommonRPC', () => {
         const responseGate = deferred();
         const response = new Uint8Array([7]);
         const client = new Client(async () => ({
+            close: async () => { },
+            abort: () => { },
             source: (async function* () {
                 await responseGate.promise;
                 yield Packet.toBinary({

package/dist/srpc/errors.d.ts

@@ -1,5 +1,7 @@
 export declare const ERR_RPC_ABORT = "ERR_RPC_ABORT";
 export declare function isAbortError(err: unknown): boolean;
+export declare const ERR_CLOSED_BEFORE_COMPLETION = "ERR_CLOSED_BEFORE_COMPLETION";
+export declare function isClosedBeforeCompletionError(err: unknown): boolean;
 export declare const ERR_STREAM_IDLE = "ERR_STREAM_IDLE";
 export declare function isStreamIdleError(err: unknown): boolean;
 export declare class RemoteRPCError extends Error {

package/dist/srpc/errors.js

@@ -8,6 +8,20 @@ export function isAbortError(err) {
     const message = err.message;
     return message === ERR_RPC_ABORT;
 }
+// ERR_CLOSED_BEFORE_COMPLETION is returned if the stream closed before the
+// remote sent a completion or an error. The call has no verdict: the handler
+// may have finished with its answer lost in the transport, or it may never
+// have run.
+export const ERR_CLOSED_BEFORE_COMPLETION = 'ERR_CLOSED_BEFORE_COMPLETION';
+// isClosedBeforeCompletionError checks if the error object is
+// ERR_CLOSED_BEFORE_COMPLETION.
+export function isClosedBeforeCompletionError(err) {
+    if (typeof err !== 'object') {
+        return false;
+    }
+    const message = err.message;
+    return message === ERR_CLOSED_BEFORE_COMPLETION;
+}
 // ERR_STREAM_IDLE is returned if the stream idle timeout was exceeded.
 export const ERR_STREAM_IDLE = 'ERR_STREAM_IDLE';
 // isStreamIdleError checks if the error object is ERR_STREAM_IDLE.

package/dist/srpc/index.d.ts

@@ -1,4 +1,4 @@
-export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
+export { ERR_RPC_ABORT, isAbortError, ERR_CLOSED_BEFORE_COMPLETION, isClosedBeforeCompletionError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';

package/dist/srpc/index.js

@@ -1,4 +1,4 @@
-export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
+export { ERR_RPC_ABORT, isAbortError, ERR_CLOSED_BEFORE_COMPLETION, isClosedBeforeCompletionError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';

package/dist/srpc/packet-codec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/srpc/packet-codec.test.js

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest';
+import vectors from '../testdata/packet-codec-vectors.json';
+import { Packet } from './rpcproto.pb.js';
+import { decodePacketSource, encodePacketSource, lengthPrefixDecode, prependLengthPrefixTransform, uint32LEDecode, } from './packet.js';
+const bytes = (hex) => Uint8Array.from(hex.match(/../g) ?? [], (b) => parseInt(b, 16));
+const hex = (data) => Buffer.from(data.subarray()).toString('hex');
+const collect = async (source) => {
+    const out = [];
+    for await (const value of source)
+        out.push(value);
+    return out;
+};
+const validCases = vectors.cases.filter((entry) => Boolean(entry.packet_hex && entry.frame_hex));
+describe('packet codec golden vectors', () => {
+    it.each(validCases)('$name has exact protobuf and frame bytes', async (entry) => {
+        const packet = Packet.fromBinary(bytes(entry.packet_hex));
+        const encoded = (await collect(encodePacketSource((async function* () {
+            yield packet;
+        })())))[0];
+        expect(hex(encoded)).toBe(entry.packet_hex);
+        const framed = (await collect(prependLengthPrefixTransform()((async function* () {
+            yield encoded;
+        })())))[0];
+        expect(hex(framed)).toBe(entry.frame_hex);
+    });
+    it('rejects zero and oversized encoded chunks', async () => {
+        const zero = (async function* () {
+            yield new Uint8Array();
+        })();
+        await expect(collect(prependLengthPrefixTransform()(zero))).rejects.toThrow('invalid packet length');
+        const oversized = (async function* () {
+            yield new Uint8Array(10_000_001);
+        })();
+        await expect(collect(prependLengthPrefixTransform()(oversized))).rejects.toThrow('invalid packet length');
+    });
+    it('rejects zero and oversized lengths, and truncated bodies', async () => {
+        const zero = (async function* () {
+            yield bytes('00000000');
+        })();
+        await expect(collect(lengthPrefixDecode(zero, uint32LEDecode))).rejects.toThrow('invalid packet length');
+        const oversized = (async function* () {
+            yield bytes('81969800');
+        })();
+        await expect(collect(lengthPrefixDecode(oversized, uint32LEDecode))).rejects.toThrow('invalid packet length');
+        const truncated = (async function* () {
+            yield bytes('040000000a01');
+        })();
+        await expect(collect(lengthPrefixDecode(truncated, uint32LEDecode))).rejects.toThrow('truncated packet frame');
+    });
+    it('decodes fragmented and coalesced frames', async () => {
+        const frames = validCases.map((entry) => bytes(entry.frame_hex));
+        const combined = new Uint8Array(frames.reduce((n, frame) => n + frame.length, 0));
+        let offset = 0;
+        for (const frame of frames) {
+            combined.set(frame, offset);
+            offset += frame.length;
+        }
+        const payloads = await collect(lengthPrefixDecode((async function* () {
+            yield combined.subarray(0, 3);
+            yield combined.subarray(3, 11);
+            yield combined.subarray(11);
+        })(), uint32LEDecode));
+        expect(payloads.map(hex)).toEqual(validCases.map((entry) => entry.packet_hex));
+        const decoded = await collect(decodePacketSource(payloads.map((payload) => payload.slice())));
+        expect(decoded).toHaveLength(validCases.length);
+    });
+    it('rejects malformed protobuf and incomplete frame prefix', async () => {
+        const malformed = vectors.cases.find((entry) => entry.name === 'malformed_complete');
+        expect(() => Packet.fromBinary(bytes(malformed.frame_hex.slice(8)))).toThrow();
+        const incomplete = (async function* () {
+            yield bytes('010203');
+        })();
+        await expect(collect(lengthPrefixDecode(incomplete, uint32LEDecode))).rejects.toThrow('truncated packet frame');
+    });
+});

package/dist/srpc/packet.d.ts

@@ -12,7 +12,7 @@ export declare namespace uint32LEEncode {
     var bytes: number;
 }
 export declare function lengthPrefixEncode(source: Source<Uint8Array | Uint8ArrayList>, lengthEncoder: typeof uint32LEEncode): AsyncGenerator<Uint8ArrayList<ArrayBufferLike>, void, unknown>;
-export declare function lengthPrefixDecode(source: Source<Uint8Array | Uint8ArrayList>, lengthDecoder: typeof uint32LEDecode): AsyncGenerator<Uint8ArrayList<ArrayBufferLike>, void, unknown>;
+export declare function lengthPrefixDecode(source: Source<Uint8Array | Uint8ArrayList>, lengthDecoder: typeof uint32LEDecode): AsyncGenerator<Uint8ArrayList>;
 export declare function prependLengthPrefixTransform(lengthEncoder?: {
     (value: number): Uint8ArrayList<ArrayBuffer>;
     bytes: number;

package/dist/srpc/packet.js

@@ -1,6 +1,7 @@
 import { Uint8ArrayList } from 'uint8arraylist';
 import { Packet } from './rpcproto.pb.js';
 import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
+const MAX_MESSAGE_SIZE = 10_000_000;
 // decodePacketSource decodes packets from a binary data stream.
 export const decodePacketSource = buildDecodeMessageTransform(Packet);
 // encodePacketSource encodes packets from a packet object stream.
@@ -25,6 +26,9 @@ export async function* lengthPrefixEncode(source, lengthEncoder) {
     for await (const chunk of source) {
         // Encode the length of the chunk.
         const length = chunk instanceof Uint8Array ? chunk.length : chunk.byteLength;
+        if (length === 0 || length > MAX_MESSAGE_SIZE) {
+            throw RangeError(`invalid packet length: ${length}`);
+        }
         const lengthEncoded = lengthEncoder(length);
         // Concatenate the length prefix and the data.
         yield new Uint8ArrayList(lengthEncoded, chunk);
@@ -38,16 +42,22 @@ export async function* lengthPrefixDecode(source, lengthDecoder) {
         // Continue extracting messages while buffer contains enough data for decoding.
         while (buffer.length >= lengthDecoder.bytes) {
             const messageLength = lengthDecoder(buffer);
+            if (messageLength === 0 || messageLength > MAX_MESSAGE_SIZE) {
+                throw RangeError(`invalid packet length: ${messageLength}`);
+            }
             const totalLength = lengthDecoder.bytes + messageLength;
             if (buffer.length < totalLength)
                 break; // Wait for more data if the full message hasn't arrived.
             // Extract the message excluding the length prefix.
-            const message = buffer.sublist(lengthDecoder.bytes, totalLength);
+            const message = new Uint8ArrayList(buffer.slice(lengthDecoder.bytes, totalLength));
             yield message;
             // Remove the processed message from the buffer.
             buffer.consume(totalLength);
         }
     }
+    if (buffer.length !== 0) {
+        throw new RangeError('truncated packet frame');
+    }
 }
 // prependLengthPrefixTransform adds a length prefix to a message source.
 // little-endian uint32