starpc 0.49.20 → 0.50.0

package/integration/cross-language/go-server/fixture-owner_test.go

@@ -0,0 +1,127 @@
+package main
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"testing"
+)
+
+// forbiddenFixtureCalls names the pipeline constructors that rebuild a second
+// srpc server inside a fixture. The receipt post-mortem removed a hand-built
+// ReadPump pipeline; the fixture must drive one srpc.Server through one
+// Server.HandleStream and observe framed packets by decorating net.Conn.
+var forbiddenFixtureCalls = []string{"NewServerRPC", "NewPacketReadWriter", "ReadPump"}
+
+// fixtureOwnerViolations returns the ways a cross-language Go fixture source
+// diverges from the single production server owner.
+func fixtureOwnerViolations(src string) []string {
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "fixture.go", src, 0)
+	if err != nil {
+		return []string{"parse error: " + err.Error()}
+	}
+
+	seen := map[string]bool{}
+	handleStreamCalls := 0
+	newServerCalls := 0
+	ast.Inspect(file, func(n ast.Node) bool {
+		call, ok := n.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		sel, ok := call.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+		switch sel.Sel.Name {
+		case "HandleStream":
+			handleStreamCalls++
+		case "NewServer":
+			newServerCalls++
+		case "NewServerRPC", "NewPacketReadWriter", "ReadPump":
+			seen[sel.Sel.Name] = true
+		}
+		return true
+	})
+
+	var violations []string
+	for _, name := range forbiddenFixtureCalls {
+		if seen[name] {
+			violations = append(violations, "reconstructs server pipeline via "+name)
+		}
+	}
+	if newServerCalls != 1 {
+		violations = append(violations, "expected exactly one srpc.NewServer, found "+strconv.Itoa(newServerCalls))
+	}
+	if handleStreamCalls != 1 {
+		violations = append(violations, "expected exactly one Server.HandleStream entrypoint, found "+strconv.Itoa(handleStreamCalls))
+	}
+	if !decoratesNetConn(file) {
+		violations = append(violations, "no fixture type decorates net.Conn")
+	}
+	return violations
+}
+
+// decoratesNetConn reports whether the source embeds net.Conn in a struct, the
+// only sanctioned way for fixture instrumentation to observe framed packets.
+func decoratesNetConn(file *ast.File) bool {
+	found := false
+	ast.Inspect(file, func(n ast.Node) bool {
+		st, ok := n.(*ast.StructType)
+		if !ok {
+			return true
+		}
+		for _, field := range st.Fields.List {
+			if len(field.Names) != 0 {
+				continue
+			}
+			sel, ok := field.Type.(*ast.SelectorExpr)
+			if !ok {
+				continue
+			}
+			pkg, ok := sel.X.(*ast.Ident)
+			if ok && pkg.Name == "net" && sel.Sel.Name == "Conn" {
+				found = true
+			}
+		}
+		return true
+	})
+	return found
+}
+
+// TestFixtureUsesSingleServerOwner proves the shipped fixture drives one
+// srpc.Server through one Server.HandleStream and decorates net.Conn.
+func TestFixtureUsesSingleServerOwner(t *testing.T) {
+	src, err := os.ReadFile("main.go")
+	if err != nil {
+		t.Fatalf("read main.go: %v", err)
+	}
+	if violations := fixtureOwnerViolations(string(src)); len(violations) != 0 {
+		t.Fatalf("fixture diverged from single server owner: %v", violations)
+	}
+}
+
+// TestFixtureGuardDetectsSecondPipeline proves the guard fires when a fixture
+// rebuilds a second RPC server pipeline.
+func TestFixtureGuardDetectsSecondPipeline(t *testing.T) {
+	bad := `package main
+
+import (
+	"net"
+
+	"github.com/aperturerobotics/starpc/srpc"
+)
+
+func run(conn net.Conn) {
+	prw := srpc.NewPacketReadWriter(conn)
+	rpc := srpc.NewServerRPC(nil, nil)
+	_ = rpc.ReadPump(prw)
+}
+`
+	if violations := fixtureOwnerViolations(bad); len(violations) == 0 {
+		t.Fatal("guard failed to flag a second server pipeline")
+	}
+}

