starpc 0.49.17 → 0.49.20

package/integration/cross-language/run.bash

@@ -20,6 +20,8 @@ PASSED=0
 FAILED=0
 ERRORS=""
 
+SERVER_LOG=""
+
 # should_run checks if a test name matches the active filters.
 # Returns 0 (true) if the test should run, 1 (false) otherwise.
 should_run() {
@@ -77,27 +79,26 @@ RUST_CLIENT="$REPO_DIR/target/release/integration-client"
 CPP_SERVER="$REPO_DIR/build/cpp-integration-server"
 CPP_CLIENT="$REPO_DIR/build/cpp-integration-client"
 
-# Start a server and capture its address.
-# Sets SERVER_PID and SERVER_ADDR.
 start_server() {
-    local addr_file
-    addr_file=$(mktemp)
-    "$@" > "$addr_file" 2>&1 &
+    SERVER_LOG=$(mktemp)
+    "$@" > "$SERVER_LOG" 2>&1 &
     SERVER_PID=$!
     # Wait for LISTENING output (up to 3 seconds).
     local waited=0
     while [ $waited -lt 30 ]; do
-        if grep -q 'LISTENING' "$addr_file" 2>/dev/null; then
+        if grep -q 'LISTENING' "$SERVER_LOG" 2>/dev/null; then
             break
         fi
         sleep 0.1
         waited=$((waited + 1))
     done
-    SERVER_ADDR=$(grep 'LISTENING' "$addr_file" 2>/dev/null | awk '{print $2}')
-    rm -f "$addr_file"
+    SERVER_ADDR=$(grep 'LISTENING' "$SERVER_LOG" 2>/dev/null | awk '{print $2}')
     if [ -z "$SERVER_ADDR" ]; then
         echo "FAILED: server did not start"
         kill $SERVER_PID 2>/dev/null || true
+        wait $SERVER_PID 2>/dev/null || true
+        rm -f "$SERVER_LOG"
+        SERVER_LOG=""
         return 1
     fi
     return 0
@@ -110,6 +111,27 @@ stop_server() {
 
 # run_pair <test_name> <server_args...> -- <client_args...>
 # The client receives $SERVER_ADDR as its last argument.
+# check_receipt_events verifies terminal markers after the receipt server
+# naturally completes, so receipt synchronization is event/process-backed.
+check_receipt_events() {
+    local expected="$1"
+    local event_log="$2"
+    awk -v expected="$expected" '
+        $0 == "SERVER_RECEIPT_TERMINAL " expected { terminal = NR; next }
+        $0 == "SERVER_RECEIPT_ACK " expected { ack = NR; next }
+        $0 == "CLIENT_RECEIPT_RESOLVED " expected { client = NR; next }
+        END {
+            if (!terminal || !client) {
+                exit 1
+            }
+            if (expected == "committed" &&
+                (!ack || terminal >= ack || ack >= client)) {
+                exit 1
+            }
+        }
+    ' "$event_log"
+}
+
 run_pair() {
     local test_name="$1"
     shift
@@ -134,30 +156,104 @@ run_pair() {
         fi
     done
 
+    local expected_terminal=""
+    case "$test_name" in
+        *"receipt commit") expected_terminal="committed" ;;
+        *"receipt abort") expected_terminal="canceled" ;;
+        *"receipt loss") expected_terminal="transportLost" ;;
+        *"receipt bare-close") expected_terminal="closed" ;;
+    esac
+
     echo -n "  ${test_name}... "
 
+    local event_fifo=""
+    local event_log=""
+    local event_reader=""
+    if [ -n "$expected_terminal" ]; then
+        event_fifo=$(mktemp)
+        rm -f "$event_fifo"
+        mkfifo "$event_fifo"
+        event_log=$(mktemp)
+        exec 3<>"$event_fifo"
+        (
+            exec 3>&-
+            cat "$event_fifo" > "$event_log"
+        ) &
+        event_reader=$!
+        export RECEIPT_EVENT_FIFO="$event_fifo"
+    else
+        unset RECEIPT_EVENT_FIFO
+    fi
+
     if ! start_server "${srv_args[@]}"; then
         echo "FAILED (server start)"
         FAILED=$((FAILED + 1))
         ERRORS="${ERRORS}\n  ${test_name} (server start failed)"
+        if [ -n "$event_reader" ]; then
+            exec 3>&-
+            kill "$event_reader" 2>/dev/null || true
+            wait "$event_reader" 2>/dev/null || true
+            rm -f "$event_fifo" "$event_log"
+        fi
+        unset RECEIPT_EVENT_FIFO
         return
     fi
 
     local client_out
     client_out=$(mktemp)
+    local client_ok=false
+    local server_ok=true
     if "${cli_args[@]}" "$SERVER_ADDR" > "$client_out" 2>&1; then
+        client_ok=true
+    fi
+
+    if [ -n "$event_reader" ]; then
+        if $client_ok; then
+            if ! wait "$SERVER_PID"; then
+                server_ok=false
+            fi
+        else
+            stop_server
+            wait "$SERVER_PID" 2>/dev/null || true
+            server_ok=false
+        fi
+        exec 3>&-
+        wait "$event_reader" 2>/dev/null || true
+    else
+        stop_server
+    fi
+    unset RECEIPT_EVENT_FIFO
+
+    local terminal_ok=true
+    if [ -n "$expected_terminal" ] &&
+        ! check_receipt_events "$expected_terminal" "$event_log"; then
+        terminal_ok=false
+    fi
+
+    if $client_ok && $server_ok && $terminal_ok; then
         echo "PASSED"
+        if [ -n "$expected_terminal" ]; then
+            echo "    receipt events:"
+            sed 's/^/      /' "$event_log"
+        fi
         PASSED=$((PASSED + 1))
     else
         echo "FAILED"
         FAILED=$((FAILED + 1))
         ERRORS="${ERRORS}\n  ${test_name}"
-        echo "    client output:"
-        sed 's/^/    /' "$client_out"
+        if ! $client_ok; then
+            echo "    client output:"
+            sed 's/^/    /' "$client_out"
+        fi
+        if ! $terminal_ok; then
+            echo "    receipt events:"
+            sed 's/^/    /' "$event_log"
+            echo "    server output:"
+            sed 's/^/    /' "$SERVER_LOG"
+        fi
     fi
-    rm -f "$client_out"
-
-    stop_server
+    rm -f "$client_out" "$SERVER_LOG" "$event_fifo" "$event_log"
+    SERVER_LOG=""
 }
 
 echo ""
