@qredence/fleet 0.6.3 → 0.6.5

package/dist/web/server/{router-DfG45nTQ-3VXEUYG5.js → router-DOPFvRSC-G7G75P7U.js}

@@ -1,6 +1,3 @@
-import {
-  isModelPatternEnabled
-} from "./chunk-WTYNN6EV.js";
 import {
   ChatMcpDeleteRequestSchema,
   ChatMcpOAuthLoginRequestSchema,
@@ -10,44 +7,25 @@ import {
   ChatProviderRemoveRequestSchema,
   ChatProviderUpdateRequestSchema,
   ChatSettingsUpdateRequestSchema,
+  ComposerCompletionRequestSchema,
+  ComposerIntentCredentialSchema,
+  ComposerIntentRequestSchema,
+  ComposerIntentSettingsUpdateSchema,
   FLEET_ADAPTER_CAPABILITIES,
-  HTMLVisualElement,
-  MotionConfig,
   NETWORK_DISCONNECTED_MESSAGE,
   QueryClient,
   QueryClientProvider,
-  SVGVisualElement,
   SessionTreeNavigateRequestSchema,
   SessionTreeNavigateResponseSchema,
   SessionTreeSnapshotResponseSchema,
-  addValueToWillChange,
-  animateMotionValue,
-  animateSingleValue,
-  animateTarget,
-  applyBoxDelta,
-  applyTreeDeltas,
-  circOut,
-  convertBoundingBoxToBox,
-  convertBoxToBoundingBox,
-  getOptimisedAppearId,
-  getValueTransition,
-  has2DTranslate,
-  hasScale,
-  hasTransform,
+  composerCompletionIgnores,
   initAnalytics,
-  isKeyframesTarget,
-  isSVGElement,
-  isSVGSVGElement,
   isServer,
-  measurePageBox,
-  pipe,
-  progress,
-  resolveElements,
-  resolveVariant,
-  scalePoint,
-  transformBox,
-  translateAxis
-} from "./chunk-O2IC376F.js";
+  normalizeCompletionDraft
+} from "./chunk-5TXDGMCK.js";
+import {
+  isModelPatternEnabled
+} from "./chunk-WTYNN6EV.js";
 import {
   DEFAULT_UI_PREFERENCES,
   applyUiPreferencesToDocument,
@@ -55,53 +33,102 @@ import {
 } from "./chunk-4EBSM4JR.js";
 import {
   Toaster
-} from "./chunk-TR2GA5OF.js";
+} from "./chunk-VHLBXWEN.js";
 import {
   fallbackSessionLabel,
   meaningfulSessionLabel,
   redactSessionLabelSecrets
 } from "./chunk-PTCKOR23.js";
 import "./chunk-SZJUXVWG.js";
