@blade-hq/agent-react 2612.0.0-beta.75 → 2612.0.0-beta.77

package/dist/{chunk-XP6T6SHZ.js → chunk-IVGTMWRV.js}

@@ -9,17 +9,17 @@ import {
   useEffectEvent,
   useSessionPluginActivation,
   useSessionSkills
-} from "./chunk-2DPLLZOU.js";
+} from "./chunk-F2IJZX2Z.js";
 import {
   ImageLightbox,
   McpAppMessageContext,
   MessageImage,
   ToolUiCardView,
   getRenderer
-} from "./chunk-HCW7SI5Q.js";
+} from "./chunk-26NE55SJ.js";
 import {
   MarkdownContent
-} from "./chunk-XJ6ZA6LN.js";
+} from "./chunk-VBHHFIII.js";
 import {
   BladeProvider,
   ChatEnvironmentProvider,
@@ -61,7 +61,7 @@ import {
   useSessionSource,
   useSessionState,
   useSingleSessionSource
-} from "./chunk-WRIMPZPN.js";
+} from "./chunk-EQOKPZI2.js";
 import {
   Archive,
   ArrowRight,
@@ -118,7 +118,7 @@ import {
   Zap,
   dist_exports2 as dist_exports,
   useControllableState
-} from "./chunk-QIR73CES.js";
+} from "./chunk-XBEN2ASY.js";
 
 // src/hooks/use-agent-session.ts
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
@@ -219,8 +219,8 @@ function useAgentSession(sessionId, options = {}) {
     }),
     [session]
   );
-  const state = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-  return { session, state, error };
+  const state2 = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+  return { session, state: state2, error };
 }
 
 // src/hooks/use-replay.ts
@@ -246,10 +246,10 @@ function useReplay(session) {
       return;
     }
     const pull = () => {
-      const state = session.getState();
-      setReplay(state.replay);
-      setViewerRole(state.viewerRole);
-      setSourceRunning(state.isStreaming || state.status === "running");
+      const state2 = session.getState();
+      setReplay(state2.replay);
+      setViewerRole(state2.viewerRole);
+      setSourceRunning(state2.isStreaming || state2.status === "running");
     };
     pull();
     return session.subscribe(pull);
