@qredence/fleet 0.6.1 → 0.6.3

package/dist/web/server/{router-Dg72SESP-PCWKLFRG.js → router-DfG45nTQ-3VXEUYG5.js}

@@ -1,3 +1,6 @@
+import {
+  isModelPatternEnabled
+} from "./chunk-WTYNN6EV.js";
 import {
   ChatMcpDeleteRequestSchema,
   ChatMcpOAuthLoginRequestSchema,
@@ -8,22 +11,51 @@ import {
   ChatProviderUpdateRequestSchema,
   ChatSettingsUpdateRequestSchema,
   FLEET_ADAPTER_CAPABILITIES,
-  LazyMotion,
+  HTMLVisualElement,
+  MotionConfig,
   NETWORK_DISCONNECTED_MESSAGE,
   QueryClient,
   QueryClientProvider,
-  domAnimation,
+  SVGVisualElement,
+  SessionTreeNavigateRequestSchema,
+  SessionTreeNavigateResponseSchema,
+  SessionTreeSnapshotResponseSchema,
+  addValueToWillChange,
+  animateMotionValue,
+  animateSingleValue,
+  animateTarget,
+  applyBoxDelta,
+  applyTreeDeltas,
+  circOut,
+  convertBoundingBoxToBox,
+  convertBoxToBoundingBox,
+  getOptimisedAppearId,
+  getValueTransition,
+  has2DTranslate,
+  hasScale,
+  hasTransform,
   initAnalytics,
-  isServer
-} from "./chunk-YGYOBX7G.js";
+  isKeyframesTarget,
+  isSVGElement,
+  isSVGSVGElement,
+  isServer,
+  measurePageBox,
+  pipe,
+  progress,
+  resolveElements,
+  resolveVariant,
+  scalePoint,
+  transformBox,
+  translateAxis
+} from "./chunk-O2IC376F.js";
 import {
   DEFAULT_UI_PREFERENCES,
-  isModelPatternEnabled,
+  applyUiPreferencesToDocument,
   readUiPreferences
-} from "./chunk-ETTDO4UO.js";
+} from "./chunk-4EBSM4JR.js";
 import {
   Toaster
-} from "./chunk-UL2725KQ.js";
+} from "./chunk-TR2GA5OF.js";
 import {
   fallbackSessionLabel,
   meaningfulSessionLabel,
@@ -32,9 +64,44 @@ import {
 import "./chunk-SZJUXVWG.js";
 import "./chunk-TNL4YV63.js";
 import {
-  drag,
-  layout
-} from "./chunk-FAGDMGLK.js";
+  isHTMLElement,
+  usePresence
+} from "./chunk-K6PTNSCW.js";
+import {
+  LayoutGroupContext,
+  LazyContext,
+  SubscriptionManager,
+  SwitchLayoutGroupContext,
+  addUniqueItem,
+  cancelFrame,
+  clamp,
+  cornerRadiusProps,
+  createBox,
+  createDelta,
+  frame,
+  frameData,
+  frameSteps,
+  invariant,
+  isAnimationControls,
+  isRefObject,
+  isSVGComponent,
+  isVariantLabel,
+  loadFeatures,
+  microtask,
+  millisecondsToSeconds,
+  mixNumber,
+  motionValue,
+  noop,
+  percent,
+  px,
+  removeItem,
+  resolveMotionValue,
+  scaleCorrectors,
+  secondsToMilliseconds,
+  time,
+  variantPriorityOrder,
+  variantProps
+} from "./chunk-7E76R7MB.js";
 import {
   Card,
   CardContent,
@@ -42,7 +109,7 @@ import {
   CardHeader,
   CardTitle,
   validateAndNormalizeOpenUIHtmlArtifact
-} from "./chunk-3TIMGWWI.js";
+} from "./chunk-UM3RHJNZ.js";
 import {
   ChatNewRequestSchema,
   ChatOpenUIArtifactUpsertRequestSchema,
@@ -62,7 +129,7 @@ import {
   UploadedAttachmentSchema,
   ZodError,
   external_exports
-} from "./chunk-PLYZ7P2Y.js";
+} from "./chunk-DP26GVWH.js";
 import {
   KNOWN_PROVIDERS,
   OPENAI_CHAT_COMPLETIONS_PROVIDER_ID,
@@ -77,12 +144,13 @@ import {
   toInstanceSlug,
   toOccInstanceId
 } from "./chunk-RJOANOT4.js";
-import "./chunk-WNCAL4HN.js";
 import "./chunk-JBLHIEVG.js";
-import "./chunk-XIB6XNUX.js";
+import "./chunk-HQ5TEXHT.js";
+import "./chunk-TLNZNR7C.js";
+import "./chunk-XJ6TGSUB.js";
 import "./chunk-HFQZLPU2.js";
 import "./chunk-4ZIEVI5O.js";
-import "./chunk-DJMHPJBP.js";
+import "./chunk-CHEC7TWB.js";
 import {
   HeadContent,
   Outlet,
@@ -96,8 +164,8 @@ import "./chunk-JDCCC7A7.js";
 import "./chunk-L547YHC4.js";
 import "./chunk-MLKGABMK.js";
 
-// web/app/dist/server/assets/router-Dg72SESP.js
-import { useEffect, useLayoutEffect } from "react";
+// web/app/dist/server/assets/router-DfG45nTQ.js
+import { Component, Fragment, useContext, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -107,8 +175,2868 @@ import { AuthStorage, DAEMON_PROTOCOL_NAME, DAEMON_PROTOCOL_VERSION, DaemonAgent
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { getProviders, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+function calcChildStagger(children, child, delayChildren, staggerChildren = 0, staggerDirection = 1) {
+  const index = Array.from(children).sort((a, b) => a.sortNodePosition(b)).indexOf(child);
+  const numChildren = children.size;
+  const maxStaggerDuration = (numChildren - 1) * staggerChildren;
+  return typeof delayChildren === "function" ? delayChildren(index, numChildren) : staggerDirection === 1 ? index * staggerChildren : maxStaggerDuration - index * staggerChildren;
+}
+function animateVariant(visualElement, variant, options = {}) {
+  const resolved = resolveVariant(visualElement, variant, options.type === "exit" ? visualElement.presenceContext?.custom : void 0);
+  let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
+  if (options.transitionOverride) transition = options.transitionOverride;
+  const getAnimation = resolved ? () => Promise.all(animateTarget(visualElement, resolved, options)) : () => Promise.resolve();
+  const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size ? (forwardDelay = 0) => {
+    const { delayChildren = 0, staggerChildren, staggerDirection } = transition;
+    return animateChildren(visualElement, variant, forwardDelay, delayChildren, staggerChildren, staggerDirection, options);
+  } : () => Promise.resolve();
+  const { when } = transition;
+  if (when) {
+    const [first, last] = when === "beforeChildren" ? [getAnimation, getChildAnimations] : [getChildAnimations, getAnimation];
+    return first().then(() => last());
+  } else return Promise.all([getAnimation(), getChildAnimations(options.delay)]);
+}
+function animateChildren(visualElement, variant, delay2 = 0, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {
+  const animations2 = [];
+  for (const child of visualElement.variantChildren) {
+    child.notify("AnimationStart", variant);
+    animations2.push(animateVariant(child, variant, {
+      ...options,
+      delay: delay2 + (typeof delayChildren === "function" ? 0 : delayChildren) + calcChildStagger(visualElement.variantChildren, child, delayChildren, staggerChildren, staggerDirection)
+    }).then(() => child.notify("AnimationComplete", variant)));
+  }
+  return Promise.all(animations2);
+}
+function animateVisualElement(visualElement, definition, options = {}) {
+  visualElement.notify("AnimationStart", definition);
+  let animation;
+  if (Array.isArray(definition)) {
+    const animations2 = definition.map((variant) => animateVariant(visualElement, variant, options));
+    animation = Promise.all(animations2);
+  } else if (typeof definition === "string") animation = animateVariant(visualElement, definition, options);
+  else {
+    const resolvedDefinition = typeof definition === "function" ? resolveVariant(visualElement, definition, options.custom) : definition;
+    animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));
+  }
+  return animation.then(() => {
+    visualElement.notify("AnimationComplete", definition);
+  });
+}
+var isDragging = {
+  x: false,
+  y: false
+};
+function isDragActive() {
+  return isDragging.x || isDragging.y;
+}
+function setDragLock(axis) {
+  if (axis === "x" || axis === "y") {
+    if (isDragging[axis]) return null;
+    else {
+      isDragging[axis] = true;
+      return () => {
+        isDragging[axis] = false;
+      };
+    }
+  } else if (isDragging.x || isDragging.y) return null;
+  else {
+    isDragging.x = isDragging.y = true;
+    return () => {
+      isDragging.x = isDragging.y = false;
+    };
+  }
+}
+function setupGesture(elementOrSelector, options) {
+  const elements = resolveElements(elementOrSelector);
+  const gestureAbortController = new AbortController();
+  const eventOptions = {
+    passive: true,
+    ...options,
+    signal: gestureAbortController.signal
+  };
+  const cancel = () => gestureAbortController.abort();
+  return [
+    elements,
+    eventOptions,
+    cancel
+  ];
+}
+function isValidHover(event) {
+  return !(event.pointerType === "touch" || isDragActive());
+}
+function hover(elementOrSelector, onHoverStart, options = {}) {
+  const [elements, eventOptions, cancel] = setupGesture(elementOrSelector, options);
+  elements.forEach((element) => {
+    let isPressed = false;
+    let deferredHoverEnd = false;
+    let hoverEndCallback;
+    const removePointerLeave = () => {
+      element.removeEventListener("pointerleave", onPointerLeave);
+    };
+    const endHover = (event) => {
+      if (hoverEndCallback) {
+        hoverEndCallback(event);
+        hoverEndCallback = void 0;
+      }
+      removePointerLeave();
+    };
+    const onPointerUp = (event) => {
+      isPressed = false;
+      window.removeEventListener("pointerup", onPointerUp);
+      window.removeEventListener("pointercancel", onPointerUp);
+      if (deferredHoverEnd) {
+        deferredHoverEnd = false;
+        endHover(event);
+      }
+    };
+    const onPointerDown = () => {
+      isPressed = true;
+      window.addEventListener("pointerup", onPointerUp, eventOptions);
+      window.addEventListener("pointercancel", onPointerUp, eventOptions);
+    };
+    const onPointerLeave = (leaveEvent) => {
+      if (leaveEvent.pointerType === "touch") return;
+      if (isPressed) {
+        deferredHoverEnd = true;
+        return;
+      }
+      endHover(leaveEvent);
+    };
+    const onPointerEnter = (enterEvent) => {
+      if (!isValidHover(enterEvent)) return;
+      deferredHoverEnd = false;
+      const onHoverEnd = onHoverStart(element, enterEvent);
+      if (typeof onHoverEnd !== "function") return;
+      hoverEndCallback = onHoverEnd;
+      element.addEventListener("pointerleave", onPointerLeave, eventOptions);
+    };
+    element.addEventListener("pointerenter", onPointerEnter, eventOptions);
+    element.addEventListener("pointerdown", onPointerDown, eventOptions);
+  });
+  return cancel;
+}
+var isNodeOrChild = (parent, child) => {
+  if (!child) return false;
+  else if (parent === child) return true;
+  else return isNodeOrChild(parent, child.parentElement);
+};
+var isPrimaryPointer = (event) => {
+  if (event.pointerType === "mouse") return typeof event.button !== "number" || event.button <= 0;
+  else
+    return event.isPrimary !== false;
+};
+var keyboardAccessibleElements = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function isElementKeyboardAccessible(element) {
+  return keyboardAccessibleElements.has(element.tagName) || element.isContentEditable === true;
+}
+var textInputElements = /* @__PURE__ */ new Set([
+  "INPUT",
+  "SELECT",
+  "TEXTAREA"
+]);
+function isElementTextInput(element) {
+  return textInputElements.has(element.tagName) || element.isContentEditable === true;
+}
+var isPressing = /* @__PURE__ */ new WeakSet();
+function filterEvents(callback) {
+  return (event) => {
+    if (event.key !== "Enter") return;
+    callback(event);
+  };
+}
+function firePointerEvent(target, type) {
+  target.dispatchEvent(new PointerEvent("pointer" + type, {
+    isPrimary: true,
+    bubbles: true
+  }));
+}
+var enableKeyboardPress = (focusEvent, eventOptions) => {
+  const element = focusEvent.currentTarget;
+  if (!element) return;
+  const handleKeydown = filterEvents(() => {
+    if (isPressing.has(element)) return;
+    firePointerEvent(element, "down");
+    const handleKeyup = filterEvents(() => {
+      firePointerEvent(element, "up");
+    });
+    const handleBlur = () => firePointerEvent(element, "cancel");
+    element.addEventListener("keyup", handleKeyup, eventOptions);
+    element.addEventListener("blur", handleBlur, eventOptions);
+  });
+  element.addEventListener("keydown", handleKeydown, eventOptions);
+  element.addEventListener("blur", () => element.removeEventListener("keydown", handleKeydown), eventOptions);
+};
+function isValidPressEvent(event) {
+  return isPrimaryPointer(event) && !isDragActive();
+}
+var claimedPointerDownEvents = /* @__PURE__ */ new WeakSet();
+function press(targetOrSelector, onPressStart, options = {}) {
+  const [targets, eventOptions, cancelEvents] = setupGesture(targetOrSelector, options);
+  const startPress = (startEvent) => {
+    const target = startEvent.currentTarget;
+    if (!isValidPressEvent(startEvent)) return;
+    if (claimedPointerDownEvents.has(startEvent)) return;
+    isPressing.add(target);
+    if (options.stopPropagation) claimedPointerDownEvents.add(startEvent);
+    const onPressEnd = onPressStart(target, startEvent);
+    const endEventOptions = {
+      ...eventOptions,
+      capture: true
+    };
+    const onPointerEnd = (endEvent, success) => {
+      window.removeEventListener("pointerup", onPointerUp, endEventOptions);
+      window.removeEventListener("pointercancel", onPointerCancel, endEventOptions);
+      if (isPressing.has(target)) isPressing.delete(target);
+      if (!isValidPressEvent(endEvent)) return;
+      if (typeof onPressEnd === "function") onPressEnd(endEvent, { success });
+    };
+    const onPointerUp = (upEvent) => {
+      onPointerEnd(upEvent, target === window || target === document || options.useGlobalTarget || isNodeOrChild(target, upEvent.target));
+    };
+    const onPointerCancel = (cancelEvent) => {
+      onPointerEnd(cancelEvent, false);
+    };
+    window.addEventListener("pointerup", onPointerUp, endEventOptions);
+    window.addEventListener("pointercancel", onPointerCancel, endEventOptions);
+  };
+  targets.forEach((target) => {
+    (options.useGlobalTarget ? window : target).addEventListener("pointerdown", startPress, eventOptions);
+    if (isHTMLElement(target)) {
+      target.addEventListener("focus", (event) => enableKeyboardPress(event, eventOptions));
+      if (!isElementKeyboardAccessible(target) && !target.hasAttribute("tabindex")) target.tabIndex = 0;
+    }
+  });
+  return cancelEvents;
+}
+var resizeHandlers = /* @__PURE__ */ new WeakMap();
+var observer;
+var getSize = (borderBoxAxis, svgAxis, htmlAxis) => (target, borderBoxSize) => {
+  if (borderBoxSize && borderBoxSize[0]) return borderBoxSize[0][borderBoxAxis + "Size"];
+  else if (isSVGElement(target) && "getBBox" in target) return target.getBBox()[svgAxis];
+  else return target[htmlAxis];
+};
+var getWidth = /* @__PURE__ */ getSize("inline", "width", "offsetWidth");
+var getHeight = /* @__PURE__ */ getSize("block", "height", "offsetHeight");
+function notifyTarget({ target, borderBoxSize }) {
+  resizeHandlers.get(target)?.forEach((handler) => {
+    handler(target, {
+      get width() {
+        return getWidth(target, borderBoxSize);
+      },
+      get height() {
+        return getHeight(target, borderBoxSize);
+      }
+    });
+  });
+}
+function notifyAll(entries) {
+  entries.forEach(notifyTarget);
+}
+function createResizeObserver() {
+  if (typeof ResizeObserver === "undefined") return;
+  observer = new ResizeObserver(notifyAll);
+}
+function resizeElement(target, handler) {
+  if (!observer) createResizeObserver();
+  const elements = resolveElements(target);
+  elements.forEach((element) => {
+    let elementHandlers = resizeHandlers.get(element);
+    if (!elementHandlers) {
+      elementHandlers = /* @__PURE__ */ new Set();
+      resizeHandlers.set(element, elementHandlers);
+    }
+    elementHandlers.add(handler);
+    observer?.observe(element);
+  });
+  return () => {
+    elements.forEach((element) => {
+      const elementHandlers = resizeHandlers.get(element);
+      elementHandlers?.delete(handler);
+      if (!elementHandlers?.size) observer?.unobserve(element);
+    });
+  };
+}
+var windowCallbacks = /* @__PURE__ */ new Set();
+var windowResizeHandler;
+function createWindowResizeHandler() {
+  windowResizeHandler = () => {
+    const info = {
+      get width() {
+        return window.innerWidth;
+      },
+      get height() {
+        return window.innerHeight;
+      }
+    };
+    windowCallbacks.forEach((callback) => callback(info));
+  };
+  window.addEventListener("resize", windowResizeHandler);
+}
+function resizeWindow(callback) {
+  windowCallbacks.add(callback);
+  if (!windowResizeHandler) createWindowResizeHandler();
+  return () => {
+    windowCallbacks.delete(callback);
+    if (!windowCallbacks.size && typeof windowResizeHandler === "function") {
+      window.removeEventListener("resize", windowResizeHandler);
+      windowResizeHandler = void 0;
+    }
+  };
+}
+function resize(a, b) {
+  return typeof a === "function" ? resizeWindow(a) : resizeElement(a, b);
+}
+var statsBuffer = {
+  value: null,
+  addProjectionMetrics: null
+};
+var Feature = class {
+  constructor(node) {
+    this.isMounted = false;
+    this.node = node;
+  }
+  update() {
+  }
+};
+var numVariantProps = variantProps.length;
+function getVariantContext(visualElement) {
+  if (!visualElement) return void 0;
+  if (!visualElement.isControllingVariants) {
+    const context2 = visualElement.parent ? getVariantContext(visualElement.parent) || {} : {};
+    if (visualElement.props.initial !== void 0) context2.initial = visualElement.props.initial;
+    return context2;
+  }
+  const context = {};
+  for (let i = 0; i < numVariantProps; i++) {
+    const name = variantProps[i];
+    const prop = visualElement.props[name];
+    if (isVariantLabel(prop) || prop === false) context[name] = prop;
+  }
+  return context;
+}
+function shallowCompare(next, prev) {
+  if (!Array.isArray(prev)) return false;
+  const prevLength = prev.length;
+  if (prevLength !== next.length) return false;
+  for (let i = 0; i < prevLength; i++) if (prev[i] !== next[i]) return false;
+  return true;
+}
+var reversePriorityOrder = [...variantPriorityOrder].reverse();
+var numAnimationTypes = variantPriorityOrder.length;
+function createAnimateFunction(visualElement) {
+  return (animations2) => {
+    return Promise.all(animations2.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));
+  };
+}
+function createAnimationState(visualElement) {
+  let animate = createAnimateFunction(visualElement);
+  let state = createState$1();
+  let isInitialRender = true;
+  let wasReset = false;
+  const buildResolvedTypeValues = (type) => (acc, definition) => {
+    const resolved = resolveVariant(visualElement, definition, type === "exit" ? visualElement.presenceContext?.custom : void 0);
+    if (resolved) {
+      const { transition, transitionEnd, ...target } = resolved;
+      acc = {
+        ...acc,
+        ...target,
+        ...transitionEnd
+      };
+    }
+    return acc;
+  };
+  function setAnimateFunction(makeAnimator) {
+    animate = makeAnimator(visualElement);
+  }
+  function animateChanges(changedActiveType) {
+    const { props } = visualElement;
+    const context = getVariantContext(visualElement.parent) || {};
+    const animations2 = [];
+    const removedKeys = /* @__PURE__ */ new Set();
+    let encounteredKeys = {};
+    let removedVariantIndex = Infinity;
+    for (let i = 0; i < numAnimationTypes; i++) {
+      const type = reversePriorityOrder[i];
+      const typeState = state[type];
+      const prop = props[type] !== void 0 ? props[type] : context[type];
+      const propIsVariant = isVariantLabel(prop);
+      const activeDelta = type === changedActiveType ? typeState.isActive : null;
+      if (activeDelta === false) removedVariantIndex = i;
+      let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;
+      if (isInherited && (isInitialRender || wasReset) && visualElement.manuallyAnimateOnMount) isInherited = false;
+      typeState.protectedKeys = { ...encounteredKeys };
+      if (!typeState.isActive && activeDelta === null || !prop && !typeState.prevProp || isAnimationControls(prop) || typeof prop === "boolean") continue;
+      if (type === "exit" && typeState.isActive && activeDelta !== true) {
+        if (typeState.prevResolvedValues) encounteredKeys = {
+          ...encounteredKeys,
+          ...typeState.prevResolvedValues
+        };
+        continue;
+      }
+      const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);
+      let shouldAnimateType = variantDidChange || type === changedActiveType && typeState.isActive && !isInherited && propIsVariant || i > removedVariantIndex && propIsVariant;
+      let handledRemovedValues = false;
+      const definitionList = Array.isArray(prop) ? prop : [prop];
+      let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});
+      if (activeDelta === false) resolvedValues = {};
+      const { prevResolvedValues = {} } = typeState;
+      const allKeys = {
+        ...prevResolvedValues,
+        ...resolvedValues
+      };
+      const markToAnimate = (key) => {
+        shouldAnimateType = true;
+        if (removedKeys.has(key)) {
+          handledRemovedValues = true;
+          removedKeys.delete(key);
+        }
+        typeState.needsAnimating[key] = true;
+        const motionValue2 = visualElement.getValue(key);
+        if (motionValue2) motionValue2.liveStyle = false;
+      };
+      for (const key in allKeys) {
+        const next = resolvedValues[key];
+        const prev = prevResolvedValues[key];
+        if (encounteredKeys.hasOwnProperty(key)) continue;
+        let valueHasChanged = false;
+        if (isKeyframesTarget(next) && isKeyframesTarget(prev)) valueHasChanged = !shallowCompare(next, prev) || variantDidChange;
+        else valueHasChanged = next !== prev;
+        if (valueHasChanged) {
+          if (next !== void 0 && next !== null) markToAnimate(key);
+          else removedKeys.add(key);
+        } else if (next !== void 0 && removedKeys.has(key))
+          markToAnimate(key);
+        else
+          typeState.protectedKeys[key] = true;
+      }
+      typeState.prevProp = prop;
+      typeState.prevResolvedValues = resolvedValues;
+      if (typeState.isActive) encounteredKeys = {
+        ...encounteredKeys,
+        ...resolvedValues
+      };
+      if ((isInitialRender || wasReset) && visualElement.blockInitialAnimation) shouldAnimateType = false;
+      const willAnimateViaParent = isInherited && variantDidChange;
+      if (shouldAnimateType && (!willAnimateViaParent || handledRemovedValues)) animations2.push(...definitionList.map((animation) => {
+        const options = { type };
+        if (typeof animation === "string" && (isInitialRender || wasReset) && !willAnimateViaParent && visualElement.manuallyAnimateOnMount && visualElement.parent) {
+          const { parent } = visualElement;
+          const parentVariant = resolveVariant(parent, animation);
+          if (parent.enteringChildren && parentVariant) {
+            const { delayChildren } = parentVariant.transition || {};
+            options.delay = calcChildStagger(parent.enteringChildren, visualElement, delayChildren);
+          }
+        }
+        return {
+          animation,
+          options
+        };
+      }));
+    }
+    if (removedKeys.size) {
+      const fallbackAnimation = {};
+      if (typeof props.initial !== "boolean") {
+        const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial) ? props.initial[0] : props.initial);
+        if (initialTransition && initialTransition.transition) fallbackAnimation.transition = initialTransition.transition;
+      }
+      removedKeys.forEach((key) => {
+        const fallbackTarget = visualElement.getBaseTarget(key);
+        const motionValue2 = visualElement.getValue(key);
+        if (motionValue2) motionValue2.liveStyle = true;
+        fallbackAnimation[key] = fallbackTarget ?? null;
+      });
+      animations2.push({ animation: fallbackAnimation });
+    }
+    let shouldAnimate = Boolean(animations2.length);
+    if (isInitialRender && (props.initial === false || props.initial === props.animate) && !visualElement.manuallyAnimateOnMount) shouldAnimate = false;
+    isInitialRender = false;
+    wasReset = false;
+    return shouldAnimate ? animate(animations2) : Promise.resolve();
+  }
+  function setActive(type, isActive) {
+    if (state[type].isActive === isActive) return Promise.resolve();
+    visualElement.variantChildren?.forEach((child) => child.animationState?.setActive(type, isActive));
+    state[type].isActive = isActive;
+    const animations2 = animateChanges(type);
+    for (const key in state) state[key].protectedKeys = {};
+    return animations2;
+  }
+  return {
+    animateChanges,
+    setActive,
+    setAnimateFunction,
+    getState: () => state,
+    reset: () => {
+      state = createState$1();
+      wasReset = true;
+    }
+  };
+}
+function checkVariantsDidChange(prev, next) {
+  if (typeof next === "string") return next !== prev;
+  else if (Array.isArray(next)) return !shallowCompare(next, prev);
+  return false;
+}
+function createTypeState(isActive = false) {
+  return {
+    isActive,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function createState$1() {
+  return {
+    animate: createTypeState(true),
+    whileInView: createTypeState(),
+    whileHover: createTypeState(),
+    whileTap: createTypeState(),
+    whileDrag: createTypeState(),
+    whileFocus: createTypeState(),
+    exit: createTypeState()
+  };
+}
+function copyAxisInto(axis, originAxis) {
+  axis.min = originAxis.min;
+  axis.max = originAxis.max;
+}
+function copyBoxInto(box, originBox) {
+  copyAxisInto(box.x, originBox.x);
+  copyAxisInto(box.y, originBox.y);
+}
+function copyAxisDeltaInto(delta, originDelta) {
+  delta.translate = originDelta.translate;
+  delta.scale = originDelta.scale;
+  delta.originPoint = originDelta.originPoint;
+  delta.origin = originDelta.origin;
+}
+var SCALE_MIN = 0.9999;
+var SCALE_MAX = 1.0001;
+var TRANSLATE_MIN = -0.01;
+var TRANSLATE_MAX = 0.01;
+function calcLength(axis) {
+  return axis.max - axis.min;
+}
+function isNear(value, target, maxDistance) {
+  return Math.abs(value - target) <= maxDistance;
+}
+function calcAxisDelta(delta, source, target, origin = 0.5) {
+  delta.origin = origin;
+  delta.originPoint = mixNumber(source.min, source.max, delta.origin);
+  delta.scale = calcLength(target) / calcLength(source);
+  delta.translate = mixNumber(target.min, target.max, delta.origin) - delta.originPoint;
+  if (delta.scale >= SCALE_MIN && delta.scale <= SCALE_MAX || isNaN(delta.scale)) delta.scale = 1;
+  if (delta.translate >= TRANSLATE_MIN && delta.translate <= TRANSLATE_MAX || isNaN(delta.translate)) delta.translate = 0;
+}
+function calcBoxDelta(delta, source, target, origin) {
+  calcAxisDelta(delta.x, source.x, target.x, origin ? origin.originX : void 0);
+  calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : void 0);
+}
+function calcRelativeAxis(target, relative2, parent, anchor = 0) {
+  target.min = (anchor ? mixNumber(parent.min, parent.max, anchor) : parent.min) + relative2.min;
+  target.max = target.min + calcLength(relative2);
+}
+function calcRelativeBox(target, relative2, parent, anchor) {
+  calcRelativeAxis(target.x, relative2.x, parent.x, anchor?.x);
+  calcRelativeAxis(target.y, relative2.y, parent.y, anchor?.y);
+}
+function calcRelativeAxisPosition(target, layout2, parent, anchor = 0) {
+  const anchorPoint = anchor ? mixNumber(parent.min, parent.max, anchor) : parent.min;
+  target.min = layout2.min - anchorPoint;
+  target.max = target.min + calcLength(layout2);
+}
+function calcRelativePosition(target, layout2, parent, anchor) {
+  calcRelativeAxisPosition(target.x, layout2.x, parent.x, anchor?.x);
+  calcRelativeAxisPosition(target.y, layout2.y, parent.y, anchor?.y);
+}
+function removePointDelta(point, translate, scale, originPoint, boxScale) {
+  point -= translate;
+  point = scalePoint(point, 1 / scale, originPoint);
+  if (boxScale !== void 0) point = scalePoint(point, 1 / boxScale, originPoint);
+  return point;
+}
+function removeAxisDelta(axis, translate = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {
+  if (percent.test(translate)) {
+    translate = parseFloat(translate);
+    translate = mixNumber(sourceAxis.min, sourceAxis.max, translate / 100) - sourceAxis.min;
+  }
+  if (typeof translate !== "number") return;
+  let originPoint = mixNumber(originAxis.min, originAxis.max, origin);
+  if (axis === originAxis) originPoint -= translate;
+  axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);
+  axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);
+}
+function removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {
+  removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);
+}
+var xKeys = [
+  "x",
+  "scaleX",
+  "originX"
+];
+var yKeys = [
+  "y",
+  "scaleY",
+  "originY"
+];
+function removeBoxTransforms(box, transforms, originBox, sourceBox) {
+  removeAxisTransforms(box.x, transforms, xKeys, originBox ? originBox.x : void 0, sourceBox ? sourceBox.x : void 0);
+  removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : void 0, sourceBox ? sourceBox.y : void 0);
+}
+function isAxisDeltaZero(delta) {
+  return delta.translate === 0 && delta.scale === 1;
+}
+function isDeltaZero(delta) {
+  return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);
+}
+function axisEquals(a, b) {
+  return a.min === b.min && a.max === b.max;
+}
+function boxEquals(a, b) {
+  return axisEquals(a.x, b.x) && axisEquals(a.y, b.y);
+}
+function axisEqualsRounded(a, b) {
+  return Math.round(a.min) === Math.round(b.min) && Math.round(a.max) === Math.round(b.max);
+}
+function boxEqualsRounded(a, b) {
+  return axisEqualsRounded(a.x, b.x) && axisEqualsRounded(a.y, b.y);
+}
+function aspectRatio(box) {
+  return calcLength(box.x) / calcLength(box.y);
+}
+function axisDeltaEquals(a, b) {
+  return a.translate === b.translate && a.scale === b.scale && a.originPoint === b.originPoint;
+}
+function eachAxis(callback) {
+  return [callback("x"), callback("y")];
+}
+function buildProjectionTransform(delta, treeScale, latestTransform) {
+  let transform = "";
+  const xTranslate = delta.x.translate / treeScale.x;
+  const yTranslate = delta.y.translate / treeScale.y;
+  const zTranslate = latestTransform?.z || 0;
+  if (xTranslate || yTranslate || zTranslate) transform = `translate3d(${xTranslate}px, ${yTranslate}px, ${zTranslate}px) `;
+  if (treeScale.x !== 1 || treeScale.y !== 1) transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;
+  if (latestTransform) {
+    const { transformPerspective, rotate, pathRotation, rotateX, rotateY, skewX, skewY } = latestTransform;
+    if (transformPerspective) transform = `perspective(${transformPerspective}px) ${transform}`;
+    if (rotate) transform += `rotate(${rotate}deg) `;
+    if (pathRotation) transform += `rotate(${pathRotation}deg) `;
+    if (rotateX) transform += `rotateX(${rotateX}deg) `;
+    if (rotateY) transform += `rotateY(${rotateY}deg) `;
+    if (skewX) transform += `skewX(${skewX}deg) `;
+    if (skewY) transform += `skewY(${skewY}deg) `;
+  }
+  const elementScaleX = delta.x.scale * treeScale.x;
+  const elementScaleY = delta.y.scale * treeScale.y;
+  if (elementScaleX !== 1 || elementScaleY !== 1) transform += `scale(${elementScaleX}, ${elementScaleY})`;
+  return transform || "none";
+}
+var numBorders = cornerRadiusProps.length;
+var asNumber = (value) => typeof value === "string" ? parseFloat(value) : value;
+var isPx = (value) => typeof value === "number" || px.test(value);
+function mixValues(target, follow, lead, progress2, shouldCrossfadeOpacity, isOnlyMember) {
+  if (shouldCrossfadeOpacity) {
+    target.opacity = mixNumber(0, lead.opacity ?? 1, easeCrossfadeIn(progress2));
+    target.opacityExit = mixNumber(follow.opacity ?? 1, 0, easeCrossfadeOut(progress2));
+  } else if (isOnlyMember) target.opacity = mixNumber(follow.opacity ?? 1, lead.opacity ?? 1, progress2);
+  for (let i = 0; i < numBorders; i++) {
+    const borderLabel = cornerRadiusProps[i];
+    let followRadius = getRadius(follow, borderLabel);
+    let leadRadius = getRadius(lead, borderLabel);
+    if (followRadius === void 0 && leadRadius === void 0) continue;
+    followRadius || (followRadius = 0);
+    leadRadius || (leadRadius = 0);
+    if (followRadius === 0 || leadRadius === 0 || isPx(followRadius) === isPx(leadRadius)) {
+      target[borderLabel] = Math.max(mixNumber(asNumber(followRadius), asNumber(leadRadius), progress2), 0);
+      if (percent.test(leadRadius) || percent.test(followRadius)) target[borderLabel] += "%";
+    } else target[borderLabel] = leadRadius;
+  }
+  if (follow.rotate || lead.rotate) target.rotate = mixNumber(follow.rotate || 0, lead.rotate || 0, progress2);
+}
+function getRadius(values, radiusName) {
+  return values[radiusName] !== void 0 ? values[radiusName] : values.borderRadius;
+}
+var easeCrossfadeIn = /* @__PURE__ */ compress(0, 0.5, circOut);
+var easeCrossfadeOut = /* @__PURE__ */ compress(0.5, 0.95, noop);
+function compress(min, max, easing) {
+  return (p) => {
+    if (p < min) return 0;
+    if (p > max) return 1;
+    return easing(progress(min, max, p));
+  };
+}
+function addDomEvent(target, eventName, handler, options = { passive: true }) {
+  target.addEventListener(eventName, handler, options);
+  return () => target.removeEventListener(eventName, handler, options);
+}
+var compareByDepth = (a, b) => a.depth - b.depth;
+var FlatTree = class {
+  constructor() {
+    this.children = [];
+    this.isDirty = false;
+  }
+  add(child) {
+    addUniqueItem(this.children, child);
+    this.isDirty = true;
+  }
+  remove(child) {
+    removeItem(this.children, child);
+    this.isDirty = true;
+  }
+  forEach(callback) {
+    this.isDirty && this.children.sort(compareByDepth);
+    this.isDirty = false;
+    this.children.forEach(callback);
+  }
+};
+function delay$1(callback, timeout) {
+  const start = time.now();
+  const checkElapsed = ({ timestamp }) => {
+    const elapsed = timestamp - start;
+    if (elapsed >= timeout) {
+      cancelFrame(checkElapsed);
+      callback(elapsed - timeout);
+    }
+  };
+  frame.setup(checkElapsed, true);
+  return () => cancelFrame(checkElapsed);
+}
+var NodeStack = class {
+  constructor() {
+    this.members = [];
+  }
+  add(node) {
+    addUniqueItem(this.members, node);
+    for (let i = this.members.length - 1; i >= 0; i--) {
+      const member = this.members[i];
+      if (member === node || member === this.lead || member === this.prevLead) continue;
+      const inst = member.instance;
+      if ((!inst || inst.isConnected === false) && !member.snapshot) {
+        removeItem(this.members, member);
+        member.unmount();
+      }
+    }
+    node.scheduleRender();
+  }
+  remove(node) {
+    removeItem(this.members, node);
+    if (node === this.prevLead) this.prevLead = void 0;
+    if (node === this.lead) {
+      const prevLead = this.members[this.members.length - 1];
+      if (prevLead) this.promote(prevLead);
+    }
+  }
+  relegate(node) {
+    for (let i = this.members.indexOf(node) - 1; i >= 0; i--) {
+      const member = this.members[i];
+      if (member.isPresent !== false && member.instance?.isConnected !== false) {
+        this.promote(member);
+        return true;
+      }
+    }
+    return false;
+  }
+  promote(node, preserveFollowOpacity) {
+    const prevLead = this.lead;
+    if (node === prevLead) return;
+    this.prevLead = prevLead;
+    this.lead = node;
+    node.show();
+    if (prevLead) {
+      prevLead.updateSnapshot();
+      node.scheduleRender();
+      const { layoutDependency: prevDep } = prevLead.options;
+      const { layoutDependency: nextDep } = node.options;
+      if (prevDep === void 0 || prevDep !== nextDep) {
+        node.resumeFrom = prevLead;
+        if (preserveFollowOpacity) prevLead.preserveOpacity = true;
+        if (prevLead.snapshot) {
+          node.snapshot = prevLead.snapshot;
+          node.snapshot.latestValues = prevLead.animationValues || prevLead.latestValues;
+        }
+        if (node.root?.isUpdating) node.isLayoutDirty = true;
+      }
+      if (node.options.crossfade === false) prevLead.hide();
+    }
+  }
+  exitAnimationComplete() {
+    this.members.forEach((member) => {
+      member.options.onExitComplete?.();
+      member.resumingFrom?.options.onExitComplete?.();
+    });
+  }
+  scheduleRender() {
+    this.members.forEach((member) => member.instance && member.scheduleRender(false));
+  }
+  removeLeadSnapshot() {
+    if (this.lead?.snapshot) this.lead.snapshot = void 0;
+  }
+};
+var globalProjectionState = {
+  /**
+  * Global flag as to whether the tree has animated since the last time
+  * we resized the window
+  */
+  hasAnimatedSinceResize: true,
+  /**
+  * We set this to true once, on the first update. Any nodes added to the tree beyond that
+  * update will be given a `data-projection-id` attribute.
+  */
+  hasEverUpdated: false
+};
+var metrics = {
+  nodes: 0,
+  calculatedTargetDeltas: 0,
+  calculatedProjections: 0
+};
+var transformAxes = [
+  "",
+  "X",
+  "Y",
+  "Z"
+];
+var animationTarget = 1e3;
+var id$1 = 0;
+function resetDistortingTransform(key, visualElement, values, sharedAnimationValues) {
+  const { latestValues } = visualElement;
+  if (latestValues[key]) {
+    values[key] = latestValues[key];
+    visualElement.setStaticValue(key, 0);
+    if (sharedAnimationValues) sharedAnimationValues[key] = 0;
+  }
+}
+function cancelTreeOptimisedTransformAnimations(projectionNode) {
+  projectionNode.hasCheckedOptimisedAppear = true;
+  if (projectionNode.root === projectionNode) return;
+  const { visualElement } = projectionNode.options;
+  if (!visualElement) return;
+  const appearId = getOptimisedAppearId(visualElement);
+  if (window.MotionHasOptimisedAnimation(appearId, "transform")) {
+    const { layout: layout2, layoutId } = projectionNode.options;
+    window.MotionCancelOptimisedAnimation(appearId, "transform", frame, !(layout2 || layoutId));
+  }
+  const { parent } = projectionNode;
+  if (parent && !parent.hasCheckedOptimisedAppear) cancelTreeOptimisedTransformAnimations(parent);
+}
+function createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform }) {
+  return class ProjectionNode {
+    constructor(latestValues = {}, parent = defaultParent?.()) {
+      this.id = id$1++;
+      this.animationId = 0;
+      this.animationCommitId = 0;
+      this.children = /* @__PURE__ */ new Set();
+      this.options = {};
+      this.isTreeAnimating = false;
+      this.isAnimationBlocked = false;
+      this.isLayoutDirty = false;
+      this.isProjectionDirty = false;
+      this.isSharedProjectionDirty = false;
+      this.isTransformDirty = false;
+      this.updateManuallyBlocked = false;
+      this.updateBlockedByResize = false;
+      this.isUpdating = false;
+      this.isSVG = false;
+      this.needsReset = false;
+      this.shouldResetTransform = false;
+      this.hasCheckedOptimisedAppear = false;
+      this.treeScale = {
+        x: 1,
+        y: 1
+      };
+      this.eventHandlers = /* @__PURE__ */ new Map();
+      this.hasTreeAnimated = false;
+      this.layoutVersion = 0;
+      this.updateScheduled = false;
+      this.scheduleUpdate = () => this.update();
+      this.projectionUpdateScheduled = false;
+      this.checkUpdateFailed = () => {
+        if (this.isUpdating) {
+          this.isUpdating = false;
+          this.clearAllSnapshots();
+        }
+      };
+      this.updateProjection = () => {
+        this.projectionUpdateScheduled = false;
+        if (statsBuffer.value) metrics.nodes = metrics.calculatedTargetDeltas = metrics.calculatedProjections = 0;
+        this.nodes.forEach(propagateDirtyNodes);
+        this.nodes.forEach(resolveTargetDelta);
+        this.nodes.forEach(calcProjection);
+        this.nodes.forEach(cleanDirtyNodes);
+        if (statsBuffer.addProjectionMetrics) statsBuffer.addProjectionMetrics(metrics);
+      };
+      this.resolvedRelativeTargetAt = 0;
+      this.linkedParentVersion = 0;
+      this.hasProjected = false;
+      this.isVisible = true;
+      this.animationProgress = 0;
+      this.sharedNodes = /* @__PURE__ */ new Map();
+      this.latestValues = latestValues;
+      this.root = parent ? parent.root || parent : this;
+      this.path = parent ? [...parent.path, parent] : [];
+      this.parent = parent;
+      this.depth = parent ? parent.depth + 1 : 0;
+      for (let i = 0; i < this.path.length; i++) this.path[i].shouldResetTransform = true;
+      if (this.root === this) this.nodes = new FlatTree();
+    }
+    addEventListener(name, handler) {
+      if (!this.eventHandlers.has(name)) this.eventHandlers.set(name, new SubscriptionManager());
+      return this.eventHandlers.get(name).add(handler);
+    }
+    notifyListeners(name, ...args) {
+      const subscriptionManager = this.eventHandlers.get(name);
+      subscriptionManager && subscriptionManager.notify(...args);
+    }
+    hasListeners(name) {
+      return this.eventHandlers.has(name);
+    }
+    /**
+    * Lifecycles
+    */
+    mount(instance) {
+      if (this.instance) return;
+      this.isSVG = isSVGElement(instance) && !isSVGSVGElement(instance);
+      this.instance = instance;
+      const { layoutId, layout: layout2, visualElement } = this.options;
+      if (visualElement && !visualElement.current) visualElement.mount(instance);
+      this.root.nodes.add(this);
+      this.parent && this.parent.children.add(this);
+      if (this.root.hasTreeAnimated && (layout2 || layoutId)) this.isLayoutDirty = true;
+      if (attachResizeListener) {
+        let cancelDelay;
+        let innerWidth = 0;
+        const resizeUnblockUpdate = () => this.root.updateBlockedByResize = false;
+        frame.read(() => {
+          innerWidth = window.innerWidth;
+        });
+        attachResizeListener(instance, () => {
+          const newInnerWidth = window.innerWidth;
+          if (newInnerWidth === innerWidth) return;
+          innerWidth = newInnerWidth;
+          this.root.updateBlockedByResize = true;
+          cancelDelay && cancelDelay();
+          cancelDelay = delay$1(resizeUnblockUpdate, 250);
+          if (globalProjectionState.hasAnimatedSinceResize) {
+            globalProjectionState.hasAnimatedSinceResize = false;
+            this.nodes.forEach(finishAnimation);
+          }
+        });
+      }
+      if (layoutId) this.root.registerSharedNode(layoutId, this);
+      if (this.options.animate !== false && visualElement && (layoutId || layout2)) this.addEventListener("didUpdate", ({ delta, hasLayoutChanged, hasRelativeLayoutChanged, layout: newLayout }) => {
+        if (this.isTreeAnimationBlocked()) {
+          this.target = void 0;
+          this.relativeTarget = void 0;
+          return;
+        }
+        const layoutTransition = this.options.transition || visualElement.getDefaultTransition() || defaultLayoutTransition;
+        const { onLayoutAnimationStart, onLayoutAnimationComplete } = visualElement.getProps();
+        const hasTargetChanged = !this.targetLayout || !boxEqualsRounded(this.targetLayout, newLayout);
+        const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeLayoutChanged;
+        if (this.options.layoutRoot || this.resumeFrom || hasOnlyRelativeTargetChanged || hasLayoutChanged && (hasTargetChanged || !this.currentAnimation)) {
+          if (this.resumeFrom) {
+            this.resumingFrom = this.resumeFrom;
+            this.resumingFrom.resumingFrom = void 0;
+          }
+          const animationOptions = {
+            ...getValueTransition(layoutTransition, "layout"),
+            onPlay: onLayoutAnimationStart,
+            onComplete: onLayoutAnimationComplete
+          };
+          if (visualElement.shouldReduceMotion || this.options.layoutRoot) {
+            animationOptions.delay = 0;
+            animationOptions.type = false;
+          }
+          this.startAnimation(animationOptions);
+          this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged, animationOptions.path);
+        } else {
+          if (!hasLayoutChanged) finishAnimation(this);
+          if (this.isLead() && this.options.onExitComplete) this.options.onExitComplete();
+        }
+        this.targetLayout = newLayout;
+      });
+    }
+    unmount() {
+      this.options.layoutId && this.willUpdate();
+      this.root.nodes.remove(this);
+      const stack = this.getStack();
+      stack && stack.remove(this);
+      this.parent && this.parent.children.delete(this);
+      this.instance = void 0;
+      this.eventHandlers.clear();
+      cancelFrame(this.updateProjection);
+    }
+    blockUpdate() {
+      this.updateManuallyBlocked = true;
+    }
+    unblockUpdate() {
+      this.updateManuallyBlocked = false;
+    }
+    isUpdateBlocked() {
+      return this.updateManuallyBlocked || this.updateBlockedByResize;
+    }
+    isTreeAnimationBlocked() {
+      return this.isAnimationBlocked || this.parent && this.parent.isTreeAnimationBlocked() || false;
+    }
+    startUpdate() {
+      if (this.isUpdateBlocked()) return;
+      this.isUpdating = true;
+      this.nodes && this.nodes.forEach(resetSkewAndRotation);
+      this.animationId++;
+    }
+    getTransformTemplate() {
+      const { visualElement } = this.options;
+      return visualElement && visualElement.getProps().transformTemplate;
+    }
+    willUpdate(shouldNotifyListeners = true) {
+      this.root.hasTreeAnimated = true;
+      if (this.root.isUpdateBlocked()) {
+        this.options.onExitComplete && this.options.onExitComplete();
+        return;
+      }
+      if (window.MotionCancelOptimisedAnimation && !this.hasCheckedOptimisedAppear) cancelTreeOptimisedTransformAnimations(this);
+      !this.root.isUpdating && this.root.startUpdate();
+      if (this.isLayoutDirty) return;
+      this.isLayoutDirty = true;
+      for (let i = 0; i < this.path.length; i++) {
+        const node = this.path[i];
+        node.shouldResetTransform = true;
+        if (typeof node.latestValues.x === "string" || typeof node.latestValues.y === "string") node.isLayoutDirty = true;
+        node.updateScroll("snapshot");
+        if (node.options.layoutRoot) node.willUpdate(false);
+      }
+      const { layoutId, layout: layout2 } = this.options;
+      if (layoutId === void 0 && !layout2) return;
+      const transformTemplate = this.getTransformTemplate();
+      this.prevTransformTemplateValue = transformTemplate ? transformTemplate(this.latestValues, "") : void 0;
+      this.updateSnapshot();
+      shouldNotifyListeners && this.notifyListeners("willUpdate");
+    }
+    update() {
+      this.updateScheduled = false;
+      if (this.isUpdateBlocked()) {
+        const wasBlockedByResize = this.updateBlockedByResize;
+        this.unblockUpdate();
+        this.updateBlockedByResize = false;
+        this.clearAllSnapshots();
+        if (wasBlockedByResize) this.nodes.forEach(forceLayoutMeasure);
+        this.nodes.forEach(clearMeasurements);
+        return;
+      }
+      if (this.animationId <= this.animationCommitId) {
+        this.nodes.forEach(clearIsLayoutDirty);
+        return;
+      }
+      this.animationCommitId = this.animationId;
+      if (!this.isUpdating) this.nodes.forEach(clearIsLayoutDirty);
+      else {
+        this.isUpdating = false;
+        this.nodes.forEach(ensureDraggedNodesSnapshotted);
+        this.nodes.forEach(resetTransformStyle);
+        this.nodes.forEach(updateLayout);
+        this.nodes.forEach(notifyLayoutUpdate);
+      }
+      this.clearAllSnapshots();
+      const now2 = time.now();
+      frameData.delta = clamp(0, 1e3 / 60, now2 - frameData.timestamp);
+      frameData.timestamp = now2;
+      frameData.isProcessing = true;
+      frameSteps.update.process(frameData);
+      frameSteps.preRender.process(frameData);
+      frameSteps.render.process(frameData);
+      frameData.isProcessing = false;
+    }
+    didUpdate() {
+      if (!this.updateScheduled) {
+        this.updateScheduled = true;
+        microtask.read(this.scheduleUpdate);
+      }
+    }
+    clearAllSnapshots() {
+      this.nodes.forEach(clearSnapshot);
+      this.sharedNodes.forEach(removeLeadSnapshots);
+    }
+    scheduleUpdateProjection() {
+      if (!this.projectionUpdateScheduled) {
+        this.projectionUpdateScheduled = true;
+        frame.preRender(this.updateProjection, false, true);
+      }
+    }
+    scheduleCheckAfterUnmount() {
+      frame.postRender(() => {
+        if (this.isLayoutDirty) this.root.didUpdate();
+        else this.root.checkUpdateFailed();
+      });
+    }
+    /**
+    * Update measurements
+    */
+    updateSnapshot() {
+      if (this.snapshot || !this.instance) return;
+      this.snapshot = this.measure();
+      if (this.snapshot && !calcLength(this.snapshot.measuredBox.x) && !calcLength(this.snapshot.measuredBox.y)) this.snapshot = void 0;
+    }
+    updateLayout() {
+      if (!this.instance) return;
+      this.updateScroll();
+      if (!(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty) return;
+      if (this.resumeFrom && !this.resumeFrom.instance) for (let i = 0; i < this.path.length; i++) this.path[i].updateScroll();
+      const prevLayout = this.layout;
+      this.layout = this.measure(false);
+      this.layoutVersion++;
+      if (!this.layoutCorrected) this.layoutCorrected = createBox();
+      this.isLayoutDirty = false;
+      this.projectionDelta = void 0;
+      this.notifyListeners("measure", this.layout.layoutBox);
+      const { visualElement } = this.options;
+      visualElement && visualElement.notify("LayoutMeasure", this.layout.layoutBox, prevLayout ? prevLayout.layoutBox : void 0);
+    }
+    updateScroll(phase = "measure") {
+      let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);
+      if (this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === phase) needsMeasurement = false;
+      if (needsMeasurement && this.instance) {
+        const isRoot = checkIsScrollRoot(this.instance);
+        this.scroll = {
+          animationId: this.root.animationId,
+          phase,
+          isRoot,
+          offset: measureScroll(this.instance),
+          wasRoot: this.scroll ? this.scroll.isRoot : isRoot
+        };
+      }
+    }
+    resetTransform() {
+      if (!resetTransform) return;
+      const isResetRequested = this.isLayoutDirty || this.shouldResetTransform || this.options.alwaysMeasureLayout;
+      const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);
+      const transformTemplate = this.getTransformTemplate();
+      const transformTemplateValue = transformTemplate ? transformTemplate(this.latestValues, "") : void 0;
+      const transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;
+      if (isResetRequested && this.instance && (hasProjection || hasTransform(this.latestValues) || transformTemplateHasChanged)) {
+        resetTransform(this.instance, transformTemplateValue);
+        this.shouldResetTransform = false;
+        this.scheduleRender();
+      }
+    }
+    measure(removeTransform = true) {
+      const pageBox = this.measurePageBox();
+      let layoutBox = this.removeElementScroll(pageBox);
+      if (removeTransform) layoutBox = this.removeTransform(layoutBox);
+      roundBox(layoutBox);
+      return {
+        animationId: this.root.animationId,
+        measuredBox: pageBox,
+        layoutBox,
+        latestValues: {},
+        source: this.id
+      };
+    }
+    measurePageBox() {
+      const { visualElement } = this.options;
+      if (!visualElement) return createBox();
+      const box = visualElement.measureViewportBox();
+      if (!(this.scroll?.wasRoot || this.path.some(checkNodeWasScrollRoot))) {
+        const { scroll } = this.root;
+        if (scroll) {
+          translateAxis(box.x, scroll.offset.x);
+          translateAxis(box.y, scroll.offset.y);
+        }
+      }
+      return box;
+    }
+    removeElementScroll(box) {
+      const boxWithoutScroll = createBox();
+      copyBoxInto(boxWithoutScroll, box);
+      if (this.scroll?.wasRoot) return boxWithoutScroll;
+      for (let i = 0; i < this.path.length; i++) {
+        const node = this.path[i];
+        const { scroll, options } = node;
+        if (node !== this.root && scroll && options.layoutScroll) {
+          if (scroll.wasRoot) copyBoxInto(boxWithoutScroll, box);
+          translateAxis(boxWithoutScroll.x, scroll.offset.x);
+          translateAxis(boxWithoutScroll.y, scroll.offset.y);
+        }
+      }
+      return boxWithoutScroll;
+    }
+    applyTransform(box, transformOnly = false, output) {
+      const withTransforms = output || createBox();
+      copyBoxInto(withTransforms, box);
+      for (let i = 0; i < this.path.length; i++) {
+        const node = this.path[i];
+        if (!transformOnly && node.options.layoutScroll && node.scroll && node !== node.root) {
+          translateAxis(withTransforms.x, -node.scroll.offset.x);
+          translateAxis(withTransforms.y, -node.scroll.offset.y);
+        }
+        if (!hasTransform(node.latestValues)) continue;
+        transformBox(withTransforms, node.latestValues, node.layout?.layoutBox);
+      }
+      if (hasTransform(this.latestValues)) transformBox(withTransforms, this.latestValues, this.layout?.layoutBox);
+      return withTransforms;
+    }
+    removeTransform(box) {
+      const boxWithoutTransform = createBox();
+      copyBoxInto(boxWithoutTransform, box);
+      for (let i = 0; i < this.path.length; i++) {
+        const node = this.path[i];
+        if (!hasTransform(node.latestValues)) continue;
+        let sourceBox;
+        if (node.instance) {
+          hasScale(node.latestValues) && node.updateSnapshot();
+          sourceBox = createBox();
+          copyBoxInto(sourceBox, node.measurePageBox());
+        }
+        removeBoxTransforms(boxWithoutTransform, node.latestValues, node.snapshot?.layoutBox, sourceBox);
+      }
+      if (hasTransform(this.latestValues)) removeBoxTransforms(boxWithoutTransform, this.latestValues);
+      return boxWithoutTransform;
+    }
+    setTargetDelta(delta) {
+      this.targetDelta = delta;
+      this.root.scheduleUpdateProjection();
+      this.isProjectionDirty = true;
+    }
+    setOptions(options) {
+      this.options = {
+        ...this.options,
+        ...options,
+        crossfade: options.crossfade !== void 0 ? options.crossfade : true
+      };
+    }
+    clearMeasurements() {
+      this.scroll = void 0;
+      this.layout = void 0;
+      this.snapshot = void 0;
+      this.prevTransformTemplateValue = void 0;
+      this.targetDelta = void 0;
+      this.target = void 0;
+      this.isLayoutDirty = false;
+    }
+    forceRelativeParentToResolveTarget() {
+      if (!this.relativeParent) return;
+      if (this.relativeParent.resolvedRelativeTargetAt !== frameData.timestamp) this.relativeParent.resolveTargetDelta(true);
+    }
+    resolveTargetDelta(forceRecalculation = false) {
+      const lead = this.getLead();
+      this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);
+      this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);
+      this.isSharedProjectionDirty || (this.isSharedProjectionDirty = lead.isSharedProjectionDirty);
+      const isShared = Boolean(this.resumingFrom) || this !== lead;
+      if (!(forceRecalculation || isShared && this.isSharedProjectionDirty || this.isProjectionDirty || this.parent?.isProjectionDirty || this.attemptToResolveRelativeTarget || this.root.updateBlockedByResize)) return;
+      const { layout: layout2, layoutId } = this.options;
+      if (!this.layout || !(layout2 || layoutId)) return;
+      this.resolvedRelativeTargetAt = frameData.timestamp;
+      const relativeParent = this.getClosestProjectingParent();
+      if (relativeParent && this.linkedParentVersion !== relativeParent.layoutVersion && !relativeParent.options.layoutRoot) this.removeRelativeTarget();
+      if (!this.targetDelta && !this.relativeTarget) {
+        if (this.options.layoutAnchor !== false && relativeParent && relativeParent.layout) this.createRelativeTarget(relativeParent, this.layout.layoutBox, relativeParent.layout.layoutBox);
+        else this.removeRelativeTarget();
+      }
+      if (!this.relativeTarget && !this.targetDelta) return;
+      if (!this.target) {
+        this.target = createBox();
+        this.targetWithTransforms = createBox();
+      }
+      if (this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target) {
+        this.forceRelativeParentToResolveTarget();
+        calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target, this.options.layoutAnchor || void 0);
+      } else if (this.targetDelta) {
+        if (Boolean(this.resumingFrom)) this.applyTransform(this.layout.layoutBox, false, this.target);
+        else copyBoxInto(this.target, this.layout.layoutBox);
+        applyBoxDelta(this.target, this.targetDelta);
+      } else
+        copyBoxInto(this.target, this.layout.layoutBox);
+      if (this.attemptToResolveRelativeTarget) {
+        this.attemptToResolveRelativeTarget = false;
+        if (this.options.layoutAnchor !== false && relativeParent && Boolean(relativeParent.resumingFrom) === Boolean(this.resumingFrom) && !relativeParent.options.layoutScroll && relativeParent.target && this.animationProgress !== 1) this.createRelativeTarget(relativeParent, this.target, relativeParent.target);
+        else this.relativeParent = this.relativeTarget = void 0;
+      }
+      if (statsBuffer.value) metrics.calculatedTargetDeltas++;
+    }
+    getClosestProjectingParent() {
+      if (!this.parent || hasScale(this.parent.latestValues) || has2DTranslate(this.parent.latestValues)) return;
+      if (this.parent.isProjecting()) return this.parent;
+      else return this.parent.getClosestProjectingParent();
+    }
+    isProjecting() {
+      return Boolean((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout);
+    }
+    createRelativeTarget(relativeParent, layout2, parentLayout) {
+      this.relativeParent = relativeParent;
+      this.linkedParentVersion = relativeParent.layoutVersion;
+      this.forceRelativeParentToResolveTarget();
+      this.relativeTarget = createBox();
+      this.relativeTargetOrigin = createBox();
+      calcRelativePosition(this.relativeTargetOrigin, layout2, parentLayout, this.options.layoutAnchor || void 0);
+      copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);
+    }
+    removeRelativeTarget() {
+      this.relativeParent = this.relativeTarget = void 0;
+    }
+    calcProjection() {
+      const lead = this.getLead();
+      const isShared = Boolean(this.resumingFrom) || this !== lead;
+      let canSkip = true;
+      if (this.isProjectionDirty || this.parent?.isProjectionDirty) canSkip = false;
+      if (isShared && (this.isSharedProjectionDirty || this.isTransformDirty)) canSkip = false;
+      if (this.resolvedRelativeTargetAt === frameData.timestamp) canSkip = false;
+      if (canSkip) return;
+      const { layout: layout2, layoutId } = this.options;
+      this.isTreeAnimating = Boolean(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation);
+      if (!this.isTreeAnimating) this.targetDelta = this.relativeTarget = void 0;
+      if (!this.layout || !(layout2 || layoutId)) return;
+      copyBoxInto(this.layoutCorrected, this.layout.layoutBox);
+      const prevTreeScaleX = this.treeScale.x;
+      const prevTreeScaleY = this.treeScale.y;
+      applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, isShared);
+      if (lead.layout && !lead.target && (this.treeScale.x !== 1 || this.treeScale.y !== 1)) {
+        lead.target = lead.layout.layoutBox;
+        lead.targetWithTransforms = createBox();
+      }
+      const { target } = lead;
+      if (!target) {
+        if (this.prevProjectionDelta) {
+          this.createProjectionDeltas();
+          this.scheduleRender();
+        }
+        return;
+      }
+      if (!this.projectionDelta || !this.prevProjectionDelta) this.createProjectionDeltas();
+      else {
+        copyAxisDeltaInto(this.prevProjectionDelta.x, this.projectionDelta.x);
+        copyAxisDeltaInto(this.prevProjectionDelta.y, this.projectionDelta.y);
+      }
+      calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);
+      if (this.treeScale.x !== prevTreeScaleX || this.treeScale.y !== prevTreeScaleY || !axisDeltaEquals(this.projectionDelta.x, this.prevProjectionDelta.x) || !axisDeltaEquals(this.projectionDelta.y, this.prevProjectionDelta.y)) {
+        this.hasProjected = true;
+        this.scheduleRender();
+        this.notifyListeners("projectionUpdate", target);
+      }
+      if (statsBuffer.value) metrics.calculatedProjections++;
+    }
+    hide() {
+      this.isVisible = false;
+    }
+    show() {
+      this.isVisible = true;
+    }
+    scheduleRender(notifyAll2 = true) {
+      this.options.visualElement?.scheduleRender();
+      if (notifyAll2) {
+        const stack = this.getStack();
+        stack && stack.scheduleRender();
+      }
+      if (this.resumingFrom && !this.resumingFrom.instance) this.resumingFrom = void 0;
+    }
+    createProjectionDeltas() {
+      this.prevProjectionDelta = createDelta();
+      this.projectionDelta = createDelta();
+      this.projectionDeltaWithTransform = createDelta();
+    }
+    setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false, pathFn) {
+      const snapshot2 = this.snapshot;
+      const snapshotLatestValues = snapshot2 ? snapshot2.latestValues : {};
+      const mixedValues = { ...this.latestValues };
+      const targetDelta = createDelta();
+      if (!this.relativeParent || !this.relativeParent.options.layoutRoot) this.relativeTarget = this.relativeTargetOrigin = void 0;
+      this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;
+      const relativeLayout = createBox();
+      const isSharedLayoutAnimation = (snapshot2 ? snapshot2.source : void 0) !== (this.layout ? this.layout.source : void 0);
+      const stack = this.getStack();
+      const isOnlyMember = !stack || stack.members.length <= 1;
+      const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation && !isOnlyMember && this.options.crossfade === true && !this.path.some(hasOpacityCrossfade));
+      this.animationProgress = 0;
+      let prevRelativeTarget;
+      const interpolate = pathFn?.interpolateProjection(delta);
+      this.mixTargetDelta = (latest) => {
+        const progress2 = latest / 1e3;
+        const point = interpolate?.(progress2);
+        if (point) {
+          targetDelta.x.translate = point.x;
+          targetDelta.x.scale = mixNumber(delta.x.scale, 1, progress2);
+          targetDelta.x.origin = delta.x.origin;
+          targetDelta.x.originPoint = delta.x.originPoint;
+          targetDelta.y.translate = point.y;
+          targetDelta.y.scale = mixNumber(delta.y.scale, 1, progress2);
+          targetDelta.y.origin = delta.y.origin;
+          targetDelta.y.originPoint = delta.y.originPoint;
+        } else {
+          mixAxisDeltaLinear(targetDelta.x, delta.x, progress2);
+          mixAxisDeltaLinear(targetDelta.y, delta.y, progress2);
+        }
+        this.setTargetDelta(targetDelta);
+        if (this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout) {
+          calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox, this.options.layoutAnchor || void 0);
+          mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress2);
+          if (prevRelativeTarget && boxEquals(this.relativeTarget, prevRelativeTarget)) this.isProjectionDirty = false;
+          if (!prevRelativeTarget) prevRelativeTarget = createBox();
+          copyBoxInto(prevRelativeTarget, this.relativeTarget);
+        }
+        if (isSharedLayoutAnimation) {
+          this.animationValues = mixedValues;
+          mixValues(mixedValues, snapshotLatestValues, this.latestValues, progress2, shouldCrossfadeOpacity, isOnlyMember);
+        }
+        if (point && point.rotate !== void 0) {
+          if (!this.animationValues) this.animationValues = mixedValues;
+          this.animationValues.pathRotation = point.rotate;
+        }
+        this.root.scheduleUpdateProjection();
+        this.scheduleRender();
+        this.animationProgress = progress2;
+      };
+      this.mixTargetDelta(this.options.layoutRoot ? 1e3 : 0);
+    }
+    startAnimation(options) {
+      this.notifyListeners("animationStart");
+      this.currentAnimation?.stop();
+      this.resumingFrom?.currentAnimation?.stop();
+      if (this.pendingAnimation) {
+        cancelFrame(this.pendingAnimation);
+        this.pendingAnimation = void 0;
+      }
+      this.pendingAnimation = frame.update(() => {
+        globalProjectionState.hasAnimatedSinceResize = true;
+        this.motionValue || (this.motionValue = motionValue(0));
+        this.motionValue.jump(0, false);
+        this.currentAnimation = animateSingleValue(this.motionValue, [0, 1e3], {
+          ...options,
+          velocity: 0,
+          isSync: true,
+          onUpdate: (latest) => {
+            this.mixTargetDelta(latest);
+            options.onUpdate && options.onUpdate(latest);
+          },
+          onComplete: () => {
+            options.onComplete && options.onComplete();
+            this.completeAnimation();
+          }
+        });
+        if (this.resumingFrom) this.resumingFrom.currentAnimation = this.currentAnimation;
+        this.pendingAnimation = void 0;
+      });
+    }
+    completeAnimation() {
+      if (this.resumingFrom) {
+        this.resumingFrom.currentAnimation = void 0;
+        this.resumingFrom.preserveOpacity = void 0;
+      }
+      const stack = this.getStack();
+      stack && stack.exitAnimationComplete();
+      this.resumingFrom = this.currentAnimation = this.animationValues = void 0;
+      this.notifyListeners("animationComplete");
+    }
+    finishAnimation() {
+      if (this.currentAnimation) {
+        this.mixTargetDelta && this.mixTargetDelta(animationTarget);
+        this.currentAnimation.stop();
+      }
+      this.completeAnimation();
+    }
+    applyTransformsToTarget() {
+      const lead = this.getLead();
+      let { targetWithTransforms, target, layout: layout2, latestValues } = lead;
+      if (!targetWithTransforms || !target || !layout2) return;
+      if (this !== lead && this.layout && layout2 && shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout2.layoutBox)) {
+        target = this.target || createBox();
+        const xLength = calcLength(this.layout.layoutBox.x);
+        target.x.min = lead.target.x.min;
+        target.x.max = target.x.min + xLength;
+        const yLength = calcLength(this.layout.layoutBox.y);
+        target.y.min = lead.target.y.min;
+        target.y.max = target.y.min + yLength;
+      }
+      copyBoxInto(targetWithTransforms, target);
+      transformBox(targetWithTransforms, latestValues);
+      calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);
+    }
+    registerSharedNode(layoutId, node) {
+      if (!this.sharedNodes.has(layoutId)) this.sharedNodes.set(layoutId, new NodeStack());
+      this.sharedNodes.get(layoutId).add(node);
+      const config = node.options.initialPromotionConfig;
+      node.promote({
+        transition: config ? config.transition : void 0,
+        preserveFollowOpacity: config && config.shouldPreserveFollowOpacity ? config.shouldPreserveFollowOpacity(node) : void 0
+      });
+    }
+    isLead() {
+      const stack = this.getStack();
+      return stack ? stack.lead === this : true;
+    }
+    getLead() {
+      const { layoutId } = this.options;
+      return layoutId ? this.getStack()?.lead || this : this;
+    }
+    getPrevLead() {
+      const { layoutId } = this.options;
+      return layoutId ? this.getStack()?.prevLead : void 0;
+    }
+    getStack() {
+      const { layoutId } = this.options;
+      if (layoutId) return this.root.sharedNodes.get(layoutId);
+    }
+    promote({ needsReset, transition, preserveFollowOpacity } = {}) {
+      const stack = this.getStack();
+      if (stack) stack.promote(this, preserveFollowOpacity);
+      if (needsReset) {
+        this.projectionDelta = void 0;
+        this.needsReset = true;
+      }
+      if (transition) this.setOptions({ transition });
+    }
+    relegate() {
+      const stack = this.getStack();
+      if (stack) return stack.relegate(this);
+      else return false;
+    }
+    resetSkewAndRotation() {
+      const { visualElement } = this.options;
+      if (!visualElement) return;
+      let hasDistortingTransform = false;
+      const { latestValues } = visualElement;
+      if (latestValues.z || latestValues.rotate || latestValues.rotateX || latestValues.rotateY || latestValues.rotateZ || latestValues.skewX || latestValues.skewY) hasDistortingTransform = true;
+      if (!hasDistortingTransform) return;
+      const resetValues = {};
+      if (latestValues.z) resetDistortingTransform("z", visualElement, resetValues, this.animationValues);
+      for (let i = 0; i < transformAxes.length; i++) {
+        resetDistortingTransform(`rotate${transformAxes[i]}`, visualElement, resetValues, this.animationValues);
+        resetDistortingTransform(`skew${transformAxes[i]}`, visualElement, resetValues, this.animationValues);
+      }
+      visualElement.render();
+      for (const key in resetValues) {
+        visualElement.setStaticValue(key, resetValues[key]);
+        if (this.animationValues) this.animationValues[key] = resetValues[key];
+      }
+      visualElement.scheduleRender();
+    }
+    applyProjectionStyles(targetStyle, styleProp) {
+      if (!this.instance || this.isSVG) return;
+      if (!this.isVisible) {
+        targetStyle.visibility = "hidden";
+        return;
+      }
+      const transformTemplate = this.getTransformTemplate();
+      if (this.needsReset) {
+        this.needsReset = false;
+        targetStyle.visibility = "";
+        targetStyle.opacity = "";
+        targetStyle.pointerEvents = resolveMotionValue(styleProp?.pointerEvents) || "";
+        targetStyle.transform = transformTemplate ? transformTemplate(this.latestValues, "") : "none";
+        return;
+      }
+      const lead = this.getLead();
+      if (!this.projectionDelta || !this.layout || !lead.target) {
+        if (this.options.layoutId) {
+          targetStyle.opacity = this.latestValues.opacity !== void 0 ? this.latestValues.opacity : 1;
+          targetStyle.pointerEvents = resolveMotionValue(styleProp?.pointerEvents) || "";
+        }
+        if (this.hasProjected && !hasTransform(this.latestValues)) {
+          targetStyle.transform = transformTemplate ? transformTemplate({}, "") : "none";
+          this.hasProjected = false;
+        }
+        return;
+      }
+      targetStyle.visibility = "";
+      const valuesToRender = lead.animationValues || lead.latestValues;
+      this.applyTransformsToTarget();
+      let transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);
+      if (transformTemplate) transform = transformTemplate(valuesToRender, transform);
+      targetStyle.transform = transform;
+      const { x, y } = this.projectionDelta;
+      targetStyle.transformOrigin = `${x.origin * 100}% ${y.origin * 100}% 0`;
+      if (lead.animationValues)
+        targetStyle.opacity = lead === this ? valuesToRender.opacity ?? this.latestValues.opacity ?? 1 : this.preserveOpacity ? this.latestValues.opacity : valuesToRender.opacityExit;
+      else
+        targetStyle.opacity = lead === this ? valuesToRender.opacity !== void 0 ? valuesToRender.opacity : "" : valuesToRender.opacityExit !== void 0 ? valuesToRender.opacityExit : 0;
+      for (const key in scaleCorrectors) {
+        if (valuesToRender[key] === void 0) continue;
+        const { correct, applyTo, isCSSVariable } = scaleCorrectors[key];
+        const corrected = transform === "none" ? valuesToRender[key] : correct(valuesToRender[key], lead);
+        if (applyTo) {
+          const num = applyTo.length;
+          for (let i = 0; i < num; i++) targetStyle[applyTo[i]] = corrected;
+        } else if (isCSSVariable) this.options.visualElement.renderState.vars[key] = corrected;
+        else targetStyle[key] = corrected;
+      }
+      if (this.options.layoutId) targetStyle.pointerEvents = lead === this ? resolveMotionValue(styleProp?.pointerEvents) || "" : "none";
+    }
+    clearSnapshot() {
+      this.resumeFrom = this.snapshot = void 0;
+    }
+    resetTree() {
+      this.root.nodes.forEach((node) => node.currentAnimation?.stop());
+      this.root.nodes.forEach(clearMeasurements);
+      this.root.sharedNodes.clear();
+    }
+  };
+}
+function updateLayout(node) {
+  node.updateLayout();
+}
+function notifyLayoutUpdate(node) {
+  const snapshot2 = node.resumeFrom?.snapshot || node.snapshot;
+  if (node.isLead() && node.layout && snapshot2 && node.hasListeners("didUpdate")) {
+    const { layoutBox: layout2, measuredBox: measuredLayout } = node.layout;
+    const { animationType } = node.options;
+    const isShared = snapshot2.source !== node.layout.source;
+    if (animationType === "size") eachAxis((axis) => {
+      const axisSnapshot = isShared ? snapshot2.measuredBox[axis] : snapshot2.layoutBox[axis];
+      const length = calcLength(axisSnapshot);
+      axisSnapshot.min = layout2[axis].min;
+      axisSnapshot.max = axisSnapshot.min + length;
+    });
+    else if (animationType === "x" || animationType === "y") {
+      const snapAxis = animationType === "x" ? "y" : "x";
+      copyAxisInto(isShared ? snapshot2.measuredBox[snapAxis] : snapshot2.layoutBox[snapAxis], layout2[snapAxis]);
+    } else if (shouldAnimatePositionOnly(animationType, snapshot2.layoutBox, layout2)) eachAxis((axis) => {
+      const axisSnapshot = isShared ? snapshot2.measuredBox[axis] : snapshot2.layoutBox[axis];
+      const length = calcLength(layout2[axis]);
+      axisSnapshot.max = axisSnapshot.min + length;
+      if (node.relativeTarget && !node.currentAnimation) {
+        node.isProjectionDirty = true;
+        node.relativeTarget[axis].max = node.relativeTarget[axis].min + length;
+      }
+    });
+    const layoutDelta = createDelta();
+    calcBoxDelta(layoutDelta, layout2, snapshot2.layoutBox);
+    const visualDelta = createDelta();
+    if (isShared) calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot2.measuredBox);
+    else calcBoxDelta(visualDelta, layout2, snapshot2.layoutBox);
+    const hasLayoutChanged = !isDeltaZero(layoutDelta);
+    let hasRelativeLayoutChanged = false;
+    if (!node.resumeFrom) {
+      const relativeParent = node.getClosestProjectingParent();
+      if (relativeParent && !relativeParent.resumeFrom) {
+        const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;
+        if (parentSnapshot && parentLayout) {
+          const anchor = node.options.layoutAnchor || void 0;
+          const relativeSnapshot = createBox();
+          calcRelativePosition(relativeSnapshot, snapshot2.layoutBox, parentSnapshot.layoutBox, anchor);
+          const relativeLayout = createBox();
+          calcRelativePosition(relativeLayout, layout2, parentLayout.layoutBox, anchor);
+          if (!boxEqualsRounded(relativeSnapshot, relativeLayout)) hasRelativeLayoutChanged = true;
+          if (relativeParent.options.layoutRoot) {
+            node.relativeTarget = relativeLayout;
+            node.relativeTargetOrigin = relativeSnapshot;
+            node.relativeParent = relativeParent;
+          }
+        }
+      }
+    }
+    node.notifyListeners("didUpdate", {
+      layout: layout2,
+      snapshot: snapshot2,
+      delta: visualDelta,
+      layoutDelta,
+      hasLayoutChanged,
+      hasRelativeLayoutChanged
+    });
+  } else if (node.isLead()) {
+    const { onExitComplete } = node.options;
+    onExitComplete && onExitComplete();
+  }
+  node.options.transition = void 0;
+}
+function propagateDirtyNodes(node) {
+  if (statsBuffer.value) metrics.nodes++;
+  if (!node.parent) return;
+  if (!node.isProjecting()) node.isProjectionDirty = node.parent.isProjectionDirty;
+  node.isSharedProjectionDirty || (node.isSharedProjectionDirty = Boolean(node.isProjectionDirty || node.parent.isProjectionDirty || node.parent.isSharedProjectionDirty));
+  node.isTransformDirty || (node.isTransformDirty = node.parent.isTransformDirty);
+}
+function cleanDirtyNodes(node) {
+  node.isProjectionDirty = node.isSharedProjectionDirty = node.isTransformDirty = false;
+}
+function clearSnapshot(node) {
+  node.clearSnapshot();
+}
+function clearMeasurements(node) {
+  node.clearMeasurements();
+}
+function forceLayoutMeasure(node) {
+  node.isLayoutDirty = true;
+  node.updateLayout();
+}
+function clearIsLayoutDirty(node) {
+  node.isLayoutDirty = false;
+}
+function ensureDraggedNodesSnapshotted(node) {
+  if (node.isAnimationBlocked && node.layout && !node.isLayoutDirty) {
+    node.snapshot = node.layout;
+    node.isLayoutDirty = true;
+  }
+}
+function resetTransformStyle(node) {
+  const { visualElement } = node.options;
+  if (visualElement && visualElement.getProps().onBeforeLayoutMeasure) visualElement.notify("BeforeLayoutMeasure");
+  node.resetTransform();
+}
+function finishAnimation(node) {
+  node.finishAnimation();
+  node.targetDelta = node.relativeTarget = node.target = void 0;
+  node.isProjectionDirty = true;
+}
+function resolveTargetDelta(node) {
+  node.resolveTargetDelta();
+}
+function calcProjection(node) {
+  node.calcProjection();
+}
+function resetSkewAndRotation(node) {
+  node.resetSkewAndRotation();
+}
+function removeLeadSnapshots(stack) {
+  stack.removeLeadSnapshot();
+}
+function mixAxisDeltaLinear(output, delta, p) {
+  output.translate = mixNumber(delta.translate, 0, p);
+  output.scale = mixNumber(delta.scale, 1, p);
+  output.origin = delta.origin;
+  output.originPoint = delta.originPoint;
+}
+function mixAxis(output, from, to, p) {
+  output.min = mixNumber(from.min, to.min, p);
+  output.max = mixNumber(from.max, to.max, p);
+}
+function mixBox(output, from, to, p) {
+  mixAxis(output.x, from.x, to.x, p);
+  mixAxis(output.y, from.y, to.y, p);
+}
+function hasOpacityCrossfade(node) {
+  return node.animationValues && node.animationValues.opacityExit !== void 0;
+}
+var defaultLayoutTransition = {
+  duration: 0.45,
+  ease: [
+    0.4,
+    0,
+    0.1,
+    1
+  ]
+};
+var userAgentContains = (string) => typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().includes(string);
+var roundPoint = userAgentContains("applewebkit/") && !userAgentContains("chrome/") ? Math.round : noop;
+function roundAxis(axis) {
+  axis.min = roundPoint(axis.min);
+  axis.max = roundPoint(axis.max);
+}
+function roundBox(box) {
+  roundAxis(box.x);
+  roundAxis(box.y);
+}
+function shouldAnimatePositionOnly(animationType, snapshot2, layout2) {
+  return animationType === "position" || animationType === "preserve-aspect" && !isNear(aspectRatio(snapshot2), aspectRatio(layout2), 0.2);
+}
+function checkNodeWasScrollRoot(node) {
+  return node !== node.root && node.scroll?.wasRoot;
+}
+var DocumentProjectionNode = createProjectionNode({
+  attachResizeListener: (ref, notify) => addDomEvent(ref, "resize", notify),
+  measureScroll: () => ({
+    x: document.documentElement.scrollLeft || document.body?.scrollLeft || 0,
+    y: document.documentElement.scrollTop || document.body?.scrollTop || 0
+  }),
+  checkIsScrollRoot: () => true
+});
+var rootProjectionNode = { current: void 0 };
+var HTMLProjectionNode = createProjectionNode({
+  measureScroll: (instance) => ({
+    x: instance.scrollLeft,
+    y: instance.scrollTop
+  }),
+  defaultParent: () => {
+    if (!rootProjectionNode.current) {
+      const documentNode = new DocumentProjectionNode({});
+      documentNode.mount(window);
+      documentNode.setOptions({ layoutScroll: true });
+      rootProjectionNode.current = documentNode;
+    }
+    return rootProjectionNode.current;
+  },
+  resetTransform: (instance, value) => {
+    instance.style.transform = value !== void 0 ? value : "none";
+  },
+  checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === "fixed")
+});
+function LazyMotion({ children, features, strict = false }) {
+  const [, setIsLoaded] = useState(!isLazyBundle(features));
+  const loadedRenderer = useRef(void 0);
+  if (!isLazyBundle(features)) {
+    const { renderer, ...loadedFeatures } = features;
+    loadedRenderer.current = renderer;
+    loadFeatures(loadedFeatures);
+  }
+  useEffect(() => {
+    if (isLazyBundle(features)) features().then(({ renderer, ...loadedFeatures }) => {
+      loadFeatures(loadedFeatures);
+      loadedRenderer.current = renderer;
+      setIsLoaded(true);
+    });
+  }, []);
+  return jsx(LazyContext.Provider, {
+    value: {
+      renderer: loadedRenderer.current,
+      strict
+    },
+    children
+  });
+}
+function isLazyBundle(features) {
+  return typeof features === "function";
+}
+var createDomVisualElement = (Component2, options) => {
+  return options.isSVG ?? isSVGComponent(Component2) ? new SVGVisualElement(options) : new HTMLVisualElement(options, { allowProjection: Component2 !== Fragment });
+};
+var AnimationFeature = class extends Feature {
+  /**
+  * We dynamically generate the AnimationState manager as it contains a reference
+  * to the underlying animation library. We only want to load that if we load this,
+  * so people can optionally code split it out using the `m` component.
+  */
+  constructor(node) {
+    super(node);
+    node.animationState || (node.animationState = createAnimationState(node));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate } = this.node.getProps();
+    if (isAnimationControls(animate)) this.unmountControls = animate.subscribe(this.node);
+  }
+  /**
+  * Subscribe any provided AnimationControls to the component's VisualElement
+  */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate } = this.node.getProps();
+    const { animate: prevAnimate } = this.node.prevProps || {};
+    if (animate !== prevAnimate) this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    this.node.animationState.reset();
+    this.unmountControls?.();
+  }
+};
+var id = 0;
+var ExitAnimationFeature = class extends Feature {
+  constructor() {
+    super(...arguments);
+    this.id = id++;
+    this.isExitComplete = false;
+  }
+  update() {
+    if (!this.node.presenceContext) return;
+    const { isPresent, onExitComplete } = this.node.presenceContext;
+    const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || isPresent === prevIsPresent) return;
+    if (isPresent && prevIsPresent === false) {
+      if (this.isExitComplete) {
+        const { initial, custom } = this.node.getProps();
+        if (typeof initial === "string" || typeof initial === "object" && initial !== null && !Array.isArray(initial)) {
+          const resolved = resolveVariant(this.node, initial, custom);
+          if (resolved) {
+            const { transition, transitionEnd, ...target } = resolved;
+            for (const key in target) this.node.getValue(key)?.jump(target[key]);
+          }
+        }
+        this.node.animationState.reset();
+        this.node.animationState.animateChanges();
+      } else this.node.animationState.setActive("exit", false);
+      this.isExitComplete = false;
+      return;
+    }
+    const exitAnimation = this.node.animationState.setActive("exit", !isPresent);
+    if (onExitComplete && !isPresent) exitAnimation.then(() => {
+      this.isExitComplete = true;
+      onExitComplete(this.id);
+    });
+  }
+  mount() {
+    const { register, onExitComplete } = this.node.presenceContext || {};
+    if (onExitComplete) onExitComplete(this.id);
+    if (register) this.unmount = register(this.id);
+  }
+  unmount() {
+  }
+};
+var animations = {
+  animation: { Feature: AnimationFeature },
+  exit: { Feature: ExitAnimationFeature }
+};
+function extractEventInfo(event) {
+  return { point: {
+    x: event.pageX,
+    y: event.pageY
+  } };
+}
+var addPointerInfo = (handler) => (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));
+function addPointerEvent(target, eventName, handler, options) {
+  return addDomEvent(target, eventName, addPointerInfo(handler), options);
+}
+var getContextWindow = ({ current }) => {
+  return current ? current.ownerDocument.defaultView : null;
+};
+var distance = (a, b) => Math.abs(a - b);
+function distance2D(a, b) {
+  const xDelta = distance(a.x, b.x);
+  const yDelta = distance(a.y, b.y);
+  return Math.sqrt(xDelta ** 2 + yDelta ** 2);
+}
+var overflowStyles = /* @__PURE__ */ new Set(["auto", "scroll"]);
+var PanSession = class {
+  constructor(event, handlers, { transformPagePoint, contextWindow = window, dragSnapToOrigin = false, distanceThreshold = 3, element } = {}) {
+    this.startEvent = null;
+    this.lastMoveEvent = null;
+    this.lastMoveEventInfo = null;
+    this.lastRawMoveEventInfo = null;
+    this.handlers = {};
+    this.contextWindow = window;
+    this.scrollPositions = /* @__PURE__ */ new Map();
+    this.removeScrollListeners = null;
+    this.onElementScroll = (event2) => {
+      this.handleScroll(event2.target);
+    };
+    this.onWindowScroll = () => {
+      this.handleScroll(window);
+    };
+    this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo)) return;
+      if (this.lastRawMoveEventInfo) this.lastMoveEventInfo = transformPoint(this.lastRawMoveEventInfo, this.transformPagePoint);
+      const info = getPanInfo(this.lastMoveEventInfo, this.history);
+      const isPanStarted = this.startEvent !== null;
+      const isDistancePastThreshold = distance2D(info.offset, {
+        x: 0,
+        y: 0
+      }) >= this.distanceThreshold;
+      if (!isPanStarted && !isDistancePastThreshold) return;
+      const { point: point2 } = info;
+      const { timestamp: timestamp2 } = frameData;
+      this.history.push({
+        ...point2,
+        timestamp: timestamp2
+      });
+      const { onStart, onMove } = this.handlers;
+      if (!isPanStarted) {
+        onStart && onStart(this.lastMoveEvent, info);
+        this.startEvent = this.lastMoveEvent;
+      }
+      onMove && onMove(this.lastMoveEvent, info);
+    };
+    this.handlePointerMove = (event2, info) => {
+      this.lastMoveEvent = event2;
+      this.lastRawMoveEventInfo = info;
+      this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);
+      frame.update(this.updatePoint, true);
+    };
+    this.handlePointerUp = (event2, info) => {
+      this.end();
+      const { onEnd, onSessionEnd, resumeAnimation } = this.handlers;
+      if (this.dragSnapToOrigin || !this.startEvent) resumeAnimation && resumeAnimation();
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo)) return;
+      const panInfo = getPanInfo(event2.type === "pointercancel" ? this.lastMoveEventInfo : transformPoint(info, this.transformPagePoint), this.history);
+      if (this.startEvent && onEnd) onEnd(event2, panInfo);
+      onSessionEnd && onSessionEnd(event2, panInfo);
+    };
+    if (!isPrimaryPointer(event)) return;
+    this.dragSnapToOrigin = dragSnapToOrigin;
+    this.handlers = handlers;
+    this.transformPagePoint = transformPagePoint;
+    this.distanceThreshold = distanceThreshold;
+    this.contextWindow = contextWindow || window;
+    const initialInfo = transformPoint(extractEventInfo(event), this.transformPagePoint);
+    const { point } = initialInfo;
+    const { timestamp } = frameData;
+    this.history = [{
+      ...point,
+      timestamp
+    }];
+    const { onSessionStart } = handlers;
+    onSessionStart && onSessionStart(event, getPanInfo(initialInfo, this.history));
+    const eventOptions = {
+      passive: true,
+      capture: true
+    };
+    this.removeListeners = pipe(addPointerEvent(this.contextWindow, "pointermove", this.handlePointerMove, eventOptions), addPointerEvent(this.contextWindow, "pointerup", this.handlePointerUp, eventOptions), addPointerEvent(this.contextWindow, "pointercancel", this.handlePointerUp, eventOptions));
+    if (element) this.startScrollTracking(element);
+  }
+  /**
+  * Start tracking scroll on ancestors and window.
+  */
+  startScrollTracking(element) {
+    let current = element.parentElement;
+    while (current) {
+      const style = getComputedStyle(current);
+      if (overflowStyles.has(style.overflowX) || overflowStyles.has(style.overflowY)) this.scrollPositions.set(current, {
+        x: current.scrollLeft,
+        y: current.scrollTop
+      });
+      current = current.parentElement;
+    }
+    this.scrollPositions.set(window, {
+      x: window.scrollX,
+      y: window.scrollY
+    });
+    window.addEventListener("scroll", this.onElementScroll, { capture: true });
+    window.addEventListener("scroll", this.onWindowScroll);
+    this.removeScrollListeners = () => {
+      window.removeEventListener("scroll", this.onElementScroll, { capture: true });
+      window.removeEventListener("scroll", this.onWindowScroll);
+    };
+  }
+  /**
+  * Handle scroll compensation during drag.
+  *
+  * For element scroll: adjusts history origin since pageX/pageY doesn't change.
+  * For window scroll: adjusts lastMoveEventInfo since pageX/pageY would change.
+  */
+  handleScroll(target) {
+    const initial = this.scrollPositions.get(target);
+    if (!initial) return;
+    const isWindow = target === window;
+    const current = isWindow ? {
+      x: window.scrollX,
+      y: window.scrollY
+    } : {
+      x: target.scrollLeft,
+      y: target.scrollTop
+    };
+    const delta = {
+      x: current.x - initial.x,
+      y: current.y - initial.y
+    };
+    if (delta.x === 0 && delta.y === 0) return;
+    if (isWindow) {
+      if (this.lastMoveEventInfo) {
+        this.lastMoveEventInfo.point.x += delta.x;
+        this.lastMoveEventInfo.point.y += delta.y;
+      }
+    } else if (this.history.length > 0) {
+      this.history[0].x -= delta.x;
+      this.history[0].y -= delta.y;
+    }
+    this.scrollPositions.set(target, current);
+    frame.update(this.updatePoint, true);
+  }
+  updateHandlers(handlers) {
+    this.handlers = handlers;
+  }
+  end() {
+    this.removeListeners && this.removeListeners();
+    this.removeScrollListeners && this.removeScrollListeners();
+    this.scrollPositions.clear();
+    cancelFrame(this.updatePoint);
+  }
+};
+function transformPoint(info, transformPagePoint) {
+  return transformPagePoint ? { point: transformPagePoint(info.point) } : info;
+}
+function subtractPoint(a, b) {
+  return {
+    x: a.x - b.x,
+    y: a.y - b.y
+  };
+}
+function getPanInfo({ point }, history) {
+  return {
+    point,
+    delta: subtractPoint(point, lastDevicePoint(history)),
+    offset: subtractPoint(point, startDevicePoint(history)),
+    velocity: getVelocity(history, 0.1)
+  };
+}
+function startDevicePoint(history) {
+  return history[0];
+}
+function lastDevicePoint(history) {
+  return history[history.length - 1];
+}
+function getVelocity(history, timeDelta) {
+  if (history.length < 2) return {
+    x: 0,
+    y: 0
+  };
+  let i = history.length - 1;
+  let timestampedPoint = null;
+  const lastPoint = lastDevicePoint(history);
+  while (i >= 0) {
+    timestampedPoint = history[i];
+    if (lastPoint.timestamp - timestampedPoint.timestamp > secondsToMilliseconds(timeDelta)) break;
+    i--;
+  }
+  if (!timestampedPoint) return {
+    x: 0,
+    y: 0
+  };
+  if (timestampedPoint === history[0] && history.length > 2 && lastPoint.timestamp - timestampedPoint.timestamp > secondsToMilliseconds(timeDelta) * 2) timestampedPoint = history[1];
+  const time2 = millisecondsToSeconds(lastPoint.timestamp - timestampedPoint.timestamp);
+  if (time2 === 0) return {
+    x: 0,
+    y: 0
+  };
+  const currentVelocity = {
+    x: (lastPoint.x - timestampedPoint.x) / time2,
+    y: (lastPoint.y - timestampedPoint.y) / time2
+  };
+  if (currentVelocity.x === Infinity) currentVelocity.x = 0;
+  if (currentVelocity.y === Infinity) currentVelocity.y = 0;
+  return currentVelocity;
+}
+function applyConstraints(point, { min, max }, elastic) {
+  if (min !== void 0 && point < min) point = elastic ? mixNumber(min, point, elastic.min) : Math.max(point, min);
+  else if (max !== void 0 && point > max) point = elastic ? mixNumber(max, point, elastic.max) : Math.min(point, max);
+  return point;
+}
+function calcRelativeAxisConstraints(axis, min, max) {
+  return {
+    min: min !== void 0 ? axis.min + min : void 0,
+    max: max !== void 0 ? axis.max + max - (axis.max - axis.min) : void 0
+  };
+}
+function calcRelativeConstraints(layoutBox, { top, left, bottom, right }) {
+  return {
+    x: calcRelativeAxisConstraints(layoutBox.x, left, right),
+    y: calcRelativeAxisConstraints(layoutBox.y, top, bottom)
+  };
+}
+function calcViewportAxisConstraints(layoutAxis, constraintsAxis) {
+  let min = constraintsAxis.min - layoutAxis.min;
+  let max = constraintsAxis.max - layoutAxis.max;
+  if (constraintsAxis.max - constraintsAxis.min < layoutAxis.max - layoutAxis.min) [min, max] = [max, min];
+  return {
+    min,
+    max
+  };
+}
+function calcViewportConstraints(layoutBox, constraintsBox) {
+  return {
+    x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),
+    y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y)
+  };
+}
+function calcOrigin(source, target) {
+  let origin = 0.5;
+  const sourceLength = calcLength(source);
+  const targetLength = calcLength(target);
+  if (targetLength > sourceLength) origin = progress(target.min, target.max - sourceLength, source.min);
+  else if (sourceLength > targetLength) origin = progress(source.min, source.max - targetLength, target.min);
+  return clamp(0, 1, origin);
+}
+function rebaseAxisConstraints(layout2, constraints) {
+  const relativeConstraints = {};
+  if (constraints.min !== void 0) relativeConstraints.min = constraints.min - layout2.min;
+  if (constraints.max !== void 0) relativeConstraints.max = constraints.max - layout2.min;
+  return relativeConstraints;
+}
+var defaultElastic = 0.35;
+function resolveDragElastic(dragElastic = defaultElastic) {
+  if (dragElastic === false) dragElastic = 0;
+  else if (dragElastic === true) dragElastic = defaultElastic;
+  return {
+    x: resolveAxisElastic(dragElastic, "left", "right"),
+    y: resolveAxisElastic(dragElastic, "top", "bottom")
+  };
+}
+function resolveAxisElastic(dragElastic, minLabel, maxLabel) {
+  return {
+    min: resolvePointElastic(dragElastic, minLabel),
+    max: resolvePointElastic(dragElastic, maxLabel)
+  };
+}
+function resolvePointElastic(dragElastic, label) {
+  return typeof dragElastic === "number" ? dragElastic : dragElastic[label] || 0;
+}
+var elementDragControls = /* @__PURE__ */ new WeakMap();
+var VisualElementDragControls = class {
+  constructor(visualElement) {
+    this.openDragLock = null;
+    this.isDragging = false;
+    this.currentDirection = null;
+    this.originPoint = {
+      x: 0,
+      y: 0
+    };
+    this.constraints = false;
+    this.hasMutatedConstraints = false;
+    this.elastic = createBox();
+    this.latestPointerEvent = null;
+    this.latestPanInfo = null;
+    this.visualElement = visualElement;
+  }
+  start(originEvent, { snapToCursor = false, distanceThreshold } = {}) {
+    const { presenceContext } = this.visualElement;
+    if (presenceContext && presenceContext.isPresent === false) return;
+    const onSessionStart = (event) => {
+      if (snapToCursor) this.snapToCursor(extractEventInfo(event).point);
+      this.stopAnimation();
+    };
+    const onStart = (event, info) => {
+      const { drag: drag2, dragPropagation, onDragStart } = this.getProps();
+      if (drag2 && !dragPropagation) {
+        if (this.openDragLock) this.openDragLock();
+        this.openDragLock = setDragLock(drag2);
+        if (!this.openDragLock) return;
+      }
+      this.latestPointerEvent = event;
+      this.latestPanInfo = info;
+      this.isDragging = true;
+      this.currentDirection = null;
+      this.resolveConstraints();
+      if (this.visualElement.projection) {
+        this.visualElement.projection.isAnimationBlocked = true;
+        this.visualElement.projection.target = void 0;
+      }
+      eachAxis((axis) => {
+        let current = this.getAxisMotionValue(axis).get() || 0;
+        if (percent.test(current)) {
+          const { projection } = this.visualElement;
+          if (projection && projection.layout) {
+            const measuredAxis = projection.layout.layoutBox[axis];
+            if (measuredAxis) current = calcLength(measuredAxis) * (parseFloat(current) / 100);
+          }
+        }
+        this.originPoint[axis] = current;
+      });
+      if (onDragStart) frame.update(() => onDragStart(event, info), false, true);
+      addValueToWillChange(this.visualElement, "transform");
+      const { animationState } = this.visualElement;
+      animationState && animationState.setActive("whileDrag", true);
+    };
+    const onMove = (event, info) => {
+      this.latestPointerEvent = event;
+      this.latestPanInfo = info;
+      const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag } = this.getProps();
+      if (!dragPropagation && !this.openDragLock) return;
+      const { offset } = info;
+      if (dragDirectionLock && this.currentDirection === null) {
+        this.currentDirection = getCurrentDirection(offset);
+        if (this.currentDirection !== null) onDirectionLock && onDirectionLock(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", info.point, offset);
+      this.updateAxis("y", info.point, offset);
+      this.visualElement.render();
+      if (onDrag) frame.update(() => onDrag(event, info), false, true);
+    };
+    const onSessionEnd = (event, info) => {
+      this.latestPointerEvent = event;
+      this.latestPanInfo = info;
+      this.stop(event, info);
+      this.latestPointerEvent = null;
+      this.latestPanInfo = null;
+    };
+    const resumeAnimation = () => {
+      const { dragSnapToOrigin: snap } = this.getProps();
+      if (snap || this.constraints) this.startAnimation({
+        x: 0,
+        y: 0
+      });
+    };
+    const { dragSnapToOrigin } = this.getProps();
+    this.panSession = new PanSession(originEvent, {
+      onSessionStart,
+      onStart,
+      onMove,
+      onSessionEnd,
+      resumeAnimation
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin,
+      distanceThreshold,
+      contextWindow: getContextWindow(this.visualElement),
+      element: this.visualElement.current
+    });
+  }
+  /**
+  * @internal
+  */
+  stop(event, panInfo) {
+    const finalEvent = event || this.latestPointerEvent;
+    const finalPanInfo = panInfo || this.latestPanInfo;
+    const isDragging2 = this.isDragging;
+    this.cancel();
+    if (!isDragging2 || !finalPanInfo || !finalEvent) return;
+    const { velocity } = finalPanInfo;
+    this.startAnimation(velocity);
+    const { onDragEnd } = this.getProps();
+    if (onDragEnd) frame.postRender(() => onDragEnd(finalEvent, finalPanInfo));
+  }
+  /**
+  * @internal
+  */
+  cancel() {
+    this.isDragging = false;
+    const { projection, animationState } = this.visualElement;
+    if (projection) projection.isAnimationBlocked = false;
+    this.endPanSession();
+    const { dragPropagation } = this.getProps();
+    if (!dragPropagation && this.openDragLock) {
+      this.openDragLock();
+      this.openDragLock = null;
+    }
+    animationState && animationState.setActive("whileDrag", false);
+  }
+  /**
+  * Clean up the pan session without modifying other drag state.
+  * This is used during unmount to ensure event listeners are removed
+  * without affecting projection animations or drag locks.
+  * @internal
+  */
+  endPanSession() {
+    this.panSession && this.panSession.end();
+    this.panSession = void 0;
+  }
+  updateAxis(axis, _point, offset) {
+    const { drag: drag2 } = this.getProps();
+    if (!offset || !shouldDrag(axis, drag2, this.currentDirection)) return;
+    const axisValue = this.getAxisMotionValue(axis);
+    let next = this.originPoint[axis] + offset[axis];
+    if (this.constraints && this.constraints[axis]) next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);
+    axisValue.set(next);
+  }
+  resolveConstraints() {
+    const { dragConstraints, dragElastic } = this.getProps();
+    const layout2 = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(false) : this.visualElement.projection?.layout;
+    const prevConstraints = this.constraints;
+    if (dragConstraints && isRefObject(dragConstraints)) {
+      if (!this.constraints) this.constraints = this.resolveRefConstraints();
+    } else if (dragConstraints && layout2) this.constraints = calcRelativeConstraints(layout2.layoutBox, dragConstraints);
+    else this.constraints = false;
+    this.elastic = resolveDragElastic(dragElastic);
+    if (prevConstraints !== this.constraints && !isRefObject(dragConstraints) && layout2 && this.constraints && !this.hasMutatedConstraints) eachAxis((axis) => {
+      if (this.constraints !== false && this.getAxisMotionValue(axis)) this.constraints[axis] = rebaseAxisConstraints(layout2.layoutBox[axis], this.constraints[axis]);
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();
+    if (!constraints || !isRefObject(constraints)) return false;
+    const constraintsElement = constraints.current;
+    invariant(constraintsElement !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
+    const { projection } = this.visualElement;
+    if (!projection || !projection.layout) return false;
+    if (projection.root) {
+      projection.root.scroll = void 0;
+      projection.root.updateScroll();
+    }
+    const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());
+    let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, constraintsBox);
+    if (onMeasureDragConstraints) {
+      const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));
+      this.hasMutatedConstraints = !!userConstraints;
+      if (userConstraints) measuredConstraints = convertBoundingBoxToBox(userConstraints);
+    }
+    return measuredConstraints;
+  }
+  startAnimation(velocity) {
+    const { drag: drag2, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd } = this.getProps();
+    const constraints = this.constraints || {};
+    const momentumAnimations = eachAxis((axis) => {
+      if (!shouldDrag(axis, drag2, this.currentDirection)) return;
+      let transition = constraints && constraints[axis] || {};
+      if (dragSnapToOrigin === true || dragSnapToOrigin === axis) transition = {
+        min: 0,
+        max: 0
+      };
+      const bounceStiffness = dragElastic ? 200 : 1e6;
+      const bounceDamping = dragElastic ? 40 : 1e7;
+      const inertia = {
+        type: "inertia",
+        velocity: dragMomentum ? velocity[axis] : 0,
+        bounceStiffness,
+        bounceDamping,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...dragTransition,
+        ...transition
+      };
+      return this.startAxisValueAnimation(axis, inertia);
+    });
+    return Promise.all(momentumAnimations).then(onDragTransitionEnd);
+  }
+  startAxisValueAnimation(axis, transition) {
+    const axisValue = this.getAxisMotionValue(axis);
+    addValueToWillChange(this.visualElement, axis);
+    return axisValue.start(animateMotionValue(axis, axisValue, 0, transition, this.visualElement, false));
+  }
+  stopAnimation() {
+    eachAxis((axis) => this.getAxisMotionValue(axis).stop());
+  }
+  /**
+  * Drag works differently depending on which props are provided.
+  *
+  * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+  * - Otherwise, we apply the delta to the x/y motion values.
+  */
+  getAxisMotionValue(axis) {
+    const dragKey = `_drag${axis.toUpperCase()}`;
+    const externalMotionValue = this.visualElement.getProps()[dragKey];
+    return externalMotionValue ? externalMotionValue : this.visualElement.getValue(axis, this.visualElement.latestValues[axis] ?? 0);
+  }
+  snapToCursor(point) {
+    eachAxis((axis) => {
+      const { drag: drag2 } = this.getProps();
+      if (!shouldDrag(axis, drag2, this.currentDirection)) return;
+      const { projection } = this.visualElement;
+      const axisValue = this.getAxisMotionValue(axis);
+      if (projection && projection.layout) {
+        const { min, max } = projection.layout.layoutBox[axis];
+        const current = axisValue.get() || 0;
+        axisValue.set(point[axis] - mixNumber(min, max, 0.5) + current);
+      }
+    });
+  }
+  /**
+  * When the viewport resizes we want to check if the measured constraints
+  * have changed and, if so, reposition the element within those new constraints
+  * relative to where it was before the resize.
+  */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current) return;
+    const { drag: drag2, dragConstraints } = this.getProps();
+    const { projection } = this.visualElement;
+    if (!isRefObject(dragConstraints) || !projection || !this.constraints) return;
+    this.stopAnimation();
+    const boxProgress = {
+      x: 0,
+      y: 0
+    };
+    eachAxis((axis) => {
+      const axisValue = this.getAxisMotionValue(axis);
+      if (axisValue && this.constraints !== false) {
+        const latest = axisValue.get();
+        boxProgress[axis] = calcOrigin({
+          min: latest,
+          max: latest
+        }, this.constraints[axis]);
+      }
+    });
+    const { transformTemplate } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = transformTemplate ? transformTemplate({}, "") : "none";
+    projection.root && projection.root.updateScroll();
+    projection.updateLayout();
+    this.constraints = false;
+    this.resolveConstraints();
+    eachAxis((axis) => {
+      if (!shouldDrag(axis, drag2, null)) return;
+      const axisValue = this.getAxisMotionValue(axis);
+      const { min, max } = this.constraints[axis];
+      axisValue.set(mixNumber(min, max, boxProgress[axis]));
+    });
+    this.visualElement.render();
+  }
+  addListeners() {
+    if (!this.visualElement.current) return;
+    elementDragControls.set(this.visualElement, this);
+    const element = this.visualElement.current;
+    const stopPointerListener = addPointerEvent(element, "pointerdown", (event) => {
+      const { drag: drag2, dragListener = true } = this.getProps();
+      const target = event.target;
+      const isClickingTextInputChild = target !== element && isElementTextInput(target);
+      if (drag2 && dragListener && !isClickingTextInputChild) this.start(event);
+    });
+    let stopResizeObservers;
+    const measureDragConstraints = () => {
+      const { dragConstraints } = this.getProps();
+      if (isRefObject(dragConstraints) && dragConstraints.current) {
+        this.constraints = this.resolveRefConstraints();
+        if (!stopResizeObservers) stopResizeObservers = startResizeObservers(element, dragConstraints.current, () => this.scalePositionWithinConstraints());
+      }
+    };
+    const { projection } = this.visualElement;
+    const stopMeasureLayoutListener = projection.addEventListener("measure", measureDragConstraints);
+    if (projection && !projection.layout) {
+      projection.root && projection.root.updateScroll();
+      projection.updateLayout();
+    }
+    frame.read(measureDragConstraints);
+    const stopResizeListener = addDomEvent(window, "resize", () => this.scalePositionWithinConstraints());
+    const stopLayoutUpdateListener = projection.addEventListener("didUpdate", (({ delta, hasLayoutChanged }) => {
+      if (this.isDragging && hasLayoutChanged) {
+        eachAxis((axis) => {
+          const motionValue2 = this.getAxisMotionValue(axis);
+          if (!motionValue2) return;
+          this.originPoint[axis] += delta[axis].translate;
+          motionValue2.set(motionValue2.get() + delta[axis].translate);
+        });
+        this.visualElement.render();
+      }
+    }));
+    return () => {
+      stopResizeListener();
+      stopPointerListener();
+      stopMeasureLayoutListener();
+      stopLayoutUpdateListener && stopLayoutUpdateListener();
+      stopResizeObservers && stopResizeObservers();
+    };
+  }
+  getProps() {
+    const props = this.visualElement.getProps();
+    const { drag: drag2 = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true } = props;
+    return {
+      ...props,
+      drag: drag2,
+      dragDirectionLock,
+      dragPropagation,
+      dragConstraints,
+      dragElastic,
+      dragMomentum
+    };
+  }
+};
+function skipFirstCall(callback) {
+  let isFirst = true;
+  return () => {
+    if (isFirst) {
+      isFirst = false;
+      return;
+    }
+    callback();
+  };
+}
+function startResizeObservers(element, constraintsElement, onResize) {
+  const stopElement = resize(element, skipFirstCall(onResize));
+  const stopContainer = resize(constraintsElement, skipFirstCall(onResize));
+  return () => {
+    stopElement();
+    stopContainer();
+  };
+}
+function shouldDrag(direction, drag2, currentDirection) {
+  return (drag2 === true || drag2 === direction) && (currentDirection === null || currentDirection === direction);
+}
+function getCurrentDirection(offset, lockThreshold = 10) {
+  let direction = null;
+  if (Math.abs(offset.y) > lockThreshold) direction = "y";
+  else if (Math.abs(offset.x) > lockThreshold) direction = "x";
+  return direction;
+}
+var DragGesture = class extends Feature {
+  constructor(node) {
+    super(node);
+    this.removeGroupControls = noop;
+    this.removeListeners = noop;
+    this.controls = new VisualElementDragControls(node);
+  }
+  mount() {
+    const { dragControls } = this.node.getProps();
+    if (dragControls) this.removeGroupControls = dragControls.subscribe(this.controls);
+    this.removeListeners = this.controls.addListeners() || noop;
+  }
+  update() {
+    const { dragControls } = this.node.getProps();
+    const { dragControls: prevDragControls } = this.node.prevProps || {};
+    if (dragControls !== prevDragControls) {
+      this.removeGroupControls();
+      if (dragControls) this.removeGroupControls = dragControls.subscribe(this.controls);
+    }
+  }
+  unmount() {
+    this.removeGroupControls();
+    this.removeListeners();
+    if (!this.controls.isDragging) this.controls.endPanSession();
+  }
+};
+var asyncHandler = (handler) => (event, info) => {
+  if (handler) frame.update(() => handler(event, info), false, true);
+};
+var PanGesture = class extends Feature {
+  constructor() {
+    super(...arguments);
+    this.removePointerDownListener = noop;
+  }
+  onPointerDown(pointerDownEvent) {
+    this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), {
+      transformPagePoint: this.node.getTransformPagePoint(),
+      contextWindow: getContextWindow(this.node)
+    });
+  }
+  createPanHandlers() {
+    const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();
+    return {
+      onSessionStart: asyncHandler(onPanSessionStart),
+      onStart: asyncHandler(onPanStart),
+      onMove: asyncHandler(onPan),
+      onEnd: (event, info) => {
+        delete this.session;
+        if (onPanEnd) frame.postRender(() => onPanEnd(event, info));
+      }
+    };
+  }
+  mount() {
+    this.removePointerDownListener = addPointerEvent(this.node.current, "pointerdown", (event) => this.onPointerDown(event));
+  }
+  update() {
+    this.session && this.session.updateHandlers(this.createPanHandlers());
+  }
+  unmount() {
+    this.removePointerDownListener();
+    this.session && this.session.end();
+  }
+};
+var hasTakenAnySnapshot = false;
+var MeasureLayoutWithContext = class extends Component {
+  /**
+  * This only mounts projection nodes for components that
+  * need measuring, we might want to do it for all components
+  * in order to incorporate transforms
+  */
+  componentDidMount() {
+    const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;
+    const { projection } = visualElement;
+    if (projection) {
+      if (layoutGroup.group) layoutGroup.group.add(projection);
+      if (switchLayoutGroup && switchLayoutGroup.register && layoutId) switchLayoutGroup.register(projection);
+      if (hasTakenAnySnapshot) projection.root.didUpdate();
+      projection.addEventListener("animationComplete", () => {
+        this.safeToRemove();
+      });
+      projection.setOptions({
+        ...projection.options,
+        layoutDependency: this.props.layoutDependency,
+        onExitComplete: () => this.safeToRemove()
+      });
+    }
+    globalProjectionState.hasEverUpdated = true;
+  }
+  getSnapshotBeforeUpdate(prevProps) {
+    const { layoutDependency, visualElement, drag: drag2, isPresent } = this.props;
+    const { projection } = visualElement;
+    if (!projection) return null;
+    projection.isPresent = isPresent;
+    if (prevProps.layoutDependency !== layoutDependency) projection.setOptions({
+      ...projection.options,
+      layoutDependency
+    });
+    hasTakenAnySnapshot = true;
+    if (drag2 || prevProps.layoutDependency !== layoutDependency || layoutDependency === void 0 || prevProps.isPresent !== isPresent) projection.willUpdate();
+    else this.safeToRemove();
+    if (prevProps.isPresent !== isPresent) {
+      if (isPresent) projection.promote();
+      else if (!projection.relegate())
+        frame.postRender(() => {
+          const stack = projection.getStack();
+          if (!stack || !stack.members.length) this.safeToRemove();
+        });
+    }
+    return null;
+  }
+  componentDidUpdate() {
+    const { visualElement, layoutAnchor } = this.props;
+    const { projection } = visualElement;
+    if (projection) {
+      projection.options.layoutAnchor = layoutAnchor;
+      projection.root.didUpdate();
+      microtask.postRender(() => {
+        if (!projection.currentAnimation && projection.isLead()) this.safeToRemove();
+      });
+    }
+  }
+  componentWillUnmount() {
+    const { visualElement, layoutGroup, switchLayoutGroup: promoteContext } = this.props;
+    const { projection } = visualElement;
+    hasTakenAnySnapshot = true;
+    if (projection) {
+      projection.scheduleCheckAfterUnmount();
+      if (layoutGroup && layoutGroup.group) layoutGroup.group.remove(projection);
+      if (promoteContext && promoteContext.deregister) promoteContext.deregister(projection);
+    }
+  }
+  safeToRemove() {
+    const { safeToRemove } = this.props;
+    safeToRemove && safeToRemove();
+  }
+  render() {
+    return null;
+  }
+};
+function MeasureLayout(props) {
+  const [isPresent, safeToRemove] = usePresence();
+  const layoutGroup = useContext(LayoutGroupContext);
+  return jsx(MeasureLayoutWithContext, {
+    ...props,
+    layoutGroup,
+    switchLayoutGroup: useContext(SwitchLayoutGroupContext),
+    isPresent,
+    safeToRemove
+  });
+}
+var drag = {
+  pan: { Feature: PanGesture },
+  drag: {
+    Feature: DragGesture,
+    ProjectionNode: HTMLProjectionNode,
+    MeasureLayout
+  }
+};
+function handleHoverEvent(node, event, lifecycle) {
+  const { props } = node;
+  if (node.animationState && props.whileHover) node.animationState.setActive("whileHover", lifecycle === "Start");
+  const callback = props["onHover" + lifecycle];
+  if (callback) frame.postRender(() => callback(event, extractEventInfo(event)));
+}
+var HoverGesture = class extends Feature {
+  mount() {
+    const { current } = this.node;
+    if (!current) return;
+    this.unmount = hover(current, (_element, startEvent) => {
+      handleHoverEvent(this.node, startEvent, "Start");
+      return (endEvent) => handleHoverEvent(this.node, endEvent, "End");
+    });
+  }
+  unmount() {
+  }
+};
+var FocusGesture = class extends Feature {
+  constructor() {
+    super(...arguments);
+    this.isActive = false;
+  }
+  onFocus() {
+    let isFocusVisible = false;
+    try {
+      isFocusVisible = this.node.current.matches(":focus-visible");
+    } catch (e) {
+      isFocusVisible = true;
+    }
+    if (!isFocusVisible || !this.node.animationState) return;
+    this.node.animationState.setActive("whileFocus", true);
+    this.isActive = true;
+  }
+  onBlur() {
+    if (!this.isActive || !this.node.animationState) return;
+    this.node.animationState.setActive("whileFocus", false);
+    this.isActive = false;
+  }
+  mount() {
+    this.unmount = pipe(addDomEvent(this.node.current, "focus", () => this.onFocus()), addDomEvent(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+};
+function handlePressEvent(node, event, lifecycle) {
+  const { props } = node;
+  if (node.current instanceof HTMLButtonElement && node.current.disabled) return;
+  if (node.animationState && props.whileTap) node.animationState.setActive("whileTap", lifecycle === "Start");
+  const callback = props["onTap" + (lifecycle === "End" ? "" : lifecycle)];
+  if (callback) frame.postRender(() => callback(event, extractEventInfo(event)));
+}
+var PressGesture = class extends Feature {
+  mount() {
+    const { current } = this.node;
+    if (!current) return;
+    const { globalTapTarget, propagate } = this.node.props;
+    this.unmount = press(current, (_element, startEvent) => {
+      handlePressEvent(this.node, startEvent, "Start");
+      return (endEvent, { success }) => handlePressEvent(this.node, endEvent, success ? "End" : "Cancel");
+    }, {
+      useGlobalTarget: globalTapTarget,
+      stopPropagation: propagate?.tap === false
+    });
+  }
+  unmount() {
+  }
+};
+var observerCallbacks = /* @__PURE__ */ new WeakMap();
+var observers = /* @__PURE__ */ new WeakMap();
+var fireObserverCallback = (entry) => {
+  const callback = observerCallbacks.get(entry.target);
+  callback && callback(entry);
+};
+var fireAllObserverCallbacks = (entries) => {
+  entries.forEach(fireObserverCallback);
+};
+function initIntersectionObserver({ root: root2, ...options }) {
+  const lookupRoot = root2 || document;
+  if (!observers.has(lookupRoot)) observers.set(lookupRoot, {});
+  const rootObservers = observers.get(lookupRoot);
+  const key = JSON.stringify(options);
+  if (!rootObservers[key]) rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, {
+    root: root2,
+    ...options
+  });
+  return rootObservers[key];
+}
+function observeIntersection(element, options, callback) {
+  const rootInteresectionObserver = initIntersectionObserver(options);
+  observerCallbacks.set(element, callback);
+  rootInteresectionObserver.observe(element);
+  return () => {
+    observerCallbacks.delete(element);
+    rootInteresectionObserver.unobserve(element);
+  };
+}
+var thresholdNames = {
+  some: 0,
+  all: 1
+};
+var InViewFeature = class extends Feature {
+  constructor() {
+    super(...arguments);
+    this.hasEnteredView = false;
+    this.isInView = false;
+  }
+  startObserver() {
+    this.stopObserver?.();
+    const { viewport = {} } = this.node.getProps();
+    const { root: root2, margin: rootMargin, amount = "some", once } = viewport;
+    const options = {
+      root: root2 ? root2.current : void 0,
+      rootMargin,
+      threshold: typeof amount === "number" ? amount : thresholdNames[amount]
+    };
+    const onIntersectionUpdate = (entry) => {
+      const { isIntersecting } = entry;
+      if (this.isInView === isIntersecting) return;
+      this.isInView = isIntersecting;
+      if (once && !isIntersecting && this.hasEnteredView) return;
+      else if (isIntersecting) this.hasEnteredView = true;
+      if (this.node.animationState) this.node.animationState.setActive("whileInView", isIntersecting);
+      const { onViewportEnter, onViewportLeave } = this.node.getProps();
+      const callback = isIntersecting ? onViewportEnter : onViewportLeave;
+      callback && callback(entry);
+    };
+    this.stopObserver = observeIntersection(this.node.current, options, onIntersectionUpdate);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver === "undefined") return;
+    const { props, prevProps } = this.node;
+    if ([
+      "amount",
+      "margin",
+      "root"
+    ].some(hasViewportOptionChanged(props, prevProps))) this.startObserver();
+  }
+  unmount() {
+    this.stopObserver?.();
+    this.hasEnteredView = false;
+    this.isInView = false;
+  }
+};
+function hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {
+  return (name) => viewport[name] !== prevViewport[name];
+}
+var gestureAnimations = {
+  inView: { Feature: InViewFeature },
+  tap: { Feature: PressGesture },
+  focus: { Feature: FocusGesture },
+  hover: { Feature: HoverGesture }
+};
+var layout = { layout: {
+  ProjectionNode: HTMLProjectionNode,
+  MeasureLayout
+} };
 var domMax = {
-  ...domAnimation,
+  renderer: createDomVisualElement,
+  ...animations,
+  ...gestureAnimations,
   ...drag,
   ...layout
 };
@@ -125,13 +3053,33 @@ function NotFoundPage({ title = "404", description = "The requested page could n
     })
   });
 }