-import "./chunk-TNL4YV63.js";
+import "./chunk-HFN4TNR3.js";
 import {
   isHTMLElement,
+  isObject,
   usePresence
-} from "./chunk-K6PTNSCW.js";
+} from "./chunk-36BG6OPK.js";
 import {
+  KeyframeResolver,
   LayoutGroupContext,
   LazyContext,
+  MotionConfigContext,
+  MotionGlobalConfig,
+  NativeAnimation,
   SubscriptionManager,
   SwitchLayoutGroupContext,
+  VisualElement,
+  WithPromise,
+  acceleratedValues,
   addUniqueItem,
+  analyseComplexValue,
+  buildHTMLStyles,
+  buildSVGAttrs,
+  camelToDash,
   cancelFrame,
   clamp,
+  color,
+  complex,
+  containsCSSVariable,
   cornerRadiusProps,
   createBox,
   createDelta,
+  cssStyleProperties,
+  defaultTransformValue,
+  findDimensionValueType,
+  flushKeyframeResolvers,
   frame,
   frameData,
   frameSteps,
+  generateLinearEasing,
+  getAnimatableNone,
+  getDefaultValueType,
+  getFinalKeyframe,
+  hex,
+  hsla,
   invariant,
   isAnimationControls,
+  isBezierDefinition,
+  isCSSVariableName,
+  isCSSVariableToken,
+  isGenerator,
+  isMotionValue,
+  isNumOrPxType,
+  isNumericalString,
   isRefObject,
   isSVGComponent,
+  isSVGTag,
   isVariantLabel,
+  isZeroValueString,
   loadFeatures,
+  memo$1,
   microtask,
   millisecondsToSeconds,
   mixNumber,
   motionValue,
   noop,
+  optimizedAppearDataAttribute,
   percent,
+  positionalValues,
   px,
+  readTransformValue,
   removeItem,
   resolveMotionValue,
+  resolveVariantFromProps,
+  rgba,
   scaleCorrectors,
+  scrapeMotionValuesFromProps,
+  scrapeMotionValuesFromProps$1,
   secondsToMilliseconds,
+  setStyle,
   time,
+  transformPropOrder,
+  transformProps,
+  useConstant,
   variantPriorityOrder,
-  variantProps
-} from "./chunk-7E76R7MB.js";
+  variantProps,
+  velocityPerSecond,
+  warning
+} from "./chunk-QHCQDVCQ.js";
+import "./chunk-FOMB2JR7.js";
 import {
   Card,
   CardContent,
@@ -109,8 +136,10 @@ import {
   CardHeader,
   CardTitle,
   validateAndNormalizeOpenUIHtmlArtifact
-} from "./chunk-UM3RHJNZ.js";
+} from "./chunk-FF2M3MLP.js";
 import {
+  COMPOSER_INTENT_COMMANDS,
+  COMPOSER_INTENT_NONE,
   ChatNewRequestSchema,
   ChatOpenUIArtifactUpsertRequestSchema,
   ChatPlanPresentationSchema,
@@ -128,8 +157,11 @@ import {
   SessionIdSchema,
   UploadedAttachmentSchema,
   ZodError,
-  external_exports
-} from "./chunk-DP26GVWH.js";
+  composerIntentCommand,
+  decideComposerIntent,
+  external_exports,
+  isSingleTokenDraft
+} from "./chunk-3YYNG52U.js";
 import {
   KNOWN_PROVIDERS,
   OPENAI_CHAT_COMPLETIONS_PROVIDER_ID,
@@ -144,13 +176,13 @@ import {
   toInstanceSlug,
   toOccInstanceId
 } from "./chunk-RJOANOT4.js";
-import "./chunk-JBLHIEVG.js";
-import "./chunk-HQ5TEXHT.js";
-import "./chunk-TLNZNR7C.js";
-import "./chunk-XJ6TGSUB.js";
-import "./chunk-HFQZLPU2.js";
-import "./chunk-4ZIEVI5O.js";
-import "./chunk-CHEC7TWB.js";
+import "./chunk-XZCIEF54.js";
+import "./chunk-UXS5E6OE.js";
+import "./chunk-UUDBEYKV.js";
+import "./chunk-EKVRPCBJ.js";
+import "./chunk-SGMJ5CGW.js";
+import "./chunk-JVXQQYXB.js";
+import "./chunk-JCK6B7ZW.js";
 import {
   HeadContent,
   Outlet,
@@ -159,13 +191,13 @@ import {
   createRootRoute,
   createRouter,
   lazyRouteComponent
-} from "./chunk-5727TXOK.js";
-import "./chunk-JDCCC7A7.js";
+} from "./chunk-F5DJQ3PQ.js";
+import "./chunk-RPWKCJHL.js";
 import "./chunk-L547YHC4.js";
 import "./chunk-MLKGABMK.js";
 
-// web/app/dist/server/assets/router-DfG45nTQ.js
-import { Component, Fragment, useContext, useEffect, useLayoutEffect, useRef, useState } from "react";
+// web/app/dist/server/assets/router-DOPFvRSC.js
+import { Component, Fragment, useContext, useEffect, useLayoutEffect, useMemo, 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";
@@ -175,12 +207,1295 @@ 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";
+var pipe = (...transformers) => transformers.reduce((a, b) => (v) => b(a(v)));
+var progress = /* @__NO_SIDE_EFFECTS__ */ (from, to, value) => {
+  const range = to - from;
+  return range ? (value - from) / range : 1;
+};
+var calcBezier = (t, a1, a2) => (((1 - 3 * a2 + 3 * a1) * t + (3 * a2 - 6 * a1)) * t + 3 * a1) * t;
+var subdivisionPrecision = 1e-7;
+var subdivisionMaxIterations = 12;
+function binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {
+  let currentX;
+  let currentT;
+  let i = 0;
+  do {
+    currentT = lowerBound + (upperBound - lowerBound) / 2;
+    currentX = calcBezier(currentT, mX1, mX2) - x;
+    if (currentX > 0) upperBound = currentT;
+    else lowerBound = currentT;
+  } while (Math.abs(currentX) > subdivisionPrecision && ++i < subdivisionMaxIterations);
+  return currentT;
+}
+// @__NO_SIDE_EFFECTS__
+function cubicBezier(mX1, mY1, mX2, mY2) {
+  if (mX1 === mY1 && mX2 === mY2) return noop;
+  const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);
+  return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);
+}
+var mirrorEasing = /* @__NO_SIDE_EFFECTS__ */ (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;
+var reverseEasing = /* @__NO_SIDE_EFFECTS__ */ (easing) => (p) => 1 - easing(1 - p);
+var backOut = /* @__PURE__ */ cubicBezier(0.33, 1.53, 0.69, 0.99);
+var backIn = /* @__PURE__ */ reverseEasing(backOut);
+var backInOut = /* @__PURE__ */ mirrorEasing(backIn);
+var anticipate = (p) => p >= 1 ? 1 : (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));
+var circIn = (p) => 1 - Math.sin(Math.acos(p));
+var circOut = /* @__PURE__ */ reverseEasing(circIn);
+var circInOut = /* @__PURE__ */ mirrorEasing(circIn);
+var easeIn = /* @__PURE__ */ cubicBezier(0.42, 0, 1, 1);
+var easeOut = /* @__PURE__ */ cubicBezier(0, 0, 0.58, 1);
+var easeInOut = /* @__PURE__ */ cubicBezier(0.42, 0, 0.58, 1);
+var isEasingArray = /* @__NO_SIDE_EFFECTS__ */ (ease2) => {
+  return Array.isArray(ease2) && typeof ease2[0] !== "number";
+};
+var easingLookup = {
+  linear: noop,
+  easeIn,
+  easeInOut,
+  easeOut,
+  circIn,
+  circInOut,
+  circOut,
+  backIn,
+  backInOut,
+  backOut,
+  anticipate
+};
+var isValidEasing = (easing) => {
+  return typeof easing === "string";
+};
+var easingDefinitionToFunction = (definition) => {
+  if (isBezierDefinition(definition)) {
+    invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`, "cubic-bezier-length");
+    const [x1, y1, x2, y2] = definition;
+    return /* @__PURE__ */ cubicBezier(x1, y1, x2, y2);
+  } else if (isValidEasing(definition)) {
+    invariant(easingLookup[definition] !== void 0, `Invalid easing type '${definition}'`, "invalid-easing-type");
+    return easingLookup[definition];
+  }
+  return definition;
+};
+function hueToRgb(p, q, t) {
+  if (t < 0) t += 1;
+  if (t > 1) t -= 1;
+  if (t < 1 / 6) return p + (q - p) * 6 * t;
+  if (t < 1 / 2) return q;
+  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+  return p;
+}
+function hslaToRgba({ hue, saturation, lightness, alpha }) {
+  hue /= 360;
+  saturation /= 100;
+  lightness /= 100;
+  let red = 0;
+  let green = 0;
+  let blue = 0;
+  if (!saturation) red = green = blue = lightness;
+  else {
+    const q = lightness < 0.5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;
+    const p = 2 * lightness - q;
+    red = hueToRgb(p, q, hue + 1 / 3);
+    green = hueToRgb(p, q, hue);
+    blue = hueToRgb(p, q, hue - 1 / 3);
+  }
+  return {
+    red: Math.round(red * 255),
+    green: Math.round(green * 255),
+    blue: Math.round(blue * 255),
+    alpha
+  };
+}
+function mixImmediate(a, b) {
+  return (p) => p > 0 ? b : a;
+}
+var mixLinearColor = (from, to, v) => {
+  const fromExpo = from * from;
+  const expo = v * (to * to - fromExpo) + fromExpo;
+  return expo < 0 ? 0 : Math.sqrt(expo);
+};
+var colorTypes = [
+  hex,
+  rgba,
+  hsla
+];
+var getColorType = (v) => colorTypes.find((type) => type.test(v));
+function asRGBA(color2) {
+  const type = getColorType(color2);
+  warning(Boolean(type), `'${color2}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable");
+  if (!Boolean(type)) return false;
+  let model = type.parse(color2);
+  if (type === hsla) model = hslaToRgba(model);
+  return model;
+}
+var mixColor = (from, to) => {
+  const fromRGBA = asRGBA(from);
+  const toRGBA = asRGBA(to);
+  if (!fromRGBA || !toRGBA) return mixImmediate(from, to);
+  const blended = { ...fromRGBA };
+  return (v) => {
+    blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);
+    blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);
+    blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);
+    blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v);
+    return rgba.transform(blended);
+  };
+};
+var invisibleValues = /* @__PURE__ */ new Set(["none", "hidden"]);
+function mixVisibility(origin, target) {
+  if (invisibleValues.has(origin)) return (p) => p <= 0 ? origin : target;
+  else return (p) => p >= 1 ? target : origin;
+}
+function mixNumber2(a, b) {
+  return (p) => mixNumber(a, b, p);
+}
+function getMixer(a) {
+  if (typeof a === "number") return mixNumber2;
+  else if (typeof a === "string") return isCSSVariableToken(a) ? mixImmediate : color.test(a) ? mixColor : mixComplex;
+  else if (Array.isArray(a)) return mixArray;
+  else if (typeof a === "object") return color.test(a) ? mixColor : mixObject;
+  return mixImmediate;
+}
+function mixArray(a, b) {
+  const output = [...a];
+  const numValues = output.length;
+  const blendValue = a.map((v, i) => getMixer(v)(v, b[i]));
+  return (p) => {
+    for (let i = 0; i < numValues; i++) output[i] = blendValue[i](p);
+    return output;
+  };
+}
+function mixObject(a, b) {
+  const output = {
+    ...a,
+    ...b
+  };
+  const blendValue = {};
+  for (const key in output) if (a[key] !== void 0 && b[key] !== void 0) blendValue[key] = getMixer(a[key])(a[key], b[key]);
+  return (v) => {
+    for (const key in blendValue) output[key] = blendValue[key](v);
+    return output;
+  };
+}
+function matchOrder(origin, target) {
+  const orderedOrigin = [];
+  const pointers = {
+    color: 0,
+    var: 0,
+    number: 0
+  };
+  for (let i = 0; i < target.values.length; i++) {
+    const type = target.types[i];
+    const originIndex = origin.indexes[type][pointers[type]];
+    const originValue = origin.values[originIndex] ?? 0;
+    orderedOrigin[i] = originValue;
+    pointers[type]++;
+  }
+  return orderedOrigin;
+}
+var mixComplex = (origin, target) => {
+  const template = complex.createTransformer(target);
+  const originStats = analyseComplexValue(origin);
+  const targetStats = analyseComplexValue(target);
+  if (originStats.indexes.var.length === targetStats.indexes.var.length && originStats.indexes.color.length === targetStats.indexes.color.length && originStats.indexes.number.length >= targetStats.indexes.number.length) {
+    if (invisibleValues.has(origin) && !targetStats.values.length || invisibleValues.has(target) && !originStats.values.length) return mixVisibility(origin, target);
+    return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), template);
+  } else {
+    warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, "complex-values-different");
+    return mixImmediate(origin, target);
+  }
+};
+function mix(from, to, p) {
+  if (typeof from === "number" && typeof to === "number" && typeof p === "number") return mixNumber(from, to, p);
+  return getMixer(from)(from, to);
+}
+var frameloopDriver = (update) => {
+  const passTimestamp = ({ timestamp }) => update(timestamp);
+  return {
+    start: (keepAlive = true) => frame.update(passTimestamp, keepAlive),
+    stop: () => cancelFrame(passTimestamp),
+    /**
+    * If we're processing this frame we can use the
+    * framelocked timestamp to keep things in sync.
+    */
+    now: () => frameData.isProcessing ? frameData.timestamp : time.now()
+  };
+};
+var maxGeneratorDuration = 2e4;
+function calcGeneratorDuration(generator, timeStep = 50, maxDuration = maxGeneratorDuration, keyframes2) {
+  let duration = 0;
+  let state = generator.next(duration);
+  keyframes2?.push(state.value);
+  while (!state.done && duration < maxDuration) {
+    duration += timeStep;
+    state = generator.next(duration);
+    keyframes2?.push(state.value);
+  }
+  return duration >= maxDuration ? Infinity : duration;
+}
+function createGeneratorEasing(options, scale = 100, createGenerator) {
+  const generator = createGenerator({
+    ...options,
+    keyframes: [0, scale]
+  });
+  const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+  return {
+    type: "keyframes",
+    ease: (progress2) => {
+      return generator.next(duration * progress2).value / scale;
+    },
+    duration: millisecondsToSeconds(duration)
+  };
+}
+var springDefaults = {
+  stiffness: 100,
+  damping: 10,
+  mass: 1,
+  velocity: 0,
+  duration: 800,
+  bounce: 0.3,
+  visualDuration: 0.3,
+  restSpeed: {
+    granular: 0.01,
+    default: 2
+  },
+  restDelta: {
+    granular: 5e-3,
+    default: 0.5
+  },
+  minDuration: 0.01,
+  maxDuration: 10,
+  minDamping: 0.05,
+  maxDamping: 1
+};
+function calcAngularFreq(undampedFreq, dampingRatio) {
+  return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
+}
+var rootIterations = 12;
+function approximateRoot(envelope, derivative, initialGuess) {
+  let result = initialGuess;
+  for (let i = 1; i < rootIterations; i++) result = result - envelope(result) / derivative(result);
+  return result;
+}
+var safeMin = 1e-3;
+function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass }) {
+  let envelope;
+  let derivative;
+  warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let dampingRatio = 1 - bounce;
+  dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
+  duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));
+  if (dampingRatio < 1) {
+    envelope = (undampedFreq2) => {
+      const exponentialDecay = undampedFreq2 * dampingRatio;
+      const delta = exponentialDecay * duration;
+      const a = exponentialDecay - velocity;
+      const b = calcAngularFreq(undampedFreq2, dampingRatio);
+      const c = Math.exp(-delta);
+      return safeMin - a / b * c;
+    };
+    derivative = (undampedFreq2) => {
+      const delta = undampedFreq2 * dampingRatio * duration;
+      const d = delta * velocity + velocity;
+      const e = dampingRatio * dampingRatio * undampedFreq2 * undampedFreq2 * duration;
+      const f = Math.exp(-delta);
+      const g = calcAngularFreq(undampedFreq2 * undampedFreq2, dampingRatio);
+      return (-envelope(undampedFreq2) + safeMin > 0 ? -1 : 1) * ((d - e) * f) / g;
+    };
+  } else {
+    envelope = (undampedFreq2) => {
+      return -1e-3 + Math.exp(-undampedFreq2 * duration) * ((undampedFreq2 - velocity) * duration + 1);
+    };
+    derivative = (undampedFreq2) => {
+      return Math.exp(-undampedFreq2 * duration) * ((velocity - undampedFreq2) * (duration * duration));
+    };
+  }
+  const initialGuess = 5 / duration;
+  const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
+  duration = secondsToMilliseconds(duration);
+  if (isNaN(undampedFreq)) return {
+    stiffness: springDefaults.stiffness,
+    damping: springDefaults.damping,
+    duration
+  };
+  else {
+    const stiffness = undampedFreq * undampedFreq * mass;
+    return {
+      stiffness,
+      damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
+      duration
+    };
+  }
+}
+var durationKeys = ["duration", "bounce"];
+var physicsKeys = [
+  "stiffness",
+  "damping",
+  "mass"
+];
+function isSpringType(options, keys) {
+  return keys.some((key) => options[key] !== void 0);
+}
+function getSpringOptions(options) {
+  let springOptions = {
+    velocity: springDefaults.velocity,
+    stiffness: springDefaults.stiffness,
+    damping: springDefaults.damping,
+    mass: springDefaults.mass,
+    isResolvedFromDuration: false,
+    ...options
+  };
+  if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {
+    springOptions.velocity = 0;
+    if (options.visualDuration) {
+      const visualDuration = options.visualDuration;
+      const root2 = 2 * Math.PI / (visualDuration * 1.2);
+      const stiffness = root2 * root2;
+      const damping = 2 * clamp(0.05, 1, 1 - (options.bounce || 0)) * Math.sqrt(stiffness);
+      springOptions = {
+        ...springOptions,
+        mass: springDefaults.mass,
+        stiffness,
+        damping
+      };
+    } else {
+      const derived = findSpring({
+        ...options,
+        velocity: 0
+      });
+      springOptions = {
+        ...springOptions,
+        ...derived,
+        mass: springDefaults.mass
+      };
+      springOptions.isResolvedFromDuration = true;
+    }
+  }
+  return springOptions;
+}
+function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
+  const options = typeof optionsOrVisualDuration !== "object" ? {
+    visualDuration: optionsOrVisualDuration,
+    keyframes: [0, 1],
+    bounce
+  } : optionsOrVisualDuration;
+  let { restSpeed, restDelta } = options;
+  const origin = options.keyframes[0];
+  const target = options.keyframes[options.keyframes.length - 1];
+  const state = {
+    done: false,
+    value: origin
+  };
+  const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration } = getSpringOptions({
+    ...options,
+    velocity: -millisecondsToSeconds(options.velocity || 0)
+  });
+  const initialVelocity = velocity || 0;
+  const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
+  const initialDelta = target - origin;
+  const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
+  const decay = dampingRatio * undampedAngularFreq;
+  const isGranularScale = Math.abs(initialDelta) < 5;
+  restSpeed || (restSpeed = isGranularScale ? springDefaults.restSpeed.granular : springDefaults.restSpeed.default);
+  restDelta || (restDelta = isGranularScale ? springDefaults.restDelta.granular : springDefaults.restDelta.default);
+  let resolveSpring;
+  let resolveVelocity;
+  if (dampingRatio < 1) {
+    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
+    const A = (initialVelocity + decay * initialDelta) / angularFreq;
+    const sinCoeff = decay * A + initialDelta * angularFreq;
+    const cosCoeff = decay * initialDelta - A * angularFreq;
+    let sampledT = -1;
+    let position = 0;
+    let velocityAtT = 0;
+    const sample = (t) => {
+      if (t !== sampledT) {
+        sampledT = t;
+        const envelope = Math.exp(-decay * t);
+        const sin = Math.sin(angularFreq * t);
+        const cos = Math.cos(angularFreq * t);
+        position = target - envelope * (A * sin + initialDelta * cos);
+        velocityAtT = envelope * (sinCoeff * sin + cosCoeff * cos);
+      }
+    };
+    resolveSpring = (t) => {
+      sample(t);
+      return position;
+    };
+    resolveVelocity = (t) => {
+      sample(t);
+      return velocityAtT;
+    };
+  } else if (dampingRatio === 1) {
+    resolveSpring = (t) => target - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);
+    const C = initialVelocity + undampedAngularFreq * initialDelta;
+    resolveVelocity = (t) => Math.exp(-undampedAngularFreq * t) * (undampedAngularFreq * C * t - initialVelocity);
+  } else {
+    const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
+    resolveSpring = (t) => {
+      const envelope = Math.exp(-decay * t);
+      const freqForT = Math.min(dampedAngularFreq * t, 300);
+      return target - envelope * ((initialVelocity + decay * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
+    };
+    const P = (initialVelocity + decay * initialDelta) / dampedAngularFreq;
+    const sinhCoeff = decay * P - initialDelta * dampedAngularFreq;
+    const coshCoeff = decay * initialDelta - P * dampedAngularFreq;
+    resolveVelocity = (t) => {
+      const envelope = Math.exp(-decay * t);
+      const freqForT = Math.min(dampedAngularFreq * t, 300);
+      return envelope * (sinhCoeff * Math.sinh(freqForT) + coshCoeff * Math.cosh(freqForT));
+    };
+  }
+  const generator = {
+    calculatedDuration: isResolvedFromDuration ? duration || null : null,
+    velocity: (t) => secondsToMilliseconds(resolveVelocity(t)),
+    next: (t) => {
+      const current = resolveSpring(t);
+      if (!isResolvedFromDuration) {
+        const currentVelocity = secondsToMilliseconds(resolveVelocity(t));
+        state.done = Math.abs(currentVelocity) <= restSpeed && Math.abs(target - current) <= restDelta;
+      } else state.done = t >= duration;
+      state.value = state.done ? target : current;
+      return state;
+    },
+    toString: () => {
+      const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+      const easing = generateLinearEasing((progress2) => generator.next(calculatedDuration * progress2).value, calculatedDuration, 30);
+      return calculatedDuration + "ms " + easing;
+    },
+    toTransition: () => {
+    }
+  };
+  return generator;
+}
+spring.applyToOptions = (options) => {
+  const generatorOptions = createGeneratorEasing(options, 100, spring);
+  options.ease = generatorOptions.ease;
+  options.duration = secondsToMilliseconds(generatorOptions.duration);
+  options.type = "keyframes";
+  return options;
+};
+function inertia({ keyframes: keyframes2, velocity = 0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed }) {
+  const origin = keyframes2[0];
+  const state = {
+    done: false,
+    value: origin
+  };
+  const isOutOfBounds = (v) => v < min || v > max;
+  const nearestBoundary = (v) => {
+    if (min === void 0) return max;
+    if (max === void 0) return min;
+    return Math.abs(min - v) < Math.abs(max - v) ? min : max;
+  };
+  let amplitude = power * velocity;
+  const ideal = origin + amplitude;
+  const target = modifyTarget === void 0 ? ideal : modifyTarget(ideal);
+  if (target !== ideal) amplitude = target - origin;
+  const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);
+  const applyFriction = (t) => {
+    const delta = calcDelta(t);
+    state.done = Math.abs(delta) <= restDelta;
+    state.value = state.done ? target : target + delta;
+  };
+  let timeReachedBoundary;
+  let spring$1;
+  const checkCatchBoundary = (t) => {
+    if (!isOutOfBounds(state.value)) return;
+    timeReachedBoundary = t;
+    spring$1 = spring({
+      keyframes: [state.value, nearestBoundary(state.value)],
+      /**
+      * The friction curve is target + calcDelta(t), so its exact
+      * derivative is -calcDelta(t) / timeConstant in units/ms,
+      * converted here to the units/second expected by spring.
+      */
+      velocity: -calcDelta(t) / timeConstant * 1e3,
+      damping: bounceDamping,
+      stiffness: bounceStiffness,
+      restDelta,
+      restSpeed
+    });
+  };
+  checkCatchBoundary(0);
+  return {
+    calculatedDuration: null,
+    next: (t) => {
+      let hasUpdatedFrame = false;
+      if (!spring$1 && timeReachedBoundary === void 0) {
+        hasUpdatedFrame = true;
+        applyFriction(t);
+        checkCatchBoundary(t);
+      }
+      if (timeReachedBoundary !== void 0 && t >= timeReachedBoundary) return spring$1.next(t - timeReachedBoundary);
+      else {
+        !hasUpdatedFrame && applyFriction(t);
+        return state;
+      }
+    }
+  };
+}
+function createMixers(output, ease2, customMixer) {
+  const mixers = [];
+  const mixerFactory = customMixer || MotionGlobalConfig.mix || mix;
+  const numMixers = output.length - 1;
+  for (let i = 0; i < numMixers; i++) {
+    let mixer = mixerFactory(output[i], output[i + 1]);
+    if (ease2) mixer = pipe(Array.isArray(ease2) ? ease2[i] || noop : ease2, mixer);
+    mixers.push(mixer);
+  }
+  return mixers;
+}
+function interpolate(input, output, { clamp: isClamp = true, ease: ease2, mixer } = {}) {
+  const inputLength = input.length;
+  invariant(inputLength === output.length, "Both input and output ranges must be the same length", "range-length");
+  if (inputLength === 1) return () => output[0];
+  if (inputLength === 2 && output[0] === output[1]) return () => output[1];
+  const isZeroDeltaRange = input[0] === input[1];
+  if (input[0] > input[inputLength - 1]) {
+    input = [...input].reverse();
+    output = [...output].reverse();
+  }
+  const mixers = createMixers(output, ease2, mixer);
+  const numMixers = mixers.length;
+  const interpolator = (v) => {
+    if (isZeroDeltaRange && v < input[0]) return output[0];
+    let i = 0;
+    if (numMixers > 1) {
+      for (; i < input.length - 2; i++) if (v < input[i + 1]) break;
+    }
+    const progressInRange = /* @__PURE__ */ progress(input[i], input[i + 1], v);
+    return mixers[i](progressInRange);
+  };
+  return isClamp ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v)) : interpolator;
+}
+function fillOffset(offset, remaining) {
+  const min = offset[offset.length - 1];
+  for (let i = 1; i <= remaining; i++) {
+    const offsetProgress = /* @__PURE__ */ progress(0, remaining, i);
+    offset.push(mixNumber(min, 1, offsetProgress));
+  }
+}
+function defaultOffset(arr) {
+  const offset = [0];
+  fillOffset(offset, arr.length - 1);
+  return offset;
+}
+function convertOffsetToTimes(offset, duration) {
+  return offset.map((o) => o * duration);
+}
+function defaultEasing(values, easing) {
+  return values.map(() => easing || easeInOut).splice(0, values.length - 1);
+}
+function keyframes({ duration = 300, keyframes: keyframeValues, times, ease: ease2 = "easeInOut" }) {
+  const easingFunctions = /* @__PURE__ */ isEasingArray(ease2) ? ease2.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease2);
+  const state = {
+    done: false,
+    value: keyframeValues[0]
+  };
+  const mapTimeToKeyframe = interpolate(convertOffsetToTimes(times && times.length === keyframeValues.length ? times : defaultOffset(keyframeValues), duration), keyframeValues, { ease: Array.isArray(easingFunctions) ? easingFunctions : defaultEasing(keyframeValues, easingFunctions) });
+  return {
+    calculatedDuration: duration,
+    next: (t) => {
+      state.value = mapTimeToKeyframe(t);
+      state.done = t >= duration;
+      return state;
+    }
+  };
+}
+var velocitySampleDuration = 5;
+function getGeneratorVelocity(resolveValue, t, current) {
+  const prevT = Math.max(t - velocitySampleDuration, 0);
+  return velocityPerSecond(current - resolveValue(prevT), t - prevT);
+}
+var transitionTypeMap = {
+  decay: inertia,
+  inertia,
+  tween: keyframes,
+  keyframes,
+  spring
+};
+function replaceTransitionType(transition) {
+  if (typeof transition.type === "string") transition.type = transitionTypeMap[transition.type];
+}
+var percentToProgress = (percent2) => percent2 / 100;
+var JSAnimation = class extends WithPromise {
+  constructor(options) {
+    super();
+    this.state = "idle";
+    this.startTime = null;
+    this.isStopped = false;
+    this.currentTime = 0;
+    this.holdTime = null;
+    this.playbackSpeed = 1;
+    this.delayState = {
+      done: false,
+      value: void 0
+    };
+    this.stop = () => {
+      const { motionValue: motionValue2 } = this.options;
+      if (motionValue2 && motionValue2.updatedAt !== time.now()) this.tick(time.now());
+      this.isStopped = true;
+      if (this.state === "idle") return;
+      this.teardown();
+      this.options.onStop?.();
+    };
+    this.options = options;
+    this.initAnimation();
+    this.play();
+    if (options.autoplay === false) this.pause();
+  }
+  initAnimation() {
+    const { options } = this;
+    replaceTransitionType(options);
+    const { type = keyframes, repeat = 0, repeatDelay = 0, repeatType, velocity = 0 } = options;
+    let { keyframes: keyframes$1 } = options;
+    const generatorFactory = type || keyframes;
+    if (generatorFactory !== keyframes && typeof keyframes$1[0] !== "number") {
+      this.mixKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));
+      keyframes$1 = [0, 100];
+    }
+    const generator = generatorFactory({
+      ...options,
+      keyframes: keyframes$1
+    });
+    if (repeatType === "mirror") this.mirroredGenerator = generatorFactory({
+      ...options,
+      keyframes: [...keyframes$1].reverse(),
+      velocity: -velocity
+    });
+    if (generator.calculatedDuration === null) generator.calculatedDuration = calcGeneratorDuration(generator);
+    const { calculatedDuration } = generator;
+    this.calculatedDuration = calculatedDuration;
+    this.resolvedDuration = calculatedDuration + repeatDelay;
+    this.totalDuration = this.resolvedDuration * (repeat + 1) - repeatDelay;
+    this.generator = generator;
+  }
+  updateTime(timestamp) {
+    const animationTime = Math.round(timestamp - this.startTime) * this.playbackSpeed;
+    if (this.holdTime !== null) this.currentTime = this.holdTime;
+    else this.currentTime = animationTime;
+  }
+  tick(timestamp, sample = false) {
+    const { generator, totalDuration, mixKeyframes, mirroredGenerator, resolvedDuration, calculatedDuration } = this;
+    if (this.startTime === null) return generator.next(0);
+    const { delay: delay2 = 0, keyframes: keyframes2, repeat, repeatType, repeatDelay, type, onUpdate, finalKeyframe } = this.options;
+    if (this.speed > 0) this.startTime = Math.min(this.startTime, timestamp);
+    else if (this.speed < 0) this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);
+    if (sample) this.currentTime = timestamp;
+    else this.updateTime(timestamp);
+    const timeWithoutDelay = this.currentTime - delay2 * (this.playbackSpeed >= 0 ? 1 : -1);
+    const isInDelayPhase = this.playbackSpeed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;
+    this.currentTime = Math.max(timeWithoutDelay, 0);
+    if (this.state === "finished" && this.holdTime === null) this.currentTime = totalDuration;
+    let elapsed = this.currentTime;
+    let frameGenerator = generator;
+    if (repeat) {
+      const progress2 = Math.min(this.currentTime, totalDuration) / resolvedDuration;
+      let currentIteration = Math.floor(progress2);
+      let iterationProgress = progress2 % 1;
+      if (!iterationProgress && progress2 >= 1) iterationProgress = 1;
+      iterationProgress === 1 && currentIteration--;
+      currentIteration = Math.min(currentIteration, repeat + 1);
+      if (Boolean(currentIteration % 2)) {
+        if (repeatType === "reverse") {
+          iterationProgress = 1 - iterationProgress;
+          if (repeatDelay) iterationProgress -= repeatDelay / resolvedDuration;
+        } else if (repeatType === "mirror") frameGenerator = mirroredGenerator;
+      }
+      elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;
+    }
+    let state;
+    if (isInDelayPhase) {
+      this.delayState.value = keyframes2[0];
+      state = this.delayState;
+    } else state = frameGenerator.next(elapsed);
+    if (mixKeyframes && !isInDelayPhase) state.value = mixKeyframes(state.value);
+    let { done } = state;
+    if (!isInDelayPhase && calculatedDuration !== null) done = this.playbackSpeed >= 0 ? this.currentTime >= totalDuration : this.currentTime <= 0;
+    const isAnimationFinished = this.holdTime === null && (this.state === "finished" || this.state === "running" && done);
+    if (isAnimationFinished && type !== inertia) state.value = getFinalKeyframe(keyframes2, this.options, finalKeyframe, this.speed);
+    if (onUpdate) onUpdate(state.value);
+    if (isAnimationFinished) this.finish();
+    return state;
+  }
+  /**
+  * Allows the returned animation to be awaited or promise-chained. Currently
+  * resolves when the animation finishes at all but in a future update could/should
+  * reject if its cancels.
+  */
+  then(resolve2, reject) {
+    return this.finished.then(resolve2, reject);
+  }
+  get duration() {
+    return millisecondsToSeconds(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay: delay2 = 0 } = this.options || {};
+    return this.duration + millisecondsToSeconds(delay2);
+  }
+  get time() {
+    return millisecondsToSeconds(this.currentTime);
+  }
+  set time(newTime) {
+    newTime = secondsToMilliseconds(newTime);
+    this.currentTime = newTime;
+    if (this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0) this.holdTime = newTime;
+    else if (this.driver) this.startTime = this.driver.now() - newTime / this.playbackSpeed;
+    if (this.driver) this.driver.start(false);
+    else {
+      this.startTime = 0;
+      this.state = "paused";
+      this.holdTime = newTime;
+      this.tick(newTime);
+    }
+  }
+  /**
+  * Returns the generator's velocity at the current time in units/second.
+  * Uses the analytical derivative when available (springs), avoiding
+  * the MotionValue's frame-dependent velocity estimation.
+  */
+  getGeneratorVelocity() {
+    const t = this.currentTime;
+    if (t <= 0) return this.options.velocity || 0;
+    if (this.generator.velocity) return this.generator.velocity(t);
+    const current = this.generator.next(t).value;
+    return getGeneratorVelocity((s) => this.generator.next(s).value, t, current);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(newSpeed) {
+    const hasChanged = this.playbackSpeed !== newSpeed;
+    if (hasChanged && this.driver) this.updateTime(time.now());
+    this.playbackSpeed = newSpeed;
+    if (hasChanged && this.driver) this.time = millisecondsToSeconds(this.currentTime);
+  }
+  play() {
+    if (this.isStopped) return;
+    const { driver = frameloopDriver, startTime } = this.options;
+    if (!this.driver) this.driver = driver((timestamp) => this.tick(timestamp));
+    this.options.onPlay?.();
+    const now2 = this.driver.now();
+    if (this.state === "finished") {
+      this.updateFinished();
+      this.startTime = now2;
+    } else if (this.holdTime !== null) this.startTime = now2 - this.holdTime;
+    else if (!this.startTime) this.startTime = startTime ?? now2;
+    if (this.state === "finished" && this.speed < 0) this.startTime += this.calculatedDuration;
+    this.holdTime = null;
+    this.state = "running";
+    this.driver.start();
+  }
+  pause() {
+    this.state = "paused";
+    this.updateTime(time.now());
+    this.holdTime = this.currentTime;
+  }
+  complete() {
+    if (this.state !== "running") this.play();
+    this.state = "finished";
+    this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished();
+    this.teardown();
+    this.state = "finished";
+    this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null;
+    this.startTime = 0;
+    this.tick(0);
+    this.teardown();
+    this.options.onCancel?.();
+  }
+  teardown() {
+    this.state = "idle";
+    this.stopDriver();
+    this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    if (!this.driver) return;
+    this.driver.stop();
+    this.driver = void 0;
+  }
+  sample(sampleTime) {
+    this.startTime = 0;
+    return this.tick(sampleTime, true);
+  }
+  attachTimeline(timeline) {
+    if (this.options.allowFlatten) {
+      this.options.type = "keyframes";
+      this.options.ease = "linear";
+      this.initAnimation();
+    }
+    this.driver?.stop();
+    return timeline.observe(this);
+  }
+};
+var unsupportedEasingFunctions = {
+  anticipate,
+  backInOut,
+  circInOut
+};
+function isUnsupportedEase(key) {
+  return key in unsupportedEasingFunctions;
+}
+function replaceStringEasing(transition) {
+  if (typeof transition.ease === "string" && isUnsupportedEase(transition.ease)) transition.ease = unsupportedEasingFunctions[transition.ease];
+}
+var sampleDelta = 10;
+var NativeAnimationExtended = class extends NativeAnimation {
+  constructor(options) {
+    replaceStringEasing(options);
+    replaceTransitionType(options);
+    super(options);
+    if (options.startTime !== void 0 && options.autoplay !== false) this.startTime = options.startTime;
+    this.options = options;
+  }
+  /**
+  * WAAPI doesn't natively have any interruption capabilities.
+  *
+  * Rather than read committed styles back out of the DOM, we can
+  * create a renderless JS animation and sample it twice to calculate
+  * its current value, "previous" value, and therefore allow
+  * Motion to calculate velocity for any subsequent animation.
+  */
+  updateMotionValue(value) {
+    const { motionValue: motionValue2, onUpdate, onComplete, element, ...options } = this.options;
+    if (!motionValue2) return;
+    if (value !== void 0) {
+      motionValue2.set(value);
+      return;
+    }
+    const sampleAnimation = new JSAnimation({
+      ...options,
+      autoplay: false
+    });
+    const sampleTime = Math.max(sampleDelta, time.now() - this.startTime);
+    const delta = clamp(0, sampleDelta, sampleTime - sampleDelta);
+    const current = sampleAnimation.sample(sampleTime).value;
+    const { name } = this.options;
+    if (element && name) setStyle(element, name, current);
+    motionValue2.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, current, delta);
+    sampleAnimation.stop();
+  }
+};
+var isAnimatable = (value, name) => {
+  if (name === "zIndex") return false;
+  if (typeof value === "number" || Array.isArray(value)) return true;
+  if (typeof value === "string" && (complex.test(value) || value === "0") && !value.startsWith("url(")) return true;
+  return false;
+};
+function hasKeyframesChanged(keyframes2) {
+  const current = keyframes2[0];
+  if (keyframes2.length === 1) return true;
+  for (let i = 0; i < keyframes2.length; i++) if (keyframes2[i] !== current) return true;
+}
+function canAnimate(keyframes2, name, type, velocity) {
+  const originKeyframe = keyframes2[0];
+  if (originKeyframe === null) return false;
+  if (name === "display" || name === "visibility") return true;
+  const targetKeyframe = keyframes2[keyframes2.length - 1];
+  const isOriginAnimatable = isAnimatable(originKeyframe, name);
+  const isTargetAnimatable = isAnimatable(targetKeyframe, name);
+  warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} from "${originKeyframe}" to "${targetKeyframe}". "${isOriginAnimatable ? targetKeyframe : originKeyframe}" is not an animatable value.`, "value-not-animatable");
+  if (!isOriginAnimatable || !isTargetAnimatable) return false;
+  return hasKeyframesChanged(keyframes2) || (type === "spring" || isGenerator(type)) && velocity;
+}
+function makeAnimationInstant(options) {
+  options.duration = 0;
+  options.type = "keyframes";
+}
+var browserColorFunctions = /^(?:oklch|oklab|lab|lch|color|color-mix|light-dark)\(/;
+function hasBrowserOnlyColors(keyframes2) {
+  for (let i = 0; i < keyframes2.length; i++) if (typeof keyframes2[i] === "string" && browserColorFunctions.test(keyframes2[i])) return true;
+  return false;
+}
+var colorProperties = /* @__PURE__ */ new Set([
+  "color",
+  "backgroundColor",
+  "outlineColor",
+  "fill",
+  "stroke",
+  "borderColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor"
+]);
+var supportsWaapi = /* @__PURE__ */ memo$1(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function supportsBrowserAnimation(options) {
+  const { motionValue: motionValue2, name, repeatDelay, repeatType, damping, type, keyframes: keyframes2 } = options;
+  const subject = motionValue2?.owner?.current;
+  if (!(subject instanceof HTMLElement) && !(subject instanceof SVGElement)) return false;
+  const { onUpdate, transformTemplate } = motionValue2.owner.getProps();
+  return supportsWaapi() && name && (acceleratedValues.has(name) || colorProperties.has(name) && hasBrowserOnlyColors(keyframes2)) && (name !== "transform" || !transformTemplate) && !onUpdate && !repeatDelay && repeatType !== "mirror" && damping !== 0 && type !== "inertia";
+}
+var MAX_RESOLVE_DELAY = 40;
+var AsyncMotionValueAnimation = class extends WithPromise {
+  constructor({ autoplay = true, delay: delay2 = 0, type = "keyframes", repeat = 0, repeatDelay = 0, repeatType = "loop", keyframes: keyframes2, name, motionValue: motionValue2, element, ...options }) {
+    super();
+    this.stop = () => {
+      if (this._animation) {
+        this._animation.stop();
+        this.stopTimeline?.();
+      }
+      this.keyframeResolver?.cancel();
+    };
+    this.createdAt = time.now();
+    const optionsWithDefaults = {
+      autoplay,
+      delay: delay2,
+      type,
+      repeat,
+      repeatDelay,
+      repeatType,
+      name,
+      motionValue: motionValue2,
+      element,
+      ...options
+    };
+    const KeyframeResolver$1 = element?.KeyframeResolver || KeyframeResolver;
+    this.keyframeResolver = new KeyframeResolver$1(keyframes2, (resolvedKeyframes, finalKeyframe, forced) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe, optionsWithDefaults, !forced), name, motionValue2, element);
+    this.keyframeResolver?.scheduleResolve();
+  }
+  onKeyframesResolved(keyframes2, finalKeyframe, options, sync) {
+    this.keyframeResolver = void 0;
+    const { name, type, velocity, delay: delay2, isHandoff, onUpdate } = options;
+    this.resolvedAt = time.now();
+    let canAnimateValue = true;
+    if (!canAnimate(keyframes2, name, type, velocity)) {
+      canAnimateValue = false;
+      if (MotionGlobalConfig.instantAnimations || !delay2) onUpdate?.(getFinalKeyframe(keyframes2, options, finalKeyframe));
+      keyframes2[0] = keyframes2[keyframes2.length - 1];
+      makeAnimationInstant(options);
+      options.repeat = 0;
+    }
+    const resolvedOptions = {
+      startTime: sync ? !this.resolvedAt ? this.createdAt : this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY ? this.resolvedAt : this.createdAt : void 0,
+      finalKeyframe,
+      ...options,
+      keyframes: keyframes2
+    };
+    const useWaapi = canAnimateValue && !isHandoff && supportsBrowserAnimation(resolvedOptions);
+    const element = resolvedOptions.motionValue?.owner?.current;
+    let animation;
+    if (useWaapi) try {
+      animation = new NativeAnimationExtended({
+        ...resolvedOptions,
+        element
+      });
+    } catch {
+      animation = new JSAnimation(resolvedOptions);
+    }
+    else animation = new JSAnimation(resolvedOptions);
+    animation.finished.then(() => {
+      this.notifyFinished();
+    }).catch(noop);
+    if (this.pendingTimeline) {
+      this.stopTimeline = animation.attachTimeline(this.pendingTimeline);
+      this.pendingTimeline = void 0;
+    }
+    this._animation = animation;
+  }
+  get finished() {
+    if (!this._animation) return this._finished;
+    else return this.animation.finished;
+  }
+  then(onResolve, _onReject) {
+    return this.finished.finally(onResolve).then(() => {
+    });
+  }
+  get animation() {
+    if (!this._animation) {
+      this.keyframeResolver?.resume();
+      flushKeyframeResolvers();
+    }
+    return this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(newTime) {
+    this.animation.time = newTime;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(newSpeed) {
+    this.animation.speed = newSpeed;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(timeline) {
+    if (this._animation) this.stopTimeline = this.animation.attachTimeline(timeline);
+    else this.pendingTimeline = timeline;
+    return () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    if (this._animation) this.animation.cancel();
+    this.keyframeResolver?.cancel();
+  }
+};
 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 resolveTransition(transition, parentTransition) {
+  if (transition?.inherit && parentTransition) {
+    const { inherit: _, ...rest } = transition;
+    return {
+      ...parentTransition,
+      ...rest
+    };
+  }
+  return transition;
+}
+function getValueTransition(transition, key) {
+  const valueTransition = transition?.[key] ?? transition?.["default"] ?? transition;
+  if (valueTransition !== transition) return resolveTransition(valueTransition, transition);
+  return valueTransition;
+}
+var underDampedSpring = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+};
+var criticallyDampedSpring = (target) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: target === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+});
+var keyframesTransition = {
+  type: "keyframes",
+  duration: 0.8
+};
+var ease = {
+  type: "keyframes",
+  ease: [
+    0.25,
+    0.1,
+    0.35,
+    1
+  ],
+  duration: 0.3
+};
+var getDefaultTransition = (valueKey, { keyframes: keyframes2 }) => {
+  if (keyframes2.length > 2) return keyframesTransition;
+  else if (transformProps.has(valueKey)) return valueKey.startsWith("scale") ? criticallyDampedSpring(keyframes2[1]) : underDampedSpring;
+  return ease;
+};
+var orchestrationKeys = /* @__PURE__ */ new Set([
+  "when",
+  "delay",
+  "delayChildren",
+  "staggerChildren",
+  "staggerDirection",
+  "repeat",
+  "repeatType",
+  "repeatDelay",
+  "from",
+  "elapsed"
+]);
+function isTransitionDefined(transition) {
+  for (const key in transition) if (!orchestrationKeys.has(key)) return true;
+  return false;
+}
+var animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
+  const valueTransition = getValueTransition(transition, name) || {};
+  const delay2 = valueTransition.delay || transition.delay || 0;
+  let { elapsed = 0 } = transition;
+  elapsed = elapsed - secondsToMilliseconds(delay2);
+  const options = {
+    keyframes: Array.isArray(target) ? target : [null, target],
+    ease: "easeOut",
+    velocity: value.getVelocity(),
+    ...valueTransition,
+    delay: -elapsed,
+    onUpdate: (v) => {
+      value.set(v);
+      valueTransition.onUpdate && valueTransition.onUpdate(v);
+    },
+    onComplete: () => {
+      onComplete();
+      valueTransition.onComplete && valueTransition.onComplete();
+    },
+    name,
+    motionValue: value,
+    element: isHandoff ? void 0 : element
+  };
+  if (!isTransitionDefined(valueTransition)) Object.assign(options, getDefaultTransition(name, options));
+  options.duration && (options.duration = secondsToMilliseconds(options.duration));
+  options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));
+  if (options.from !== void 0) options.keyframes[0] = options.from;
+  let shouldSkip = false;
+  if (options.type === false || options.duration === 0 && !options.repeatDelay) {
+    makeAnimationInstant(options);
+    if (options.delay === 0) shouldSkip = true;
+  }
+  if (MotionGlobalConfig.instantAnimations || MotionGlobalConfig.skipAnimations || element?.shouldSkipAnimations || valueTransition.skipAnimations) {
+    shouldSkip = true;
+    makeAnimationInstant(options);
+    options.delay = 0;
+  }
+  options.allowFlatten = !valueTransition.type && !valueTransition.ease;
+  if (shouldSkip && !isHandoff && value.get() !== void 0) {
+    const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);
+    if (finalKeyframe !== void 0) {
+      frame.update(() => {
+        options.onUpdate(finalKeyframe);
+        options.onComplete();
+      });
+      return;
+    }
+  }
+  return valueTransition.isSync ? new JSAnimation(options) : new AsyncMotionValueAnimation(options);
+};
+var splitCSSVariableRegex = /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u;
+function parseCSSVariable(current) {
+  const match = splitCSSVariableRegex.exec(current);
+  if (!match) return [,];
+  const [, token1, token2, fallback] = match;
+  return [`--${token1 ?? token2}`, fallback];
+}
+var maxDepth = 4;
+function getVariableValue(current, element, depth = 1) {
+  invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property "${current}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+  const [token, fallback] = parseCSSVariable(current);
+  if (!token) return;
+  const resolved = window.getComputedStyle(element).getPropertyValue(token);
+  if (resolved) {
+    const trimmed = resolved.trim();
+    return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;
+  }
+  return isCSSVariableToken(fallback) ? getVariableValue(fallback, element, depth + 1) : fallback;
+}
+function resolveVariant(visualElement, definition, custom) {
+  const props = visualElement.getProps();
+  return resolveVariantFromProps(props, definition, custom !== void 0 ? custom : props.custom, visualElement);
+}
+var positionalKeys = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...transformPropOrder
+]);
+var isKeyframesTarget = (v) => {
+  return Array.isArray(v);
+};
+function setMotionValue(visualElement, key, value) {
+  if (visualElement.hasValue(key)) visualElement.getValue(key).set(value);
+  else visualElement.addValue(key, motionValue(value));
+}
+function resolveFinalValueInKeyframes(v) {
+  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
+}
+function setTarget(visualElement, definition) {
+  let { transitionEnd = {}, transition = {}, ...target } = resolveVariant(visualElement, definition) || {};
+  target = {
+    ...target,
+    ...transitionEnd
+  };
+  for (const key in target) setMotionValue(visualElement, key, resolveFinalValueInKeyframes(target[key]));
+}
+function isWillChangeMotionValue(value) {
+  return Boolean(isMotionValue(value) && value.add);
+}
+function addValueToWillChange(visualElement, key) {
+  const willChange = visualElement.getValue("willChange");
+  if (isWillChangeMotionValue(willChange)) return willChange.add(key);
+  else if (!willChange && MotionGlobalConfig.WillChange) {
+    const newWillChange = new MotionGlobalConfig.WillChange("auto");
+    visualElement.addValue("willChange", newWillChange);
+    newWillChange.add(key);
+  }
+}
+function getOptimisedAppearId(visualElement) {
+  return visualElement.props[optimizedAppearDataAttribute];
+}
+var isBrowser = typeof window !== "undefined";
+function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
+  const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
+  needsAnimating[key] = false;
+  return shouldBlock;
+}
+function animateTarget(visualElement, targetAndTransition, { delay: delay2 = 0, transitionOverride, type } = {}) {
+  let { transition, transitionEnd, ...target } = targetAndTransition;
+  const defaultTransition = visualElement.getDefaultTransition();
+  transition = transition ? resolveTransition(transition, defaultTransition) : defaultTransition;
+  const reduceMotion = transition?.reduceMotion;
+  const skipAnimations = transition?.skipAnimations;
+  if (transitionOverride) transition = transitionOverride;
+  const animations2 = [];
+  const animationTypeState = type && visualElement.animationState && visualElement.animationState.getState()[type];
+  const path = transition?.path;
+  if (path) path.animateVisualElement(visualElement, target, transition, delay2, animations2);
+  for (const key in target) {
+    const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);
+    const valueTarget = target[key];
+    if (valueTarget === void 0 || animationTypeState && shouldBlockAnimation(animationTypeState, key)) continue;
+    const valueTransition = {
+      delay: delay2,
+      ...getValueTransition(transition || {}, key)
+    };
+    if (skipAnimations) valueTransition.skipAnimations = true;
+    const currentValue = value.get();
+    if (currentValue !== void 0 && !value.isAnimating() && !Array.isArray(valueTarget) && valueTarget === currentValue && !valueTransition.velocity) {
+      frame.update(() => value.set(valueTarget));
+      continue;
+    }
+    let isHandoff = false;
+    if (isBrowser && window.MotionHandoffAnimation) {
+      const appearId = getOptimisedAppearId(visualElement);
+      if (appearId) {
+        const startTime = window.MotionHandoffAnimation(appearId, key, frame);
+        if (startTime !== null) {
+          valueTransition.startTime = startTime;
+          isHandoff = true;
+        }
+      }
+    }
+    addValueToWillChange(visualElement, key);
+    const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;
+    value.start(animateMotionValue(key, value, valueTarget, shouldReduceMotion && positionalKeys.has(key) ? { type: false } : valueTransition, visualElement, isHandoff));
+    const animation = value.animation;
+    if (animation) animations2.push(animation);
+  }
+  if (transitionEnd) {
+    const applyTransitionEnd = () => frame.update(() => {
+      transitionEnd && setTarget(visualElement, transitionEnd);
+    });
+    if (animations2.length) Promise.all(animations2).then(applyTransitionEnd);
+    else applyTransitionEnd();
+  }
+  return animations2;
+}
 function animateVariant(visualElement, variant, options = {}) {
   const resolved = resolveVariant(visualElement, variant, options.type === "exit" ? visualElement.presenceContext?.custom : void 0);
   let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
@@ -222,6 +1537,103 @@ function animateVisualElement(visualElement, definition, options = {}) {
     visualElement.notify("AnimationComplete", definition);
   });
 }
+function isNone(value) {
+  if (typeof value === "number") return value === 0;
+  else if (value !== null) return value === "none" || value === "0" || isZeroValueString(value);
+  else return true;
+}
+var invalidTemplates = /* @__PURE__ */ new Set([
+  "auto",
+  "none",
+  "0"
+]);
+function makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {
+  let i = 0;
+  let animatableTemplate = void 0;
+  while (i < unresolvedKeyframes.length && !animatableTemplate) {
+    const keyframe = unresolvedKeyframes[i];
+    if (typeof keyframe === "string" && !invalidTemplates.has(keyframe) && analyseComplexValue(keyframe).values.length) animatableTemplate = unresolvedKeyframes[i];
+    i++;
+  }
+  if (animatableTemplate && name) for (const noneIndex of noneKeyframeIndexes) unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);
+}
+var DOMKeyframesResolver = class extends KeyframeResolver {
+  constructor(unresolvedKeyframes, onComplete, name, motionValue2, element) {
+    super(unresolvedKeyframes, onComplete, name, motionValue2, element, true);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes, element, name } = this;
+    if (!element || !element.current) return;
+    super.readKeyframes();
+    for (let i = 0; i < unresolvedKeyframes.length; i++) {
+      let keyframe = unresolvedKeyframes[i];
+      if (typeof keyframe === "string") {
+        keyframe = keyframe.trim();
+        if (isCSSVariableToken(keyframe)) {
+          const resolved = getVariableValue(keyframe, element.current);
+          if (resolved !== void 0) unresolvedKeyframes[i] = resolved;
+          if (i === unresolvedKeyframes.length - 1) this.finalKeyframe = keyframe;
+        }
+      }
+    }
+    this.resolveNoneKeyframes();
+    if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) return;
+    const [origin, target] = unresolvedKeyframes;
+    const originType = findDimensionValueType(origin);
+    const targetType = findDimensionValueType(target);
+    if (containsCSSVariable(origin) !== containsCSSVariable(target) && positionalValues[name]) {
+      this.needsMeasurement = true;
+      return;
+    }
+    if (originType === targetType) return;
+    if (isNumOrPxType(originType) && isNumOrPxType(targetType)) for (let i = 0; i < unresolvedKeyframes.length; i++) {
+      const value = unresolvedKeyframes[i];
+      if (typeof value === "string") unresolvedKeyframes[i] = parseFloat(value);
+    }
+    else if (positionalValues[name])
+      this.needsMeasurement = true;
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes, name } = this;
+    const noneKeyframeIndexes = [];
+    for (let i = 0; i < unresolvedKeyframes.length; i++) if (unresolvedKeyframes[i] === null || isNone(unresolvedKeyframes[i])) noneKeyframeIndexes.push(i);
+    if (noneKeyframeIndexes.length) makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);
+  }
+  measureInitialState() {
+    const { element, unresolvedKeyframes, name } = this;
+    if (!element || !element.current) return;
+    if (name === "height") this.suspendedScrollY = window.pageYOffset;
+    this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
+    unresolvedKeyframes[0] = this.measuredOrigin;
+    const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
+    if (measureKeyframe !== void 0) element.getValue(name, measureKeyframe).jump(measureKeyframe, false);
+  }
+  measureEndState() {
+    const { element, name, unresolvedKeyframes } = this;
+    if (!element || !element.current) return;
+    const value = element.getValue(name);
+    value && value.jump(this.measuredOrigin, false);
+    const finalKeyframeIndex = unresolvedKeyframes.length - 1;
+    const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];
+    unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
+    if (finalKeyframe !== null && this.finalKeyframe === void 0) this.finalKeyframe = finalKeyframe;
+    if (this.removedTransforms?.length) this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {
+      element.getValue(unsetTransformName).set(unsetTransformValue);
+    });
+    this.resolveNoneKeyframes();
+  }
+};
+function resolveElements(elementOrSelector, scope, selectorCache) {
+  if (elementOrSelector == null) return [];
+  if (elementOrSelector instanceof EventTarget) return [elementOrSelector];
+  else if (typeof elementOrSelector === "string") {
+    let root2 = document;
+    if (scope) root2 = scope.current;
+    const elements = selectorCache?.[elementOrSelector] ?? root2.querySelectorAll(elementOrSelector);
+    return elements ? Array.from(elements) : [];
+  }
+  return Array.from(elementOrSelector).filter((element) => element != null);
+}
 var isDragging = {
   x: false,
   y: false
@@ -414,6 +1826,9 @@ function press(targetOrSelector, onPressStart, options = {}) {
   });
   return cancelEvents;
 }
+function isSVGElement(element) {
+  return isObject(element) && "ownerSVGElement" in element;
+}
 var resizeHandlers = /* @__PURE__ */ new WeakMap();
 var observer;
 var getSize = (borderBoxAxis, svgAxis, htmlAxis) => (target, borderBoxSize) => {
@@ -496,6 +1911,36 @@ var statsBuffer = {
   value: null,
   addProjectionMetrics: null
 };
+function isSVGSVGElement(element) {
+  return isSVGElement(element) && element.tagName === "svg";
+}
+var DOMVisualElement = class extends VisualElement {
+  constructor() {
+    super(...arguments);
+    this.KeyframeResolver = DOMKeyframesResolver;
+  }
+  sortInstanceNodePosition(a, b) {
+    return a.compareDocumentPosition(b) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(props, key) {
+    const style = props.style;
+    return style ? style[key] : void 0;
+  }
+  removeValueFromRenderState(key, { vars, style }) {
+    delete vars[key];
+    delete style[key];
+  }
+  handleChildMotionValue() {
+    if (this.childSubscription) {
+      this.childSubscription();
+      delete this.childSubscription;
+    }
+    const { children } = this.props;
+    if (isMotionValue(children)) this.childSubscription = children.on("change", (latest) => {
+      if (this.current) this.current.textContent = `${latest}`;
+    });
+  }
+};
 var Feature = class {
   constructor(node) {
     this.isMounted = false;
@@ -504,6 +1949,231 @@ var Feature = class {
   update() {
   }
 };
+function convertBoundingBoxToBox({ top, left, right, bottom }) {
+  return {
+    x: {
+      min: left,
+      max: right
+    },
+    y: {
+      min: top,
+      max: bottom
+    }
+  };
+}
+function convertBoxToBoundingBox({ x, y }) {
+  return {
+    top: y.min,
+    right: x.max,
+    bottom: y.max,
+    left: x.min
+  };
+}
+function transformBoxPoints(point, transformPoint2) {
+  if (!transformPoint2) return point;
+  const topLeft = transformPoint2({
+    x: point.left,
+    y: point.top
+  });
+  const bottomRight = transformPoint2({
+    x: point.right,
+    y: point.bottom
+  });
+  return {
+    top: topLeft.y,
+    left: topLeft.x,
+    bottom: bottomRight.y,
+    right: bottomRight.x
+  };
+}
+function isIdentityScale(scale) {
+  return scale === void 0 || scale === 1;
+}
+function hasScale({ scale, scaleX, scaleY }) {
+  return !isIdentityScale(scale) || !isIdentityScale(scaleX) || !isIdentityScale(scaleY);
+}
+function hasTransform(values) {
+  return hasScale(values) || has2DTranslate(values) || values.z || values.rotate || values.rotateX || values.rotateY || values.skewX || values.skewY;
+}
+function has2DTranslate(values) {
+  return is2DTranslate(values.x) || is2DTranslate(values.y);
+}
+function is2DTranslate(value) {
+  return value && value !== "0%";
+}
+function scalePoint(point, scale, originPoint) {
+  return originPoint + scale * (point - originPoint);
+}
+function applyPointDelta(point, translate, scale, originPoint, boxScale) {
+  if (boxScale !== void 0) point = scalePoint(point, boxScale, originPoint);
+  return scalePoint(point, scale, originPoint) + translate;
+}
+function applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {
+  axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);
+  axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);
+}
+function applyBoxDelta(box, { x, y }) {
+  applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);
+  applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);
+}
+var TREE_SCALE_SNAP_MIN = 0.999999999999;
+var TREE_SCALE_SNAP_MAX = 1.0000000000001;
+function applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {
+  const treeLength = treePath.length;
+  if (!treeLength) return;
+  treeScale.x = treeScale.y = 1;
+  let node;
+  let delta;
+  for (let i = 0; i < treeLength; i++) {
+    node = treePath[i];
+    delta = node.projectionDelta;
+    const { visualElement } = node.options;
+    if (visualElement && visualElement.props.style && visualElement.props.style.display === "contents") continue;
+    if (isSharedTransition && node.options.layoutScroll && node.scroll && node !== node.root) {
+      translateAxis(box.x, -node.scroll.offset.x);
+      translateAxis(box.y, -node.scroll.offset.y);
+    }
+    if (delta) {
+      treeScale.x *= delta.x.scale;
+      treeScale.y *= delta.y.scale;
+      applyBoxDelta(box, delta);
+    }
+    if (isSharedTransition && hasTransform(node.latestValues)) transformBox(box, node.latestValues, node.layout?.layoutBox);
+  }
+  if (treeScale.x < TREE_SCALE_SNAP_MAX && treeScale.x > TREE_SCALE_SNAP_MIN) treeScale.x = 1;
+  if (treeScale.y < TREE_SCALE_SNAP_MAX && treeScale.y > TREE_SCALE_SNAP_MIN) treeScale.y = 1;
+}
+function translateAxis(axis, distance2) {
+  axis.min += distance2;
+  axis.max += distance2;
+}
+function transformAxis(axis, axisTranslate, axisScale, boxScale, axisOrigin = 0.5) {
+  applyAxisDelta(axis, axisTranslate, axisScale, mixNumber(axis.min, axis.max, axisOrigin), boxScale);
+}
+function resolveAxisTranslate(value, axis) {
+  if (typeof value === "string") return parseFloat(value) / 100 * (axis.max - axis.min);
+  return value;
+}
+function transformBox(box, transform, sourceBox) {
+  const resolveBox = sourceBox ?? box;
+  transformAxis(box.x, resolveAxisTranslate(transform.x, resolveBox.x), transform.scaleX, transform.scale, transform.originX);
+  transformAxis(box.y, resolveAxisTranslate(transform.y, resolveBox.y), transform.scaleY, transform.scale, transform.originY);
+}
+function measureViewportBox(instance, transformPoint2) {
+  return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint2));
+}
+function measurePageBox(element, rootProjectionNode2, transformPagePoint) {
+  const viewportBox = measureViewportBox(element, transformPagePoint);
+  const { scroll } = rootProjectionNode2;
+  if (scroll) {
+    translateAxis(viewportBox.x, scroll.offset.x);
+    translateAxis(viewportBox.y, scroll.offset.y);
+  }
+  return viewportBox;
+}
+function renderHTML(element, { style, vars }, styleProp, projection) {
+  const elementStyle = element.style;
+  let key;
+  for (key in style) elementStyle[key] = style[key];
+  projection?.applyProjectionStyles(elementStyle, styleProp);
+  for (key in vars) elementStyle.setProperty(key, vars[key]);
+}
+function getComputedStyle$1(element) {
+  return window.getComputedStyle(element);
+}
+var HTMLVisualElement = class extends DOMVisualElement {
+  constructor() {
+    super(...arguments);
+    this.type = "html";
+    this.renderInstance = renderHTML;
+  }
+  mount(instance) {
+    invariant(Boolean(instance.style), "motion.create() components must forward their ref to a HTML or SVG element", "custom-component-ref");
+    super.mount(instance);
+  }
+  readValueFromInstance(instance, key) {
+    if (transformProps.has(key)) return this.projection?.isProjecting ? defaultTransformValue(key) : readTransformValue(instance, key);
+    else {
+      const computedStyle = getComputedStyle$1(instance);
+      const value = (isCSSVariableName(key) ? computedStyle.getPropertyValue(key) : computedStyle[key]) || 0;
+      return typeof value === "string" ? value.trim() : value;
+    }
+  }
+  measureInstanceViewportBox(instance, { transformPagePoint }) {
+    return measureViewportBox(instance, transformPagePoint);
+  }
+  build(renderState, latestValues, props) {
+    buildHTMLStyles(renderState, latestValues, props.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+    return scrapeMotionValuesFromProps$1(props, prevProps, visualElement);
+  }
+};
+var camelCaseAttributes = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform",
+  "pathLength",
+  "startOffset",
+  "textLength",
+  "lengthAdjust"
+]);
+function renderSVG(element, renderState, _styleProp, projection) {
+  renderHTML(element, renderState, void 0, projection);
+  for (const key in renderState.attrs) element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);
+}
+var SVGVisualElement = class extends DOMVisualElement {
+  constructor() {
+    super(...arguments);
+    this.type = "svg";
+    this.isSVGTag = false;
+    this.measureInstanceViewportBox = createBox;
+  }
+  getBaseTargetFromProps(props, key) {
+    return props[key];
+  }
+  readValueFromInstance(instance, key) {
+    if (transformProps.has(key)) {
+      const defaultType = getDefaultValueType(key);
+      return defaultType ? defaultType.default || 0 : 0;
+    }
+    if (cssStyleProperties.includes(key)) {
+      const value = getComputedStyle(instance)[key];
+      if (typeof value === "string" && value) return value.trim();
+    }
+    key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
+    return instance.getAttribute(key);
+  }
+  scrapeMotionValuesFromProps(props, prevProps, visualElement) {
+    return scrapeMotionValuesFromProps(props, prevProps, visualElement);
+  }
+  build(renderState, latestValues, props) {
+    buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate, props.style);
+  }
+  renderInstance(instance, renderState, styleProp, projection) {
+    renderSVG(instance, renderState, styleProp, projection);
+  }
+  mount(instance) {
+    this.isSVGTag = isSVGTag(instance.tagName);
+    super.mount(instance);
+  }
+};
 var numVariantProps = variantProps.length;
 function getVariantContext(visualElement) {
   if (!visualElement) return void 0;
@@ -869,9 +2539,14 @@ function compress(min, max, easing) {
   return (p) => {
     if (p < min) return 0;
     if (p > max) return 1;
-    return easing(progress(min, max, p));
+    return easing(/* @__PURE__ */ progress(min, max, p));
   };
 }
+function animateSingleValue(value, keyframes2, options) {
+  const motionValue$1 = isMotionValue(value) ? value : motionValue(value);
+  motionValue$1.start(animateMotionValue("", motionValue$1, keyframes2, options));
+  return motionValue$1.animation;
+}
 function addDomEvent(target, eventName, handler, options = { passive: true }) {
   target.addEventListener(eventName, handler, options);
   return () => target.removeEventListener(eventName, handler, options);
@@ -1553,10 +3228,10 @@ function createProjectionNode({ attachResizeListener, defaultParent, measureScro
       const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation && !isOnlyMember && this.options.crossfade === true && !this.path.some(hasOpacityCrossfade));
       this.animationProgress = 0;
       let prevRelativeTarget;
-      const interpolate = pathFn?.interpolateProjection(delta);
+      const interpolate2 = pathFn?.interpolateProjection(delta);
       this.mixTargetDelta = (latest) => {
         const progress2 = latest / 1e3;
-        const point = interpolate?.(progress2);
+        const point = interpolate2?.(progress2);
         if (point) {
           targetDelta.x.translate = point.x;
           targetDelta.x.scale = mixNumber(delta.x.scale, 1, progress2);
@@ -1989,6 +3664,26 @@ function LazyMotion({ children, features, strict = false }) {
 function isLazyBundle(features) {
   return typeof features === "function";
 }
+function MotionConfig({ children, ...config }) {
+  const parentConfig = useContext(MotionConfigContext);
+  config = {
+    ...parentConfig,
+    ...config
+  };
+  config.transition = resolveTransition(config.transition, parentConfig.transition);
+  config.isStatic = useConstant(() => config.isStatic);
+  const context = useMemo(() => config, [
+    JSON.stringify(config.transition),
+    config.transformPagePoint,
+    config.reducedMotion,
+    config.skipAnimations,
+    config.isValidProp
+  ]);
+  return jsx(MotionConfigContext.Provider, {
+    value: context,
+    children
+  });
+}
 var createDomVisualElement = (Component2, options) => {
   return options.isSVG ?? isSVGComponent(Component2) ? new SVGVisualElement(options) : new HTMLVisualElement(options, { allowProjection: Component2 !== Fragment });
 };
@@ -2322,8 +4017,8 @@ 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);
+  if (targetLength > sourceLength) origin = /* @__PURE__ */ progress(target.min, target.max - sourceLength, source.min);
+  else if (sourceLength > targetLength) origin = /* @__PURE__ */ progress(source.min, source.max - targetLength, target.min);
   return clamp(0, 1, origin);
 }
 function rebaseAxisConstraints(layout2, constraints) {
@@ -2543,7 +4238,7 @@ var VisualElementDragControls = class {
       };
       const bounceStiffness = dragElastic ? 200 : 1e6;
       const bounceDamping = dragElastic ? 40 : 1e7;
-      const inertia = {
+      const inertia2 = {
         type: "inertia",
         velocity: dragMomentum ? velocity[axis] : 0,
         bounceStiffness,
@@ -2554,7 +4249,7 @@ var VisualElementDragControls = class {
         ...dragTransition,
         ...transition
       };
-      return this.startAxisValueAnimation(axis, inertia);
+      return this.startAxisValueAnimation(axis, inertia2);
     });
     return Promise.all(momentumAnimations).then(onDragTransitionEnd);
   }
@@ -3079,7 +4774,7 @@ function MotionRuntime({ children }) {
     })
   });
 }
-var globals_default = "/assets/globals-BtCXZXL_.css";
+var globals_default = "/assets/globals-BiAbxPQ2.css";
 function makeQueryClient() {
   return new QueryClient({ defaultOptions: { queries: {
     staleTime: 6e4,
@@ -3093,7 +4788,7 @@ function getQueryClient() {
   if (!browserQueryClient) browserQueryClient = makeQueryClient();
   return browserQueryClient;
 }
-var Route$27 = createRootRoute({
+var Route$29 = createRootRoute({
   head: () => ({
     meta: [
       { charSet: "utf-8" },
@@ -3161,8 +4856,8 @@ function RootDocument({ children }) {
     ] })]
   });
 }
-var $$splitComponentImporter = () => import("./routes-B9F9UfF1-UN2IVBMJ.js");
-var Route$26 = createFileRoute("/")({ component: lazyRouteComponent($$splitComponentImporter, "component") });
+var $$splitComponentImporter = () => import("./routes-i2Ai-ZwX-SMSFONDQ.js");
+var Route$28 = createFileRoute("/")({ component: lazyRouteComponent($$splitComponentImporter, "component") });
 var ManagedAttachmentValidationError = class extends Error {
   status;
   constructor(message, status) {
@@ -5859,14 +7554,14 @@ function contentToChatParts(content) {
   }
   return parts;
 }
-function isRecord(value) {
+function isRecord$1(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var PRIVATE_PAYLOAD_KEY = /(?:api[_-]?key|access[_-]?token|refresh[_-]?token|password|secret|authorization|sessionDir|fullOutputPath|harnessStatePath)/i;
 function browserSafePayload(value, key) {
   if (key && PRIVATE_PAYLOAD_KEY.test(key)) return "[redacted]";
   if (Array.isArray(value)) return value.map((item) => browserSafePayload(item));
-  if (isRecord(value)) return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, browserSafePayload(entryValue, entryKey)]));
+  if (isRecord$1(value)) return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, browserSafePayload(entryValue, entryKey)]));
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) return value;
 }
 function stringifyPayload(value) {
@@ -6550,7 +8245,7 @@ function reasoningFrame(state, phase, streaming) {
   };
 }
 function sentAgentMessageId(value) {
-  const record2 = isRecord(value) ? value : void 0;
+  const record2 = isRecord$1(value) ? value : void 0;
   return typeof record2?.id === "string" ? record2.id : void 0;
 }
 function rememberSentAgentMessage(state, toolCallId, message) {
@@ -6565,8 +8260,8 @@ function withSentAgentMessages(state, toolCallId, value) {
   if (!toolCallId) return value;
   const sentAgentMessages = state.currentToolSentAgentMessages[toolCallId];
   if (!sentAgentMessages || sentAgentMessages.length === 0) return value;
-  const base = isRecord(value) ? value : {};
-  const details = isRecord(base.details) ? base.details : {};
+  const base = isRecord$1(value) ? value : {};
+  const details = isRecord$1(base.details) ? base.details : {};
   return {
     ...base,
     details: {
@@ -9060,14 +10755,14 @@ var PrimeBridge = class {
     return session;
   }
 };
-var globalStore = globalThis;
+var globalStore$2 = globalThis;
 function getBridge() {
-  if (!globalStore.__primeBridge) globalStore.__primeBridge = new PrimeBridge({
+  if (!globalStore$2.__primeBridge) globalStore$2.__primeBridge = new PrimeBridge({
     kernelTimeoutMs: 3e4,
     ringBufferCapacity: 500,
     dialogTimeoutMs: 6e4
   });
-  return globalStore.__primeBridge;
+  return globalStore$2.__primeBridge;
 }
 function isLoopbackHostname(hostname) {
   const host = hostname.toLowerCase().replace(/\.$/, "");
@@ -9808,6 +11503,386 @@ function handleChatCommandsGet(request) {
     });
   }, request);
 }
+function normalizeCompletionText(text) {
+  return normalizeCompletionDraft(text);
+}
+function longestCommonPrefix(values) {
+  const first = values[0];
+  if (first === void 0) return "";
+  let prefix = first;
+  for (let index = 1; index < values.length; index += 1) {
+    const value = values[index] ?? "";
+    const limit = Math.min(prefix.length, value.length);
+    let shared = 0;
+    while (shared < limit && prefix[shared]?.toLowerCase() === value[shared]?.toLowerCase()) shared += 1;
+    prefix = prefix.slice(0, shared);
+    if (prefix.length === 0) break;
+  }
+  return prefix;
+}
+function sessionIdFromFile(sessionFile) {
+  return (sessionFile.split(/[/\\]/).pop() ?? "").replace(/\.jsonl$/i, "");
+}
+function isFromSession(candidate, sessionId) {
+  if (!sessionId) return false;
+  if (candidate.sessionId) return candidate.sessionId === sessionId;
+  if (!candidate.sessionFile) return false;
+  return sessionIdFromFile(candidate.sessionFile) === sessionId;
+}
+function findCompletion(draft, candidates, options = {}) {
+  const minChars = options.minChars ?? 4;
+  const maxChars = options.maxChars ?? 200;
+  const normalizedDraft = normalizeCompletionText(draft);
+  if (normalizedDraft.length < minChars) return void 0;
+  const needle = normalizedDraft.toLowerCase();
+  const matched = [];
+  for (const candidate of candidates) {
+    const text = normalizeCompletionText(candidate.text);
+    if (text.length <= normalizedDraft.length) continue;
+    if (text.length > maxChars) continue;
+    if (!text.toLowerCase().startsWith(needle)) continue;
+    matched.push({
+      candidate,
+      text
+    });
+  }
+  if (matched.length === 0) return void 0;
+  const sessionMatches = matched.filter((entry) => isFromSession(entry.candidate, options.sessionId));
+  const tier = sessionMatches.length > 0 ? sessionMatches : matched;
+  const source = sessionMatches.length > 0 ? "session" : "corpus";
+  const ranked = [...tier].sort((a, b) => b.candidate.at - a.candidate.at || b.text.length - a.text.length);
+  const best = ranked[0];
+  if (!best) return void 0;
+  const bestRemainder = best.text.slice(normalizedDraft.length);
+  const remainders = [bestRemainder, ...ranked.filter((entry) => entry !== best).map((entry) => entry.text.slice(normalizedDraft.length))];
+  const agreed = longestCommonPrefix(remainders);
+  if (agreed.length === 0) return void 0;
+  const shortestRemainder = Math.min(...remainders.map((remainder) => remainder.length));
+  const agreement = shortestRemainder === 0 ? 0 : agreed.length / shortestRemainder;
+  const confidence = Math.min(1, agreement);
+  if (confidence < (options.floor ?? 0.5)) return void 0;
+  const extendConfidence = options.extendConfidence ?? 0.8;
+  return {
+    completion: normalizedDraft + (source === "corpus" ? agreed : confidence >= extendConfidence ? bestRemainder : agreed),
+    confidence,
+    source,
+    candidateCount: ranked.length
+  };
+}
+function harvestPromptCandidates(messages, at, maxChars = 200) {
+  const out = [];
+  for (const message of messages) {
+    if (message.role !== "user") continue;
+    const text = normalizeCompletionText(message.text);
+    if (text.length < 8 || text.length > maxChars) continue;
+    if (text.startsWith("<") || text.startsWith("[harness") || text.includes("<harness_state>")) continue;
+    out.push({
+      text,
+      at
+    });
+  }
+  return out;
+}
+var INDEX_READY_TIMEOUT_MS = 250;
+function createComposerCompletionService(options) {
+  return { async complete(draft, sessionId) {
+    if (composerCompletionIgnores(draft)) return {};
+    await Promise.race([options.index.ready(), new Promise((resolve2) => setTimeout(resolve2, INDEX_READY_TIMEOUT_MS))]);
+    const suggestion = findCompletion(draft, options.index.candidates(), { sessionId });
+    if (!suggestion) return {};
+    return {
+      completion: suggestion.completion,
+      confidence: suggestion.confidence,
+      source: suggestion.source
+    };
+  } };
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function timestampValue(value) {
+  if (value instanceof Date) return value.toISOString();
+  return stringValue(value);
+}
+function messageCountValue(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
+}
+function normalizeSessionListRow(source) {
+  const raw = source;
+  const sessionId = stringValue(raw.sessionId) ?? stringValue(raw.id);
+  const cwd = stringValue(raw.cwd);
+  if (!sessionId || !cwd) throw new Error("The Prime Agent session listing returned an invalid session entry");
+  const createdAt = timestampValue(raw.created) ?? timestampValue(raw.modified) ?? (/* @__PURE__ */ new Date()).toISOString();
+  const updatedAt = timestampValue(raw.modified) ?? timestampValue(raw.created) ?? createdAt;
+  const isSubagent2 = typeof raw.runtimeKind === "string" ? raw.runtimeKind === "subagent" : Boolean(raw.rlmChildId ?? raw.rlmParentNodeId ?? raw.parentActiveSessionId ?? raw.parentSessionId ?? raw.parentSessionPath);
+  return {
+    source,
+    sessionId,
+    cwd,
+    title: meaningfulSessionLabel(stringValue(raw.sessionName) ?? stringValue(raw.name)),
+    createdAt,
+    updatedAt,
+    messageCount: messageCountValue(raw.messageCount),
+    firstMessage: meaningfulSessionLabel(typeof raw.firstMessage === "string" ? raw.firstMessage : void 0) ?? "",
+    isSubagent: isSubagent2
+  };
+}
+function sessionSourcePath(source) {
+  const raw = source;
+  return stringValue(raw.sessionFile) ?? stringValue(raw.path);
+}
+function latestBy(entries, time2) {
+  if (entries.length === 0) return void 0;
+  return entries.reduce((latest, entry) => time2(entry) >= time2(latest) ? entry : latest);
+}
+function presentationListActivity(presentation) {
+  if (!presentation) return { activityCount: 0 };
+  const artifacts = presentation.artifactRuns.flatMap((run) => run.artifacts);
+  const latestRefinement = latestBy(presentation.refinements, (entry) => entry.timestamp);
+  const latestArtifact = latestBy(artifacts, (entry) => entry.timestamp);
+  const latestBash = latestBy(presentation.userBash, (entry) => entry.startedAt);
+  return {
+    title: meaningfulSessionLabel(presentation.sessionName) ?? meaningfulSessionLabel(latestRefinement?.summary) ?? meaningfulSessionLabel(latestArtifact?.title) ?? meaningfulSessionLabel(latestBash?.command),
+    activityCount: presentation.refinements.length + artifacts.length + presentation.userBash.length
+  };
+}
+function applyPresentationToSessionRow(row, presentation) {
+  const { title: presentationTitle, activityCount } = presentationListActivity(presentation);
+  const firstMessage = row.firstMessage || presentationTitle || "";
+  return {
+    title: row.title ?? meaningfulSessionLabel(firstMessage) ?? presentationTitle ?? fallbackSessionLabel(row.sessionId),
+    firstMessage,
+    messageCount: row.messageCount > 0 ? row.messageCount : activityCount > 0 ? 1 : 0
+  };
+}
+function sessionNeedsPresentationJoin(row) {
+  return row.messageCount === 0 || !row.title || !row.firstMessage;
+}
+async function loadSessionListPresentation(row, source, livePresentation) {
+  const liveActivity = presentationListActivity(livePresentation);
+  if (liveActivity.activityCount > 0 || liveActivity.title) return livePresentation;
+  if (!sessionNeedsPresentationJoin(row)) return livePresentation;
+  const path = sessionSourcePath(source);
+  if (!path) return livePresentation;
+  return await loadManagedPrimePresentation({ sessionPath: path }) ?? livePresentation;
+}
+var PROMPT_INDEX_MAX_SESSION_ENTRIES = 1e4;
+var PROMPT_INDEX_CANDIDATE_LIMIT = 2e3;
+var PROMPT_INDEX_RETRY_BACKOFF_MS = 6e4;
+var PROMPT_INDEX_FILE = "fleet-prompt-index.json";
+function promptIndexPath(agentDir) {
+  return join(agentDir, PROMPT_INDEX_FILE);
+}
+function isSubagent(session) {
+  return session.isSubagent === true;
+}
+function sessionRecency(session) {
+  const raw = session.modified;
+  const parsed = raw ? Date.parse(raw) : NaN;
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+async function readPersisted(agentDir) {
+  try {
+    const raw = JSON.parse(await readFile(promptIndexPath(agentDir), "utf8"));
+    if (raw.version !== 1 || !Array.isArray(raw.sessions)) return void 0;
+    const sessions2 = raw.sessions.filter((entry) => typeof entry?.sessionFile === "string" && typeof entry.modified === "string" && Array.isArray(entry.prompts) && entry.prompts.every((prompt) => typeof prompt === "string"));
+    const emptyStreak = typeof raw.emptyStreak === "number" && raw.emptyStreak > 0 ? raw.emptyStreak : 0;
+    return {
+      version: 1,
+      builtAt: typeof raw.builtAt === "string" ? raw.builtAt : "",
+      emptyStreak,
+      sessions: sessions2
+    };
+  } catch {
+    return;
+  }
+}
+async function writePersisted(agentDir, index) {
+  const path = promptIndexPath(agentDir);
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(index)}
+`, "utf8");
+  await rename(temporary, path);
+}
+function flattenPromptIndex(index, limit) {
+  const out = [];
+  for (const session of index.sessions) {
+    const base = Date.parse(session.modified);
+    const at = Number.isFinite(base) ? base : 0;
+    const sessionId = sessionIdFromFile(session.sessionFile);
+    session.prompts.forEach((text, offset) => {
+      out.push({
+        text,
+        at: at + Math.min(offset, 999) / 1e3,
+        sessionFile: session.sessionFile,
+        sessionId
+      });
+    });
+  }
+  out.sort((a, b) => b.at - a.at);
+  return out.slice(0, limit);
+}
+function createPromptIndex(options) {
+  const limit = options.sessionLimit ?? 2e3;
+  const now2 = options.now ?? Date.now;
+  const log = options.log ?? (() => {
+  });
+  let persisted;
+  let loading;
+  let building;
+  let retryAfter = 0;
+  let flattened;
+  const load = () => {
+    loading ??= (async () => {
+      persisted = await readPersisted(options.agentDir);
+      flattened = void 0;
+    })();
+    return loading;
+  };
+  load();
+  const build = async () => {
+    await load();
+    const previous = new Map((persisted?.sessions ?? []).map((entry) => [entry.sessionFile, entry]));
+    let sessions2;
+    try {
+      sessions2 = await options.listSessions();
+    } catch (error) {
+      log(`prompt index: session listing failed (${error instanceof Error ? error.name : "unknown"})`);
+      return false;
+    }
+    const scoped = sessions2.filter((session) => !isSubagent(session)).filter((session) => typeof session.sessionFile === "string" && session.sessionFile.length > 0).sort((a, b) => sessionRecency(b) - sessionRecency(a)).slice(0, limit);
+    const next = [];
+    for (const session of scoped) {
+      const modified = session.modified ?? "";
+      const cached = previous.get(session.sessionFile);
+      if (cached && cached.modified === modified) {
+        next.push(cached);
+        continue;
+      }
+      try {
+        const messages = await options.openSession(session.sessionFile);
+        if (messages.length > 1e4) {
+          if (cached) next.push(cached);
+          else log(`prompt index: skipped ${session.sessionFile} (${messages.length} entries > ${PROMPT_INDEX_MAX_SESSION_ENTRIES})`);
+          continue;
+        }
+        next.push({
+          sessionFile: session.sessionFile,
+          modified,
+          prompts: harvestPromptCandidates(messages, 0).map((candidate) => candidate.text)
+        });
+      } catch {
+        if (cached) next.push(cached);
+      }
+    }
+    const harvest = next.reduce((total, entry) => total + entry.prompts.length, 0);
+    const hadCorpus = (persisted?.sessions.length ?? 0) > 0;
+    const emptyStreak = (persisted?.emptyStreak ?? 0) + 1;
+    if (harvest === 0 && hadCorpus && emptyStreak < 2) {
+      persisted = {
+        ...persisted,
+        emptyStreak
+      };
+      try {
+        await writePersisted(options.agentDir, persisted);
+      } catch {
+      }
+      log("prompt index: rebuild produced no prompts; keeping the previous corpus");
+      return false;
+    }
+    if (harvest === 0 && hadCorpus) log("prompt index: store confirmed empty; clearing the corpus");
+    persisted = {
+      version: 1,
+      builtAt: new Date(now2()).toISOString(),
+      emptyStreak: 0,
+      sessions: next
+    };
+    flattened = void 0;
+    try {
+      await writePersisted(options.agentDir, persisted);
+    } catch (error) {
+      log(`prompt index: persist failed (${error instanceof Error ? error.name : "unknown"})`);
+    }
+    return true;
+  };
+  const ensureFresh = () => {
+    if (building) return;
+    if (now2() < retryAfter) return;
+    building = (async () => {
+      await load();
+      const builtAt = persisted ? Date.parse(persisted.builtAt) : NaN;
+      if (Number.isFinite(builtAt) && now2() - builtAt <= 6e5) return;
+      retryAfter = await build() ? 0 : now2() + PROMPT_INDEX_RETRY_BACKOFF_MS;
+    })().catch(() => {
+      retryAfter = now2() + PROMPT_INDEX_RETRY_BACKOFF_MS;
+    }).finally(() => {
+      building = void 0;
+    });
+  };
+  return {
+    ready: () => load(),
+    candidates() {
+      ensureFresh();
+      if (!persisted) return [];
+      flattened ??= flattenPromptIndex(persisted, PROMPT_INDEX_CANDIDATE_LIMIT);
+      return flattened;
+    },
+    async refresh() {
+      await (building ?? build().then(() => void 0));
+    },
+    stats() {
+      const builtAt = persisted ? Date.parse(persisted.builtAt) : NaN;
+      return {
+        sessions: persisted?.sessions.length ?? 0,
+        prompts: persisted?.sessions.reduce((total, entry) => total + entry.prompts.length, 0) ?? 0,
+        builtAt: Number.isFinite(builtAt) ? builtAt : 0
+      };
+    }
+  };
+}
+var globalStore$1 = globalThis;
+function messageText(message) {
+  if (typeof message !== "object" || message === null) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((part) => {
+    if (typeof part !== "object" || part === null) return false;
+    const candidate = part;
+    return candidate.type === "text" && typeof candidate.text === "string";
+  }).map((part) => part.text).join(" ");
+}
+var openSessionWithRuntime = async (sessionFile) => {
+  return (await SessionManager.openAsync(sessionFile)).getEntries().filter((entry) => entry.type === "message").map((entry) => ({
+    role: entry.message.role,
+    text: messageText(entry.message)
+  }));
+};
+function getPromptIndex() {
+  if (!globalStore$1.__fleetPromptIndex) globalStore$1.__fleetPromptIndex = createPromptIndex({
+    agentDir: getPrimeConfig().agentDir,
+    listSessions: async () => (await getBridge().listSessions()).map((summary) => {
+      const row = normalizeSessionListRow(summary);
+      return {
+        sessionFile: sessionSourcePath(row.source),
+        modified: row.updatedAt,
+        isSubagent: row.isSubagent
+      };
+    }),
+    openSession: openSessionWithRuntime,
+    log: (message) => process.stderr.write(`[completion] ${message}
+`)
+  });
+  return globalStore$1.__fleetPromptIndex;
+}
+function handleChatCompletionPost(request) {
+  return wrapApiHandler(async () => {
+    const body = ComposerCompletionRequestSchema.parse(await request.json().catch(() => ({})));
+    const service = createComposerCompletionService({ index: getPromptIndex() });
+    return Response.json(await service.complete(body.text, body.sessionId));
+  }, request);
+}
 function shouldReplaySseEvent(event, pendingQuestionIds) {
   if (!pendingQuestionIds) return true;
   if (!event || typeof event !== "object") return true;
@@ -9986,6 +12061,481 @@ function handleChatEventsGet(request) {
     return createSseResponse(request, getBridge(), { sessionId: sessionId.data }, lastEventIdFor(request, url));
   }, request);
 }