@@ -168,6 +264,10 @@ echo ""
 run_pair "go-server + go-client"   "$GO_SERVER" -- "$GO_CLIENT"
 run_pair "go-server + rust-client" "$GO_SERVER" -- "$RUST_CLIENT"
 run_pair "go-server + ts-client"   "$GO_SERVER" -- node "$TS_CLIENT"
+run_pair "go-server + ts-client receipt commit" "$GO_SERVER" receipt commit -- node "$TS_CLIENT" receipt commit
+run_pair "go-server + ts-client receipt abort" "$GO_SERVER" receipt abort -- node "$TS_CLIENT" receipt abort
+run_pair "go-server + ts-client receipt loss" "$GO_SERVER" receipt loss -- node "$TS_CLIENT" receipt loss
+run_pair "go-server + ts-client receipt bare-close" "$GO_SERVER" receipt bare-close -- node "$TS_CLIENT" receipt bare-close
 run_pair "go-server + cpp-client"  "$GO_SERVER" -- "$CPP_CLIENT"
 
 # Rust server combinations
@@ -178,6 +278,10 @@ run_pair "rust-server + cpp-client"  "$RUST_SERVER" -- "$CPP_CLIENT"
 
 # TypeScript server combinations
 run_pair "ts-server + go-client"   node "$TS_SERVER" -- "$GO_CLIENT"
