starpc 0.49.18 → 0.50.0

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

@@ -1,16 +1,33 @@
 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,
   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, 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
+  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 +52,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
+        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()
           })
         })
+        await writeDone
+        if (receiptCompletion) {
+          finishReceiptServer()
+        }
       }
       socket.end()
     },
@@ -50,9 +79,82 @@ 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 ${terminalName(terminal)}`)
+          if (terminal !== TerminalKind.COMMITTED) {
+            finishReceiptServer()
+          }
+        })(),
+      )
+    }
+  })
+}
+
+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)
-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 +166,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/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/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.18",
+  "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

@@ -0,0 +1,111 @@
+package srpc_test
+
+import (
+	"context"
+	"net"
+	"testing"
+
+	yamux "github.com/libp2p/go-yamux/v5"
+
+	"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.TerminalKind_TERMINAL_KIND_COMMITTED {
+		t.Fatalf("terminal = %v, want committed", kind)
+	}
+}

package/srpc/call-receipt.go

@@ -0,0 +1,112 @@
+package srpc
+
+import (
+	"context"
+	"io"
+	"sync/atomic"
+
+	"github.com/pkg/errors"
+)
+
+// ExecCallReceipt executes a unary call over cc.NewStream, reads the single
+// response into out, and returns a held receipt. The caller must dispose it
+// with Commit, Abort, or Close.
+func ExecCallReceipt(
+	ctx context.Context,
+	cc Client,
+	service, method string,
+	in, out Message,
+) (*CallReceipt, error) {
+	strm, err := cc.NewStream(ctx, service, method, in)
+	if err != nil {
+		return nil, err
+	}
+	if err := strm.MsgRecv(out); err != nil {
+		_ = strm.Close()
+		return nil, err
+	}
+	return &CallReceipt{strm: strm}, nil
+}
+
+// CallReceipt holds a unary call until the server finalizes it.
+type CallReceipt struct {
+	strm     Stream
+	disposed atomic.Bool
+}
+
+// Context returns the context of the held call.
+func (r *CallReceipt) Context() context.Context {
+	return r.strm.Context()
+}
+
+// Commit sends request completion and waits for the server completion
+// acknowledgment before releasing the stream.
+func (r *CallReceipt) Commit() error {
+	if r.disposed.Swap(true) {
+		return nil
+	}
+
+	if r.strm.Context().Err() != nil {
+		_ = r.strm.Close()
+		return context.Canceled
+	}
+	if err := r.strm.CloseSend(); err != nil {
+		_ = r.strm.Close()
+		return err
+	}
+
+	var done receiptDone
+	err := r.strm.MsgRecv(&done)
+	_ = r.strm.Close()
+	if err == io.EOF {
+		receipt, ok := r.strm.(receiptTerminalStream)
+		if ok {
+			terminal, terminalOK := receipt.receiptTerminalKind()
+			if terminalOK && terminal == TerminalKind_TERMINAL_KIND_COMMITTED {
+				return nil
+			}
+		}
+		return errors.New("missing trailing completion acknowledgment")
+	}
+	if err == nil {
+		return errors.New("unexpected trailing response data")
+	}
+	return err
+}
+
+// Abort sends request cancellation and releases the stream.
+func (r *CallReceipt) Abort() error {
+	if r.disposed.Swap(true) {
+		return nil
+	}
+	return r.strm.Close()
+}
+
+// Close aborts the held call unless it has already reached a terminal.
+func (r *CallReceipt) Close() error {
+	return r.Abort()
+}
+
+// receiptDone is a no-op message used to read the trailing completion packet.
+type receiptDone struct{}
+
+func (*receiptDone) SizeVT() int {
+	return 0
+}
+
+func (*receiptDone) MarshalToSizedBufferVT([]byte) (int, error) {
+	return 0, nil
+}
+
+func (*receiptDone) MarshalVT() ([]byte, error) {
+	return nil, nil
+}
+
+func (*receiptDone) UnmarshalVT([]byte) error {
+	return nil
+}
+
+func (*receiptDone) Reset() {}
+
+// _ is a type assertion.
+var _ Message = (*receiptDone)(nil)