+var DEFAULT_FLEET_SETTINGS = {
+  version: 1,
+  composerIntentEnabled: false
+};
+var FLEET_SETTINGS_FILE = "fleet-settings.json";
+function fleetSettingsPath(agentDir) {
+  return join(agentDir, FLEET_SETTINGS_FILE);
+}
+async function readFleetSettings(agentDir) {
+  try {
+    return {
+      version: 1,
+      composerIntentEnabled: JSON.parse(await readFile(fleetSettingsPath(agentDir), "utf8")).composerIntentEnabled === true
+    };
+  } catch {
+    return { ...DEFAULT_FLEET_SETTINGS };
+  }
+}
+var writeChain = Promise.resolve();
+async function updateFleetSettings(agentDir, patch) {
+  const update = writeChain.then(() => writeFleetSettings(agentDir, patch));
+  writeChain = update.catch(() => void 0);
+  return update;
+}
+async function writeFleetSettings(agentDir, patch) {
+  const current = await readFleetSettings(agentDir);
+  const next = {
+    version: 1,
+    composerIntentEnabled: patch.composerIntentEnabled ?? current.composerIntentEnabled
+  };
+  const path = fleetSettingsPath(agentDir);
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(next, null, "	")}
+`, "utf8");
+  await rename(temporary, path);
+  return next;
+}
+var TYPESAFE_CREDENTIAL_ID = "typesafe";
+function readCredential() {
+  try {
+    const credential = getPrimeConfig().authStorage.get(TYPESAFE_CREDENTIAL_ID);
+    return credential?.type === "api_key" ? credential : void 0;
+  } catch {
+    return;
+  }
+}
+function readStoredTypeSafeKey() {
+  const key = readCredential()?.key?.trim();
+  return key ? key : void 0;
+}
+function writeStoredTypeSafeKey(key) {
+  const trimmed = key.trim();
+  if (!trimmed) throw new Error("A TypeSafe API key cannot be empty");
+  const config = getPrimeConfig();
+  config.authStorage.set(TYPESAFE_CREDENTIAL_ID, {
+    type: "api_key",
+    key: trimmed
+  });
+  config.reloadAuth();
+}
+function clearStoredTypeSafeKey() {
+  const config = getPrimeConfig();
+  if (config.authStorage.has("typesafe")) config.authStorage.remove(TYPESAFE_CREDENTIAL_ID);
+  config.reloadAuth();
+}
+function typeSafeKeySource() {
+  if (readStoredTypeSafeKey()) return "settings";
+  if ((process.env.TYPESAFE_API_KEY ?? "").trim()) return "environment";
+  return "none";
+}
+var DEFAULT_TYPESAFE_INTENT_TIMEOUT_MS = 1500;
+var LOG_LEVELS = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "off"
+];
+function positiveInt(value, fallback) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function nonNegativeInt(value, fallback) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function isCredentialSafeBaseUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  if (url.protocol === "https:") return true;
+  if (url.protocol !== "http:") return false;
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+function isLogLevel(value) {
+  return value !== void 0 && LOG_LEVELS.includes(value);
+}
+function readTypeSafeConfig(env = process.env, storedKey) {
+  const apiKey = (storedKey ?? "").trim() || (env.TYPESAFE_API_KEY ?? "").trim() || void 0;
+  const killed = (env.FLEET_TYPESAFE_ENABLED ?? "").trim() === "0";
+  const requestedBaseUrl = (env.TYPESAFE_BASE_URL ?? "").trim().replace(/\/+$/, "");
+  const baseUrlUsable = requestedBaseUrl === "" || isCredentialSafeBaseUrl(requestedBaseUrl);
+  return {
+    configured: Boolean(apiKey) && !killed && baseUrlUsable,
+    apiKey,
+    baseUrl: requestedBaseUrl || "https://api.typesafe.ai",
+    model: (env.TYPESAFE_MODEL ?? "").trim() || "jev-latest",
+    intentTimeoutMs: positiveInt(env.TYPESAFE_INTENT_TIMEOUT_MS, DEFAULT_TYPESAFE_INTENT_TIMEOUT_MS),
+    intentMaxRetries: nonNegativeInt(env.TYPESAFE_INTENT_MAX_RETRIES, 1),
+    logLevel: isLogLevel(env.TYPESAFE_LOG_LEVEL) ? env.TYPESAFE_LOG_LEVEL : "warn"
+  };
+}
+var TypeSafeTransportError = class extends Error {
+  kind;
+  status;
+  constructor(message, kind, status, options) {
+    super(message, options);
+    this.name = "TypeSafeTransportError";
+    this.kind = kind;
+    this.status = status;
+  }
+};
+var TYPESAFE_RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
+  408,
+  429,
+  500,
+  502,
+  503,
+  504,
+  529
+]);
+var NO_RETRY_STATUSES = /* @__PURE__ */ new Set();
+var RETRY_MAX_DELAY_MS = 5e3;
+function retryDelayMs(response, attempt) {
+  const header = response.headers.get("retry-after")?.trim();
+  if (header) {
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, RETRY_MAX_DELAY_MS);
+    const date = Date.parse(header);
+    if (Number.isFinite(date)) return Math.min(Math.max(date - Date.now(), 0), RETRY_MAX_DELAY_MS);
+  }
+  const exponential = Math.min(250 * 2 ** attempt, RETRY_MAX_DELAY_MS);
+  return Math.round(exponential * (0.5 + Math.random() / 2));
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function noul(instructions, criteria) {
+  return criteria ? {
+    type: "noul",
+    instructions,
+    criteria
+  } : {
+    type: "noul",
+    instructions
+  };
+}
+function choice(instructions, criteria) {
+  return {
+    type: "choice",
+    instructions,
+    criteria
+  };
+}
+function choiceAnswer(result, id2) {
+  const answer = result.answers[id2];
+  return answer?.type === "choice" ? answer : void 0;
+}
+function noulAnswer(result, id2) {
+  const answer = result.answers[id2];
+  return answer?.type === "noul" ? answer : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function postSystemOne(config, body, options = {}, fetchImpl = globalThis.fetch) {
+  if (!config.configured || !config.apiKey) throw new TypeSafeTransportError("TypeSafe is not configured", "unconfigured");
+  const apiKey = config.apiKey;
+  const timeoutMs = options.timeoutMs ?? config.intentTimeoutMs;
+  const maxRetries = options.maxRetries ?? 0;
+  const retryStatuses = options.retryStatuses ?? NO_RETRY_STATUSES;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+    try {
+      const response = await fetchImpl(`${config.baseUrl}/v1/systemone`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          state: body.state,
+          model: config.model,
+          questions: body.questions
+        }),
+        signal
+      });
+      if (!response.ok) {
+        await response.text().catch(() => "");
+        const error = new TypeSafeTransportError(`TypeSafe request failed with HTTP ${response.status}`, "http", response.status);
+        if (attempt < maxRetries && retryStatuses.has(response.status)) {
+          lastError = error;
+          await sleep(retryDelayMs(response, attempt));
+          continue;
+        }
+        throw error;
+      }
+      const parsed = await response.json().catch(() => void 0);
+      if (!isRecord(parsed) || !isRecord(parsed.answers)) throw new TypeSafeTransportError("TypeSafe returned an unreadable body", "malformed");
+      const usage = isRecord(parsed.usage) ? parsed.usage : {};
+      return {
+        model: typeof parsed.model === "string" ? parsed.model : config.model,
+        answers: parsed.answers,
+        usage: {
+          input_tokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
+          output_tokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0
+        }
+      };
+    } catch (error) {
+      if (error instanceof TypeSafeTransportError) throw error;
+      const kind = timeoutSignal.aborted ? "timeout" : options.signal?.aborted ? "aborted" : "http";
+      lastError = new TypeSafeTransportError(kind === "timeout" ? `TypeSafe request exceeded ${timeoutMs}ms` : "TypeSafe request failed", kind, void 0, { cause: error });
+      if (attempt >= maxRetries) throw lastError;
+    }
+  }
+  throw lastError ?? new TypeSafeTransportError("TypeSafe request failed", "http");
+}
+async function probeConnection(config, fetchImpl = globalThis.fetch, timeoutMs = 3e3) {
+  if (!config.configured || !config.apiKey) return false;
+  try {
+    const response = await fetchImpl(`${config.baseUrl}/v1/models`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${config.apiKey}` },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    await response.text().catch(() => "");
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+var INTENT_ROUTE_QUESTION_ID = "route";
+var INTENT_CODE_TASK_QUESTION_ID = "is_code_task";
+var MAX_INTENT_STATE_CHARS = 1e3;
+var ROUTE_INSTRUCTIONS = [
+  "`utterance` is free text a developer typed into the message composer of a coding-agent chat app.",
+  "`commands` lists the app's built-in commands, each with an `id`, a `what` description, and optional `args`.",
+  "",
+  "Decide whether the developer is asking the app to RUN one of those commands, or whether the text is an ordinary request for the coding agent.",
+  "",
+  "Rules:",
+  "- Every command in `commands` only changes the app's own interface or the conversation session. None of them read, write, edit, run, or inspect code, files, tests, dependencies, or git.",
+  "- If `utterance` asks for any work on code, files, tests, builds, dependencies, git, or the workspace, answer `none` \u2014 even when it also contains a word that appears in a command description.",
+  "- Answer `none` when no command clearly matches what the developer wants, and when you are unsure.",
+  "- Match the developer's intent, not a word the text happens to share with a description."
+].join("\n");
+var CODE_TASK_INSTRUCTIONS = [
+  "Does `utterance` ask for real engineering work on code, files, tests, builds, dependencies, git, or the workspace?",
+  "Bug reports, feature requests, questions about the codebase, and refactors all count as yes.",
+  "Requests about the app's own interface, the session, or the conversation do not count, even when they mention code:",
+  "setting a goal, compacting the session, renaming a session, or changing how much reasoning the model uses are all no."
+].join("\n");
+var CODE_TASK_CRITERIA = {
+  true: "The developer wants engineering work done on code, files, tests, builds, dependencies, git, or the workspace.",
+  false: "The developer wants the app's own interface or session acted on, or is making conversation."
+};
+function buildIntentState(text) {
+  return {
+    utterance: text.slice(0, MAX_INTENT_STATE_CHARS),
+    commands: COMPOSER_INTENT_COMMANDS.map((command) => ({
+      id: command.id,
+      what: command.description,
+      ...command.argumentHint ? { args: command.argumentHint } : {}
+    }))
+  };
+}
+function buildIntentQuestions() {
+  const criteria = { [COMPOSER_INTENT_NONE]: "The text should be sent to the coding agent as an ordinary message." };
+  for (const command of COMPOSER_INTENT_COMMANDS) criteria[command.id] = command.argumentHint ? `${command.description}. Arguments the developer may name: ${command.argumentHint}.` : command.description;
+  const route = choice(ROUTE_INSTRUCTIONS, criteria);
+  const codeTask = noul(CODE_TASK_INSTRUCTIONS, CODE_TASK_CRITERIA);
+  return {
+    [INTENT_ROUTE_QUESTION_ID]: route,
+    [INTENT_CODE_TASK_QUESTION_ID]: codeTask
+  };
+}
+function interpretIntentResult(result, draft) {
+  const route = choiceAnswer(result, INTENT_ROUTE_QUESTION_ID);
+  const codeTask = noulAnswer(result, INTENT_CODE_TASK_QUESTION_ID);
+  if (!route) return {
+    outcome: "none",
+    reason: "no_match"
+  };
+  const confidence = typeof route.confidence === "number" ? route.confidence : 0;
+  const codeTaskProbability = codeTask && typeof codeTask.noul === "number" ? codeTask.noul : 0;
+  const decision = decideComposerIntent({
+    command: route.choice,
+    confidence,
+    codeTaskProbability,
+    requireConfirmation: isSingleTokenDraft(draft) || draft.trim().length > 1e3
+  });
+  if (decision.outcome === "none") return decision;
+  if (!composerIntentCommand(decision.command.id)) return {
+    outcome: "none",
+    reason: "no_match"
+  };
+  return {
+    ...decision,
+    confidence,
+    codeTaskProbability
+  };
+}
+var CACHE_LIMIT = 48;
+var CACHE_TTL_MS = 3e5;
+var MIN_INTENT_CHARS = 4;
+var PROBE_TTL_MS = 3e5;
+function normalizeIntentText(text) {
+  return text.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function disabledResponse(enabled, reason) {
+  return {
+    enabled,
+    outcome: "none",
+    ...reason ? { reason } : {}
+  };
+}
+function createTypeSafeService(options = {}) {
+  const config = options.config ?? readTypeSafeConfig();
+  const fetchImpl = options.fetch ?? ((...args) => globalThis.fetch(...args));
+  const now2 = options.now ?? Date.now;
+  const cache = /* @__PURE__ */ new Map();
+  let probe;
+  function readCache(key) {
+    const entry = cache.get(key);
+    if (!entry) return void 0;
+    if (now2() - entry.at > CACHE_TTL_MS) {
+      cache.delete(key);
+      return;
+    }
+    return entry.response;
+  }
+  function writeCache(key, response) {
+    cache.set(key, {
+      response,
+      at: now2()
+    });
+    while (cache.size > CACHE_LIMIT) {
+      const oldest = cache.keys().next();
+      if (oldest.done) break;
+      cache.delete(oldest.value);
+    }
+  }
+  return {
+    configured: config.configured,
+    model: config.model,
+    async status() {
+      if (!config.configured) return "unconfigured";
+      if (probe && now2() - probe.at <= PROBE_TTL_MS) return probe.ok ? "ready" : "error";
+      const ok = await probeConnection(config, fetchImpl);
+      probe = {
+        at: now2(),
+        ok
+      };
+      return ok ? "ready" : "error";
+    },
+    async routeComposerIntent(request, enabled) {
+      if (!enabled) return disabledResponse(false, "disabled");
+      if (!config.configured) return disabledResponse(false, "disabled");
+      const text = request.text.trim();
+      if (text.length < MIN_INTENT_CHARS) return disabledResponse(true, "empty");
+      if (text.startsWith("/")) return disabledResponse(true, "empty");
+      const key = normalizeIntentText(text);
+      const cached = readCache(key);
+      if (cached) return cached;
+      const startedAt = now2();
+      try {
+        const result = await postSystemOne(config, {
+          state: buildIntentState(text),
+          questions: buildIntentQuestions()
+        }, {
+          timeoutMs: config.intentTimeoutMs,
+          maxRetries: config.intentMaxRetries,
+          retryStatuses: TYPESAFE_RETRYABLE_STATUSES
+        }, fetchImpl);
+        const decision = interpretIntentResult(result, text);
+        const response = decision.outcome === "matched" ? {
+          enabled: true,
+          outcome: "matched",
+          command: decision.command.id,
+          confidence: decision.confidence,
+          disposition: decision.disposition,
+          model: result.model,
+          latencyMs: now2() - startedAt
+        } : {
+          enabled: true,
+          outcome: "none",
+          reason: decision.reason,
+          confidence: decision.confidence,
+          model: result.model,
+          latencyMs: now2() - startedAt
+        };
+        writeCache(key, response);
+        return response;
+      } catch (error) {
+        const rateLimited = error instanceof TypeSafeTransportError && error.status === 429;
+        if (config.logLevel !== "off") {
+          const kind = error instanceof TypeSafeTransportError ? error.kind : "unknown";
+          process.stderr.write(`[typesafe] intent routing unavailable (${kind})
+`);
+        }
+        return disabledResponse(true, rateLimited ? "rate_limited" : "unavailable");
+      }
+    },
+    resetCachesForTests() {
+      cache.clear();
+      probe = void 0;
+    }
+  };
+}
+var globalStore = globalThis;
+function getTypeSafeService() {
+  if (!globalStore.__fleetTypeSafe) globalStore.__fleetTypeSafe = createTypeSafeService({ config: readTypeSafeConfig(process.env, readStoredTypeSafeKey()) });
+  return globalStore.__fleetTypeSafe;
+}
+function resetTypeSafeService() {
+  globalStore.__fleetTypeSafe = void 0;
+}
+async function composerIntentSettings() {
+  const service = getTypeSafeService();
+  return {
+    enabled: (await readFleetSettings(getPrimeConfig().agentDir)).composerIntentEnabled,
+    status: service.configured ? await service.status() : "unconfigured",
+    keySource: typeSafeKeySource()
+  };
+}
+function handleChatIntentGet(request) {
+  return wrapApiHandler(async () => Response.json(await composerIntentSettings()), request);
+}
+function handleChatIntentPut(request) {
+  return wrapApiHandler(async () => {
+    const body = ComposerIntentCredentialSchema.parse(await request.json().catch(() => ({})));
+    if (body.apiKey === null) clearStoredTypeSafeKey();
+    else writeStoredTypeSafeKey(body.apiKey);
+    resetTypeSafeService();
+    return Response.json(await composerIntentSettings());
+  }, request);
+}
+function handleChatIntentPatch(request) {
+  return wrapApiHandler(async () => {
+    const body = ComposerIntentSettingsUpdateSchema.parse(await request.json().catch(() => ({})));
+    await updateFleetSettings(getPrimeConfig().agentDir, { composerIntentEnabled: body.enabled });
+    return Response.json(await composerIntentSettings());
+  }, request);
+}
+function handleChatIntentPost(request) {
+  return wrapApiHandler(async () => {
+    const body = ComposerIntentRequestSchema.parse(await request.json().catch(() => ({})));
+    const service = getTypeSafeService();
+    if (!service.configured) return Response.json({
+      enabled: false,
+      outcome: "none",
+      reason: "disabled"
+    });
+    const settings = await readFleetSettings(getPrimeConfig().agentDir);
+    const response = await service.routeComposerIntent(body, settings.composerIntentEnabled);
+    return Response.json(response);
+  }, request);
+}
 var PRIME_BUTTERFLY_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 178 178" aria-hidden="true"><path fill="currentColor" d="m 123.322,84.092671 c -0.192,0.0065 -0.43,0.0147 -0.74,0.0147 l -0.018,-0.0247 c -0.873,0.1977 -1.958,0.1266 -3.067,0.0537 -3.29,-0.216 -6.799,-0.4465 -5.635,6.2824 0.259,1.4822 -1.538,1.8465 -2.73,1.9082 -3.384,0.1853 -6.78,0.2594 -10.171,0.1915 -0.641,-0.0106 -1.2979,-0.5506 -1.8904,-1.0388 -0.1022,-0.0844 -0.2034,-0.1673 -0.3016,-0.2457 -0.1052,-0.0865 0.2898,-1.2042 0.4942,-1.2166 3.3078,-0.1931 4.5068,-2.4361 5.7028,-4.6724 0.603,-1.1253 1.204,-2.2488 2.072,-3.1088 7.856,-7.7874 15.878,-15.4265 25.054,-21.7008 0.895,-0.6114 1.989,-1.1733 2.73,-0.1111 0.571,0.8205 0.036,1.2854 -0.512,1.7627 -0.24,0.2088 -0.482,0.4199 -0.637,0.6642 -0.554,0.8792 -1.538,1.5273 -2.514,2.1717 -1.92,1.2655 -3.82,2.5172 -2.408,5.4798 1.225,2.5651 0.129,3.0202 -1.555,3.7198 l -0.069,0.0287 c -0.72,0.3021 -1.458,0.5764 -2.194,0.8506 -1.568,0.5835 -3.134,1.1662 -4.537,2.0149 -1.408,0.8522 -2.081,2.5134 0.222,3.4954 5.033,2.1428 18.064,-1.2784 20.608,-5.9965 2.377,-4.4147 5.931,-7.6891 9.481,-10.9611 1.992,-1.836 3.984,-3.6712 5.767,-5.7067 3.844,-4.3849 8.344,-8.1939 12.846,-12.005 2.239,-1.8944 4.478,-3.78938 6.637,-5.75588 1.624,-1.48207 2.297,-3.43353 1.026,-5.56412 -1.267,-2.118215 -3.416,-2.402287 -5.435,-1.926802 -13.309,3.130982 -26.166,7.355122 -37.585,15.241302 -18.23,12.5919 -36.4911,25.1406 -54.9002,37.4669 -6.2743,4.2056 -10.0723,2.1491 -12.1657,-5.1318 -4.6502,-16.1676 -11.4681,-30.2664 -31.0569,-32.4587 -7.1574,-0.8028 -12.4066,3.6807 -11.3692,10.7949 0.5249,3.6065 0.0495,7.003 -1.6858,10.3872 -0.3827,0.7472 -0.7689,1.4947 -1.1556,2.243 -2.672,5.1706 -5.3671,10.3857 -7.0394,15.8885 -0.1399,0.4602 -0.3002,0.9444 -0.4654,1.4437 -1.4909,4.5052 -3.3862,10.2323 5.659,10.5492 0.3705,0.0123 1.0808,0.944799 0.9943,1.290699 -0.1976,0.8213 -0.5991,1.797 -1.2413,2.2725 -8.6705,6.3917 -15.79706,14.1294 -18.860151,24.5971 -1.550066,5.2865 -0.524909,10.7765 3.989391,14.8705 3.22984,2.928 7.35516,4.625 10.97396,2.162 3.3009,-2.247 6.9232,-3.754 10.538,-5.259 3.1819,-1.324 6.358,-2.646 9.3041,-4.468 0.7101,-0.439 1.5727,-0.841 2.4456,-1.248 2.4138,-1.1228 4.9063,-2.2843 4.4709,-4.3841 -0.6854,-3.2908 -4.1623,-6.3418 -7.0586,-8.7384 -2.8716,-2.3769 -10.1897,-18.3411 -9.3189,-22.176099 1.2193,-5.3704 3.9645,-10.0201 6.7125,-14.6744 2.3458,-3.9731 4.6935,-7.9497 6.0956,-12.3806 0.5804,-1.828 2.8037,-2.8284 4.9466,-2.0997 1.4543,0.4928 1.2068,1.8278 0.9762,3.0715 -0.0063,0.0344 -0.0127,0.0685 -0.019,0.1027 -0.8688,4.7802 -1.721,9.566 -2.5733,14.3517 -0.4261,2.3924 -0.8521,4.7847 -1.2803,7.1762 -0.2717,1.5316 0.2038,2.7544 1.7909,3.0631 3.0569,0.599 2.989,1.9762 1.6119,4.341499 -1.4636,2.5072 -1.6674,5.5703 -0.0309,7.8861 1.6427,2.3282 4.3908,2.8161 7.1821,1.4204 1.7415,-0.8646 3.094,-0.0927 3.0755,1.6612 -0.1112,9.3688 3.8103,7.2561 8.584,3.1681 0.439,-0.3763 1.0373,-0.5846 1.6152,-0.7857 0.1048,-0.0366 0.2091,-0.0728 0.3116,-0.1098 0.4529,-0.1616 0.9062,-0.3224 1.3595,-0.4833 8.986,-3.1884 17.9603,-6.3725 23.0334,-15.573099 0.392,-0.7187 1.6783,-1.0669 2.6795,-1.3377 0.057,-0.0154 0.113,-0.0307 0.1681,-0.0456 5.8013,-1.5766 11.7248,-1.6001 17.6438,-1.6237 4.445,-0.0176 8.888,-0.0352 13.277,-0.7107 4.329,-0.667 9.047,-3.1928 9.084,-7.3736 0.035,-3.3707 -2.546,-3.1612 -5.123,-2.9519 -1.115,0.0906 -2.231,0.1811 -3.134,-0.0185 -0.182,-0.0381 -0.375,-0.0316 -0.686,-0.0209 z"/><path fill="currentColor" d="m 55.1325,131.29447 c -1.0745,7.1515 1.6551,13.2715 12.8266,13.1915 h -0.0062 c 9.5413,-0.389 20.3365,-6.164 30.8838,-13.5492 6.9653,-4.8787 12.9873,-10.0236 16.8903,-17.6253 2.872,-5.5889 1.395,-10.0723 -2.933,-13.993799 -1.908,-1.7291 -3.73,-1.9205 -5.867,0.1667 -7.5842,7.423099 -17.0261,11.474299 -26.7218,15.550099 -2.4706,1.0393 -5.2847,1.5582 -8.1187,2.0809 -7.5511,1.3924 -15.2431,2.8103 -16.954,14.1791 z"/></svg>`;
 function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
@@ -39438,75 +41988,6 @@ function handleChatSessionDelete(request) {
     });
   }, request);
 }
