@qredence/fleet 0.6.3 → 0.6.5

package/dist/web/server/{chunk-O2IC376F.js → chunk-5TXDGMCK.js}

@@ -1,1739 +1,16 @@
-import {
-  isObject
-} from "./chunk-K6PTNSCW.js";
-import {
-  KeyframeResolver,
-  MotionConfigContext,
-  MotionGlobalConfig,
-  NativeAnimation,
-  VisualElement,
-  WithPromise,
-  acceleratedValues,
-  analyseComplexValue,
-  buildHTMLStyles,
-  buildSVGAttrs,
-  camelToDash,
-  cancelFrame,
-  clamp,
-  color,
-  complex,
-  containsCSSVariable,
-  createBox,
-  cssStyleProperties,
-  defaultTransformValue,
-  findDimensionValueType,
-  flushKeyframeResolvers,
-  frame,
-  frameData,
-  generateLinearEasing,
-  getAnimatableNone,
-  getDefaultValueType,
-  getFinalKeyframe,
-  hex,
-  hsla,
-  invariant,
-  isBezierDefinition,
-  isCSSVariableName,
-  isCSSVariableToken,
-  isGenerator,
-  isMotionValue,
-  isNumOrPxType,
-  isNumericalString,
-  isSVGTag,
-  isZeroValueString,
-  memo$1,
-  millisecondsToSeconds,
-  mixNumber,
-  motionValue,
-  noop,
-  optimizedAppearDataAttribute,
-  positionalValues,
-  readTransformValue,
-  resolveVariantFromProps,
-  rgba,
-  scrapeMotionValuesFromProps,
-  scrapeMotionValuesFromProps$1,
-  secondsToMilliseconds,
-  setStyle,
-  time,
-  transformPropOrder,
-  transformProps,
-  useConstant,
-  velocityPerSecond,
-  warning
-} from "./chunk-7E76R7MB.js";
 import {
   ChatDeliveryModeSchema,
   ChatThinkingLevelSchema,
   ChatTransportSchema,
+  ProjectIdSchema,
   SessionIdSchema,
   external_exports,
   nonEmptyStringSchema,
   nonNegativeIntSchema,
   positiveIntSchema
-} from "./chunk-DP26GVWH.js";
+} from "./chunk-3YYNG52U.js";
 
