@ttsc/darwin-x64 0.32.1 → 0.33.0

package/bin/go/src/net/http/httputil/reverseproxy.go

@@ -531,6 +531,21 @@ func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 		}
 	}
 
+	if outreq.Method == "CONNECT" {
+		// We cannot handle CONNECT requests.
+		// (Perhaps we should just send a 405 and never call ErrorHandler?
+		// More consistent to always call ErrorHandler or ModifyResponse,
+		// so we do that for now.)
+		err := errors.New("client sent unsupported CONNECT request")
+		if p.ErrorHandler != nil {
+			p.ErrorHandler(rw, outreq, err)
+		} else {
+			p.logf("http: proxy error: %v", err)
+			rw.WriteHeader(http.StatusMethodNotAllowed)
+		}
+		return
+	}
+
 	if _, ok := outreq.Header["User-Agent"]; !ok {
 		// If the outbound request doesn't have a User-Agent header set,
 		// don't send the default Go HTTP client User-Agent.

package/bin/go/src/net/http/server.go

@@ -1253,7 +1253,11 @@ func (cw *chunkWriter) writeHeader(p []byte) {
 
 	w := cw.res
 	keepAlivesEnabled := w.conn.server.doKeepAlives()
-	isHEAD := w.req.Method == "HEAD"
+
+	// Consult w.conn.lastMethod instead of w.req.Method,
+	// just in case a middleware layer modified w.req.
+	isHEAD := w.conn.lastMethod == "HEAD"
+	isCONNECT := w.conn.lastMethod == "CONNECT"
 
 	// header is written out to w.conn.buf below. Depending on the
 	// state of the handler, we either own the map or not. If we
@@ -1365,6 +1369,11 @@ func (cw *chunkWriter) writeHeader(p []byte) {
 		w.closeAfterReply = true
 	}
 
+	if isCONNECT {
+		// Don't reuse a connection after a CONNECT, even if we reject it.
+		w.closeAfterReply = true
+	}
+
 	// We do this by default because there are a number of clients that
 	// send a full request before starting to read the response, and they
 	// can deadlock if we start writing the response with unconsumed body
@@ -1464,7 +1473,13 @@ func (cw *chunkWriter) writeHeader(p []byte) {
 		hasCL = false
 	}
 
-	if w.req.Method == "HEAD" || !bodyAllowedForStatus(code) || code == StatusNoContent {
+	isSuccessfulCONNECT := isCONNECT && code >= 200 && code < 300
+	if isSuccessfulCONNECT {
+		// Tunnel established, connection is no longer HTTP.
+		delHeader("Transfer-Encoding")
+		delHeader("Content-Length")
+		setHeader.contentLength = nil
+	} else if isHEAD || !bodyAllowedForStatus(code) || code == StatusNoContent {
 		// Response has no body.
 		delHeader("Transfer-Encoding")
 	} else if hasCL {
@@ -1514,8 +1529,13 @@ func (cw *chunkWriter) writeHeader(p []byte) {
 		!isProtocolSwitchResponse(w.status, header)
 	if delConnectionHeader {
 		delHeader("Connection")
-		if w.req.ProtoAtLeast(1, 1) {
+		// Don't set Connection: close on a 2xx CONNECT response,
+		// even though we will close the connection if the handler doesn't hijack it.
+		// If the handler does hijack the connection, the Connection: close is confusing.
+		if w.req.ProtoAtLeast(1, 1) && !isSuccessfulCONNECT {
 			setHeader.connection = "close"
+		} else {
+			setHeader.connection = ""
 		}
 	}
 

package/bin/go/src/net/http/transport.go

@@ -2367,12 +2367,17 @@ func (pc *persistConn) readLoop() {
 		pc.mu.Unlock()
 
 		bodyWritable := resp.bodyIsWritable()
+		isConnect := rc.treq.Request.Method == "CONNECT"
 		hasBody := rc.treq.Request.Method != "HEAD" && resp.ContentLength != 0
 
-		if resp.Close || rc.treq.Request.Close || resp.StatusCode <= 199 || bodyWritable {
+		if resp.Close || rc.treq.Request.Close || resp.StatusCode <= 199 || bodyWritable || isConnect {
 			// Don't do keep-alive on error if either party requested a close
 			// or we get an unexpected informational (1xx) response.
 			// StatusCode 100 is already handled above.
+			//
+			// Don't do keep-alive after sending a CONNECT request.
+			// Only a 2xx response converts the connection into a tunnel,
+			// but for safety we'll drop the connection even after getting a non-2xx.
 			alive = false
 		}
 

package/bin/go/src/net/textproto/reader.go

@@ -180,7 +180,7 @@ func (r *Reader) readContinuedLineSlice(lim int64, validateFirstLine func([]byte
 		}
 		line, err := r.readLineSlice(lim - int64(len(r.buf)))
 		if err != nil {
-			break
+			return nil, err
 		}
 		r.buf = append(r.buf, trim(line)...)
 	}
@@ -514,6 +514,10 @@ func (r *Reader) ReadMIMEHeader() (MIMEHeader, error) {
 // readMIMEHeader is a version of ReadMIMEHeader which takes a limit on the header size.
 // It is called by the mime/multipart package.
 func readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error) {
+	if maxMemory < 0 {
+		return nil, errMessageTooLarge
+	}
+
 	// Avoid lots of small slice allocations later by allocating one
 	// large one ahead of time which we'll cut up into smaller
 	// slices. If this isn't big enough later, we allocate small ones.
@@ -528,12 +532,6 @@ func readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error)
 
 	m := make(MIMEHeader, hint)
 
-	// Account for 400 bytes of overhead for the MIMEHeader, plus 200 bytes per entry.
-	// Benchmarking map creation as of go1.20, a one-entry MIMEHeader is 416 bytes and large
-	// MIMEHeaders average about 200 bytes per entry.
-	maxMemory -= 400
-	const mapEntryOverhead = 200
-
 	// The first line cannot start with a leading space.
 	if buf, err := r.R.Peek(1); err == nil && (buf[0] == ' ' || buf[0] == '\t') {
 		const errorLimit = 80 // arbitrary limit on how much of the line we'll quote
@@ -575,6 +573,10 @@ func readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error)
 
 		vv := m[key]
 		if vv == nil {
+			// Account for per-entry overhead.
+			// 200 bytes is based on benchmarks circa Go 1.20.
+			const mapEntryOverhead = 200
+
 			maxMemory -= int64(len(key))
 			maxMemory -= mapEntryOverhead
 		}

package/bin/go/src/os/file_windows.go

@@ -100,11 +100,15 @@ func newFile(h syscall.Handle, name string, kind newFileKind, nonBlocking bool)
 		panic("newFile with unknown kind")
 	}
 
+	// Completion notification modes are shared by all handles to the file
+	// object. Preserve them for handles passed to NewFile, since other users
+	// of the file object may rely on those modes. See go.dev/issue/80979.
 	f := &File{&file{
 		pfd: poll.FD{
-			Sysfd:         h,
-			IsStream:      true,
-			ZeroReadIsEOF: true,
+			Sysfd:                   h,
+			IsStream:                true,
+			ZeroReadIsEOF:           true,
+			KeepFileCompletionModes: kind == kindNewFile,
 		},
 		name: name,
 	}}

package/bin/go/src/os/root_openat.go

@@ -153,13 +153,13 @@ func rootMkdirAll(r *Root, fullname string, perm FileMode) error {
 	openLastComponentFunc := func(parent sysfdType, name string, endsInSlash bool) (struct{}, error) {
 		err := mkdirat(parent, name, perm)
 		if err == syscall.EEXIST {
-			mode, e := modeAt(parent, name)
+			fi, e := lstatat(parent, name)
 			if e == nil {
-				if mode.IsDir() {
+				if fi.Mode().IsDir() {
 					// The target of MkdirAll is an existing directory.
 					err = nil
-				} else if mode&ModeSymlink != 0 {
-					// The target of MkdirAll is a symlink.
+				} else if isLink(fi) {
+					// The target of MkdirAll is a symlink or junction.
 					// For consistency with os.MkdirAll,
 					// succeed if the link resolves to a directory.
 					// We don't return errSymlink here, because we don't
@@ -420,7 +420,7 @@ Loop:
 				case err != nil:
 					return
 				case fi.Mode().Type() == fs.ModeDir:
-				case fi.Mode().Type() == fs.ModeSymlink:
+				case isLink(fi):
 					if runtime.GOOS != "windows" || flags&doInRootAlwaysResolveTerminalSlash != 0 {
 						err = checkSymlink(dirfd, parts[i], syscall.ENOTDIR)
 					} else {

package/bin/go/src/os/root_unix.go

@@ -306,6 +306,10 @@ func readlinkat(fd int, name string) (string, error) {
 	}
 }
 
+func isLink(fi FileInfo) bool {
+	return fi.Mode()&ModeSymlink != 0
+}
+
 // isDirectoryLink always returns false, because Unix systems don't have separate
 // symlink types for files and directories.
 // (See the Windows version of this function for more details.)

package/bin/go/src/os/root_windows.go

@@ -421,8 +421,14 @@ func lstatat(parent syscall.Handle, name string) (FileInfo, error) {
 	return fi, nil
 }
 
-// isDirectoryLink reports whether fi (assumed to be a symlink) is a directory link.
-// Windows symlinks come in two flavors: file and directory. This function distinguishes
+// isLink reports whether fi is a symlink or other surrogate reparse point (such as a junction).
+func isLink(fi FileInfo) bool {
+	fs, ok := fi.(*fileStat)
+	return ok && fs.isReparseTagNameSurrogate()
+}
+
+// isDirectoryLink reports whether fi (assumed to be a link) is a directory link.
+// Windows links come in two flavors: file and directory. This function distinguishes
 // between the two.
 func isDirectoryLink(fi FileInfo) bool {
 	fs, ok := fi.(*fileStat)

package/bin/go/src/runtime/metrics/doc.go

@@ -342,6 +342,11 @@ Below is the full list of supported metrics, ordered lexicographically.
 		by the net/http package due to a non-default
 		GODEBUG=httpservecontentkeepheaders=... setting.
 
+	/godebug/non-default-behavior/httpservecontentmaxranges:events
+		The number of non-default behaviors executed
+		by the net/http package due to a non-default
+		GODEBUG=httpservecontentmaxranges=... setting.
+
 	/godebug/non-default-behavior/installgoroot:events
 		The number of non-default behaviors executed by the go/build
 		package due to a non-default GODEBUG=installgoroot=... setting.

package/bin/go/src/runtime/netpoll_epoll.go

@@ -18,6 +18,21 @@ var (
 	netpollWakeSig atomic.Uint32      // used to avoid duplicate calls of netpollBreak
 )
 
+// netpollPackData stores pd and its fdseq in the epoll data field of ev as
+// a taggedPointer. A nil pd marks the netpollBreak eventfd: netpollopen always
+// registers a non-nil *pollDesc, so netpollUnpackData can tell the two apart
+// by the pointer alone, on any word size or endianness.
+func netpollPackData(ev *linux.EpollEvent, pd *pollDesc, fdseq uintptr) {
+	*(*taggedPointer)(unsafe.Pointer(&ev.Data)) = taggedPointerPack(unsafe.Pointer(pd), fdseq)
+}
+
+// netpollUnpackData returns the pollDesc and fdseq stored by netpollPackData.
+// pd is nil for the netpollBreak eventfd.
+func netpollUnpackData(ev *linux.EpollEvent) (pd *pollDesc, fdseq uintptr) {
+	tp := *(*taggedPointer)(unsafe.Pointer(&ev.Data))
+	return (*pollDesc)(tp.pointer()), tp.tag()
+}
+
 func netpollinit() {
 	var errno uintptr
 	epfd, errno = linux.EpollCreate1(linux.EPOLL_CLOEXEC)
@@ -33,7 +48,7 @@ func netpollinit() {
 	ev := linux.EpollEvent{
 		Events: linux.EPOLLIN,
 	}
-	*(**uintptr)(unsafe.Pointer(&ev.Data)) = &netpollEventFd
+	netpollPackData(&ev, nil, 0)
 	errno = linux.EpollCtl(epfd, linux.EPOLL_CTL_ADD, efd, &ev)
 	if errno != 0 {
 		println("runtime: epollctl failed with", errno)
@@ -49,8 +64,7 @@ func netpollIsPollDescriptor(fd uintptr) bool {
 func netpollopen(fd uintptr, pd *pollDesc) uintptr {
 	var ev linux.EpollEvent
 	ev.Events = linux.EPOLLIN | linux.EPOLLOUT | linux.EPOLLRDHUP | linux.EPOLLET
-	tp := taggedPointerPack(unsafe.Pointer(pd), pd.fdseq.Load())
-	*(*taggedPointer)(unsafe.Pointer(&ev.Data)) = tp
+	netpollPackData(&ev, pd, pd.fdseq.Load())
 	return linux.EpollCtl(epfd, linux.EPOLL_CTL_ADD, int32(fd), &ev)
 }
 
@@ -137,7 +151,9 @@ retry:
 			continue
 		}
 
-		if *(**uintptr)(unsafe.Pointer(&ev.Data)) == &netpollEventFd {
+		pd, tag := netpollUnpackData(&ev)
+		// pd == nil denotes a netpollBreak eventfd.
+		if pd == nil {
 			if ev.Events != linux.EPOLLIN {
 				println("runtime: netpoll: eventfd ready for", ev.Events)
 				throw("runtime: netpoll: eventfd ready for something unexpected")
@@ -163,9 +179,6 @@ retry:
 			mode += 'w'
 		}
 		if mode != 0 {
-			tp := *(*taggedPointer)(unsafe.Pointer(&ev.Data))
-			pd := (*pollDesc)(tp.pointer())
-			tag := tp.tag()
 			if pd.fdseq.Load() == tag {
 				pd.setEventErr(ev.Events == linux.EPOLLERR, tag)
 				delta += netpollready(&toRun, pd, mode)

package/bin/go/src/runtime/os_windows.go

@@ -1149,6 +1149,23 @@ const preemptMSupported = true
 // suspending each other.
 var suspendLock mutex
 
+// threadPausedLockRank warns the runtime against acquiring new locks on this
+// thread while it has another thread paused. The holder of this lock rank is
+// effectively a signal handler for a paused thread, which may be holding
+// arbitrary locks.
+//
+// The warning takes two concrete forms: First, unlock2 will see that this
+// thread is holding other locks, so won't try to flush the mutex contention
+// buffer (which can involve acquiring another lock). Second, builds with
+// GOEXPERIMENT=staticlockranking (currently broken, https://go.dev/issue/76058)
+// will report a rank violation.
+//
+// suspendLock serializes the transition into "suspended", but it's fine for
+// multiple threads to be in the suspended state concurrently, with each of
+// their sponsors independently using threadPausedLockRank to discourage
+// themselves from acquiring new locks.
+const threadPausedLockRank = lockRankLeafRank
+
 func preemptM(mp *m) {
 	if mp == getg().m {
 		throw("self-preempt")
@@ -1191,6 +1208,9 @@ func preemptM(mp *m) {
 	// actually suspended.
 	lock(&suspendLock)
 
+	// Signal handler rules are in effect; don't acquire new locks.
+	acquireLockRankAndM(threadPausedLockRank)
+
 	// Suspend the thread.
 	if int32(stdcall(_SuspendThread, thread)) == -1 {
 		unlock(&suspendLock)
@@ -1199,6 +1219,7 @@ func preemptM(mp *m) {
 		// The thread no longer exists. This shouldn't be
 		// possible, but just acknowledge the request.
 		mp.preemptGen.Add(1)
+		releaseLockRankAndM(threadPausedLockRank)
 		return
 	}
 
@@ -1233,6 +1254,8 @@ func preemptM(mp *m) {
 
 	stdcall(_ResumeThread, thread)
 	stdcall(_CloseHandle, thread)
+
+	releaseLockRankAndM(threadPausedLockRank)
 }
 
 // osPreemptExtEnter is called before entering external code that may

package/bin/go/src/vendor/modules.txt

@@ -6,7 +6,7 @@ golang.org/x/crypto/cryptobyte
 golang.org/x/crypto/cryptobyte/asn1
 golang.org/x/crypto/internal/alias
 golang.org/x/crypto/internal/poly1305
-# golang.org/x/net v0.47.1-0.20260731170545-cb1d721f7fb3
+# golang.org/x/net v0.47.1-0.20260925170545-1431957440b7
 ## explicit; go 1.24.0
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/darwin-x64",
-  "version": "0.32.1",
+  "version": "0.33.0",
   "description": "macOS x64 native ttsc/ttscserver binaries and bundled Go compiler for ttsc.",
   "os": [
     "darwin"
@@ -24,6 +24,7 @@
     "executableFiles": [
       "./bin/ttsc",
       "./bin/ttscserver",
+      "./bin/ttsc-cache",
       "./bin/go/bin/go",
       "./bin/go/bin/gofmt",
       "./bin/go/pkg/tool/darwin_amd64/asm",