+run_pair "ts-server + go-client receipt commit" node "$TS_SERVER" receipt commit -- "$GO_CLIENT" receipt commit
+run_pair "ts-server + go-client receipt abort" node "$TS_SERVER" receipt abort -- "$GO_CLIENT" receipt abort
+run_pair "ts-server + go-client receipt loss" node "$TS_SERVER" receipt loss -- "$GO_CLIENT" receipt loss
+run_pair "ts-server + go-client receipt bare-close" node "$TS_SERVER" receipt bare-close -- "$GO_CLIENT" receipt bare-close
 run_pair "ts-server + rust-client" node "$TS_SERVER" -- "$RUST_CLIENT"
 run_pair "ts-server + ts-client"   node "$TS_SERVER" -- node "$TS_CLIENT"
 run_pair "ts-server + cpp-client"  node "$TS_SERVER" -- "$CPP_CLIENT"

package/integration/cross-language/ts-client.ts

@@ -1,4 +1,5 @@
 import net from 'net'
+import { closeSync, openSync, writeSync } from 'node:fs'
 import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
 import { Client } from '../../srpc/client.js'
@@ -7,9 +8,22 @@ import {
   prependLengthPrefixTransform,
 } from '../../srpc/packet.js'
 import { combineUint8ArrayListTransform } from '../../srpc/array-list.js'
-import { runClientTest } from '../../echo/client-test.js'
+import { EchoMsg, runClientTest } from '../../echo/index.js'
 import type { OpenStreamFunc, PacketStream } from '../../srpc/stream.js'
 import type { Source } from 'it-stream-types'
+function emitReceiptEvent(line: string): void {
+  console.log(line)
+  const fifo = process.env.RECEIPT_EVENT_FIFO
+  if (!fifo) {
+    return
+  }
+  const fd = openSync(fifo, 'w')
+  try {
+    writeSync(fd, `${line}\n`)
+  } finally {
+    closeSync(fd)
+  }
+}
 
 // tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
 function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