-// web/app/dist/server/assets/chat-protocol.zod-gvwn378O.js
-import { useContext, useMemo } from "react";
-import { jsx } from "react/jsx-runtime";
-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) {
-  let duration = 0;
-  const timeStep = 50;
-  let state = generator.next(duration);
-  while (!state.done && duration < 2e4) {
-    duration += timeStep;
-    state = generator.next(duration);
-  }
-  return duration >= 2e4 ? 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 = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq2, 2) * duration;
-      const f = Math.exp(-delta);
-      const g = calcAngularFreq(Math.pow(undampedFreq2, 2), 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 = Math.pow(undampedFreq, 2) * 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 root = 2 * Math.PI / (visualDuration * 1.2);
-      const stiffness = root * root;
-      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 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;
-  let angularFreq;
-  let A;
-  let sinCoeff;
-  let cosCoeff;
-  if (dampingRatio < 1) {
-    angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
-    A = (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq;
-    resolveSpring = (t) => {
-      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-      return target - envelope * (A * Math.sin(angularFreq * t) + initialDelta * Math.cos(angularFreq * t));
-    };
-    sinCoeff = dampingRatio * undampedAngularFreq * A + initialDelta * angularFreq;
-    cosCoeff = dampingRatio * undampedAngularFreq * initialDelta - A * angularFreq;
-    resolveVelocity = (t) => {
-      return Math.exp(-dampingRatio * undampedAngularFreq * t) * (sinCoeff * Math.sin(angularFreq * t) + cosCoeff * Math.cos(angularFreq * t));
-    };
-  } 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(-dampingRatio * undampedAngularFreq * t);
-      const freqForT = Math.min(dampedAngularFreq * t, 300);
-      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
-    };
-    const P = (initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / dampedAngularFreq;
-    const sinhCoeff = dampingRatio * undampedAngularFreq * P - initialDelta * dampedAngularFreq;
-    const coshCoeff = dampingRatio * undampedAngularFreq * initialDelta - P * dampedAngularFreq;
-    resolveVelocity = (t) => {
-      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * 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) => {
-      if (!isResolvedFromDuration && dampingRatio < 1) {
-        const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
-        const sin = Math.sin(angularFreq * t);
-        const cos = Math.cos(angularFreq * t);
-        const current2 = target - envelope * (A * sin + initialDelta * cos);
-        const currentVelocity = secondsToMilliseconds(envelope * (sinCoeff * sin + cosCoeff * cos));
-        state.done = Math.abs(currentVelocity) <= restSpeed && Math.abs(target - current2) <= restDelta;
-        state.value = state.done ? target : current2;
-        return state;
-      }
-      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;
-};
-var velocitySampleDuration = 5;
-function getGeneratorVelocity(resolveValue, t, current) {
-  const prevT = Math.max(t - velocitySampleDuration, 0);
-  return velocityPerSecond(current - resolveValue(prevT), t - prevT);
-}
-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) => min !== void 0 && v < min || max !== void 0 && 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 calcLatest = (t) => target + calcDelta(t);
-  const applyFriction = (t) => {
-    const delta = calcDelta(t);
-    const latest = calcLatest(t);
-    state.done = Math.abs(delta) <= restDelta;
-    state.value = state.done ? target : latest;
-  };
-  let timeReachedBoundary;
-  let spring$1;
-  const checkCatchBoundary = (t) => {
-    if (!isOutOfBounds(state.value)) return;
-    timeReachedBoundary = t;
-    spring$1 = spring({
-      keyframes: [state.value, nearestBoundary(state.value)],
-      velocity: getGeneratorVelocity(calcLatest, t, state.value),
-      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 transitionTypeMap = {
-  decay: inertia,
-  inertia,
-  tween: keyframes,
-  keyframes,
-  spring
-};
-function replaceTransitionType(transition) {
-  if (typeof transition.type === "string") transition.type = transitionTypeMap[transition.type];
-}
-var percentToProgress = (percent) => percent / 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 = 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 - delay * (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(resolve, reject) {
-    return this.finished.then(resolve, reject);
-  }
-  get duration() {
-    return millisecondsToSeconds(this.calculatedDuration);
-  }
-  get iterationDuration() {
-    const { delay = 0 } = this.options || {};
-    return this.duration + millisecondsToSeconds(delay);
-  }
-  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 now = this.driver.now();
-    if (this.state === "finished") {
-      this.updateFinished();
-      this.startTime = now;
-    } else if (this.holdTime !== null) this.startTime = now - this.holdTime;
-    else if (!this.startTime) this.startTime = startTime ?? now;
-    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 = 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,
-      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, isHandoff, onUpdate } = options;
-    this.resolvedAt = time.now();
-    let canAnimateValue = true;
-    if (!canAnimate(keyframes2, name, type, velocity)) {
-      canAnimateValue = false;
-      if (MotionGlobalConfig.instantAnimations || !delay) 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 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 delay = valueTransition.delay || transition.delay || 0;
-  let { elapsed = 0 } = transition;
-  elapsed = elapsed - secondsToMilliseconds(delay);
-  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 = 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 animations = [];
-  const animationTypeState = type && visualElement.animationState && visualElement.animationState.getState()[type];
-  const path = transition?.path;
-  if (path) path.animateVisualElement(visualElement, target, transition, delay, animations);
-  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,
-      ...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) animations.push(animation);
-  }
-  if (transitionEnd) {
-    const applyTransitionEnd = () => frame.update(() => {
-      transitionEnd && setTarget(visualElement, transitionEnd);
-    });
-    if (animations.length) Promise.all(animations).then(applyTransitionEnd);
-    else applyTransitionEnd();
-  }
-  return animations;
-}
-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 root = document;
-    if (scope) root = scope.current;
-    const elements = selectorCache?.[elementOrSelector] ?? root.querySelectorAll(elementOrSelector);
-    return elements ? Array.from(elements) : [];
-  }
-  return Array.from(elementOrSelector).filter((element) => element != null);
-}
-function isSVGElement(element) {
-  return isObject(element) && "ownerSVGElement" in element;
-}
-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}`;
-    });
-  }
-};
-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, transformPoint) {
-  if (!transformPoint) return point;
-  const topLeft = transformPoint({
-    x: point.left,
-    y: point.top
-  });
-  const bottomRight = transformPoint({
-    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, distance) {
-  axis.min += distance;
-  axis.max += distance;
-}
-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, transformPoint) {
-  return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));
-}
-function measurePageBox(element, rootProjectionNode, transformPagePoint) {
-  const viewportBox = measureViewportBox(element, transformPagePoint);
-  const { scroll } = rootProjectionNode;
-  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);
-  }
-};
-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 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
-  });
-}
+// web/app/dist/server/assets/composer-completion-Bjb1zW3r.js
 function observeWebVitals(onVital) {
   if (typeof window === "undefined" || typeof PerformanceObserver === "undefined") return () => {
   };
@@ -1880,11 +157,13 @@ function initAnalytics() {
 var NETWORK_DISCONNECTED_MESSAGE = "Fleet Prime is not connected to the Prime Agent runtime. Start or reconnect the runtime, then try again.";
 var FLEET_ADAPTER_CAPABILITIES = {
   protocolVersion: 1,
-  schemaRevision: 2,
+  schemaRevision: 4,
   features: [
     "reasoning-summary-v1",
     "mcp-connections-v1",
-    "session-tree-v1"
+    "session-tree-v1",
+    "composer-intent-v1",
+    "composer-completion-v1"
   ]
 };
 var ChatModelInfoSchema = external_exports.object({
@@ -2057,6 +336,67 @@ var ChatCommandsResponseSchema = external_exports.object({
   commands: external_exports.array(ChatSlashCommandInfoSchema),
   diagnostics: external_exports.array(external_exports.string())
 }).openapi({ description: "Chat slash commands response" });
+var ComposerCompletionSourceSchema = external_exports.enum(["session", "corpus"]).openapi({ description: "Where a completion came from: this session or another session" });
+external_exports.enum(["append", "replace"]).openapi({ description: "Whether accepting appends the completion or replaces the draft with it" });
+var ComposerCompletionRequestSchema = external_exports.object({
+  text: nonEmptyStringSchema.max(2e3),
+  /** The session being typed in; its own prompts are preferred over the corpus. */
+  sessionId: nonEmptyStringSchema.max(200).optional(),
+  projectId: ProjectIdSchema.optional()
+}).openapi({ description: "Composer ghost-text completion request" });
+external_exports.object({
+  completion: external_exports.string().min(1).max(2e3).optional(),
+  confidence: external_exports.number().min(0).max(1).optional(),
+  source: ComposerCompletionSourceSchema.optional()
+}).openapi({ description: "Composer ghost-text completion from history; a verbatim string that always extends the draft, never model prose" });
+var ComposerIntentStatusSchema = external_exports.enum([
+  "unconfigured",
+  "unverified",
+  "ready",
+  "error"
+]).openapi({ description: "Coarse readiness of the optional composer intent classifier" });
+var ComposerIntentReasonSchema = external_exports.enum([
+  "disabled",
+  "not_ready",
+  "empty",
+  "no_match",
+  "code_task",
+  "below_floor",
+  "unavailable",
+  "rate_limited"
+]).openapi({ description: "Why a routing attempt produced no action" });
+var ComposerIntentKeySourceSchema = external_exports.enum([
+  "settings",
+  "environment",
+  "none"
+]).openapi({ description: "Which key the classifier is using; never the key itself" });
+var ComposerIntentDispositionSchema = external_exports.enum(["execute", "suggest"]).openapi({ description: "Whether a matched command may run automatically or is only offered" });
+var ComposerIntentRequestSchema = external_exports.object({
+  text: nonEmptyStringSchema.max(2e3),
+  projectId: ProjectIdSchema.optional()
+}).openapi({ description: "Composer free-text intent routing request" });
+external_exports.object({
+  enabled: external_exports.boolean(),
+  outcome: external_exports.enum(["none", "matched"]),
+  command: external_exports.string().min(1).max(64).optional(),
+  confidence: external_exports.number().min(0).max(1).optional(),
+  disposition: ComposerIntentDispositionSchema.optional(),
+  reason: ComposerIntentReasonSchema.optional(),
+  model: external_exports.string().max(120).optional(),
+  latencyMs: external_exports.number().nonnegative().optional()
+}).openapi({ description: "Composer intent routing decision; never carries model prose or error text" });
+external_exports.object({
+  /** The user's choice in Settings. Off until they turn it on. */
+  enabled: external_exports.boolean(),
+  /** Whether a usable key is present. `unverified` until a probe succeeds. */
+  status: ComposerIntentStatusSchema,
+  keySource: ComposerIntentKeySourceSchema
+}).openapi({ description: "Composer intent routing availability; never reveals the key or a raw error" });
+var ComposerIntentCredentialSchema = external_exports.object({
+  /** A key to store, or null to remove the stored one. */
+  apiKey: nonEmptyStringSchema.max(400).nullable()
+}).openapi({ description: "Set or clear the stored classifier key; write-only" });
+var ComposerIntentSettingsUpdateSchema = external_exports.object({ enabled: external_exports.boolean() }).openapi({ description: "Enable or disable composer intent routing" });
 var MCP_SERVER_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 var MCP_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var mcpServerNameSchema = external_exports.string().regex(MCP_SERVER_NAME_PATTERN, "MCP server names must be 1-64 letters, numbers, underscores, or hyphens and start with a letter or number.");
@@ -2250,10 +590,27 @@ var ChatSettingsResponseSchema = external_exports.object({
     resourceReloadRequired: external_exports.boolean()
   })
 }).openapi({ description: "Pi settings response" });
+function composerCompletionIgnores(draft) {
+  if (draft.trimStart().startsWith("/")) return true;
+  return /(?:^|\s)@[^\s@]*$/.test(draft);
+}
+function normalizeCompletionDraft(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+function composerCompletionGhost(draft, completion, mode = "append") {
+  if (!completion) return void 0;
+  const normalizedCompletion = normalizeCompletionDraft(completion);
+  if (mode === "replace") return normalizedCompletion.length > 0 ? normalizedCompletion : void 0;
+  const normalizedDraft = normalizeCompletionDraft(draft);
+  if (normalizedCompletion.length <= normalizedDraft.length) return void 0;
+  if (!normalizedCompletion.toLowerCase().startsWith(normalizedDraft.toLowerCase())) return void 0;
+  const suffix = normalizedCompletion.slice(normalizedDraft.length);
+  return /\s$/.test(draft) ? suffix.replace(/^\s+/, "") : suffix;
+}
 
-// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
+// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.3.0/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
 import * as React from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 var QueryClientContext = React.createContext(void 0);
 var useQueryClient = (queryClient) => {
   const client = React.useContext(QueryClientContext);
@@ -2268,7 +625,7 @@ var QueryClientProvider = ({ client, children }) => {
       client.unmount();
     };
   }, [client]);
-  return /* @__PURE__ */ jsx2(QueryClientContext.Provider, {
+  return /* @__PURE__ */ jsx(QueryClientContext.Provider, {
     value: client,
     children
   });
@@ -2316,7 +673,7 @@ function systemSetTimeoutZero(callback) {
 
 // node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/utils.js
 var isServer = typeof window === "undefined" || "Deno" in globalThis;
-function noop2() {
+function noop() {
 }
 function functionalUpdate(updater, input) {
   return typeof updater === "function" ? updater(input) : updater;
@@ -2715,7 +1072,7 @@ function createRetryer(config) {
     promiseResolve = resolve2;
     promiseReject = reject2;
   });
-  promise.catch(noop2);
+  promise.catch(noop);
   const isResolved = () => status !== "pending";
   const cancel = (cancelOptions) => {
     if (!isResolved()) {
@@ -3151,7 +1508,7 @@ var MutationCache = class extends Subscribable {
   }
   resumePausedMutations() {
     const pausedMutations = this.getAll().filter((x) => x.state.isPaused);
-    return notifyManager.batch(() => Promise.all(pausedMutations.map((mutation) => mutation.continue().catch(noop2))));
+    return notifyManager.batch(() => Promise.all(pausedMutations.map((mutation) => mutation.continue().catch(noop))));
   }
 };
 function scopeFor(mutation) {
@@ -3307,7 +1664,7 @@ var Query = class extends Removable {
   cancel(options) {
     const promise = this.#retryer?.promise;
     this.#retryer?.cancel(options);
-    return promise ? promise.then(noop2).catch(noop2) : Promise.resolve();
+    return promise ? promise.then(noop).catch(noop) : Promise.resolve();
   }
   destroy() {
     super.destroy();
@@ -3840,7 +2197,7 @@ var QueryClient = class {
       ...cancelOptions
     };
     const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map((query) => query.cancel(defaultedCancelOptions)));
-    return Promise.all(promises).then(noop2).catch(noop2);
+    return Promise.all(promises).then(noop).catch(noop);
   }
   invalidateQueries(filters, options = {}) {
     return notifyManager.batch(() => {
@@ -3861,10 +2218,10 @@ var QueryClient = class {
     };
     const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter((query) => !query.isDisabled() && !query.isStatic()).map((query) => {
       let promise = query.fetch(void 0, fetchOptions);
-      if (!fetchOptions.throwOnError) promise = promise.catch(noop2);
+      if (!fetchOptions.throwOnError) promise = promise.catch(noop);
       return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
     }));
-    return Promise.all(promises).then(noop2);
+    return Promise.all(promises).then(noop);
   }
   async query(options) {
     const defaultedOptions = this.defaultQueryOptions(options);
@@ -3888,7 +2245,7 @@ var QueryClient = class {
   * @deprecated Use queryClient.query(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
   */
   prefetchQuery(options) {
-    return this.fetchQuery(options).then(noop2).catch(noop2);
+    return this.fetchQuery(options).then(noop).catch(noop);
   }
   infiniteQuery(options) {
     options._type = "infinite";
@@ -3905,7 +2262,7 @@ var QueryClient = class {
   * @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
   */
   prefetchInfiniteQuery(options) {
-    return this.fetchInfiniteQuery(options).then(noop2).catch(noop2);
+    return this.fetchInfiniteQuery(options).then(noop).catch(noop);
   }
   /**
   * @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
@@ -4121,7 +2478,7 @@ var QueryObserver = class extends Subscribable {
   #executeFetch(fetchOptions) {
     this.#updateQuery();
     let promise = this.#currentQuery.fetch(this.options, fetchOptions);
-    if (!fetchOptions?.throwOnError) promise = promise.catch(noop2);
+    if (!fetchOptions?.throwOnError) promise = promise.catch(noop);
     return promise;
   }
   #shouldScheduleTimer(timeout) {
@@ -4428,15 +2785,15 @@ var MutationObserver = class extends Subscribable {
   }
 };
 
-// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
+// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.3.0/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
 import * as React2 from "react";
 var IsRestoringContext = React2.createContext(false);
 var useIsRestoring = () => React2.useContext(IsRestoringContext);
 var IsRestoringProvider = IsRestoringContext.Provider;
 
-// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
+// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.3.0/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
 import * as React3 from "react";
-import { jsx as jsx3 } from "react/jsx-runtime";
+import { jsx as jsx2 } from "react/jsx-runtime";
 function createValue() {
   let isReset = false;
   return {
@@ -4454,7 +2811,7 @@ function createValue() {
 var QueryErrorResetBoundaryContext = React3.createContext(createValue());
 var useQueryErrorResetBoundary = () => React3.useContext(QueryErrorResetBoundaryContext);
 
-// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
+// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.3.0/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
 import * as React4 from "react";
 var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
   const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
@@ -4471,13 +2828,13 @@ var getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }
   return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
 };
 
-// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/suspense.js
+// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.3.0/node_modules/@tanstack/react-query/build/modern/suspense.js
 var ensureSuspenseTimers = (defaultedOptions) => {
   if (defaultedOptions.suspense) {
     const MIN_SUSPENSE_TIME_MS = 1e3;
-    const clamp2 = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
+    const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
     const originalStaleTime = defaultedOptions.staleTime;
-    defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp2(originalStaleTime(...args)) : clamp2(originalStaleTime);
+    defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
     if (typeof defaultedOptions.gcTime === "number") defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, MIN_SUSPENSE_TIME_MS);
   }
 };
@@ -4486,7 +2843,7 @@ var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observ
   errorResetBoundary.clearReset();
 });
 
-// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
+// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.3.0/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
 import * as React5 from "react";
 function useBaseQuery(options, Observer, queryClient) {
   if (process.env.NODE_ENV !== "production") {
@@ -4509,7 +2866,7 @@ function useBaseQuery(options, Observer, queryClient) {
   const result = observer.getOptimisticResult(defaultedOptions);
   const shouldSubscribe = !isRestoring && subscribed;
   React5.useSyncExternalStore(React5.useCallback((onStoreChange) => {
-    const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop2;
+    const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
     observer.updateResult();
     return unsubscribe;
   }, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
@@ -4527,12 +2884,12 @@ function useBaseQuery(options, Observer, queryClient) {
   return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
 }
 
-// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useQuery.js
+// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.3.0/node_modules/@tanstack/react-query/build/modern/useQuery.js
 function useQuery(options, queryClient) {
   return useBaseQuery(options, QueryObserver, queryClient);
 }
 
-// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useMutation.js
+// node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.3.0/node_modules/@tanstack/react-query/build/modern/useMutation.js
 import * as React6 from "react";
 function useMutation(options, queryClient) {
   const client = useQueryClient(queryClient);
@@ -4542,7 +2899,7 @@ function useMutation(options, queryClient) {
   }, [observer, options]);
   const result = React6.useSyncExternalStore(React6.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
   const mutate = React6.useCallback((...args) => {
-    observer.mutate(args[0], args[1]).catch(noop2);
+    observer.mutate(args[0], args[1]).catch(noop);
   }, [observer]);
   if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
   return {
@@ -4553,40 +2910,6 @@ function useMutation(options, queryClient) {
 }
 
 export {
-  pipe,
-  progress,
-  reverseEasing,
-  circOut,
-  isEasingArray,
-  createGeneratorEasing,
-  spring,
-  fillOffset,
-  defaultOffset,
-  getValueTransition,
-  animateMotionValue,
-  resolveVariant,
-  isKeyframesTarget,
-  addValueToWillChange,
-  getOptimisedAppearId,
-  animateTarget,
-  resolveElements,
-  isSVGElement,
-  isSVGSVGElement,
-  convertBoundingBoxToBox,
-  convertBoxToBoundingBox,
-  hasScale,
-  hasTransform,
-  has2DTranslate,
-  scalePoint,
-  applyBoxDelta,
-  applyTreeDeltas,
-  translateAxis,
-  transformBox,
-  measurePageBox,
-  HTMLVisualElement,
-  SVGVisualElement,
-  animateSingleValue,
-  MotionConfig,
   initAnalytics,
   NETWORK_DISCONNECTED_MESSAGE,
   FLEET_ADAPTER_CAPABILITIES,
@@ -4603,6 +2926,10 @@ export {
   ChatProviderOAuthLoginRequestSchema,
   ChatProviderOAuthLoginResponseSchema,
   ChatCommandsResponseSchema,
+  ComposerCompletionRequestSchema,
+  ComposerIntentRequestSchema,
+  ComposerIntentCredentialSchema,
+  ComposerIntentSettingsUpdateSchema,
   ChatMcpListResponseSchema,
   ChatMcpUpsertRequestSchema,
   ChatMcpDeleteRequestSchema,
@@ -4613,6 +2940,9 @@ export {
   SessionTreeNavigateResponseSchema,
   ChatSettingsUpdateRequestSchema,
   ChatSettingsResponseSchema,
+  composerCompletionIgnores,
+  normalizeCompletionDraft,
+  composerCompletionGhost,
   useQueryClient,
   QueryClientProvider,
   isServer,