fix: close stream adaptive gaps and switch notify to stario v0.1.1

- make stream fast path honor adaptive soft payload limits end-to-end
  - split oversized fast-stream payloads into sequential frames before batching
  - use adaptive soft cap when encoding stream batch payloads
  - move timeout-like error detection into production code for adaptive tx
  - tune notify FrameReader read size explicitly to avoid throughput regression
  - drop local stario replace and depend on released b612.me/stario v0.1.1

client_transport.go

@@ -130,24 +130,85 @@ func (c *ClientCommon) handleTransportReadResultWithSessionDispatcher(stopCtx co
 	return true
 }
 
+func (c *ClientCommon) readTransportPayloadPooled(conn net.Conn, reader *stario.FrameReader) ([]byte, func(), error) {
+	if reader == nil {
+		return nil, nil, net.ErrClosed
+	}
+	if conn == nil {
+		return nil, nil, net.ErrClosed
+	}
+	if c.maxReadTimeout.Seconds() != 0 {
+		_ = conn.SetReadDeadline(time.Now().Add(c.maxReadTimeout))
+	}
+	return reader.NextPooled()
+}
+
+func (c *ClientCommon) handleTransportPayloadReadResultWithSession(stopCtx context.Context, binding *transportBinding, payload []byte, release func(), err error, epoch uint64, dispatcher *inboundDispatcher) bool {
+	if err == os.ErrDeadlineExceeded {
+		return true
+	}
+	if err != nil {
+		if release != nil {
+			release()
+		}
+		if c.showError || c.debugMode {
+			fmt.Println("client read error", err)
+		}
+		select {
+		case <-sessionStopChan(stopCtx):
+			c.closeClientTransportBinding(binding)
+			return false
+		default:
+		}
+		c.stopClientSessionIfCurrent(epoch, "client read error", err)
+		return false
+	}
+	c.dispatchTransportPayloadFast(payload, release, dispatcher)
+	return true
+}
+
+func (c *ClientCommon) dispatchTransportPayloadFast(payload []byte, release func(), dispatcher *inboundDispatcher) {
+	if len(payload) == 0 {
+		if release != nil {
+			release()
+		}
+		return
+	}
+	if c.tryDispatchBorrowedBulkTransportPayload(payload) {
+		if release != nil {
+			release()
+		}
+		return
+	}
+	owned := append([]byte(nil), payload...)
+	if release != nil {
+		release()
+	}
+	if dispatcher == nil {
+		now := time.Now()
+		if err := c.dispatchInboundTransportPayload(owned, now); err != nil && (c.showError || c.debugMode) {
+			fmt.Println("client decode envelope error", err)
+		}
+		return
+	}
+	c.wg.Add(1)
+	if !dispatcher.Dispatch(clientInboundDispatchSource(), func() {
+		defer c.wg.Done()
+		now := time.Now()
+		if err := c.dispatchInboundTransportPayload(owned, now); err != nil && (c.showError || c.debugMode) {
+			fmt.Println("client decode envelope error", err)
+		}
+	}) {
+		c.wg.Done()
+	}
+}
+
 func (c *ClientCommon) pushMessageFast(queue *stario.StarQueue, data []byte, dispatcher *inboundDispatcher) bool {
 	if queue == nil || dispatcher == nil || len(data) == 0 {
 		return false
 	}
-	if err := queue.ParseMessageOwned(data, "b612", func(msg stario.MsgQueue) error {
-		payload := msg.Msg
-		c.wg.Add(1)
-		if !dispatcher.Dispatch(clientInboundDispatchSource(), func() {
-			defer c.wg.Done()
-			now := time.Now()
-			if err := c.dispatchInboundTransportPayload(payload, now); err != nil {
-				if c.showError || c.debugMode {
-					fmt.Println("client decode envelope error", err)
-				}
-			}
-		}) {
-			c.wg.Done()
-		}
+	if err := queue.ParseMessageView(data, "b612", func(frame stario.FrameView) error {
+		c.dispatchTransportPayloadFast(frame.Payload, nil, dispatcher)
 		return nil
 	}); err != nil && (c.showError || c.debugMode) {
 		fmt.Println("client parse inbound frame error", err)