package/integration/cross-language/go-server/main.go

@@ -2,11 +2,13 @@ package main
 
 import (
 	"context"
+	"encoding/binary"
 	"fmt"
 	"net"
 	"os"
 	"os/signal"
 	"sync"
+	"sync/atomic"
 
 	"github.com/aperturerobotics/starpc/echo"
 	"github.com/aperturerobotics/starpc/srpc"
@@ -39,6 +41,7 @@ func main() {
 	}
 	var receiptDone <-chan struct{}
 	var finishReceipt func()
+	var receiptCommitted atomic.Bool
 	if receiptMode {
 		done := make(chan struct{})
 		var doneOnce sync.Once
@@ -73,16 +76,16 @@ func main() {
 			if markerErr != nil {
 				return true, markerErr
 			}
-			if kind != srpc.TerminalCommitted {
+			if kind == srpc.TerminalKind_TERMINAL_KIND_COMMITTED {
+				receiptCommitted.Store(true)
+			}
+			if kind != srpc.TerminalKind_TERMINAL_KIND_COMMITTED {
 				finishReceipt()
 			}
 			return true, nil
 		})
 	}
-	var server *srpc.Server
-	if !receiptMode {
-		server = srpc.NewServer(invoker)
-	}
+	server := srpc.NewServer(invoker)
 	ln, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "listen error: %v\n", err)