+function useHtmlReducedMotionClass() {
+  const [reduced, setReduced] = useState(false);
+  useLayoutEffect(() => {
+    const root2 = document.documentElement;
+    const sync = () => setReduced(root2.classList.contains("reduce-motion"));
+    sync();
+    const observer2 = new MutationObserver(sync);
+    observer2.observe(root2, {
+      attributes: true,
+      attributeFilter: ["class"]
+    });
+    return () => observer2.disconnect();
+  }, []);
+  return reduced;
+}
 function MotionRuntime({ children }) {
+  const htmlReduced = useHtmlReducedMotionClass();
   return /* @__PURE__ */ jsx(LazyMotion, {
     features: domMax,
-    children
+    strict: true,
+    children: /* @__PURE__ */ jsx(MotionConfig, {
+      reducedMotion: htmlReduced ? "always" : "user",
+      children
+    })
   });
 }
-var globals_default = "/assets/globals-CuIiqOTg.css";
+var globals_default = "/assets/globals-BtCXZXL_.css";
 function makeQueryClient() {
   return new QueryClient({ defaultOptions: { queries: {
     staleTime: 6e4,
@@ -145,7 +3093,7 @@ function getQueryClient() {
   if (!browserQueryClient) browserQueryClient = makeQueryClient();
   return browserQueryClient;
 }
-var Route$29 = createRootRoute({
+var Route$27 = createRootRoute({
   head: () => ({
     meta: [
       { charSet: "utf-8" },
@@ -192,9 +3140,7 @@ var Route$29 = createRootRoute({
 });
 function RootComponent() {
   useLayoutEffect(() => {
-    const preferences = readUiPreferences();
-    document.documentElement.dataset.density = preferences.density;
-    document.documentElement.classList.toggle("reduce-motion", preferences.motion === "reduced");
+    applyUiPreferencesToDocument(readUiPreferences());
   }, []);
   useEffect(() => {
     initAnalytics();
@@ -215,8 +3161,8 @@ function RootDocument({ children }) {
     ] })]
   });
 }
-var $$splitComponentImporter = () => import("./routes-BGrVtPYF-SURPAJN6.js");
-var Route$28 = createFileRoute("/")({ component: lazyRouteComponent($$splitComponentImporter, "component") });
+var $$splitComponentImporter = () => import("./routes-B9F9UfF1-UN2IVBMJ.js");
+var Route$26 = createFileRoute("/")({ component: lazyRouteComponent($$splitComponentImporter, "component") });
 var ManagedAttachmentValidationError = class extends Error {
   status;
   constructor(message, status) {
@@ -1028,8 +3974,8 @@ var openUIPromptSpec = {
       description: "A button that triggers interactive actions or conversational updates."
     },
     PanelAction: {
-      signature: 'PanelAction(label: string, panel: "resources" | "workspace" | "artifacts" | "repl" | "subagents" | "session-insights", relativePath?: any, focus?: boolean)',
-      description: "A trusted local action that opens Resources, Workspace, Artifacts, REPL, Subagents, or Session insights. relativePath selects a contained workspace-relative path and is valid only for Workspace and Artifacts panels."
+      signature: 'PanelAction(label: string, panel: "resources" | "workspace" | "artifacts" | "repl" | "subagents" | "session-insights" | "session-tree", relativePath?: any, focus?: boolean)',
+      description: "A trusted local action that opens Resources, Workspace, Artifacts, REPL, Subagents, Session insights, or Session tree. relativePath selects a contained workspace-relative path and is valid only for Workspace and Artifacts panels."
     },
     Input: {
       signature: 'Input(name: string, value: $binding<string>, placeholder?: string, type?: "text" | "email" | "number" | "password" | "search", disabled?: boolean)',
@@ -1353,7 +4299,8 @@ var openUIPromptSpec = {
               "artifacts",
               "repl",
               "subagents",
-              "session-insights"
+              "session-insights",
+              "session-tree"
             ]
           },
           relativePath: { type: "string" },
@@ -1368,7 +4315,7 @@ var openUIPromptSpec = {
           "focus"
         ],
         additionalProperties: false,
-        description: "A trusted local action that opens Resources, Workspace, Artifacts, REPL, Subagents, or Session insights. relativePath selects a contained workspace-relative path and is valid only for Workspace and Artifacts panels."
+        description: "A trusted local action that opens Resources, Workspace, Artifacts, REPL, Subagents, Session insights, or Session tree. relativePath selects a contained workspace-relative path and is valid only for Workspace and Artifacts panels."
       },
       Input: {
         type: "object",
@@ -2292,8 +5239,8 @@ function createPrimeConfig(initialCwd) {
   const authStorage = AuthStorage.create();
   const modelRegistry2 = ModelRegistry.create(authStorage);
   const projectRegistry = new ProjectRegistry(agentDir, initialCwd);
-  let currentDefaultCwd = resolve(initialCwd);
-  let defaultSettings = SettingsManager.create(currentDefaultCwd);
+  const currentDefaultCwd = resolve(initialCwd);
+  const defaultSettings = SettingsManager.create(currentDefaultCwd);
   const settingsByCwd = /* @__PURE__ */ new Map();
   settingsByCwd.set(currentDefaultCwd, defaultSettings);
   return {
@@ -2325,17 +5272,6 @@ function createPrimeConfig(initialCwd) {
       await loader.reload();
       return loader;
     },
-    setDefaultCwd(cwd) {
-      const next = resolve(cwd);
-      currentDefaultCwd = next;
-      const existing = settingsByCwd.get(next);
-      if (existing) {
-        defaultSettings = existing;
-        return;
-      }
-      defaultSettings = SettingsManager.create(next);
-      settingsByCwd.set(next, defaultSettings);
-    },
     reloadAuth() {
       this.authStorage.reload();
       this.modelRegistry.refresh();
@@ -2345,7 +5281,7 @@ function createPrimeConfig(initialCwd) {
 function getPrimeConfig() {
   const globalStore2 = globalThis;
   const existing = globalStore2.__primeConfig;
-  if (!existing || typeof existing.setDefaultCwd !== "function" || !existing.projectRegistry) globalStore2.__primeConfig = createPrimeConfig(resolveDefaultWorkspaceRoot(process.cwd()));
+  if (!existing || !existing.projectRegistry) globalStore2.__primeConfig = createPrimeConfig(resolveDefaultWorkspaceRoot(process.cwd()));
   return globalStore2.__primeConfig;
 }
 var DAEMON_STARTUP_TIMEOUT_MS = 3e4;
@@ -2942,11 +5878,11 @@ function stringifyPayload(value) {
     return String(value);
   }
 }
-function createPayloadPart(kind, title, payload, text, id) {
+function createPayloadPart(kind, title, payload, text, id2) {
   const safePayload = browserSafePayload(payload);
   return {
     type: "payload",
-    ...id ? { id } : {},
+    ...id2 ? { id: id2 } : {},
     kind,
     title,
     ...text ? { text } : {},
@@ -2956,7 +5892,7 @@ function createPayloadPart(kind, title, payload, text, id) {
 function textFromChatParts(parts) {
   return parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
 }
-function toChatMessageFromRuntimeMessage(message, id) {
+function toChatMessageFromRuntimeMessage(message, id2) {
   const value = message;
   const role = typeof value.role === "string" ? value.role : "runtime";
   const timestamp = getTimestamp(message);
@@ -2974,7 +5910,7 @@ function toChatMessageFromRuntimeMessage(message, id) {
       cancelled ? "(cancelled)" : status
     ].filter((part) => Boolean(part)).join("\n");
     return {
-      id,
+      id: id2,
       role: "assistant",
       parts: [createPayloadPart("bashExecution", "Bash", {
         command,
@@ -2983,7 +5919,7 @@ function toChatMessageFromRuntimeMessage(message, id) {
         cancelled,
         truncated,
         excludeFromContext: value.excludeFromContext === true
-      }, text, id)],
+      }, text, id2)],
       createdAt: timestamp
     };
   }
@@ -2997,23 +5933,23 @@ function toChatMessageFromRuntimeMessage(message, id) {
       ...details !== void 0 ? { details } : {}
     };
     return {
-      id,
+      id: id2,
       role: "assistant",
-      parts: [...contentParts2, createPayloadPart(customType, `[${customType}]`, payload2, textFromChatParts(contentParts2) ? void 0 : stringifyPayload(details), id)],
+      parts: [...contentParts2, createPayloadPart(customType, `[${customType}]`, payload2, textFromChatParts(contentParts2) ? void 0 : stringifyPayload(details), id2)],
       createdAt: timestamp
     };
   }
   if (role === "branchSummary") {
     const summary = typeof value.summary === "string" ? value.summary : "";
     return {
-      id,
+      id: id2,
       role: "assistant",
       parts: [createPayloadPart("branchSummary", "Branch summary", {
         fromId: value.fromId,
         summary
       }, `Branch Summary
 
-${summary}`, id)],
+${summary}`, id2)],
       createdAt: timestamp
     };
   }
@@ -3023,7 +5959,7 @@ ${summary}`, id)],
     const customInstructions = typeof value.customInstructions === "string" ? value.customInstructions : void 0;
     const tokenLabel = tokensBefore === void 0 ? "" : `Compacted from ${tokensBefore.toLocaleString()} tokens`;
     return {
-      id,
+      id: id2,
       role: "assistant",
       parts: [createPayloadPart("compactionSummary", "Compaction summary", {
         summary,
@@ -3034,7 +5970,7 @@ ${summary}`, id)],
         tokenLabel,
         customInstructions ? `Focus: ${customInstructions}` : void 0,
         summary
-      ].filter((part) => Boolean(part)).join("\n\n"), id)],
+      ].filter((part) => Boolean(part)).join("\n\n"), id2)],
       createdAt: timestamp
     };
   }
@@ -3042,13 +5978,13 @@ ${summary}`, id)],
   const contentParts = contentToChatParts(value.content);
   const payload = browserSafePayload(Object.fromEntries(Object.entries(value).filter(([key]) => key !== "content")));
   return {
-    id,
+    id: id2,
     role: "assistant",
-    parts: [...contentParts, createPayloadPart(role, `[${role}]`, payload, textFromChatParts(contentParts) ? void 0 : stringifyPayload(payload), id)],
+    parts: [...contentParts, createPayloadPart(role, `[${role}]`, payload, textFromChatParts(contentParts) ? void 0 : stringifyPayload(payload), id2)],
     createdAt: timestamp
   };
 }
-function toChatMessageFromAssistant(msg, id) {
+function toChatMessageFromAssistant(msg, id2) {
   const parts = [];
   for (const block of msg.content) {
     const value = block;
@@ -3082,15 +6018,15 @@ function toChatMessageFromAssistant(msg, id) {
     message: errorMessage
   });
   return {
-    id,
+    id: id2,
     role: "assistant",
     parts,
     createdAt: getTimestamp(msg)
   };
 }
-function toChatMessageFromUser(msg, id) {
+function toChatMessageFromUser(msg, id2) {
   return {
-    id,
+    id: id2,
     role: "user",
     parts: contentToChatParts(msg.content),
     createdAt: getTimestamp(msg)
@@ -3224,16 +6160,16 @@ function toChatMessagesFromAgentMessages(messages, sessionId) {
   const output = [];
   for (const [index, message] of messages.entries()) {
     const role = message.role;
-    const id = `${sessionId}-m${index}`;
+    const id2 = `${sessionId}-m${index}`;
     if (role === "assistant") {
-      output.push(toChatMessageFromAssistant(message, id));
+      output.push(toChatMessageFromAssistant(message, id2));
       continue;
     }
     if (role === "user") {
-      output.push(toChatMessageFromUser(message, id));
+      output.push(toChatMessageFromUser(message, id2));
       continue;
     }
-    const runtimeMessage = toChatMessageFromRuntimeMessage(message, id);
+    const runtimeMessage = toChatMessageFromRuntimeMessage(message, id2);
     if (runtimeMessage) {
       output.push(runtimeMessage);
       continue;
@@ -3250,10 +6186,10 @@ function toChatMessagesFromAgentMessages(messages, sessionId) {
     let attached = false;
     if (toolCallId) for (let messageIndex = output.length - 1; messageIndex >= 0 && !attached; messageIndex -= 1) {
       const candidate = output[messageIndex];
-      const partIndex = candidate.parts.findIndex((part2) => part2.type.startsWith("tool-") && part2.toolCallId === toolCallId);
+      const partIndex = candidate.parts.findIndex((part2) => isChatToolPart(part2) && part2.toolCallId === toolCallId);
       if (partIndex < 0) continue;
       const part = candidate.parts[partIndex];
-      if (!part.type.startsWith("tool-")) continue;
+      if (!isChatToolPart(part)) continue;
       const nextPart = {
         ...part,
         state: isError ? "output-error" : "output-available",
@@ -3270,7 +6206,7 @@ function toChatMessagesFromAgentMessages(messages, sessionId) {
       attached = true;
     }
     if (!attached) output.push({
-      id,
+      id: id2,
       role: "assistant",
       createdAt: typeof result.timestamp === "number" ? result.timestamp : void 0,
       parts: [{
@@ -3395,8 +6331,8 @@ function computeRlmExecutionTree(rootSessionId, children, activeNodeId) {
   };
   for (const child of children) if (child.parentId && child.parentId !== rootSessionId && nodes[child.parentId]) nodes[child.parentId].childrenIds.push(child.id);
   else rootChildrenIds.push(child.id);
-  const queue = rootChildrenIds.map((id) => ({
-    id,
+  const queue = rootChildrenIds.map((id2) => ({
+    id: id2,
     depth: 1
   }));
   const visited = /* @__PURE__ */ new Set();
@@ -3621,8 +6557,8 @@ function rememberSentAgentMessage(state, toolCallId, message) {
   const safeMessage = browserSafePayload(message);
   if (safeMessage === void 0) return;
   const messages = state.currentToolSentAgentMessages[toolCallId] ?? [];
-  const id = sentAgentMessageId(safeMessage);
-  if (id && messages.some((entry) => sentAgentMessageId(entry) === id)) return;
+  const id2 = sentAgentMessageId(safeMessage);
+  if (id2 && messages.some((entry) => sentAgentMessageId(entry) === id2)) return;
   state.currentToolSentAgentMessages[toolCallId] = [...messages, safeMessage];
 }
 function withSentAgentMessages(state, toolCallId, value) {
@@ -3740,8 +6676,8 @@ function mapCoreAgentEvent(state, event) {
       }];
     case "message_start":
       if (isUserMessage(event.message)) {
-        const id = `${state.runId}-u${state.userMessages.length}`;
-        const message = toChatMessageFromUser(event.message, id);
+        const id2 = `${state.runId}-u${state.userMessages.length}`;
+        const message = toChatMessageFromUser(event.message, id2);
         state.userMessages.push(message);
         return [{
           type: "message",
@@ -4056,10 +6992,10 @@ function mapSessionSpecificEvent(state, event) {
       })];
     case "bash_start": {
       const runId = event.runId ?? stablePresentationId(`bash:${state.sessionId}:${state.userBashSequence++}:${event.command}`);
-      const id = stablePresentationId(`user-bash:${runId}`);
-      state.activeUserBashId = id;
+      const id2 = stablePresentationId(`user-bash:${runId}`);
+      state.activeUserBashId = id2;
       const entry = {
-        id,
+        id: id2,
         runId,
         command: event.command,
         output: "",
@@ -4113,10 +7049,10 @@ function mapSessionSpecificEvent(state, event) {
       }))];
     }
     case "refine_failed": {
-      const id = stablePresentationId(`${presentationRunId(state)}:refinement:${state.presentation.refinements.length}`);
+      const id2 = stablePresentationId(`${presentationRunId(state)}:refinement:${state.presentation.refinements.length}`);
       const timestamp = Date.now();
       const refinement = {
-        id,
+        id: id2,
         summary: "Refinement failed",
         rationale: "",
         expectedOutcome: "",
@@ -4129,9 +7065,9 @@ function mapSessionSpecificEvent(state, event) {
         ...state.presentation,
         refinements: [...state.presentation.refinements, refinement]
       }, {
-        id: stablePresentationId(`${presentationRunId(state)}:${id}:refinement`),
+        id: stablePresentationId(`${presentationRunId(state)}:${id2}:refinement`),
         runId: presentationRunId(state),
-        sourceToolCallId: id,
+        sourceToolCallId: id2,
         kind: "refinement",
         title: refinement.summary,
         status: "error",
@@ -4449,7 +7385,7 @@ var PendingDialogRegistry = class {
     if (!dialog) return false;
     clearTimeout(dialog.timer);
     this.bySession.get(sessionId)?.delete(toolCallId);
-    const frame = {
+    const frame2 = {
       type: "tool",
       part: {
         type: "tool-Question",
@@ -4462,7 +7398,7 @@ var PendingDialogRegistry = class {
         }
       }
     };
-    this.emitFrame(sessionId, frame);
+    this.emitFrame(sessionId, frame2);
     dialog.reject(/* @__PURE__ */ new Error(`Question cancelled: ${reason}`));
     return true;
   }
@@ -4531,6 +7467,123 @@ var RingBuffer = class {
     this.nextSeq = 1;
   }
 };
+var SessionTreeBusyError = class extends Error {
+  status = 409;
+  constructor() {
+    super("Session is still streaming. Stop the current turn before rewinding.");
+    this.name = "SessionTreeBusyError";
+  }
+};
+var SessionTreeConcurrencyError = class extends Error {
+  status = 409;
+  constructor() {
+    super("The session tree changed while you were selecting a rewind target. Refresh and try again.");
+    this.name = "SessionTreeConcurrencyError";
+  }
+};
+var SessionTreeCancelledError = class extends Error {
+  status = 409;
+  constructor() {
+    super("Session tree navigation was cancelled. Refresh and try again.");
+    this.name = "SessionTreeCancelledError";
+  }
+};
+function messageContentToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string").map((part) => part.text).join(" ");
+}
+function entryPreview(node) {
+  const { entry } = node;
+  if (entry.type === "message" && entry.message) {
+    const role = entry.message.role ?? "message";
+    const oneLine = messageContentToText(entry.message.content).replace(/\s+/g, " ").trim();
+    return `${role}: ${oneLine.length > 72 ? `${oneLine.slice(0, 72)}\u2026` : oneLine}`;
+  }
+  return entry.label ?? node.label ?? entry.type;
+}
+function entryKind(entry) {
+  if (entry.type === "message") return "message";
+  if (entry.type === "system" || entry.type === "compaction" || entry.type === "model_change") return "system";
+  return "other";
+}
+function entryRole(entry) {
+  if (entry.type !== "message" || !entry.message?.role) return void 0;
+  switch (entry.message.role) {
+    case "user":
+      return "user";
+    case "assistant":
+      return "assistant";
+    case "system":
+      return "system";
+    default:
+      return "unknown";
+  }
+}
+function findActiveBranchPath(nodes, leafId) {
+  const active = /* @__PURE__ */ new Set();
+  if (!leafId) return active;
+  const walk = (items) => {
+    for (const node of items) {
+      if (node.entry.id === leafId) {
+        active.add(node.entry.id);
+        return true;
+      }
+      if (walk(node.children)) {
+        active.add(node.entry.id);
+        return true;
+      }
+    }
+    return false;
+  };
+  walk(nodes);
+  return active;
+}
+function buildMessageIndexByEntryId(nodes, leafId) {
+  const activePath = findActiveBranchPath(nodes, leafId);
+  const messageIndexByEntryId = /* @__PURE__ */ new Map();
+  let messageIndex = 0;
+  const walk = (items) => {
+    for (const node of items) {
+      if (!activePath.has(node.entry.id)) continue;
+      if (node.entry.type === "message") {
+        messageIndexByEntryId.set(node.entry.id, messageIndex);
+        messageIndex += 1;
+      }
+      walk(node.children);
+      return;
+    }
+  };
+  walk(nodes);
+  return messageIndexByEntryId;
+}
+function mapNode(node, leafId, activePath, messageIndexByEntryId) {
+  const preview = entryPreview(node);
+  const role = entryRole(node.entry);
+  const messageIndex = messageIndexByEntryId.get(node.entry.id);
+  return {
+    id: node.entry.id,
+    ...node.entry.parentId ? { parentId: node.entry.parentId } : {},
+    kind: entryKind(node.entry),
+    ...role ? { role } : {},
+    label: node.entry.label ?? node.label ?? node.entry.type,
+    preview,
+    isLeaf: node.entry.id === leafId,
+    isOnActiveBranch: activePath.has(node.entry.id),
+    ...messageIndex !== void 0 ? { messageIndex } : {},
+    children: node.children.map((child) => mapNode(child, leafId, activePath, messageIndexByEntryId))
+  };
+}
+function mapSessionTreeSnapshot(sessionId, nodes, leafId) {
+  const upstreamNodes = nodes;
+  const activePath = findActiveBranchPath(upstreamNodes, leafId);
+  const messageIndexByEntryId = buildMessageIndexByEntryId(upstreamNodes, leafId);
+  return {
+    sessionId,
+    leafId,
+    nodes: upstreamNodes.map((node) => mapNode(node, leafId, activePath, messageIndexByEntryId))
+  };
+}
 var WEB_UI_UNSUPPORTED = "Not available in the web UI";
 function unsupportedInWebUi(method) {
   throw new Error(`${method}: ${WEB_UI_UNSUPPORTED}`);
@@ -4842,6 +7895,7 @@ var PrimeBridge = class {
   #childPromptStarter;
   #childPrompts = /* @__PURE__ */ new Map();
   #caches = /* @__PURE__ */ new Map();
+  #sessionTreeNavigationQueues = /* @__PURE__ */ new Map();
   #openUIPromptTransitions = /* @__PURE__ */ new Map();
   #daemonDialogs = /* @__PURE__ */ new Map();
   #auxiliaryWarnings = /* @__PURE__ */ new Set();
@@ -4857,7 +7911,7 @@ var PrimeBridge = class {
     this.#childPromptStarter = options.childPromptStarter ?? startDaemonChildPrompt;
     this.#dialogs = new PendingDialogRegistry({
       defaultTimeoutMs: options.dialogTimeoutMs ?? 6e4,
-      emitFrame: (sessionId, frame) => this.#dispatch(sessionId, frame)
+      emitFrame: (sessionId, frame2) => this.#dispatch(sessionId, frame2)
     });
   }
   /** Late-boot kernel readiness gate. Boot-time callers await this; failures cause `/api/chat` to 503. */
@@ -4896,11 +7950,11 @@ var PrimeBridge = class {
     return () => this.#listeners.delete(listener);
   }
   /** Emit a frame to ring buffer (SSE replay) and all live listeners. */
-  #dispatch(sessionId, frame) {
-    const next = frame.type === "done" && !(frame.sessionId ?? "").trim() ? {
-      ...frame,
+  #dispatch(sessionId, frame2) {
+    const next = frame2.type === "done" && !(frame2.sessionId ?? "").trim() ? {
+      ...frame2,
       sessionId
-    } : frame;
+    } : frame2;
     const buffer = this.#ringBuffers.get(sessionId);
     if (buffer) buffer.push(next);
     for (const listener of this.#listeners) listener(sessionId, next);
@@ -4937,6 +7991,7 @@ var PrimeBridge = class {
     this.#presentationWrites.clear();
     this.#presentationGenerations.clear();
     this.#caches.clear();
+    this.#sessionTreeNavigationQueues.clear();
     this.#openUIPromptTransitions.clear();
     this.#daemonDialogs.clear();
     this.#auxiliaryWarnings.clear();
@@ -5040,7 +8095,7 @@ var PrimeBridge = class {
     await getPrimeConfig().projectRegistry.assignSession(sessionId, resolvedProjectId);
     const uiContext = createWebUIContext({
       sessionId,
-      emitFrame: (frame) => this.#dispatch(sessionId, frame),
+      emitFrame: (frame2) => this.#dispatch(sessionId, frame2),
       dialogs: this.#dialogs
     });
     await webAgent.bindUiContext?.(uiContext);
@@ -5073,9 +8128,9 @@ var PrimeBridge = class {
       } catch {
       }
       const frames = mapAgentConnectionEvent(mapperState, event);
-      for (const frame of frames) {
-        if (frame.type === "presentation") this.#persistPresentation(sessionId, sessionPath, frame.presentation);
-        this.#dispatch(sessionId, frame);
+      for (const frame2 of frames) {
+        if (frame2.type === "presentation") this.#persistPresentation(sessionId, sessionPath, frame2.presentation);
+        this.#dispatch(sessionId, frame2);
       }
       if (event.type === "session_resynced" || event.type === "session_event" && event.event.type === "rlm_child_update") this.#queueRlmChildMetadataRefresh(sessionId);
     });
@@ -5215,7 +8270,7 @@ var PrimeBridge = class {
       sessions2 = await this.#sessionLister();
     } catch {
       for (const child of parent.mapperState.presentation.rlmChildren) parent.mapperState.rlmChildOverrides.delete(child.id);
-      for (const frame of applyRlmChildStatusOverrides(parent.mapperState, /* @__PURE__ */ new Map())) this.#dispatch(rootSessionId, frame);
+      for (const frame2 of applyRlmChildStatusOverrides(parent.mapperState, /* @__PURE__ */ new Map())) this.#dispatch(rootSessionId, frame2);
       return;
     }
     const { sessionsByIdentifier, sessionsByPath, rootIdentifiers, rootPaths } = await this.#resolveRlmLineage(sessions2, rootSessionId, parent.sessionPath);
@@ -5226,9 +8281,9 @@ var PrimeBridge = class {
       else parent.mapperState.rlmChildOverrides.delete(child.id);
     }
     const frames = applyRlmChildStatusOverrides(parent.mapperState, overrides);
-    for (const frame of frames) {
-      if (frame.type === "presentation") this.#persistPresentation(rootSessionId, parent.sessionPath, frame.presentation);
-      this.#dispatch(rootSessionId, frame);
+    for (const frame2 of frames) {
+      if (frame2.type === "presentation") this.#persistPresentation(rootSessionId, parent.sessionPath, frame2.presentation);
+      this.#dispatch(rootSessionId, frame2);
     }
   }
   #childStreamStatus(child, summary) {
@@ -5323,12 +8378,12 @@ var PrimeBridge = class {
       terminal: true
     };
     const frames = mapAgentConnectionEvent(stream.mapperState, event);
-    for (const frame of frames) {
-      if (frame.type === "error") stream.snapshot = {
+    for (const frame2 of frames) {
+      if (frame2.type === "error") stream.snapshot = {
         ...stream.snapshot,
         status: "error"
       };
-      this.#dispatch(stream.channelId, frame);
+      this.#dispatch(stream.channelId, frame2);
     }
     if (event.type === "session_event" && event.event.type === "rlm_child_update") this.#queueRlmChildMetadataRefresh(stream.parentSessionId);
     if (event.type === "session_replaced" || event.type === "session_resynced" || event.type === "closed" || event.type === "session_event" && (event.event.type === "agent_end" || event.event.type === "turn_end")) this.#queueRlmChildSnapshot(stream);
@@ -5625,12 +8680,6 @@ var PrimeBridge = class {
     session.openUIPrompt.artifact = artifact;
     session.openUIPrompt.prompt = nextPrompt;
   }
-  async steer(sessionId, text) {
-    await this.#requireSession(sessionId).connection.steer(text);
-  }
-  async followUp(sessionId, text) {
-    await this.#requireSession(sessionId).connection.followUp(text);
-  }
   async mutateQueuedMessage(sessionId, lane, index, expectedText, mutation) {
     const session = this.#requireSession(sessionId);
     const upstreamMutation = mutation.type === "delete" ? { type: "delete" } : {
@@ -5648,9 +8697,6 @@ var PrimeBridge = class {
       }
     };
   }
-  async deleteQueuedMessage(sessionId, lane, index, expectedText) {
-    return this.mutateQueuedMessage(sessionId, lane, index, expectedText, { type: "delete" });
-  }
   async abort(sessionId) {
     const session = this.#requireSession(sessionId);
     this.#dialogs.cancelAll(sessionId, "user-abort");
@@ -5811,8 +8857,12 @@ var PrimeBridge = class {
   /** /tree — session-tree navigation via navigateTree (requires entry id). */
   async navigateTree(sessionId, targetId) {
     const session = this.#requireSession(sessionId);
-    await session.connection.navigateTree(targetId, {});
-    await deleteManagedPlanPresentationsForSession(sessionId, session.sessionPath);
+    await this.#withSessionTreeNavigationLock(sessionId, async () => {
+      await session.connection.waitForIdle();
+      await session.connection.navigateTree(targetId, {});
+      await this.#refreshSessionTreeCache(sessionId, session.connection);
+      await deleteManagedPlanPresentationsForSession(sessionId, session.sessionPath);
+    });
   }
   /** /tree — the session's entry tree plus the current leaf, for pickers. */
   getSessionTree(sessionId) {
@@ -5824,6 +8874,43 @@ var PrimeBridge = class {
       leafId: null
     };
   }
+  async #refreshSessionTreeCache(sessionId, connection) {
+    const tree = await connection.getSessionTree();
+    const cache = this.#caches.get(sessionId) ?? emptyCache();
+    cache.tree = {
+      tree: tree.tree,
+      leafId: tree.leafId
+    };
+    this.#caches.set(sessionId, cache);
+  }
+  async #withSessionTreeNavigationLock(sessionId, operation) {
+    const current = (this.#sessionTreeNavigationQueues.get(sessionId) ?? Promise.resolve()).catch(() => void 0).then(operation);
+    const tail = current.then(() => void 0, () => void 0);
+    this.#sessionTreeNavigationQueues.set(sessionId, tail);
+    tail.then(() => {
+      if (this.#sessionTreeNavigationQueues.get(sessionId) === tail) this.#sessionTreeNavigationQueues.delete(sessionId);
+    });
+    return current;
+  }
+  /** Reads a browser-safe session tree snapshot from the live connection. */
+  async readSessionTreeSnapshot(sessionId) {
+    const session = this.#requireSession(sessionId);
+    await this.#refreshSessionTreeCache(sessionId, session.connection);
+    const cached = this.getSessionTree(sessionId);
+    return mapSessionTreeSnapshot(sessionId, cached.tree, cached.leafId);
+  }
+  /** Navigates the live session tree and returns the authoritative browser-safe snapshot. */
+  async navigateSessionTree(sessionId, targetEntryId, expectedLeafId) {
+    const session = this.#requireSession(sessionId);
+    return this.#withSessionTreeNavigationLock(sessionId, async () => {
+      await session.connection.waitForIdle();
+      const before = await session.connection.getSessionTree();
+      if (expectedLeafId && before.leafId !== expectedLeafId) throw new SessionTreeConcurrencyError();
+      if ((await session.connection.navigateTree(targetEntryId, {})).cancelled) throw new SessionTreeCancelledError();
+      await deleteManagedPlanPresentationsForSession(sessionId, session.sessionPath);
+      return this.readSessionTreeSnapshot(sessionId);
+    });
+  }
   /**
   * /fork and /clone — branch the session at `entryId` into a NEW live session.
   *
@@ -6097,10 +9184,10 @@ async function handleChatChildPost(bridge, parentSessionId, childId, message, st
       } catch {
       }
     };
-    const write = (frame) => {
+    const write = (frame2) => {
       if (closed) return;
       try {
-        controller.enqueue(encoder.encode(`${JSON.stringify(frame)}
+        controller.enqueue(encoder.encode(`${JSON.stringify(frame2)}
 `));
       } catch {
       }
@@ -6232,21 +9319,21 @@ ${attachmentContext.join("\n\n")}` : message;
           } catch {
           }
         };
-        const write = (frame) => {
+        const write = (frame2) => {
           if (closed) return;
           try {
-            controller.enqueue(encoder.encode(`${JSON.stringify(frame)}
+            controller.enqueue(encoder.encode(`${JSON.stringify(frame2)}
 `));
           } catch {
           }
         };
-        removeListener = bridge.addEventListener((sid, frame) => {
+        removeListener = bridge.addEventListener((sid, frame2) => {
           if (sid !== session.sessionId) return;
           if (backendSessionCommand) return;
-          const nextFrame = frame.type === "done" && !frame.sessionReset ? {
-            ...frame,
+          const nextFrame = frame2.type === "done" && !frame2.sessionReset ? {
+            ...frame2,
             presentation: bridge.getPresentation(session.sessionId)
-          } : frame;
+          } : frame2;
           write(nextFrame);
           if (nextFrame.type === "done" && !nextFrame.sessionReset) terminalDoneSent = true;
           if (nextFrame.type === "error" || nextFrame.type === "done" && !nextFrame.sessionReset) close();
@@ -6329,14 +9416,14 @@ ${attachmentContext.join("\n\n")}` : message;
     } });
   }, request);
 }
-var BodySchema$3 = external_exports.object({
+var BodySchema$2 = external_exports.object({
   sessionId: SessionIdSchema.optional(),
   childId: external_exports.string().min(1).max(160).optional()
 });
 function handleChatAbortPost(request) {
   return wrapApiHandler(async () => {
     const raw = await request.json().catch(() => ({}));
-    const body = BodySchema$3.parse(raw);
+    const body = BodySchema$2.parse(raw);
     const sessionId = body.sessionId;
     if (!sessionId) return Response.json({ message: "abort requires sessionId" }, { status: 400 });
     const bridge = getBridge();
@@ -6423,14 +9510,14 @@ function handleChatAttachmentGet(request) {
     } });
   }, request);
 }
-var BodySchema$2 = external_exports.object({
+var BodySchema$1 = external_exports.object({
   sessionId: SessionIdSchema,
   command: external_exports.string(),
   args: external_exports.string().max(1024).optional()
 });
 function handleChatCommandPost(request) {
   return wrapApiHandler(async () => {
-    const body = BodySchema$2.parse(await request.json().catch(() => ({})));
+    const body = BodySchema$1.parse(await request.json().catch(() => ({})));
     const bridge = getBridge();
     const args = body.args?.trim() ?? "";
     switch (body.command) {
@@ -6724,9 +9811,9 @@ function handleChatCommandsGet(request) {
 function shouldReplaySseEvent(event, pendingQuestionIds) {
   if (!pendingQuestionIds) return true;
   if (!event || typeof event !== "object") return true;
-  const frame = event;
-  if (frame.type !== "tool" || frame.part?.type !== "tool-Question") return true;
-  const toolCallId = frame.part.toolCallId;
+  const frame2 = event;
+  if (frame2.type !== "tool" || frame2.part?.type !== "tool-Question") return true;
+  const toolCallId = frame2.part.toolCallId;
   return typeof toolCallId === "string" && pendingQuestionIds.has(toolCallId);
 }
 function normalizeSseReplayEvent(event) {
@@ -34219,7 +37306,7 @@ var MODELS = {
 var modelRegistry = /* @__PURE__ */ new Map();
 for (const [provider, models] of Object.entries(MODELS)) {
   const providerModels = /* @__PURE__ */ new Map();
-  for (const [id, model] of Object.entries(models)) providerModels.set(id, model);
+  for (const [id2, model] of Object.entries(models)) providerModels.set(id2, model);
   modelRegistry.set(provider, providerModels);
 }
 function getModels(provider) {
@@ -34755,8 +37842,8 @@ var oauthProviderRegistry = new Map([
     }
   }
 ].map((provider) => [provider.id, provider]));
-function getOAuthProvider(id) {
-  return oauthProviderRegistry.get(id);
+function getOAuthProvider(id2) {
+  return oauthProviderRegistry.get(id2);
 }
 function registerOAuthProvider(provider) {
   oauthProviderRegistry.set(provider.id, provider);
@@ -35373,7 +38460,7 @@ function addCustomProviderModelIds(filePath, providerId, modelIds) {
   if (!existing) return;
   providers[providerId] = {
     ...existing,
-    models: mergeModelDefinitions(existing.models, [...existing.models ?? [], ...modelIds.map((id) => ({ id }))])
+    models: mergeModelDefinitions(existing.models, [...existing.models ?? [], ...modelIds.map((id2) => ({ id: id2 }))])
   };
   writeModelsJson(filePath, {
     ...data,
@@ -35495,23 +38582,23 @@ function buildProviders() {
   const builtinIds = new Set(getProviders());
   const allIds = /* @__PURE__ */ new Set([...builtinIds, ...Object.keys(custom)]);
   allIds.add(OPENAI_CHAT_COMPLETIONS_PROVIDER_ID);
-  return [...allIds].map((id) => {
-    const isCustom = !builtinIds.has(id);
-    const customEntry = isCustom ? custom[id] : void 0;
-    const status = config.modelRegistry.getProviderAuthStatus(id);
-    const catalogEntry = KNOWN_PROVIDER_BY_ID.get(id);
-    const name = isCustom ? customEntry?.name ?? catalogEntry?.name ?? id : BUILT_IN_PROVIDER_DISPLAY_NAMES[id] ?? catalogEntry?.name ?? id;
-    const envVarName = isCustom ? customEntry?.apiKey ?? catalogEntry?.envVarName ?? "" : envHintForBuiltin(id);
+  return [...allIds].map((id2) => {
+    const isCustom = !builtinIds.has(id2);
+    const customEntry = isCustom ? custom[id2] : void 0;
+    const status = config.modelRegistry.getProviderAuthStatus(id2);
+    const catalogEntry = KNOWN_PROVIDER_BY_ID.get(id2);
+    const name = isCustom ? customEntry?.name ?? catalogEntry?.name ?? id2 : BUILT_IN_PROVIDER_DISPLAY_NAMES[id2] ?? catalogEntry?.name ?? id2;
+    const envVarName = isCustom ? customEntry?.apiKey ?? catalogEntry?.envVarName ?? "" : envHintForBuiltin(id2);
     const row = {
-      id,
+      id: id2,
       name,
       envVarName,
-      ...resolveProviderAuthFields(id, envVarName, oauthIds),
+      ...resolveProviderAuthFields(id2, envVarName, oauthIds),
       isConfigured: status.configured
     };
-    if (isOccProviderId(id) || isCustomProviderId(id)) {
-      row.providerFamily = isOccProviderId(id) ? OPENAI_CHAT_COMPLETIONS_PROVIDER_ID : "custom";
-      if (customEntry?.name && (isNamedOccInstanceId(id) || isCustomProviderId(id))) row.displayName = customEntry.name;
+    if (isOccProviderId(id2) || isCustomProviderId(id2)) {
+      row.providerFamily = isOccProviderId(id2) ? OPENAI_CHAT_COMPLETIONS_PROVIDER_ID : "custom";
+      if (customEntry?.name && (isNamedOccInstanceId(id2) || isCustomProviderId(id2))) row.displayName = customEntry.name;
       const customApi = uiApiForCustomProvider(customEntry?.api);
       if (customApi) row.api = customApi;
       if (customEntry?.baseUrl) row.baseUrl = customEntry.baseUrl;
@@ -35585,7 +38672,7 @@ function handleChatProvidersPost(request) {
       baseUrl,
       api,
       apiKey: envVarNameForManagedProvider(providerId),
-      models: modelIds.map((id) => ({ id }))
+      models: modelIds.map((id2) => ({ id: id2 }))
     });
     config.authStorage.set(providerId, {
       type: "api_key",
@@ -35938,27 +39025,6 @@ function handleChatMcpOAuthPost(request, deps = defaultMcpDeps()) {
     return Response.json(toMcpOAuthResponse(startOAuthLogin(providerId, oauthDeps(deps))));
   }, request);
 }
-var BodySchema$1 = external_exports.object({
-  sessionId: SessionIdSchema,
-  model: external_exports.object({
-    provider: external_exports.string(),
-    id: external_exports.string()
-  })
-});
-function handleChatModelPost(request) {
-  return wrapApiHandler(async () => {
-    const raw = await request.json().catch(() => ({}));
-    const body = BodySchema$1.parse(raw);
-    const bridge = getBridge();
-    const session = bridge.getSession(body.sessionId) ?? await bridge.resumeSessionById(body.sessionId);
-    if (!session || !await requireProjectSession(session)) return Response.json({ message: `Unknown session: ${body.sessionId}` }, { status: 404 });
-    await bridge.setModel(body.sessionId, {
-      provider: body.model.provider,
-      id: body.model.id
-    });
-    return Response.json({ ok: true });
-  }, request);
-}
 function toPatternCandidate(model) {
   return {
     id: model.id,
@@ -36406,9 +39472,9 @@ function sessionSourcePath(source) {
   const raw = source;
   return stringValue(raw.sessionFile) ?? stringValue(raw.path);
 }
-function latestBy(entries, time) {
+function latestBy(entries, time2) {
   if (entries.length === 0) return void 0;
-  return entries.reduce((latest, entry) => time(entry) >= time(latest) ? entry : latest);
+  return entries.reduce((latest, entry) => time2(entry) >= time2(latest) ? entry : latest);
 }
 function presentationListActivity(presentation) {
   if (!presentation) return { activityCount: 0 };
@@ -36658,9 +39724,52 @@ function handleHealthGet(request) {
     });
   }, request);
 }
-function handleWorkspaceBrowseGet(request) {
+async function requireReadableSession(sessionId) {
+  const bridge = getBridge();
+  const session = bridge.getSession(sessionId) ?? await bridge.resumeSessionById(sessionId);
+  if (!await requireProjectSession(session)) return {
+    ok: false,
+    response: Response.json({ message: `Unknown session: ${sessionId}` }, { status: 404 })
+  };
+  return {
+    ok: true,
+    session
+  };
+}
+async function requireWritableSession(sessionId) {
+  const access = await requireReadableSession(sessionId);
+  if (!access.ok) return access;
+  const { session } = access;
+  if (session?.isStreaming) return {
+    ok: false,
+    response: Response.json({ message: new SessionTreeBusyError().message }, { status: 409 })
+  };
+  return access;
+}
+function handleChatSessionTreeGet(request) {
   return wrapApiHandler(async () => {
-    return Response.json({ message: "Workspace root switching is disabled; use /api/projects/browse for opaque directory tokens." }, { status: 410 });
+    const sessionId = new URL(request.url).searchParams.get("sessionId");
+    if (!sessionId) return Response.json({ message: "GET /api/chat/session-tree requires ?sessionId=" }, { status: 400 });
+    const parsedSessionId = SessionIdSchema.safeParse(sessionId);
+    if (!parsedSessionId.success) return Response.json({ message: "Invalid session id" }, { status: 400 });
+    const access = await requireReadableSession(parsedSessionId.data);
+    if (!access.ok) return access.response;
+    const snapshot2 = await getBridge().readSessionTreeSnapshot(parsedSessionId.data);
+    return Response.json(SessionTreeSnapshotResponseSchema.parse({ snapshot: snapshot2 }));
+  }, request);
+}
+function handleChatSessionTreeNavigatePost(request) {
+  return wrapApiHandler(async () => {
+    const body = SessionTreeNavigateRequestSchema.parse(await request.json().catch(() => ({})));
+    const access = await requireWritableSession(body.sessionId);
+    if (!access.ok) return access.response;
+    try {
+      const snapshot2 = await getBridge().navigateSessionTree(body.sessionId, body.targetEntryId, body.expectedLeafId);
+      return Response.json(SessionTreeNavigateResponseSchema.parse({ snapshot: snapshot2 }));
+    } catch (error) {
+      if (error instanceof SessionTreeConcurrencyError || error instanceof SessionTreeCancelledError) return Response.json({ message: error.message }, { status: error.status });
+      throw error;
+    }
   }, request);
 }
 function canonicalizePath(path) {
@@ -36864,188 +39973,179 @@ function handleWorkspaceTreeGet(_request) {
     });
   }, _request);
 }
-var Route$27 = createFileRoute("/api/chat")({ server: { handlers: { POST: ({ request }) => handleChatPost(request) } } });
-var Route$26 = createFileRoute("/api/health")({ server: { handlers: { GET: ({ request }) => handleHealthGet(request) } } });
-var Route$25 = createFileRoute("/api/projects")({ server: { handlers: {
+var Route$25 = createFileRoute("/api/chat")({ server: { handlers: { POST: ({ request }) => handleChatPost(request) } } });
+var Route$24 = createFileRoute("/api/health")({ server: { handlers: { GET: ({ request }) => handleHealthGet(request) } } });
+var Route$23 = createFileRoute("/api/projects")({ server: { handlers: {
   DELETE: ({ request }) => handleProjectDelete(request),
   GET: ({ request }) => handleProjectsGet(request),
   PATCH: ({ request }) => handleProjectPatch(request),
   POST: ({ request }) => handleProjectsPost(request)
 } } });
-var Route$24 = createFileRoute("/api/chat/abort")({ server: { handlers: { POST: ({ request }) => handleChatAbortPost(request) } } });
-var Route$23 = createFileRoute("/api/chat/artifacts")({ server: { handlers: { PUT: ({ request }) => handleChatOpenUIArtifactPut(request) } } });
-var Route$22 = createFileRoute("/api/chat/command")({ server: { handlers: { POST: ({ request }) => handleChatCommandPost(request) } } });
-var Route$21 = createFileRoute("/api/chat/commands")({ server: { handlers: { GET: ({ request }) => handleChatCommandsGet(request) } } });
-var Route$20 = createFileRoute("/api/chat/events")({ server: { handlers: { GET: ({ request }) => handleChatEventsGet(request) } } });
-var Route$19 = createFileRoute("/api/chat/mcp")({ server: { handlers: {
+var Route$22 = createFileRoute("/api/chat/abort")({ server: { handlers: { POST: ({ request }) => handleChatAbortPost(request) } } });
+var Route$21 = createFileRoute("/api/chat/artifacts")({ server: { handlers: { PUT: ({ request }) => handleChatOpenUIArtifactPut(request) } } });
+var Route$20 = createFileRoute("/api/chat/command")({ server: { handlers: { POST: ({ request }) => handleChatCommandPost(request) } } });
+var Route$19 = createFileRoute("/api/chat/commands")({ server: { handlers: { GET: ({ request }) => handleChatCommandsGet(request) } } });
+var Route$18 = createFileRoute("/api/chat/events")({ server: { handlers: { GET: ({ request }) => handleChatEventsGet(request) } } });
+var Route$17 = createFileRoute("/api/chat/mcp")({ server: { handlers: {
   GET: ({ request }) => handleChatMcpGet(request),
   POST: ({ request }) => handleChatMcpPost(request),
   DELETE: ({ request }) => handleChatMcpDelete(request)
 } } });
-var Route$18 = createFileRoute("/api/chat/model")({ server: { handlers: { POST: ({ request }) => handleChatModelPost(request) } } });
-var Route$17 = createFileRoute("/api/chat/models")({ server: { handlers: { GET: ({ request }) => handleChatModelsGet(request) } } });
-var Route$16 = createFileRoute("/api/chat/new")({ server: { handlers: { POST: ({ request }) => handleChatNewPost(request) } } });
-var Route$15 = createFileRoute("/api/chat/providers")({ server: { handlers: {
+var Route$16 = createFileRoute("/api/chat/models")({ server: { handlers: { GET: ({ request }) => handleChatModelsGet(request) } } });
+var Route$15 = createFileRoute("/api/chat/new")({ server: { handlers: { POST: ({ request }) => handleChatNewPost(request) } } });
+var Route$14 = createFileRoute("/api/chat/providers")({ server: { handlers: {
   GET: ({ request }) => handleChatProvidersGet(request),
   POST: ({ request }) => handleChatProvidersPost(request),
   DELETE: ({ request }) => handleChatProvidersDelete(request)
 } } });
-var Route$14 = createFileRoute("/api/chat/question")({ server: { handlers: { POST: ({ request }) => handleChatQuestionPost(request) } } });
-var Route$13 = createFileRoute("/api/chat/resources")({ server: { handlers: { GET: ({ request }) => handleChatResourcesGet(request) } } });
-var Route$12 = createFileRoute("/api/chat/resume")({ server: { handlers: { POST: ({ request }) => handleChatResumePost(request) } } });
-var Route$11 = createFileRoute("/api/chat/session")({ server: { handlers: {
+var Route$13 = createFileRoute("/api/chat/question")({ server: { handlers: { POST: ({ request }) => handleChatQuestionPost(request) } } });
+var Route$12 = createFileRoute("/api/chat/resources")({ server: { handlers: { GET: ({ request }) => handleChatResourcesGet(request) } } });
+var Route$11 = createFileRoute("/api/chat/resume")({ server: { handlers: { POST: ({ request }) => handleChatResumePost(request) } } });
+var Route$10 = createFileRoute("/api/chat/session")({ server: { handlers: {
   GET: ({ request }) => new URL(request.url).searchParams.has("attachmentId") ? handleChatAttachmentGet(request) : handleChatSessionGet(request),
   POST: ({ request }) => handleChatAttachmentsPost(request),
   PUT: ({ request }) => handleChatPlanPresentationPut(request),
   PATCH: ({ request }) => handleChatQueueMutationPost(request)
 } } });
-var Route$10 = createFileRoute("/api/chat/sessions")({ server: { handlers: {
+var Route$9 = createFileRoute("/api/chat/session-tree")({ server: { handlers: {
+  GET: ({ request }) => handleChatSessionTreeGet(request),
+  POST: ({ request }) => handleChatSessionTreeNavigatePost(request)
+} } });
+var Route$8 = createFileRoute("/api/chat/sessions")({ server: { handlers: {
   DELETE: ({ request }) => handleChatSessionDelete(request),
   GET: ({ request }) => handleChatSessionsGet(request),
   PATCH: ({ request }) => handleChatSessionRenamePatch(request)
 } } });
-var Route$9 = createFileRoute("/api/chat/settings")({ server: { handlers: {
+var Route$7 = createFileRoute("/api/chat/settings")({ server: { handlers: {
   GET: ({ request }) => handleChatSettingsGet(request),
   PATCH: ({ request }) => handleChatSettingsPatch(request)
 } } });
-var Route$8 = createFileRoute("/api/projects/browse")({ server: { handlers: { GET: ({ request }) => handleProjectBrowseGet(request) } } });
-var Route$7 = createFileRoute("/api/projects/fork")({ server: { handlers: { POST: ({ request }) => handleProjectSessionFork(request) } } });
-var Route$6 = createFileRoute("/api/workspace/browse")({ server: { handlers: { GET: ({ request }) => handleWorkspaceBrowseGet(request) } } });
-var Route$5 = createFileRoute("/api/workspace/file")({ server: { handlers: { GET: ({ request }) => handleWorkspaceFileGet(request) } } });
-var Route$4 = createFileRoute("/api/workspace/root")({ server: { handlers: { POST: () => Response.json({ message: "The workspace root is fixed when Fleet starts" }, { status: 405 }) } } });
+var Route$6 = createFileRoute("/api/projects/browse")({ server: { handlers: { GET: ({ request }) => handleProjectBrowseGet(request) } } });
+var Route$5 = createFileRoute("/api/projects/fork")({ server: { handlers: { POST: ({ request }) => handleProjectSessionFork(request) } } });
+var Route$4 = createFileRoute("/api/workspace/file")({ server: { handlers: { GET: ({ request }) => handleWorkspaceFileGet(request) } } });
 var Route$3 = createFileRoute("/api/workspace/tree")({ server: { handlers: { GET: ({ request }) => handleWorkspaceTreeGet(request) } } });
 var Route$2 = createFileRoute("/api/chat/mcp/oauth")({ server: { handlers: { POST: ({ request }) => handleChatMcpOAuthPost(request) } } });
 var Route$1 = createFileRoute("/api/chat/models/discover")({ server: { handlers: { POST: ({ request }) => handleChatModelsDiscoverPost(request) } } });
 var Route = createFileRoute("/api/chat/providers/oauth")({ server: { handlers: { POST: ({ request }) => handleChatProvidersOAuthPost(request) } } });
-var IndexRoute = Route$28.update({
+var IndexRoute = Route$26.update({
   id: "/",
   path: "/",
-  getParentRoute: () => Route$29
+  getParentRoute: () => Route$27
 });
-var ApiChatRoute = Route$27.update({
+var ApiChatRoute = Route$25.update({
   id: "/api/chat",
   path: "/api/chat",
-  getParentRoute: () => Route$29
+  getParentRoute: () => Route$27
 });
-var ApiHealthRoute = Route$26.update({
+var ApiHealthRoute = Route$24.update({
   id: "/api/health",
   path: "/api/health",
-  getParentRoute: () => Route$29
+  getParentRoute: () => Route$27
 });
-var ApiProjectsRoute = Route$25.update({
+var ApiProjectsRoute = Route$23.update({
   id: "/api/projects",
   path: "/api/projects",
-  getParentRoute: () => Route$29
+  getParentRoute: () => Route$27
 });
-var ApiChatAbortRoute = Route$24.update({
+var ApiChatAbortRoute = Route$22.update({
   id: "/abort",
   path: "/abort",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatArtifactsRoute = Route$23.update({
+var ApiChatArtifactsRoute = Route$21.update({
   id: "/artifacts",
   path: "/artifacts",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatCommandRoute = Route$22.update({
+var ApiChatCommandRoute = Route$20.update({
   id: "/command",
   path: "/command",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatCommandsRoute = Route$21.update({
+var ApiChatCommandsRoute = Route$19.update({
   id: "/commands",
   path: "/commands",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatEventsRoute = Route$20.update({
+var ApiChatEventsRoute = Route$18.update({
   id: "/events",
   path: "/events",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatMcpRoute = Route$19.update({
+var ApiChatMcpRoute = Route$17.update({
   id: "/mcp",
   path: "/mcp",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatModelRoute = Route$18.update({
-  id: "/model",
-  path: "/model",
-  getParentRoute: () => ApiChatRoute
-});
-var ApiChatModelsRoute = Route$17.update({
+var ApiChatModelsRoute = Route$16.update({
   id: "/models",
   path: "/models",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatNewRoute = Route$16.update({
+var ApiChatNewRoute = Route$15.update({
   id: "/new",
   path: "/new",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatProvidersRoute = Route$15.update({
+var ApiChatProvidersRoute = Route$14.update({
   id: "/providers",
   path: "/providers",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatQuestionRoute = Route$14.update({
+var ApiChatQuestionRoute = Route$13.update({
   id: "/question",
   path: "/question",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatResourcesRoute = Route$13.update({
+var ApiChatResourcesRoute = Route$12.update({
   id: "/resources",
   path: "/resources",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatResumeRoute = Route$12.update({
+var ApiChatResumeRoute = Route$11.update({
   id: "/resume",
   path: "/resume",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatSessionRoute = Route$11.update({
+var ApiChatSessionRoute = Route$10.update({
   id: "/session",
   path: "/session",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatSessionsRoute = Route$10.update({
+var ApiChatSessionTreeRoute = Route$9.update({
+  id: "/session-tree",
+  path: "/session-tree",
+  getParentRoute: () => ApiChatRoute
+});
+var ApiChatSessionsRoute = Route$8.update({
   id: "/sessions",
   path: "/sessions",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatSettingsRoute = Route$9.update({
+var ApiChatSettingsRoute = Route$7.update({
   id: "/settings",
   path: "/settings",
   getParentRoute: () => ApiChatRoute
 });
-var ApiProjectsBrowseRoute = Route$8.update({
+var ApiProjectsBrowseRoute = Route$6.update({
   id: "/browse",
   path: "/browse",
   getParentRoute: () => ApiProjectsRoute
 });
-var ApiProjectsForkRoute = Route$7.update({
+var ApiProjectsForkRoute = Route$5.update({
   id: "/fork",
   path: "/fork",
   getParentRoute: () => ApiProjectsRoute
 });
-var ApiWorkspaceBrowseRoute = Route$6.update({
-  id: "/api/workspace/browse",
-  path: "/api/workspace/browse",
-  getParentRoute: () => Route$29
-});
-var ApiWorkspaceFileRoute = Route$5.update({
+var ApiWorkspaceFileRoute = Route$4.update({
   id: "/api/workspace/file",
   path: "/api/workspace/file",
-  getParentRoute: () => Route$29
-});
-var ApiWorkspaceRootRoute = Route$4.update({
-  id: "/api/workspace/root",
-  path: "/api/workspace/root",
-  getParentRoute: () => Route$29
+  getParentRoute: () => Route$27
 });
 var ApiWorkspaceTreeRoute = Route$3.update({
   id: "/api/workspace/tree",
   path: "/api/workspace/tree",
-  getParentRoute: () => Route$29
+  getParentRoute: () => Route$27
 });
 var ApiChatMcpOauthRoute = Route$2.update({
   id: "/oauth",
@@ -37074,7 +40174,6 @@ var ApiChatRouteChildren = {
   ApiChatCommandsRoute,
   ApiChatEventsRoute,
   ApiChatMcpRoute: ApiChatMcpRouteWithChildren,
-  ApiChatModelRoute,
   ApiChatModelsRoute: ApiChatModelsRouteWithChildren,
   ApiChatNewRoute,
   ApiChatProvidersRoute: ApiChatProvidersRoute._addFileChildren(ApiChatProvidersRouteChildren),
@@ -37082,6 +40181,7 @@ var ApiChatRouteChildren = {
   ApiChatResourcesRoute,
   ApiChatResumeRoute,
   ApiChatSessionRoute,
+  ApiChatSessionTreeRoute,
   ApiChatSessionsRoute,
   ApiChatSettingsRoute
 };
@@ -37095,12 +40195,10 @@ var rootRouteChildren = {
   ApiChatRoute: ApiChatRouteWithChildren,
   ApiHealthRoute,
   ApiProjectsRoute: ApiProjectsRoute._addFileChildren(ApiProjectsRouteChildren),
-  ApiWorkspaceBrowseRoute,
   ApiWorkspaceFileRoute,
-  ApiWorkspaceRootRoute,
   ApiWorkspaceTreeRoute
 };
-var routeTree = Route$29._addFileChildren(rootRouteChildren)._addFileTypes();
+var routeTree = Route$27._addFileChildren(rootRouteChildren)._addFileTypes();
 function getRouter() {
   return createRouter({
     routeTree,