-function stringValue(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function timestampValue(value) {
-  if (value instanceof Date) return value.toISOString();
-  return stringValue(value);
-}
-function messageCountValue(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
-}
-function normalizeSessionListRow(source) {
-  const raw = source;
-  const sessionId = stringValue(raw.sessionId) ?? stringValue(raw.id);
-  const cwd = stringValue(raw.cwd);
-  if (!sessionId || !cwd) throw new Error("The Prime Agent session listing returned an invalid session entry");
-  const createdAt = timestampValue(raw.created) ?? timestampValue(raw.modified) ?? (/* @__PURE__ */ new Date()).toISOString();
-  const updatedAt = timestampValue(raw.modified) ?? timestampValue(raw.created) ?? createdAt;
-  const isSubagent = typeof raw.runtimeKind === "string" ? raw.runtimeKind === "subagent" : Boolean(raw.rlmChildId ?? raw.rlmParentNodeId ?? raw.parentActiveSessionId ?? raw.parentSessionId ?? raw.parentSessionPath);
-  return {
-    source,
-    sessionId,
-    cwd,
-    title: meaningfulSessionLabel(stringValue(raw.sessionName) ?? stringValue(raw.name)),
-    createdAt,
-    updatedAt,
-    messageCount: messageCountValue(raw.messageCount),
-    firstMessage: meaningfulSessionLabel(typeof raw.firstMessage === "string" ? raw.firstMessage : void 0) ?? "",
-    isSubagent
-  };
-}
-function sessionSourcePath(source) {
-  const raw = source;
-  return stringValue(raw.sessionFile) ?? stringValue(raw.path);
-}
-function latestBy(entries, time2) {
-  if (entries.length === 0) return void 0;
-  return entries.reduce((latest, entry) => time2(entry) >= time2(latest) ? entry : latest);
-}
-function presentationListActivity(presentation) {
-  if (!presentation) return { activityCount: 0 };
-  const artifacts = presentation.artifactRuns.flatMap((run) => run.artifacts);
-  const latestRefinement = latestBy(presentation.refinements, (entry) => entry.timestamp);
-  const latestArtifact = latestBy(artifacts, (entry) => entry.timestamp);
-  const latestBash = latestBy(presentation.userBash, (entry) => entry.startedAt);
-  return {
-    title: meaningfulSessionLabel(presentation.sessionName) ?? meaningfulSessionLabel(latestRefinement?.summary) ?? meaningfulSessionLabel(latestArtifact?.title) ?? meaningfulSessionLabel(latestBash?.command),
-    activityCount: presentation.refinements.length + artifacts.length + presentation.userBash.length
-  };
-}
-function applyPresentationToSessionRow(row, presentation) {
-  const { title: presentationTitle, activityCount } = presentationListActivity(presentation);
-  const firstMessage = row.firstMessage || presentationTitle || "";
-  return {
-    title: row.title ?? meaningfulSessionLabel(firstMessage) ?? presentationTitle ?? fallbackSessionLabel(row.sessionId),
-    firstMessage,
-    messageCount: row.messageCount > 0 ? row.messageCount : activityCount > 0 ? 1 : 0
-  };
-}
-function sessionNeedsPresentationJoin(row) {
-  return row.messageCount === 0 || !row.title || !row.firstMessage;
-}
-async function loadSessionListPresentation(row, source, livePresentation) {
-  const liveActivity = presentationListActivity(livePresentation);
-  if (liveActivity.activityCount > 0 || liveActivity.title) return livePresentation;
-  if (!sessionNeedsPresentationJoin(row)) return livePresentation;
-  const path = sessionSourcePath(source);
-  if (!path) return livePresentation;
-  return await loadManagedPrimePresentation({ sessionPath: path }) ?? livePresentation;
-}
 function sessionStatus(info, live) {
   if (live?.isStreaming || live?.session?.isStreaming || info.isStreaming) return "running";
   if (info.activity === "working" && (info.isSessionActive || info.hasRunningRlmChildren === true)) return "running";
@@ -39973,19 +42454,26 @@ function handleWorkspaceTreeGet(_request) {
     });
   }, _request);
 }
