self._linked_to is not applied immediately. First print is "toggle_link after =", must be "toggle_link after = shared_global"

[pussik124-arch]

import reflex as rx


class MySharedThing(rx.SharedState):
	my_counter: int = 0

	@rx.event
	async def toggle_link(self):
		print("toggle_link before = " + self._linked_to)
		if not self._linked_to:
			await self._link_to(await self.get_var_value(State.shared_token))
		else:
			return await self._unlink()

		print("toggle_after = " + self._linked_to)

	@rx.event
	def increment(self):
		self.my_counter += 1

	@rx.event
	def decrement(self):
		self.my_counter -= 1

	@rx.var
	def linked_to(self) -> str:
		return self._linked_to or "not linked"

	@rx.var
	def linked_from(self) -> str:
		return ", ".join(self._linked_from) or "no links"

	@rx.event(background=True)
	async def delayed_multi_increment(self, amount: int):
		import asyncio

		for _ in range(amount):
			await asyncio.sleep(1)
			async with self:
				self.my_counter += 1


class State(rx.State):
	@rx.var
	def shared_token(self) -> str:
		return (self.room or "shared_global").replace("_", "-")

	@rx.var
	async def current_count(self) -> int:
		shared_state = await self.get_state(MySharedThing)
		return shared_state.my_counter

	@rx.event
	async def print_current_count(self):
		shared_state = await self.get_state(MySharedThing)
		print(f"Current count is: {shared_state.my_counter}")


def index() -> rx.Component:
	return rx.container(
		rx.color_mode.button(position="top-right"),
		rx.vstack(
			rx.text(f"Shared token: {State.shared_token}"),
			rx.button(f"Linked To: {MySharedThing.linked_to}", on_click=MySharedThing.toggle_link),
			rx.text(f"Linked From: {MySharedThing.linked_from}"),
			rx.heading(State.current_count),
			rx.button(
				"Increment",
				on_click=MySharedThing.increment,
			),
			rx.button(
				"Increment 5 times with 1s delay",
				on_click=MySharedThing.delayed_multi_increment(5),
			),
			rx.button(
				"Decrement",
				on_click=MySharedThing.decrement,
			),
			rx.button(
				"Print Current Count to Console",
				on_click=State.print_current_count,
			),
		),
	)


app = rx.App()
app.add_page(index, route="/[room]")
app.add_page(index)

[pussik124-arch]

I am developing a web application using Reflex that includes a support ticket system. The interface consists of a sidebar with a list of tickets on the left and a chat window on the right.
To implement real-time messaging without requiring the user to refresh the page, I decided to use the SharedState feature as described in the Reflex documentation. While I have integrated it into my project, I encountered a persistent issue: connecting to a specific "room" or "channel" using self._link_to does not seem to take effect on the first attempt. I have to click the ticket (trigger the event) twice for the state to actually link to the desired identifier and start synchronizing data.
To verify this, I created a minimal reproduction app using the example code provided on the Reflex documentation website, and the behavior is the same: self._link_to fails to establish the link on the first call.
In my project, I am using MySQL with the aiomysql library for the backend. Below is a snippet of my TicketChatSharedState implementation.

class TicketChatSharedState(rx.SharedState):
	messages: list[dict] = []
	ticket: dict = {}

	@rx.event
	async def join_chat(self, ticket_to: dict):
		temp_link_id = f"chat-room-{ticket_to['TicketID']}"
		if self._linked_to and self._linked_to != temp_link_id:
			print(f"[TicketChatSharedState] (join_chat) linked to {self._linked_to}")
			print(f"[TicketChatSharedState] (join_chat) unlinking from {self._linked_to}...")
			await self._unlink()
			print(f"[TicketChatSharedState] (join_chat) linking to {temp_link_id}")
			await self._link_to(temp_link_id)
		elif not self._linked_to:
			print(f"[TicketChatSharedState] (join_chat) first linking to {temp_link_id}")
			await self._link_to("chat-room")
		
		if not self.messages:
			await self.load_chat(ticket_to['TicketID'])

		if not self.ticket:
			self.ticket = ticket_to

		print(f"[TicketChatSharedState] (join_chat) Done, current link = {self._linked_to}") # this is empty after first time.

	@rx.event
	async def add_new_message(self, msg_dict: dict):
		print("add_new_message")
		self.messages.append(msg_dict)

	@rx.event
	async def delete_current_ticket(self, ticket_id: int):
		if self.ticket and self.ticket["TicketID"] == ticket_id:
			self.ticket = dict()


	@rx.var
	def grouped_messages(self) -> list[dict]:
		formatted = []
		last_sender = None
		for m in self.messages:
			msg = m.copy()
			msg["show_header"] = (msg["sender_id"] != last_sender)
			msg["custom_mt"] = "2px" if not msg["show_header"] else "15px"
			
			msg["files_list"] = msg.get("files", [])
			
			formatted.append(msg)
			last_sender = msg["sender_id"]

		return formatted

	async def load_chat(self, ticket_id: int):
		global DB_MANAGER_POOL
		if DB_MANAGER_POOL is None:
			await init_server_db()

		async with DB_MANAGER_POOL.acquire() as conn:
			async with conn.cursor(aiomysql.DictCursor) as cur:
				await cur.execute(
					"""
					SELECT tm.*, u.Username 
					FROM ticket_messages tm
					JOIN users u ON tm.sender_id = u.UserID
					WHERE tm.ticket_id = %s 
					ORDER BY tm.created_at ASC
					""",
					(ticket_id,)
				)
				res = await cur.fetchall()
				temp_chat_messages = [dict(row) for row in res] if res else []

				if res:
					for tm in temp_chat_messages:
						files_string = tm["files"]
						tm["files"] = []
						if files_string:
							for fs in files_string.split(";"):
								tm["files"].append(fs)

					self.messages = temp_chat_messages
					print(self.messages)