@@ -32,8 +46,7 @@ function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
     source: socketSource(),
     sink: async (source: Source<Uint8Array>): Promise<void> => {
       for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
-        const data =
-          chunk instanceof Uint8Array ? chunk : (chunk as any).subarray()
+        const data = chunk instanceof Uint8Array ? chunk : chunk.subarray()
         await new Promise<void>((resolve, reject) => {
           socket.write(data, (err) => {
             if (err) reject(err)
@@ -47,30 +60,98 @@ function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
 }
 
 async function main() {
-  const addr = process.argv[2]
+  const receiptMode = process.argv[2] === 'receipt'
+  const receiptCase = receiptMode ? process.argv[3] : undefined
+  const addr = receiptMode ? process.argv[4] : process.argv[2]
   if (!addr) {
-    console.error('usage: ts-client <host:port>')
+    console.error('usage: ts-client [receipt <case>] <host:port>')
     process.exit(1)
   }
+  if (
+    receiptMode &&
+    !['commit', 'abort', 'loss', 'bare-close'].includes(receiptCase ?? '')
+  ) {
+    throw new Error(`unknown receipt case: ${receiptCase}`)
+  }
 
   const [host, portStr] = addr.split(':')
   const port = parseInt(portStr, 10)
+  let activeSocket: net.Socket | undefined
 
   const openStream: OpenStreamFunc = async (): Promise<PacketStream> => {
-    return new Promise((resolve, reject) => {
-      const socket = net.connect(port, host, () => {
-        resolve(tcpSocketToPacketStream(socket))
-      })
-      socket.on('error', reject)
+    const { promise, resolve, reject } = Promise.withResolvers<PacketStream>()
+    const socket = net.connect(port, host, () => {
+      activeSocket = socket
+      resolve(tcpSocketToPacketStream(socket))
     })
+    socket.on('error', reject)
+    return promise
   }
 
   const client = new Client(openStream)
 
-  console.log('Running client test via TCP...')
-  await runClientTest(client)
+  if (receiptMode) {
+    console.log(`Running held receipt test via TCP (${receiptCase})...`)
+    const request = EchoMsg.create({ body: 'held receipt' })
+    const held = await client.requestWithReceipt(
+      'echo.Echoer',
+      'Echo',
+      EchoMsg.toBinary(request),
+    )
+    const result = EchoMsg.fromBinary(held.response)
+    if (result.body !== request.body) {
+      throw new Error(`expected ${request.body}, got ${result.body}`)
+    }
+    switch (receiptCase) {
+      case 'commit':
+        await held.receipt.commit()
+        break
+      case 'abort':
+        await held.receipt.abort()
+        break
+      case 'loss':
+        activeSocket?.resetAndDestroy()
+        await expectReceiptFailure(held.receipt)
+        break
+      case 'bare-close':
+        activeSocket?.end()
+        await expectReceiptFailure(held.receipt)
+        break
+    }
+    emitReceiptEvent(
+      `CLIENT_RECEIPT_RESOLVED ${receiptTerminalName(receiptCase ?? '')}`,
+    )
+  } else {
+    console.log('Running client test via TCP...')
+    await runClientTest(client)
+  }
   console.log('All tests passed.')
-  process.exit(0)
+}
+
+function receiptTerminalName(receiptCase: string): string {
+  switch (receiptCase) {
+    case 'commit':
+      return 'committed'
+    case 'abort':
+      return 'canceled'
+    case 'loss':
+      return 'transportLost'
+    case 'bare-close':
+      return 'closed'
+    default:
+      return 'unknown'
+  }
+}
+
+async function expectReceiptFailure(receipt: {
+  commit(): Promise<void>
+}): Promise<void> {
+  try {
+    await receipt.commit()
+  } catch {
+    return
+  }
+  throw new Error('receipt commit unexpectedly succeeded')
 }
 
 process.on('unhandledRejection', (ev) => {

package/integration/cross-language/ts-server.ts

@@ -1,4 +1,5 @@
 import net from 'net'
+import { closeSync, openSync, writeSync } from 'node:fs'
 import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
 import { createMux, createHandler, Server } from '../../srpc/index.js'
@@ -7,10 +8,24 @@ import {
   prependLengthPrefixTransform,
 } from '../../srpc/packet.js'
 import { combineUint8ArrayListTransform } from '../../srpc/array-list.js'
-import { EchoerServer } from '../../echo/server.js'
+import { EchoerServer, EchoMsg } from '../../echo/index.js'
 import { EchoerDefinition } from '../../echo/echo_srpc.pb.js'
+import { Packet } from '../../srpc/rpcproto.pb.js'
 import type { PacketStream } from '../../srpc/stream.js'
 import type { Source } from 'it-stream-types'
+function emitReceiptEvent(line: string): void {
+  console.log(line)
+  const fifo = process.env.RECEIPT_EVENT_FIFO
+  if (!fifo) {
+    return
+  }
+  const fd = openSync(fifo, 'w')
+  try {
+    writeSync(fd, `${line}\n`)
+  } finally {
+    closeSync(fd)
+  }
+}
 
 // tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
 // Each Uint8Array in source/sink is one packet (no length prefix).
@@ -35,14 +50,26 @@ function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
     source: socketSource(),
     sink: async (source: Source<Uint8Array>): Promise<void> => {
       for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
-        const data =
-          chunk instanceof Uint8Array ? chunk : (chunk as any).subarray()
-        await new Promise<void>((resolve, reject) => {
+        const data = chunk instanceof Uint8Array ? chunk : chunk.subarray()
+        const packet = Packet.fromBinary(data.subarray(4))
+        const receiptCompletion =
+          receiptMode &&
+          packet.body?.case === 'callData' &&
+          packet.body.value.complete &&
+          !packet.body.value.error
+        const writeDone = new Promise<void>((resolve, reject) => {
           socket.write(data, (err) => {
             if (err) reject(err)
             else resolve()
           })
         })
+        if (receiptCompletion) {
+          emitReceiptEvent('SERVER_RECEIPT_ACK committed')
+        }
+        await writeDone
+        if (receiptCompletion) {
+          finishReceiptServer()
+        }
       }
       socket.end()
     },
@@ -50,9 +77,64 @@ function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
 }
 
 const mux = createMux()
+const receiptMode = process.argv[2] === 'receipt'
+const receiptCase = receiptMode ? process.argv[3] : undefined
+if (
+  receiptMode &&
+  !['commit', 'abort', 'loss', 'bare-close'].includes(receiptCase ?? '')
+) {
+  console.error(`unknown receipt case: ${receiptCase}`)
+  process.exit(1)
+}
+
+const receiptServerDone = Promise.withResolvers<void>()
+let receiptServerFinished = false
+function finishReceiptServer(): void {
+  if (!receiptServerFinished) {
+    receiptServerFinished = true
+    receiptServerDone.resolve()
+  }
+}
+
+if (receiptMode) {
+  mux.registerLookupMethod(async (serviceID, methodID) => {
+    if (serviceID !== 'echo.Echoer' || methodID !== 'Echo') {
+      return null
+    }
+    return async (dataSource, dataSink, invocation) => {
+      let requestData: Uint8Array | undefined
+      for await (const data of dataSource) {
+        requestData = data
+        break
+      }
+      if (!requestData) {
+        throw new Error('receipt request was empty')
+      }
+      const requestMsg = EchoMsg.fromBinary(requestData)
+      await dataSink(
+        (async function* () {
+          yield EchoMsg.toBinary(requestMsg)
+          if (!invocation) {
+            throw new Error('receipt invocation was missing')
+          }
+          emitReceiptEvent('SERVER_RECEIPT_WAITING')
+          const terminal = await invocation.waitTerminal(
+            new AbortController().signal,
+          )
+          emitReceiptEvent(`SERVER_RECEIPT_TERMINAL ${terminal}`)
+          if (terminal !== 'committed') {
+            finishReceiptServer()
+          }
+        })(),
+      )
+    }
+  })
+}
 const server = new Server(mux.lookupMethod)
-const echoer = new EchoerServer(server)
-mux.register(createHandler(EchoerDefinition, echoer))
+if (!receiptMode) {
+  const echoer = new EchoerServer(server)
+  mux.register(createHandler(EchoerDefinition, echoer))
+}
 
 const tcpServer = net.createServer((socket) => {
   const stream = tcpSocketToPacketStream(socket)
@@ -64,6 +146,12 @@ tcpServer.listen(0, '127.0.0.1', () => {
   console.log(`LISTENING ${addr.address}:${addr.port}`)
 })
 
+if (receiptMode) {
+  void receiptServerDone.promise.then(() => {
+    tcpServer.close()
+  })
+}
+
 process.on('SIGINT', () => {
   tcpServer.close()
   process.exit(0)

package/mock/mock.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-lite. DO NOT EDIT.
-// protoc-gen-go-lite version: v0.12.1
+// protoc-gen-go-lite version: v0.13.0
 // source: github.com/aperturerobotics/starpc/mock/mock.proto
 
 package e2e_mock

package/mock/mock.pb.ts

@@ -2,8 +2,10 @@
 // @generated from file github.com/aperturerobotics/starpc/mock/mock.proto (package e2e.mock, syntax proto3)
 /* eslint-disable */
 
-import type { MessageType, PartialFieldInfo } from '@aptre/protobuf-es-lite'
-import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite'
+import type { MessageType } from '@aptre/protobuf-es-lite/message'
+import { createMessageType } from '@aptre/protobuf-es-lite/message'
+import { ScalarType } from '@aptre/protobuf-es-lite/scalar'
+import type { PartialFieldInfo } from '@aptre/protobuf-es-lite/field'
 
 export const protobufPackage = 'e2e.mock'
 
@@ -19,11 +21,10 @@ export interface MockMsg {
   body?: string
 }
 
-// MockMsg contains the message type declaration for MockMsg.
-export const MockMsg: MessageType<MockMsg> = createMessageType({
+export const MockMsg: MessageType<MockMsg> = /* @__PURE__ */ createMessageType({
   typeName: 'e2e.mock.MockMsg',
   fields: [
     { no: 1, name: 'body', kind: 'scalar', T: ScalarType.STRING },
-  ] as readonly PartialFieldInfo[],
+  ] satisfies readonly PartialFieldInfo[],
   packedByDefault: true,
 })

package/mock/mock_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.46.1
+// protoc-gen-starpc-cpp version: v0.49.7
 // source: github.com/aperturerobotics/starpc/mock/mock.proto
 
 #include "mock_srpc.pb.hpp"

package/mock/mock_srpc.pb.go

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

package/mock/mock_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.46.1
+// protoc-gen-starpc-cpp version: v0.49.7
 // source: github.com/aperturerobotics/starpc/mock/mock.proto
 
 #pragma once

package/mock/mock_srpc.pb.rs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.49.17",
+  "version": "0.49.20",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/call-receipt-e2e_test.go

@@ -0,0 +1,111 @@
+package srpc_test
+
+import (
+	"context"
+	"net"
+	"testing"
+
+	yamux "github.com/libp2p/go-yamux/v4"
+
+	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/srpc"
+)
+
+type receiptEchoServer struct {
+	echo.SRPCEchoerServer
+	invocationFound chan bool
+}
+
+func (s *receiptEchoServer) Echo(
+	ctx context.Context,
+	msg *echo.EchoMsg,
+) (*echo.EchoMsg, error) {
+	_, found := srpc.GetServerInvocation(ctx)
+	s.invocationFound <- found
+	return msg.CloneVT(), nil
+}
+
+func TestCallReceiptGoGo(t *testing.T) {
+	clientConn, serverConn := net.Pipe()
+	clientMux, err := srpc.NewMuxedConn(clientConn, true, nil)
+	if err != nil {
+		t.Fatalf("client mux: %v", err)
+	}
+	serverMux, err := srpc.NewMuxedConn(serverConn, false, nil)
+	if err != nil {
+		_ = clientMux.Close()
+		t.Fatalf("server mux: %v", err)
+	}
+
+	mux := srpc.NewMux()
+	echoServer := &receiptEchoServer{
+		SRPCEchoerServer: echo.NewEchoServer(mux),
+		invocationFound:  make(chan bool, 1),
+	}
+	if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
+		t.Fatalf("register echo: %v", err)
+	}
+
+	terminal := make(chan srpc.TerminalKind, 1)
+	invoker := srpc.InvokerFunc(func(
+		serviceID, methodID string,
+		strm srpc.Stream,
+	) (bool, error) {
+		handled, err := mux.InvokeMethod(serviceID, methodID, strm)
+		if err != nil || !handled {
+			return handled, err
+		}
+		invocation, ok := srpc.GetServerInvocation(strm.Context())
+		if !ok {
+			return true, context.Canceled
+		}
+		kind, err := invocation.WaitTerminal(context.Background())
+		if err == nil {
+			terminal <- kind
+		}
+		return true, err
+	})
+	server := srpc.NewServer(invoker)
+	serverCtx, serverCancel := context.WithCancel(context.Background())
+	serverErr := make(chan error, 1)
+	go func() {
+		serverErr <- server.AcceptMuxedConn(serverCtx, serverMux)
+	}()
+	t.Cleanup(func() {
+		if err := serverMux.Close(); err != nil {
+			t.Errorf("close server mux: %v", err)
+		}
+		acceptErr := <-serverErr
+		serverCancel()
+		if acceptErr != yamux.ErrSessionShutdown {
+			t.Errorf("server accept: %v, want session shutdown", acceptErr)
+		}
+		if err := clientMux.Close(); err != nil {
+			t.Errorf("close client mux: %v", err)
+		}
+	})
+
+	client := srpc.NewClientWithMuxedConn(clientMux)
+	out := new(echo.EchoMsg)
+	receipt, err := srpc.ExecCallReceipt(
+		context.Background(), client, echo.SRPCEchoerServiceID, "Echo",
+		&echo.EchoMsg{Body: "held"}, out,
+	)
+	if err != nil {
+		t.Fatalf("exec receipt: %v", err)
+	}
+	if err := receipt.Commit(); err != nil {
+		t.Fatalf("commit: %v", err)
+	}
+	if out.GetBody() != "held" {
+		t.Fatalf("response body = %q, want held", out.GetBody())
+	}
+	found := <-echoServer.invocationFound
+	if !found {
+		t.Fatal("generated handler context lost server invocation")
+	}
+	kind := <-terminal
+	if kind != srpc.TerminalCommitted {
+		t.Fatalf("terminal = %v, want committed", kind)
+	}
+}