-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: {
+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: {
   DELETE: ({ request }) => handleProjectDelete(request),
   GET: ({ request }) => handleProjectsGet(request),
   PATCH: ({ request }) => handleProjectPatch(request),
   POST: ({ request }) => handleProjectsPost(request)
 } } });
-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$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/completion")({ server: { handlers: { POST: ({ request }) => handleChatCompletionPost(request) } } });
+var Route$19 = createFileRoute("/api/chat/events")({ server: { handlers: { GET: ({ request }) => handleChatEventsGet(request) } } });
+var Route$18 = createFileRoute("/api/chat/intent")({ server: { handlers: {
+  GET: ({ request }) => handleChatIntentGet(request),
+  PATCH: ({ request }) => handleChatIntentPatch(request),
+  POST: ({ request }) => handleChatIntentPost(request),
+  PUT: ({ request }) => handleChatIntentPut(request)
+} } });
 var Route$17 = createFileRoute("/api/chat/mcp")({ server: { handlers: {
   GET: ({ request }) => handleChatMcpGet(request),
   POST: ({ request }) => handleChatMcpPost(request),
@@ -40027,51 +42515,61 @@ var Route$3 = createFileRoute("/api/workspace/tree")({ server: { handlers: { GET
 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$26.update({
+var IndexRoute = Route$28.update({
   id: "/",
   path: "/",
-  getParentRoute: () => Route$27
+  getParentRoute: () => Route$29
 });
-var ApiChatRoute = Route$25.update({
+var ApiChatRoute = Route$27.update({
   id: "/api/chat",
   path: "/api/chat",
-  getParentRoute: () => Route$27
+  getParentRoute: () => Route$29
 });
-var ApiHealthRoute = Route$24.update({
+var ApiHealthRoute = Route$26.update({
   id: "/api/health",
   path: "/api/health",
-  getParentRoute: () => Route$27
+  getParentRoute: () => Route$29
 });
-var ApiProjectsRoute = Route$23.update({
+var ApiProjectsRoute = Route$25.update({
   id: "/api/projects",
   path: "/api/projects",
-  getParentRoute: () => Route$27
+  getParentRoute: () => Route$29
 });
-var ApiChatAbortRoute = Route$22.update({
+var ApiChatAbortRoute = Route$24.update({
   id: "/abort",
   path: "/abort",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatArtifactsRoute = Route$21.update({
+var ApiChatArtifactsRoute = Route$23.update({
   id: "/artifacts",
   path: "/artifacts",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatCommandRoute = Route$20.update({
+var ApiChatCommandRoute = Route$22.update({
   id: "/command",
   path: "/command",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatCommandsRoute = Route$19.update({
+var ApiChatCommandsRoute = Route$21.update({
   id: "/commands",
   path: "/commands",
   getParentRoute: () => ApiChatRoute
 });
-var ApiChatEventsRoute = Route$18.update({
+var ApiChatCompletionRoute = Route$20.update({
+  id: "/completion",
+  path: "/completion",
+  getParentRoute: () => ApiChatRoute
+});
+var ApiChatEventsRoute = Route$19.update({
   id: "/events",
   path: "/events",
   getParentRoute: () => ApiChatRoute
 });
+var ApiChatIntentRoute = Route$18.update({
+  id: "/intent",
+  path: "/intent",
+  getParentRoute: () => ApiChatRoute
+});
 var ApiChatMcpRoute = Route$17.update({
   id: "/mcp",
   path: "/mcp",
@@ -40140,12 +42638,12 @@ var ApiProjectsForkRoute = Route$5.update({
 var ApiWorkspaceFileRoute = Route$4.update({
   id: "/api/workspace/file",
   path: "/api/workspace/file",
-  getParentRoute: () => Route$27
+  getParentRoute: () => Route$29
 });
 var ApiWorkspaceTreeRoute = Route$3.update({
   id: "/api/workspace/tree",
   path: "/api/workspace/tree",
-  getParentRoute: () => Route$27
+  getParentRoute: () => Route$29
 });
 var ApiChatMcpOauthRoute = Route$2.update({
   id: "/oauth",
@@ -40172,7 +42670,9 @@ var ApiChatRouteChildren = {
   ApiChatArtifactsRoute,
   ApiChatCommandRoute,
   ApiChatCommandsRoute,
+  ApiChatCompletionRoute,
   ApiChatEventsRoute,
+  ApiChatIntentRoute,
   ApiChatMcpRoute: ApiChatMcpRouteWithChildren,
   ApiChatModelsRoute: ApiChatModelsRouteWithChildren,
   ApiChatNewRoute,
@@ -40198,7 +42698,7 @@ var rootRouteChildren = {
   ApiWorkspaceFileRoute,
   ApiWorkspaceTreeRoute
 };
-var routeTree = Route$27._addFileChildren(rootRouteChildren)._addFileTypes();
+var routeTree = Route$29._addFileChildren(rootRouteChildren)._addFileTypes();
 function getRouter() {
   return createRouter({
     routeTree,