type context.Context

967 uses

	context (current package)
		context.go#L71: type Context interface {
		context.go#L215: func Background() Context {
		context.go#L223: func TODO() Context {
		context.go#L240: func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
		context.go#L268: func WithCancelCause(parent Context) (ctx Context, cancel CancelCauseFunc) {
		context.go#L273: func withCancel(parent Context) *cancelCtx {
		context.go#L288: func Cause(c Context) error {
		context.go#L325: func AfterFunc(ctx Context, f func()) (stop func() bool) {
		context.go#L366: 	Context
		context.go#L382: func parentCancelCtx(parent Context) (*cancelCtx, bool) {
		context.go#L399: func removeChild(parent Context, child canceler) {
		context.go#L432: 	Context
		context.go#L475: func (c *cancelCtx) propagateCancel(parent Context, child canceler) {
		context.go#L535: func contextName(c Context) string {
		context.go#L585: func WithoutCancel(parent Context) Context {
		context.go#L593: 	c Context
		context.go#L625: func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
		context.go#L632: func WithDeadlineCause(parent Context, d time.Time, cause error) (Context, CancelFunc) {
		context.go#L703: func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
		context.go#L710: func WithTimeoutCause(parent Context, timeout time.Duration, cause error) (Context, CancelFunc) {
		context.go#L727: func WithValue(parent Context, key, val any) Context {
		context.go#L743: 	Context
		context.go#L775: func value(c Context, key any) any {

	crypto/tls
		common.go#L495: 	ctx context.Context
		common.go#L501: func (c *ClientHelloInfo) Context() context.Context {
		common.go#L523: 	ctx context.Context
		common.go#L529: func (c *CertificateRequestInfo) Context() context.Context {
		conn.go#L32: 	handshakeFn func(context.Context) error // (*Conn).clientHandshake or serverHandshake
		conn.go#L1513: func (c *Conn) HandshakeContext(ctx context.Context) error {
		conn.go#L1519: func (c *Conn) handshakeContext(ctx context.Context) (ret error) {
		handshake_client.go#L33: 	ctx          context.Context
		handshake_client.go#L221: func (c *Conn) clientHandshake(ctx context.Context) (err error) {
		handshake_client.go#L1200: func certificateRequestInfoFromMsg(ctx context.Context, vers uint16, certReq *certificateRequestMsg) *CertificateRequestInfo {
		handshake_client_tls13.go#L24: 	ctx          context.Context
		handshake_server.go#L27: 	ctx          context.Context
		handshake_server.go#L42: func (c *Conn) serverHandshake(ctx context.Context) error {
		handshake_server.go#L134: func (c *Conn) readClientHello(ctx context.Context) (*clientHelloMsg, *echServerContext, error) {
		handshake_server.go#L1021: func clientHelloInfo(ctx context.Context, c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo {
		handshake_server_tls13.go#L47: 	ctx             context.Context
		quic.go#L165: 	ctx      context.Context // handshake context
		quic.go#L213: func (q *QUICConn) Start(ctx context.Context) error {
		tls.go#L133: func dial(ctx context.Context, netDialer *net.Dialer, network, addr string, config *Config) (*Conn, error) {
		tls.go#L229: func (d *Dialer) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {

	database/sql
		ctxutil.go#L13: func ctxDriverPrepare(ctx context.Context, ci driver.Conn, query string) (driver.Stmt, error) {
		ctxutil.go#L29: func ctxDriverExec(ctx context.Context, execerCtx driver.ExecerContext, execer driver.Execer, query string, nvdargs []driver.NamedValue) (driver.Result, error) {
		ctxutil.go#L46: func ctxDriverQuery(ctx context.Context, queryerCtx driver.QueryerContext, queryer driver.Queryer, query string, nvdargs []driver.NamedValue) (driver.Rows, error) {
		ctxutil.go#L63: func ctxDriverStmtExec(ctx context.Context, si driver.Stmt, nvdargs []driver.NamedValue) (driver.Result, error) {
		ctxutil.go#L80: func ctxDriverStmtQuery(ctx context.Context, si driver.Stmt, nvdargs []driver.NamedValue) (driver.Rows, error) {
		ctxutil.go#L97: func ctxDriverBegin(ctx context.Context, opts *TxOptions, ci driver.Conn) (driver.Tx, error) {
		sql.go#L596: func (dc *driverConn) resetSession(ctx context.Context) error {
		sql.go#L626: func (dc *driverConn) prepareLocked(ctx context.Context, cg stmtConnGrabber, query string) (*driverStmt, error) {
		sql.go#L808: func (t dsnConnector) Connect(_ context.Context) (driver.Conn, error) {
		sql.go#L882: func (db *DB) pingDC(ctx context.Context, dc *driverConn, release func(error)) error {
		sql.go#L895: func (db *DB) PingContext(ctx context.Context) error {
		sql.go#L1259: func (db *DB) connectionOpener(ctx context.Context) {
		sql.go#L1271: func (db *DB) openNewConnection(ctx context.Context) {
		sql.go#L1316: func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn, error) {
		sql.go#L1594: func (db *DB) PrepareContext(ctx context.Context, query string) (*Stmt, error) {
		sql.go#L1618: func (db *DB) prepare(ctx context.Context, query string, strategy connReuseStrategy) (*Stmt, error) {
		sql.go#L1635: func (db *DB) prepareDC(ctx context.Context, dc *driverConn, release func(error), cg stmtConnGrabber, query string) (*Stmt, error) {
		sql.go#L1667: func (db *DB) ExecContext(ctx context.Context, query string, args ...any) (Result, error) {
		sql.go#L1688: func (db *DB) exec(ctx context.Context, query string, args []any, strategy connReuseStrategy) (Result, error) {
		sql.go#L1696: func (db *DB) execDC(ctx context.Context, dc *driverConn, release func(error), query string, args []any) (res Result, err error) {
		sql.go#L1737: func (db *DB) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) {
		sql.go#L1758: func (db *DB) query(ctx context.Context, query string, args []any, strategy connReuseStrategy) (*Rows, error) {
		sql.go#L1771: func (db *DB) queryDC(ctx, txctx context.Context, dc *driverConn, releaseConn func(error), query string, args []any) (*Rows, error) {
		sql.go#L1841: func (db *DB) QueryRowContext(ctx context.Context, query string, args ...any) *Row {
		sql.go#L1869: func (db *DB) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error) {
		sql.go#L1890: func (db *DB) begin(ctx context.Context, opts *TxOptions, strategy connReuseStrategy) (tx *Tx, err error) {
		sql.go#L1899: func (db *DB) beginDC(ctx context.Context, dc *driverConn, release func(error), opts *TxOptions) (tx *Tx, err error) {
		sql.go#L1945: func (db *DB) Conn(ctx context.Context) (*Conn, error) {
		sql.go#L2000: func (c *Conn) grabConn(context.Context) (*driverConn, releaseConn, error) {
		sql.go#L2012: func (c *Conn) PingContext(ctx context.Context) error {
		sql.go#L2022: func (c *Conn) ExecContext(ctx context.Context, query string, args ...any) (Result, error) {
		sql.go#L2032: func (c *Conn) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) {
		sql.go#L2046: func (c *Conn) QueryRowContext(ctx context.Context, query string, args ...any) *Row {
		sql.go#L2059: func (c *Conn) PrepareContext(ctx context.Context, query string) (*Stmt, error) {
		sql.go#L2110: func (c *Conn) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error) {
		sql.go#L2127: func (c *Conn) txCtx() context.Context {
		sql.go#L2204: 	ctx context.Context
		sql.go#L2245: func (tx *Tx) grabConn(ctx context.Context) (*driverConn, releaseConn, error) {
		sql.go#L2265: func (tx *Tx) txCtx() context.Context {
		sql.go#L2372: func (tx *Tx) PrepareContext(ctx context.Context, query string) (*Stmt, error) {
		sql.go#L2417: func (tx *Tx) StmtContext(ctx context.Context, stmt *Stmt) *Stmt {
		sql.go#L2511: func (tx *Tx) ExecContext(ctx context.Context, query string, args ...any) (Result, error) {
		sql.go#L2529: func (tx *Tx) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) {
		sql.go#L2552: func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...any) *Row {
		sql.go#L2581: 	grabConn(context.Context) (*driverConn, releaseConn, error)
		sql.go#L2586: 	txCtx() context.Context
		sql.go#L2643: func (s *Stmt) ExecContext(ctx context.Context, args ...any) (Result, error) {
		sql.go#L2671: func resultFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, args ...any) (Result, error) {
		sql.go#L2718: func (s *Stmt) connStmt(ctx context.Context, strategy connReuseStrategy) (dc *driverConn, releaseConn func(error), ds *driverStmt, err error) {
		sql.go#L2771: func (s *Stmt) prepareOnConnLocked(ctx context.Context, dc *driverConn) (*driverStmt, error) {
		sql.go#L2785: func (s *Stmt) QueryContext(ctx context.Context, args ...any) (*Rows, error) {
		sql.go#L2817: 			var txctx context.Context
		sql.go#L2841: func rowsiFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, args ...any) (driver.Rows, error) {
		sql.go#L2857: func (s *Stmt) QueryRowContext(ctx context.Context, args ...any) *Row {
		sql.go#L2987: func (rs *Rows) initContextClose(ctx, txctx context.Context) {
		sql.go#L3004: func (rs *Rows) awaitDone(ctx, txctx, closectx context.Context) {

	database/sql/driver
		driver.go#L136: 	Connect(context.Context) (Conn, error)
		driver.go#L173: 	Ping(ctx context.Context) error
		driver.go#L200: 	ExecContext(ctx context.Context, query string, args []NamedValue) (Result, error)
		driver.go#L227: 	QueryContext(ctx context.Context, query string, args []NamedValue) (Rows, error)
		driver.go#L262: 	PrepareContext(ctx context.Context, query string) (Stmt, error)
		driver.go#L293: 	BeginTx(ctx context.Context, opts TxOptions) (Tx, error)
		driver.go#L302: 	ResetSession(ctx context.Context) error
		driver.go#L370: 	ExecContext(ctx context.Context, args []NamedValue) (Result, error)
		driver.go#L379: 	QueryContext(ctx context.Context, args []NamedValue) (Rows, error)

	github.com/jackc/pgx/v5
		batch.go#L119: 	ctx       context.Context
		batch.go#L280: 	ctx       context.Context
		conn.go#L135: func Connect(ctx context.Context, connString string) (*Conn, error) {
		conn.go#L145: func ConnectWithOptions(ctx context.Context, connString string, options ParseConfigOptions) (*Conn, error) {
		conn.go#L155: func ConnectConfig(ctx context.Context, connConfig *ConnConfig) (*Conn, error) {
		conn.go#L243: func connect(ctx context.Context, config *ConnConfig) (c *Conn, err error) {
		conn.go#L301: func (c *Conn) Close(ctx context.Context) error {
		conn.go#L319: func (c *Conn) Prepare(ctx context.Context, name, sql string) (sd *pgconn.StatementDescription, err error) {
		conn.go#L375: func (c *Conn) Deallocate(ctx context.Context, name string) error {
		conn.go#L397: func (c *Conn) DeallocateAll(ctx context.Context) error {
		conn.go#L415: func (c *Conn) WaitForNotification(ctx context.Context) (*pgconn.Notification, error) {
		conn.go#L453: func (c *Conn) Ping(ctx context.Context) error {
		conn.go#L472: func (c *Conn) Exec(ctx context.Context, sql string, arguments ...any) (pgconn.CommandTag, error) {
		conn.go#L490: func (c *Conn) exec(ctx context.Context, sql string, arguments ...any) (commandTag pgconn.CommandTag, err error) {
		conn.go#L580: func (c *Conn) execSimpleProtocol(ctx context.Context, sql string, arguments []any) (commandTag pgconn.CommandTag, err error) {
		conn.go#L596: func (c *Conn) execParams(ctx context.Context, sd *pgconn.StatementDescription, arguments []any) (pgconn.CommandTag, error) {
		conn.go#L607: func (c *Conn) execPrepared(ctx context.Context, sd *pgconn.StatementDescription, arguments []any) (pgconn.CommandTag, error) {
		conn.go#L618: func (c *Conn) execSQLParams(ctx context.Context, sql string, args []any) (pgconn.CommandTag, error) {
		conn.go#L629: func (c *Conn) getRows(ctx context.Context, sql string, args []any) *baseRows {
		conn.go#L727: 	RewriteQuery(ctx context.Context, conn *Conn, sql string, args []any) (newSQL string, newArgs []any, err error)
		conn.go#L751: func (c *Conn) Query(ctx context.Context, sql string, args ...any) (Rows, error) {
		conn.go#L893: 	ctx context.Context,
		conn.go#L931: func (c *Conn) QueryRow(ctx context.Context, sql string, args ...any) Row {
		conn.go#L942: func (c *Conn) SendBatch(ctx context.Context, b *Batch) (br BatchResults) {
		conn.go#L1017: func (c *Conn) sendBatchQueryExecModeSimpleProtocol(ctx context.Context, b *Batch) *batchResults {
		conn.go#L1039: func (c *Conn) sendBatchQueryExecModeExec(ctx context.Context, b *Batch) *batchResults {
		conn.go#L1073: func (c *Conn) sendBatchQueryExecModeCacheStatement(ctx context.Context, b *Batch) (pbr *pipelineBatchResults) {
		conn.go#L1105: func (c *Conn) sendBatchQueryExecModeCacheDescribe(ctx context.Context, b *Batch) (pbr *pipelineBatchResults) {
		conn.go#L1136: func (c *Conn) sendBatchQueryExecModeDescribeExec(ctx context.Context, b *Batch) (pbr *pipelineBatchResults) {
		conn.go#L1158: func (c *Conn) sendBatchExtendedWithDescription(ctx context.Context, b *Batch, distinctNewQueries []*pgconn.StatementDescription, sdCache stmtcache.Cache) (pbr *pipelineBatchResults) {
		conn.go#L1290: func (c *Conn) LoadType(ctx context.Context, typeName string) (*pgtype.Type, error) {
		conn.go#L1364: func (c *Conn) getArrayElementOID(ctx context.Context, oid uint32) (uint32, error) {
		conn.go#L1375: func (c *Conn) getRangeElementOID(ctx context.Context, oid uint32) (uint32, error) {
		conn.go#L1386: func (c *Conn) getMultiRangeElementOID(ctx context.Context, oid uint32) (uint32, error) {
		conn.go#L1397: func (c *Conn) getCompositeFields(ctx context.Context, oid uint32) ([]pgtype.CompositeCodecField, error) {
		conn.go#L1431: func (c *Conn) deallocateInvalidatedCachedStatements(ctx context.Context) error {
		copy_from.go#L118: func (ct *copyFrom) run(ctx context.Context) (int64, error) {
		copy_from.go#L265: func (c *Conn) CopyFrom(ctx context.Context, tableName Identifier, columnNames []string, rowSrc CopyFromSource) (int64, error) {
		derived_types.go#L162: func (c *Conn) LoadTypes(ctx context.Context, typeNames []string) ([]*pgtype.Type, error) {
		large_objects.go#L32: func (o *LargeObjects) Create(ctx context.Context, oid uint32) (uint32, error) {
		large_objects.go#L39: func (o *LargeObjects) Open(ctx context.Context, oid uint32, mode LargeObjectMode) (*LargeObject, error) {
		large_objects.go#L49: func (o *LargeObjects) Unlink(ctx context.Context, oid uint32) error {
		large_objects.go#L71: 	ctx context.Context
		named_args.go#L26: func (na NamedArgs) RewriteQuery(ctx context.Context, conn *Conn, sql string, args []any) (newSQL string, newArgs []any, err error) {
		named_args.go#L35: func (sna StrictNamedArgs) RewriteQuery(ctx context.Context, conn *Conn, sql string, args []any) (newSQL string, newArgs []any, err error) {
		named_args.go#L43: func (r errorQueryRewriter) RewriteQuery(ctx context.Context, conn *Conn, sql string, args []any) (newSQL string, newArgs []any, err error) {
		rows.go#L140: 	ctx         context.Context
		tracer.go#L13: 	TraceQueryStart(ctx context.Context, conn *Conn, data TraceQueryStartData) context.Context
		tracer.go#L15: 	TraceQueryEnd(ctx context.Context, conn *Conn, data TraceQueryEndData)
		tracer.go#L32: 	TraceBatchStart(ctx context.Context, conn *Conn, data TraceBatchStartData) context.Context
		tracer.go#L34: 	TraceBatchQuery(ctx context.Context, conn *Conn, data TraceBatchQueryData)
		tracer.go#L35: 	TraceBatchEnd(ctx context.Context, conn *Conn, data TraceBatchEndData)
		tracer.go#L57: 	TraceCopyFromStart(ctx context.Context, conn *Conn, data TraceCopyFromStartData) context.Context
		tracer.go#L59: 	TraceCopyFromEnd(ctx context.Context, conn *Conn, data TraceCopyFromEndData)
		tracer.go#L76: 	TracePrepareStart(ctx context.Context, conn *Conn, data TracePrepareStartData) context.Context
		tracer.go#L78: 	TracePrepareEnd(ctx context.Context, conn *Conn, data TracePrepareEndData)
		tracer.go#L95: 	TraceConnectStart(ctx context.Context, data TraceConnectStartData) context.Context
		tracer.go#L97: 	TraceConnectEnd(ctx context.Context, data TraceConnectEndData)
		tx.go#L94: func (c *Conn) Begin(ctx context.Context) (Tx, error) {
		tx.go#L100: func (c *Conn) BeginTx(ctx context.Context, txOptions TxOptions) (Tx, error) {
		tx.go#L124: 	Begin(ctx context.Context) (Tx, error)
		tx.go#L130: 	Commit(ctx context.Context) error
		tx.go#L137: 	Rollback(ctx context.Context) error
		tx.go#L139: 	CopyFrom(ctx context.Context, tableName Identifier, columnNames []string, rowSrc CopyFromSource) (int64, error)
		tx.go#L140: 	SendBatch(ctx context.Context, b *Batch) BatchResults
		tx.go#L143: 	Prepare(ctx context.Context, name, sql string) (*pgconn.StatementDescription, error)
		tx.go#L145: 	Exec(ctx context.Context, sql string, arguments ...any) (commandTag pgconn.CommandTag, err error)
		tx.go#L146: 	Query(ctx context.Context, sql string, args ...any) (Rows, error)
		tx.go#L147: 	QueryRow(ctx context.Context, sql string, args ...any) Row
		tx.go#L165: func (tx *dbTx) Begin(ctx context.Context) (Tx, error) {
		tx.go#L180: func (tx *dbTx) Commit(ctx context.Context) error {
		tx.go#L209: func (tx *dbTx) Rollback(ctx context.Context) error {
		tx.go#L226: func (tx *dbTx) Exec(ctx context.Context, sql string, arguments ...any) (commandTag pgconn.CommandTag, err error) {
		tx.go#L235: func (tx *dbTx) Prepare(ctx context.Context, name, sql string) (*pgconn.StatementDescription, error) {
		tx.go#L244: func (tx *dbTx) Query(ctx context.Context, sql string, args ...any) (Rows, error) {
		tx.go#L255: func (tx *dbTx) QueryRow(ctx context.Context, sql string, args ...any) Row {
		tx.go#L261: func (tx *dbTx) CopyFrom(ctx context.Context, tableName Identifier, columnNames []string, rowSrc CopyFromSource) (int64, error) {
		tx.go#L270: func (tx *dbTx) SendBatch(ctx context.Context, b *Batch) BatchResults {
		tx.go#L295: func (sp *dbSimulatedNestedTx) Begin(ctx context.Context) (Tx, error) {
		tx.go#L304: func (sp *dbSimulatedNestedTx) Commit(ctx context.Context) error {
		tx.go#L317: func (sp *dbSimulatedNestedTx) Rollback(ctx context.Context) error {
		tx.go#L328: func (sp *dbSimulatedNestedTx) Exec(ctx context.Context, sql string, arguments ...any) (commandTag pgconn.CommandTag, err error) {
		tx.go#L337: func (sp *dbSimulatedNestedTx) Prepare(ctx context.Context, name, sql string) (*pgconn.StatementDescription, error) {
		tx.go#L346: func (sp *dbSimulatedNestedTx) Query(ctx context.Context, sql string, args ...any) (Rows, error) {
		tx.go#L357: func (sp *dbSimulatedNestedTx) QueryRow(ctx context.Context, sql string, args ...any) Row {
		tx.go#L363: func (sp *dbSimulatedNestedTx) CopyFrom(ctx context.Context, tableName Identifier, columnNames []string, rowSrc CopyFromSource) (int64, error) {
		tx.go#L372: func (sp *dbSimulatedNestedTx) SendBatch(ctx context.Context, b *Batch) BatchResults {
		tx.go#L392: 	ctx context.Context,
		tx.go#L394: 		Begin(ctx context.Context) (Tx, error)
		tx.go#L411: 	ctx context.Context,
		tx.go#L413: 		BeginTx(ctx context.Context, txOptions TxOptions) (Tx, error)
		tx.go#L427: func beginFuncExec(ctx context.Context, tx Tx, fn func(Tx) error) (err error) {

	github.com/jackc/pgx/v5/pgconn
		auth_oauth.go#L12: func (c *PgConn) oauthAuth(ctx context.Context) error {
		config.go#L27: 	AfterConnectFunc    func(ctx context.Context, pgconn *PgConn) error
		config.go#L28: 	ValidateConnectFunc func(ctx context.Context, pgconn *PgConn) error
		config.go#L29: 	GetSSLPasswordFunc  func(ctx context.Context) string
		config.go#L63: 	AfterNetConnect func(ctx context.Context, config *Config, conn net.Conn) (net.Conn, error)
		config.go#L87: 	OAuthTokenProvider func(context.Context) (string, error)
		config.go#L1006: func ValidateConnectTargetSessionAttrsReadWrite(ctx context.Context, pgConn *PgConn) error {
		config.go#L1021: func ValidateConnectTargetSessionAttrsReadOnly(ctx context.Context, pgConn *PgConn) error {
		config.go#L1036: func ValidateConnectTargetSessionAttrsStandby(ctx context.Context, pgConn *PgConn) error {
		config.go#L1051: func ValidateConnectTargetSessionAttrsPrimary(ctx context.Context, pgConn *PgConn) error {
		config.go#L1066: func ValidateConnectTargetSessionAttrsPreferStandby(ctx context.Context, pgConn *PgConn) error {
		errors.go#L151: func normalizeTimeoutError(ctx context.Context, err error) error {
		errors.go#L226: func newContextAlreadyDoneError(ctx context.Context) (err error) {
		pgconn.go#L49: type DialFunc func(ctx context.Context, network, addr string) (net.Conn, error)
		pgconn.go#L53: type LookupFunc func(ctx context.Context, host string) (addrs []string, err error)
		pgconn.go#L115: func Connect(ctx context.Context, connString string) (*PgConn, error) {
		pgconn.go#L127: func ConnectWithOptions(ctx context.Context, connString string, parseConfigOptions ParseConfigOptions) (*PgConn, error) {
		pgconn.go#L142: func ConnectConfig(ctx context.Context, config *Config) (*PgConn, error) {
		pgconn.go#L180: func buildConnectOneConfigs(ctx context.Context, config *Config) ([]*connectOneConfig, []error) {
		pgconn.go#L247: func connectPreferred(ctx context.Context, config *Config, connectOneConfigs []*connectOneConfig) (*PgConn, []error) {
		pgconn.go#L313: func connectOne(ctx context.Context, config *Config, connectConfig *connectOneConfig,
		pgconn.go#L597: func (pgConn *PgConn) ReceiveMessage(ctx context.Context) (pgproto3.BackendMessage, error) {
		pgconn.go#L738: func (pgConn *PgConn) Close(ctx context.Context) error {
		pgconn.go#L950: func (pgConn *PgConn) Prepare(ctx context.Context, name, sql string, paramOIDs []uint32) (*StatementDescription, error) {
		pgconn.go#L1016: func (pgConn *PgConn) Deallocate(ctx context.Context, name string) error {
		pgconn.go#L1089: func (pgConn *PgConn) CancelRequest(ctx context.Context) error {
		pgconn.go#L1163: func (pgConn *PgConn) WaitForNotification(ctx context.Context) error {
		pgconn.go#L1197: func (pgConn *PgConn) Exec(ctx context.Context, sql string) *MultiResultReader {
		pgconn.go#L1255: func (pgConn *PgConn) ExecParams(ctx context.Context, sql string, paramValues [][]byte, paramOIDs []uint32, paramFormats, resultFormats []int16) *ResultReader {
		pgconn.go#L1281: func (pgConn *PgConn) ExecPrepared(ctx context.Context, stmtName string, paramValues [][]byte, paramFormats, resultFormats []int16) *ResultReader {
		pgconn.go#L1310: func (pgConn *PgConn) ExecStatement(ctx context.Context, statementDescription *StatementDescription, paramValues [][]byte, paramFormats, resultFormats []int16) *ResultReader {
		pgconn.go#L1323: func (pgConn *PgConn) execExtendedPrefix(ctx context.Context, paramValues [][]byte) *ResultReader {
		pgconn.go#L1379: func (pgConn *PgConn) CopyTo(ctx context.Context, w io.Writer, sql string) (CommandTag, error) {
		pgconn.go#L1438: func (pgConn *PgConn) CopyFrom(ctx context.Context, r io.Reader, sql string) (CommandTag, error) {
		pgconn.go#L1571: 	ctx    context.Context
		pgconn.go#L1713: 	ctx               context.Context
		pgconn.go#L1994: func (pgConn *PgConn) ExecBatch(ctx context.Context, batch *Batch) *MultiResultReader {
		pgconn.go#L2096: func (pgConn *PgConn) Ping(ctx context.Context) error {
		pgconn.go#L2147: func (pgConn *PgConn) SyncConn(ctx context.Context) error {
		pgconn.go#L2263: 	ctx  context.Context
		pgconn.go#L2426: func (pgConn *PgConn) StartPipeline(ctx context.Context) *Pipeline {
		pgconn.go#L2955: func (h *DeadlineContextWatcherHandler) HandleCancel(ctx context.Context) {
		pgconn.go#L2978: func (h *CancelRequestContextWatcherHandler) HandleCancel(context.Context) {
		pgconn.go#L2980: 	var handleUnwatchedAfterCancelCalledCtx context.Context

	github.com/jackc/pgx/v5/pgconn/ctxwatch
		context_watcher.go#L32: func (cw *ContextWatcher) Watch(ctx context.Context) {
		context_watcher.go#L68: 	HandleCancel(canceledCtx context.Context)

	github.com/jackc/pgx/v5/pgxpool
		conn.go#L85: func (c *Conn) Exec(ctx context.Context, sql string, arguments ...any) (pgconn.CommandTag, error) {
		conn.go#L89: func (c *Conn) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
		conn.go#L93: func (c *Conn) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {
		conn.go#L97: func (c *Conn) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
		conn.go#L101: func (c *Conn) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
		conn.go#L106: func (c *Conn) Begin(ctx context.Context) (pgx.Tx, error) {
		conn.go#L111: func (c *Conn) BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error) {
		conn.go#L115: func (c *Conn) Ping(ctx context.Context) error {
		pool.go#L85: 	beforeConnect         func(context.Context, *pgx.ConnConfig) error
		pool.go#L86: 	afterConnect          func(context.Context, *pgx.Conn) error
		pool.go#L87: 	prepareConn           func(context.Context, *pgx.Conn) (bool, error)
		pool.go#L90: 	shouldPing            func(context.Context, ShouldPingParams) bool
		pool.go#L125: 	BeforeConnect func(context.Context, *pgx.ConnConfig) error
		pool.go#L128: 	AfterConnect func(context.Context, *pgx.Conn) error
		pool.go#L136: 	BeforeAcquire func(context.Context, *pgx.Conn) bool
		pool.go#L148: 	PrepareConn func(context.Context, *pgx.Conn) (bool, error)
		pool.go#L159: 	ShouldPing func(context.Context, ShouldPingParams) bool
		pool.go#L210: func New(ctx context.Context, connString string) (*Pool, error) {
		pool.go#L220: func NewWithConfig(ctx context.Context, config *Config) (*Pool, error) {
		pool.go#L229: 		prepareConn = func(ctx context.Context, conn *pgx.Conn) (bool, error) {
		pool.go#L264: 		p.shouldPing = func(ctx context.Context, params ShouldPingParams) bool {
		pool.go#L272: 			Constructor: func(ctx context.Context) (*connResource, error) {
		pool.go#L568: func (p *Pool) createIdleResources(parentCtx context.Context, targetResources int) error {
		pool.go#L598: func (p *Pool) Acquire(ctx context.Context) (c *Conn, err error) {
		pool.go#L671: func (p *Pool) AcquireFunc(ctx context.Context, f func(*Conn) error) error {
		pool.go#L683: func (p *Pool) AcquireAllIdle(ctx context.Context) []*Conn {
		pool.go#L727: func (p *Pool) Exec(ctx context.Context, sql string, arguments ...any) (pgconn.CommandTag, error) {
		pool.go#L747: func (p *Pool) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
		pool.go#L774: func (p *Pool) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {
		pool.go#L784: func (p *Pool) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
		pool.go#L798: func (p *Pool) Begin(ctx context.Context) (pgx.Tx, error) {
		pool.go#L806: func (p *Pool) BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error) {
		pool.go#L821: func (p *Pool) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
		pool.go#L833: func (p *Pool) Ping(ctx context.Context) error {
		tracer.go#L13: 	TraceAcquireStart(ctx context.Context, pool *Pool, data TraceAcquireStartData) context.Context
		tracer.go#L15: 	TraceAcquireEnd(ctx context.Context, pool *Pool, data TraceAcquireEndData)
		tx.go#L17: func (tx *Tx) Begin(ctx context.Context) (pgx.Tx, error) {
		tx.go#L25: func (tx *Tx) Commit(ctx context.Context) error {
		tx.go#L37: func (tx *Tx) Rollback(ctx context.Context) error {
		tx.go#L46: func (tx *Tx) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
		tx.go#L50: func (tx *Tx) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
		tx.go#L65: func (tx *Tx) Prepare(ctx context.Context, name, sql string) (*pgconn.StatementDescription, error) {
		tx.go#L69: func (tx *Tx) Exec(ctx context.Context, sql string, arguments ...any) (pgconn.CommandTag, error) {
		tx.go#L73: func (tx *Tx) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
		tx.go#L77: func (tx *Tx) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {

	github.com/jackc/pgx/v5/tracelog
		tracelog.go#L54: 	Log(ctx context.Context, level LogLevel, msg string, data map[string]any)
		tracelog.go#L58: type LoggerFunc func(ctx context.Context, level LogLevel, msg string, data map[string]any)
		tracelog.go#L61: func (f LoggerFunc) Log(ctx context.Context, level LogLevel, msg string, data map[string]any) {
		tracelog.go#L174: func (tl *TraceLog) TraceQueryStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryStartData) context.Context {
		tracelog.go#L182: func (tl *TraceLog) TraceQueryEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryEndData) {
		tracelog.go#L205: func (tl *TraceLog) TraceBatchStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceBatchStartData) context.Context {
		tracelog.go#L211: func (tl *TraceLog) TraceBatchQuery(ctx context.Context, conn *pgx.Conn, data pgx.TraceBatchQueryData) {
		tracelog.go#L224: func (tl *TraceLog) TraceBatchEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceBatchEndData) {
		tracelog.go#L249: func (tl *TraceLog) TraceCopyFromStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceCopyFromStartData) context.Context {
		tracelog.go#L257: func (tl *TraceLog) TraceCopyFromEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceCopyFromEndData) {
		tracelog.go#L281: func (tl *TraceLog) TraceConnectStart(ctx context.Context, data pgx.TraceConnectStartData) context.Context {
		tracelog.go#L288: func (tl *TraceLog) TraceConnectEnd(ctx context.Context, data pgx.TraceConnectEndData) {
		tracelog.go#L326: func (tl *TraceLog) TracePrepareStart(ctx context.Context, _ *pgx.Conn, data pgx.TracePrepareStartData) context.Context {
		tracelog.go#L334: func (tl *TraceLog) TracePrepareEnd(ctx context.Context, conn *pgx.Conn, data pgx.TracePrepareEndData) {
		tracelog.go#L357: func (tl *TraceLog) TraceAcquireStart(ctx context.Context, _ *pgxpool.Pool, _ pgxpool.TraceAcquireStartData) context.Context {
		tracelog.go#L363: func (tl *TraceLog) TraceAcquireEnd(ctx context.Context, _ *pgxpool.Pool, data pgxpool.TraceAcquireEndData) {
		tracelog.go#L395: func (tl *TraceLog) log(ctx context.Context, conn *pgx.Conn, lvl LogLevel, msg string, data map[string]any) {

	github.com/jackc/puddle/v2
		context.go#L10: 	valueCtx  context.Context
		context.go#L11: 	cancelCtx context.Context
		context.go#L19: func newValueCancelCtx(valueCtx, cancelContext context.Context) context.Context {
		pool.go#L30: type Constructor[T any] func(ctx context.Context) (res T, err error)
		pool.go#L147: 	baseAcquireCtx       context.Context
		pool.go#L339: func (p *Pool[T]) Acquire(ctx context.Context) (_ *Resource[T], err error) {
		pool.go#L354: func (p *Pool[T]) acquire(ctx context.Context) (*Resource[T], error) {
		pool.go#L413: func (p *Pool[T]) initResourceValue(ctx context.Context, res *Resource[T]) (*Resource[T], error) {
		pool.go#L474: func (p *Pool[T]) TryAcquire(ctx context.Context) (*Resource[T], error) {
		pool.go#L607: func (p *Pool[T]) CreateResource(ctx context.Context) error {

	go.pact.im/x/flaky
		deadline.go#L9: func withinDeadline(ctx context.Context, d time.Duration) bool {
		debounce.go#L93: func (d *DebounceExecutor) Execute(ctx context.Context, f Op) error {
		flaky.go#L9: type Op func(ctx context.Context) error
		flaky.go#L14: 	Execute(ctx context.Context, f Op) error
		flaky.go#L18: type ExecutorFunc func(ctx context.Context, f Op) error
		flaky.go#L21: func (f ExecutorFunc) Execute(ctx context.Context, op Op) error {
		once.go#L16: func (*onceExecutor) Execute(ctx context.Context, f Op) error {
		permanent.go#L76: func (*untilPermanentExecutor) Execute(ctx context.Context, f Op) error {
		retry.go#L45: func (r *RetryExecutor) Execute(ctx context.Context, f Op) error {
		schedule.go#L140: func (s *ScheduleExecutor) Execute(ctx context.Context, f Op) error {
		watchdog.go#L44: func (w *WatchdogExecutor) Execute(ctx context.Context, f Op) error {

	go.pact.im/x/grpcprocess
		client.go#L21: type ClientFunc func(context.Context) (*grpc.ClientConn, error)
		client.go#L35: func (c *client) Run(ctx context.Context, callback process.Callback) error {
		client.go#L54: 	ctx context.Context,
		client.go#L68: 	ctx context.Context,
		server.go#L16: 		func(_ context.Context) error {
		server.go#L21: 		func(ctx context.Context) error {

	go.pact.im/x/httpprocess
		httpprocess.go#L22: 		func(ctx context.Context) error {
		httpprocess.go#L24: 			srv.BaseContext = func(_ net.Listener) context.Context {
		httpprocess.go#L53: 		func(ctx context.Context) error {

	go.pact.im/x/httprange
		builder.go#L30: func BuildFromRawURL(ctx context.Context, rawURL string, client httpclient.Client) (*BytesResource, error) {
		builder.go#L63: func (b *Builder) Build(ctx context.Context) (*BytesResource, error) {
		bytes.go#L67: 	Context context.Context
		metadata.go#L52: 	Extract(context.Context) (HTTPMetadataProvider, error)
		metadata.go#L67: func (e *HTTPResponseMetadataExtractor) Extract(ctx context.Context) (HTTPMetadataProvider, error) {
		ranger.go#L51: 	Range(ctx context.Context, spec Specifier) iter.Seq2[Range, error]
		ranger.go#L66: func (r *HTTPRanger) Range(ctx context.Context, spec Specifier) iter.Seq2[Range, error] {
		request.go#L12: 	Build(context.Context) (*http.Request, error)
		request.go#L17: type HTTPRequestBuilderFunc func(context.Context) (*http.Request, error)
		request.go#L20: func (f HTTPRequestBuilderFunc) Build(ctx context.Context) (*http.Request, error) {
		request.go#L30: func (r *HTTPRequest) Build(ctx context.Context) (*http.Request, error) {
		resource.go#L32: func (r *BytesResource) Reader(ctx context.Context) *BytesResourceReader {
		validator.go#L21: 	Build(context.Context, HTTPMetadataProvider, httpclient.Client) (httpclient.Client, error)
		validator.go#L37: func (b *HTTPStrongValidatorBuilder) Build(_ context.Context, mp HTTPMetadataProvider, client httpclient.Client) (httpclient.Client, error) {

	go.pact.im/x/logs
		handler.go#L11: type HandlerFunc func(context.Context, slog.Record) error
		handler.go#L15: func (f HandlerFunc) Enabled(_ context.Context, _ slog.Level) bool {
		handler.go#L20: func (f HandlerFunc) Handle(ctx context.Context, r slog.Record) error {
		handler.go#L27: 	return HandlerFunc(func(ctx context.Context, r slog.Record) error {
		handler.go#L38: 	return HandlerFunc(func(ctx context.Context, r slog.Record) error {
		handler.go#L57: 	Enabled func(ctx context.Context, l slog.Level, next slog.Handler) bool
		handler.go#L60: 	Handle func(ctx context.Context, r slog.Record, next slog.Handler) error
		handler.go#L80: func (h *WrapHandler) Enabled(ctx context.Context, l slog.Level) bool {
		handler.go#L89: func (h *WrapHandler) Handle(ctx context.Context, r slog.Record) error {
		handler.go#L129: func (f *ExpiredContextFilter) Enabled(ctx context.Context, l slog.Level, next slog.Handler) bool {
		handler.go#L135: func (f *ExpiredContextFilter) Handle(ctx context.Context, r slog.Record, next slog.Handler) error {
		handler.go#L149: func (f *ExpiredContextFilter) expired(ctx context.Context) bool {
		handler.go#L181: func (f *LevelLimitFilter) Enabled(ctx context.Context, l slog.Level, next slog.Handler) bool {
		handler.go#L187: func (f *LevelLimitFilter) Handle(ctx context.Context, r slog.Record, next slog.Handler) error {
		logger.go#L111: func (l *Logger) Enabled(ctx context.Context, level slog.Level) bool {
		logger.go#L120: func (l *Logger) Log(ctx context.Context, level slog.Level, msg string, attrs ...slog.Attr) {
		logger.go#L128: 	ctx context.Context,
		writer.go#L14: 	ctx    context.Context
		writer.go#L21: func NewLogLogger(ctx context.Context, level slog.Leveler, logger *Logger) *log.Logger {
		writer.go#L29: func (l *Logger) Writer(ctx context.Context, level slog.Leveler) *Writer {

	go.pact.im/x/netchan
		netchan.go#L117: func (l *Listener) Dial(ctx context.Context) (net.Conn, error) {

	go.pact.im/x/pgxprocess
		conn.go#L21: func (p *Conn) Run(ctx context.Context, callback process.Callback) error {
		handle.go#L13: 	Ping(context.Context) error
		handle.go#L14: 	Begin(context.Context) (pgx.Tx, error)
		handle.go#L15: 	BeginTx(context.Context, pgx.TxOptions) (pgx.Tx, error)
		handle.go#L16: 	Exec(context.Context, string, ...any) (pgconn.CommandTag, error)
		handle.go#L17: 	Query(context.Context, string, ...any) (pgx.Rows, error)
		handle.go#L18: 	QueryRow(context.Context, string, ...any) pgx.Row
		handle.go#L19: 	CopyFrom(context.Context, pgx.Identifier, []string, pgx.CopyFromSource) (int64, error)
		handle.go#L20: 	SendBatch(context.Context, *pgx.Batch) pgx.BatchResults
		handle.go#L35: func (h *handle[T, P]) Ping(ctx context.Context) error {
		handle.go#L43: func (h *handle[T, P]) Begin(ctx context.Context) (pgx.Tx, error) {
		handle.go#L51: func (h *handle[T, P]) BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error) {
		handle.go#L59: func (h *handle[T, P]) Exec(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error) {
		handle.go#L67: func (h *handle[T, P]) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
		handle.go#L75: func (h *handle[T, P]) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {
		handle.go#L83: func (h *handle[T, P]) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
		handle.go#L91: func (h *handle[T, P]) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
		pool.go#L21: func (p *Pool) Run(ctx context.Context, callback process.Callback) error {

	go.pact.im/x/pgxslog
		pgxslog.go#L33: 	ctx context.Context,

	go.pact.im/x/process
		chain.go#L23: func (r *chainRunner) Run(ctx context.Context, callback Callback) error {
		chain.go#L34: func (r *chainState) Run(ctx context.Context, callback Callback) error {
		chain.go#L49: func (r *chainState) next(ctx context.Context) error {
		parallel.go#L55: func (r *groupRunner) Run(ctx context.Context, callback Callback) error {
		parallel.go#L65: 	child := func(ctx context.Context, callback Callback) error {
		parallel.go#L84: 		startTasks[i] = func(ctx context.Context) error {
		parallel.go#L97: 		stopTasks[i] = func(ctx context.Context) error {
		process.go#L49: 	parent context.Context
		process.go#L63: func NewProcess(ctx context.Context, runner Runner) *Process {
		process.go#L98: func (p *Process) Start(ctx context.Context) error {
		process.go#L99: 	var bgctx context.Context
		process.go#L110: 		err := p.runner.Run(bgctx, func(bgctx context.Context) error {
		process.go#L156: func (p *Process) Stop(ctx context.Context) error {
		runner.go#L10: type Callback = func(context.Context) error
		runner.go#L31: 	Run(ctx context.Context, callback Callback) error
		runner.go#L35: type RunnerFunc func(context.Context, Callback) error
		runner.go#L38: func (f RunnerFunc) Run(ctx context.Context, callback Callback) error {
		runner.go#L52: func (*nopRunner) Run(ctx context.Context, callback Callback) error {
		runner.go#L73: func (p *prefixedErrorRunner) Run(ctx context.Context, callback Callback) error {
		task.go#L66: func Leaf(runInForeground, gracefulStop func(ctx context.Context) error) Runner {
		task.go#L71: 	runInForeground func(ctx context.Context) error
		task.go#L72: 	gracefulStop    func(ctx context.Context) error
		task.go#L75: func (r *leafRunner) Run(ctx context.Context, callback Callback) error {
		task.go#L113: func StartStop(startInBackground, gracefulStop func(ctx context.Context) error) Runner {
		task.go#L118: 	startInBackground func(ctx context.Context) error
		task.go#L119: 	gracefulStop      func(ctx context.Context) error
		task.go#L122: func (r *startStopRunner) Run(ctx context.Context, callback Callback) error {

	go.pact.im/x/supervisor
		builder.go#L12: type BuilderFunc[T process.Runner] func(context.Context) (T, error)
		builder.go#L16: 	return func(_ context.Context) (T, error) {
		builder.go#L23: func (f BuilderFunc[T]) Run(ctx context.Context, callback process.Callback) error {
		builder.go#L70: func (b *Builder[T]) Run(ctx context.Context, callback process.Callback) error {
		group.go#L17: 	ctx  context.Context
		group.go#L24: func NewGroup(ctx context.Context) *Group {
		group.go#L29: func GroupBuilder(ctx context.Context) (*Group, error) {
		group.go#L35: func (g *Group) Run(ctx context.Context, callback process.Callback) error {
		group.go#L68: func (g *Group) Go(p process.Runner, atExit func(context.Context, error)) {
		group.go#L82: 		atExit = func(_ context.Context, _ error) {}
		group.go#L86: 		atExit(ctx, p.Run(ctx, func(ctx context.Context) error {
		supervisor.go#L39: 	Pre func(context.Context, *Supervisor) error
		supervisor.go#L44: 	Post func(context.Context, *Supervisor) error
		supervisor.go#L89: func (s *Supervisor) Run(ctx context.Context, callback process.Callback) error {
		supervisor.go#L125: func (s *Supervisor) execute(ctx context.Context, intr *supervisorInterrupter) error {
		supervisor.go#L126: 	err := s.exec.Execute(ctx, func(ctx context.Context) error {
		supervisor.go#L131: 		err := s.runner.Run(ctx, func(ctx context.Context) error {
		supervisor.go#L154: func (s *Supervisor) pre(ctx context.Context) error {
		supervisor.go#L162: func (s *Supervisor) post(ctx context.Context) error {

	go.pact.im/x/task
		context.go#L11: 	return func(ctx context.Context) error {
		executor.go#L14: 	Execute(ctx context.Context, cond CancelCondition, tasks ...Task) error
		executor.go#L34: func (e *executor) Execute(ctx context.Context, cond CancelCondition, tasks ...Task) error {
		task.go#L15: type Task func(ctx context.Context) error
		task.go#L18: func (t Task) Run(ctx context.Context) error {
		task.go#L24: 	return func(ctx context.Context) error {
		task.go#L37: 	return func(ctx context.Context) error {
		task.go#L64: 	return func(ctx context.Context) error {

	go.pact.im/x/zapslog
		zapslog.go#L23: 	ctx     context.Context
		zapslog.go#L29: func New(ctx context.Context, handler slog.Handler) *Core {

	go.uber.org/mock/gomock
		controller.go#L143: func WithContext(ctx context.Context, t TestReporter) (*Controller, context.Context) {

	golang.org/x/net/http2
		client_conn_pool.go#L107: 	ctx  context.Context
		client_conn_pool.go#L114: func (p *clientConnPool) getStartDialLocked(ctx context.Context, addr string) *dialCall {
		client_conn_pool.go#L129: func (c *dialCall) dial(ctx context.Context, addr string) {
		clientconn.go#L43: func (cc *ClientConn) Shutdown(ctx context.Context) error {
		clientconn.go#L55: func (cc *ClientConn) Ping(ctx context.Context) error {
		server.go#L224: 		var ctx context.Context
		server.go#L226: 			BaseContext() context.Context
		server.go#L422: 	baseCtx          context.Context
		server.go#L526: 	ctx       context.Context
		server_common.go#L141: 	Context context.Context
		server_common.go#L188: func (o *ServeConnOpts) context() context.Context {
		server_common.go#L214: func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx context.Context, cancel func()) {
		transport.go#L288: 	ctx       context.Context
		transport.go#L422: func (t *Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (*ClientConn, error) {
		transport.go#L816: func (cc *ClientConn) shutdown(ctx context.Context) error {
		transport.go#L2608: func (cc *ClientConn) ping(ctx context.Context) error {
		transport_common.go#L50: 	DialTLSContext func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error)
		transport_common.go#L380: func (t *Transport) dialTLS(ctx context.Context, network, addr string, tlsCfg *tls.Config) (net.Conn, error) {
		transport_common.go#L403: func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) {

	golang.org/x/net/internal/httpcommon
		request.go#L64: func EncodeHeaders(ctx context.Context, param EncodeHeadersParam, headerf func(name, value string)) (res EncodeHeadersResult, _ error) {

	golang.org/x/net/trace
		trace.go#L136: func NewContext(ctx context.Context, tr Trace) context.Context {
		trace.go#L141: func FromContext(ctx context.Context) (tr Trace, ok bool) {

	golang.org/x/sync/errgroup
		errgroup.go#L48: func WithContext(ctx context.Context) (*Group, context.Context) {

	golang.org/x/sync/semaphore
		semaphore.go#L38: func (s *Weighted) Acquire(ctx context.Context, n int64) error {

	golang.org/x/tools/go/packages
		golist.go#L110: 	ctx context.Context
		golist.go#L1089: func getSizesForArgs(ctx context.Context, inv gocommand.Invocation, gocmdRunner *gocommand.Runner) (string, string, error) {
		packages.go#L160: 	Context context.Context

	golang.org/x/tools/internal/event
		event.go#L17: type Exporter func(context.Context, core.Event, label.Map) context.Context
		event.go#L28: func Log(ctx context.Context, message string, labels ...label.Label) {
		event.go#L44: func Error(ctx context.Context, message string, err error, labels ...label.Label) {
		event.go#L60: func Metric(ctx context.Context, labels ...label.Label) {
		event.go#L74: func Label(ctx context.Context, labels ...label.Label) context.Context {
		event.go#L90: func Start(ctx context.Context, name string, labels ...label.Label) (context.Context, func()) {
		event.go#L116: func Detach(ctx context.Context) context.Context {

	golang.org/x/tools/internal/event/core
		export.go#L17: type Exporter func(context.Context, Event, label.Map) context.Context
		export.go#L38: func deliver(ctx context.Context, exporter Exporter, ev Event) context.Context {
		export.go#L46: func Export(ctx context.Context, ev Event) context.Context {
		export.go#L59: func ExportPair(ctx context.Context, begin, end Event) (context.Context, func()) {
		fast.go#L16: func Log1(ctx context.Context, message string, t1 label.Label) {
		fast.go#L25: func Log2(ctx context.Context, message string, t1 label.Label, t2 label.Label) {
		fast.go#L34: func Metric1(ctx context.Context, t1 label.Label) context.Context {
		fast.go#L42: func Metric2(ctx context.Context, t1, t2 label.Label) context.Context {
		fast.go#L53: func Start1(ctx context.Context, name string, t1 label.Label) (context.Context, func()) {
		fast.go#L67: func Start2(ctx context.Context, name string, t1, t2 label.Label) (context.Context, func()) {

	golang.org/x/tools/internal/gocommand
		invoke.go#L70: func (runner *Runner) Run(ctx context.Context, inv Invocation) (*bytes.Buffer, error) {
		invoke.go#L80: func (runner *Runner) RunPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) error {
		invoke.go#L91: func (runner *Runner) RunRaw(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error) {
		invoke.go#L114: func (runner *Runner) runConcurrent(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error) {
		invoke.go#L129: func (runner *Runner) runPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) (error, error) {
		invoke.go#L186: func (i *Invocation) runWithFriendlyError(ctx context.Context, stdout, stderr io.Writer) (friendlyError error, rawError error) {
		invoke.go#L209: func (i *Invocation) run(ctx context.Context, stdout, stderr io.Writer) error {
		invoke.go#L296: func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
		vendor.go#L41: func VendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, *ModuleJSON, error) {
		vendor.go#L83: func getMainModuleAnd114(ctx context.Context, inv Invocation, r *Runner) (*ModuleJSON, bool, error) {
		vendor.go#L115: func WorkspaceVendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, []*ModuleJSON, error) {
		vendor.go#L135: func getWorkspaceMainModules(ctx context.Context, inv Invocation, r *Runner) ([]*ModuleJSON, error) {
		version.go#L24: func GoVersion(ctx context.Context, inv Invocation, r *Runner) (int, error) {
		version.go#L56: func GoVersionOutput(ctx context.Context, inv Invocation, r *Runner) (string, error) {

	google.golang.org/grpc
		balancer_wrapper.go#L41: 	noOpRegisterHealthListenerFn = func(_ context.Context, listener func(balancer.SubConnState)) func() {
		balancer_wrapper.go#L113: 	uccs := func(ctx context.Context) {
		balancer_wrapper.go#L144: 	ccb.serializer.TrySchedule(func(ctx context.Context) {
		balancer_wrapper.go#L160: 	ccb.serializer.TrySchedule(func(context.Context) {
		balancer_wrapper.go#L172: 	ccb.serializer.TrySchedule(func(ctx context.Context) {
		balancer_wrapper.go#L308: 	acbw.ccb.serializer.TrySchedule(func(ctx context.Context) {
		balancer_wrapper.go#L361: func (acbw *acBalancerWrapper) NewStream(ctx context.Context, desc *StreamDesc, method string, opts ...CallOption) (ClientStream, error) {
		balancer_wrapper.go#L372: func (acbw *acBalancerWrapper) Invoke(ctx context.Context, method string, args any, reply any, opts ...CallOption) error {
		balancer_wrapper.go#L434: type healthProducerRegisterFn = func(context.Context, balancer.SubConn, string, func(balancer.SubConnState)) func()
		balancer_wrapper.go#L445: func (acbw *acBalancerWrapper) healthListenerRegFn() func(context.Context, func(balancer.SubConnState)) func() {
		balancer_wrapper.go#L459: 	return func(ctx context.Context, listener func(balancer.SubConnState)) func() {
		balancer_wrapper.go#L489: 	acbw.ccb.serializer.TrySchedule(func(ctx context.Context) {
		balancer_wrapper.go#L502: 			acbw.ccb.serializer.TrySchedule(func(ctx context.Context) {
		call.go#L29: func (cc *ClientConn) Invoke(ctx context.Context, method string, args, reply any, opts ...CallOption) error {
		call.go#L59: func Invoke(ctx context.Context, method string, args, reply any, cc *ClientConn, opts ...CallOption) error {
		call.go#L65: func invoke(ctx context.Context, method string, req, reply any, cc *ClientConn, opts ...CallOption) error {
		clientconn.go#L280: func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *ClientConn, err error) {
		clientconn.go#L533: 		chainedInt = func(ctx context.Context, method string, req, reply any, cc *ClientConn, invoker UnaryInvoker, opts ...CallOption) error {
		clientconn.go#L545: 	return func(ctx context.Context, method string, req, reply any, cc *ClientConn, opts ...CallOption) error {
		clientconn.go#L564: 		chainedInt = func(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, streamer Streamer, opts ...CallOption) (ClientStream, error) {
		clientconn.go#L576: 	return func(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (ClientStream, error) {
		clientconn.go#L583: func newConnectivityStateManager(ctx context.Context, channel *channelz.Channel) *connectivityStateManager {
		clientconn.go#L649: 	Invoke(ctx context.Context, method string, args any, reply any, opts ...CallOption) error
		clientconn.go#L651: 	NewStream(ctx context.Context, desc *StreamDesc, method string, opts ...CallOption) (ClientStream, error)
		clientconn.go#L670: 	ctx    context.Context    // Initialized using the background context at dial time.
		clientconn.go#L712: func (cc *ClientConn) WaitForStateChange(ctx context.Context, sourceState connectivity.State) bool {
		clientconn.go#L759: func (cc *ClientConn) waitForResolvedAddrs(ctx context.Context) (bool, error) {
		clientconn.go#L1243: 	ctx    context.Context
		clientconn.go#L1452: func (ac *addrConn) tryAllAddrs(ctx context.Context, addrs []resolver.Address, connectDeadline time.Time) error {
		clientconn.go#L1490: func (ac *addrConn) createTransport(ctx context.Context, addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time) error {
		clientconn.go#L1610: func (ac *addrConn) startHealthCheck(ctx context.Context) {
		dialoptions.go#L498: func WithContextDialer(f func(context.Context, string) (net.Conn, error)) DialOption {
		dialoptions.go#L513: 		func(ctx context.Context, addr string) (net.Conn, error) {
		interceptor.go#L26: type UnaryInvoker func(ctx context.Context, method string, req, reply any, cc *ClientConn, opts ...CallOption) error
		interceptor.go#L43: type UnaryClientInterceptor func(ctx context.Context, method string, req, reply any, cc *ClientConn, invoker UnaryInvoker, opts ...CallOption) error
		interceptor.go#L46: type Streamer func(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (ClientStream, error)
		interceptor.go#L63: type StreamClientInterceptor func(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, streamer Streamer, opts ...CallOption) (ClientStream, error)
		interceptor.go#L81: type UnaryHandler func(ctx context.Context, req any) (any, error)
		interceptor.go#L87: type UnaryServerInterceptor func(ctx context.Context, req any, info *UnaryServerInfo, handler UnaryHandler) (resp any, err error)
		picker_wrapper.go#L105: func (pw *pickerWrapper) pick(ctx context.Context, failfast bool, info balancer.PickInfo) (pick, error) {
		resolver_wrapper.go#L70: 	ccr.serializer.TrySchedule(func(ctx context.Context) {
		resolver_wrapper.go#L100: 	ccr.serializer.TrySchedule(func(ctx context.Context) {
		resolver_wrapper.go#L117: 	ccr.serializer.TrySchedule(func(context.Context) {
		rpc_util.go#L1089: func newContextWithRPCInfo(ctx context.Context, failfast bool, codec baseCodec, cp Compressor, comp encoding.Compressor) context.Context {
		rpc_util.go#L1100: func rpcInfoFromContext(ctx context.Context) (s *rpcInfo, ok bool) {
		server.go#L98: type MethodHandler func(srv any, ctx context.Context, dec func(any) error, interceptor UnaryServerInterceptor) (any, error)
		server.go#L1053: func (s *Server) serveStreams(ctx context.Context, st transport.ServerTransport, rawConn net.Conn) {
		server.go#L1188: func (s *Server) sendResponse(ctx context.Context, stream *transport.ServerStream, msg any, cp Compressor, opts *transport.WriteOptions, comp encoding.Compressor) error {
		server.go#L1246: 	return func(ctx context.Context, req any, info *UnaryServerInfo, handler UnaryHandler) (any, error) {
		server.go#L1255: 	return func(ctx context.Context, req any) (any, error) {
		server.go#L1260: func (s *Server) processUnaryRPC(ctx context.Context, stream *transport.ServerStream, info *serviceInfo, md *MethodDesc, trInfo *traceInfo) (err error) {
		server.go#L1590: func (s *Server) processStreamingRPC(ctx context.Context, stream *transport.ServerStream, info *serviceInfo, sd *StreamDesc, trInfo *traceInfo) (err error) {
		server.go#L1903: func NewContextWithServerTransportStream(ctx context.Context, stream ServerTransportStream) context.Context {
		server.go#L1933: func ServerTransportStreamFromContext(ctx context.Context) ServerTransportStream {
		server.go#L2047: func serverFromContext(ctx context.Context) *Server {
		server.go#L2053: func contextWithServer(ctx context.Context, server *Server) context.Context {
		server.go#L2102: func SetHeader(ctx context.Context, md metadata.MD) error {
		server.go#L2121: func SendHeader(ctx context.Context, md metadata.MD) error {
		server.go#L2155: func SetSendCompressor(ctx context.Context, name string) error {
		server.go#L2177: func ClientSupportedCompressors(ctx context.Context) ([]string, error) {
		server.go#L2192: func SetTrailer(ctx context.Context, md metadata.MD) error {
		server.go#L2205: func Method(ctx context.Context) (string, bool) {
		stream.go#L53: var metadataFromOutgoingContextRaw = internal.FromOutgoingContextRaw.(func(context.Context) (metadata.MD, [][]string, bool))
		stream.go#L86: 	Context() context.Context
		stream.go#L115: 	Context() context.Context
		stream.go#L167: func (cc *ClientConn) NewStream(ctx context.Context, desc *StreamDesc, method string, opts ...CallOption) (ClientStream, error) {
		stream.go#L179: func NewClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (ClientStream, error) {
		stream.go#L204: func newClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (_ ClientStream, err error) {
		stream.go#L247: 	newStream := func(ctx context.Context, done func()) (iresolver.ClientStream, error) {
		stream.go#L273: 			newStream = func(ctx context.Context, done func()) (iresolver.ClientStream, error) {
		stream.go#L286: func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, mc *serviceconfig.MethodConfig, onCommit, doneFunc func(), nameResolutionDelayed bool, opts ...CallOption) (_ iresolver.ClientStream, err error) {
		stream.go#L593: 	ctx context.Context // the application's context, wrapped by stats/tracing
		stream.go#L637: 	ctx             context.Context
		stream.go#L806: func (cs *clientStream) Context() context.Context {
		stream.go#L1283: func newNonRetryClientStream(ctx context.Context, desc *StreamDesc, method string, t transport.ClientTransport, ac *addrConn, opts ...CallOption) (_ ClientStream, err error) {
		stream.go#L1398: 	ctx              context.Context
		stream.go#L1442: func (as *addrConnStream) Context() context.Context {
		stream.go#L1601: 	Context() context.Context
		stream.go#L1633: 	ctx   context.Context
		stream.go#L1666: func (ss *serverStream) Context() context.Context {
		trace_withtrace.go#L33: func newTraceContext(ctx context.Context, tr traceLog) context.Context {

	google.golang.org/grpc/balancer
		balancer.go#L203: 	Dialer func(context.Context, string) (net.Conn, error)
		balancer.go#L245: 	Ctx context.Context

	google.golang.org/grpc/credentials
		credentials.go#L48: 	GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error)
		credentials.go#L172: 	ClientHandshake(context.Context, string, net.Conn) (net.Conn, AuthInfo, error)
		credentials.go#L245: func RequestInfoFromContext(ctx context.Context) (ri RequestInfo, ok bool) {
		credentials.go#L260: func NewContextWithRequestInfo(ctx context.Context, ri RequestInfo) context.Context {
		credentials.go#L280: func ClientHandshakeInfoFromContext(ctx context.Context) ClientHandshakeInfo {
		tls.go#L112: func (c *tlsCreds) ClientHandshake(ctx context.Context, authority string, rawConn net.Conn) (_ net.Conn, _ AuthInfo, err error) {

	google.golang.org/grpc/credentials/insecure
		insecure.go#L43: func (insecureTC) ClientHandshake(_ context.Context, _ string, conn net.Conn) (net.Conn, credentials.AuthInfo, error) {

	google.golang.org/grpc/experimental/stats
		metrics.go#L33: func NewContextWithCustomLabel(ctx context.Context, label string) context.Context {
		metrics.go#L39: func CustomLabelFromContext(ctx context.Context) string {

	google.golang.org/grpc/internal
		internal.go#L259: type HealthChecker func(ctx context.Context, newStream func(string) (any, error), setConnectivityState func(connectivity.State, error), serviceName string) error

	google.golang.org/grpc/internal/backoff
		backoff.go#L86: func RunF(ctx context.Context, f func() error, backoff func(int) time.Duration) {

	google.golang.org/grpc/internal/binarylog
		method_logger.go#L57: 	Log(context.Context, LogEntryConfig)
		method_logger.go#L109: func (ml *TruncatingMethodLogger) Log(_ context.Context, c LogEntryConfig) {

	google.golang.org/grpc/internal/credentials
		credentials.go#L28: func ClientHandshakeInfoFromContext(ctx context.Context) any {
		credentials.go#L33: func NewClientHandshakeInfoContext(ctx context.Context, chi any) context.Context {

	google.golang.org/grpc/internal/grpcsync
		callback_serializer.go#L47: func NewCallbackSerializer(ctx context.Context) *CallbackSerializer {
		callback_serializer.go#L63: func (cs *CallbackSerializer) TrySchedule(f func(ctx context.Context)) {
		callback_serializer.go#L74: func (cs *CallbackSerializer) ScheduleOr(f func(ctx context.Context), onFailure func()) {
		callback_serializer.go#L80: func (cs *CallbackSerializer) run(ctx context.Context) {
		callback_serializer.go#L90: 		cb.(func(context.Context))(ctx)
		pubsub.go#L57: func NewPubSub(ctx context.Context) *PubSub {
		pubsub.go#L80: 		ps.cs.TrySchedule(func(context.Context) {
		pubsub.go#L106: 		ps.cs.TrySchedule(func(context.Context) {

	google.golang.org/grpc/internal/grpcutil
		metadata.go#L30: func WithExtraMetadata(ctx context.Context, md metadata.MD) context.Context {
		metadata.go#L37: func ExtraMetadata(ctx context.Context) (md metadata.MD, ok bool) {

	google.golang.org/grpc/internal/resolver
		config_selector.go#L44: 	Context context.Context
		config_selector.go#L52: 	Context      context.Context
		config_selector.go#L76: 	Context() context.Context
		config_selector.go#L127: 	NewStream(ctx context.Context, ri RPCInfo, done func(), newStream func(ctx context.Context, done func()) (ClientStream, error)) (ClientStream, error)
		config_selector.go#L138: 	AllowRPC(ctx context.Context) error // TODO: Make this a real interceptor for filters such as rate limiting.

	google.golang.org/grpc/internal/resolver/dns
		dns_resolver.go#L85: var addressDialer = func(address string) func(context.Context, string, string) (net.Conn, error) {
		dns_resolver.go#L86: 	return func(ctx context.Context, network, _ string) (net.Conn, error) {
		dns_resolver.go#L174: 	ctx      context.Context
		dns_resolver.go#L243: func (d *dnsResolver) lookupSRV(ctx context.Context) ([]resolver.Address, error) {
		dns_resolver.go#L293: func (d *dnsResolver) lookupTXT(ctx context.Context) *serviceconfig.ParseResult {
		dns_resolver.go#L321: func (d *dnsResolver) lookupHost(ctx context.Context) ([]resolver.Address, error) {

	google.golang.org/grpc/internal/resolver/dns/internal
		internal.go#L33: 	LookupHost(ctx context.Context, host string) (addrs []string, err error)
		internal.go#L34: 	LookupSRV(ctx context.Context, service, proto, name string) (cname string, addrs []*net.SRV, err error)
		internal.go#L35: 	LookupTXT(ctx context.Context, name string) (txts []string, err error)
		internal.go#L76: 	AddressDialer func(address string) func(context.Context, string, string) (net.Conn, error)

	google.golang.org/grpc/internal/stats
		labels.go#L37: func UpdateLabels(ctx context.Context, update map[string]string) {
		labels.go#L43: func RegisterTelemetryLabelCallback(ctx context.Context, callback LabelCallback) context.Context {
		labels.go#L62: func executeTelemetryLabelCallbacks(ctx context.Context, labels map[string]string) {
		stats.go#L46: func (ch *combinedHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context {
		stats.go#L53: func (ch *combinedHandler) HandleRPC(ctx context.Context, stats stats.RPCStats) {
		stats.go#L59: func (ch *combinedHandler) TagConn(ctx context.Context, info *stats.ConnTagInfo) context.Context {
		stats.go#L66: func (ch *combinedHandler) HandleConn(ctx context.Context, stats stats.ConnStats) {

	google.golang.org/grpc/internal/transport
		handler_server.go#L392: func (ht *serverHandlerTransport) HandleStreams(ctx context.Context, startStream func(*ServerStream)) {
		http2_client.go#L68: var metadataFromOutgoingContextRaw = internal.FromOutgoingContextRaw.(func(context.Context) (metadata.MD, [][]string, bool))
		http2_client.go#L73: 	ctx       context.Context
		http2_client.go#L161: func dial(ctx context.Context, fn func(context.Context, string) (net.Conn, error), addr resolver.Address, grpcUA string) (net.Conn, error) {
		http2_client.go#L210: func NewHTTP2Client(connectCtx, ctx context.Context, addr resolver.Address, opts ConnectOptions, onClose OnCloseFunc) (_ ClientTransport, err error) {
		http2_client.go#L490: func (t *http2Client) newStream(ctx context.Context, callHdr *CallHdr, handler stats.Handler) *ClientStream {
		http2_client.go#L543: func (t *http2Client) createHeaderFields(ctx context.Context, callHdr *CallHdr) ([]hpack.HeaderField, error) {
		http2_client.go#L674: func (t *http2Client) getTrAuthData(ctx context.Context, audience string) (map[string]string, error) {
		http2_client.go#L701: func (t *http2Client) getCallAuthData(ctx context.Context, audience string, callHdr *CallHdr) (map[string]string, error) {
		http2_client.go#L757: func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr, handler stats.Handler) (*ClientStream, error) {
		http2_server.go#L377: func (t *http2Server) operateHeaders(ctx context.Context, frame *http2.MetaHeadersFrame, handle func(*ServerStream)) error {
		http2_server.go#L639: func (t *http2Server) HandleStreams(ctx context.Context, handle func(*ServerStream)) {
		http2_server.go#L1500: func GetConnection(ctx context.Context) net.Conn {
		http2_server.go#L1508: func SetConnection(ctx context.Context, conn net.Conn) context.Context {
		proxy.go#L57: func doHTTPConnectHandshake(ctx context.Context, conn net.Conn, grpcUA string, opts proxyattributes.Options) (_ net.Conn, err error) {
		proxy.go#L102: func proxyDial(ctx context.Context, addr resolver.Address, grpcUA string, opts proxyattributes.Options) (net.Conn, error) {
		proxy.go#L110: func sendHTTPRequest(ctx context.Context, req *http.Request, conn net.Conn) error {
		server_stream.go#L123: func (s *ServerStream) SetContext(ctx context.Context) {
		transport.go#L134: 	ctx          context.Context
		transport.go#L295: 	ctx          context.Context // the associated context of the stream
		transport.go#L344: func (s *Stream) Context() context.Context {
		transport.go#L523: 	Dialer func(context.Context, string) (net.Conn, error)
		transport.go#L626: 	NewStream(ctx context.Context, callHdr *CallHdr, handler stats.Handler) (*ClientStream, error)
		transport.go#L656: 	HandleStreams(context.Context, func(*ServerStream))

	google.golang.org/grpc/metadata
		metadata.go#L164: func NewIncomingContext(ctx context.Context, md MD) context.Context {
		metadata.go#L172: func NewOutgoingContext(ctx context.Context, md MD) context.Context {
		metadata.go#L179: func AppendToOutgoingContext(ctx context.Context, kv ...string) context.Context {
		metadata.go#L197: func FromIncomingContext(ctx context.Context) (MD, bool) {
		metadata.go#L216: func ValueFromIncomingContext(ctx context.Context, key string) []string {
		metadata.go#L248: func fromOutgoingContextRaw(ctx context.Context) (MD, [][]string, bool) {
		metadata.go#L260: func FromOutgoingContext(ctx context.Context) (MD, bool) {

	google.golang.org/grpc/peer
		peer.go#L75: func NewContext(ctx context.Context, p *Peer) context.Context {
		peer.go#L80: func FromContext(ctx context.Context) (p *Peer, ok bool) {

	google.golang.org/grpc/resolver
		resolver.go#L175: 	Dialer func(context.Context, string) (net.Conn, error)

	google.golang.org/grpc/stats
		handlers.go#L57: 	TagRPC(context.Context, *RPCTagInfo) context.Context
		handlers.go#L59: 	HandleRPC(context.Context, RPCStats)
		handlers.go#L69: 	TagConn(context.Context, *ConnTagInfo) context.Context
		handlers.go#L71: 	HandleConn(context.Context, ConnStats)
		stats.go#L285: func SetTags(ctx context.Context, b []byte) context.Context {
		stats.go#L292: func Tags(ctx context.Context) []byte {
		stats.go#L305: func SetTrace(ctx context.Context, b []byte) context.Context {
		stats.go#L312: func Trace(ctx context.Context) []byte {

	google.golang.org/grpc/tap
		tap.go#L62: type ServerInHandle func(ctx context.Context, info *Info) (context.Context, error)

	log/slog
		handler.go#L43: 	Enabled(context.Context, Level) bool
		handler.go#L65: 	Handle(context.Context, Record) error
		handler.go#L107: func (*defaultHandler) Enabled(_ context.Context, l Level) bool {
		handler.go#L114: func (h *defaultHandler) Handle(ctx context.Context, r Record) error {
		handler.go#L641: func (dh discardHandler) Enabled(context.Context, Level) bool  { return false }
		handler.go#L642: func (dh discardHandler) Handle(context.Context, Record) error { return nil }
		json_handler.go#L46: func (h *JSONHandler) Enabled(_ context.Context, level Level) bool {
		json_handler.go#L88: func (h *JSONHandler) Handle(_ context.Context, r Record) error {
		logger.go#L164: func (l *Logger) Enabled(ctx context.Context, level Level) bool {
		logger.go#L188: func (l *Logger) Log(ctx context.Context, level Level, msg string, args ...any) {
		logger.go#L193: func (l *Logger) LogAttrs(ctx context.Context, level Level, msg string, attrs ...Attr) {
		logger.go#L203: func (l *Logger) DebugContext(ctx context.Context, msg string, args ...any) {
		logger.go#L213: func (l *Logger) InfoContext(ctx context.Context, msg string, args ...any) {
		logger.go#L223: func (l *Logger) WarnContext(ctx context.Context, msg string, args ...any) {
		logger.go#L233: func (l *Logger) ErrorContext(ctx context.Context, msg string, args ...any) {
		logger.go#L240: func (l *Logger) log(ctx context.Context, level Level, msg string, args ...any) {
		logger.go#L260: func (l *Logger) logAttrs(ctx context.Context, level Level, msg string, attrs ...Attr) {
		logger.go#L285: func DebugContext(ctx context.Context, msg string, args ...any) {
		logger.go#L295: func InfoContext(ctx context.Context, msg string, args ...any) {
		logger.go#L305: func WarnContext(ctx context.Context, msg string, args ...any) {
		logger.go#L315: func ErrorContext(ctx context.Context, msg string, args ...any) {
		logger.go#L320: func Log(ctx context.Context, level Level, msg string, args ...any) {
		logger.go#L325: func LogAttrs(ctx context.Context, level Level, msg string, attrs ...Attr) {
		multi_handler.go#L26: func (h *MultiHandler) Enabled(ctx context.Context, l Level) bool {
		multi_handler.go#L35: func (h *MultiHandler) Handle(ctx context.Context, r Record) error {
		text_handler.go#L44: func (h *TextHandler) Enabled(_ context.Context, level Level) bool {
		text_handler.go#L92: func (h *TextHandler) Handle(_ context.Context, r Record) error {

	net
		cgo_unix.go#L47: func doBlockingWithCtx[T any](ctx context.Context, lookupName string, blocking func() (T, error)) (T, error) {
		cgo_unix.go#L80: func cgoLookupHost(ctx context.Context, name string) (hosts []string, err error) {
		cgo_unix.go#L91: func cgoLookupPort(ctx context.Context, network, service string) (port int, err error) {
		cgo_unix.go#L227: func cgoLookupIP(ctx context.Context, network, name string) (addrs []IPAddr, err error) {
		cgo_unix.go#L246: func cgoLookupPTR(ctx context.Context, addr string) (names []string, err error) {
		cgo_unix.go#L300: func cgoLookupCNAME(ctx context.Context, name string) (cname string, err error) {
		cgo_unix.go#L314: func resSearch(ctx context.Context, hostname string, rtype, class int) ([]dnsmessage.Resource, error) {
		dial.go#L225: 	ControlContext func(ctx context.Context, network, address string, c syscall.RawConn) error
		dial.go#L251: func (d *Dialer) deadline(ctx context.Context, now time.Time) (earliest time.Time) {
		dial.go#L300: func parseNetwork(ctx context.Context, network string, needsProto bool) (afnet string, proto int, err error) {
		dial.go#L335: func (r *Resolver) resolveAddrList(ctx context.Context, op, network, addr string, hint Addr) (addrList, error) {
		dial.go#L494: 	testHookDialTCP  func(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error)
		dial.go#L526: func (d *Dialer) DialContext(ctx context.Context, network, address string) (Conn, error) {
		dial.go#L560: func (d *Dialer) dialCtx(ctx context.Context) (context.Context, context.CancelFunc) {
		dial.go#L569: 			var subCtx context.Context
		dial.go#L603: func (d *Dialer) DialTCP(ctx context.Context, network string, laddr netip.AddrPort, raddr netip.AddrPort) (*TCPConn, error) {
		dial.go#L617: func (d *Dialer) DialUDP(ctx context.Context, network string, laddr netip.AddrPort, raddr netip.AddrPort) (*UDPConn, error) {
		dial.go#L631: func (d *Dialer) DialIP(ctx context.Context, network string, laddr netip.Addr, raddr netip.Addr) (*IPConn, error) {
		dial.go#L645: func (d *Dialer) DialUnix(ctx context.Context, network string, laddr *UnixAddr, raddr *UnixAddr) (*UnixConn, error) {
		dial.go#L655: func (sd *sysDialer) dialParallel(ctx context.Context, primaries, fallbacks addrList) (Conn, error) {
		dial.go#L671: 	startRacer := func(ctx context.Context, primary bool) {
		dial.go#L729: func (sd *sysDialer) dialSerial(ctx context.Context, ras addrList) (Conn, error) {
		dial.go#L773: func (sd *sysDialer) dialSingle(ctx context.Context, ra Addr) (c Conn, err error) {
		dial.go#L874: func (lc *ListenConfig) Listen(ctx context.Context, network, address string) (Listener, error) {
		dial.go#L911: func (lc *ListenConfig) ListenPacket(ctx context.Context, network, address string) (PacketConn, error) {
		dnsclient_unix.go#L169: func (r *Resolver) exchange(ctx context.Context, server string, q dnsmessage.Question, timeout time.Duration, useTCP, ad bool) (dnsmessage.Parser, dnsmessage.Header, error) {
		dnsclient_unix.go#L297: func (r *Resolver) tryOneName(ctx context.Context, cfg *dnsConfig, name string, qtype dnsmessage.Type) (dnsmessage.Parser, string, error) {
		dnsclient_unix.go#L441: func (r *Resolver) lookup(ctx context.Context, name string, qtype dnsmessage.Type, conf *dnsConfig) (dnsmessage.Parser, string, error) {
		dnsclient_unix.go#L565: func (r *Resolver) goLookupHostOrder(ctx context.Context, name string, order hostLookupOrder, conf *dnsConfig) (addrs []string, err error) {
		dnsclient_unix.go#L604: func (r *Resolver) goLookupIP(ctx context.Context, network, host string, order hostLookupOrder, conf *dnsConfig) (addrs []IPAddr, err error) {
		dnsclient_unix.go#L609: func (r *Resolver) goLookupIPCNAMEOrder(ctx context.Context, network, name string, order hostLookupOrder, conf *dnsConfig) (addrs []IPAddr, cname dnsmessage.Name, err error) {
		dnsclient_unix.go#L821: func (r *Resolver) goLookupCNAME(ctx context.Context, host string, order hostLookupOrder, conf *dnsConfig) (string, error) {
		dnsclient_unix.go#L827: func (r *Resolver) goLookupPTR(ctx context.Context, addr string, order hostLookupOrder, conf *dnsConfig) ([]string, error) {
		fd_unix.go#L44: func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa syscall.Sockaddr, ret error) {
		hook.go#L13: 	testHookDialTCP func(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error)
		hook.go#L16: 		ctx context.Context,
		hook.go#L17: 		fn func(context.Context, string, string) ([]IPAddr, error),
		iprawsock.go#L226: func dialIP(ctx context.Context, dialer *Dialer, network string, laddr, raddr *IPAddr) (*IPConn, error) {
		iprawsock_posix.go#L115: func (sd *sysDialer) dialIP(ctx context.Context, laddr, raddr *IPAddr) (*IPConn, error) {
		iprawsock_posix.go#L127: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		iprawsock_posix.go#L138: func (sl *sysListener) listenIP(ctx context.Context, laddr *IPAddr) (*IPConn, error) {
		iprawsock_posix.go#L148: 	var ctrlCtxFn func(ctx context.Context, network, address string, c syscall.RawConn) error
		iprawsock_posix.go#L150: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		ipsock.go#L249: func (r *Resolver) internetAddrList(ctx context.Context, net, addr string) (addrList, error) {
		ipsock_posix.go#L159: func internetSocket(ctx context.Context, net string, laddr, raddr sockaddr, sotype, proto int, mode string, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) (fd *netFD, err error) {
		lookup.go#L161: 	Dial func(ctx context.Context, network, address string) (Conn, error)
		lookup.go#L193: func (r *Resolver) LookupHost(ctx context.Context, host string) (addrs []string, err error) {
		lookup.go#L220: func (r *Resolver) LookupIPAddr(ctx context.Context, host string) ([]IPAddr, error) {
		lookup.go#L228: func (r *Resolver) LookupIP(ctx context.Context, network, host string) ([]IP, error) {
		lookup.go#L258: func (r *Resolver) LookupNetIP(ctx context.Context, network, host string) ([]netip.Addr, error) {
		lookup.go#L279: 	context.Context
		lookup.go#L280: 	lookupValues context.Context
		lookup.go#L283: var _ context.Context = (*onlyValuesCtx)(nil)
		lookup.go#L299: func withUnexpiredValuesPreserved(lookupCtx context.Context) context.Context {
		lookup.go#L305: func (r *Resolver) lookupIPAddr(ctx context.Context, network, host string) ([]IPAddr, error) {
		lookup.go#L321: 	if alt, _ := ctx.Value(nettrace.LookupIPAltResolverKey{}).(func(context.Context, string, string) ([]IPAddr, error)); alt != nil {
		lookup.go#L415: func (r *Resolver) LookupPort(ctx context.Context, network, service string) (port int, err error) {
		lookup.go#L469: func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error) {
		lookup.go#L512: func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
		lookup.go#L555: func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) {
		lookup.go#L600: func (r *Resolver) LookupNS(ctx context.Context, name string) ([]*NS, error) {
		lookup.go#L636: func (r *Resolver) LookupTXT(ctx context.Context, name string) ([]string, error) {
		lookup.go#L662: func (r *Resolver) LookupAddr(ctx context.Context, addr string) ([]string, error) {
		lookup.go#L687: func (r *Resolver) dial(ctx context.Context, network, server string) (Conn, error) {
		lookup.go#L716: func (r *Resolver) goLookupSRV(ctx context.Context, service, proto, name string) (target string, srvs []*SRV, err error) {
		lookup.go#L767: func (r *Resolver) goLookupMX(ctx context.Context, name string) ([]*MX, error) {
		lookup.go#L811: func (r *Resolver) goLookupNS(ctx context.Context, name string) ([]*NS, error) {
		lookup.go#L853: func (r *Resolver) goLookupTXT(ctx context.Context, name string) ([]string, error) {
		lookup_unix.go#L48: func lookupProtocol(_ context.Context, name string) (int, error) {
		lookup_unix.go#L53: func (r *Resolver) lookupHost(ctx context.Context, host string) (addrs []string, err error) {
		lookup_unix.go#L61: func (r *Resolver) lookupIP(ctx context.Context, network, host string) (addrs []IPAddr, err error) {
		lookup_unix.go#L70: func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int, error) {
		lookup_unix.go#L87: func (r *Resolver) lookupCNAME(ctx context.Context, name string) (string, error) {
		lookup_unix.go#L97: func (r *Resolver) lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
		lookup_unix.go#L101: func (r *Resolver) lookupMX(ctx context.Context, name string) ([]*MX, error) {
		lookup_unix.go#L105: func (r *Resolver) lookupNS(ctx context.Context, name string) ([]*NS, error) {
		lookup_unix.go#L109: func (r *Resolver) lookupTXT(ctx context.Context, name string) ([]string, error) {
		lookup_unix.go#L113: func (r *Resolver) lookupAddr(ctx context.Context, addr string) ([]string, error) {
		mptcpsock_linux.go#L60: func (sd *sysDialer) dialMPTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error) {
		mptcpsock_linux.go#L76: func (sl *sysListener) listenMPTCP(ctx context.Context, laddr *TCPAddr) (*TCPListener, error) {
		net.go#L809: func acquireThread(ctx context.Context) error {
		sock_posix.go#L18: func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) (fd *netFD, err error) {
		sock_posix.go#L92: func (fd *netFD) dial(ctx context.Context, laddr, raddr sockaddr, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) error {
		sock_posix.go#L150: func (fd *netFD) listenStream(ctx context.Context, laddr sockaddr, backlog int, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) error {
		sock_posix.go#L181: func (fd *netFD) listenDatagram(ctx context.Context, laddr sockaddr, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) error {
		tcpsock.go#L321: func dialTCP(ctx context.Context, dialer *Dialer, network string, laddr, raddr *TCPAddr) (*TCPConn, error) {
		tcpsock_posix.go#L64: func (sd *sysDialer) dialTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error) {
		tcpsock_posix.go#L74: func (sd *sysDialer) doDialTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error) {
		tcpsock_posix.go#L78: func (sd *sysDialer) doDialTCPProto(ctx context.Context, laddr, raddr *TCPAddr, proto int) (*TCPConn, error) {
		tcpsock_posix.go#L81: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		tcpsock_posix.go#L178: func (sl *sysListener) listenTCP(ctx context.Context, laddr *TCPAddr) (*TCPListener, error) {
		tcpsock_posix.go#L182: func (sl *sysListener) listenTCPProto(ctx context.Context, laddr *TCPAddr, proto int) (*TCPListener, error) {
		tcpsock_posix.go#L183: 	var ctrlCtxFn func(ctx context.Context, network, address string, c syscall.RawConn) error
		tcpsock_posix.go#L185: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		udpsock.go#L291: func dialUDP(ctx context.Context, dialer *Dialer, network string, laddr, raddr *UDPAddr) (*UDPConn, error) {
		udpsock_posix.go#L213: func (sd *sysDialer) dialUDP(ctx context.Context, laddr, raddr *UDPAddr) (*UDPConn, error) {
		udpsock_posix.go#L216: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		udpsock_posix.go#L227: func (sl *sysListener) listenUDP(ctx context.Context, laddr *UDPAddr) (*UDPConn, error) {
		udpsock_posix.go#L228: 	var ctrlCtxFn func(ctx context.Context, network, address string, c syscall.RawConn) error
		udpsock_posix.go#L230: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		udpsock_posix.go#L241: func (sl *sysListener) listenMulticastUDP(ctx context.Context, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error) {
		udpsock_posix.go#L242: 	var ctrlCtxFn func(ctx context.Context, network, address string, c syscall.RawConn) error
		udpsock_posix.go#L244: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		unixsock.go#L207: func dialUnix(ctx context.Context, dialer *Dialer, network string, laddr, raddr *UnixAddr) (*UnixConn, error) {
		unixsock_posix.go#L16: func unixSocket(ctx context.Context, net string, laddr, raddr sockaddr, mode string, ctxCtrlFn func(context.Context, string, string, syscall.RawConn) error) (*netFD, error) {
		unixsock_posix.go#L157: func (sd *sysDialer) dialUnix(ctx context.Context, laddr, raddr *UnixAddr) (*UnixConn, error) {
		unixsock_posix.go#L160: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		unixsock_posix.go#L219: func (sl *sysListener) listenUnix(ctx context.Context, laddr *UnixAddr) (*UnixListener, error) {
		unixsock_posix.go#L220: 	var ctrlCtxFn func(ctx context.Context, network, address string, c syscall.RawConn) error
		unixsock_posix.go#L222: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
		unixsock_posix.go#L233: func (sl *sysListener) listenUnixgram(ctx context.Context, laddr *UnixAddr) (*UnixConn, error) {
		unixsock_posix.go#L234: 	var ctrlCtxFn func(ctx context.Context, network, address string, c syscall.RawConn) error
		unixsock_posix.go#L236: 		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {

	net/http
		client.go#L312: func timeBeforeContextDeadline(t time.Time, ctx context.Context) bool {
		clientconn.go#L113: func (t *Transport) NewClientConn(ctx context.Context, scheme, address string) (*ClientConn, error) {
		h2_bundle.go#L838: 	ctx  context.Context
		h2_bundle.go#L845: func (p *http2clientConnPool) getStartDialLocked(ctx context.Context, addr string) *http2dialCall {
		h2_bundle.go#L860: func (c *http2dialCall) dial(ctx context.Context, addr string) {
		h2_bundle.go#L4296: 		var ctx context.Context
		h2_bundle.go#L4298: 			BaseContext() context.Context
		h2_bundle.go#L4336: 	Context context.Context
		h2_bundle.go#L4362: func (o *http2ServeConnOpts) context() context.Context {
		h2_bundle.go#L4550: func http2serverConnBaseContext(c net.Conn, opts *http2ServeConnOpts) (ctx context.Context, cancel func()) {
		h2_bundle.go#L4574: 	baseCtx          context.Context
		h2_bundle.go#L4661: 	ctx       context.Context
		h2_bundle.go#L7365: 	DialTLSContext func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error)
		h2_bundle.go#L7704: 	ctx       context.Context
		h2_bundle.go#L8015: func (t *http2Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (*http2ClientConn, error) {
		h2_bundle.go#L8044: func (t *http2Transport) dialTLS(ctx context.Context, network, addr string, tlsCfg *tls.Config) (net.Conn, error) {
		h2_bundle.go#L8471: func (cc *http2ClientConn) Shutdown(ctx context.Context) error {
		h2_bundle.go#L10275: func (cc *http2ClientConn) Ping(ctx context.Context) error {
		h2_bundle.go#L10725: func (t *http2Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) {
		request.go#L333: 	ctx context.Context
		request.go#L352: func (r *Request) Context() context.Context {
		request.go#L368: func (r *Request) WithContext(ctx context.Context) *Request {
		request.go#L386: func (r *Request) Clone(ctx context.Context) *Request {
		request.go#L889: func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
		server.go#L976: func (c *conn) readRequest(ctx context.Context) (w *response, err error) {
		server.go#L1897: func (c *conn) serve(ctx context.Context) {
		server.go#L2122: 	ctx context.Context
		server.go#L2127: func (h unencryptedHTTP2Request) BaseContext() context.Context { return h.ctx }
		server.go#L2158: func (c *conn) maybeServeUnencryptedHTTP2(ctx context.Context) bool {
		server.go#L3055: 	BaseContext func(net.Listener) context.Context
		server.go#L3061: 	ConnContext func(ctx context.Context, c net.Conn) context.Context
		server.go#L3150: func (s *Server) Shutdown(ctx context.Context) error {
		server.go#L3806: 	testContext context.Context
		server.go#L3962: 	ctx context.Context
		server.go#L3971: func (h initALPNRequest) BaseContext() context.Context { return h.ctx }
		socks_bundle.go#L27: func (d *socksDialer) connect(ctx context.Context, c net.Conn, address string) (_ net.Addr, ctxErr error) {
		socks_bundle.go#L284: 	ProxyDial func(context.Context, string, string) (net.Conn, error)
		socks_bundle.go#L294: 	Authenticate func(context.Context, io.ReadWriter, socksAuthMethod) error
		socks_bundle.go#L307: func (d *socksDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
		socks_bundle.go#L343: func (d *socksDialer) DialWithConn(ctx context.Context, c net.Conn, network, address string) (net.Addr, error) {
		socks_bundle.go#L443: func (up *socksUsernamePassword) Authenticate(ctx context.Context, rw io.ReadWriter, auth socksAuthMethod) error {
		transport.go#L134: 	OnProxyConnectResponse func(ctx context.Context, proxyURL *url.URL, connectReq *Request, connectRes *Response) error
		transport.go#L144: 	DialContext func(ctx context.Context, network, addr string) (net.Conn, error)
		transport.go#L168: 	DialTLSContext func(ctx context.Context, network, addr string) (net.Conn, error)
		transport.go#L269: 	GetProxyConnectHeader func(ctx context.Context, proxyURL *url.URL, target string) (Header, error)
		transport.go#L527: 	ctx    context.Context // canceled when we are done with the request
		transport.go#L751: func awaitLegacyCancel(ctx context.Context, cancel context.CancelCauseFunc, req *Request) {
		transport.go#L1305: func (t *Transport) dial(ctx context.Context, network, addr string) (net.Conn, error) {
		transport.go#L1340: 	ctx       context.Context // context for dial, cleared after delivered or canceled
		transport.go#L1361: func (w *wantConn) getCtxForDial() context.Context {
		transport.go#L1500: func (t *Transport) customDialTLS(ctx context.Context, network, addr string) (conn net.Conn, err error) {
		transport.go#L1714: func (pconn *persistConn) addTLS(ctx context.Context, name string, trace *httptrace.ClientTrace) error {
		transport.go#L1769: func (t *Transport) dialConn(ctx context.Context, cm connectMethod, isClientConn bool, internalStateHook func()) (pconn *persistConn, err error) {
		transport.go#L2802: func (pc *persistConn) waitForAvailability(ctx context.Context) error {
		transport_default_other.go#L14: func defaultTransportDialContext(dialer *net.Dialer) func(context.Context, string, string) (net.Conn, error) {

	net/http/httptrace
		trace.go#L24: func ContextClientTrace(ctx context.Context) *ClientTrace {
		trace.go#L34: func WithClientTrace(ctx context.Context, trace *ClientTrace) context.Context {

	net/http/internal/httpcommon
		httpcommon.go#L215: func EncodeHeaders(ctx context.Context, param EncodeHeadersParam, headerf func(name, value string)) (res EncodeHeadersResult, _ error) {

	os/exec
		exec.go#L247: 	ctx context.Context
		exec.go#L484: func CommandContext(ctx context.Context, name string, arg ...string) *Cmd {

	runtime/pprof
		label.go#L23: func labelValue(ctx context.Context) labelMap {
		label.go#L56: func WithLabels(ctx context.Context, labels LabelSet) context.Context {
		label.go#L129: func Label(ctx context.Context, key string) (string, bool) {
		label.go#L141: func ForLabels(ctx context.Context, f func(key, value string) bool) {
		runtime.go#L41: func SetGoroutineLabels(ctx context.Context) {
		runtime.go#L53: func Do(ctx context.Context, labels LabelSet, f func(context.Context)) {

	runtime/trace
		annotation.go#L38: func NewTask(pctx context.Context, taskType string) (ctx context.Context, task *Task) {
		annotation.go#L65: func fromContext(ctx context.Context) *Task {
		annotation.go#L95: func Log(ctx context.Context, category, message string) {
		annotation.go#L101: func Logf(ctx context.Context, category, format string, args ...any) {
		annotation.go#L122: func WithRegion(ctx context.Context, regionType string, fn func()) {
		annotation.go#L152: func StartRegion(ctx context.Context, regionType string) *Region {

	testing
		testing.go#L682: 	ctx       context.Context
		testing.go#L911: 	Context() context.Context
		testing.go#L1589: func (c *common) Context() context.Context {

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)