starpc 0.50.0 → 0.52.0

package/dist/srpc/common-rpc.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-import { Packet, TerminalKind, } from './rpcproto.pb.js';
+import { Packet } from './rpcproto.pb.js';
 import { ERR_RPC_ABORT, RemoteRPCError } from './errors.js';
 const maxBufferedOutgoingPackets = 1;
 // CommonRPC is common logic between server and client RPCs.
@@ -24,25 +24,13 @@ export class CommonRPC {
     method;
     // closed indicates this rpc has been closed already.
     closed;
-    // remoteCompleted is set only by an explicit remote CallData completion.
-    remoteCompleted = false;
     // remoteError records a remote error or transport failure.
     remoteError;
-    // remoteSourceClosed records an incoming source ending without a packet error.
-    remoteSourceClosed = false;
-    // remoteTerminal is the first valid remote terminal.
-    remoteTerminal;
-    // invocationController cancels the server invocation on a remote terminal.
+    // invocationController cancels the server invocation when the RPC closes.
     invocationController = new AbortController();
-    // terminalPromise resolves when a remote terminal is recorded.
-    terminalPromise;
-    resolveTerminal;
     // writeDrainAbort wakes writers waiting for outbound stream drain on close.
     writeDrainAbort = new AbortController();
     constructor() {
-        const { promise, resolve } = Promise.withResolvers();
-        this.terminalPromise = promise;
-        this.resolveTerminal = resolve;
         this.sink = this._createSink();
         this.source = this._source;
         this.rpcDataSource = this._rpcDataSource;
@@ -51,49 +39,10 @@ export class CommonRPC {
     get isClosed() {
         return this.closed ?? false;
     }
-    // invocationSignal is canceled when the RPC reaches a terminal.
+    // invocationSignal is canceled when the RPC closes.
     get invocationSignal() {
         return this.invocationController.signal;
     }
-    // waitTerminal waits for the remote terminal or external owner cancellation.
-    async waitTerminal(ownerSignal) {
-        const { promise: ownerDone, resolve: resolveOwnerDone } = Promise.withResolvers();
-        const onAbort = () => resolveOwnerDone();
-        ownerSignal.addEventListener('abort', onAbort, { once: true });
-        let ownerAborted = ownerSignal.aborted;
-        try {
-            for (;;) {
-                const terminal = this.getTerminalKind();
-                if (terminal !== undefined) {
-                    if (terminal === TerminalKind.CLOSED &&
-                        this.remoteSourceClosed &&
-                        !this.closed) {
-                        await this.close();
-                    }
-                    return terminal;
-                }
-                if (ownerAborted) {
-                    return TerminalKind.ABANDONED;
-                }
-                await Promise.race([this.terminalPromise, ownerDone]);
-                ownerAborted = ownerSignal.aborted;
-            }
-        }
-        finally {
-            ownerSignal.removeEventListener('abort', onAbort);
-        }
-    }
-    // getTerminalKind returns the observed remote terminal, if any.
-    getTerminalKind() {
-        return this.remoteTerminal;
-    }
-    recordRemoteTerminal(kind) {
-        if (this.remoteTerminal !== undefined) {
-            return;
-        }
-        this.remoteTerminal = kind;
-        this.resolveTerminal();
-    }
     // writeCallData writes the call data packet.
     async writeCallData(data, complete, error) {
         await this.writeCallDataPacket(data, complete, error);
@@ -221,20 +170,16 @@ export class CommonRPC {
         if (remoteError) {
             this.remoteError ??= remoteError;
             this.invocationController.abort();
-            this.recordRemoteTerminal(TerminalKind.TRANSPORT_LOST);
         }
         if (packet.complete && !remoteError) {
-            this.remoteCompleted = true;
-            this.recordRemoteTerminal(TerminalKind.COMMITTED);
             this._rpcDataSource.end(remoteError);
         }
         else if (remoteError) {
             this._rpcDataSource.end(remoteError);
         }
     }
-    // handleCallCancel handles a CallCancel packet.
+    // handleCallCancel aborts the invocation and closes the call.
     async handleCallCancel() {
-        this.recordRemoteTerminal(TerminalKind.CANCELED);
         await this.close(new Error(ERR_RPC_ABORT));
     }
     // close closes the call, optionally with an error.
@@ -246,7 +191,6 @@ export class CommonRPC {
         if (!this.remoteError && err) {
             this.remoteError = err;
         }
-        this.recordRemoteTerminal(err ? TerminalKind.TRANSPORT_LOST : TerminalKind.CLOSED);
         this.invocationController.abort();
         // note: this does nothing if _source is already ended.
         if (err && err.message) {
@@ -272,8 +216,6 @@ export class CommonRPC {
                         await this.handlePacket(msg);
                     }
                 }
-                this.remoteSourceClosed = true;
-                this.recordRemoteTerminal(TerminalKind.CLOSED);
             }
             catch (err) {
                 this.close(err);

package/dist/srpc/handler.d.ts

@@ -1,7 +1,14 @@
 import type { Sink, Source } from 'it-stream-types';
-import { ServiceDefinition, ServiceMethodDefinitions } from './definition.js';
-import type { ServerInvocation } from './server-invocation.js';
-export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>, invocation?: ServerInvocation) => Promise<void>;
+import { MethodKind, type MessageType } from '@aptre/protobuf-es-lite';
+import type { MessageStream } from './message.js';
+import { type MethodDefinition, ServiceDefinition, ServiceMethodDefinitions } from './definition.js';
+import type { ServerContext } from './server-context.js';
+type MessageOf<T> = T extends MessageType<infer M> ? M : never;
+type ServerMethod<T> = T extends MethodDefinition<infer Request, infer Response, infer Kind, infer _Idempotency> ? Kind extends MethodKind.Unary ? (request: MessageOf<Request>, abortSignal: AbortSignal, context: ServerContext) => Promise<MessageOf<Response>> : Kind extends MethodKind.ServerStreaming ? (request: MessageOf<Request>, abortSignal: AbortSignal, context: ServerContext) => MessageStream<MessageOf<Response>> : Kind extends MethodKind.ClientStreaming ? (request: MessageStream<MessageOf<Request>>, abortSignal: AbortSignal, context: ServerContext) => Promise<MessageOf<Response>> : (request: MessageStream<MessageOf<Request>>, abortSignal: AbortSignal, context: ServerContext) => MessageStream<MessageOf<Response>> : never;
+export type HandlerImplementation<T extends ServiceMethodDefinitions> = Partial<{
+    [Method in keyof T]: ServerMethod<T[Method]>;
+}>;
+export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>, context: ServerContext) => Promise<void>;
 export interface Handler {
     getServiceID(): string;
     getMethodIDs(): string[];
@@ -18,4 +25,5 @@ export declare class StaticHandler implements Handler {
     getMethodIDs(): string[];
     lookupMethod(serviceID: string, methodID: string): Promise<InvokeFn | null>;
 }
-export declare function createHandler<T extends ServiceMethodDefinitions = ServiceMethodDefinitions>(definition: ServiceDefinition<T>, impl: any, serviceID?: string): Handler;
+export declare function createHandler<T extends ServiceMethodDefinitions = ServiceMethodDefinitions>(definition: ServiceDefinition<T>, impl: HandlerImplementation<T>, serviceID?: string): Handler;
+export {};

package/dist/srpc/index.d.ts

@@ -1,9 +1,5 @@
 export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
-export { CallReceipt } from './call-receipt.js';
-export type { HeldCall, ReceiptRpc } from './call-receipt.js';
-export { ServerInvocation } from './server-invocation.js';
-export { TerminalKind } from './rpcproto.pb.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';
 export type { StreamConnParams, StreamHandler } from './conn.js';
@@ -31,3 +27,5 @@ export { HandleStreamCtr } from './handle-stream-ctr.js';
 export { writeToPushable, buildPushableSink, messagePushable, } from './pushable.js';
 export { Watchdog } from './watchdog.js';
 export type { ProtoRpc } from './proto-rpc.js';
+export { createContextKey, serverContextValue, withServerContextValue, } from './server-context.js';
+export type { ContextKey, ServerContext } from './server-context.js';

package/dist/srpc/index.js

@@ -1,8 +1,5 @@
 export { ERR_RPC_ABORT, isAbortError, ERR_STREAM_IDLE, isStreamIdleError, castToError, } from './errors.js';
 export { Client } from './client.js';
-export { CallReceipt } from './call-receipt.js';
-export { ServerInvocation } from './server-invocation.js';
-export { TerminalKind } from './rpcproto.pb.js';
 export { Server } from './server.js';
 export { StreamConn } from './conn.js';
 export { WebSocketConn } from './websocket.js';
@@ -21,3 +18,4 @@ export { OpenStreamCtr } from './open-stream-ctr.js';
 export { HandleStreamCtr } from './handle-stream-ctr.js';
 export { writeToPushable, buildPushableSink, messagePushable, } from './pushable.js';
 export { Watchdog } from './watchdog.js';
+export { createContextKey, serverContextValue, withServerContextValue, } from './server-context.js';

package/dist/srpc/invoker.d.ts

@@ -1,7 +1,7 @@
 import type { MethodDefinition } from './definition.js';
+import type { ServerContext } from './server-context.js';
 import { InvokeFn } from './handler.js';
 import type { MessageType, Message } from '@aptre/protobuf-es-lite';
 import { MethodIdempotency, MethodKind } from '@aptre/protobuf-es-lite';
-import type { ServerInvocation } from './server-invocation.js';
-export type MethodProto<R extends Message<R>, O extends Message<O>> = ((request: R, invocation?: ServerInvocation) => Promise<O>) | ((request: R, invocation?: ServerInvocation) => AsyncIterable<O>) | ((request: AsyncIterable<R>, invocation?: ServerInvocation) => Promise<O>) | ((request: AsyncIterable<R>, invocation?: ServerInvocation) => AsyncIterable<O>);
+export type MethodProto<R extends Message<R>, O extends Message<O>> = ((request: R, abortSignal: AbortSignal, context: ServerContext) => Promise<O>) | ((request: R, abortSignal: AbortSignal, context: ServerContext) => AsyncIterable<O>) | ((request: AsyncIterable<R>, abortSignal: AbortSignal, context: ServerContext) => Promise<O>) | ((request: AsyncIterable<R>, abortSignal: AbortSignal, context: ServerContext) => AsyncIterable<O>);
 export declare function createInvokeFn<R extends Message<R>, O extends Message<O>>(methodInfo: MethodDefinition<MessageType<R>, MessageType<O>, MethodKind, MethodIdempotency | undefined>, methodProto: MethodProto<R, O>): InvokeFn;

package/dist/srpc/invoker.js

@@ -6,7 +6,7 @@ import { MethodKind } from '@aptre/protobuf-es-lite';
 // createInvokeFn builds an InvokeFn from a method definition and a function prototype.
 export function createInvokeFn(methodInfo, methodProto) {
     const requestDecode = buildDecodeMessageTransform(methodInfo.I);
-    return async (dataSource, dataSink, invocation) => {
+    return async (dataSource, dataSink, context) => {
         // responseSink is a Sink for response messages.
         const responseSink = pushable({
             objectMode: true,
@@ -34,7 +34,7 @@ export function createInvokeFn(methodInfo, methodProto) {
         }
         // Call the implementation.
         try {
-            const responseObj = methodProto(requestArg, invocation);
+            const responseObj = methodProto(requestArg, context.signal, context);
             if (!responseObj) {
                 throw new Error('return value was undefined');
             }

package/dist/srpc/rpcproto.pb.d.ts

@@ -1,49 +1,5 @@
 import type { MessageType } from '@aptre/protobuf-es-lite/message';
 export declare const protobufPackage = "srpc";
-/**
- * TerminalKind is the terminal state of a held unary invocation.
- *
- * @generated from enum srpc.TerminalKind
- */
-export declare enum TerminalKind {
-    /**
-     * TERMINAL_KIND_UNSPECIFIED is not a valid terminal state.
-     *
-     * @generated from enum value: TERMINAL_KIND_UNSPECIFIED = 0;
-     */
-    UNSPECIFIED = 0,
-    /**
-     * TERMINAL_KIND_COMMITTED identifies an explicit remote CallData completion.
-     *
-     * @generated from enum value: TERMINAL_KIND_COMMITTED = 1;
-     */
-    COMMITTED = 1,
-    /**
-     * TERMINAL_KIND_CANCELED identifies a remote CallCancel packet.
-     *
-     * @generated from enum value: TERMINAL_KIND_CANCELED = 2;
-     */
-    CANCELED = 2,
-    /**
-     * TERMINAL_KIND_TRANSPORT_LOST identifies a remote error or transport failure.
-     *
-     * @generated from enum value: TERMINAL_KIND_TRANSPORT_LOST = 3;
-     */
-    TRANSPORT_LOST = 3,
-    /**
-     * TERMINAL_KIND_CLOSED identifies a bare remote close without completion.
-     *
-     * @generated from enum value: TERMINAL_KIND_CLOSED = 4;
-     */
-    CLOSED = 4,
-    /**
-     * TERMINAL_KIND_ABANDONED identifies owner-context expiry without a remote terminal.
-     *
-     * @generated from enum value: TERMINAL_KIND_ABANDONED = 5;
-     */
-    ABANDONED = 5
-}
-export declare const TerminalKind_Enum: import("@aptre/protobuf-es-lite/enum").EnumType;
 /**
  * CallStart requests starting a new RPC call.
  *

package/dist/srpc/rpcproto.pb.js

@@ -1,62 +1,9 @@
 // @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/srpc/rpcproto.proto (package srpc, syntax proto3)
 /* eslint-disable */
-import { createEnumType } from '@aptre/protobuf-es-lite/enum';
 import { createMessageType } from '@aptre/protobuf-es-lite/message';
 import { ScalarType } from '@aptre/protobuf-es-lite/scalar';
 export const protobufPackage = 'srpc';
-/**
- * TerminalKind is the terminal state of a held unary invocation.
- *
- * @generated from enum srpc.TerminalKind
- */
-export var TerminalKind;
-(function (TerminalKind) {
-    /**
-     * TERMINAL_KIND_UNSPECIFIED is not a valid terminal state.
-     *
-     * @generated from enum value: TERMINAL_KIND_UNSPECIFIED = 0;
-     */
-    TerminalKind[TerminalKind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
-    /**
-     * TERMINAL_KIND_COMMITTED identifies an explicit remote CallData completion.
-     *
-     * @generated from enum value: TERMINAL_KIND_COMMITTED = 1;
-     */
-    TerminalKind[TerminalKind["COMMITTED"] = 1] = "COMMITTED";
-    /**
-     * TERMINAL_KIND_CANCELED identifies a remote CallCancel packet.
-     *
-     * @generated from enum value: TERMINAL_KIND_CANCELED = 2;
-     */
-    TerminalKind[TerminalKind["CANCELED"] = 2] = "CANCELED";
-    /**
-     * TERMINAL_KIND_TRANSPORT_LOST identifies a remote error or transport failure.
-     *
-     * @generated from enum value: TERMINAL_KIND_TRANSPORT_LOST = 3;
-     */
-    TerminalKind[TerminalKind["TRANSPORT_LOST"] = 3] = "TRANSPORT_LOST";
-    /**
-     * TERMINAL_KIND_CLOSED identifies a bare remote close without completion.
-     *
-     * @generated from enum value: TERMINAL_KIND_CLOSED = 4;
-     */
-    TerminalKind[TerminalKind["CLOSED"] = 4] = "CLOSED";
-    /**
-     * TERMINAL_KIND_ABANDONED identifies owner-context expiry without a remote terminal.
-     *
-     * @generated from enum value: TERMINAL_KIND_ABANDONED = 5;
-     */
-    TerminalKind[TerminalKind["ABANDONED"] = 5] = "ABANDONED";
-})(TerminalKind || (TerminalKind = {}));
-export const TerminalKind_Enum = /* @__PURE__ */ createEnumType('srpc.TerminalKind', [
-    [0, 'TERMINAL_KIND_UNSPECIFIED'],
-    [1, 'TERMINAL_KIND_COMMITTED'],
-    [2, 'TERMINAL_KIND_CANCELED'],
-    [3, 'TERMINAL_KIND_TRANSPORT_LOST'],
-    [4, 'TERMINAL_KIND_CLOSED'],
-    [5, 'TERMINAL_KIND_ABANDONED'],
-]);
 export const CallStart = 
 /* @__PURE__ */ createMessageType({
     typeName: 'srpc.CallStart',

package/dist/srpc/server-context.d.ts

@@ -0,0 +1,11 @@
+declare const contextKeyValue: unique symbol;
+export interface ContextKey<T> {
+    readonly [contextKeyValue]?: T;
+}
+export interface ServerContext {
+    readonly signal: AbortSignal;
+}
+export declare function createContextKey<T>(): ContextKey<T>;
+export declare function withServerContextValue<T>(context: ServerContext, key: ContextKey<T>, value: T): ServerContext;
+export declare function serverContextValue<T>(context: ServerContext, key: ContextKey<T>): T | undefined;
+export {};

package/dist/srpc/server-context.js

@@ -0,0 +1,28 @@
+const contextParent = Symbol('server context parent');
+const contextKey = Symbol('server context key');
+const contextStoredValue = Symbol('server context value');
+// createContextKey constructs an identity key for one server-context value.
+export function createContextKey() {
+    return {};
+}
+// withServerContextValue derives a context with one immutable typed value.
+export function withServerContextValue(context, key, value) {
+    const derived = {
+        signal: context.signal,
+        [contextParent]: context,
+        [contextKey]: key,
+        [contextStoredValue]: value,
+    };
+    return derived;
+}
+// serverContextValue retrieves the nearest value for a typed identity key.
+export function serverContextValue(context, key) {
+    let current = context;
+    while (current) {
+        if (current[contextKey] === key) {
+            return current[contextStoredValue];
+        }
+        current = current[contextParent];
+    }
+    return undefined;
+}

package/dist/srpc/server-rpc.js

@@ -1,5 +1,4 @@
 import { CommonRPC } from './common-rpc.js';
-import { ServerInvocation } from './server-invocation.js';
 // ServerRPC is an ongoing RPC from the server side.
 export class ServerRPC extends CommonRPC {
     // lookupMethod looks up the incoming RPC methods.
@@ -38,9 +37,10 @@ export class ServerRPC extends CommonRPC {
     // invokeRPC starts invoking the RPC handler.
     async invokeRPC(invokeFn) {
         const dataSink = this._createDataSink();
-        const invocation = new ServerInvocation(this.invocationSignal, (ownerSignal) => this.waitTerminal(ownerSignal));
         try {
-            await invokeFn(this.rpcDataSource, dataSink, invocation);
+            await invokeFn(this.rpcDataSource, dataSink, {
+                signal: this.invocationSignal,
+            });
         }
         catch (err) {
             this.close(err);

package/dist/srpc/server.test.js

@@ -1,7 +1,7 @@
 import { describe, it, beforeEach, expect, vi } from 'vitest';
 import { pipe } from 'it-pipe';
-import { createHandler, createMux, Server, Client, StreamConn, ChannelStream, combineUint8ArrayListTransform, Packet, } from '../srpc/index.js';
-import { EchoerDefinition, EchoerServer, EchoerServiceName, runClientTest, } from '../echo/index.js';
+import { createHandler, createMux, Server, Client, StreamConn, ChannelStream, combineUint8ArrayListTransform, Packet, createContextKey, serverContextValue, withServerContextValue, } from '../srpc/index.js';
+import { EchoerDefinition, EchoerServer, EchoerServiceName, EchoMsg, runClientTest, } from '../echo/index.js';
 import { runAbortControllerTest, runRpcStreamTest, } from '../echo/client-test.js';
 describe('srpc server', () => {
     let client;
@@ -39,6 +39,62 @@ describe('srpc server', () => {
     it('should pass rpc stream tests', async () => {
         await runRpcStreamTest(client);
     });
+    it('passes the exact invocation context after async request decode', async () => {
+        const controller = new AbortController();
+        const callerKey = createContextKey();
+        let observedAbortSignal;
+        let observedContextSignal;
+        let observedCaller;
+        const handler = createHandler(EchoerDefinition, {
+            Echo: async (request, abortSignal, context) => {
+                observedAbortSignal = abortSignal;
+                observedContextSignal = context.signal;
+                observedCaller = serverContextValue(context, callerKey);
+                return request;
+            },
+        });
+        const invokeFn = await handler.lookupMethod(EchoerServiceName, 'Echo');
+        if (!invokeFn) {
+            throw new Error('Echo method was not found');
+        }
+        const request = EchoMsg.create({ body: 'signal identity' });
+        const drained = Promise.withResolvers();
+        await invokeFn((async function* () {
+            await Promise.resolve();
+            yield EchoMsg.toBinary(request);
+        })(), async (source) => {
+            for await (const _data of source) {
+                // Drain the encoded response so the invocation pipeline completes.
+            }
+            drained.resolve();
+        }, withServerContextValue({ signal: controller.signal }, callerKey, 'caller-1'));
+        await drained.promise;
+        expect(observedAbortSignal).toBe(controller.signal);
+        expect(observedContextSignal).toBe(controller.signal);
+        expect(observedCaller).toBe('caller-1');
+    });
+    it('keeps two-argument server handlers compatible', async () => {
+        const controller = new AbortController();
+        let observedSignal;
+        const handler = createHandler(EchoerDefinition, {
+            Echo: async (request, abortSignal) => {
+                observedSignal = abortSignal;
+                return request;
+            },
+        });
+        const invokeFn = await handler.lookupMethod(EchoerServiceName, 'Echo');
+        if (!invokeFn)
+            throw new Error('Echo method was not found');
+        const request = EchoMsg.create({ body: 'legacy handler' });
+        await invokeFn((async function* () {
+            yield EchoMsg.toBinary(request);
+        })(), async (source) => {
+            for await (const _data of source) {
+                // Drain the response.
+            }
+        }, { signal: controller.signal });
+        expect(observedSignal).toBe(controller.signal);
+    });
     it('keeps detached server-streaming responses open after request source completes', async () => {
         const mux = createMux();
         const response = new TextEncoder().encode('delayed init');
@@ -166,6 +222,13 @@ describe('srpc server', () => {
         await new Promise((resolve) => setTimeout(resolve, 50));
         expect(removeEventListener).toHaveBeenCalledWith('abort', expect.any(Function));
     });
+    it('settles a late abort after the call has already closed', async () => {
+        const controller = new AbortController();
+        vi.spyOn(controller.signal, 'removeEventListener').mockImplementation(() => undefined);
+        await client.request(EchoerServiceName, 'Echo', new TextEncoder().encode('late abort'), controller.signal);
+        controller.abort();
+        await Promise.resolve();
+    });
     it('tears down passive channel close state', async () => {
         const { port1, port2 } = new MessageChannel();
         const opts = { idleTimeoutMs: 1000, keepAliveMs: 1000 };

package/dist/srpc/watchdog.test.js

@@ -5,6 +5,7 @@ describe('Watchdog', () => {
         vi.useFakeTimers();
     });
     afterEach(() => {
+        vi.useRealTimers();
         vi.restoreAllMocks();
     });
     it('should call expired callback after timeout', () => {

package/echo/echo.go

@@ -7,15 +7,15 @@ import (
 
 // _ is a type assertion
 var (
-	_ srpc.StreamRecv[*EchoMsg] = (SRPCEchoer_EchoBidiStreamClient)(nil)
-	_ srpc.StreamRecv[*EchoMsg] = (SRPCEchoer_EchoServerStreamClient)(nil)
+	_ srpc.StreamRecv[*EchoMsg] = SRPCEchoer_EchoBidiStreamClient(nil)
+	_ srpc.StreamRecv[*EchoMsg] = SRPCEchoer_EchoServerStreamClient(nil)
 
-	_ srpc.StreamSend[*EchoMsg] = (SRPCEchoer_EchoBidiStreamClient)(nil)
-	_ srpc.StreamSend[*EchoMsg] = (SRPCEchoer_EchoClientStreamClient)(nil)
+	_ srpc.StreamSend[*EchoMsg] = SRPCEchoer_EchoBidiStreamClient(nil)
+	_ srpc.StreamSend[*EchoMsg] = SRPCEchoer_EchoClientStreamClient(nil)
 
-	_ srpc.StreamSendAndClose[*EchoMsg] = (SRPCEchoer_EchoBidiStreamStream)(nil)
-	_ srpc.StreamSendAndClose[*EchoMsg] = (SRPCEchoer_EchoServerStreamStream)(nil)
+	_ srpc.StreamSendAndClose[*EchoMsg] = SRPCEchoer_EchoBidiStreamStream(nil)
+	_ srpc.StreamSendAndClose[*EchoMsg] = SRPCEchoer_EchoServerStreamStream(nil)
 
-	_ srpc.StreamRecv[*rpcstream.RpcStreamPacket]         = (SRPCEchoer_RpcStreamStream)(nil)
-	_ srpc.StreamSendAndClose[*rpcstream.RpcStreamPacket] = (SRPCEchoer_RpcStreamStream)(nil)
+	_ srpc.StreamRecv[*rpcstream.RpcStreamPacket]         = SRPCEchoer_RpcStreamStream(nil)
+	_ srpc.StreamSendAndClose[*rpcstream.RpcStreamPacket] = SRPCEchoer_RpcStreamStream(nil)
 )

package/echo/echo.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-lite. DO NOT EDIT.
-// protoc-gen-go-lite version: v0.13.0
+// protoc-gen-go-lite version: v0.16.0
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 package echo
@@ -8,8 +8,6 @@ import (
 	fmt "fmt"
 	io "io"
 	slices "slices"
-	strconv "strconv"
-	strings "strings"
 
 	protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
 	json "github.com/aperturerobotics/protobuf-go-lite/json"
@@ -141,13 +139,10 @@ func (m *EchoMsg) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if m.unknownFields != nil {
-		i -= len(m.unknownFields)
-		copy(dAtA[i:], m.unknownFields)
+		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
 	}
 	if len(m.Body) > 0 {
-		i -= len(m.Body)
-		copy(dAtA[i:], m.Body)
-		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Body)))
+		i = protobuf_go_lite.EncodeString(dAtA, i, m.Body)
 		i--
 		dAtA[i] = 0xa
 	}
@@ -160,26 +155,19 @@ func (m *EchoMsg) SizeVT() (n int) {
 	}
 	var l int
 	_ = l
-	l = len(m.Body)
-	if l > 0 {
-		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
-	}
+	n += protobuf_go_lite.SizeStringNonEmpty(1, m.Body)
 	n += len(m.unknownFields)
 	return n
 }
 
 func (x *EchoMsg) MarshalProtoText() string {
-	var sb strings.Builder
-	sb.WriteString("EchoMsg {")
+	var sb protobuf_go_lite.TextBuilder
+	initialLen := protobuf_go_lite.TextStartMessage(&sb, "EchoMsg")
 	if x.Body != "" {
-		if sb.Len() > 9 {
-			sb.WriteString(" ")
-		}
-		sb.WriteString("body: ")
-		sb.WriteString(strconv.Quote(x.Body))
+		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "body")
+		protobuf_go_lite.TextWriteString(&sb, x.Body)
 	}
-	sb.WriteString("}")
-	return sb.String()
+	return protobuf_go_lite.TextFinishMessage(&sb)
 }
 
 func (x *EchoMsg) String() string {
@@ -210,24 +198,12 @@ func (m *EchoMsg) UnmarshalVT(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
 			}
-			var stringLen uint64
-			stringLen, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
+			var v string
+			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
 			if err != nil {
 				return err
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return protobuf_go_lite.ErrInvalidLength
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return protobuf_go_lite.ErrInvalidLength
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Body = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
+			m.Body = v
 		default:
 			iNdEx = preIndex
 			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])

package/echo/echo_srpc.pb.cpp

@@ -1,7 +1,7 @@
 //go:build deps_only
 
 // Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
-// protoc-gen-starpc-cpp version: v0.49.7
+// protoc-gen-starpc-cpp version: v0.49.21
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #include "echo_srpc.pb.hpp"

package/echo/echo_srpc.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-srpc. DO NOT EDIT.
-// protoc-gen-srpc version: v0.49.7
+// protoc-gen-srpc version: v0.49.21
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 package echo

package/echo/echo_srpc.pb.hpp

@@ -1,7 +1,7 @@
 //go:build deps_only && cgo
 
 // Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
-// protoc-gen-starpc-cpp version: v0.49.7
+// protoc-gen-starpc-cpp version: v0.49.21
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #pragma once

package/echo/echo_srpc.pb.rs

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-starpc-rust. DO NOT EDIT.
-// protoc-gen-starpc-rust version: v0.49.7
+// protoc-gen-starpc-rust version: v0.49.21
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #[allow(unused_imports)]