@@ -101,7 +104,7 @@ func main() {
 
 	go func() {
 		<-ctx.Done()
-		ln.Close()
+		_ = ln.Close()
 	}()
 
 	for {
@@ -109,63 +112,82 @@ func main() {
 		if err != nil {
 			return
 		}
+		var stream net.Conn
+		stream = conn
 		if receiptMode {
-			go handleReceiptStream(ctx, conn, invoker, finishReceipt)
-		} else {
-			go server.HandleStream(ctx, conn)
+			stream = &receiptConn{
+				Conn:          conn,
+				finishReceipt: finishReceipt,
+				committed:     &receiptCommitted,
+			}
 		}
+		go server.HandleStream(ctx, stream)
 	}
 }
 
-func handleReceiptStream(
-	ctx context.Context,
-	conn net.Conn,
-	invoker srpc.Invoker,
-	finishReceipt func(),
-) {
-	prw := srpc.NewPacketReadWriter(conn)
-	writer := &receiptPacketWriter{
-		inner:         prw,
-		finishReceipt: finishReceipt,
-	}
-	rpc := srpc.NewServerRPC(ctx, invoker, writer)
-	prw.ReadPump(rpc.HandlePacketData, rpc.HandleStreamClose)
-}
-
-type receiptPacketWriter struct {
-	inner         srpc.PacketWriter
+type receiptConn struct {
+	net.Conn
 	finishReceipt func()
+	committed     *atomic.Bool
+	inspect       []byte
+	ackPending    bool
 }
 
-func (w *receiptPacketWriter) WritePacket(pkt *srpc.Packet) error {
-	if err := w.inner.WritePacket(pkt); err != nil {
-		return err
+func (c *receiptConn) Write(p []byte) (int, error) {
+	if !c.ackPending {
+		if err := c.observeReceiptPackets(p); err != nil {
+			return 0, err
+		}
+	}
+	n, err := c.Conn.Write(p)
+	if err != nil {
+		return n, err
 	}
-	data := pkt.GetCallData()
-	if data != nil && data.GetComplete() && data.GetError() == "" {
-		if err := emitReceiptEvent("SERVER_RECEIPT_ACK committed"); err != nil {
+	if c.ackPending && n == len(p) {
+		c.finishReceipt()
+		c.ackPending = false
+	}
+	return n, nil
+}
+
+func (c *receiptConn) observeReceiptPackets(p []byte) error {
+	c.inspect = append(c.inspect, p...)
+	for len(c.inspect) >= 4 {
+		size := int(binary.LittleEndian.Uint32(c.inspect[:4]))
+		if len(c.inspect) < 4+size {
+			break
+		}
+		pkt := &srpc.Packet{}
+		if err := pkt.UnmarshalVT(c.inspect[4 : 4+size]); err != nil {
+			return err
+		}
+		c.inspect = c.inspect[4+size:]
+		data := pkt.GetCallData()
+		if !c.committed.Load() {
+			continue
+		}
+		if data == nil || !data.GetComplete() || data.GetError() != "" {
+			continue
+		}
+		if err := emitReceiptEvent("SERVER_RECEIPT_ACK_WRITE committed"); err != nil {
 			return err
 		}
-		w.finishReceipt()
+		c.ackPending = true
 	}
 	return nil
 }
 
-func (w *receiptPacketWriter) Close() error {
-	return w.inner.Close()
-}
-
 func terminalName(kind srpc.TerminalKind) string {
 	switch kind {
-	case srpc.TerminalCommitted:
+	case srpc.TerminalKind_TERMINAL_KIND_COMMITTED:
 		return "committed"
-	case srpc.TerminalCanceled:
+	case srpc.TerminalKind_TERMINAL_KIND_CANCELED:
 		return "canceled"
-	case srpc.TerminalLost:
+	case srpc.TerminalKind_TERMINAL_KIND_TRANSPORT_LOST:
 		return "transportLost"
-	case srpc.TerminalClosed:
+	case srpc.TerminalKind_TERMINAL_KIND_CLOSED:
 		return "closed"
-	case srpc.TerminalAbandoned:
+	case srpc.TerminalKind_TERMINAL_KIND_ABANDONED:
 		return "abandoned"
 	default:
 		return "unknown"

package/integration/cross-language/run.bash

@@ -118,14 +118,14 @@ check_receipt_events() {
     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 == "SERVER_RECEIPT_ACK_WRITE " expected { ack_write = NR; next }
         $0 == "CLIENT_RECEIPT_RESOLVED " expected { client = NR; next }
         END {
             if (!terminal || !client) {
                 exit 1
             }
             if (expected == "committed" &&
-                (!ack || terminal >= ack || ack >= client)) {
+                (!ack_write || terminal >= ack_write || ack_write >= client)) {
                 exit 1
             }
         }

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

@@ -2,6 +2,8 @@ import net from 'net'
 import { closeSync, openSync, writeSync } from 'node:fs'
 import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
+import type { Source } from 'it-stream-types'
+
 import { createMux, createHandler, Server } from '../../srpc/index.js'
 import {
   parseLengthPrefixTransform,
@@ -10,9 +12,9 @@ import {
 import { combineUint8ArrayListTransform } from '../../srpc/array-list.js'
 import { EchoerServer, EchoMsg } from '../../echo/index.js'
 import { EchoerDefinition } from '../../echo/echo_srpc.pb.js'
-import { Packet } from '../../srpc/rpcproto.pb.js'
+import { Packet, TerminalKind } 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
@@ -57,15 +59,15 @@ function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
           packet.body?.case === 'callData' &&
           packet.body.value.complete &&
           !packet.body.value.error
+        if (receiptCompletion) {
+          emitReceiptEvent('SERVER_RECEIPT_ACK_WRITE committed')
+        }
         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()
@@ -121,8 +123,8 @@ if (receiptMode) {
           const terminal = await invocation.waitTerminal(
             new AbortController().signal,
           )
-          emitReceiptEvent(`SERVER_RECEIPT_TERMINAL ${terminal}`)
-          if (terminal !== 'committed') {
+          emitReceiptEvent(`SERVER_RECEIPT_TERMINAL ${terminalName(terminal)}`)
+          if (terminal !== TerminalKind.COMMITTED) {
             finishReceiptServer()
           }
         })(),
@@ -130,6 +132,24 @@ if (receiptMode) {
     }
   })
 }
+
+function terminalName(terminal: TerminalKind): string {
+  switch (terminal) {
+    case TerminalKind.COMMITTED:
+      return 'committed'
+    case TerminalKind.CANCELED:
+      return 'canceled'
+    case TerminalKind.TRANSPORT_LOST:
+      return 'transportLost'
+    case TerminalKind.CLOSED:
+      return 'closed'
+    case TerminalKind.ABANDONED:
+      return 'abandoned'
+    default:
+      return 'unknown'
+  }
+}
+
 const server = new Server(mux.lookupMethod)
 if (!receiptMode) {
   const echoer = new EchoerServer(server)

package/mock/index.ts

@@ -1,2 +1,2 @@
-export * from "./mock.pb.js"
-export * from "./mock_srpc.pb.js"
+export * from './mock.pb.js'
+export * from './mock_srpc.pb.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.49.20",
+  "version": "0.50.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -68,10 +68,10 @@
     "deps": "depcheck --ignores 'bufferutil,utf-8-validate,rimraf,starpc,@aptre/protobuf-es-lite,tsx'",
     "codegen": "bun run gen",
     "ci": "bun run build && bun run lint:js && bun run lint:go",
-    "format": "bun run format:go && bun run format:js && bun run format:config",
-    "format:config": "prettier --write tsconfig.json package.json",
+    "format": "bun run format:js && bun run format:go && bun run format:config",
+    "format:config": "oxfmt '*.json' '.github/**/*.json' '.github/**/*.yml' '.oxfmtrc.json' 'tsconfig.json'",
     "format:go": "bun run go:aptre -- format",
-    "format:js": "prettier --write './{srpc,echo,e2e,integration,rpcstream,cmd}/**/(*.ts|*.tsx|*.html|*.css)'",
+    "format:js": "oxfmt './{srpc,echo,e2e,integration,rpcstream,cmd,mock,scripts}/**/*.{ts,tsx,js,mjs,html,css,scss}' '*.{ts,tsx,js,mjs}'",
     "gen": "bun run go:aptre -- generate && bun run format",
     "gen:force": "bun run go:aptre -- generate --force && bun run format",
     "test": "bun run test:js && bun run test:go",
@@ -90,46 +90,39 @@
     "integration:rust:cpp": "bash ./integration/cross-language/run.bash rust:cpp",
     "lint": "bun run lint:go && bun run lint:js",
     "lint:go": "bun run go:aptre -- lint",
-    "lint:js": "eslint ./",
+    "lint:js": "oxlint .",
+    "lint:js:fix": "bun run lint:js -- --fix",
     "prepare": "husky && go mod vendor",
     "go:aptre": "go run -mod=mod github.com/aperturerobotics/common/cmd/aptre",
     "precommit": "lint-staged",
-    "release": "npm run release:version && npm run release:commit",
-    "release:minor": "npm run release:version:minor && npm run release:commit",
-    "release:version": "npm version patch -m \"release: v%s\" --no-git-tag-version && npm run release:sync-cargo",
-    "release:version:minor": "npm version minor -m \"release: v%s\" --no-git-tag-version && npm run release:sync-cargo",
-    "release:sync-cargo": "node -e \"const v=require('./package.json').version,f='Cargo.toml',c=require('fs').readFileSync(f,'utf8');require('fs').writeFileSync(f,c.replace(/^version = \\\".*?\\\"/m,'version = \\\"'+v+'\\\"'))\"",
-    "release:commit": "git reset && git add package.json Cargo.toml && git commit -s -m \"release: v$(node -p \"require('./package.json').version\")\" && git tag v$(node -p \"require('./package.json').version\")",
+    "release": "bun run release:version && bun run release:commit",
+    "release:minor": "bun run release:version:minor && bun run release:commit",
+    "release:version": "bun scripts/release-version.ts patch",
+    "release:version:minor": "bun scripts/release-version.ts minor",
+    "release:commit": "version=$(bun -e 'console.log(require(\"./package.json\").version)') && git reset && git add package.json Cargo.toml && git commit -s -m \"release: v$version\" && git tag \"v$version\"",
     "release:publish": "git push && git push --tags"
   },
   "preferUnplugged": true,
   "lint-staged": {
-    "package.json": "prettier --config .prettierrc.yaml --write",
-    "./{srpc,echo,e2e,integration,rpcstream,cmd}/**/(*.ts|*.tsx|*.html|*.css)": "prettier --config .prettierrc.yaml --write"
+    "*.{json,ts,tsx,js,mjs}": "oxfmt",
+    "./{srpc,echo,e2e,integration,rpcstream,cmd,mock,scripts}/**/*.{ts,tsx,js,mjs,html,css,scss}": "oxfmt"
   },
   "devDependencies": {
-    "@eslint/js": "^10.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.59.0",
-    "@typescript-eslint/parser": "^8.59.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260422.1",
     "depcheck": "^1.4.6",
     "esbuild": "^0.28.0",
-    "eslint": "^10.2.1",
-    "eslint-config-prettier": "^10.0.0",
-    "eslint-plugin-unused-imports": "^4.4.1",
-    "globals": "^17.5.0",
     "happy-dom": "^20.9.0",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.0",
-    "prettier": "^3.8.3",
+    "oxfmt": "0.61.0",
+    "oxlint": "^1.76.0",
     "rimraf": "^6.1.3",
     "tsx": "^4.20.4",
-    "typescript": "^6.0.3",
-    "@typescript/native-preview": "^7.0.0-dev.20260422.1",
     "vitest": "^4.1.5"
   },
   "dependencies": {
     "@aptre/it-ws": "^1.1.2",
-    "@aptre/protobuf-es-lite": "1.1.0",
+    "@aptre/protobuf-es-lite": "1.1.1",
     "@aptre/yamux": "^1.0.3",
     "event-iterator": "^2.0.0",
     "isomorphic-ws": "^5.0.0",
@@ -141,9 +134,9 @@
     "ws": "^8.20.0"
   },
   "resolutions": {
-    "@aptre/protobuf-es-lite": "1.1.0"
+    "@aptre/protobuf-es-lite": "1.1.1"
   },
   "overrides": {
-    "@aptre/protobuf-es-lite": "1.1.0"
+    "@aptre/protobuf-es-lite": "1.1.1"
   }
 }

package/srpc/accept.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net"
 
-	"github.com/libp2p/go-yamux/v4"
+	"github.com/libp2p/go-yamux/v5"
 )
 
 // AcceptMuxedListener accepts incoming connections from a net.Listener.

package/srpc/call-receipt-e2e_test.go

@@ -5,7 +5,7 @@ import (
 	"net"
 	"testing"
 
-	yamux "github.com/libp2p/go-yamux/v4"
+	yamux "github.com/libp2p/go-yamux/v5"
 
 	"github.com/aperturerobotics/starpc/echo"
 	"github.com/aperturerobotics/starpc/srpc"
@@ -105,7 +105,7 @@ func TestCallReceiptGoGo(t *testing.T) {
 		t.Fatal("generated handler context lost server invocation")
 	}
 	kind := <-terminal
-	if kind != srpc.TerminalCommitted {
+	if kind != srpc.TerminalKind_TERMINAL_KIND_COMMITTED {
 		t.Fatalf("terminal = %v, want committed", kind)
 	}
 }

package/srpc/call-receipt.go

@@ -62,7 +62,7 @@ func (r *CallReceipt) Commit() error {
 		receipt, ok := r.strm.(receiptTerminalStream)
 		if ok {
 			terminal, terminalOK := receipt.receiptTerminalKind()
-			if terminalOK && terminal == TerminalCommitted {
+			if terminalOK && terminal == TerminalKind_TERMINAL_KIND_COMMITTED {
 				return nil
 			}
 		}

package/srpc/call-receipt.test.ts

@@ -9,9 +9,9 @@ import { Client } from './client.js'
 import { ClientRPC } from './client-rpc.js'
 import { Server } from './server.js'
 import { CallReceipt } from './call-receipt.js'
-import { Packet } from './rpcproto.pb.js'
+import { Packet, TerminalKind } from './rpcproto.pb.js'
 import { ServerRPC } from './server-rpc.js'
-import { ServerInvocation, type TerminalKind } from './server-invocation.js'
+import { ServerInvocation } from './server-invocation.js'
 
 const response = new Uint8Array([1, 2, 3])
 
@@ -68,7 +68,7 @@ describe('held unary receipt', () => {
   })
 
   it('commits through a real TypeScript server', async () => {
-    const terminal = Promise.withResolvers<string>()
+    const terminal = Promise.withResolvers<TerminalKind>()
     const server = new Server(async () => {
       return async (_source, dataSink, invocation) => {
         await dataSink(
@@ -113,7 +113,7 @@ describe('held unary receipt', () => {
       response,
     )
     await expect(held.receipt.commit()).resolves.toBeUndefined()
-    await expect(terminal.promise).resolves.toBe('committed')
+    await expect(terminal.promise).resolves.toBe(TerminalKind.COMMITTED)
   })
 
   it('rejects commit after a bare remote close', async () => {
@@ -292,12 +292,12 @@ describe('held unary receipt', () => {
 
 describe('server invocation terminal', () => {
   it.each([
-    ['explicit completion', 'committed'],
-    ['cancel', 'canceled'],
-    ['transport loss', 'transportLost'],
-    ['remote error packet', 'transportLost'],
-    ['bare close', 'closed'],
-    ['remote error packet with completion', 'transportLost'],
+    ['explicit completion', TerminalKind.COMMITTED],
+    ['cancel', TerminalKind.CANCELED],
+    ['transport loss', TerminalKind.TRANSPORT_LOST],
+    ['remote error packet', TerminalKind.TRANSPORT_LOST],
+    ['bare close', TerminalKind.CLOSED],
+    ['remote error packet with completion', TerminalKind.TRANSPORT_LOST],
   ] as const)('%s is classified distinctly', async (_name, expected) => {
     const captured = Promise.withResolvers<ServerInvocation>()
     const owner = new AbortController()
@@ -318,11 +318,11 @@ describe('server invocation terminal', () => {
       dataIsZero: true,
     })
     const invocation = await captured.promise
-    if (expected === 'committed') {
+    if (expected === TerminalKind.COMMITTED) {
       await rpc.handleCallData({ complete: true })
-    } else if (expected === 'canceled') {
+    } else if (expected === TerminalKind.CANCELED) {
       await rpc.handleCallCancel()
-    } else if (expected === 'transportLost') {
+    } else if (expected === TerminalKind.TRANSPORT_LOST) {
       if (
         _name === 'remote error packet' ||
         _name === 'remote error packet with completion'
@@ -346,7 +346,10 @@ describe('server invocation terminal', () => {
       }
       expect(rpcState.remoteCompleted).toBe(false)
     }
-    if (expected === 'closed' || expected === 'transportLost') {
+    if (
+      expected === TerminalKind.CLOSED ||
+      expected === TerminalKind.TRANSPORT_LOST
+    ) {
       expect(invocation.signal.aborted).toBe(true)
     }
   })
@@ -379,7 +382,7 @@ describe('server invocation terminal', () => {
         await rpc.handleCallCancel()
       }
       await expect(invocation.waitTerminal(owner.signal)).resolves.toBe(
-        'committed',
+        TerminalKind.COMMITTED,
       )
       owner.abort()
     },
@@ -406,7 +409,7 @@ describe('server invocation terminal', () => {
     const invocation = await captured.promise
     owner.abort()
     await expect(invocation.waitTerminal(owner.signal)).resolves.toBe(
-      'abandoned',
+      TerminalKind.ABANDONED,
     )
   })
 })

package/srpc/call-receipt.ts

@@ -1,6 +1,7 @@
 /// <reference lib="es2024.promise" />
 import { ERR_RPC_ABORT } from './errors.js'
 import { ClientRPC } from './client-rpc.js'
+import { TerminalKind } from './rpcproto.pb.js'
 
 // ReceiptRpc exposes held unary calls without widening ProtoRpc.
 export interface ReceiptRpc {
@@ -49,7 +50,7 @@ export class CallReceipt {
       }
       const terminal = this.#call.getTerminalKind()
       if (
-        terminal !== 'committed' ||
+        terminal !== TerminalKind.COMMITTED ||
         !this.#requestCommitted ||
         this.#terminal !== 'committed'
       ) {