@frontera-sdk/chat-ui 1.50.40

package/dist/chunk-FXKXDR5K.js

@@ -0,0 +1,2166 @@
+'use client';
+import { cn } from './chunk-DGDHKMDB.js';
+import { forwardRef, useState, useId, useRef, useMemo, memo, useEffect, useLayoutEffect } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { z } from 'zod';
+
+// src/vendor/ui/agent-avatar/lab/math.ts
+var TAU = Math.PI * 2;
+var clamp = (value, minimum = 0, maximum = 1) => value < minimum ? minimum : value > maximum ? maximum : value;
+var lerp = (from, to, progress) => from + (to - from) * progress;
+var easings = {
+  easeOutCubic: (progress) => 1 - (1 - progress) ** 3,
+  easeInOutCubic: (progress) => progress < 0.5 ? 4 * progress ** 3 : 1 - (-2 * progress + 2) ** 3 / 2,
+  easeOutQuint: (progress) => 1 - (1 - progress) ** 5
+};
+function loopNoise(time, period, seed = 0) {
+  const phase = time / period * TAU;
+  return 0.55 * Math.sin(phase + seed) + 0.3 * Math.sin(2 * phase + seed * 1.7 + 1.1) + 0.15 * Math.sin(3 * phase + seed * 2.3 + 2.4);
+}
+function createRng(seed) {
+  let value = seed >>> 0;
+  return () => {
+    value = value + 1831565813 >>> 0;
+    let next = Math.imul(value ^ value >>> 15, 1 | value);
+    next = next + Math.imul(next ^ next >>> 7, 61 | next) ^ next;
+    return ((next ^ next >>> 14) >>> 0) / 4294967296;
+  };
+}
+var r2 = (value) => Math.round(value * 100) / 100;
+
+// src/vendor/ui/agent-avatar/lab/expressions.ts
+var eye = (width, height, tilt = 0, open = 1) => ({
+  width,
+  height,
+  tilt,
+  open
+});
+var pair = (width, height, tilt = 0, open = 1) => [
+  eye(width, height, tilt, open),
+  eye(width, height, -tilt, open)
+];
+var EYE_EXPRESSIONS = [
+  { id: "neutral", name: "Neutral", description: "Clear and composed", separation: 15.5, gaze: { x: 0, y: 0 }, eyes: pair(0.186, 0.412) },
+  { id: "attentive", name: "Attentive", description: "Ready to listen", separation: 16, gaze: { x: 0.04, y: 0.05 }, eyes: pair(0.21, 0.44) },
+  { id: "surprised", name: "Surprised", description: "Wide recognition", separation: 19, gaze: { x: 0.03, y: -0.03 }, eyes: pair(0.45, 0.47) },
+  { id: "energized", name: "Energized", description: "High momentum", separation: 19.5, gaze: { x: 0.06, y: -0.14 }, eyes: pair(0.4, 0.56, -10) },
+  { id: "happy", name: "Happy", description: "Quietly positive", separation: 17, gaze: { x: 0.05, y: 0.09 }, eyes: pair(0.27, 0.17, 14) },
+  { id: "delighted", name: "Delighted", description: "Openly positive", separation: 18, gaze: { x: 0.04, y: 0.14 }, eyes: pair(0.34, 0.13, 20) },
+  { id: "focused", name: "Focused", description: "Decisive attention", separation: 14.5, gaze: { x: 0.03, y: 0.04 }, eyes: pair(0.19, 0.32) },
+  { id: "concerned", name: "Concerned", description: "Careful review", separation: 16, gaze: { x: 0.03, y: -0.13 }, eyes: [eye(0.2, 0.4), eye(0.24, 0.32)] },
+  { id: "alert", name: "Alert", description: "Fully engaged", separation: 20.5, gaze: { x: 0.02, y: -0.2 }, eyes: pair(0.4, 0.6) },
+  { id: "skeptical", name: "Skeptical", description: "Evaluating closely", separation: 16, gaze: { x: 0.12, y: 0.06 }, eyes: [eye(0.21, 0.4), eye(0.22, 0.15)] },
+  { id: "puzzled", name: "Puzzled", description: "Working it through", separation: 16.5, gaze: { x: -0.14, y: 0.03 }, eyes: [eye(0.2, 0.44, -18), eye(0.28, 0.17, 14)] },
+  { id: "curious", name: "Curious", description: "Exploring a lead", separation: 16.5, gaze: { x: 0.16, y: -0.09 }, eyes: [eye(0.24, 0.46, -8), eye(0.2, 0.38, -8)] },
+  { id: "assured", name: "Assured", description: "Calm confidence", separation: 17, gaze: { x: 0.05, y: 0.14 }, eyes: pair(0.26, 0.2) },
+  { id: "reserved", name: "Reserved", description: "Present, understated", separation: 14, gaze: { x: -0.19, y: -0.14 }, eyes: pair(0.17, 0.3) },
+  { id: "unimpressed", name: "Unimpressed", description: "Measured restraint", separation: 16, gaze: { x: -0.22, y: 0.02 }, eyes: pair(0.3, 0.12) },
+  { id: "sleepy", name: "Sleepy", description: "Low energy", separation: 16, gaze: { x: 0.06, y: -0.09 }, eyes: pair(0.2, 0.42, 0, 0.42) }
+];
+var EYE_EXPRESSION_BY_ID = new Map(
+  EYE_EXPRESSIONS.map((expression) => [expression.id, expression])
+);
+function blendEyeExpressions(from, to, progress) {
+  const mix = (a, b) => a + (b - a) * progress;
+  const blendEye = (index) => ({
+    width: mix(from.eyes[index].width, to.eyes[index].width),
+    height: mix(from.eyes[index].height, to.eyes[index].height),
+    tilt: mix(from.eyes[index].tilt, to.eyes[index].tilt),
+    open: mix(from.eyes[index].open, to.eyes[index].open)
+  });
+  return {
+    ...to,
+    separation: mix(from.separation, to.separation),
+    gaze: {
+      x: mix(from.gaze.x, to.gaze.x),
+      y: mix(from.gaze.y, to.gaze.y)
+    },
+    eyes: [blendEye(0), blendEye(1)]
+  };
+}
+
+// src/vendor/ui/agent-avatar/lab/eyes.ts
+function clampGaze(gaze) {
+  return {
+    x: clamp(gaze.x, -1, 1),
+    y: clamp(gaze.y, -1, 1),
+    active: gaze.active ?? false
+  };
+}
+function eyePair(region, gaze, openness, state, expressionInput = "neutral", eyeScale = 1) {
+  const target = clampGaze(gaze);
+  const expression = typeof expressionInput === "string" ? EYE_EXPRESSION_BY_ID.get(expressionInput) ?? EYE_EXPRESSION_BY_ID.get("neutral") : expressionInput;
+  const gazeX = clamp(target.x + expression.gaze.x, -1, 1);
+  const gazeY = clamp(target.y + expression.gaze.y, -1, 1);
+  const centerX = region.x + region.width / 2 + gazeX * region.width * 0.065;
+  const centerY = region.y + region.height / 2 + gazeY * region.height * 0.075;
+  const separation = region.width * (expression.separation / 100);
+  const depthBias = target.x * 0.055;
+  const visibleOpenness = clamp(openness, 0.06, 1.08);
+  const buildEye = (side, index) => {
+    const geometry = expression.eyes[index];
+    const stateHeight = state === "waiting" ? 0.92 : state === "attentive" ? 1.04 : 1;
+    const eyeOpenness = visibleOpenness * geometry.open;
+    return {
+      cx: centerX + separation * side,
+      cy: centerY + (state === "working" ? side * 0.5 : 0),
+      width: region.height * geometry.width * (1 + depthBias * side) * eyeScale,
+      height: Math.max(2.4, region.height * geometry.height * eyeOpenness * stateHeight * eyeScale),
+      rotation: geometry.tilt + (state === "working" ? side * 1.5 : target.x * side * 1.8),
+      openness: eyeOpenness
+    };
+  };
+  return [buildEye(-1, 0), buildEye(1, 1)];
+}
+
+// src/vendor/ui/agent-avatar/lab/shape.ts
+function normalizeProfile(radii, maximum = 1) {
+  const peak = Math.max(...radii);
+  if (!Number.isFinite(peak) || peak <= 0) return [...radii];
+  const factor = maximum / peak;
+  return radii.map((radius) => radius * factor);
+}
+function superellipseProfile(samples, exponent, scaleX = 1, scaleY = 1) {
+  return Array.from({ length: samples }, (_, index) => {
+    const angle = index / samples * TAU;
+    const x = Math.abs(Math.cos(angle) / scaleX) ** exponent;
+    const y = Math.abs(Math.sin(angle) / scaleY) ** exponent;
+    return (x + y) ** (-1 / exponent);
+  });
+}
+function unionOfCirclesProfile(samples, circles) {
+  return Array.from({ length: samples }, (_, index) => {
+    const angle = index / samples * TAU;
+    const dx = Math.cos(angle);
+    const dy = Math.sin(angle);
+    let furthest = 0;
+    for (const circle of circles) {
+      const projection = dx * circle.x + dy * circle.y;
+      const discriminant = projection ** 2 - (circle.x ** 2 + circle.y ** 2 - circle.radius ** 2);
+      if (discriminant < 0) continue;
+      furthest = Math.max(furthest, projection + Math.sqrt(discriminant));
+    }
+    return furthest;
+  });
+}
+function profileFromPolygon(samples, polygon, centerX = 0, centerY = 0) {
+  return Array.from({ length: samples }, (_, sampleIndex) => {
+    const angle = sampleIndex / samples * TAU;
+    const dx = Math.cos(angle);
+    const dy = Math.sin(angle);
+    let furthest = 0;
+    for (let index = 0; index < polygon.length; index += 1) {
+      const from = polygon[index];
+      const to = polygon[(index + 1) % polygon.length];
+      const edgeX = to.x - from.x;
+      const edgeY = to.y - from.y;
+      const denominator = dx * edgeY - dy * edgeX;
+      if (Math.abs(denominator) < 1e-9) continue;
+      const relativeX = from.x - centerX;
+      const relativeY = from.y - centerY;
+      const rayDistance = (relativeX * edgeY - relativeY * edgeX) / denominator;
+      const edgePosition = (relativeX * dy - relativeY * dx) / denominator;
+      if (rayDistance > furthest && edgePosition >= 0 && edgePosition <= 1) {
+        furthest = rayDistance;
+      }
+    }
+    return furthest;
+  });
+}
+function hullOfCircles(x1, y1, radius1, x2, y2, radius2, steps = 96) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const distance = Math.hypot(dx, dy) || 1e-6;
+  const base = Math.atan2(dy, dx);
+  const spread = Math.acos(Math.min(1, Math.max(-1, (radius1 - radius2) / distance)));
+  const points = [];
+  for (let index = 0; index <= steps / 2; index += 1) {
+    const angle = base + spread + (TAU - 2 * spread) * index / (steps / 2);
+    points.push({ x: x1 + Math.cos(angle) * radius1, y: y1 + Math.sin(angle) * radius1 });
+  }
+  for (let index = 0; index <= steps / 2; index += 1) {
+    const angle = base - spread + 2 * spread * index / (steps / 2);
+    points.push({ x: x2 + Math.cos(angle) * radius2, y: y2 + Math.sin(angle) * radius2 });
+  }
+  return points;
+}
+function roundedPolygon(vertices, cornerRadius, arcSteps = 10) {
+  const outwardNormal = (from, to) => {
+    const dx = to.x - from.x;
+    const dy = to.y - from.y;
+    const length = Math.hypot(dx, dy) || 1;
+    return Math.atan2(-dx / length, dy / length);
+  };
+  const points = [];
+  for (let index = 0; index < vertices.length; index += 1) {
+    const previous = vertices[(index - 1 + vertices.length) % vertices.length];
+    const current = vertices[index];
+    const next = vertices[(index + 1) % vertices.length];
+    const fromAngle = outwardNormal(previous, current);
+    const toAngle = outwardNormal(current, next);
+    let delta = toAngle - fromAngle;
+    while (delta > Math.PI) delta -= TAU;
+    while (delta < -Math.PI) delta += TAU;
+    for (let step = 0; step <= arcSteps; step += 1) {
+      const angle = fromAngle + delta * step / arcSteps;
+      points.push({
+        x: current.x + Math.cos(angle) * cornerRadius,
+        y: current.y + Math.sin(angle) * cornerRadius
+      });
+    }
+  }
+  return points;
+}
+function regularPolygonProfile(samples, sides, radius, cornerRadius, rotationDegrees = 0) {
+  const rotation = rotationDegrees * Math.PI / 180;
+  const vertices = Array.from({ length: sides }, (_, index) => {
+    const angle = rotation + index / sides * TAU;
+    return {
+      x: Math.cos(angle) * (radius - cornerRadius),
+      y: Math.sin(angle) * (radius - cornerRadius)
+    };
+  });
+  return profileFromPolygon(samples, roundedPolygon(vertices, cornerRadius));
+}
+function blendProfiles(from, to, progress) {
+  const length = Math.min(from.length, to.length);
+  return Array.from(
+    { length },
+    (_, index) => lerp(from[index] ?? 1, to[index] ?? 1, progress)
+  );
+}
+function profilePoints(radii, radius = 104, centerX = 128, centerY = 128, pose = {}) {
+  const rotation = pose.rotation ?? 0;
+  const scaleX = pose.scaleX ?? 1;
+  const scaleY = pose.scaleY ?? 1;
+  const translateX = pose.translateX ?? 0;
+  const translateY = pose.translateY ?? 0;
+  const cosine = Math.cos(rotation);
+  const sine = Math.sin(rotation);
+  return radii.map((profileRadius, index) => {
+    const angle = index / radii.length * TAU;
+    const x = profileRadius * Math.cos(angle);
+    const y = profileRadius * Math.sin(angle);
+    const rotatedX = x * cosine - y * sine;
+    const rotatedY = x * sine + y * cosine;
+    return {
+      x: centerX + (rotatedX * scaleX + translateX) * radius,
+      y: centerY + (rotatedY * scaleY + translateY) * radius
+    };
+  });
+}
+function closedPath(points, tension = 1 / 6) {
+  const count = points.length;
+  if (count < 3) return "";
+  const first = points[0];
+  let path = `M${r2(first.x)} ${r2(first.y)}`;
+  for (let index = 0; index < count; index += 1) {
+    const before = points[(index - 1 + count) % count];
+    const current = points[index];
+    const next = points[(index + 1) % count];
+    const after = points[(index + 2) % count];
+    const c1x = current.x + (next.x - before.x) * tension;
+    const c1y = current.y + (next.y - before.y) * tension;
+    const c2x = next.x - (after.x - current.x) * tension;
+    const c2y = next.y - (after.y - current.y) * tension;
+    path += `C${r2(c1x)} ${r2(c1y)} ${r2(c2x)} ${r2(c2y)} ${r2(next.x)} ${r2(next.y)}`;
+  }
+  return `${path}Z`;
+}
+function profilePath(radii, pose = {}, tension = 1 / 6) {
+  return closedPath(profilePoints(radii, 104, 128, 128, pose), tension);
+}
+
+// src/vendor/ui/agent-avatar/lab/profiles.ts
+var PROFILE_SAMPLES = 64;
+var angles = Array.from(
+  { length: PROFILE_SAMPLES },
+  (_, index) => index / PROFILE_SAMPLES * Math.PI * 2
+);
+var harmonic = (fn, maximum = 1) => normalizeProfile(angles.map(fn), maximum);
+var round = new Array(PROFILE_SAMPLES).fill(1);
+var pebble = harmonic(
+  (angle) => 1 + 0.075 * Math.cos(2 * angle + 0.5) + 0.035 * Math.cos(3 * angle + 2.1),
+  1.02
+);
+var squircle = normalizeProfile(superellipseProfile(PROFILE_SAMPLES, 4.2), 1.15);
+var capsule = profileFromPolygon(
+  PROFILE_SAMPLES,
+  hullOfCircles(-0.42, 0, 0.62, 0.42, 0, 0.62)
+);
+var triangle = regularPolygonProfile(PROFILE_SAMPLES, 3, 1.12, 0.34, -90);
+var hexagon = regularPolygonProfile(PROFILE_SAMPLES, 6, 1.04, 0.26);
+var cloud = normalizeProfile(
+  unionOfCirclesProfile(PROFILE_SAMPLES, [
+    { x: -0.44, y: 0.2, radius: 0.54 },
+    { x: 0.46, y: 0.2, radius: 0.5 },
+    { x: 0.02, y: 0.3, radius: 0.6 },
+    { x: -0.24, y: -0.3, radius: 0.48 },
+    { x: 0.3, y: -0.24, radius: 0.44 }
+  ]),
+  1.02
+);
+var sampleCubic = (from, controlA, controlB, to, steps = 32) => Array.from({ length: steps }, (_, index) => {
+  const progress = index / steps;
+  const inverse = 1 - progress;
+  return {
+    x: inverse ** 3 * from.x + 3 * inverse ** 2 * progress * controlA.x + 3 * inverse * progress ** 2 * controlB.x + progress ** 3 * to.x,
+    y: inverse ** 3 * from.y + 3 * inverse ** 2 * progress * controlA.y + 3 * inverse * progress ** 2 * controlB.y + progress ** 3 * to.y
+  };
+});
+var eggTop = { x: 0, y: -0.9 };
+var eggWidest = { x: 0.76, y: 0.15 };
+var eggBottom = { x: 0, y: 0.96 };
+var eggRight = [
+  ...sampleCubic(eggTop, { x: 0.4, y: -0.91 }, { x: 0.75, y: -0.43 }, eggWidest),
+  ...sampleCubic(eggWidest, { x: 0.77, y: 0.6 }, { x: 0.42, y: 0.96 }, eggBottom),
+  eggBottom
+];
+var eggOutline = [
+  ...eggRight,
+  ...eggRight.slice(1, -1).reverse().map((point) => ({ x: -point.x, y: point.y }))
+];
+var egg = normalizeProfile(
+  profileFromPolygon(PROFILE_SAMPLES, eggOutline),
+  1.04
+);
+var smoothCircularProfile = (radii, passes = 2) => {
+  let current = [...radii];
+  for (let pass = 0; pass < passes; pass += 1) {
+    current = current.map((radius, index) => {
+      const before = current[(index - 1 + current.length) % current.length];
+      const after = current[(index + 1) % current.length];
+      return before * 0.2 + radius * 0.6 + after * 0.2;
+    });
+  }
+  return current;
+};
+var eary = normalizeProfile(
+  smoothCircularProfile(profileFromPolygon(PROFILE_SAMPLES, [
+    { x: 0, y: -0.56 },
+    { x: 0.25, y: -0.58 },
+    { x: 0.68, y: -0.98 },
+    { x: 0.84, y: -0.3 },
+    { x: 0.86, y: 0.28 },
+    { x: 0.68, y: 0.66 },
+    { x: 0, y: 0.86 },
+    { x: -0.68, y: 0.66 },
+    { x: -0.86, y: 0.28 },
+    { x: -0.84, y: -0.3 },
+    { x: -0.68, y: -0.98 },
+    { x: -0.25, y: -0.58 }
+  ]), 1),
+  1.04
+);
+var puff = normalizeProfile(
+  smoothCircularProfile(unionOfCirclesProfile(PROFILE_SAMPLES, [
+    { x: 0, y: -0.1, radius: 0.75 },
+    { x: -0.62, y: 0.3, radius: 0.38 },
+    { x: 0.62, y: 0.3, radius: 0.38 },
+    { x: 0, y: 0.2, radius: 0.66 }
+  ]), 1),
+  1.04
+);
+var orb = new Array(PROFILE_SAMPLES).fill(0.99);
+var rolePolygon = (points, minimum = 0.5, maximum = 1.05) => normalizeProfile(
+  smoothCircularProfile(
+    profileFromPolygon(PROFILE_SAMPLES, points).map((radius) => Math.max(minimum, radius))
+  ),
+  maximum
+);
+var bolt = rolePolygon([
+  { x: -0.18, y: -1 },
+  { x: 0.58, y: -1 },
+  { x: 0.22, y: -0.25 },
+  { x: 0.92, y: -0.25 },
+  { x: -0.52, y: 1 },
+  { x: -0.26, y: 0.18 },
+  { x: -0.92, y: 0.18 }
+], 0.56, 1.08);
+var briefcase = rolePolygon([
+  { x: -0.94, y: -0.48 },
+  { x: -0.38, y: -0.48 },
+  { x: -0.38, y: -0.82 },
+  { x: 0.38, y: -0.82 },
+  { x: 0.38, y: -0.48 },
+  { x: 0.94, y: -0.48 },
+  { x: 0.94, y: 0.78 },
+  { x: -0.94, y: 0.78 }
+], 0.58, 1.04);
+var chart = rolePolygon([
+  { x: -0.92, y: 0.84 },
+  { x: -0.92, y: 0.12 },
+  { x: -0.42, y: 0.12 },
+  { x: -0.42, y: -0.3 },
+  { x: 0.08, y: -0.3 },
+  { x: 0.08, y: -0.78 },
+  { x: 0.66, y: -0.78 },
+  { x: 0.66, y: 0.84 }
+], 0.52, 1.04);
+var support = rolePolygon([
+  { x: -0.94, y: -0.76 },
+  { x: 0.94, y: -0.76 },
+  { x: 0.94, y: 0.48 },
+  { x: 0.28, y: 0.48 },
+  { x: 0, y: 0.94 },
+  { x: -0.26, y: 0.48 },
+  { x: -0.94, y: 0.48 }
+], 0.58, 1.04);
+var spark = rolePolygon([
+  { x: 0, y: -1.02 },
+  { x: 0.25, y: -0.4 },
+  { x: 0.92, y: -0.34 },
+  { x: 0.42, y: 0.1 },
+  { x: 0.58, y: 0.8 },
+  { x: 0, y: 0.46 },
+  { x: -0.58, y: 0.8 },
+  { x: -0.42, y: 0.1 },
+  { x: -0.92, y: -0.34 },
+  { x: -0.25, y: -0.4 }
+], 0.58, 1.04);
+var roundedRectPath = (x, y, width, height, radius) => {
+  const right = x + width;
+  const bottom = y + height;
+  return `M${x + radius} ${y}H${right - radius}Q${right} ${y} ${right} ${y + radius}V${bottom - radius}Q${right} ${bottom} ${right - radius} ${bottom}H${x + radius}Q${x} ${bottom} ${x} ${bottom - radius}V${y + radius}Q${x} ${y} ${x + radius} ${y}Z`;
+};
+var ROLE_PATHS = {
+  bolt: "M154 38Q164 34 159 48L143 94Q141 101 149 101H194Q210 101 199 113L109 211Q98 223 102 206L118 157Q121 149 111 149H62Q46 149 57 137L143 43Q148 38 154 38Z",
+  briefcase: `${roundedRectPath(42, 82, 172, 126, 26)}M78 82V70Q78 45 104 45H152Q178 45 178 70V82H157V70Q157 65 151 65H105Q99 65 99 70V82Z`,
+  chart: "M62 207Q45 207 45 190V151Q45 137 59 137H96V105Q96 91 110 91H151V59Q151 45 165 45H194Q208 45 208 59V190Q208 207 191 207Z",
+  support: "M63 48H193Q216 48 216 72V149Q216 173 192 173H167L138 201Q127 211 126 196V173H63Q39 173 39 149V72Q39 48 63 48Z",
+  spark: "M122 42Q128 27 134 42L151 83Q154 90 162 90L205 91Q221 91 209 103L176 132Q170 138 173 146L184 187Q188 202 175 194L136 171Q128 166 120 171L81 194Q68 202 72 187L83 146Q86 138 80 132L47 103Q35 91 51 91L94 90Q102 90 105 83Z"
+};
+var ROLE_LAYERS = {
+  bolt: [
+    { path: "M154 38Q164 34 159 48L143 94Q141 101 149 101H162L118 149H62Q46 149 57 137L143 43Q148 38 154 38Z", tone: "highlight", opacity: 0.14 },
+    { path: "M118 157Q121 149 111 149H144L199 113Q210 101 194 101H149L137 149L109 211Q98 223 102 206Z", tone: "shade", opacity: 0.12 }
+  ],
+  briefcase: [
+    { path: "M42 106Q42 82 66 82H190Q214 82 214 106V119Q176 142 128 142Q80 142 42 119Z", tone: "highlight", opacity: 0.18 },
+    { path: "M42 181Q80 198 128 198Q176 198 214 181V184Q214 208 190 208H66Q42 208 42 184Z", tone: "shade", opacity: 0.09 }
+  ],
+  chart: [
+    { path: "M45 151Q45 137 59 137H96V190Q96 207 79 207H62Q45 207 45 190Z", tone: "highlight", opacity: 0.24 },
+    { path: "M151 59Q151 45 165 45H194Q208 45 208 59V190Q208 207 191 207H151Z", tone: "shade", opacity: 0.12 }
+  ],
+  support: [
+    { path: "M63 48H193Q216 48 216 72V88H39V72Q39 48 63 48Z", tone: "highlight", opacity: 0.24 },
+    { path: "M39 140Q84 158 128 158Q172 158 216 140V149Q216 173 192 173H167L138 201Q127 211 126 196V173H63Q39 173 39 149Z", tone: "shade", opacity: 0.14 }
+  ],
+  spark: [
+    { path: "M122 42Q128 27 134 42L151 83Q154 90 162 90L177 90L148 116Q141 122 144 132L155 182L136 171Q128 166 120 171L81 194Q68 202 72 187L83 146Q86 138 80 132L47 103Q35 91 51 91L94 90Q102 90 105 83Z", tone: "highlight", opacity: 0.3 },
+    { path: "M148 116L177 90L205 91Q221 91 209 103L176 132Q170 138 173 146L184 187Q188 202 175 194L155 182L144 132Q141 122 148 116Z", tone: "shade", opacity: 0.22 }
+  ]
+};
+var AVATAR_SHAPES = [
+  {
+    id: "round",
+    name: "Round",
+    description: "Balanced and open",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: round,
+    face: { x: 56, y: 70, width: 144, height: 116, radius: 32 }
+  },
+  {
+    id: "pebble",
+    name: "Pebble",
+    description: "Quietly organic",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: pebble,
+    face: { x: 56, y: 70, width: 144, height: 116, radius: 32 }
+  },
+  {
+    id: "squircle",
+    name: "Squircle",
+    description: "Precise and neutral",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: squircle,
+    face: { x: 54, y: 68, width: 148, height: 120, radius: 30 }
+  },
+  {
+    id: "capsule",
+    name: "Capsule",
+    description: "Wide and operational",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: capsule,
+    face: { x: 58, y: 78, width: 140, height: 100, radius: 28 }
+  },
+  {
+    id: "triangle",
+    name: "Triangle",
+    description: "Directional and clear",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: triangle,
+    face: { x: 73, y: 96, width: 110, height: 94, radius: 25 }
+  },
+  {
+    id: "hexagon",
+    name: "Hexagon",
+    description: "Structured and assured",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: hexagon,
+    face: { x: 59, y: 78, width: 138, height: 104, radius: 27 }
+  },
+  {
+    id: "cloud",
+    name: "Cloud",
+    description: "Flexible and collaborative",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: cloud,
+    face: { x: 60, y: 88, width: 136, height: 100, radius: 30 }
+  },
+  {
+    id: "egg",
+    name: "Egg",
+    description: "Warm and composed",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: egg,
+    face: { x: 68, y: 78, width: 120, height: 106, radius: 30 }
+  },
+  {
+    id: "eary",
+    name: "Eary",
+    description: "Curious and observant",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 0.12,
+    radii: eary,
+    face: { x: 62, y: 82, width: 132, height: 104, radius: 30 }
+  },
+  {
+    id: "puff",
+    name: "Puff",
+    description: "Soft and easygoing",
+    family: "core",
+    faceStyle: "monitor",
+    pathTension: 1 / 6,
+    radii: puff,
+    face: { x: 59, y: 76, width: 138, height: 110, radius: 31 }
+  },
+  {
+    id: "orb",
+    name: "Orb",
+    description: "Ambient and responsive",
+    family: "orb",
+    faceStyle: "open",
+    pathTension: 1 / 6,
+    radii: orb,
+    face: { x: 70, y: 84, width: 116, height: 88, radius: 40 }
+  },
+  {
+    id: "bolt",
+    name: "Bolt",
+    description: "Automation and action",
+    family: "role",
+    role: "Automation",
+    referenceIcon: "bolt",
+    faceStyle: "open",
+    pathTension: 0.06,
+    opticalScale: 1.2,
+    restPath: ROLE_PATHS.bolt,
+    layers: ROLE_LAYERS.bolt,
+    radii: bolt,
+    face: { x: 82, y: 98, width: 92, height: 62, radius: 20 }
+  },
+  {
+    id: "briefcase",
+    name: "Briefcase",
+    description: "Business operations",
+    family: "role",
+    role: "Business",
+    referenceIcon: "suitcase-work",
+    faceStyle: "open",
+    pathTension: 0.06,
+    opticalScale: 1.2,
+    restPath: ROLE_PATHS.briefcase,
+    layers: ROLE_LAYERS.briefcase,
+    radii: briefcase,
+    face: { x: 78, y: 108, width: 100, height: 66, radius: 20 }
+  },
+  {
+    id: "chart",
+    name: "Chart",
+    description: "Analytics and reporting",
+    family: "role",
+    role: "Analytics",
+    referenceIcon: "chart-3",
+    faceStyle: "open",
+    pathTension: 0.06,
+    opticalScale: 1.26,
+    restPath: ROLE_PATHS.chart,
+    layers: ROLE_LAYERS.chart,
+    radii: chart,
+    face: { x: 62, y: 125, width: 112, height: 62, radius: 20 }
+  },
+  {
+    id: "support",
+    name: "Support",
+    description: "Customer service",
+    family: "role",
+    role: "Customer Support",
+    referenceIcon: "bubble-wide",
+    faceStyle: "open",
+    pathTension: 0.06,
+    opticalScale: 1.16,
+    restPath: ROLE_PATHS.support,
+    layers: ROLE_LAYERS.support,
+    radii: support,
+    face: { x: 73, y: 80, width: 110, height: 70, radius: 20 }
+  },
+  {
+    id: "spark",
+    name: "Spark",
+    description: "Initiative and outreach",
+    family: "role",
+    role: "Outreach",
+    referenceIcon: "star",
+    faceStyle: "open",
+    pathTension: 0.06,
+    opticalScale: 1.27,
+    restPath: ROLE_PATHS.spark,
+    layers: ROLE_LAYERS.spark,
+    radii: spark,
+    face: { x: 82, y: 97, width: 92, height: 62, radius: 20 }
+  }
+];
+var AVATAR_SHAPE_BY_ID = new Map(AVATAR_SHAPES.map((shape) => [shape.id, shape]));
+var AVATAR_FACE_COLORS = {
+  light: { face: "#F7F3E8", eyes: "#202228" },
+  dark: { face: "#6B6E78", eyes: "#202228" }
+};
+var AVATAR_EYE_SCALE = {
+  small: 0.5,
+  normal: 0.64,
+  large: 0.82
+};
+var DEFAULT_IDENTITY = {
+  color: "#3B93F0"};
+function normalizeColor(value) {
+  const compact = value.trim();
+  const short = /^#([0-9a-f]{3})$/i.exec(compact);
+  if (short) {
+    const [red, green, blue] = short[1].split("");
+    return `#${red}${red}${green}${green}${blue}${blue}`.toUpperCase();
+  }
+  if (!/^#[0-9a-f]{6}$/i.test(compact)) return null;
+  return compact.toUpperCase();
+}
+function relativeLuminance(hex) {
+  const normalized = normalizeColor(hex) ?? DEFAULT_IDENTITY.color;
+  const channels = [1, 3, 5].map((index) => {
+    const value = Number.parseInt(normalized.slice(index, index + 2), 16) / 255;
+    return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  });
+  return channels[0] * 0.2126 + channels[1] * 0.7152 + channels[2] * 0.0722;
+}
+function contrastRatio(first, second) {
+  const light = Math.max(relativeLuminance(first), relativeLuminance(second));
+  const dark = Math.min(relativeLuminance(first), relativeLuminance(second));
+  return (light + 0.05) / (dark + 0.05);
+}
+function resolveOpenEyeColor(_housingColor) {
+  return AVATAR_FACE_COLORS.light.eyes;
+}
+function resolveEyeColorOnBody(bodyColor) {
+  const dark = AVATAR_FACE_COLORS.light.eyes;
+  const light = AVATAR_FACE_COLORS.light.face;
+  return contrastRatio(bodyColor, dark) >= contrastRatio(bodyColor, light) ? dark : light;
+}
+function resolveFaceColors(housingColor, preference) {
+  let tone;
+  if (preference === "auto") {
+    const lightContrast = contrastRatio(housingColor, AVATAR_FACE_COLORS.light.face);
+    const darkContrast = contrastRatio(housingColor, AVATAR_FACE_COLORS.dark.face);
+    tone = lightContrast >= 2.25 || lightContrast >= darkContrast ? "light" : "dark";
+  } else {
+    tone = preference;
+  }
+  return { tone, ...AVATAR_FACE_COLORS[tone] };
+}
+
+// src/vendor/ui/agent-avatar/lab/motion.ts
+var BLINK_RNG = createRng(24301);
+var BLINKS = (() => {
+  const schedule = [];
+  let time = 1.4;
+  while (time < 900) {
+    schedule.push(time);
+    time += 1.9 + BLINK_RNG() * 2.7;
+    if (BLINK_RNG() < 0.18) {
+      schedule.push(time);
+      time += 0.24;
+    }
+  }
+  return schedule;
+})();
+var BLINK_DURATION = 0.18;
+function blinkOpenness(time, _motionKey = "frontera") {
+  const wrapped = (time % 900 + 900) % 900;
+  for (const start of BLINKS) {
+    if (wrapped < start) break;
+    const progress = (wrapped - start) / BLINK_DURATION;
+    if (progress >= 0 && progress <= 1) {
+      const lid = progress < 0.45 ? 1 - progress / 0.45 : (progress - 0.45) / 0.55;
+      return 0.06 + 0.94 * clamp(lid);
+    }
+  }
+  return 1;
+}
+var eye2 = (width, height, tilt = 0, open = 1) => ({
+  width,
+  height,
+  tilt,
+  open
+});
+var stateExpression = (separation, gaze, eyes) => ({
+  id: "neutral",
+  name: "State pose",
+  description: "Mapped from Bloub",
+  separation,
+  gaze,
+  eyes
+});
+var WIDE_EYES = stateExpression(
+  18.43,
+  { x: 0, y: 0 },
+  [eye2(0.356, 0.875), eye2(0.356, 0.875)]
+);
+var WINK_EYES = stateExpression(
+  16.25,
+  { x: 0, y: 0 },
+  [eye2(0.236, 0.464), eye2(0.447, 0.089)]
+);
+var still = () => ({
+  gazeX: 0,
+  gazeY: 0,
+  openness: 1,
+  scale: 1,
+  rotation: 0,
+  translateX: 0,
+  translateY: 0,
+  faceOpacity: 1,
+  eyeOpacity: 1,
+  bodyRadius: null,
+  eyeExpression: null
+});
+function sampleStateMotion(state, time, _motionKey) {
+  if (state === "paused") return still();
+  const blink = blinkOpenness(time);
+  const driftX = loopNoise(time, 7.9, 1.9) * 6e-3 * 104;
+  const driftY = loopNoise(time, 5.3, 0.3) * 7e-3 * 104;
+  const breath = 1 + Math.sin(time / 3.4 * Math.PI * 2) * 5e-3;
+  const wanderX = loopNoise(time, 11.3, 0.4) * 0.18 + loopNoise(time, 3.7, 2.1) * 0.053;
+  const wanderY = loopNoise(time, 9.1, 1.3) * 0.14 + loopNoise(time, 4.3, 0.7) * 0.043;
+  if (state === "attentive") {
+    return {
+      ...still(),
+      // Bloub `wide`: yaw 6.92, pitch -21.96, roll 11.6.
+      gazeX: 6.92 / 30 + wanderX,
+      gazeY: -21.96 / 30 + wanderY,
+      openness: blink,
+      rotation: 11.6 * Math.PI / 180,
+      translateX: driftX,
+      translateY: driftY,
+      scale: breath,
+      eyeExpression: WIDE_EYES
+    };
+  }
+  if (state === "working") {
+    const scan = Math.sin(time / 1.8 * TAU);
+    const lift = Math.cos(time / 1.8 * TAU);
+    return {
+      ...still(),
+      gazeX: scan * 0.6,
+      gazeY: lift * 0.12,
+      openness: blink,
+      rotation: scan * 0.035,
+      translateX: scan * 3.2,
+      translateY: lift * 1.4,
+      scale: 1 + lift * 6e-3
+    };
+  }
+  if (state === "responding") {
+    return {
+      ...still(),
+      // Bloub `wink`: yaw -5.37, pitch 4.55, roll 6.7.
+      gazeX: -5.37 / 30 + wanderX,
+      gazeY: 4.55 / 30 + wanderY,
+      openness: blink,
+      rotation: 6.7 * Math.PI / 180,
+      translateX: driftX,
+      translateY: driftY,
+      scale: breath,
+      eyeExpression: WINK_EYES
+    };
+  }
+  if (state === "waiting") {
+    const bounce = Math.abs(Math.sin(time / 1.2 * TAU));
+    const alternate = 0.5 + 0.5 * Math.sin(time / 1.2 * TAU);
+    const loadingEyes = stateExpression(
+      16,
+      { x: 0, y: -0.03 },
+      [
+        eye2(0.2, 0.42, 0, lerp(0.36, 1, alternate)),
+        eye2(0.2, 0.42, 0, lerp(1, 0.36, alternate))
+      ]
+    );
+    return {
+      ...still(),
+      openness: blink,
+      rotation: Math.sin(time / 2.4 * TAU) * 0.02,
+      translateY: -bounce * 8,
+      scale: 1 + bounce * 0.012,
+      eyeExpression: loadingEyes
+    };
+  }
+  return {
+    ...still(),
+    gazeX: wanderX,
+    gazeY: wanderY,
+    openness: blink,
+    scale: breath,
+    translateX: driftX,
+    translateY: driftY
+  };
+}
+function blendMotion(from, to, progress) {
+  const mix = clamp(progress);
+  return {
+    gazeX: lerp(from.gazeX, to.gazeX, mix),
+    gazeY: lerp(from.gazeY, to.gazeY, mix),
+    openness: lerp(from.openness, to.openness, mix),
+    scale: lerp(from.scale, to.scale, mix),
+    rotation: lerp(from.rotation, to.rotation, mix),
+    translateX: lerp(from.translateX, to.translateX, mix),
+    translateY: lerp(from.translateY, to.translateY, mix),
+    faceOpacity: lerp(from.faceOpacity, to.faceOpacity, mix),
+    eyeOpacity: lerp(from.eyeOpacity, to.eyeOpacity, mix),
+    bodyRadius: to.bodyRadius,
+    eyeExpression: to.eyeExpression
+  };
+}
+
+// src/vendor/ui/agent-avatar/lab/engine.ts
+var ROLE_EYE_SCALE = 1.35;
+function sampleAvatarFrame({
+  shape: shapeId,
+  state,
+  time,
+  seed = "frontera",
+  gaze,
+  previousState,
+  transition = 1,
+  profile,
+  face: faceOverride,
+  expression = "neutral",
+  eyeSize = "normal"
+}) {
+  const shape = AVATAR_SHAPE_BY_ID.get(shapeId) ?? AVATAR_SHAPE_BY_ID.get("squircle");
+  const face = faceOverride ?? shape.face;
+  const current = sampleStateMotion(state, state === "paused" ? 0 : time);
+  const previous = previousState ? sampleStateMotion(previousState, state === "paused" ? 0 : time) : current;
+  const stateMix = clamp(transition);
+  const motion = blendMotion(previous, current, stateMix);
+  const externalGaze = gaze ? clampGaze(gaze) : null;
+  const resolvedGaze = externalGaze?.active ? externalGaze : { x: motion.gazeX, y: motion.gazeY, active: false };
+  const identityProfile = profile ?? shape.radii;
+  const profileFor = (radius) => radius === null ? identityProfile : new Array(PROFILE_SAMPLES).fill(radius);
+  const bodyProfile = blendProfiles(
+    profileFor(previous.bodyRadius),
+    profileFor(current.bodyRadius),
+    stateMix
+  );
+  const selectedExpression = EYE_EXPRESSION_BY_ID.get(expression) ?? EYE_EXPRESSION_BY_ID.get("neutral");
+  const fromExpression = previous.eyeExpression ?? selectedExpression;
+  const toExpression = current.eyeExpression ?? selectedExpression;
+  const resolvedExpression = blendEyeExpressions(fromExpression, toExpression, stateMix);
+  const usesAuthoredShape = Boolean(shape.restPath);
+  return {
+    bodyPath: usesAuthoredShape && shape.restPath ? shape.restPath : profilePath(bodyProfile, {}, shape.pathTension),
+    body: {
+      scale: motion.scale,
+      rotation: motion.rotation,
+      translateX: motion.translateX,
+      translateY: motion.translateY
+    },
+    face,
+    faceOpacity: motion.faceOpacity,
+    eyeOpacity: motion.eyeOpacity,
+    eyes: eyePair(
+      face,
+      resolvedGaze,
+      motion.openness,
+      state,
+      resolvedExpression,
+      AVATAR_EYE_SCALE[eyeSize] * (shape.faceStyle === "open" ? ROLE_EYE_SCALE : 1)
+    ),
+    gaze: clampGaze(resolvedGaze),
+    usesAuthoredShape
+  };
+}
+var BOX_FRAME = { x: 22, y: 22, size: 212, radius: 48 };
+function mixHexColor(hex, target, amount) {
+  const digits = hex.replace("#", "");
+  const full = digits.length === 3 ? digits.split("").map((d) => d + d).join("") : digits;
+  const value = Number.parseInt(full, 16);
+  const channels = [value >> 16 & 255, value >> 8 & 255, value & 255];
+  const mixed = channels.map(
+    (channel) => Math.round(channel + (target * 255 - channel) * amount).toString(16).padStart(2, "0")
+  );
+  return `#${mixed.join("")}`;
+}
+function glassGradientIds(instanceId) {
+  const prefix = `frontera-glass-${instanceId}`;
+  return {
+    backdrop: `${prefix}-backdrop`,
+    rim: `${prefix}-rim`,
+    innerBevel: `${prefix}-bevel`,
+    surfaceGlare: `${prefix}-glare`,
+    screenReflection: `${prefix}-refl`,
+    microGrain: `${prefix}-grain`
+  };
+}
+function GlassDefs({ ids }) {
+  return /* @__PURE__ */ jsxs("defs", { children: [
+    /* @__PURE__ */ jsxs("linearGradient", { id: ids.backdrop, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "#FFFFFF", stopOpacity: "0.055" }),
+      /* @__PURE__ */ jsx("stop", { offset: "55%", stopColor: "#FFFFFF", stopOpacity: "0.012" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "#000000", stopOpacity: "0.03" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: ids.rim, x1: "0", y1: "0", x2: "1", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "#FFFFFF", stopOpacity: "0.8" }),
+      /* @__PURE__ */ jsx("stop", { offset: "30%", stopColor: "#FFFFFF", stopOpacity: "0.35" }),
+      /* @__PURE__ */ jsx("stop", { offset: "70%", stopColor: "#FFFFFF", stopOpacity: "0.1" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "#FFFFFF", stopOpacity: "0.28" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: ids.innerBevel, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "#FFFFFF", stopOpacity: "0.45" }),
+      /* @__PURE__ */ jsx("stop", { offset: "40%", stopColor: "#FFFFFF", stopOpacity: "0.1" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "#000000", stopOpacity: "0.08" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: ids.surfaceGlare, x1: "0.1", y1: "0", x2: "0.85", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "#FFFFFF", stopOpacity: "0.12" }),
+      /* @__PURE__ */ jsx("stop", { offset: "25%", stopColor: "#FFFFFF", stopOpacity: "0.04" }),
+      /* @__PURE__ */ jsx("stop", { offset: "48%", stopColor: "#FFFFFF", stopOpacity: "0.005" }),
+      /* @__PURE__ */ jsx("stop", { offset: "70%", stopColor: "#FFFFFF", stopOpacity: "0" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: ids.screenReflection, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "#FFFFFF", stopOpacity: "0.15" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "#FFFFFF", stopOpacity: "0" })
+    ] }),
+    /* @__PURE__ */ jsxs("filter", { id: ids.microGrain, x: "0%", y: "0%", width: "100%", height: "100%", children: [
+      /* @__PURE__ */ jsx(
+        "feTurbulence",
+        {
+          type: "fractalNoise",
+          baseFrequency: "0.8",
+          numOctaves: "2",
+          stitchTiles: "stitch",
+          result: "noise"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "feColorMatrix",
+        {
+          type: "matrix",
+          values: "0 0 0 0 1\n                  0 0 0 0 1\n                  0 0 0 0 1\n                  0.4 0 0 0 0"
+        }
+      )
+    ] })
+  ] });
+}
+function GlassBackdrop({ ids }) {
+  return /* @__PURE__ */ jsxs("g", { children: [
+    /* @__PURE__ */ jsx(
+      "rect",
+      {
+        "data-avatar-glass": true,
+        "data-avatar-enclosure": "",
+        x: BOX_FRAME.x,
+        y: BOX_FRAME.y,
+        width: BOX_FRAME.size,
+        height: BOX_FRAME.size,
+        rx: BOX_FRAME.radius,
+        fill: `url(#${ids.backdrop})`,
+        stroke: `url(#${ids.rim})`,
+        strokeWidth: "2"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "rect",
+      {
+        "data-avatar-glass": true,
+        "data-avatar-enclosure-pane": "",
+        x: BOX_FRAME.x + 3,
+        y: BOX_FRAME.y + 3,
+        width: BOX_FRAME.size - 6,
+        height: BOX_FRAME.size - 6,
+        rx: BOX_FRAME.radius - 3,
+        fill: "none",
+        stroke: `url(#${ids.innerBevel})`,
+        strokeWidth: "1.2"
+      }
+    )
+  ] });
+}
+function GlassBackground({ ids, color }) {
+  const baseId = `${ids.backdrop}-base`;
+  const glowId = `${ids.backdrop}-glow`;
+  const glowTint = mixHexColor(color, 1, 0.55);
+  return /* @__PURE__ */ jsxs("g", { children: [
+    /* @__PURE__ */ jsxs("defs", { children: [
+      /* @__PURE__ */ jsxs("linearGradient", { id: baseId, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+        /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: mixHexColor(color, 0, 0.34) }),
+        /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: mixHexColor(color, 0, 0.54) })
+      ] }),
+      /* @__PURE__ */ jsxs(
+        "linearGradient",
+        {
+          id: glowId,
+          gradientUnits: "userSpaceOnUse",
+          x1: "0",
+          y1: "86",
+          x2: "0",
+          y2: "234",
+          children: [
+            /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: glowTint, stopOpacity: "0" }),
+            /* @__PURE__ */ jsx("stop", { offset: "45%", stopColor: glowTint, stopOpacity: "0.07" }),
+            /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: glowTint, stopOpacity: "0.15" })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      "rect",
+      {
+        "data-avatar-glass": true,
+        "data-avatar-enclosure-background": "",
+        x: BOX_FRAME.x,
+        y: BOX_FRAME.y,
+        width: BOX_FRAME.size,
+        height: BOX_FRAME.size,
+        rx: BOX_FRAME.radius,
+        opacity: "0.065",
+        fill: `url(#${baseId})`
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        "data-avatar-glass": true,
+        "data-avatar-enclosure-glow": "",
+        d: "M22 132C50 102 86 86 128 86C170 86 206 102 234 132V186C234 212.5 212.5 234 186 234H70C43.5 234 22 212.5 22 186Z",
+        fill: `url(#${glowId})`
+      }
+    )
+  ] });
+}
+function GlassOverlay({ ids }) {
+  return /* @__PURE__ */ jsxs("g", { children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        "data-avatar-glass": true,
+        "data-avatar-enclosure-reflection": "",
+        d: "M22 60C22 38 38 22 60 22H196C218 22 234 38 234 60C234 76 180 88 128 88C76 88 22 76 22 60Z",
+        fill: `url(#${ids.screenReflection})`
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        "data-avatar-glass": true,
+        "data-avatar-enclosure-shine": "",
+        d: "M22 22H140L234 160V234H180L22 76Z",
+        fill: `url(#${ids.surfaceGlare})`
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        "data-avatar-glass": true,
+        "data-avatar-enclosure-glint": "",
+        d: "M30 78C30 52 52 30 78 30",
+        fill: "none",
+        stroke: "#FFFFFF",
+        strokeOpacity: "0.7",
+        strokeWidth: "3",
+        strokeLinecap: "round"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        "data-avatar-glass": true,
+        d: "M86 30H112",
+        fill: "none",
+        stroke: "#FFFFFF",
+        strokeOpacity: "0.35",
+        strokeWidth: "1.8",
+        strokeLinecap: "round"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "rect",
+      {
+        "data-avatar-glass": true,
+        "data-avatar-enclosure-grain": "",
+        x: BOX_FRAME.x,
+        y: BOX_FRAME.y,
+        width: BOX_FRAME.size,
+        height: BOX_FRAME.size,
+        opacity: "0.12",
+        filter: `url(#${ids.microGrain})`,
+        style: { mixBlendMode: "screen" }
+      }
+    )
+  ] });
+}
+var ORB_FRAME = { cx: 128, cy: 128, radius: 106 };
+var ORB_ENERGY = {
+  paused: 0,
+  idle: 0.28,
+  attentive: 0.5,
+  working: 0.7,
+  responding: 0.95,
+  waiting: 0.78
+};
+function mixHexColor2(hex, target, amount) {
+  const digits = hex.replace("#", "");
+  const full = digits.length === 3 ? digits.split("").map((digit) => digit + digit).join("") : digits;
+  const value = Number.parseInt(full, 16);
+  const channels = [value >> 16 & 255, value >> 8 & 255, value & 255];
+  const mixed = channels.map(
+    (channel) => Math.round(channel + (target * 255 - channel) * amount).toString(16).padStart(2, "0")
+  );
+  return `#${mixed.join("")}`;
+}
+function blendHexColors(first, second, amount) {
+  const toChannels = (hex) => {
+    const value = Number.parseInt(hex.replace("#", ""), 16);
+    return [value >> 16 & 255, value >> 8 & 255, value & 255];
+  };
+  const from = toChannels(first);
+  const to = toChannels(second);
+  return `#${from.map(
+    (channel, index) => Math.round(channel + (to[index] - channel) * amount).toString(16).padStart(2, "0")
+  ).join("")}`;
+}
+function orbGradientIds(instanceId) {
+  const prefix = `frontera-orb-${instanceId}`;
+  return {
+    rim: `${prefix}-rim`,
+    specular: `${prefix}-specular`,
+    sheen: `${prefix}-sheen`,
+    diffusion: `${prefix}-diffusion`
+  };
+}
+function sampleOrbPresence(state, time, reducedMotion = false) {
+  const energy = ORB_ENERGY[state];
+  const wave = reducedMotion ? 0 : 0.5 + 0.5 * Math.sin(time * Math.PI * 1.25);
+  return {
+    scale: 1,
+    lightOpacity: 0.15 + energy * 0.18 + wave * 0.05,
+    coreOpacity: 0.22 + energy * 0.18 + wave * 0.04,
+    fieldOpacity: 0.2 + energy * 0.24 + wave * 0.08
+  };
+}
+function OrbDefs({ ids }) {
+  return /* @__PURE__ */ jsxs("defs", { children: [
+    /* @__PURE__ */ jsxs("linearGradient", { id: ids.rim, x1: "0", y1: "0", x2: "1", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "#FFFFFF", stopOpacity: "0.78" }),
+      /* @__PURE__ */ jsx("stop", { offset: "30%", stopColor: "#FFFFFF", stopOpacity: "0.28" }),
+      /* @__PURE__ */ jsx("stop", { offset: "72%", stopColor: "#FFFFFF", stopOpacity: "0.05" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "#000000", stopOpacity: "0.24" })
+    ] }),
+    /* @__PURE__ */ jsxs("radialGradient", { id: ids.specular, cx: "32%", cy: "24%", r: "72%", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "#FFFFFF", stopOpacity: "0.68" }),
+      /* @__PURE__ */ jsx("stop", { offset: "38%", stopColor: "#FFFFFF", stopOpacity: "0.12" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "#FFFFFF", stopOpacity: "0" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: ids.sheen, x1: "0.18", y1: "0", x2: "0.82", y2: "1", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: "#FFFFFF", stopOpacity: "0.22" }),
+      /* @__PURE__ */ jsx("stop", { offset: "42%", stopColor: "#FFFFFF", stopOpacity: "0.035" }),
+      /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: "#FFFFFF", stopOpacity: "0" })
+    ] }),
+    /* @__PURE__ */ jsx("filter", { id: ids.diffusion, x: "-28%", y: "-28%", width: "156%", height: "156%", children: /* @__PURE__ */ jsx("feGaussianBlur", { stdDeviation: "15" }) })
+  ] });
+}
+function OrbBackdrop({
+  ids,
+  color,
+  state,
+  time,
+  reducedMotion
+}) {
+  const bodyId = `${ids.rim}-body`;
+  const coreId = `${ids.rim}-core`;
+  const presence = sampleOrbPresence(state, time, reducedMotion);
+  const light = mixHexColor2(color, 1, 0.42);
+  const base = mixHexColor2(color, 0, 0.1);
+  const edge = mixHexColor2(color, 0, 0.5);
+  const cool = blendHexColors(color, "#645CFF", 0.42);
+  const warm = blendHexColors(color, "#FF8A5C", 0.35);
+  const aura = blendHexColors(color, "#67DBFF", 0.28);
+  const clipId = `${ids.rim}-clip`;
+  return /* @__PURE__ */ jsxs(
+    "g",
+    {
+      "data-avatar-orb": "",
+      transform: `translate(128 128) scale(${presence.scale}) translate(-128 -128)`,
+      children: [
+        /* @__PURE__ */ jsxs("defs", { children: [
+          /* @__PURE__ */ jsx("clipPath", { id: clipId, children: /* @__PURE__ */ jsx("circle", { cx: ORB_FRAME.cx, cy: ORB_FRAME.cy, r: ORB_FRAME.radius - 1 }) }),
+          /* @__PURE__ */ jsxs("radialGradient", { id: bodyId, cx: "31%", cy: "24%", r: "84%", children: [
+            /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: light }),
+            /* @__PURE__ */ jsx("stop", { offset: "34%", stopColor: base }),
+            /* @__PURE__ */ jsx("stop", { offset: "76%", stopColor: mixHexColor2(color, 0, 0.25) }),
+            /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: edge })
+          ] }),
+          /* @__PURE__ */ jsxs("radialGradient", { id: coreId, cx: "50%", cy: "46%", r: "58%", children: [
+            /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: blendHexColors(light, aura, 0.4), stopOpacity: "0.92" }),
+            /* @__PURE__ */ jsx("stop", { offset: "54%", stopColor: light, stopOpacity: "0.26" }),
+            /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: light, stopOpacity: "0" })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            cx: ORB_FRAME.cx,
+            cy: ORB_FRAME.cy,
+            r: ORB_FRAME.radius,
+            fill: `url(#${bodyId})`
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "g",
+          {
+            "data-avatar-orb-field": "",
+            clipPath: `url(#${clipId})`,
+            filter: `url(#${ids.diffusion})`,
+            opacity: presence.fieldOpacity,
+            children: [
+              /* @__PURE__ */ jsx("ellipse", { cx: "84", cy: "92", rx: "48", ry: "42", fill: aura }),
+              /* @__PURE__ */ jsx("ellipse", { cx: "168", cy: "126", rx: "62", ry: "48", fill: warm }),
+              /* @__PURE__ */ jsx("ellipse", { cx: "126", cy: "184", rx: "58", ry: "42", fill: cool })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            "data-avatar-orb-core": "",
+            cx: ORB_FRAME.cx,
+            cy: ORB_FRAME.cy + 8,
+            r: ORB_FRAME.radius * 0.78,
+            fill: `url(#${coreId})`,
+            opacity: presence.coreOpacity
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            "data-avatar-orb-light": "",
+            cx: ORB_FRAME.cx,
+            cy: ORB_FRAME.cy,
+            r: ORB_FRAME.radius - 6,
+            fill: `url(#${ids.specular})`,
+            opacity: presence.lightOpacity
+          }
+        )
+      ]
+    }
+  );
+}
+var ORB_DIAMETER = 212;
+var VERTEX_SHADER = `
+attribute vec2 a_position;
+
+void main() {
+  gl_Position = vec4(a_position, 0.0, 1.0);
+}
+`;
+var FRAGMENT_SHADER = `
+precision highp float;
+
+uniform vec2 u_resolution;
+uniform float u_time;
+uniform float u_activity;
+uniform vec3 u_primary;
+
+float hash(vec2 p) {
+  p = fract(p * vec2(123.34, 456.21));
+  p += dot(p, p + 45.32);
+  return fract(p.x * p.y);
+}
+
+float noise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(hash(i), hash(i + vec2(1.0, 0.0)), u.x),
+    mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), u.x),
+    u.y
+  );
+}
+
+float fbm(vec2 p) {
+  float value = 0.0;
+  float amplitude = 0.52;
+  mat2 rotation = mat2(0.80, 0.60, -0.60, 0.80);
+  for (int octave = 0; octave < 5; octave++) {
+    value += amplitude * noise(p);
+    p = rotation * p * 1.92 + vec2(9.7, 4.3);
+    amplitude *= 0.5;
+  }
+  return value;
+}
+
+void main() {
+  vec2 uv = gl_FragCoord.xy / u_resolution;
+  vec2 centered = uv - 0.5;
+  vec2 p = centered * 2.0;
+  float t = u_time;
+  vec2 warp = vec2(
+    fbm(p * 1.02 + vec2(t * 0.34, -t * 0.24)),
+    fbm(p * 1.08 + vec2(-t * 0.27, t * 0.32) + vec2(6.7, 2.9))
+  );
+  vec2 curl = vec2(
+    sin(p.y * 2.4 + t * 0.68 + warp.y * 3.2),
+    cos(p.x * 2.1 - t * 0.61 + warp.x * 3.0)
+  );
+  vec2 warped = p +
+    (warp - 0.5) * (1.18 + u_activity * 0.38) +
+    curl * (0.035 + u_activity * 0.07);
+  float broad = fbm(warped * 0.92 + vec2(t * 0.14, -t * 0.18));
+  float folded = fbm(warped * 1.66 + vec2(-t * 0.23, t * 0.19) + 5.2);
+  float field = mix(broad, folded, 0.3 + u_activity * 0.14);
+
+  float horizon = 0.46 +
+    0.08 * sin((uv.x + warp.x * 0.2) * 5.4 + t * 0.42) +
+    0.16 * (broad - 0.5);
+  float upper = smoothstep(horizon - 0.12, horizon + 0.08, uv.y);
+  float band = exp(-pow((uv.y - horizon) * (5.2 + u_activity * 0.8), 2.0));
+  float cloud = smoothstep(0.24, 0.79, field);
+
+  vec3 white = vec3(0.98, 0.985, 1.0);
+  vec3 deep = mix(vec3(0.36, 0.39, 0.985), u_primary, 0.84);
+  vec3 upperTint = mix(vec3(0.48, 0.56, 0.985), mix(u_primary, white, 0.34), 0.80);
+  vec3 lowerTint = mix(vec3(0.72, 0.78, 0.975), mix(u_primary, white, 0.78), 0.78);
+  vec3 color = mix(lowerTint, upperTint, upper);
+  float upperDepth = upper * (0.14 + smoothstep(0.42, 0.78, folded) * 0.5);
+  color = mix(color, deep, upperDepth);
+
+  float milkAmount = clamp(band * (0.42 + cloud * 0.62), 0.0, 0.88);
+  color = mix(color, white, milkAmount);
+  float lowerMist = (1.0 - upper) * smoothstep(0.58, 0.9, broad) * 0.18;
+  color = mix(color, white, lowerMist);
+  float grain = (noise(gl_FragCoord.xy * 0.64) - 0.5) / 255.0;
+  gl_FragColor = vec4(color + grain, 1.0);
+}
+`;
+function toOrbCloudState(state) {
+  if (state === "attentive") return "listening";
+  if (state === "working" || state === "responding") return "speaking";
+  if (state === "waiting") return "thinking";
+  return "idle";
+}
+function sampleOrbCloudMotion(state) {
+  if (state === "attentive") return { activity: 0.46, speed: 0.98 };
+  if (state === "working") return { activity: 0.86, speed: 2.72 };
+  if (state === "responding") return { activity: 0.62, speed: 1.4 };
+  if (state === "waiting") return { activity: 0.35, speed: 0.54 };
+  return { activity: 0.12, speed: 0.2 };
+}
+function parseHexColor(color) {
+  const source = color.replace("#", "");
+  const hex = source.length === 3 ? source.split("").map((channel) => channel + channel).join("") : source;
+  if (!/^[0-9a-f]{6}$/i.test(hex)) return [0.36, 0.39, 0.985];
+  const value = Number.parseInt(hex, 16);
+  return [(value >> 16) / 255, (value >> 8 & 255) / 255, (value & 255) / 255];
+}
+function compileShader(gl, type, source) {
+  const shader = gl.createShader(type);
+  if (!shader) return void 0;
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    gl.deleteShader(shader);
+    return void 0;
+  }
+  return shader;
+}
+function createCloudRenderer(canvas, color) {
+  let gl;
+  try {
+    gl = canvas.getContext("webgl", {
+      alpha: false,
+      antialias: true
+    });
+  } catch {
+    return void 0;
+  }
+  if (!gl) return void 0;
+  const vertexShader = compileShader(gl, gl.VERTEX_SHADER, VERTEX_SHADER);
+  const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, FRAGMENT_SHADER);
+  if (!vertexShader || !fragmentShader) {
+    if (vertexShader) gl.deleteShader(vertexShader);
+    if (fragmentShader) gl.deleteShader(fragmentShader);
+    return void 0;
+  }
+  const program = gl.createProgram();
+  const buffer = gl.createBuffer();
+  if (!program || !buffer) {
+    if (program) gl.deleteProgram(program);
+    if (buffer) gl.deleteBuffer(buffer);
+    gl.deleteShader(vertexShader);
+    gl.deleteShader(fragmentShader);
+    return void 0;
+  }
+  gl.attachShader(program, vertexShader);
+  gl.attachShader(program, fragmentShader);
+  gl.linkProgram(program);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    gl.deleteProgram(program);
+    gl.deleteBuffer(buffer);
+    gl.deleteShader(vertexShader);
+    gl.deleteShader(fragmentShader);
+    return void 0;
+  }
+  const position = gl.getAttribLocation(program, "a_position");
+  const resolution = gl.getUniformLocation(program, "u_resolution");
+  const time = gl.getUniformLocation(program, "u_time");
+  const activity = gl.getUniformLocation(program, "u_activity");
+  const primary = gl.getUniformLocation(program, "u_primary");
+  if (position < 0 || !resolution || !time || !activity || !primary) {
+    gl.deleteProgram(program);
+    gl.deleteBuffer(buffer);
+    gl.deleteShader(vertexShader);
+    gl.deleteShader(fragmentShader);
+    return void 0;
+  }
+  const pixelRatio = Math.min(window.devicePixelRatio || 1, 2);
+  const pixelSize = Math.max(1, Math.round(ORB_DIAMETER * pixelRatio));
+  canvas.width = pixelSize;
+  canvas.height = pixelSize;
+  gl.viewport(0, 0, pixelSize, pixelSize);
+  gl.useProgram(program);
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  gl.bufferData(
+    gl.ARRAY_BUFFER,
+    new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]),
+    gl.STATIC_DRAW
+  );
+  gl.enableVertexAttribArray(position);
+  gl.vertexAttribPointer(position, 2, gl.FLOAT, false, 0, 0);
+  gl.uniform2f(resolution, pixelSize, pixelSize);
+  gl.uniform3fv(primary, parseHexColor(color));
+  return {
+    draw(flowTime, flowActivity) {
+      gl.uniform1f(time, flowTime);
+      gl.uniform1f(activity, flowActivity);
+      gl.drawArrays(gl.TRIANGLES, 0, 6);
+    },
+    destroy() {
+      gl.deleteProgram(program);
+      gl.deleteBuffer(buffer);
+      gl.deleteShader(vertexShader);
+      gl.deleteShader(fragmentShader);
+      gl.getExtension("WEBGL_lose_context")?.loseContext();
+    }
+  };
+}
+function cloudFallback(color) {
+  return `radial-gradient(circle at 50% 47%, rgba(255,255,255,0.92) 0%, ${color} 42%, rgba(80, 88, 220, 0.9) 100%)`;
+}
+function paintCloudSnapshot(canvas, color, state) {
+  const source = document.createElement("canvas");
+  const renderer = createCloudRenderer(source, color);
+  if (!renderer) return false;
+  renderer.draw(0, sampleOrbCloudMotion(state).activity);
+  canvas.width = source.width;
+  canvas.height = source.height;
+  let context;
+  try {
+    context = canvas.getContext("2d");
+  } catch {
+    renderer.destroy();
+    return false;
+  }
+  if (!context) {
+    renderer.destroy();
+    return false;
+  }
+  context.drawImage(source, 0, 0, canvas.width, canvas.height);
+  renderer.destroy();
+  return true;
+}
+function OrbCloud({ color, playing, reducedMotion, state }) {
+  const canvasRef = useRef(null);
+  const stateRef = useRef(state);
+  const rendererKey = `${color}:${playing}:${reducedMotion}`;
+  const [unavailableRendererKey, setUnavailableRendererKey] = useState(null);
+  const webglUnavailable = unavailableRendererKey === rendererKey;
+  const continuouslyAnimated = playing && !reducedMotion && !webglUnavailable;
+  const snapshotState = continuouslyAnimated ? null : state;
+  useLayoutEffect(() => {
+    stateRef.current = state;
+  }, [state]);
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    canvas.style.background = cloudFallback(color);
+    if (!continuouslyAnimated) {
+      paintCloudSnapshot(canvas, color, snapshotState ?? stateRef.current);
+      return;
+    }
+    const renderer = createCloudRenderer(canvas, color);
+    if (!renderer) {
+      setUnavailableRendererKey(rendererKey);
+      return;
+    }
+    const handleContextLost = (event) => {
+      event.preventDefault();
+      setUnavailableRendererKey(rendererKey);
+    };
+    canvas.addEventListener("webglcontextlost", handleContextLost);
+    let frame = 0;
+    let previousTime = performance.now();
+    let flowTime = 0;
+    const render = (now) => {
+      const deltaSeconds = Math.min((now - previousTime) / 1e3, 0.05);
+      previousTime = now;
+      const nextState = stateRef.current;
+      const motion = sampleOrbCloudMotion(nextState);
+      if (!reducedMotion) flowTime += deltaSeconds * motion.speed;
+      renderer.draw(flowTime, motion.activity);
+      frame = requestAnimationFrame(render);
+    };
+    render(previousTime);
+    return () => {
+      cancelAnimationFrame(frame);
+      canvas.removeEventListener("webglcontextlost", handleContextLost);
+      renderer.destroy();
+    };
+  }, [color, continuouslyAnimated, rendererKey, snapshotState]);
+  return /* @__PURE__ */ jsx(
+    "foreignObject",
+    {
+      x: "0",
+      y: "0",
+      width: "256",
+      height: "256",
+      "data-avatar-orb-cloud": "",
+      "data-avatar-orb-cloud-state": state,
+      "data-avatar-orb-cloud-theme": toOrbCloudState(state),
+      style: { pointerEvents: "none" },
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            alignItems: "center",
+            display: "flex",
+            height: 256,
+            justifyContent: "center",
+            width: 256
+          },
+          children: /* @__PURE__ */ jsx(
+            "canvas",
+            {
+              ref: canvasRef,
+              "aria-hidden": "true",
+              "data-avatar-orb-cloud-alpha": "opaque",
+              "data-avatar-orb-cloud-canvas": "",
+              "data-avatar-orb-cloud-renderer": continuouslyAnimated ? "animated-webgl" : "snapshot-2d",
+              style: {
+                borderRadius: "50%",
+                clipPath: "circle(50% at 50% 50%)",
+                display: "block",
+                height: ORB_DIAMETER,
+                width: ORB_DIAMETER
+              }
+            },
+            continuouslyAnimated ? "animated-webgl" : "snapshot-2d"
+          )
+        }
+      )
+    }
+  );
+}
+
+// src/vendor/ui/agent-avatar/lab/timeline.ts
+var STATE_TRANSITION_DURATION = {
+  idle: 0.45,
+  attentive: 0.55,
+  working: 0.4,
+  responding: 0.3,
+  waiting: 0.5
+};
+var DEFAULT_SEQUENCE = [
+  { state: "idle", duration: 2.4 },
+  { state: "attentive", duration: 1.8 },
+  { state: "working", duration: 2.6 },
+  { state: "responding", duration: 1.6 },
+  { state: "waiting", duration: 2.4 }
+];
+function sequenceDuration(sequence) {
+  return sequence.reduce((total, step) => total + step.duration, 0);
+}
+function sampleSequence(sequence, time, speed = 1) {
+  const safeSequence = sequence.length > 0 ? sequence : DEFAULT_SEQUENCE;
+  const total = sequenceDuration(safeSequence);
+  const scaled = time * Math.max(0, speed);
+  const wrapped = total > 0 ? (scaled % total + total) % total : 0;
+  let offset = 0;
+  for (let index = 0; index < safeSequence.length; index += 1) {
+    const step = safeSequence[index];
+    const end = offset + step.duration;
+    if (wrapped < end || index === safeSequence.length - 1) {
+      const elapsed = wrapped - offset;
+      const previous = safeSequence[(index - 1 + safeSequence.length) % safeSequence.length];
+      const transitionWindow = Math.min(STATE_TRANSITION_DURATION[step.state], step.duration * 0.4);
+      return {
+        index,
+        state: step.state,
+        previousState: previous.state,
+        elapsed,
+        progress: clamp(elapsed / step.duration),
+        transition: easings.easeInOutCubic(clamp(elapsed / transitionWindow))
+      };
+    }
+    offset = end;
+  }
+  const fallback = safeSequence[0];
+  return {
+    index: 0,
+    state: fallback.state,
+    previousState: safeSequence[safeSequence.length - 1].state,
+    elapsed: 0,
+    progress: 0,
+    transition: 0
+  };
+}
+function useAnimationClock(active, resetKey = 0) {
+  const [time, setTime] = useState(0);
+  const accumulated = useRef(0);
+  const latest = useRef(0);
+  const startedAt = useRef(null);
+  useEffect(() => {
+    accumulated.current = 0;
+    latest.current = 0;
+    startedAt.current = null;
+    setTime(0);
+  }, [resetKey]);
+  useEffect(() => {
+    if (!active) {
+      startedAt.current = null;
+      return;
+    }
+    let frame = 0;
+    const tick = (now) => {
+      if (document.visibilityState === "hidden") {
+        startedAt.current = now;
+      } else {
+        if (startedAt.current === null) startedAt.current = now;
+        const elapsed = (now - startedAt.current) / 1e3;
+        latest.current = accumulated.current + elapsed;
+        setTime(latest.current);
+      }
+      frame = requestAnimationFrame(tick);
+    };
+    frame = requestAnimationFrame(tick);
+    return () => {
+      cancelAnimationFrame(frame);
+      accumulated.current = latest.current;
+      startedAt.current = null;
+    };
+  }, [active]);
+  return time;
+}
+function useReducedMotion(force) {
+  const [systemPrefersReducedMotion, setSystemPrefersReducedMotion] = useState(
+    () => typeof window !== "undefined" && typeof window.matchMedia === "function" ? window.matchMedia("(prefers-reduced-motion: reduce)").matches : false
+  );
+  useEffect(() => {
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+    const media = window.matchMedia("(prefers-reduced-motion: reduce)");
+    const update = () => setSystemPrefersReducedMotion(media.matches);
+    update();
+    media.addEventListener?.("change", update);
+    return () => media.removeEventListener?.("change", update);
+  }, []);
+  return force ?? systemPrefersReducedMotion;
+}
+var IDENTITY_MORPH_DURATION_SECONDS = 0.18;
+var BOX_CHARACTER_SCALE = 0.82;
+function sampleBoxCharacterOffset(state, time) {
+  if (state === "responding") return -10 + Math.sin(time * Math.PI * 2.4) * 3;
+  if (state === "attentive") return 2 + Math.sin(time * Math.PI * 1.8) * 2;
+  if (state === "working") return 15 + Math.sin(time * Math.PI * 2.2) * 8;
+  if (state === "waiting") return 44 + Math.sin(time * Math.PI * 1.1) * 2;
+  if (state === "paused") return 12;
+  return 12 + Math.sin(time * Math.PI * 0.65) * 2;
+}
+function sampleBoxCharacterSway(state, time) {
+  if (state === "waiting") return Math.sin(time * Math.PI * 0.9) * 9;
+  return 0;
+}
+function sampleBoxCharacterTilt(state, time) {
+  if (state === "waiting") return Math.sin(time * Math.PI * 0.9) * 2.4;
+  return 0;
+}
+function interpolateFace(from, to, progress) {
+  return {
+    x: lerp(from.x, to.x, progress),
+    y: lerp(from.y, to.y, progress),
+    width: lerp(from.width, to.width, progress),
+    height: lerp(from.height, to.height, progress),
+    radius: lerp(from.radius, to.radius, progress)
+  };
+}
+var Avatar = forwardRef(function Avatar2({
+  identity,
+  state,
+  sequence,
+  playing = true,
+  speed = 1,
+  followPointer = false,
+  reducedMotion: forceReducedMotion,
+  frozenAt,
+  playbackKey = 0,
+  size = "100%",
+  motionKey = "frontera",
+  label = "Frontera agent avatar",
+  className,
+  style,
+  testId
+}, forwardedRef) {
+  const reducedMotion = useReducedMotion(forceReducedMotion);
+  const clock = useAnimationClock(playing && !reducedMotion && frozenAt === void 0, playbackKey);
+  const time = reducedMotion ? 0 : frozenAt ?? clock;
+  const [pointer, setPointer] = useState({ x: 0, y: 0, active: false });
+  const instanceId = useId().replace(/:/g, "");
+  const clipId = `frontera-face-${instanceId}`;
+  const boxClipId = `frontera-box-${instanceId}`;
+  const glassIds = glassGradientIds(instanceId);
+  const orbIds = orbGradientIds(instanceId);
+  const currentShape = AVATAR_SHAPE_BY_ID.get(identity.shape) ?? AVATAR_SHAPE_BY_ID.get("squircle");
+  const morph = useRef({
+    id: currentShape.id,
+    resetKey: playbackKey,
+    fromProfile: currentShape.radii,
+    toProfile: currentShape.radii,
+    fromFace: currentShape.face,
+    toFace: currentShape.face,
+    start: 0
+  });
+  if (morph.current.resetKey !== playbackKey) {
+    morph.current = {
+      id: currentShape.id,
+      resetKey: playbackKey,
+      fromProfile: currentShape.radii,
+      toProfile: currentShape.radii,
+      fromFace: currentShape.face,
+      toFace: currentShape.face,
+      start: time - IDENTITY_MORPH_DURATION_SECONDS
+    };
+  } else if (morph.current.id !== currentShape.id) {
+    const previousProgress = playing ? easings.easeOutQuint(clamp((time - morph.current.start) / IDENTITY_MORPH_DURATION_SECONDS)) : 1;
+    morph.current = {
+      id: currentShape.id,
+      resetKey: playbackKey,
+      fromProfile: blendProfiles(morph.current.fromProfile, morph.current.toProfile, previousProgress),
+      toProfile: currentShape.radii,
+      fromFace: interpolateFace(morph.current.fromFace, morph.current.toFace, previousProgress),
+      toFace: currentShape.face,
+      start: time
+    };
+  }
+  const morphProgress = playing ? easings.easeOutQuint(clamp((time - morph.current.start) / IDENTITY_MORPH_DURATION_SECONDS)) : 1;
+  const profile = blendProfiles(morph.current.fromProfile, morph.current.toProfile, morphProgress);
+  const face = interpolateFace(morph.current.fromFace, morph.current.toFace, morphProgress);
+  const sequenceSample = sequence && !state ? sampleSequence(sequence, time, speed) : null;
+  const resolvedState = state ?? sequenceSample?.state ?? "idle";
+  const effectiveState = playing && !reducedMotion ? resolvedState : state === "paused" ? "paused" : resolvedState;
+  const sequenceTime = sequence && !state ? time * Math.max(0, speed) : time;
+  const stateTransition = reducedMotion ? 1 : sequenceSample?.transition ?? 1;
+  const previousSequenceState = reducedMotion ? effectiveState : sequenceSample?.previousState ?? effectiveState;
+  const frame = useMemo(
+    () => sampleAvatarFrame({
+      shape: identity.shape,
+      state: reducedMotion ? "paused" : effectiveState,
+      previousState: previousSequenceState,
+      transition: stateTransition,
+      time: sequenceTime,
+      seed: motionKey,
+      gaze: followPointer ? pointer : void 0,
+      profile,
+      face,
+      expression: identity.expression,
+      eyeSize: identity.eyeSize}),
+    [
+      effectiveState,
+      followPointer,
+      identity.shape,
+      identity.expression,
+      identity.eyeSize,
+      morphProgress,
+      playing,
+      pointer,
+      profile,
+      reducedMotion,
+      previousSequenceState,
+      face,
+      motionKey,
+      sequence,
+      sequenceTime,
+      speed,
+      stateTransition,
+      state,
+      time
+    ]
+  );
+  const onPointerMove = (event) => {
+    if (!followPointer || reducedMotion) return;
+    const bounds = event.currentTarget.getBoundingClientRect();
+    if (bounds.width <= 0 || bounds.height <= 0) return;
+    setPointer({
+      x: (event.clientX - bounds.left) / bounds.width * 2 - 1,
+      y: (event.clientY - bounds.top) / bounds.height * 2 - 1,
+      active: true
+    });
+  };
+  const transform = [
+    `translate(${frame.body.translateX} ${frame.body.translateY})`,
+    "translate(128 128)",
+    `rotate(${frame.body.rotation * 180 / Math.PI})`,
+    `scale(${frame.body.scale})`,
+    "translate(-128 -128)"
+  ].join(" ");
+  const faceColors = resolveFaceColors(identity.color, identity.faceTone);
+  const isOpenFace = currentShape.faceStyle === "open";
+  const showsFacePlate = !isOpenFace && identity.face !== "none";
+  const eyeColor = isOpenFace ? resolveOpenEyeColor(identity.color) : showsFacePlate ? faceColors.eyes : resolveEyeColorOnBody(identity.color);
+  const eyeGlint = eyeColor === "#202228" ? "#F7F3E8" : "#202228";
+  const opticalScale = currentShape.opticalScale ?? 1;
+  const opticalTransform = `translate(128 128) scale(${opticalScale}) translate(-128 -128)`;
+  const isOrbForm = currentShape.id === "orb";
+  const presentation = isOrbForm ? "free" : identity.presentation;
+  const isBox = presentation === "box";
+  const boxOffset = lerp(
+    sampleBoxCharacterOffset(previousSequenceState, sequenceTime),
+    sampleBoxCharacterOffset(effectiveState, sequenceTime),
+    stateTransition
+  );
+  const boxSway = lerp(
+    sampleBoxCharacterSway(previousSequenceState, sequenceTime),
+    sampleBoxCharacterSway(effectiveState, sequenceTime),
+    stateTransition
+  );
+  const boxTilt = lerp(
+    sampleBoxCharacterTilt(previousSequenceState, sequenceTime),
+    sampleBoxCharacterTilt(effectiveState, sequenceTime),
+    stateTransition
+  );
+  const presentationTransform = isBox && !isOrbForm ? `translate(128 128) translate(${boxSway} ${boxOffset}) rotate(${boxTilt}) scale(${BOX_CHARACTER_SCALE}) translate(-128 -128)` : void 0;
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      ref: forwardedRef,
+      viewBox: "0 0 256 256",
+      width: size,
+      height: size,
+      role: "img",
+      "aria-label": label,
+      className,
+      style,
+      "data-avatar-root": "",
+      "data-avatar-state": effectiveState,
+      "data-avatar-presentation": presentation,
+      "data-testid": testId,
+      onPointerMove,
+      onPointerLeave: () => setPointer({ x: 0, y: 0, active: false }),
+      children: [
+        /* @__PURE__ */ jsxs("defs", { children: [
+          isBox && /* @__PURE__ */ jsx(GlassDefs, { ids: glassIds }),
+          isOrbForm && /* @__PURE__ */ jsx(OrbDefs, { ids: orbIds }),
+          isBox && /* @__PURE__ */ jsx("clipPath", { id: boxClipId, children: /* @__PURE__ */ jsx(
+            "rect",
+            {
+              x: BOX_FRAME.x,
+              y: BOX_FRAME.y,
+              width: BOX_FRAME.size,
+              height: BOX_FRAME.size,
+              rx: BOX_FRAME.radius
+            }
+          ) })
+        ] }),
+        isBox && /* @__PURE__ */ jsx(GlassBackground, { ids: glassIds, color: identity.color }),
+        isBox && /* @__PURE__ */ jsx(GlassBackdrop, { ids: glassIds }),
+        /* @__PURE__ */ jsx("g", { clipPath: isBox ? `url(#${boxClipId})` : void 0, children: /* @__PURE__ */ jsx(
+          "g",
+          {
+            "data-avatar-box-character": isBox ? "" : void 0,
+            "data-avatar-box-offset": isBox && !isOrbForm ? boxOffset : void 0,
+            "data-avatar-box-sway": isBox && !isOrbForm ? boxSway : void 0,
+            "data-avatar-box-tilt": isBox && !isOrbForm ? boxTilt : void 0,
+            transform: presentationTransform,
+            children: /* @__PURE__ */ jsx("g", { transform: isOrbForm ? void 0 : transform, children: /* @__PURE__ */ jsxs(
+              "g",
+              {
+                "data-avatar-artwork": "",
+                "data-avatar-optical-scale": opticalScale,
+                transform: opticalTransform,
+                children: [
+                  isOrbForm ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx("g", { "data-avatar-orb-export-fallback": "", display: "none", children: /* @__PURE__ */ jsx(
+                      OrbBackdrop,
+                      {
+                        ids: orbIds,
+                        color: identity.color,
+                        state: effectiveState,
+                        time: sequenceTime,
+                        reducedMotion
+                      }
+                    ) }),
+                    /* @__PURE__ */ jsx(
+                      OrbCloud,
+                      {
+                        color: identity.color,
+                        playing,
+                        reducedMotion,
+                        state: effectiveState
+                      }
+                    )
+                  ] }) : /* @__PURE__ */ jsx(
+                    "path",
+                    {
+                      "data-avatar-bezel": "",
+                      d: frame.bodyPath,
+                      fill: identity.color,
+                      fillRule: "nonzero"
+                    }
+                  ),
+                  !isOrbForm && frame.usesAuthoredShape && currentShape.layers?.map((layer, index) => /* @__PURE__ */ jsx(
+                    "path",
+                    {
+                      "data-avatar-role-layer": "",
+                      d: layer.path,
+                      fill: layer.tone === "highlight" ? "#FFFFFF" : "#0A0A0C",
+                      fillRule: "evenodd",
+                      opacity: layer.opacity
+                    },
+                    index
+                  )),
+                  !isOrbForm && /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx("clipPath", { id: clipId, children: /* @__PURE__ */ jsx(
+                      "rect",
+                      {
+                        x: frame.face.x,
+                        y: frame.face.y,
+                        width: frame.face.width,
+                        height: frame.face.height,
+                        rx: frame.face.radius
+                      }
+                    ) }) }),
+                    /* @__PURE__ */ jsx(
+                      "rect",
+                      {
+                        "data-avatar-face": "",
+                        x: frame.face.x,
+                        y: frame.face.y,
+                        width: frame.face.width,
+                        height: frame.face.height,
+                        rx: frame.face.radius,
+                        fill: faceColors.face,
+                        "data-avatar-face-tone": faceColors.tone,
+                        "data-avatar-face-style": currentShape.faceStyle,
+                        opacity: showsFacePlate ? frame.faceOpacity : 0
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("g", { clipPath: `url(#${clipId})`, opacity: frame.eyeOpacity, children: frame.eyes.map((eye3, index) => {
+                      const glintRadius = Math.max(1, Math.min(eye3.width, eye3.height) * 0.16);
+                      const eyeTransform = `rotate(${eye3.rotation} ${eye3.cx} ${eye3.cy})`;
+                      return /* @__PURE__ */ jsxs("g", { transform: eyeTransform, children: [
+                        /* @__PURE__ */ jsx(
+                          "rect",
+                          {
+                            "data-avatar-eye": "",
+                            x: eye3.cx - eye3.width / 2,
+                            y: eye3.cy - eye3.height / 2,
+                            width: eye3.width,
+                            height: eye3.height,
+                            rx: Math.min(eye3.width, eye3.height) / 2,
+                            fill: eyeColor
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(
+                          "circle",
+                          {
+                            "data-avatar-eye-glint": "",
+                            cx: eye3.cx - eye3.width * 0.14,
+                            cy: eye3.cy - eye3.height * 0.18,
+                            r: glintRadius,
+                            fill: eyeGlint
+                          }
+                        )
+                      ] }, index);
+                    }) })
+                  ] })
+                ]
+              }
+            ) })
+          }
+        ) }),
+        isBox && /* @__PURE__ */ jsx("g", { clipPath: `url(#${boxClipId})`, children: /* @__PURE__ */ jsx(GlassOverlay, { ids: glassIds }) })
+      ]
+    }
+  );
+});
+
+// src/vendor/service/agent-avatar-seed.ts
+var SEEDED_AGENT_AVATAR_COLORS = [
+  "#E8483F",
+  "#F08A24",
+  "#F0B429",
+  "#3ECF8E",
+  "#2FBFA0",
+  "#3B93F0",
+  "#2563EB",
+  "#8B5CF6",
+  "#E152B0",
+  "#8B5E3C"
+];
+function pickAgentAvatarColor(seed) {
+  const normalized = seed.trim().toLowerCase();
+  let hash = 2166136261;
+  for (let index = 0; index < normalized.length; index += 1) {
+    hash ^= normalized.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return SEEDED_AGENT_AVATAR_COLORS[(hash >>> 0) % SEEDED_AGENT_AVATAR_COLORS.length];
+}
+
+// src/vendor/service/agent-avatar-config.ts
+var AGENT_AVATAR_SHAPES = [
+  "orb",
+  "round",
+  "pebble",
+  "squircle",
+  "capsule",
+  "triangle",
+  "hexagon",
+  "cloud",
+  "egg",
+  "eary",
+  "puff",
+  "bolt",
+  "briefcase",
+  "chart",
+  "support",
+  "spark"
+];
+z.object({
+  version: z.literal(4),
+  shape: z.enum(AGENT_AVATAR_SHAPES),
+  color: z.string().regex(/^#[0-9A-F]{6}$/i),
+  expression: z.enum(["neutral", "focused", "happy", "puzzled"]),
+  faceTone: z.enum(["auto", "light", "dark"]),
+  eyeSize: z.enum(["small", "normal", "large"]),
+  presentation: z.enum(["free", "box"]),
+  face: z.enum(["square", "none"]).optional()
+}).strict();
+
+// src/vendor/service/agent-history-contract.ts
+var HISTORY_CITATION_PREFIX = "/cite/history/";
+function historyCitationReference(href) {
+  if (!href.startsWith(HISTORY_CITATION_PREFIX)) return null;
+  const reference = href.slice(HISTORY_CITATION_PREFIX.length);
+  return reference.length <= 16e3 && /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(reference) ? reference : null;
+}
+
+// src/vendor/service-types.ts
+var FORMAT_EXT = {
+  markdown: "md",
+  csv: "csv",
+  sheet: "xlsx",
+  pdf: "pdf",
+  image: "png",
+  htmldeck: "json",
+  file: "bin",
+  canvas: "html"
+};
+
+// src/vendor/ui/agent-avatar/types.ts
+var DEFAULT_AGENT_AVATAR_CONFIG = {
+  version: 4,
+  shape: "orb",
+  color: "#0084FF",
+  expression: "neutral",
+  faceTone: "light",
+  eyeSize: "normal",
+  presentation: "free"
+};
+function createSeededAgentAvatarConfig(seed) {
+  const normalizedSeed = seed?.trim();
+  if (!normalizedSeed) return DEFAULT_AGENT_AVATAR_CONFIG;
+  return {
+    ...DEFAULT_AGENT_AVATAR_CONFIG,
+    color: pickAgentAvatarColor(normalizedSeed)
+  };
+}
+function normalizeAgentAvatarConfig(value, seed) {
+  if (!value) return createSeededAgentAvatarConfig(seed);
+  if (value.shape === "orb" && value.presentation === "box") {
+    return { ...value, presentation: "free" };
+  }
+  return value;
+}
+var AgentAvatarView = memo(function AgentAvatarView2({
+  name,
+  config,
+  seed,
+  size = 40,
+  state = "idle",
+  animated = false,
+  className,
+  label
+}) {
+  const persistedIdentity = normalizeAgentAvatarConfig(config, seed ?? name);
+  const identity = { ...persistedIdentity, faceTone: "light" };
+  const accessibleLabel = label ?? `${name?.trim() || "Agent"} avatar`;
+  return /* @__PURE__ */ jsx(
+    Avatar,
+    {
+      identity,
+      state,
+      playing: animated,
+      followPointer: animated,
+      reducedMotion: animated ? void 0 : true,
+      size,
+      motionKey: `${identity.shape}:${identity.color}:${identity.expression}`,
+      label: accessibleLabel,
+      className: cn("block shrink-0 overflow-hidden", className)
+    }
+  );
+});
+var AgentAvatar = AgentAvatarView;
+
+export { AgentAvatar, FORMAT_EXT, HISTORY_CITATION_PREFIX, historyCitationReference };