starpc 0.49.16 → 0.49.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.49.16",
+  "version": "0.49.18",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -128,9 +128,9 @@
     "vitest": "^4.1.5"
   },
   "dependencies": {
-    "@aptre/yamux": "^1.0.3",
     "@aptre/it-ws": "^1.1.2",
-    "@aptre/protobuf-es-lite": "^1.0.1",
+    "@aptre/protobuf-es-lite": "1.1.0",
+    "@aptre/yamux": "^1.0.3",
     "event-iterator": "^2.0.0",
     "isomorphic-ws": "^5.0.0",
     "it-first": "^3.0.11",
@@ -139,5 +139,11 @@
     "it-stream-types": "^2.0.4",
     "uint8arraylist": "^3.0.0",
     "ws": "^8.20.0"
+  },
+  "resolutions": {
+    "@aptre/protobuf-es-lite": "1.1.0"
+  },
+  "overrides": {
+    "@aptre/protobuf-es-lite": "1.1.0"
   }
 }

package/srpc/common-rpc.go

@@ -34,6 +34,10 @@ type commonRPC struct {
 	// localCompleting is set while the local handler is publishing its terminal
 	// packet and closing the writer.
 	localCompleting bool
+	// localActive is set while the local handler goroutine may still be inside
+	// user code. Resource owners use Wait as a lifetime barrier, so cancellation
+	// must not make Wait return while a handler can still touch mux-owned state.
+	localActive bool
 	// localDone is set after the local handler has completed normally.
 	localDone bool
 	// dataQueue contains incoming data packets.
@@ -73,6 +77,21 @@ func (c *commonRPC) Wait(ctx context.Context) error {
 		locked := c.bcast.Lock()
 		err = c.remoteErr
 		rpcCanceled = c.ctx.Err() != nil
+		// A canceled stream tells the handler to stop, but it is not proof that
+		// the handler has returned. Keep waiting while localActive is true so a
+		// caller that releases resources after Wait cannot race in-flight user
+		// code still running on the canceled Stream context.
+		if c.localActive {
+			waitCh = locked.WaitCh()
+			locked.Unlock()
+
+			select {
+			case <-ctx.Done():
+				return context.Canceled
+			case <-waitCh:
+				continue
+			}
+		}
 		localDone = c.localDone
 		if err == nil && !rpcCanceled && !localDone {
 			waitCh = locked.WaitCh()
@@ -276,6 +295,7 @@ func (c *commonRPC) finishLocalCompletion() {
 	}
 	locked = c.bcast.Lock()
 	c.localCompleting = false
+	c.localActive = false
 	c.localDone = true
 	locked.Broadcast()
 	locked.Unlock()

package/srpc/common-rpc_test.go

@@ -232,6 +232,58 @@ func TestServerRPCRemoteCloseAfterLocalCompletionDoesNotCancelStreamContext(t *t
 	}
 }
 
+func TestServerRPCWaitDoesNotReturnUntilCanceledInvokeExits(t *testing.T) {
+	writer := newPacketRecordingWriter()
+	invoked := make(chan struct{})
+	ctxCanceled := make(chan struct{})
+	releaseInvoke := make(chan struct{})
+	rpc := NewServerRPC(context.Background(), InvokerFunc(func(serviceID, methodID string, strm Stream) (bool, error) {
+		close(invoked)
+		<-strm.Context().Done()
+		close(ctxCanceled)
+		<-releaseInvoke
+		return true, nil
+	}), writer)
+
+	if err := rpc.HandleCallStart(NewCallStartPacket("service", "method", nil, false).GetCallStart()); err != nil {
+		t.Fatalf("handle call start: %v", err)
+	}
+
+	select {
+	case <-invoked:
+	case <-time.After(time.Second):
+		t.Fatal("invoker did not start")
+	}
+
+	done := make(chan error, 1)
+	go func() {
+		done <- rpc.Wait(context.Background())
+	}()
+
+	rpc.cancelContext()
+	select {
+	case <-ctxCanceled:
+	case <-time.After(time.Second):
+		t.Fatal("invoke context was not canceled")
+	}
+
+	select {
+	case err := <-done:
+		t.Fatalf("wait returned before canceled invoke exited: %v", err)
+	default:
+	}
+
+	close(releaseInvoke)
+	select {
+	case err := <-done:
+		if err != nil {
+			t.Fatalf("wait after invoke exit: %v", err)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("wait did not return after invoke exited")
+	}
+}
+
 func TestServerRPCRemoteCloseDuringLocalCompletionDoesNotCancelStreamContext(t *testing.T) {
 	writer := newBlockingPacketWriter()
 	streamCtxCh := make(chan context.Context, 1)

package/srpc/server-rpc-invoke.go

@@ -0,0 +1,7 @@
+//go:build !goscript
+
+package srpc
+
+func startServerRPCInvoke(fn func()) {
+	go fn()
+}

package/srpc/server-rpc-invoke_goscript.go

@@ -0,0 +1,12 @@
+//go:build goscript
+
+package srpc
+
+import "time"
+
+func startServerRPCInvoke(fn func()) {
+	if fn == nil {
+		return
+	}
+	time.AfterFunc(0, fn)
+}

package/srpc/server-rpc-invoke_goscript_test.go

@@ -0,0 +1,27 @@
+//go:build goscript
+
+package srpc
+
+import (
+	"testing"
+	"time"
+)
+
+func TestStartServerRPCInvokeDefersGoscriptWork(t *testing.T) {
+	ran := make(chan struct{}, 1)
+	startServerRPCInvoke(func() {
+		ran <- struct{}{}
+	})
+
+	select {
+	case <-ran:
+		t.Fatal("server rpc invoke ran inline")
+	default:
+	}
+
+	select {
+	case <-ran:
+	case <-time.After(time.Second):
+		t.Fatal("server rpc invoke did not run")
+	}
+}

package/srpc/server-rpc.go

@@ -80,9 +80,16 @@ func (r *ServerRPC) HandleCallStart(pkt *CallStart) error {
 		r.dataQueue = append(r.dataQueue, data)
 	}
 
+	// Wait is used as a resource lifetime barrier by rpcstream components.
+	// Mark the method active before scheduling it so cancellation cannot make
+	// Wait return and release a mux while invokeRPC is still running user code.
+	r.localActive = true
+
 	// invoke the rpc
 	locked.Broadcast()
-	go r.invokeRPC(service, method)
+	startServerRPCInvoke(func() {
+		r.invokeRPC(service, method)
+	})
 	locked.Unlock()
 
 	return err