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

release_p0_test.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"net"
 	"strings"
+	"sync/atomic"
 	"testing"
 	"time"
 )
@@ -14,6 +15,29 @@ type releaseP0TestAddr string
 func (a releaseP0TestAddr) Network() string { return "tcp" }
 func (a releaseP0TestAddr) String() string  { return string(a) }
 
+type closeInspectConn struct {
+	closeFn func()
+	closed  atomic.Bool
+}
+
+func (c *closeInspectConn) Read([]byte) (int, error)         { return 0, net.ErrClosed }
+func (c *closeInspectConn) Write(p []byte) (int, error)      { return len(p), nil }
+func (c *closeInspectConn) LocalAddr() net.Addr              { return releaseP0TestAddr("local") }
+func (c *closeInspectConn) RemoteAddr() net.Addr             { return releaseP0TestAddr("remote") }
+func (c *closeInspectConn) SetDeadline(time.Time) error      { return nil }
+func (c *closeInspectConn) SetReadDeadline(time.Time) error  { return nil }
+func (c *closeInspectConn) SetWriteDeadline(time.Time) error { return nil }
+
+func (c *closeInspectConn) Close() error {
+	if c == nil {
+		return nil
+	}
+	if c.closed.CompareAndSwap(false, true) && c.closeFn != nil {
+		c.closeFn()
+	}
+	return nil
+}
+
 func TestGetLogicalConnRuntimeSnapshotWithoutCompatClient(t *testing.T) {
 	server := NewServer().(*ServerCommon)
 	logical := &LogicalConn{server: server}
@@ -101,6 +125,116 @@ func TestHandleDedicatedBulkReadErrorPreservesUnderlyingCause(t *testing.T) {
 	}
 }
 
+func TestHandleClientDedicatedSidecarFailureMarksBulkBeforeClosingConn(t *testing.T) {
+	client := NewClient().(*ClientCommon)
+	runtime := client.getBulkRuntime()
+	if runtime == nil {
+		t.Fatal("client bulk runtime should not be nil")
+	}
+	bulk := newBulkHandle(context.Background(), runtime, clientFileScope(), BulkOpenRequest{
+		BulkID:    "sidecar-order",
+		DataID:    7,
+		Dedicated: true,
+		Range: BulkRange{
+			Length: 1,
+		},
+	}, 0, nil, nil, 0, nil, nil, nil, nil, nil)
+	var closeObservedErr error
+	conn := &closeInspectConn{
+		closeFn: func() {
+			closeObservedErr = bulk.resetErrSnapshot()
+		},
+	}
+	if err := bulk.attachDedicatedConnShared(conn); err != nil {
+		t.Fatalf("attachDedicatedConnShared failed: %v", err)
+	}
+	if err := runtime.register(clientFileScope(), bulk); err != nil {
+		t.Fatalf("register bulk failed: %v", err)
+	}
+	sidecar := newBulkDedicatedSidecar(conn, 1)
+	client.installClientDedicatedSidecar(1, sidecar)
+
+	client.handleClientDedicatedSidecarFailure(sidecar, errors.New("boom sidecar"))
+
+	if !errors.Is(closeObservedErr, errTransportDetached) {
+		t.Fatalf("closeObservedErr = %v, want transport detached", closeObservedErr)
+	}
+	if !strings.Contains(closeObservedErr.Error(), "dedicated bulk read error") || !strings.Contains(closeObservedErr.Error(), "boom sidecar") {
+		t.Fatalf("closeObservedErr detail = %q, want dedicated read error and cause", closeObservedErr.Error())
+	}
+}
+
+func TestCleanupClientSessionResourcesMarksBulkBeforeClosingSidecar(t *testing.T) {
+	client := NewClient().(*ClientCommon)
+	runtime := client.getBulkRuntime()
+	if runtime == nil {
+		t.Fatal("client bulk runtime should not be nil")
+	}
+	bulk := newBulkHandle(context.Background(), runtime, clientFileScope(), BulkOpenRequest{
+		BulkID:    "cleanup-order",
+		DataID:    9,
+		Dedicated: true,
+		Range: BulkRange{
+			Length: 1,
+		},
+	}, 0, nil, nil, 0, nil, nil, nil, nil, nil)
+	var closeObservedErr error
+	conn := &closeInspectConn{
+		closeFn: func() {
+			closeObservedErr = bulk.resetErrSnapshot()
+		},
+	}
+	if err := bulk.attachDedicatedConnShared(conn); err != nil {
+		t.Fatalf("attachDedicatedConnShared failed: %v", err)
+	}
+	if err := runtime.register(clientFileScope(), bulk); err != nil {
+		t.Fatalf("register bulk failed: %v", err)
+	}
+	client.installClientDedicatedSidecar(1, newBulkDedicatedSidecar(conn, 1))
+
+	client.cleanupClientSessionResources()
+
+	if !errors.Is(closeObservedErr, errServiceShutdown) {
+		t.Fatalf("closeObservedErr = %v, want %v", closeObservedErr, errServiceShutdown)
+	}
+}
+
+func TestBestEffortRejectInboundDedicatedDataUsesDedicatedResetRecord(t *testing.T) {
+	server := NewServer().(*ServerCommon)
+	UseLegacySecurityServer(server)
+
+	logical := server.bootstrapAcceptedLogical("dedicated-reject", nil, nil)
+	if logical == nil {
+		t.Fatal("bootstrapAcceptedLogical should return logical")
+	}
+	conn := newBulkAttachScriptConn(nil)
+
+	server.bestEffortRejectInboundDedicatedData(logical, conn, 42, "unknown data id")
+
+	recordConn := newBulkAttachScriptConn(conn.writtenBytes())
+	payload, err := readBulkDedicatedRecord(recordConn)
+	if err != nil {
+		t.Fatalf("readBulkDedicatedRecord failed: %v", err)
+	}
+	plain, err := server.decryptTransportPayloadLogical(logical, payload)
+	if err != nil {
+		t.Fatalf("decryptTransportPayloadLogical failed: %v", err)
+	}
+	items, err := decodeDedicatedBulkInboundItems(42, plain)
+	if err != nil {
+		t.Fatalf("decodeDedicatedBulkInboundItems failed: %v", err)
+	}
+	if len(items) != 1 {
+		t.Fatalf("decoded items = %d, want 1", len(items))
+	}
+	if items[0].Type != bulkFastPayloadTypeReset {
+		t.Fatalf("reset item type = %d, want %d", items[0].Type, bulkFastPayloadTypeReset)
+	}
+	if got, want := string(items[0].Payload), "unknown data id"; got != want {
+		t.Fatalf("reset payload = %q, want %q", got, want)
+	}
+}
+
 func TestRegisterAcceptedLogicalWithoutCompatClient(t *testing.T) {
 	server := NewServer().(*ServerCommon)
 	UseLegacySecurityServer(server)