@@ -471,10 +471,10 @@ function ReplayMismatchPrompt({ mismatch, className }) {
 
 // src/components/AgentChat.tsx
 import { BladeApiError } from "@blade-hq/agent-client/internal";
-import { useEffect as useEffect27, useMemo as useMemo17, useRef as useRef23, useState as useState30 } from "react";
+import { useEffect as useEffect28, useMemo as useMemo17, useRef as useRef23, useState as useState31 } from "react";
 
 // src/chat/ChatPanel.tsx
-import { useCallback as useCallback16, useEffect as useEffect25, useMemo as useMemo16, useState as useState28 } from "react";
+import { useCallback as useCallback16, useEffect as useEffect26, useMemo as useMemo16, useState as useState29 } from "react";
 import {
   chatErrorForDisplay as chatErrorForDisplay3,
   latestPostChatFollowup
@@ -985,8 +985,8 @@ function CurrentPlanPanel({
   sessionId,
   className
 }) {
-  const messages = useSessionState(sessionId, (state) => state.messages);
-  const isStreaming = useSessionState(sessionId, (state) => state.isStreaming);
+  const messages = useSessionState(sessionId, (state2) => state2.messages);
+  const isStreaming = useSessionState(sessionId, (state2) => state2.isStreaming);
   const hideTodo = useHideTodo();
   const revealRevision = usePlanRevealRevision(sessionId);
   const { current, updating } = useMemo2(() => getPlanUpdateDisplayState(messages), [messages]);
@@ -3294,9 +3294,9 @@ function AgentLoopBlock({
   defaultExpanded = false,
   renderDescription
 }) {
-  const agentLoops = useSessionState(sessionId, (state) => state.agentLoops);
-  const messages = useSessionState(sessionId, (state) => state.messages);
-  const askAnswers = useSessionState(sessionId, (state) => state.askAnswers);
+  const agentLoops = useSessionState(sessionId, (state2) => state2.agentLoops);
+  const messages = useSessionState(sessionId, (state2) => state2.messages);
+  const askAnswers = useSessionState(sessionId, (state2) => state2.askAnswers);
   const loopEntry = useMemo8(() => {
     for (const [loopName, info] of Object.entries(agentLoops)) {
       if (info.toolCallId === toolCall.id) {
@@ -3787,9 +3787,9 @@ function RefTokenText({ text, refs }) {
   return /* @__PURE__ */ jsx26(Fragment12, { children: parts });
 }
 function WorkflowRunBlock({ toolCall, sessionId }) {
-  const run = useSessionState(sessionId, (state) => state.workflowRuns[toolCall.id]);
-  const agentLoops = useSessionState(sessionId, (state) => state.agentLoops);
-  const sessionMessages = useSessionState(sessionId, (state) => state.messages);
+  const run = useSessionState(sessionId, (state2) => state2.workflowRuns[toolCall.id]);
+  const agentLoops = useSessionState(sessionId, (state2) => state2.agentLoops);
+  const sessionMessages = useSessionState(sessionId, (state2) => state2.messages);
   const [collapsed, setCollapsed] = useState16(false);
   const stepLoops = useMemo9(
     () => Object.entries(agentLoops).filter(([, info]) => info.workflowRunId === toolCall.id).map(([loopName, info]) => ({ loopName, info })),
@@ -3840,7 +3840,7 @@ function WorkflowRunBlock({ toolCall, sessionId }) {
   const status = run?.status ?? "running";
   const running = status === "running";
   const stepCount = groups.length || stepLoops.length;
-  const viewerRole = useSessionState(sessionId, (state) => state.viewerRole);
+  const viewerRole = useSessionState(sessionId, (state2) => state2.viewerRole);
   const canListSkills = !sessionId.startsWith("share:") && viewerRole !== "viewer";
   const { data: sessionSkills = NO_SKILLS } = useSessionSkills(canListSkills ? sessionId : null);
   const title = workflowTitle(run?.name || "\u6280\u80FD", toolCall.arguments, sessionSkills);
@@ -4185,11 +4185,11 @@ function AssistantTurnBlockBase({
   const displayModeMemoryKey = sessionId && firstEntryId ? `${sessionId}:${firstEntryId}` : null;
   const sessionMessages = useSessionState(
     sessionId,
-    (state) => hasAgentToolCall ? state.messages : EMPTY_MESSAGES
+    (state2) => hasAgentToolCall ? state2.messages : EMPTY_MESSAGES
   );
   const agentLoops = useSessionState(
     sessionId,
-    (state) => hasAgentToolCall ? state.agentLoops : EMPTY_AGENT_LOOPS
+    (state2) => hasAgentToolCall ? state2.agentLoops : EMPTY_AGENT_LOOPS
   );
   const turnMessages = useMemo10(
     () => hasAgentToolCall ? collectTurnMessages({ rootMessages: messages, sessionMessages, agentLoops }) : messages,
@@ -5805,8 +5805,8 @@ function LiteMessageList({
     };
   }, [onLoadOlder, historyLoadRevision]);
   const showContexts = false;
-  const agentLoops = useSessionState(sessionId, (state) => state.agentLoops);
-  const askAnswers = useSessionState(sessionId, (state) => state.askAnswers);
+  const agentLoops = useSessionState(sessionId, (state2) => state2.agentLoops);
+  const askAnswers = useSessionState(sessionId, (state2) => state2.askAnswers);
   const rows = useMemo11(
     () => buildLiteRows({
       messages,
@@ -6111,11 +6111,11 @@ function LiteFollowup({
 import { isBackgroundWakeMessage as isBackgroundWakeMessage3 } from "@blade-hq/agent-client/internal";
 import {
   useCallback as useCallback13,
-  useEffect as useEffect23,
+  useEffect as useEffect24,
   useLayoutEffect as useLayoutEffect5,
   useMemo as useMemo15,
   useRef as useRef21,
-  useState as useState26
+  useState as useState27
 } from "react";
 
 // ../../node_modules/.pnpm/use-stick-to-bottom@1.1.3_react@19.2.4/node_modules/use-stick-to-bottom/dist/useStickToBottom.js
@@ -6173,14 +6173,14 @@ var useStickToBottom = (options = {}) => {
     return range.commonAncestorContainer.contains(scrollRef.current) || scrollRef.current?.contains(range.commonAncestorContainer);
   }, []);
   const setIsAtBottom = useCallback8((isAtBottom2) => {
-    state.isAtBottom = isAtBottom2;
+    state2.isAtBottom = isAtBottom2;
     updateIsAtBottom(isAtBottom2);
   }, []);
   const setEscapedFromLock = useCallback8((escapedFromLock2) => {
-    state.escapedFromLock = escapedFromLock2;
+    state2.escapedFromLock = escapedFromLock2;
     updateEscapedFromLock(escapedFromLock2);
   }, []);
-  const state = useMemo12(() => {
+  const state2 = useMemo12(() => {
     let lastCalculation;
     return {
       escapedFromLock,
@@ -6195,7 +6195,7 @@ var useStickToBottom = (options = {}) => {
       set scrollTop(scrollTop) {
         if (scrollRef.current) {
           scrollRef.current.scrollTop = scrollTop;
-          state.ignoreScrollToTop = scrollRef.current.scrollTop;
+          state2.ignoreScrollToTop = scrollRef.current.scrollTop;
         }
       },
       get targetScrollTop() {
@@ -6244,7 +6244,7 @@ var useStickToBottom = (options = {}) => {
     const behavior = mergeAnimations(optionsRef.current, scrollOptions.animation);
     const { ignoreEscapes = false } = scrollOptions;
     let durationElapsed;
-    let startTarget = state.calculatedTargetScrollTop;
+    let startTarget = state2.calculatedTargetScrollTop;
     if (scrollOptions.duration instanceof Promise) {
       scrollOptions.duration.finally(() => {
         durationElapsed = Date.now();
@@ -6254,16 +6254,16 @@ var useStickToBottom = (options = {}) => {
     }
     const next = async () => {
       const promise = new Promise(requestAnimationFrame).then(() => {
-        if (!state.isAtBottom) {
-          state.animation = void 0;
+        if (!state2.isAtBottom) {
+          state2.animation = void 0;
           return false;
         }
-        const { scrollTop } = state;
+        const { scrollTop } = state2;
         const tick = performance.now();
-        const tickDelta = (tick - (state.lastTick ?? tick)) / SIXTY_FPS_INTERVAL_MS;
-        state.animation || (state.animation = { behavior, promise, ignoreEscapes });
-        if (state.animation.behavior === behavior) {
-          state.lastTick = tick;
+        const tickDelta = (tick - (state2.lastTick ?? tick)) / SIXTY_FPS_INTERVAL_MS;
+        state2.animation || (state2.animation = { behavior, promise, ignoreEscapes });
+        if (state2.animation.behavior === behavior) {
+          state2.lastTick = tick;
         }
         if (isSelecting()) {
           return next();
@@ -6271,53 +6271,53 @@ var useStickToBottom = (options = {}) => {
         if (waitElapsed > Date.now()) {
           return next();
         }
-        if (scrollTop < Math.min(startTarget, state.calculatedTargetScrollTop)) {
-          if (state.animation?.behavior === behavior) {
+        if (scrollTop < Math.min(startTarget, state2.calculatedTargetScrollTop)) {
+          if (state2.animation?.behavior === behavior) {
             if (behavior === "instant") {
-              state.scrollTop = state.calculatedTargetScrollTop;
+              state2.scrollTop = state2.calculatedTargetScrollTop;
               return next();
             }
-            state.velocity = (behavior.damping * state.velocity + behavior.stiffness * state.scrollDifference) / behavior.mass;
-            state.accumulated += state.velocity * tickDelta;
-            state.scrollTop += state.accumulated;
-            if (state.scrollTop !== scrollTop) {
-              state.accumulated = 0;
+            state2.velocity = (behavior.damping * state2.velocity + behavior.stiffness * state2.scrollDifference) / behavior.mass;
+            state2.accumulated += state2.velocity * tickDelta;
+            state2.scrollTop += state2.accumulated;
+            if (state2.scrollTop !== scrollTop) {
+              state2.accumulated = 0;
             }
           }
           return next();
         }
         if (durationElapsed > Date.now()) {
-          startTarget = state.calculatedTargetScrollTop;
+          startTarget = state2.calculatedTargetScrollTop;
           return next();
         }
-        state.animation = void 0;
-        if (state.scrollTop < state.calculatedTargetScrollTop) {
+        state2.animation = void 0;
+        if (state2.scrollTop < state2.calculatedTargetScrollTop) {
           return scrollToBottom({
             animation: mergeAnimations(optionsRef.current, optionsRef.current.resize),
             ignoreEscapes,
             duration: Math.max(0, durationElapsed - Date.now()) || void 0
           });
         }
-        return state.isAtBottom;
+        return state2.isAtBottom;
       });
       return promise.then((isAtBottom2) => {
         requestAnimationFrame(() => {
-          if (!state.animation) {
-            state.lastTick = void 0;
-            state.velocity = 0;
+          if (!state2.animation) {
+            state2.lastTick = void 0;
+            state2.velocity = 0;
           }
         });
         return isAtBottom2;
       });
     };
     if (scrollOptions.wait !== true) {
-      state.animation = void 0;
+      state2.animation = void 0;
     }
-    if (state.animation?.behavior === behavior) {
-      return state.animation.promise;
+    if (state2.animation?.behavior === behavior) {
+      return state2.animation.promise;
     }
     return next();
-  }, [setIsAtBottom, isSelecting, state]);
+  }, [setIsAtBottom, isSelecting, state2]);
   const stopScroll = useCallback8(() => {
     setEscapedFromLock(true);
     setIsAtBottom(false);
@@ -6326,16 +6326,16 @@ var useStickToBottom = (options = {}) => {
     if (target !== scrollRef.current) {
       return;
     }
-    const { scrollTop, ignoreScrollToTop } = state;
-    let { lastScrollTop = scrollTop } = state;
-    state.lastScrollTop = scrollTop;
-    state.ignoreScrollToTop = void 0;
+    const { scrollTop, ignoreScrollToTop } = state2;
+    let { lastScrollTop = scrollTop } = state2;
+    state2.lastScrollTop = scrollTop;
+    state2.ignoreScrollToTop = void 0;
     if (ignoreScrollToTop && ignoreScrollToTop > scrollTop) {
       lastScrollTop = ignoreScrollToTop;
     }
-    setIsNearBottom(state.isNearBottom);
+    setIsNearBottom(state2.isNearBottom);
     setTimeout(() => {
-      if (state.resizeDifference || scrollTop === ignoreScrollToTop) {
+      if (state2.resizeDifference || scrollTop === ignoreScrollToTop) {
         return;
       }
       if (isSelecting()) {
@@ -6345,8 +6345,8 @@ var useStickToBottom = (options = {}) => {
       }
       const isScrollingDown = scrollTop > lastScrollTop;
       const isScrollingUp = scrollTop < lastScrollTop;
-      if (state.animation?.ignoreEscapes) {
-        state.scrollTop = lastScrollTop;
+      if (state2.animation?.ignoreEscapes) {
+        state2.scrollTop = lastScrollTop;
         return;
       }
       if (isScrollingUp) {
@@ -6356,11 +6356,11 @@ var useStickToBottom = (options = {}) => {
       if (isScrollingDown) {
         setEscapedFromLock(false);
       }
-      if (!state.escapedFromLock && state.isNearBottom) {
+      if (!state2.escapedFromLock && state2.isNearBottom) {
         setIsAtBottom(true);
       }
     }, 1);
-  }, [setEscapedFromLock, setIsAtBottom, isSelecting, state]);
+  }, [setEscapedFromLock, setIsAtBottom, isSelecting, state2]);
   const handleWheel = useCallback8(({ target, deltaY }) => {
     let element = target;
     while (!["scroll", "auto"].includes(getComputedStyle(element).overflow)) {
@@ -6369,11 +6369,11 @@ var useStickToBottom = (options = {}) => {
       }
       element = element.parentElement;
     }
-    if (element === scrollRef.current && deltaY < 0 && scrollRef.current.scrollHeight > scrollRef.current.clientHeight && !state.animation?.ignoreEscapes) {
+    if (element === scrollRef.current && deltaY < 0 && scrollRef.current.scrollHeight > scrollRef.current.clientHeight && !state2.animation?.ignoreEscapes) {
       setEscapedFromLock(true);
       setIsAtBottom(false);
     }
-  }, [setEscapedFromLock, setIsAtBottom, state]);
+  }, [setEscapedFromLock, setIsAtBottom, state2]);
   const scrollRef = useRefCallback((scroll) => {
     scrollRef.current?.removeEventListener("scroll", handleScroll);
     scrollRef.current?.removeEventListener("wheel", handleWheel);
@@ -6381,19 +6381,19 @@ var useStickToBottom = (options = {}) => {
     scroll?.addEventListener("wheel", handleWheel, { passive: true });
   }, []);
   const contentRef = useRefCallback((content) => {
-    state.resizeObserver?.disconnect();
+    state2.resizeObserver?.disconnect();
     if (!content) {
       return;
     }
     let previousHeight;
-    state.resizeObserver = new ResizeObserver(([entry]) => {
+    state2.resizeObserver = new ResizeObserver(([entry]) => {
       const { height } = entry.contentRect;
       const difference = height - (previousHeight ?? height);
-      state.resizeDifference = difference;
-      if (state.scrollTop > state.targetScrollTop) {
-        state.scrollTop = state.targetScrollTop;
+      state2.resizeDifference = difference;
+      if (state2.scrollTop > state2.targetScrollTop) {
+        state2.scrollTop = state2.targetScrollTop;
       }
-      setIsNearBottom(state.isNearBottom);
+      setIsNearBottom(state2.isNearBottom);
       if (difference >= 0) {
         const animation = mergeAnimations(optionsRef.current, previousHeight ? optionsRef.current.resize : optionsRef.current.initial);
         scrollToBottom({
@@ -6403,7 +6403,7 @@ var useStickToBottom = (options = {}) => {
           duration: animation === "instant" ? void 0 : RETAIN_ANIMATION_DURATION_MS
         });
       } else {
-        if (state.isNearBottom) {
+        if (state2.isNearBottom) {
           setEscapedFromLock(false);
           setIsAtBottom(true);
         }
@@ -6411,13 +6411,13 @@ var useStickToBottom = (options = {}) => {
       previousHeight = height;
       requestAnimationFrame(() => {
         setTimeout(() => {
-          if (state.resizeDifference === difference) {
-            state.resizeDifference = 0;
+          if (state2.resizeDifference === difference) {
+            state2.resizeDifference = 0;
           }
         }, 1);
       });
     });
-    state.resizeObserver?.observe(content);
+    state2.resizeObserver?.observe(content);
   }, []);
   return {
     contentRef,
@@ -6427,7 +6427,7 @@ var useStickToBottom = (options = {}) => {
     isAtBottom: isAtBottom || isNearBottom,
     isNearBottom,
     escapedFromLock,
-    state
+    state: state2
   };
 };
 function useRefCallback(callback, deps) {
@@ -6480,7 +6480,7 @@ function StickToBottom({ instance, children, resize, initial, mass, damping, sti
     initial,
     targetScrollTop
   });
-  const { scrollRef, contentRef, scrollToBottom, stopScroll, isAtBottom, escapedFromLock, state } = instance ?? defaultInstance;
+  const { scrollRef, contentRef, scrollToBottom, stopScroll, isAtBottom, escapedFromLock, state: state2 } = instance ?? defaultInstance;
   const context = useMemo13(() => ({
     scrollToBottom,
     stopScroll,
@@ -6488,7 +6488,7 @@ function StickToBottom({ instance, children, resize, initial, mass, damping, sti
     isAtBottom,
     escapedFromLock,
     contentRef,
-    state,
+    state: state2,
     get targetScrollTop() {
       return customTargetScrollTop.current;
     },
@@ -6502,7 +6502,7 @@ function StickToBottom({ instance, children, resize, initial, mass, damping, sti
     scrollRef,
     stopScroll,
     escapedFromLock,
-    state
+    state2
   ]);
   useImperativeHandle(contextRef, () => context, [context]);
   useIsomorphicLayoutEffect(() => {
@@ -6678,7 +6678,17 @@ function useTurnNavigation({
     setIndex({ sessionId, items: keep });
     load2().then((items) => {
       if (seq2 !== indexSeq.current) return;
-      const navItems = items.map((item) => ({ id: item.entryId, title: item.preview }));
+      const navItems = items.map((item) => ({
+        id: item.entryId,
+        title: item.preview,
+        recaption: item.recaption,
+        artifacts: item.artifacts,
+        entries: item.entries?.map((entry) => ({
+          id: entry.entryId,
+          title: entry.preview,
+          answer: entry.answer
+        }))
+      }));
       indexRef.current = { sessionId, items: navItems };
       setIndex({ sessionId, items: navItems });
     }).catch(() => {
@@ -6820,10 +6830,10 @@ function initialRevealState(targetText, isLive, resetKey) {
   };
 }
 function useTypewriterReveal(targetText, isLive, resetKey) {
-  const [state, setState] = useState22(() => initialRevealState(targetText, isLive, resetKey));
+  const [state2, setState2] = useState22(() => initialRevealState(targetText, isLive, resetKey));
   const targetTextRef = useRef17(targetText);
   targetTextRef.current = targetText;
-  const revealedLenRef = useRef17(state.revealedLen);
+  const revealedLenRef = useRef17(state2.revealedLen);
   const priorTargetLenRef = useRef17(targetText.length);
   const emaCpsRef = useRef17(REVEAL_INITIAL_CPS);
   const lastTickTsRef = useRef17(null);
@@ -6837,9 +6847,9 @@ function useTypewriterReveal(targetText, isLive, resetKey) {
     stopTicking();
     revealedLenRef.current = targetTextRef.current.length;
     priorTargetLenRef.current = targetTextRef.current.length;
-    setState((s) => ({ ...s, displayedText: targetTextRef.current, revealedLen: revealedLenRef.current, isRevealing: false }));
+    setState2((s) => ({ ...s, displayedText: targetTextRef.current, revealedLen: revealedLenRef.current, isRevealing: false }));
   }, [stopTicking]);
-  if (state.resetKey !== resetKey) {
+  if (state2.resetKey !== resetKey) {
     const next = initialRevealState(targetText, isLive, resetKey);
     revealedLenRef.current = next.revealedLen;
     priorTargetLenRef.current = targetText.length;
@@ -6847,18 +6857,18 @@ function useTypewriterReveal(targetText, isLive, resetKey) {
     lastTickTsRef.current = null;
     lastArrivalTsRef.current = null;
     stopTicking();
-    setState(next);
+    setState2(next);
   } else if (!isLive) {
-    if (state.revealedLen !== targetText.length || state.displayedText !== targetText) {
+    if (state2.revealedLen !== targetText.length || state2.displayedText !== targetText) {
       revealedLenRef.current = targetText.length;
       priorTargetLenRef.current = targetText.length;
       stopTicking();
-      setState((s) => ({ ...s, displayedText: targetText, revealedLen: targetText.length, isRevealing: false }));
+      setState2((s) => ({ ...s, displayedText: targetText, revealedLen: targetText.length, isRevealing: false }));
     }
-  } else if (state.revealedLen === 0 && targetText.length > 0) {
+  } else if (state2.revealedLen === 0 && targetText.length > 0) {
     revealedLenRef.current = targetText.length;
     priorTargetLenRef.current = targetText.length;
-    setState((s) => ({ ...s, displayedText: targetText, revealedLen: targetText.length, isRevealing: false }));
+    setState2((s) => ({ ...s, displayedText: targetText, revealedLen: targetText.length, isRevealing: false }));
   }
   const tickRef = useRef17(null);
   tickRef.current = (ts) => {
@@ -6886,7 +6896,7 @@ function useTypewriterReveal(targetText, isLive, resetKey) {
     const advance = Math.max(1, paced, catchUp);
     revealedLenRef.current = Math.min(currentTargetLen, revealedLenRef.current + advance);
     const revealed = revealedLenRef.current >= currentTargetLen;
-    setState((s) => ({
+    setState2((s) => ({
       ...s,
       displayedText: targetTextRef.current.slice(
         0,
@@ -6904,7 +6914,7 @@ function useTypewriterReveal(targetText, isLive, resetKey) {
     if (revealedLenRef.current === 0) return;
     if (revealedLenRef.current >= targetText.length) return;
     if (cancelRef.current != null) return;
-    setState((s) => s.isRevealing ? s : { ...s, isRevealing: true });
+    setState2((s) => s.isRevealing ? s : { ...s, isRevealing: true });
     cancelRef.current = scheduleAnimationFrame((ts) => tickRef.current?.(ts));
   }, [targetText, isLive]);
   useEffect19(() => {
@@ -6919,7 +6929,7 @@ function useTypewriterReveal(targetText, isLive, resetKey) {
     return () => document.removeEventListener("visibilitychange", handleVisibilityChange);
   }, [flushNow]);
   useEffect19(() => stopTicking, [stopTicking]);
-  return { displayedText: state.displayedText, isRevealing: state.isRevealing, flushNow };
+  return { displayedText: state2.displayedText, isRevealing: state2.isRevealing, flushNow };
 }
 
 // src/chat/plan/PlanSummaryCard.tsx
@@ -7826,95 +7836,95 @@ function State$1(input, options) {
   this.firstTabInLine = -1;
   this.documents = [];
 }
-function generateError(state, message) {
+function generateError(state2, message) {
   var mark = {
-    name: state.filename,
-    buffer: state.input.slice(0, -1),
+    name: state2.filename,
+    buffer: state2.input.slice(0, -1),
     // omit trailing \0
-    position: state.position,
-    line: state.line,
-    column: state.position - state.lineStart
+    position: state2.position,
+    line: state2.line,
+    column: state2.position - state2.lineStart
   };
   mark.snippet = snippet(mark);
   return new exception(message, mark);
 }
-function throwError(state, message) {
-  throw generateError(state, message);
+function throwError(state2, message) {
+  throw generateError(state2, message);
 }
-function throwWarning(state, message) {
-  if (state.onWarning) {
-    state.onWarning.call(null, generateError(state, message));
+function throwWarning(state2, message) {
+  if (state2.onWarning) {
+    state2.onWarning.call(null, generateError(state2, message));
   }
 }
 var directiveHandlers = {
-  YAML: function handleYamlDirective(state, name, args) {
+  YAML: function handleYamlDirective(state2, name, args) {
     var match, major, minor;
-    if (state.version !== null) {
-      throwError(state, "duplication of %YAML directive");
+    if (state2.version !== null) {
+      throwError(state2, "duplication of %YAML directive");
     }
     if (args.length !== 1) {
-      throwError(state, "YAML directive accepts exactly one argument");
+      throwError(state2, "YAML directive accepts exactly one argument");
     }
     match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
     if (match === null) {
-      throwError(state, "ill-formed argument of the YAML directive");
+      throwError(state2, "ill-formed argument of the YAML directive");
     }
     major = parseInt(match[1], 10);
     minor = parseInt(match[2], 10);
     if (major !== 1) {
-      throwError(state, "unacceptable YAML version of the document");
+      throwError(state2, "unacceptable YAML version of the document");
     }
-    state.version = args[0];
-    state.checkLineBreaks = minor < 2;
+    state2.version = args[0];
+    state2.checkLineBreaks = minor < 2;
     if (minor !== 1 && minor !== 2) {
-      throwWarning(state, "unsupported YAML version of the document");
+      throwWarning(state2, "unsupported YAML version of the document");
     }
   },
-  TAG: function handleTagDirective(state, name, args) {
+  TAG: function handleTagDirective(state2, name, args) {
     var handle, prefix;
     if (args.length !== 2) {
-      throwError(state, "TAG directive accepts exactly two arguments");
+      throwError(state2, "TAG directive accepts exactly two arguments");
     }
     handle = args[0];
     prefix = args[1];
     if (!PATTERN_TAG_HANDLE.test(handle)) {
-      throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
+      throwError(state2, "ill-formed tag handle (first argument) of the TAG directive");
     }
-    if (_hasOwnProperty$1.call(state.tagMap, handle)) {
-      throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+    if (_hasOwnProperty$1.call(state2.tagMap, handle)) {
+      throwError(state2, 'there is a previously declared suffix for "' + handle + '" tag handle');
     }
     if (!PATTERN_TAG_URI.test(prefix)) {
-      throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+      throwError(state2, "ill-formed tag prefix (second argument) of the TAG directive");
     }
     try {
       prefix = decodeURIComponent(prefix);
     } catch (err) {
-      throwError(state, "tag prefix is malformed: " + prefix);
+      throwError(state2, "tag prefix is malformed: " + prefix);
     }
-    state.tagMap[handle] = prefix;
+    state2.tagMap[handle] = prefix;
   }
 };
-function captureSegment(state, start, end, checkJson) {
+function captureSegment(state2, start, end, checkJson) {
   var _position, _length, _character, _result;
   if (start < end) {
-    _result = state.input.slice(start, end);
+    _result = state2.input.slice(start, end);
     if (checkJson) {
       for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
         _character = _result.charCodeAt(_position);
         if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
-          throwError(state, "expected valid JSON character");
+          throwError(state2, "expected valid JSON character");
         }
       }
     } else if (PATTERN_NON_PRINTABLE.test(_result)) {
-      throwError(state, "the stream contains non-printable characters");
+      throwError(state2, "the stream contains non-printable characters");
     }
-    state.result += _result;
+    state2.result += _result;
   }
 }
-function mergeMappings(state, destination, source, overridableKeys) {
+function mergeMappings(state2, destination, source, overridableKeys) {
   var sourceKeys, key, index, quantity;
   if (!common.isObject(source)) {
-    throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+    throwError(state2, "cannot merge mappings; the provided source object is unacceptable");
   }
   sourceKeys = Object.keys(source);
   for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
@@ -7925,13 +7935,13 @@ function mergeMappings(state, destination, source, overridableKeys) {
     }
   }
 }
-function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
+function storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
   var index, quantity;
   if (Array.isArray(keyNode)) {
     keyNode = Array.prototype.slice.call(keyNode);
     for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
       if (Array.isArray(keyNode[index])) {
-        throwError(state, "nested arrays are not supported inside keys");
+        throwError(state2, "nested arrays are not supported inside keys");
       }
       if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
         keyNode[index] = "[object Object]";
@@ -7948,246 +7958,246 @@ function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valu
   if (keyTag === "tag:yaml.org,2002:merge") {
     if (Array.isArray(valueNode)) {
       for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
-        mergeMappings(state, _result, valueNode[index], overridableKeys);
+        mergeMappings(state2, _result, valueNode[index], overridableKeys);
       }
     } else {
-      mergeMappings(state, _result, valueNode, overridableKeys);
+      mergeMappings(state2, _result, valueNode, overridableKeys);
     }
   } else {
-    if (!state.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) {
-      state.line = startLine || state.line;
-      state.lineStart = startLineStart || state.lineStart;
-      state.position = startPos || state.position;
-      throwError(state, "duplicated mapping key");
+    if (!state2.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) {
+      state2.line = startLine || state2.line;
+      state2.lineStart = startLineStart || state2.lineStart;
+      state2.position = startPos || state2.position;
+      throwError(state2, "duplicated mapping key");
     }
     setProperty(_result, keyNode, valueNode);
     delete overridableKeys[keyNode];
   }
   return _result;
 }
-function readLineBreak(state) {
+function readLineBreak(state2) {
   var ch;
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   if (ch === 10) {
-    state.position++;
+    state2.position++;
   } else if (ch === 13) {
-    state.position++;
-    if (state.input.charCodeAt(state.position) === 10) {
-      state.position++;
+    state2.position++;
+    if (state2.input.charCodeAt(state2.position) === 10) {
+      state2.position++;
     }
   } else {
-    throwError(state, "a line break is expected");
+    throwError(state2, "a line break is expected");
   }
-  state.line += 1;
-  state.lineStart = state.position;
-  state.firstTabInLine = -1;
+  state2.line += 1;
+  state2.lineStart = state2.position;
+  state2.firstTabInLine = -1;
 }
-function skipSeparationSpace(state, allowComments, checkIndent) {
-  var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
+function skipSeparationSpace(state2, allowComments, checkIndent) {
+  var lineBreaks = 0, ch = state2.input.charCodeAt(state2.position);
   while (ch !== 0) {
     while (is_WHITE_SPACE(ch)) {
-      if (ch === 9 && state.firstTabInLine === -1) {
-        state.firstTabInLine = state.position;
+      if (ch === 9 && state2.firstTabInLine === -1) {
+        state2.firstTabInLine = state2.position;
       }
-      ch = state.input.charCodeAt(++state.position);
+      ch = state2.input.charCodeAt(++state2.position);
     }
     if (allowComments && ch === 35) {
       do {
-        ch = state.input.charCodeAt(++state.position);
+        ch = state2.input.charCodeAt(++state2.position);
       } while (ch !== 10 && ch !== 13 && ch !== 0);
     }
     if (is_EOL(ch)) {
-      readLineBreak(state);
-      ch = state.input.charCodeAt(state.position);
+      readLineBreak(state2);
+      ch = state2.input.charCodeAt(state2.position);
       lineBreaks++;
-      state.lineIndent = 0;
+      state2.lineIndent = 0;
       while (ch === 32) {
-        state.lineIndent++;
-        ch = state.input.charCodeAt(++state.position);
+        state2.lineIndent++;
+        ch = state2.input.charCodeAt(++state2.position);
       }
     } else {
       break;
     }
   }
-  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
-    throwWarning(state, "deficient indentation");
+  if (checkIndent !== -1 && lineBreaks !== 0 && state2.lineIndent < checkIndent) {
+    throwWarning(state2, "deficient indentation");
   }
   return lineBreaks;
 }
-function testDocumentSeparator(state) {
-  var _position = state.position, ch;
-  ch = state.input.charCodeAt(_position);
-  if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
+function testDocumentSeparator(state2) {
+  var _position = state2.position, ch;
+  ch = state2.input.charCodeAt(_position);
+  if ((ch === 45 || ch === 46) && ch === state2.input.charCodeAt(_position + 1) && ch === state2.input.charCodeAt(_position + 2)) {
     _position += 3;
-    ch = state.input.charCodeAt(_position);
+    ch = state2.input.charCodeAt(_position);
     if (ch === 0 || is_WS_OR_EOL(ch)) {
       return true;
     }
   }
   return false;
 }
-function writeFoldedLines(state, count) {
+function writeFoldedLines(state2, count) {
   if (count === 1) {
-    state.result += " ";
+    state2.result += " ";
   } else if (count > 1) {
-    state.result += common.repeat("\n", count - 1);
+    state2.result += common.repeat("\n", count - 1);
   }
 }
-function readPlainScalar(state, nodeIndent, withinFlowCollection) {
-  var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch;
-  ch = state.input.charCodeAt(state.position);
+function readPlainScalar(state2, nodeIndent, withinFlowCollection) {
+  var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state2.kind, _result = state2.result, ch;
+  ch = state2.input.charCodeAt(state2.position);
   if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) {
     return false;
   }
   if (ch === 63 || ch === 45) {
-    following = state.input.charCodeAt(state.position + 1);
+    following = state2.input.charCodeAt(state2.position + 1);
     if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
       return false;
     }
   }
-  state.kind = "scalar";
-  state.result = "";
-  captureStart = captureEnd = state.position;
+  state2.kind = "scalar";
+  state2.result = "";
+  captureStart = captureEnd = state2.position;
   hasPendingContent = false;
   while (ch !== 0) {
     if (ch === 58) {
-      following = state.input.charCodeAt(state.position + 1);
+      following = state2.input.charCodeAt(state2.position + 1);
       if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
         break;
       }
     } else if (ch === 35) {
-      preceding = state.input.charCodeAt(state.position - 1);
+      preceding = state2.input.charCodeAt(state2.position - 1);
       if (is_WS_OR_EOL(preceding)) {
         break;
       }
-    } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) {
+    } else if (state2.position === state2.lineStart && testDocumentSeparator(state2) || withinFlowCollection && is_FLOW_INDICATOR(ch)) {
       break;
     } else if (is_EOL(ch)) {
-      _line = state.line;
-      _lineStart = state.lineStart;
-      _lineIndent = state.lineIndent;
-      skipSeparationSpace(state, false, -1);
-      if (state.lineIndent >= nodeIndent) {
+      _line = state2.line;
+      _lineStart = state2.lineStart;
+      _lineIndent = state2.lineIndent;
+      skipSeparationSpace(state2, false, -1);
+      if (state2.lineIndent >= nodeIndent) {
         hasPendingContent = true;
-        ch = state.input.charCodeAt(state.position);
+        ch = state2.input.charCodeAt(state2.position);
         continue;
       } else {
-        state.position = captureEnd;
-        state.line = _line;
-        state.lineStart = _lineStart;
-        state.lineIndent = _lineIndent;
+        state2.position = captureEnd;
+        state2.line = _line;
+        state2.lineStart = _lineStart;
+        state2.lineIndent = _lineIndent;
         break;
       }
     }
     if (hasPendingContent) {
-      captureSegment(state, captureStart, captureEnd, false);
-      writeFoldedLines(state, state.line - _line);
-      captureStart = captureEnd = state.position;
+      captureSegment(state2, captureStart, captureEnd, false);
+      writeFoldedLines(state2, state2.line - _line);
+      captureStart = captureEnd = state2.position;
       hasPendingContent = false;
     }
     if (!is_WHITE_SPACE(ch)) {
-      captureEnd = state.position + 1;
+      captureEnd = state2.position + 1;
     }
-    ch = state.input.charCodeAt(++state.position);
+    ch = state2.input.charCodeAt(++state2.position);
   }
-  captureSegment(state, captureStart, captureEnd, false);
-  if (state.result) {
+  captureSegment(state2, captureStart, captureEnd, false);
+  if (state2.result) {
     return true;
   }
-  state.kind = _kind;
-  state.result = _result;
+  state2.kind = _kind;
+  state2.result = _result;
   return false;
 }
-function readSingleQuotedScalar(state, nodeIndent) {
+function readSingleQuotedScalar(state2, nodeIndent) {
   var ch, captureStart, captureEnd;
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   if (ch !== 39) {
     return false;
   }
-  state.kind = "scalar";
-  state.result = "";
-  state.position++;
-  captureStart = captureEnd = state.position;
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+  state2.kind = "scalar";
+  state2.result = "";
+  state2.position++;
+  captureStart = captureEnd = state2.position;
+  while ((ch = state2.input.charCodeAt(state2.position)) !== 0) {
     if (ch === 39) {
-      captureSegment(state, captureStart, state.position, true);
-      ch = state.input.charCodeAt(++state.position);
+      captureSegment(state2, captureStart, state2.position, true);
+      ch = state2.input.charCodeAt(++state2.position);
       if (ch === 39) {
-        captureStart = state.position;
-        state.position++;
-        captureEnd = state.position;
+        captureStart = state2.position;
+        state2.position++;
+        captureEnd = state2.position;
       } else {
         return true;
       }
     } else if (is_EOL(ch)) {
-      captureSegment(state, captureStart, captureEnd, true);
-      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-      captureStart = captureEnd = state.position;
-    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
-      throwError(state, "unexpected end of the document within a single quoted scalar");
+      captureSegment(state2, captureStart, captureEnd, true);
+      writeFoldedLines(state2, skipSeparationSpace(state2, false, nodeIndent));
+      captureStart = captureEnd = state2.position;
+    } else if (state2.position === state2.lineStart && testDocumentSeparator(state2)) {
+      throwError(state2, "unexpected end of the document within a single quoted scalar");
     } else {
-      state.position++;
-      captureEnd = state.position;
+      state2.position++;
+      captureEnd = state2.position;
     }
   }
-  throwError(state, "unexpected end of the stream within a single quoted scalar");
+  throwError(state2, "unexpected end of the stream within a single quoted scalar");
 }
-function readDoubleQuotedScalar(state, nodeIndent) {
+function readDoubleQuotedScalar(state2, nodeIndent) {
   var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   if (ch !== 34) {
     return false;
   }
-  state.kind = "scalar";
-  state.result = "";
-  state.position++;
-  captureStart = captureEnd = state.position;
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+  state2.kind = "scalar";
+  state2.result = "";
+  state2.position++;
+  captureStart = captureEnd = state2.position;
+  while ((ch = state2.input.charCodeAt(state2.position)) !== 0) {
     if (ch === 34) {
-      captureSegment(state, captureStart, state.position, true);
-      state.position++;
+      captureSegment(state2, captureStart, state2.position, true);
+      state2.position++;
       return true;
     } else if (ch === 92) {
-      captureSegment(state, captureStart, state.position, true);
-      ch = state.input.charCodeAt(++state.position);
+      captureSegment(state2, captureStart, state2.position, true);
+      ch = state2.input.charCodeAt(++state2.position);
       if (is_EOL(ch)) {
-        skipSeparationSpace(state, false, nodeIndent);
+        skipSeparationSpace(state2, false, nodeIndent);
       } else if (ch < 256 && simpleEscapeCheck[ch]) {
-        state.result += simpleEscapeMap[ch];
-        state.position++;
+        state2.result += simpleEscapeMap[ch];
+        state2.position++;
       } else if ((tmp = escapedHexLen(ch)) > 0) {
         hexLength = tmp;
         hexResult = 0;
         for (; hexLength > 0; hexLength--) {
-          ch = state.input.charCodeAt(++state.position);
+          ch = state2.input.charCodeAt(++state2.position);
           if ((tmp = fromHexCode(ch)) >= 0) {
             hexResult = (hexResult << 4) + tmp;
           } else {
-            throwError(state, "expected hexadecimal character");
+            throwError(state2, "expected hexadecimal character");
           }
         }
-        state.result += charFromCodepoint(hexResult);
-        state.position++;
+        state2.result += charFromCodepoint(hexResult);
+        state2.position++;
       } else {
-        throwError(state, "unknown escape sequence");
+        throwError(state2, "unknown escape sequence");
       }
-      captureStart = captureEnd = state.position;
+      captureStart = captureEnd = state2.position;
     } else if (is_EOL(ch)) {
-      captureSegment(state, captureStart, captureEnd, true);
-      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-      captureStart = captureEnd = state.position;
-    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
-      throwError(state, "unexpected end of the document within a double quoted scalar");
+      captureSegment(state2, captureStart, captureEnd, true);
+      writeFoldedLines(state2, skipSeparationSpace(state2, false, nodeIndent));
+      captureStart = captureEnd = state2.position;
+    } else if (state2.position === state2.lineStart && testDocumentSeparator(state2)) {
+      throwError(state2, "unexpected end of the document within a double quoted scalar");
     } else {
-      state.position++;
-      captureEnd = state.position;
+      state2.position++;
+      captureEnd = state2.position;
     }
   }
-  throwError(state, "unexpected end of the stream within a double quoted scalar");
+  throwError(state2, "unexpected end of the stream within a double quoted scalar");
 }
-function readFlowCollection(state, nodeIndent) {
-  var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch;
-  ch = state.input.charCodeAt(state.position);
+function readFlowCollection(state2, nodeIndent) {
+  var readNext = true, _line, _lineStart, _pos, _tag = state2.tag, _result, _anchor = state2.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch;
+  ch = state2.input.charCodeAt(state2.position);
   if (ch === 91) {
     terminator = 93;
     isMapping = false;
@@ -8199,71 +8209,71 @@ function readFlowCollection(state, nodeIndent) {
   } else {
     return false;
   }
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
+  if (state2.anchor !== null) {
+    state2.anchorMap[state2.anchor] = _result;
   }
-  ch = state.input.charCodeAt(++state.position);
+  ch = state2.input.charCodeAt(++state2.position);
   while (ch !== 0) {
-    skipSeparationSpace(state, true, nodeIndent);
-    ch = state.input.charCodeAt(state.position);
+    skipSeparationSpace(state2, true, nodeIndent);
+    ch = state2.input.charCodeAt(state2.position);
     if (ch === terminator) {
-      state.position++;
-      state.tag = _tag;
-      state.anchor = _anchor;
-      state.kind = isMapping ? "mapping" : "sequence";
-      state.result = _result;
+      state2.position++;
+      state2.tag = _tag;
+      state2.anchor = _anchor;
+      state2.kind = isMapping ? "mapping" : "sequence";
+      state2.result = _result;
       return true;
     } else if (!readNext) {
-      throwError(state, "missed comma between flow collection entries");
+      throwError(state2, "missed comma between flow collection entries");
     } else if (ch === 44) {
-      throwError(state, "expected the node content, but found ','");
+      throwError(state2, "expected the node content, but found ','");
     }
     keyTag = keyNode = valueNode = null;
     isPair = isExplicitPair = false;
     if (ch === 63) {
-      following = state.input.charCodeAt(state.position + 1);
+      following = state2.input.charCodeAt(state2.position + 1);
       if (is_WS_OR_EOL(following)) {
         isPair = isExplicitPair = true;
-        state.position++;
-        skipSeparationSpace(state, true, nodeIndent);
-      }
-    }
-    _line = state.line;
-    _lineStart = state.lineStart;
-    _pos = state.position;
-    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-    keyTag = state.tag;
-    keyNode = state.result;
-    skipSeparationSpace(state, true, nodeIndent);
-    ch = state.input.charCodeAt(state.position);
-    if ((isExplicitPair || state.line === _line) && ch === 58) {
+        state2.position++;
+        skipSeparationSpace(state2, true, nodeIndent);
+      }
+    }
+    _line = state2.line;
+    _lineStart = state2.lineStart;
+    _pos = state2.position;
+    composeNode(state2, nodeIndent, CONTEXT_FLOW_IN, false, true);
+    keyTag = state2.tag;
+    keyNode = state2.result;
+    skipSeparationSpace(state2, true, nodeIndent);
+    ch = state2.input.charCodeAt(state2.position);
+    if ((isExplicitPair || state2.line === _line) && ch === 58) {
       isPair = true;
-      ch = state.input.charCodeAt(++state.position);
-      skipSeparationSpace(state, true, nodeIndent);
-      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-      valueNode = state.result;
+      ch = state2.input.charCodeAt(++state2.position);
+      skipSeparationSpace(state2, true, nodeIndent);
+      composeNode(state2, nodeIndent, CONTEXT_FLOW_IN, false, true);
+      valueNode = state2.result;
     }
     if (isMapping) {
-      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
+      storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
     } else if (isPair) {
-      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
+      _result.push(storeMappingPair(state2, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
     } else {
       _result.push(keyNode);
     }
-    skipSeparationSpace(state, true, nodeIndent);
-    ch = state.input.charCodeAt(state.position);
+    skipSeparationSpace(state2, true, nodeIndent);
+    ch = state2.input.charCodeAt(state2.position);
     if (ch === 44) {
       readNext = true;
-      ch = state.input.charCodeAt(++state.position);
+      ch = state2.input.charCodeAt(++state2.position);
     } else {
       readNext = false;
     }
   }
-  throwError(state, "unexpected end of the stream within a flow collection");
+  throwError(state2, "unexpected end of the stream within a flow collection");
 }
-function readBlockScalar(state, nodeIndent) {
+function readBlockScalar(state2, nodeIndent) {
   var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch;
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   if (ch === 124) {
     folding = false;
   } else if (ch === 62) {
@@ -8271,24 +8281,24 @@ function readBlockScalar(state, nodeIndent) {
   } else {
     return false;
   }
-  state.kind = "scalar";
-  state.result = "";
+  state2.kind = "scalar";
+  state2.result = "";
   while (ch !== 0) {
-    ch = state.input.charCodeAt(++state.position);
+    ch = state2.input.charCodeAt(++state2.position);
     if (ch === 43 || ch === 45) {
       if (CHOMPING_CLIP === chomping) {
         chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
       } else {
-        throwError(state, "repeat of a chomping mode identifier");
+        throwError(state2, "repeat of a chomping mode identifier");
       }
     } else if ((tmp = fromDecimalCode(ch)) >= 0) {
       if (tmp === 0) {
-        throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+        throwError(state2, "bad explicit indentation width of a block scalar; it cannot be less than one");
       } else if (!detectedIndent) {
         textIndent = nodeIndent + tmp - 1;
         detectedIndent = true;
       } else {
-        throwError(state, "repeat of an indentation width identifier");
+        throwError(state2, "repeat of an indentation width identifier");
       }
     } else {
       break;
@@ -8296,35 +8306,35 @@ function readBlockScalar(state, nodeIndent) {
   }
   if (is_WHITE_SPACE(ch)) {
     do {
-      ch = state.input.charCodeAt(++state.position);
+      ch = state2.input.charCodeAt(++state2.position);
     } while (is_WHITE_SPACE(ch));
     if (ch === 35) {
       do {
-        ch = state.input.charCodeAt(++state.position);
+        ch = state2.input.charCodeAt(++state2.position);
       } while (!is_EOL(ch) && ch !== 0);
     }
   }
   while (ch !== 0) {
-    readLineBreak(state);
-    state.lineIndent = 0;
-    ch = state.input.charCodeAt(state.position);
-    while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
-      state.lineIndent++;
-      ch = state.input.charCodeAt(++state.position);
+    readLineBreak(state2);
+    state2.lineIndent = 0;
+    ch = state2.input.charCodeAt(state2.position);
+    while ((!detectedIndent || state2.lineIndent < textIndent) && ch === 32) {
+      state2.lineIndent++;
+      ch = state2.input.charCodeAt(++state2.position);
     }
-    if (!detectedIndent && state.lineIndent > textIndent) {
-      textIndent = state.lineIndent;
+    if (!detectedIndent && state2.lineIndent > textIndent) {
+      textIndent = state2.lineIndent;
     }
     if (is_EOL(ch)) {
       emptyLines++;
       continue;
     }
-    if (state.lineIndent < textIndent) {
+    if (state2.lineIndent < textIndent) {
       if (chomping === CHOMPING_KEEP) {
-        state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+        state2.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
       } else if (chomping === CHOMPING_CLIP) {
         if (didReadContent) {
-          state.result += "\n";
+          state2.result += "\n";
         }
       }
       break;
@@ -8332,97 +8342,97 @@ function readBlockScalar(state, nodeIndent) {
     if (folding) {
       if (is_WHITE_SPACE(ch)) {
         atMoreIndented = true;
-        state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+        state2.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
       } else if (atMoreIndented) {
         atMoreIndented = false;
-        state.result += common.repeat("\n", emptyLines + 1);
+        state2.result += common.repeat("\n", emptyLines + 1);
       } else if (emptyLines === 0) {
         if (didReadContent) {
-          state.result += " ";
+          state2.result += " ";
         }
       } else {
-        state.result += common.repeat("\n", emptyLines);
+        state2.result += common.repeat("\n", emptyLines);
       }
     } else {
-      state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+      state2.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
     }
     didReadContent = true;
     detectedIndent = true;
     emptyLines = 0;
-    captureStart = state.position;
+    captureStart = state2.position;
     while (!is_EOL(ch) && ch !== 0) {
-      ch = state.input.charCodeAt(++state.position);
+      ch = state2.input.charCodeAt(++state2.position);
     }
-    captureSegment(state, captureStart, state.position, false);
+    captureSegment(state2, captureStart, state2.position, false);
   }
   return true;
 }
-function readBlockSequence(state, nodeIndent) {
-  var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch;
-  if (state.firstTabInLine !== -1) return false;
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
+function readBlockSequence(state2, nodeIndent) {
+  var _line, _tag = state2.tag, _anchor = state2.anchor, _result = [], following, detected = false, ch;
+  if (state2.firstTabInLine !== -1) return false;
+  if (state2.anchor !== null) {
+    state2.anchorMap[state2.anchor] = _result;
   }
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   while (ch !== 0) {
-    if (state.firstTabInLine !== -1) {
-      state.position = state.firstTabInLine;
-      throwError(state, "tab characters must not be used in indentation");
+    if (state2.firstTabInLine !== -1) {
+      state2.position = state2.firstTabInLine;
+      throwError(state2, "tab characters must not be used in indentation");
     }
     if (ch !== 45) {
       break;
     }
-    following = state.input.charCodeAt(state.position + 1);
+    following = state2.input.charCodeAt(state2.position + 1);
     if (!is_WS_OR_EOL(following)) {
       break;
     }
     detected = true;
-    state.position++;
-    if (skipSeparationSpace(state, true, -1)) {
-      if (state.lineIndent <= nodeIndent) {
+    state2.position++;
+    if (skipSeparationSpace(state2, true, -1)) {
+      if (state2.lineIndent <= nodeIndent) {
         _result.push(null);
-        ch = state.input.charCodeAt(state.position);
+        ch = state2.input.charCodeAt(state2.position);
         continue;
       }
     }
-    _line = state.line;
-    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
-    _result.push(state.result);
-    skipSeparationSpace(state, true, -1);
-    ch = state.input.charCodeAt(state.position);
-    if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
-      throwError(state, "bad indentation of a sequence entry");
-    } else if (state.lineIndent < nodeIndent) {
+    _line = state2.line;
+    composeNode(state2, nodeIndent, CONTEXT_BLOCK_IN, false, true);
+    _result.push(state2.result);
+    skipSeparationSpace(state2, true, -1);
+    ch = state2.input.charCodeAt(state2.position);
+    if ((state2.line === _line || state2.lineIndent > nodeIndent) && ch !== 0) {
+      throwError(state2, "bad indentation of a sequence entry");
+    } else if (state2.lineIndent < nodeIndent) {
       break;
     }
   }
   if (detected) {
-    state.tag = _tag;
-    state.anchor = _anchor;
-    state.kind = "sequence";
-    state.result = _result;
+    state2.tag = _tag;
+    state2.anchor = _anchor;
+    state2.kind = "sequence";
+    state2.result = _result;
     return true;
   }
   return false;
 }
-function readBlockMapping(state, nodeIndent, flowIndent) {
-  var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
-  if (state.firstTabInLine !== -1) return false;
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
+function readBlockMapping(state2, nodeIndent, flowIndent) {
+  var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state2.tag, _anchor = state2.anchor, _result = {}, overridableKeys = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
+  if (state2.firstTabInLine !== -1) return false;
+  if (state2.anchor !== null) {
+    state2.anchorMap[state2.anchor] = _result;
   }
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   while (ch !== 0) {
-    if (!atExplicitKey && state.firstTabInLine !== -1) {
-      state.position = state.firstTabInLine;
-      throwError(state, "tab characters must not be used in indentation");
+    if (!atExplicitKey && state2.firstTabInLine !== -1) {
+      state2.position = state2.firstTabInLine;
+      throwError(state2, "tab characters must not be used in indentation");
     }
-    following = state.input.charCodeAt(state.position + 1);
-    _line = state.line;
+    following = state2.input.charCodeAt(state2.position + 1);
+    _line = state2.line;
     if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) {
       if (ch === 63) {
         if (atExplicitKey) {
-          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+          storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
           keyTag = keyNode = valueNode = null;
         }
         detected = true;
@@ -8432,229 +8442,229 @@ function readBlockMapping(state, nodeIndent, flowIndent) {
         atExplicitKey = false;
         allowCompact = true;
       } else {
-        throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
+        throwError(state2, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
       }
-      state.position += 1;
+      state2.position += 1;
       ch = following;
     } else {
-      _keyLine = state.line;
-      _keyLineStart = state.lineStart;
-      _keyPos = state.position;
-      if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
+      _keyLine = state2.line;
+      _keyLineStart = state2.lineStart;
+      _keyPos = state2.position;
+      if (!composeNode(state2, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
         break;
       }
-      if (state.line === _line) {
-        ch = state.input.charCodeAt(state.position);
+      if (state2.line === _line) {
+        ch = state2.input.charCodeAt(state2.position);
         while (is_WHITE_SPACE(ch)) {
-          ch = state.input.charCodeAt(++state.position);
+          ch = state2.input.charCodeAt(++state2.position);
         }
         if (ch === 58) {
-          ch = state.input.charCodeAt(++state.position);
+          ch = state2.input.charCodeAt(++state2.position);
           if (!is_WS_OR_EOL(ch)) {
-            throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
+            throwError(state2, "a whitespace character is expected after the key-value separator within a block mapping");
           }
           if (atExplicitKey) {
-            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+            storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
             keyTag = keyNode = valueNode = null;
           }
           detected = true;
           atExplicitKey = false;
           allowCompact = false;
-          keyTag = state.tag;
-          keyNode = state.result;
+          keyTag = state2.tag;
+          keyNode = state2.result;
         } else if (detected) {
-          throwError(state, "can not read an implicit mapping pair; a colon is missed");
+          throwError(state2, "can not read an implicit mapping pair; a colon is missed");
         } else {
-          state.tag = _tag;
-          state.anchor = _anchor;
+          state2.tag = _tag;
+          state2.anchor = _anchor;
           return true;
         }
       } else if (detected) {
-        throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
+        throwError(state2, "can not read a block mapping entry; a multiline key may not be an implicit key");
       } else {
-        state.tag = _tag;
-        state.anchor = _anchor;
+        state2.tag = _tag;
+        state2.anchor = _anchor;
         return true;
       }
     }
-    if (state.line === _line || state.lineIndent > nodeIndent) {
+    if (state2.line === _line || state2.lineIndent > nodeIndent) {
       if (atExplicitKey) {
-        _keyLine = state.line;
-        _keyLineStart = state.lineStart;
-        _keyPos = state.position;
+        _keyLine = state2.line;
+        _keyLineStart = state2.lineStart;
+        _keyPos = state2.position;
       }
-      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+      if (composeNode(state2, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
         if (atExplicitKey) {
-          keyNode = state.result;
+          keyNode = state2.result;
         } else {
-          valueNode = state.result;
+          valueNode = state2.result;
         }
       }
       if (!atExplicitKey) {
-        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
+        storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
         keyTag = keyNode = valueNode = null;
       }
-      skipSeparationSpace(state, true, -1);
-      ch = state.input.charCodeAt(state.position);
+      skipSeparationSpace(state2, true, -1);
+      ch = state2.input.charCodeAt(state2.position);
     }
-    if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
-      throwError(state, "bad indentation of a mapping entry");
-    } else if (state.lineIndent < nodeIndent) {
+    if ((state2.line === _line || state2.lineIndent > nodeIndent) && ch !== 0) {
+      throwError(state2, "bad indentation of a mapping entry");
+    } else if (state2.lineIndent < nodeIndent) {
       break;
     }
   }
   if (atExplicitKey) {
-    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+    storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
   }
   if (detected) {
-    state.tag = _tag;
-    state.anchor = _anchor;
-    state.kind = "mapping";
-    state.result = _result;
+    state2.tag = _tag;
+    state2.anchor = _anchor;
+    state2.kind = "mapping";
+    state2.result = _result;
   }
   return detected;
 }
-function readTagProperty(state) {
+function readTagProperty(state2) {
   var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch;
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   if (ch !== 33) return false;
-  if (state.tag !== null) {
-    throwError(state, "duplication of a tag property");
+  if (state2.tag !== null) {
+    throwError(state2, "duplication of a tag property");
   }
-  ch = state.input.charCodeAt(++state.position);
+  ch = state2.input.charCodeAt(++state2.position);
   if (ch === 60) {
     isVerbatim = true;
-    ch = state.input.charCodeAt(++state.position);
+    ch = state2.input.charCodeAt(++state2.position);
   } else if (ch === 33) {
     isNamed = true;
     tagHandle = "!!";
-    ch = state.input.charCodeAt(++state.position);
+    ch = state2.input.charCodeAt(++state2.position);
   } else {
     tagHandle = "!";
   }
-  _position = state.position;
+  _position = state2.position;
   if (isVerbatim) {
     do {
-      ch = state.input.charCodeAt(++state.position);
+      ch = state2.input.charCodeAt(++state2.position);
     } while (ch !== 0 && ch !== 62);
-    if (state.position < state.length) {
-      tagName = state.input.slice(_position, state.position);
-      ch = state.input.charCodeAt(++state.position);
+    if (state2.position < state2.length) {
+      tagName = state2.input.slice(_position, state2.position);
+      ch = state2.input.charCodeAt(++state2.position);
     } else {
-      throwError(state, "unexpected end of the stream within a verbatim tag");
+      throwError(state2, "unexpected end of the stream within a verbatim tag");
     }
   } else {
     while (ch !== 0 && !is_WS_OR_EOL(ch)) {
       if (ch === 33) {
         if (!isNamed) {
-          tagHandle = state.input.slice(_position - 1, state.position + 1);
+          tagHandle = state2.input.slice(_position - 1, state2.position + 1);
           if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
-            throwError(state, "named tag handle cannot contain such characters");
+            throwError(state2, "named tag handle cannot contain such characters");
           }
           isNamed = true;
-          _position = state.position + 1;
+          _position = state2.position + 1;
         } else {
-          throwError(state, "tag suffix cannot contain exclamation marks");
+          throwError(state2, "tag suffix cannot contain exclamation marks");
         }
       }
-      ch = state.input.charCodeAt(++state.position);
+      ch = state2.input.charCodeAt(++state2.position);
     }
-    tagName = state.input.slice(_position, state.position);
+    tagName = state2.input.slice(_position, state2.position);
     if (PATTERN_FLOW_INDICATORS.test(tagName)) {
-      throwError(state, "tag suffix cannot contain flow indicator characters");
+      throwError(state2, "tag suffix cannot contain flow indicator characters");
     }
   }
   if (tagName && !PATTERN_TAG_URI.test(tagName)) {
-    throwError(state, "tag name cannot contain such characters: " + tagName);
+    throwError(state2, "tag name cannot contain such characters: " + tagName);
   }
   try {
     tagName = decodeURIComponent(tagName);
   } catch (err) {
-    throwError(state, "tag name is malformed: " + tagName);
+    throwError(state2, "tag name is malformed: " + tagName);
   }
   if (isVerbatim) {
-    state.tag = tagName;
-  } else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) {
-    state.tag = state.tagMap[tagHandle] + tagName;
+    state2.tag = tagName;
+  } else if (_hasOwnProperty$1.call(state2.tagMap, tagHandle)) {
+    state2.tag = state2.tagMap[tagHandle] + tagName;
   } else if (tagHandle === "!") {
-    state.tag = "!" + tagName;
+    state2.tag = "!" + tagName;
   } else if (tagHandle === "!!") {
-    state.tag = "tag:yaml.org,2002:" + tagName;
+    state2.tag = "tag:yaml.org,2002:" + tagName;
   } else {
-    throwError(state, 'undeclared tag handle "' + tagHandle + '"');
+    throwError(state2, 'undeclared tag handle "' + tagHandle + '"');
   }
   return true;
 }
-function readAnchorProperty(state) {
+function readAnchorProperty(state2) {
   var _position, ch;
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   if (ch !== 38) return false;
-  if (state.anchor !== null) {
-    throwError(state, "duplication of an anchor property");
+  if (state2.anchor !== null) {
+    throwError(state2, "duplication of an anchor property");
   }
-  ch = state.input.charCodeAt(++state.position);
-  _position = state.position;
+  ch = state2.input.charCodeAt(++state2.position);
+  _position = state2.position;
   while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
-    ch = state.input.charCodeAt(++state.position);
+    ch = state2.input.charCodeAt(++state2.position);
   }
-  if (state.position === _position) {
-    throwError(state, "name of an anchor node must contain at least one character");
+  if (state2.position === _position) {
+    throwError(state2, "name of an anchor node must contain at least one character");
   }
-  state.anchor = state.input.slice(_position, state.position);
+  state2.anchor = state2.input.slice(_position, state2.position);
   return true;
 }
-function readAlias(state) {
+function readAlias(state2) {
   var _position, alias, ch;
-  ch = state.input.charCodeAt(state.position);
+  ch = state2.input.charCodeAt(state2.position);
   if (ch !== 42) return false;
-  ch = state.input.charCodeAt(++state.position);
-  _position = state.position;
+  ch = state2.input.charCodeAt(++state2.position);
+  _position = state2.position;
   while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
-    ch = state.input.charCodeAt(++state.position);
+    ch = state2.input.charCodeAt(++state2.position);
   }
-  if (state.position === _position) {
-    throwError(state, "name of an alias node must contain at least one character");
+  if (state2.position === _position) {
+    throwError(state2, "name of an alias node must contain at least one character");
   }
-  alias = state.input.slice(_position, state.position);
-  if (!_hasOwnProperty$1.call(state.anchorMap, alias)) {
-    throwError(state, 'unidentified alias "' + alias + '"');
+  alias = state2.input.slice(_position, state2.position);
+  if (!_hasOwnProperty$1.call(state2.anchorMap, alias)) {
+    throwError(state2, 'unidentified alias "' + alias + '"');
   }
-  state.result = state.anchorMap[alias];
-  skipSeparationSpace(state, true, -1);
+  state2.result = state2.anchorMap[alias];
+  skipSeparationSpace(state2, true, -1);
   return true;
 }
-function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+function composeNode(state2, parentIndent, nodeContext, allowToSeek, allowCompact) {
   var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type2, flowIndent, blockIndent;
-  if (state.listener !== null) {
-    state.listener("open", state);
+  if (state2.listener !== null) {
+    state2.listener("open", state2);
   }
-  state.tag = null;
-  state.anchor = null;
-  state.kind = null;
-  state.result = null;
+  state2.tag = null;
+  state2.anchor = null;
+  state2.kind = null;
+  state2.result = null;
   allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
   if (allowToSeek) {
-    if (skipSeparationSpace(state, true, -1)) {
+    if (skipSeparationSpace(state2, true, -1)) {
       atNewLine = true;
-      if (state.lineIndent > parentIndent) {
+      if (state2.lineIndent > parentIndent) {
         indentStatus = 1;
-      } else if (state.lineIndent === parentIndent) {
+      } else if (state2.lineIndent === parentIndent) {
         indentStatus = 0;
-      } else if (state.lineIndent < parentIndent) {
+      } else if (state2.lineIndent < parentIndent) {
         indentStatus = -1;
       }
     }
   }
   if (indentStatus === 1) {
-    while (readTagProperty(state) || readAnchorProperty(state)) {
-      if (skipSeparationSpace(state, true, -1)) {
+    while (readTagProperty(state2) || readAnchorProperty(state2)) {
+      if (skipSeparationSpace(state2, true, -1)) {
         atNewLine = true;
         allowBlockCollections = allowBlockStyles;
-        if (state.lineIndent > parentIndent) {
+        if (state2.lineIndent > parentIndent) {
           indentStatus = 1;
-        } else if (state.lineIndent === parentIndent) {
+        } else if (state2.lineIndent === parentIndent) {
           indentStatus = 0;
-        } else if (state.lineIndent < parentIndent) {
+        } else if (state2.lineIndent < parentIndent) {
           indentStatus = -1;
         }
       } else {
@@ -8671,153 +8681,153 @@ function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact
     } else {
       flowIndent = parentIndent + 1;
     }
-    blockIndent = state.position - state.lineStart;
+    blockIndent = state2.position - state2.lineStart;
     if (indentStatus === 1) {
-      if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) {
+      if (allowBlockCollections && (readBlockSequence(state2, blockIndent) || readBlockMapping(state2, blockIndent, flowIndent)) || readFlowCollection(state2, flowIndent)) {
         hasContent = true;
       } else {
-        if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) {
+        if (allowBlockScalars && readBlockScalar(state2, flowIndent) || readSingleQuotedScalar(state2, flowIndent) || readDoubleQuotedScalar(state2, flowIndent)) {
           hasContent = true;
-        } else if (readAlias(state)) {
+        } else if (readAlias(state2)) {
           hasContent = true;
-          if (state.tag !== null || state.anchor !== null) {
-            throwError(state, "alias node should not have any properties");
+          if (state2.tag !== null || state2.anchor !== null) {
+            throwError(state2, "alias node should not have any properties");
           }
-        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+        } else if (readPlainScalar(state2, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
           hasContent = true;
-          if (state.tag === null) {
-            state.tag = "?";
+          if (state2.tag === null) {
+            state2.tag = "?";
           }
         }
-        if (state.anchor !== null) {
-          state.anchorMap[state.anchor] = state.result;
+        if (state2.anchor !== null) {
+          state2.anchorMap[state2.anchor] = state2.result;
         }
       }
     } else if (indentStatus === 0) {
-      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+      hasContent = allowBlockCollections && readBlockSequence(state2, blockIndent);
     }
   }
-  if (state.tag === null) {
-    if (state.anchor !== null) {
-      state.anchorMap[state.anchor] = state.result;
+  if (state2.tag === null) {
+    if (state2.anchor !== null) {
+      state2.anchorMap[state2.anchor] = state2.result;
     }
-  } else if (state.tag === "?") {
-    if (state.result !== null && state.kind !== "scalar") {
-      throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+  } else if (state2.tag === "?") {
+    if (state2.result !== null && state2.kind !== "scalar") {
+      throwError(state2, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state2.kind + '"');
     }
-    for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
-      type2 = state.implicitTypes[typeIndex];
-      if (type2.resolve(state.result)) {
-        state.result = type2.construct(state.result);
-        state.tag = type2.tag;
-        if (state.anchor !== null) {
-          state.anchorMap[state.anchor] = state.result;
+    for (typeIndex = 0, typeQuantity = state2.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
+      type2 = state2.implicitTypes[typeIndex];
+      if (type2.resolve(state2.result)) {
+        state2.result = type2.construct(state2.result);
+        state2.tag = type2.tag;
+        if (state2.anchor !== null) {
+          state2.anchorMap[state2.anchor] = state2.result;
         }
         break;
       }
     }
-  } else if (state.tag !== "!") {
-    if (_hasOwnProperty$1.call(state.typeMap[state.kind || "fallback"], state.tag)) {
-      type2 = state.typeMap[state.kind || "fallback"][state.tag];
+  } else if (state2.tag !== "!") {
+    if (_hasOwnProperty$1.call(state2.typeMap[state2.kind || "fallback"], state2.tag)) {
+      type2 = state2.typeMap[state2.kind || "fallback"][state2.tag];
     } else {
       type2 = null;
-      typeList = state.typeMap.multi[state.kind || "fallback"];
+      typeList = state2.typeMap.multi[state2.kind || "fallback"];
       for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
-        if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
+        if (state2.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
           type2 = typeList[typeIndex];
           break;
         }
       }
     }
     if (!type2) {
-      throwError(state, "unknown tag !<" + state.tag + ">");
+      throwError(state2, "unknown tag !<" + state2.tag + ">");
     }
-    if (state.result !== null && type2.kind !== state.kind) {
-      throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type2.kind + '", not "' + state.kind + '"');
+    if (state2.result !== null && type2.kind !== state2.kind) {
+      throwError(state2, "unacceptable node kind for !<" + state2.tag + '> tag; it should be "' + type2.kind + '", not "' + state2.kind + '"');
     }
-    if (!type2.resolve(state.result, state.tag)) {
-      throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+    if (!type2.resolve(state2.result, state2.tag)) {
+      throwError(state2, "cannot resolve a node with !<" + state2.tag + "> explicit tag");
     } else {
-      state.result = type2.construct(state.result, state.tag);
-      if (state.anchor !== null) {
-        state.anchorMap[state.anchor] = state.result;
+      state2.result = type2.construct(state2.result, state2.tag);
+      if (state2.anchor !== null) {
+        state2.anchorMap[state2.anchor] = state2.result;
       }
     }
   }
-  if (state.listener !== null) {
-    state.listener("close", state);
+  if (state2.listener !== null) {
+    state2.listener("close", state2);
   }
-  return state.tag !== null || state.anchor !== null || hasContent;
+  return state2.tag !== null || state2.anchor !== null || hasContent;
 }
-function readDocument(state) {
-  var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
-  state.version = null;
-  state.checkLineBreaks = state.legacy;
-  state.tagMap = /* @__PURE__ */ Object.create(null);
-  state.anchorMap = /* @__PURE__ */ Object.create(null);
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    skipSeparationSpace(state, true, -1);
-    ch = state.input.charCodeAt(state.position);
-    if (state.lineIndent > 0 || ch !== 37) {
+function readDocument(state2) {
+  var documentStart = state2.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
+  state2.version = null;
+  state2.checkLineBreaks = state2.legacy;
+  state2.tagMap = /* @__PURE__ */ Object.create(null);
+  state2.anchorMap = /* @__PURE__ */ Object.create(null);
+  while ((ch = state2.input.charCodeAt(state2.position)) !== 0) {
+    skipSeparationSpace(state2, true, -1);
+    ch = state2.input.charCodeAt(state2.position);
+    if (state2.lineIndent > 0 || ch !== 37) {
       break;
     }
     hasDirectives = true;
-    ch = state.input.charCodeAt(++state.position);
-    _position = state.position;
+    ch = state2.input.charCodeAt(++state2.position);
+    _position = state2.position;
     while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-      ch = state.input.charCodeAt(++state.position);
+      ch = state2.input.charCodeAt(++state2.position);
     }
-    directiveName = state.input.slice(_position, state.position);
+    directiveName = state2.input.slice(_position, state2.position);
     directiveArgs = [];
     if (directiveName.length < 1) {
-      throwError(state, "directive name must not be less than one character in length");
+      throwError(state2, "directive name must not be less than one character in length");
     }
     while (ch !== 0) {
       while (is_WHITE_SPACE(ch)) {
-        ch = state.input.charCodeAt(++state.position);
+        ch = state2.input.charCodeAt(++state2.position);
       }
       if (ch === 35) {
         do {
-          ch = state.input.charCodeAt(++state.position);
+          ch = state2.input.charCodeAt(++state2.position);
         } while (ch !== 0 && !is_EOL(ch));
         break;
       }
       if (is_EOL(ch)) break;
-      _position = state.position;
+      _position = state2.position;
       while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-        ch = state.input.charCodeAt(++state.position);
+        ch = state2.input.charCodeAt(++state2.position);
       }
-      directiveArgs.push(state.input.slice(_position, state.position));
+      directiveArgs.push(state2.input.slice(_position, state2.position));
     }
-    if (ch !== 0) readLineBreak(state);
+    if (ch !== 0) readLineBreak(state2);
     if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) {
-      directiveHandlers[directiveName](state, directiveName, directiveArgs);
+      directiveHandlers[directiveName](state2, directiveName, directiveArgs);
     } else {
-      throwWarning(state, 'unknown document directive "' + directiveName + '"');
+      throwWarning(state2, 'unknown document directive "' + directiveName + '"');
     }
   }
-  skipSeparationSpace(state, true, -1);
-  if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
-    state.position += 3;
-    skipSeparationSpace(state, true, -1);
+  skipSeparationSpace(state2, true, -1);
+  if (state2.lineIndent === 0 && state2.input.charCodeAt(state2.position) === 45 && state2.input.charCodeAt(state2.position + 1) === 45 && state2.input.charCodeAt(state2.position + 2) === 45) {
+    state2.position += 3;
+    skipSeparationSpace(state2, true, -1);
   } else if (hasDirectives) {
-    throwError(state, "directives end mark is expected");
+    throwError(state2, "directives end mark is expected");
   }
-  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
-  skipSeparationSpace(state, true, -1);
-  if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
-    throwWarning(state, "non-ASCII line breaks are interpreted as content");
+  composeNode(state2, state2.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+  skipSeparationSpace(state2, true, -1);
+  if (state2.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state2.input.slice(documentStart, state2.position))) {
+    throwWarning(state2, "non-ASCII line breaks are interpreted as content");
   }
-  state.documents.push(state.result);
-  if (state.position === state.lineStart && testDocumentSeparator(state)) {
-    if (state.input.charCodeAt(state.position) === 46) {
-      state.position += 3;
-      skipSeparationSpace(state, true, -1);
+  state2.documents.push(state2.result);
+  if (state2.position === state2.lineStart && testDocumentSeparator(state2)) {
+    if (state2.input.charCodeAt(state2.position) === 46) {
+      state2.position += 3;
+      skipSeparationSpace(state2, true, -1);
     }
     return;
   }
-  if (state.position < state.length - 1) {
-    throwError(state, "end of the stream or a document separator is expected");
+  if (state2.position < state2.length - 1) {
+    throwError(state2, "end of the stream or a document separator is expected");
   } else {
     return;
   }
@@ -8833,21 +8843,21 @@ function loadDocuments(input, options) {
       input = input.slice(1);
     }
   }
-  var state = new State$1(input, options);
+  var state2 = new State$1(input, options);
   var nullpos = input.indexOf("\0");
   if (nullpos !== -1) {
-    state.position = nullpos;
-    throwError(state, "null byte is not allowed in input");
+    state2.position = nullpos;
+    throwError(state2, "null byte is not allowed in input");
   }
-  state.input += "\0";
-  while (state.input.charCodeAt(state.position) === 32) {
-    state.lineIndent += 1;
-    state.position += 1;
+  state2.input += "\0";
+  while (state2.input.charCodeAt(state2.position) === 32) {
+    state2.lineIndent += 1;
+    state2.position += 1;
   }
-  while (state.position < state.length - 1) {
-    readDocument(state);
+  while (state2.position < state2.length - 1) {
+    readDocument(state2);
   }
-  return state.documents;
+  return state2.documents;
 }
 function loadAll$1(input, iterator, options) {
   if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
@@ -9015,13 +9025,13 @@ function indentString(string, spaces) {
   }
   return result;
 }
-function generateNextLine(state, level) {
-  return "\n" + common.repeat(" ", state.indent * level);
+function generateNextLine(state2, level) {
+  return "\n" + common.repeat(" ", state2.indent * level);
 }
-function testImplicitResolving(state, str2) {
+function testImplicitResolving(state2, str2) {
   var index, length, type2;
-  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
-    type2 = state.implicitTypes[index];
+  for (index = 0, length = state2.implicitTypes.length; index < length; index += 1) {
+    type2 = state2.implicitTypes[index];
     if (type2.resolve(str2)) {
       return true;
     }
@@ -9123,30 +9133,30 @@ function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, te
   }
   return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
 }
-function writeScalar(state, string, level, iskey, inblock) {
-  state.dump = (function() {
+function writeScalar(state2, string, level, iskey, inblock) {
+  state2.dump = (function() {
     if (string.length === 0) {
-      return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
+      return state2.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
     }
-    if (!state.noCompatMode) {
+    if (!state2.noCompatMode) {
       if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
-        return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string + '"' : "'" + string + "'";
+        return state2.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string + '"' : "'" + string + "'";
       }
     }
-    var indent = state.indent * Math.max(1, level);
-    var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
-    var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
+    var indent = state2.indent * Math.max(1, level);
+    var lineWidth = state2.lineWidth === -1 ? -1 : Math.max(Math.min(state2.lineWidth, 40), state2.lineWidth - indent);
+    var singleLineOnly = iskey || state2.flowLevel > -1 && level >= state2.flowLevel;
     function testAmbiguity(string2) {
-      return testImplicitResolving(state, string2);
+      return testImplicitResolving(state2, string2);
     }
     switch (chooseScalarStyle(
       string,
       singleLineOnly,
-      state.indent,
+      state2.indent,
       lineWidth,
       testAmbiguity,
-      state.quotingType,
-      state.forceQuotes && !iskey,
+      state2.quotingType,
+      state2.forceQuotes && !iskey,
       inblock
     )) {
       case STYLE_PLAIN:
@@ -9154,9 +9164,9 @@ function writeScalar(state, string, level, iskey, inblock) {
       case STYLE_SINGLE:
         return "'" + string.replace(/'/g, "''") + "'";
       case STYLE_LITERAL:
-        return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
+        return "|" + blockHeader(string, state2.indent) + dropEndingNewline(indentString(string, indent));
       case STYLE_FOLDED:
-        return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
+        return ">" + blockHeader(string, state2.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
       case STYLE_DOUBLE:
         return '"' + escapeString(string) + '"';
       default:
@@ -9232,133 +9242,133 @@ function escapeString(string) {
   }
   return result;
 }
-function writeFlowSequence(state, level, object) {
-  var _result = "", _tag = state.tag, index, length, value;
+function writeFlowSequence(state2, level, object) {
+  var _result = "", _tag = state2.tag, index, length, value;
   for (index = 0, length = object.length; index < length; index += 1) {
     value = object[index];
-    if (state.replacer) {
-      value = state.replacer.call(object, String(index), value);
+    if (state2.replacer) {
+      value = state2.replacer.call(object, String(index), value);
     }
-    if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
-      if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
-      _result += state.dump;
+    if (writeNode(state2, level, value, false, false) || typeof value === "undefined" && writeNode(state2, level, null, false, false)) {
+      if (_result !== "") _result += "," + (!state2.condenseFlow ? " " : "");
+      _result += state2.dump;
     }
   }
-  state.tag = _tag;
-  state.dump = "[" + _result + "]";
+  state2.tag = _tag;
+  state2.dump = "[" + _result + "]";
 }
-function writeBlockSequence(state, level, object, compact) {
-  var _result = "", _tag = state.tag, index, length, value;
+function writeBlockSequence(state2, level, object, compact) {
+  var _result = "", _tag = state2.tag, index, length, value;
   for (index = 0, length = object.length; index < length; index += 1) {
     value = object[index];
-    if (state.replacer) {
-      value = state.replacer.call(object, String(index), value);
+    if (state2.replacer) {
+      value = state2.replacer.call(object, String(index), value);
     }
-    if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
+    if (writeNode(state2, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state2, level + 1, null, true, true, false, true)) {
       if (!compact || _result !== "") {
-        _result += generateNextLine(state, level);
+        _result += generateNextLine(state2, level);
       }
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+      if (state2.dump && CHAR_LINE_FEED === state2.dump.charCodeAt(0)) {
         _result += "-";
       } else {
         _result += "- ";
       }
-      _result += state.dump;
+      _result += state2.dump;
     }
   }
-  state.tag = _tag;
-  state.dump = _result || "[]";
+  state2.tag = _tag;
+  state2.dump = _result || "[]";
 }
-function writeFlowMapping(state, level, object) {
-  var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer;
+function writeFlowMapping(state2, level, object) {
+  var _result = "", _tag = state2.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer;
   for (index = 0, length = objectKeyList.length; index < length; index += 1) {
     pairBuffer = "";
     if (_result !== "") pairBuffer += ", ";
-    if (state.condenseFlow) pairBuffer += '"';
+    if (state2.condenseFlow) pairBuffer += '"';
     objectKey = objectKeyList[index];
     objectValue = object[objectKey];
-    if (state.replacer) {
-      objectValue = state.replacer.call(object, objectKey, objectValue);
+    if (state2.replacer) {
+      objectValue = state2.replacer.call(object, objectKey, objectValue);
     }
-    if (!writeNode(state, level, objectKey, false, false)) {
+    if (!writeNode(state2, level, objectKey, false, false)) {
       continue;
     }
-    if (state.dump.length > 1024) pairBuffer += "? ";
-    pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
-    if (!writeNode(state, level, objectValue, false, false)) {
+    if (state2.dump.length > 1024) pairBuffer += "? ";
+    pairBuffer += state2.dump + (state2.condenseFlow ? '"' : "") + ":" + (state2.condenseFlow ? "" : " ");
+    if (!writeNode(state2, level, objectValue, false, false)) {
       continue;
     }
-    pairBuffer += state.dump;
+    pairBuffer += state2.dump;
     _result += pairBuffer;
   }
-  state.tag = _tag;
-  state.dump = "{" + _result + "}";
+  state2.tag = _tag;
+  state2.dump = "{" + _result + "}";
 }
-function writeBlockMapping(state, level, object, compact) {
-  var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
-  if (state.sortKeys === true) {
+function writeBlockMapping(state2, level, object, compact) {
+  var _result = "", _tag = state2.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
+  if (state2.sortKeys === true) {
     objectKeyList.sort();
-  } else if (typeof state.sortKeys === "function") {
-    objectKeyList.sort(state.sortKeys);
-  } else if (state.sortKeys) {
+  } else if (typeof state2.sortKeys === "function") {
+    objectKeyList.sort(state2.sortKeys);
+  } else if (state2.sortKeys) {
     throw new exception("sortKeys must be a boolean or a function");
   }
   for (index = 0, length = objectKeyList.length; index < length; index += 1) {
     pairBuffer = "";
     if (!compact || _result !== "") {
-      pairBuffer += generateNextLine(state, level);
+      pairBuffer += generateNextLine(state2, level);
     }
     objectKey = objectKeyList[index];
     objectValue = object[objectKey];
-    if (state.replacer) {
-      objectValue = state.replacer.call(object, objectKey, objectValue);
+    if (state2.replacer) {
+      objectValue = state2.replacer.call(object, objectKey, objectValue);
     }
-    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
+    if (!writeNode(state2, level + 1, objectKey, true, true, true)) {
       continue;
     }
-    explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+    explicitPair = state2.tag !== null && state2.tag !== "?" || state2.dump && state2.dump.length > 1024;
     if (explicitPair) {
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+      if (state2.dump && CHAR_LINE_FEED === state2.dump.charCodeAt(0)) {
         pairBuffer += "?";
       } else {
         pairBuffer += "? ";
       }
     }
-    pairBuffer += state.dump;
+    pairBuffer += state2.dump;
     if (explicitPair) {
-      pairBuffer += generateNextLine(state, level);
+      pairBuffer += generateNextLine(state2, level);
     }
-    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
+    if (!writeNode(state2, level + 1, objectValue, true, explicitPair)) {
       continue;
     }
-    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+    if (state2.dump && CHAR_LINE_FEED === state2.dump.charCodeAt(0)) {
       pairBuffer += ":";
     } else {
       pairBuffer += ": ";
     }
-    pairBuffer += state.dump;
+    pairBuffer += state2.dump;
     _result += pairBuffer;
   }
-  state.tag = _tag;
-  state.dump = _result || "{}";
+  state2.tag = _tag;
+  state2.dump = _result || "{}";
 }
-function detectType(state, object, explicit) {
+function detectType(state2, object, explicit) {
   var _result, typeList, index, length, type2, style;
-  typeList = explicit ? state.explicitTypes : state.implicitTypes;
+  typeList = explicit ? state2.explicitTypes : state2.implicitTypes;
   for (index = 0, length = typeList.length; index < length; index += 1) {
     type2 = typeList[index];
     if ((type2.instanceOf || type2.predicate) && (!type2.instanceOf || typeof object === "object" && object instanceof type2.instanceOf) && (!type2.predicate || type2.predicate(object))) {
       if (explicit) {
         if (type2.multi && type2.representName) {
-          state.tag = type2.representName(object);
+          state2.tag = type2.representName(object);
         } else {
-          state.tag = type2.tag;
+          state2.tag = type2.tag;
         }
       } else {
-        state.tag = "?";
+        state2.tag = "?";
       }
       if (type2.represent) {
-        style = state.styleMap[type2.tag] || type2.defaultStyle;
+        style = state2.styleMap[type2.tag] || type2.defaultStyle;
         if (_toString.call(type2.represent) === "[object Function]") {
           _result = type2.represent(object, style);
         } else if (_hasOwnProperty.call(type2.represent, style)) {
@@ -9366,100 +9376,100 @@ function detectType(state, object, explicit) {
         } else {
           throw new exception("!<" + type2.tag + '> tag resolver accepts not "' + style + '" style');
         }
-        state.dump = _result;
+        state2.dump = _result;
       }
       return true;
     }
   }
   return false;
 }
-function writeNode(state, level, object, block, compact, iskey, isblockseq) {
-  state.tag = null;
-  state.dump = object;
-  if (!detectType(state, object, false)) {
-    detectType(state, object, true);
+function writeNode(state2, level, object, block, compact, iskey, isblockseq) {
+  state2.tag = null;
+  state2.dump = object;
+  if (!detectType(state2, object, false)) {
+    detectType(state2, object, true);
   }
-  var type2 = _toString.call(state.dump);
+  var type2 = _toString.call(state2.dump);
   var inblock = block;
   var tagStr;
   if (block) {
-    block = state.flowLevel < 0 || state.flowLevel > level;
+    block = state2.flowLevel < 0 || state2.flowLevel > level;
   }
   var objectOrArray = type2 === "[object Object]" || type2 === "[object Array]", duplicateIndex, duplicate;
   if (objectOrArray) {
-    duplicateIndex = state.duplicates.indexOf(object);
+    duplicateIndex = state2.duplicates.indexOf(object);
     duplicate = duplicateIndex !== -1;
   }
-  if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
+  if (state2.tag !== null && state2.tag !== "?" || duplicate || state2.indent !== 2 && level > 0) {
     compact = false;
   }
-  if (duplicate && state.usedDuplicates[duplicateIndex]) {
-    state.dump = "*ref_" + duplicateIndex;
+  if (duplicate && state2.usedDuplicates[duplicateIndex]) {
+    state2.dump = "*ref_" + duplicateIndex;
   } else {
-    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
-      state.usedDuplicates[duplicateIndex] = true;
+    if (objectOrArray && duplicate && !state2.usedDuplicates[duplicateIndex]) {
+      state2.usedDuplicates[duplicateIndex] = true;
     }
     if (type2 === "[object Object]") {
-      if (block && Object.keys(state.dump).length !== 0) {
-        writeBlockMapping(state, level, state.dump, compact);
+      if (block && Object.keys(state2.dump).length !== 0) {
+        writeBlockMapping(state2, level, state2.dump, compact);
         if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + state.dump;
+          state2.dump = "&ref_" + duplicateIndex + state2.dump;
         }
       } else {
-        writeFlowMapping(state, level, state.dump);
+        writeFlowMapping(state2, level, state2.dump);
         if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+          state2.dump = "&ref_" + duplicateIndex + " " + state2.dump;
         }
       }
     } else if (type2 === "[object Array]") {
-      if (block && state.dump.length !== 0) {
-        if (state.noArrayIndent && !isblockseq && level > 0) {
-          writeBlockSequence(state, level - 1, state.dump, compact);
+      if (block && state2.dump.length !== 0) {
+        if (state2.noArrayIndent && !isblockseq && level > 0) {
+          writeBlockSequence(state2, level - 1, state2.dump, compact);
         } else {
-          writeBlockSequence(state, level, state.dump, compact);
+          writeBlockSequence(state2, level, state2.dump, compact);
         }
         if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + state.dump;
+          state2.dump = "&ref_" + duplicateIndex + state2.dump;
         }
       } else {
-        writeFlowSequence(state, level, state.dump);
+        writeFlowSequence(state2, level, state2.dump);
         if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+          state2.dump = "&ref_" + duplicateIndex + " " + state2.dump;
         }
       }
     } else if (type2 === "[object String]") {
-      if (state.tag !== "?") {
-        writeScalar(state, state.dump, level, iskey, inblock);
+      if (state2.tag !== "?") {
+        writeScalar(state2, state2.dump, level, iskey, inblock);
       }
     } else if (type2 === "[object Undefined]") {
       return false;
     } else {
-      if (state.skipInvalid) return false;
+      if (state2.skipInvalid) return false;
       throw new exception("unacceptable kind of an object to dump " + type2);
     }
-    if (state.tag !== null && state.tag !== "?") {
+    if (state2.tag !== null && state2.tag !== "?") {
       tagStr = encodeURI(
-        state.tag[0] === "!" ? state.tag.slice(1) : state.tag
+        state2.tag[0] === "!" ? state2.tag.slice(1) : state2.tag
       ).replace(/!/g, "%21");
-      if (state.tag[0] === "!") {
+      if (state2.tag[0] === "!") {
         tagStr = "!" + tagStr;
       } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") {
         tagStr = "!!" + tagStr.slice(18);
       } else {
         tagStr = "!<" + tagStr + ">";
       }
-      state.dump = tagStr + " " + state.dump;
+      state2.dump = tagStr + " " + state2.dump;
     }
   }
   return true;
 }
-function getDuplicateReferences(object, state) {
+function getDuplicateReferences(object, state2) {
   var objects = [], duplicatesIndexes = [], index, length;
   inspectNode(object, objects, duplicatesIndexes);
   for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
-    state.duplicates.push(objects[duplicatesIndexes[index]]);
+    state2.duplicates.push(objects[duplicatesIndexes[index]]);
   }
-  state.usedDuplicates = new Array(length);
+  state2.usedDuplicates = new Array(length);
 }
 function inspectNode(object, objects, duplicatesIndexes) {
   var objectKeyList, index, length;
@@ -9486,13 +9496,13 @@ function inspectNode(object, objects, duplicatesIndexes) {
 }
 function dump$1(input, options) {
   options = options || {};
-  var state = new State(options);
-  if (!state.noRefs) getDuplicateReferences(input, state);
+  var state2 = new State(options);
+  if (!state2.noRefs) getDuplicateReferences(input, state2);
   var value = input;
-  if (state.replacer) {
-    value = state.replacer.call({ "": value }, "", value);
+  if (state2.replacer) {
+    value = state2.replacer.call({ "": value }, "", value);
   }
-  if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+  if (writeNode(state2, 0, value, true, true)) return state2.dump + "\n";
   return "";
 }
 var dump_1 = dump$1;
@@ -10671,6 +10681,104 @@ function TurnNavRail({
   );
 }
 
+// src/chat/turn-locate-channel.ts
+import { useEffect as useEffect23, useState as useState26 } from "react";
+var state = {};
+var statusState = {};
+var seqCounter = 0;
+var listeners = /* @__PURE__ */ new Set();
+function setState(update) {
+  const next = update(state);
+  if (next === state) return;
+  state = next;
+  for (const listener of [...listeners]) listener();
+}
+function setStatus(update) {
+  const next = update(statusState);
+  if (next === statusState) return;
+  statusState = next;
+  for (const listener of [...listeners]) listener();
+}
+var turnLocateChannel = {
+  getState: () => state,
+  getStatus: () => statusState,
+  request(sessionId, entryId) {
+    seqCounter += 1;
+    const seq2 = seqCounter;
+    setState((current) => ({ ...current, [sessionId]: { entryId, seq: seq2 } }));
+    setStatus((current) => ({ ...current, [sessionId]: { seq: seq2, entryId, state: "pending" } }));
+  },
+  /** 执行侧回传进度；只有最新一次请求的结果会被接受。 */
+  report(sessionId, seq2, state2) {
+    setStatus((current) => {
+      const entry = current[sessionId];
+      if (!entry || entry.seq !== seq2) return current;
+      return { ...current, [sessionId]: { ...entry, state: state2 } };
+    });
+  },
+  /** 定位完成（成功）：清掉进度，面板不再显示「正在定位」。 */
+  clearStatus(sessionId, seq2) {
+    setStatus((current) => {
+      const entry = current[sessionId];
+      if (!entry || entry.seq !== seq2) return current;
+      const next = { ...current };
+      delete next[sessionId];
+      return next;
+    });
+  },
+  subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  },
+  /** 某条信令已被消费：同 seq 不再重复定位（避免重新挂载时又跳一次）。 */
+  consume(sessionId, seq2) {
+    setState((current) => {
+      const request = current[sessionId];
+      if (!request || request.seq !== seq2) return current;
+      const next = { ...current };
+      delete next[sessionId];
+      return next;
+    });
+  },
+  /** 只清进度、不动未消费的请求（列表卸载时用）。 */
+  clearStatusForSession(sessionId) {
+    setStatus((current) => {
+      if (!(sessionId in current)) return current;
+      const next = { ...current };
+      delete next[sessionId];
+      return next;
+    });
+  },
+  clearSession(sessionId) {
+    setState((current) => {
+      if (!(sessionId in current)) return current;
+      const next = { ...current };
+      delete next[sessionId];
+      return next;
+    });
+  },
+  reset() {
+    setState(() => ({}));
+    setStatus(() => ({}));
+  }
+};
+function useTurnLocateRequest(sessionId) {
+  const [request, setRequest] = useState26(null);
+  useEffect23(() => {
+    if (!sessionId) {
+      setRequest(null);
+      return;
+    }
+    setRequest(turnLocateChannel.getState()[sessionId] ?? null);
+    return turnLocateChannel.subscribe(() => {
+      setRequest(turnLocateChannel.getState()[sessionId] ?? null);
+    });
+  }, [sessionId]);
+  return request;
+}
+
 // src/chat/scroll-anchor.ts
 var ENTRY_SCROLL_MARGIN_PX = 24;
 function calculateStickyAwareMargin(statusHeight = 0, statusBottomGap = 0) {
@@ -10815,9 +10923,9 @@ function MessageListBody({
 }) {
   const messages = Array.isArray(rawMessages) ? rawMessages : [];
   const session = useSessionHandle(sessionId);
-  const agentLoops = useSessionState(sessionId, (state) => state.agentLoops);
-  const askAnswers = useSessionState(sessionId, (state) => state.askAnswers);
-  const stateIsStreaming = useSessionState(sessionId, (state) => state.isStreaming);
+  const agentLoops = useSessionState(sessionId, (state2) => state2.agentLoops);
+  const askAnswers = useSessionState(sessionId, (state2) => state2.askAnswers);
+  const stateIsStreaming = useSessionState(sessionId, (state2) => state2.isStreaming);
   const sessionIsStreaming = streamingOverride ?? stateIsStreaming;
   const isPreparing = sessionIsStreaming && isPreparingReply(messages);
   const agentLoopNameSet = useMemo15(() => new Set(Object.keys(agentLoops ?? {})), [agentLoops]);
@@ -10843,10 +10951,10 @@ function MessageListBody({
     isStopping
   );
   const isRevealingAny = contentReveal.isRevealing || reasoningReveal.isRevealing;
-  useEffect23(() => {
+  useEffect24(() => {
     onRevealingChange?.(isRevealingAny);
   }, [isRevealingAny, onRevealingChange]);
-  useEffect23(() => {
+  useEffect24(() => {
     if (isStopping) {
       contentReveal.flushNow();
       reasoningReveal.flushNow();
@@ -10962,9 +11070,9 @@ function MessageListBody({
   const observedLatestUserStableIdRef = useRef21(
     latestUserIsOptimistic ? null : latestUserStableId
   );
-  const [activeTurnId, setActiveTurnId] = useState26(lastTurnId);
-  const [virtualScrollMargin, setVirtualScrollMargin] = useState26(0);
-  const [scrollContainerElement, setScrollContainerElement] = useState26(null);
+  const [activeTurnId, setActiveTurnId] = useState27(lastTurnId);
+  const [virtualScrollMargin, setVirtualScrollMargin] = useState27(0);
+  const [scrollContainerElement, setScrollContainerElement] = useState27(null);
   const loadingOlderRef = useRef21(false);
   const virtualizationEnabled = Boolean(useChatEnvironment().useVirtualizer);
   const stablePrefixEnd = useMemo15(
@@ -11026,6 +11134,51 @@ function MessageListBody({
       stickContextRef.current?.stopScroll();
     }
   });
+  const outlineLocateRequest = useTurnLocateRequest(isSharedSession ? null : sessionId);
+  const consumedLocateSeq = useRef21(0);
+  const outlineLocateRef = useRef21(null);
+  const navLoadingEntryIdRef = useRef21(navLoadingEntryId);
+  navLoadingEntryIdRef.current = navLoadingEntryId;
+  useEffect24(() => {
+    if (!outlineLocateRequest) return;
+    if (outlineLocateRequest.seq <= consumedLocateSeq.current) return;
+    consumedLocateSeq.current = outlineLocateRequest.seq;
+    const { seq: seq2 } = outlineLocateRequest;
+    outlineLocateRef.current = { seq: seq2, entryId: outlineLocateRequest.entryId };
+    selectNavEntry(outlineLocateRequest.entryId);
+    turnLocateChannel.consume(sessionId, seq2);
+    const frame = window.requestAnimationFrame(() => {
+      if (outlineLocateRef.current?.seq !== seq2) return;
+      if (navLoadingEntryIdRef.current !== null) return;
+      turnLocateChannel.clearStatus(sessionId, seq2);
+      outlineLocateRef.current = null;
+    });
+    return () => window.cancelAnimationFrame(frame);
+  }, [outlineLocateRequest, selectNavEntry, sessionId]);
+  useEffect24(() => {
+    const pending = outlineLocateRef.current;
+    if (!pending) return;
+    if (navError) {
+      turnLocateChannel.report(sessionId, pending.seq, "failed");
+      outlineLocateRef.current = null;
+      return;
+    }
+    const frame = window.requestAnimationFrame(() => {
+      if (outlineLocateRef.current?.seq !== pending.seq) return;
+      if (navLoadingEntryId !== null) return;
+      turnLocateChannel.clearStatus(sessionId, pending.seq);
+      outlineLocateRef.current = null;
+    });
+    return () => window.cancelAnimationFrame(frame);
+  }, [navError, navLoadingEntryId, sessionId]);
+  useEffect24(() => {
+    return () => {
+      const pending = outlineLocateRef.current;
+      if (!pending) return;
+      turnLocateChannel.clearStatus(sessionId, pending.seq);
+      outlineLocateRef.current = null;
+    };
+  }, [sessionId]);
   const activeViewportEntryId = useMemo15(() => {
     if (!activeTurnId) return null;
     const blockIndex = turnIdToBlockIndex.get(activeTurnId);
@@ -11105,7 +11258,7 @@ function MessageListBody({
       measureActiveTurn();
     });
   });
-  useEffect23(() => {
+  useEffect24(() => {
     void historyLoadRevision;
     scrollContainerRef.current = stickContextRef.current?.scrollRef.current ?? findScrollContainer(containerRef.current);
     const sc = scrollContainerRef.current;
@@ -11297,7 +11450,7 @@ function MessageListBody({
     previousStablePrefixEndRef.current = stablePrefixEnd;
     boundaryAnchorRef.current = captureBoundaryAnchor();
   }, [captureBoundaryAnchor, stablePrefixEnd]);
-  useEffect23(() => {
+  useEffect24(() => {
     scheduleMeasure();
   }, [lastTurnId, layoutSignature]);
   const stopNewTurnScrollAnimation = useCallback13(() => {
@@ -11368,7 +11521,7 @@ function MessageListBody({
       placeLatestUserAtTop(anchorId);
     });
   });
-  useEffect23(() => {
+  useEffect24(() => {
     const observer = new ResizeObserver((entries) => {
       for (const entry of entries) {
         const element = entry.target;
@@ -11504,14 +11657,14 @@ function MessageListBody({
       }
     }
   }, [stopNewTurnScrollAnimation]);
-  useEffect23(
+  useEffect24(
     () => () => {
       cancelPendingNewTurnScroll();
       stopNewTurnScrollAnimation();
     },
     [cancelPendingNewTurnScroll, stopNewTurnScrollAnimation]
   );
-  useEffect23(() => {
+  useEffect24(() => {
     const container = scrollContainerElement;
     if (!container) return;
     const handleScroll = () => {
@@ -11526,7 +11679,7 @@ function MessageListBody({
     container.addEventListener("scroll", handleScroll, { passive: true });
     return () => container.removeEventListener("scroll", handleScroll);
   }, [scrollContainerElement, releaseNewTurnPin]);
-  useEffect23(() => {
+  useEffect24(() => {
     if (!effectiveNewUserMessageKey) {
       const acknowledgedSameTarget = newTurnPinActiveRef.current && latestUserStableId != null && observedLatestUserStableIdRef.current === latestUserStableId;
       observedLatestUserStableIdRef.current = latestUserStableId;
@@ -11562,7 +11715,7 @@ function MessageListBody({
     releaseNewTurnPin,
     sessionIsStreaming
   ]);
-  useEffect23(() => {
+  useEffect24(() => {
     scheduleNewTurnSpacerUpdate();
     return () => {
       if (newTurnSpacerFrameRef.current != null) {
@@ -11571,11 +11724,11 @@ function MessageListBody({
       }
     };
   }, [layoutSignature]);
-  useEffect23(() => {
+  useEffect24(() => {
     if (!newTurnPinActiveRef.current) return;
     scheduleNewTurnSpacerUpdate();
   }, [contentReveal.displayedText, reasoningReveal.displayedText]);
-  useEffect23(() => () => {
+  useEffect24(() => () => {
     if (startScrollFrameRef.current != null) {
       window.cancelAnimationFrame(startScrollFrameRef.current);
       startScrollFrameRef.current = null;
@@ -11595,7 +11748,7 @@ function MessageListBody({
     appliedStartScrollKeyRef.current = null;
     appliedEntryScrollKeyRef.current = null;
   }, []);
-  useEffect23(() => {
+  useEffect24(() => {
     if (!scrollToStartKey || !hasMessages) {
       if (startScrollFrameRef.current != null) window.cancelAnimationFrame(startScrollFrameRef.current);
       if (startScrollTimeoutRef.current != null) window.clearTimeout(startScrollTimeoutRef.current);
@@ -11667,7 +11820,7 @@ function MessageListBody({
     },
     [scrollEntryId]
   );
-  useEffect23(() => {
+  useEffect24(() => {
     if (appliedEntryScrollKeyRef.current !== scrollEntryId) {
       if (entryScrollFrameRef.current != null) window.cancelAnimationFrame(entryScrollFrameRef.current);
       for (const timeoutId of entryScrollTimeoutRefs.current) window.clearTimeout(timeoutId);
@@ -12121,14 +12274,14 @@ function MessageList(props) {
 }
 
 // src/chat/runtime/use-chat-actions.ts
-import { useCallback as useCallback14, useEffect as useEffect24, useRef as useRef22, useState as useState27 } from "react";
+import { useCallback as useCallback14, useEffect as useEffect25, useRef as useRef22, useState as useState28 } from "react";
 function useChatActions(sessionId) {
   const source = useSessionSource();
   const session = useSessionHandle(sessionId);
-  const isStreaming = useSessionState(sessionId, (state) => state.isStreaming);
-  const [isStopping, setIsStopping] = useState27(false);
-  const [queueNotice, setQueueNotice] = useState27(null);
-  const [pendingQueueItemId, setPendingQueueItemId] = useState27(null);
+  const isStreaming = useSessionState(sessionId, (state2) => state2.isStreaming);
+  const [isStopping, setIsStopping] = useState28(false);
+  const [queueNotice, setQueueNotice] = useState28(null);
+  const [pendingQueueItemId, setPendingQueueItemId] = useState28(null);
   const previousSessionIdRef = useRef22(sessionId);
   const send = useCallback14(
     (msg, targetMode, askuserAnswer, options) => source.whenReady ? source.whenReady(sessionId, (ready) => sendToSession(ready, msg, targetMode, askuserAnswer, options)) : session ? sendToSession(session, msg, targetMode, askuserAnswer, options) : Promise.resolve(false),
@@ -12193,7 +12346,7 @@ function useChatActions(sessionId) {
       setIsStopping(false);
     }
   }, [isStopping, session, sessionId, source]);
-  useEffect24(() => {
+  useEffect25(() => {
     if (previousSessionIdRef.current !== sessionId) {
       previousSessionIdRef.current = sessionId;
       setIsStopping(false);
@@ -12224,8 +12377,8 @@ import { useCallback as useCallback15 } from "react";
 function useSessionReplay(sessionId) {
   const environment = useChatEnvironment();
   const session = useSessionHandle(sessionId);
-  const replay = useSessionState(sessionId, (state) => state.replay);
-  const viewerRole = useSessionState(sessionId, (state) => state.viewerRole);
+  const replay = useSessionState(sessionId, (state2) => state2.replay);
+  const viewerRole = useSessionState(sessionId, (state2) => state2.viewerRole);
   const isReplay = replay?.isReplay ?? false;
   const canControl = viewerRole !== "viewer";
   const setSpeed = useCallback15(
@@ -12333,21 +12486,21 @@ function ChatPanel({
   const scopedEnvironment = useMemo16(() => ({ ...environment, renderMode }), [environment, renderMode]);
   const DeveloperMessageList = environment.DeveloperMessageList;
   const agentSession = useSessionHandle(sessionId);
-  const messages = useSessionState(sessionId, (state) => state.messages);
-  const isStreaming = useSessionState(sessionId, (state) => state.isStreaming);
-  const queue = useSessionState(sessionId, (state) => state.queue);
-  const turns = useSessionState(sessionId, (state) => state.turns);
-  const stateMode = useSessionState(sessionId, (state) => state.mode);
-  const connection = useSessionState(sessionId, (state) => state.connection);
-  const stateStatus = useSessionState(sessionId, (state) => state.status);
-  const viewerRole = useSessionState(sessionId, (state) => state.viewerRole);
-  const stateError = useSessionState(sessionId, (state) => state.errorMessage);
-  const nextBefore = useSessionState(sessionId, (state) => state.nextBefore);
-  const historyLoadingOlder = useSessionState(sessionId, (state) => state.loadingOlder);
-  const historyLoadRevision = useSessionState(sessionId, (state) => state.historyRevision);
-  const historyRewriteRevision = useSessionState(sessionId, (state) => state.timelineRevision);
-  const activeCompaction = useSessionState(sessionId, (state) => state.activeCompaction);
-  const compactionPending = useSessionState(sessionId, (state) => state.compactionPending);
+  const messages = useSessionState(sessionId, (state2) => state2.messages);
+  const isStreaming = useSessionState(sessionId, (state2) => state2.isStreaming);
+  const queue = useSessionState(sessionId, (state2) => state2.queue);
+  const turns = useSessionState(sessionId, (state2) => state2.turns);
+  const stateMode = useSessionState(sessionId, (state2) => state2.mode);
+  const connection = useSessionState(sessionId, (state2) => state2.connection);
+  const stateStatus = useSessionState(sessionId, (state2) => state2.status);
+  const viewerRole = useSessionState(sessionId, (state2) => state2.viewerRole);
+  const stateError = useSessionState(sessionId, (state2) => state2.errorMessage);
+  const nextBefore = useSessionState(sessionId, (state2) => state2.nextBefore);
+  const historyLoadingOlder = useSessionState(sessionId, (state2) => state2.loadingOlder);
+  const historyLoadRevision = useSessionState(sessionId, (state2) => state2.historyRevision);
+  const historyRewriteRevision = useSessionState(sessionId, (state2) => state2.timelineRevision);
+  const activeCompaction = useSessionState(sessionId, (state2) => state2.activeCompaction);
+  const compactionPending = useSessionState(sessionId, (state2) => state2.compactionPending);
   const {
     isStopping,
     send,
@@ -12361,12 +12514,12 @@ function ChatPanel({
     deliverQueuedMessage,
     resumeQueue
   } = useChatActions(sessionId);
-  const [isRevealing, setIsRevealing] = useState28(false);
+  const [isRevealing, setIsRevealing] = useState29(false);
   const isStreamingDisplay = isStreaming || isRevealing;
   const detail = useChatSessionDetail(sessionId);
   const { isReplay } = useSessionReplay(sessionId);
   const isLoadingHistory = useIsSessionHistoryLoading(sessionId);
-  const [queuePanelVisible, setQueuePanelVisible] = useState28(false);
+  const [queuePanelVisible, setQueuePanelVisible] = useState29(false);
   const loadOlder = useCallback16(
     async (beforeCommit) => {
       if (!agentSession) return false;
@@ -12376,11 +12529,11 @@ function ChatPanel({
     },
     [agentSession]
   );
-  const [paginationActivation, setPaginationActivation] = useState28(() => ({
+  const [paginationActivation, setPaginationActivation] = useState29(() => ({
     sessionId,
     activated: Boolean(nextBefore)
   }));
-  useEffect25(() => {
+  useEffect26(() => {
     setPaginationActivation((current) => {
       if (current.sessionId !== sessionId) {
         return { sessionId, activated: Boolean(nextBefore) };
@@ -12397,8 +12550,8 @@ function ChatPanel({
   const isViewer = (viewerRole ?? detail?.viewer_role) === "viewer";
   const isCompacting = activeCompaction != null || compactionPending;
   const postChatFollowup = useMemo16(() => latestPostChatFollowup(turns), [turns]);
-  const [resultFeedback, setResultFeedback] = useState28([]);
-  useEffect25(() => {
+  const [resultFeedback, setResultFeedback] = useState29([]);
+  useEffect26(() => {
     setResultFeedback([]);
     if (isViewer || !sessionId) return;
     let cancelled = false;
@@ -12664,13 +12817,13 @@ function ChatPanel({
 }
 
 // src/components/SessionPluginSelector.tsx
-import { useEffect as useEffect26, useState as useState29 } from "react";
+import { useEffect as useEffect27, useState as useState30 } from "react";
 import { jsx as jsx39, jsxs as jsxs35 } from "react/jsx-runtime";
 function SessionPluginSelector(props) {
   return /* @__PURE__ */ jsx39(PluginSelectorState, { ...props }, props.sessionId);
 }
 function PluginSelectorState({ client, sessionId, className, side = "bottom", onChange }) {
-  const [open, setOpen] = useState29(false);
+  const [open, setOpen] = useState30(false);
   return /* @__PURE__ */ jsxs35("div", { className: `relative text-xs ${className ?? ""}`, children: [
     /* @__PURE__ */ jsx39(
       "button",
@@ -12694,7 +12847,7 @@ function PluginSelectorList({
 }) {
   const controller = useSessionPluginActivation({ client, sessionId, onChange });
   const { reload } = controller;
-  useEffect26(() => {
+  useEffect27(() => {
     reload();
   }, [reload]);
   return /* @__PURE__ */ jsxs35(
@@ -12732,8 +12885,8 @@ function isUnauthorizedError(error) {
   return error instanceof BladeApiError && error.status === 401;
 }
 function LoginCard({ client, onLoggedIn }) {
-  const [loggingIn, setLoggingIn] = useState30(false);
-  const [loginError, setLoginError] = useState30(null);
+  const [loggingIn, setLoggingIn] = useState31(false);
+  const [loginError, setLoginError] = useState31(null);
   const handleLogin = async () => {
     setLoggingIn(true);
     setLoginError(null);
@@ -12765,8 +12918,8 @@ function LoginCard({ client, onLoggedIn }) {
 }
 function AgentChat(props) {
   const client = useBladeClient();
-  const [attempt, setAttempt] = useState30(0);
-  const [needLogin, setNeedLogin] = useState30(() => !client.hasToken());
+  const [attempt, setAttempt] = useState31(0);
+  const [needLogin, setNeedLogin] = useState31(() => !client.hasToken());
   if (needLogin) {
     return /* @__PURE__ */ jsx40(
       "div",
@@ -12806,38 +12959,38 @@ function ChatSessionView({
 }) {
   const client = useBladeClient();
   const host = useBladeHost();
-  const { session, state, error } = useAgentSession(sessionId, {
+  const { session, state: state2, error } = useAgentSession(sessionId, {
     createOptions,
     onSessionCreated
   });
   const replay = useReplay(session);
-  const [notice, setNotice] = useState30(null);
-  const source = useSingleSessionSource(session, !session || state === null);
+  const [notice, setNotice] = useState31(null);
+  const source = useSingleSessionSource(session, !session || state2 === null);
   const resolvedSessionId = session?.sessionId;
-  const isViewer = state?.viewerRole === "viewer";
-  const replaySpeed = state?.replay?.speed;
-  const replaying = state?.replay?.isReplay;
-  useEffect27(() => {
+  const isViewer = state2?.viewerRole === "viewer";
+  const replaySpeed = state2?.replay?.speed;
+  const replaying = state2?.replay?.isReplay;
+  useEffect28(() => {
     setNotice(null);
   }, [resolvedSessionId, replaySpeed, replaying]);
   const onSessionReadyRef = useRef23(onSessionReady);
   const readySessionRef = useRef23(null);
   const hasOnSessionReady = onSessionReady !== void 0;
-  useEffect27(() => {
+  useEffect28(() => {
     onSessionReadyRef.current = onSessionReady;
   }, [onSessionReady]);
-  useEffect27(() => {
+  useEffect28(() => {
     const handler = onSessionReadyRef.current;
     if (!session || !hasOnSessionReady || !handler || readySessionRef.current === session) return;
     readySessionRef.current = session;
     handler(session);
   }, [session, hasOnSessionReady]);
-  useEffect27(() => {
+  useEffect28(() => {
     if (isUnauthorizedError(error)) {
       onUnauthorized();
     }
   }, [error, onUnauthorized]);
-  useEffect27(() => {
+  useEffect28(() => {
     if (!session || !commands) return;
     const unsubscribes = Object.entries(commands).map(
       ([action, handler]) => session.onCommand(action, (payload) => handler(payload))
@@ -12880,20 +13033,20 @@ function ChatSessionView({
 
 // src/components/LlmChat.tsx
 import { chatErrorForDisplay as chatErrorForDisplay4 } from "@blade-hq/agent-client/internal";
-import { useEffect as useEffect28, useMemo as useMemo19, useState as useState33 } from "react";
+import { useEffect as useEffect29, useMemo as useMemo19, useState as useState34 } from "react";
 
 // src/hooks/use-llm-chat.ts
-import { useCallback as useCallback17, useMemo as useMemo18, useRef as useRef24, useState as useState31 } from "react";
+import { useCallback as useCallback17, useMemo as useMemo18, useRef as useRef24, useState as useState32 } from "react";
 var DEFAULT_HISTORY_TURNS = 12;
 var DEFAULT_MAX_TOOL_ROUNDS = 4;
 var syntheticIdSeq = 0;
 function useLlmChat(options) {
-  const [history, setHistory] = useState31([]);
-  const [streamingText, setStreamingText] = useState31(null);
-  const [streamingCalls, setStreamingCalls] = useState31([]);
-  const [failedToolIds, setFailedToolIds] = useState31([]);
-  const [error, setError] = useState31(null);
-  const [isStreaming, setIsStreaming] = useState31(false);
+  const [history, setHistory] = useState32([]);
+  const [streamingText, setStreamingText] = useState32(null);
+  const [streamingCalls, setStreamingCalls] = useState32([]);
+  const [failedToolIds, setFailedToolIds] = useState32([]);
+  const [error, setError] = useState32(null);
+  const [isStreaming, setIsStreaming] = useState32(false);
   const abortRef = useRef24(null);
   const activeStartedAtRef = useRef24(null);
   const assistantTimingsRef = useRef24(/* @__PURE__ */ new WeakMap());
@@ -13239,7 +13392,7 @@ function toToolCallInfo(call, results, failedToolIds) {
 }
 
 // src/components/LlmAdvancedSettings.tsx
-import { useState as useState32 } from "react";
+import { useState as useState33 } from "react";
 import { jsx as jsx41, jsxs as jsxs37 } from "react/jsx-runtime";
 var FIELDS = [
   { id: "baseURL", label: "\u6A21\u578B\u670D\u52A1\u5730\u5740", placeholder: "http://\u5185\u7F51\u5730\u5740/v1" },
@@ -13286,8 +13439,8 @@ function writeOverride(settings, baseURL, override) {
 }
 function LlmAdvancedSettingsBar({ settings, defaults, override, onChange }) {
   const normalized = normalizeAdvanced(settings);
-  const [open, setOpen] = useState32(false);
-  const [draft, setDraft] = useState32(override);
+  const [open, setOpen] = useState33(false);
+  const [draft, setDraft] = useState33(override);
   if (!normalized) return null;
   const fields = FIELDS.filter((field) => normalized[field.id]);
   const dirty = Object.keys(override).length > 0;
@@ -13370,12 +13523,12 @@ function LlmChat({
   onOverrideChange,
   ...options
 }) {
-  const [override, setOverride] = useState33(() => readOverride(advanced, options.baseURL));
+  const [override, setOverride] = useState34(() => readOverride(advanced, options.baseURL));
   const effective = { ...options, ...override };
   const { messages, isStreaming, error, send, stop, reset } = useLlmChat(effective);
-  const [inputText, setInputText] = useState33("");
-  const [stopRequested, setStopRequested] = useState33(false);
-  const [isRevealing, setIsRevealing] = useState33(false);
+  const [inputText, setInputText] = useState34("");
+  const [stopRequested, setStopRequested] = useState34(false);
+  const [isRevealing, setIsRevealing] = useState34(false);
   const isStreamingDisplay = isStreaming || isRevealing;
   const handle = useMemo19(
     () => ({
@@ -13386,7 +13539,7 @@ ${text}` : text),
     }),
     [send, reset]
   );
-  useEffect28(() => {
+  useEffect29(() => {
     onReady?.(handle);
   }, [handle, onReady]);
   const customization = useMemo19(() => ({ classNames, renderers }), [classNames, renderers]);
@@ -13487,7 +13640,7 @@ function ChatView(props) {
 }
 
 // src/components/TopicAssetSubmitDialog.tsx
-import { useRef as useRef25, useState as useState34 } from "react";
+import { useRef as useRef25, useState as useState35 } from "react";
 import { jsx as jsx44, jsxs as jsxs39 } from "react/jsx-runtime";
 function useTopicAssetSubmissionAccess(sessionId) {
   const client = useBladeClient();
@@ -13504,12 +13657,12 @@ function useTopicAssetSubmissionAccess(sessionId) {
 }
 function TopicAssetSubmitDialog({ sessionId, topicId, path, onClose, onSubmitted }) {
   const client = useBladeClient();
-  const [folder, setFolder] = useState34("");
-  const [message, setMessage] = useState34("");
-  const [error, setError] = useState34(null);
-  const [busy, setBusy] = useState34(false);
+  const [folder, setFolder] = useState35("");
+  const [message, setMessage] = useState35("");
+  const [error, setError] = useState35(null);
+  const [busy, setBusy] = useState35(false);
   const submitting = useRef25(false);
-  const [revision, setRevision] = useState34(0);
+  const [revision, setRevision] = useState35(0);
   const assets = useAsyncValue(`${sessionId}:${topicId}:${revision}`, async () => {
     const [session, groups, result] = await Promise.all([
       client.sessions.getSession(sessionId),
@@ -13619,4 +13772,4 @@ use-stick-to-bottom/dist/StickToBottom.js:
 js-yaml/dist/js-yaml.mjs:
   (*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT *)
 */
-//# sourceMappingURL=chunk-XP6T6SHZ.js.map
+//# sourceMappingURL=chunk-IVGTMWRV.js.map