agent-robot-avatar 0.2.0

package/src/agent-robot-avatar-extension-host.js

@@ -0,0 +1,73 @@
+import AgentRobotAvatar from './agent-robot-avatar-core.js';
+
+const proto = AgentRobotAvatar.prototype;
+const basePlay = proto.play;
+const baseReset = proto.reset;
+const baseDraw = proto._draw;
+const extensionNames = new Set();
+const actionHandlers = new Map();
+const beforePlayHooks = [];
+const afterPlayHooks = [];
+const resetHooks = [];
+const drawHooks = [];
+
+function registerAvatarExtension({
+  name,
+  actions = {},
+  beforePlay,
+  afterPlay,
+  reset,
+  draw,
+}) {
+  if (!name || extensionNames.has(name)) {
+    throw new Error(`Agent Robot Avatar extension already registered: ${name || '(unnamed)'}`);
+  }
+  extensionNames.add(name);
+
+  for (const [action, handler] of Object.entries(actions)) {
+    if (actionHandlers.has(action)) {
+      throw new Error(`Agent Robot Avatar action already registered: ${action}`);
+    }
+    actionHandlers.set(action, handler);
+  }
+
+  if (beforePlay) beforePlayHooks.push(beforePlay);
+  if (afterPlay) afterPlayHooks.push(afterPlay);
+  if (reset) resetHooks.push(reset);
+  if (draw) drawHooks.push(draw);
+}
+
+proto.play = function(name) {
+  this._resumeFrames?.();
+  const action = String(name || '').trim().toLowerCase();
+  const context = {};
+
+  for (const hook of beforePlayHooks) hook.call(this, action, context);
+
+  let result;
+  try {
+    const handler = actionHandlers.get(action);
+    result = handler ? handler.call(this, action) : basePlay.call(this, action);
+  } catch (error) {
+    context.error = error;
+    for (const hook of afterPlayHooks) hook.call(this, action, undefined, context);
+    throw error;
+  }
+
+  for (const hook of afterPlayHooks) hook.call(this, action, result, context);
+  return result;
+};
+
+proto.reset = function() {
+  this._resumeFrames?.();
+  for (const hook of resetHooks) hook.call(this);
+  return baseReset.call(this);
+};
+
+proto._draw = function(now) {
+  baseDraw.call(this, now);
+  for (const hook of drawHooks) hook.call(this, now);
+};
+
+export { AgentRobotAvatar, registerAvatarExtension };
+export default AgentRobotAvatar;

package/src/agent-robot-avatar-failure.js

@@ -0,0 +1,127 @@
+import AgentRobotAvatar, { registerAvatarExtension } from './agent-robot-avatar-extension-host.js';
+
+const proto = AgentRobotAvatar.prototype;
+
+const FAILURE_HEAD_DROP = 5.5;
+const FAILURE_EYE_DROP = 4.8;
+
+function dispatchFailureState(instance, state) {
+  instance.dispatchEvent(new CustomEvent('face-state', {
+    detail: { state }
+  }));
+}
+
+function animateFailureHead(instance, frames, duration) {
+  if (!instance._headMotion?.animate) return null;
+  instance._headMotion.style.transformBox = 'view-box';
+  instance._headMotion.style.transformOrigin = '120px 120px';
+  const anim = instance._headMotion.animate(frames, {
+    duration,
+    easing: 'cubic-bezier(.32,0,.24,1)',
+    fill: 'forwards',
+  });
+  anim.onfinish = () => {
+    instance._headMotion.style.transform = frames[frames.length - 1].transform || '';
+  };
+  return anim;
+}
+
+function smooth01(t) {
+  t = Math.max(0, Math.min(1, t));
+  return t * t * (3 - 2 * t);
+}
+
+function failureEyeDrop(fx, now) {
+  const elapsed = Math.max(0, now - fx.start);
+  if (elapsed < fx.headDown) {
+    return FAILURE_EYE_DROP * smooth01(elapsed / Math.max(1, fx.headDown));
+  }
+  if (elapsed < fx.headDown + fx.hold) return FAILURE_EYE_DROP;
+  const recoverElapsed = elapsed - fx.headDown - fx.hold;
+  if (recoverElapsed < fx.recover) {
+    return FAILURE_EYE_DROP * (1 - smooth01(recoverElapsed / Math.max(1, fx.recover)));
+  }
+  return 0;
+}
+
+function addEyeDrop(eye, amount) {
+  if (!eye || Math.abs(amount) < 0.001) return;
+  const current = eye.getAttribute('transform') || '';
+  eye.setAttribute('transform', `${current} translate(0 ${amount.toFixed(2)})`);
+}
+
+proto.failure = async function() {
+  this.noteActivity();
+  this._inputWanted = false;
+  this._failureFx = null;
+
+  // Clear waiting/inspect/flash or any other active extension before entering failure.
+  this.reset();
+  if (!(await this._prepareExpression({ normalizePose: true, duration: 180, pause: 260 }))) return;
+  const token = this._transitionToken;
+
+  // First finish the sad/failure eye deformation completely.
+  const eyeIn = 320;
+  this.setState('sad', { duration: eyeIn, keepGazeLock: true });
+  dispatchFailureState(this, 'failure');
+  await this._wait(eyeIn);
+  if (token !== this._transitionToken || this._state !== 'sad') return;
+
+  // Only after the eyes have settled, lower the head and press the eyes down inside it together.
+  const headDown = 720;
+  const loweredHold = 720;
+  const recover = 520;
+  this._failureFx = {
+    start: performance.now(),
+    headDown,
+    hold: loweredHold,
+    recover,
+  };
+
+  animateFailureHead(this, [
+    { transform: 'translateY(0px)' },
+    { transform: `translateY(${FAILURE_HEAD_DROP}px)` },
+  ], headDown);
+  await this._wait(headDown);
+  if (token !== this._transitionToken) return;
+
+  // Hold the lowered, sad pose longer before recovering.
+  await this._wait(loweredHold);
+  if (token !== this._transitionToken) return;
+
+  // Head, eyes and sad expression recover together.
+  animateFailureHead(this, [
+    { transform: `translateY(${FAILURE_HEAD_DROP}px)` },
+    { transform: 'translateY(0px)' },
+  ], recover);
+  if (this._state === 'sad') await this._returnToIdle(recover);
+  this._failureFx = null;
+};
+
+function drawFailure(now) {
+  const fx = this._failureFx;
+  if (!fx) return;
+  const drop = failureEyeDrop(fx, now);
+  addEyeDrop(this._leftEye, drop);
+  addEyeDrop(this._rightEye, drop);
+}
+
+registerAvatarExtension({
+  name: 'failure',
+  actions: {
+    failure() { return this.failure(); },
+    failed() { return this.failure(); },
+    fail() { return this.failure(); },
+  },
+  beforePlay(action) {
+    if (action === 'failure' || action === 'failed' || action === 'fail') return;
+    this._failureFx = null;
+  },
+  reset() {
+    this._failureFx = null;
+  },
+  draw: drawFailure,
+});
+
+export { AgentRobotAvatar };
+export default AgentRobotAvatar;

package/src/agent-robot-avatar-head-roundness.js

@@ -0,0 +1,136 @@
+import AgentRobotAvatar from './agent-robot-avatar-extension-host.js';
+import { VERSION } from './agent-robot-avatar-version.js';
+
+const proto = AgentRobotAvatar.prototype;
+const HEAD_HEIGHT_SCALE = 0.9;
+const DEFAULT_ROUNDNESS = 50;
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function smooth01(t) {
+  t = clamp(t, 0, 1);
+  return t * t * (3 - 2 * t);
+}
+
+function flattenPoints(points) {
+  if (!points?.length) return [];
+  const source = points.map(point => ({ x: point.x, y: point.y }));
+  const minY = Math.min(...source.map(point => point.y));
+  const maxY = Math.max(...source.map(point => point.y));
+  const height = maxY - minY;
+  const centerY = (minY + maxY) / 2;
+  const inset = height * (1 - HEAD_HEIGHT_SCALE) / 2;
+  const upperLockY = minY + height * 0.40;
+  const lowerLockY = maxY - height * 0.40;
+
+  return source.map(point => {
+    let shiftY = 0;
+    if (point.y <= upperLockY) {
+      shiftY = inset;
+    } else if (point.y < centerY) {
+      const t = (centerY - point.y) / Math.max(0.001, centerY - upperLockY);
+      shiftY = inset * smooth01(t);
+    } else if (point.y >= lowerLockY) {
+      shiftY = -inset;
+    } else if (point.y > centerY) {
+      const t = (point.y - centerY) / Math.max(0.001, lowerLockY - centerY);
+      shiftY = -inset * smooth01(t);
+    }
+    return { x: point.x, y: point.y + shiftY };
+  });
+}
+
+function ensureDefaultGeometry(instance) {
+  if (!instance?._headShape || !instance._baseHeadPoints?.length) return false;
+  if (instance._headRoundnessDefaultPoints?.length) return true;
+
+  let points = instance._baseHeadPoints.map(point => ({ x: point.x, y: point.y }));
+
+  if (!instance._headFlattenedR32) {
+    points = flattenPoints(points);
+    instance._headFlattenedR32 = true;
+    instance._baseHeadPoints = points.map(point => ({ ...point }));
+    instance._baseHeadPathD = instance._pointsToPath(points);
+    instance._headShape.setAttribute('d', instance._baseHeadPathD);
+  }
+
+  instance._headRoundnessDefaultPoints = instance._baseHeadPoints.map(point => ({ x: point.x, y: point.y }));
+  instance._headRoundness = DEFAULT_ROUNDNESS;
+  return true;
+}
+
+function superellipsePoint(angle, cx, cy, halfW, halfH, exponent) {
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  const xTerm = Math.pow(Math.abs(cos) / Math.max(0.001, halfW), exponent);
+  const yTerm = Math.pow(Math.abs(sin) / Math.max(0.001, halfH), exponent);
+  const denom = Math.pow(xTerm + yTerm, 1 / exponent);
+  const radius = denom > 0 ? 1 / denom : 0;
+  return { x: cx + cos * radius, y: cy + sin * radius };
+}
+
+function targetShape(points, exponent) {
+  const minX = Math.min(...points.map(point => point.x));
+  const maxX = Math.max(...points.map(point => point.x));
+  const minY = Math.min(...points.map(point => point.y));
+  const maxY = Math.max(...points.map(point => point.y));
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const halfW = (maxX - minX) / 2;
+  const halfH = (maxY - minY) / 2;
+
+  return points.map(point => {
+    const angle = Math.atan2(point.y - cy, point.x - cx);
+    return superellipsePoint(angle, cx, cy, halfW, halfH, exponent);
+  });
+}
+
+function mixPoints(from, to, amount) {
+  const t = clamp(amount, 0, 1);
+  return from.map((point, index) => ({
+    x: point.x + (to[index].x - point.x) * t,
+    y: point.y + (to[index].y - point.y) * t,
+  }));
+}
+
+proto.setHeadRoundness = function(value = DEFAULT_ROUNDNESS) {
+  if (!ensureDefaultGeometry(this)) return this;
+
+  const roundness = clamp(Number(value) || 0, 0, 100);
+  const baseline = this._headRoundnessDefaultPoints;
+  let points = baseline.map(point => ({ ...point }));
+
+  if (roundness < DEFAULT_ROUNDNESS) {
+    const squarer = targetShape(baseline, 10);
+    points = mixPoints(baseline, squarer, (DEFAULT_ROUNDNESS - roundness) / DEFAULT_ROUNDNESS);
+  } else if (roundness > DEFAULT_ROUNDNESS) {
+    const rounder = targetShape(baseline, 2.2);
+    points = mixPoints(baseline, rounder, (roundness - DEFAULT_ROUNDNESS) / DEFAULT_ROUNDNESS);
+  }
+
+  this._headRoundness = roundness;
+  this._baseHeadPoints = points;
+  this._baseHeadPathD = this._pointsToPath(points);
+
+  if (this._dragJelly?.active || this._dragJelly?.returning) this._applyHeadDeform?.();
+  else this._headShape.setAttribute('d', this._baseHeadPathD);
+
+  this.dispatchEvent(new CustomEvent('head-roundness-change', {
+    detail: { value: roundness, version: VERSION }
+  }));
+  return this;
+};
+
+proto.getHeadRoundness = function() {
+  return Number.isFinite(this._headRoundness) ? this._headRoundness : DEFAULT_ROUNDNESS;
+};
+
+if (typeof window !== 'undefined') {
+  window.AgentRobotAvatarVersion = VERSION;
+  window.AgentRobotAvatarHeadRoundnessDefault = DEFAULT_ROUNDNESS;
+}
+
+export { AgentRobotAvatar, DEFAULT_ROUNDNESS, VERSION };
+export default AgentRobotAvatar;

package/src/agent-robot-avatar-inspect.js

@@ -0,0 +1,231 @@
+import AgentRobotAvatar, { registerAvatarExtension } from './agent-robot-avatar-extension-host.js';
+
+const proto = AgentRobotAvatar.prototype;
+
+const clamp01 = value => Math.max(0, Math.min(1, value));
+const lerp = (a, b, t) => a + (b - a) * t;
+const smooth = t => {
+  t = clamp01(t);
+  return t * t * (3 - 2 * t);
+};
+
+// Finalized from the R59 tuner values supplied by the user.
+const INSPECT_DEFAULTS = Object.freeze({
+  aperture: 16,
+  scanOffset: 16,
+  prepPause: 120,
+  close: 220,
+  holdClosed: 880,
+  down1: 400,
+  holdDown1: 560,
+  up1: 160,
+  holdUp1: 580,
+  center1: 140,
+  holdCenter: 760,
+  down2: 140,
+  holdDown2: 620,
+  up2: 180,
+  holdUp2: 620,
+  center2: 100,
+  holdAfter: 940,
+  open: 260,
+});
+
+const runtimeWindow = typeof window !== 'undefined' ? window : null;
+const inspectConfig = (runtimeWindow?.AgentRobotAvatarInspectConfig && typeof runtimeWindow.AgentRobotAvatarInspectConfig === 'object')
+  ? runtimeWindow.AgentRobotAvatarInspectConfig
+  : {};
+for (const [key, value] of Object.entries(INSPECT_DEFAULTS)) {
+  inspectConfig[key] = value;
+}
+if (runtimeWindow) {
+  runtimeWindow.AgentRobotAvatarInspectConfig = inspectConfig;
+  runtimeWindow.AgentRobotAvatarInspectDefaults = INSPECT_DEFAULTS;
+}
+
+function configNumber(key, fallback, min, max) {
+  const value = Number(inspectConfig[key]);
+  if (!Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, value));
+}
+
+function currentInspectConfig() {
+  const duration = key => configNumber(key, INSPECT_DEFAULTS[key], 0, 2400);
+  return {
+    aperture: configNumber('aperture', INSPECT_DEFAULTS.aperture, 6, 40),
+    scanOffset: configNumber('scanOffset', INSPECT_DEFAULTS.scanOffset, 0, 24),
+    prepPause: duration('prepPause'),
+    close: Math.max(40, duration('close')),
+    holdClosed: duration('holdClosed'),
+    down1: Math.max(40, duration('down1')),
+    holdDown1: duration('holdDown1'),
+    up1: Math.max(40, duration('up1')),
+    holdUp1: duration('holdUp1'),
+    center1: Math.max(40, duration('center1')),
+    holdCenter: duration('holdCenter'),
+    down2: Math.max(40, duration('down2')),
+    holdDown2: duration('holdDown2'),
+    up2: Math.max(40, duration('up2')),
+    holdUp2: duration('holdUp2'),
+    center2: Math.max(40, duration('center2')),
+    holdAfter: duration('holdAfter'),
+    open: Math.max(40, duration('open')),
+  };
+}
+
+function dispatchInspectState(instance, state) {
+  instance.dispatchEvent(new CustomEvent('face-state', {
+    detail: { state }
+  }));
+}
+
+function makeTimeline(config) {
+  let cursor = 0;
+  const phases = {};
+  const add = key => {
+    phases[`${key}Start`] = cursor;
+    cursor += config[key];
+    phases[`${key}End`] = cursor;
+  };
+  for (const key of [
+    'close','holdClosed','down1','holdDown1','up1','holdUp1','center1','holdCenter',
+    'down2','holdDown2','up2','holdUp2','center2','holdAfter','open'
+  ]) add(key);
+  phases.duration = cursor;
+  return phases;
+}
+
+function move(elapsed, start, end, from, to) {
+  if (elapsed <= start) return from;
+  if (elapsed >= end) return to;
+  const span = Math.max(1, end - start);
+  return lerp(from, to, smooth((elapsed - start) / span));
+}
+
+function verticalShift(elapsed, phases, offset) {
+  if (elapsed < phases.down1Start) return 0;
+  if (elapsed < phases.down1End) return move(elapsed, phases.down1Start, phases.down1End, 0, offset);
+  if (elapsed < phases.holdDown1End) return offset;
+  if (elapsed < phases.up1End) return move(elapsed, phases.up1Start, phases.up1End, offset, -offset);
+  if (elapsed < phases.holdUp1End) return -offset;
+  if (elapsed < phases.center1End) return move(elapsed, phases.center1Start, phases.center1End, -offset, 0);
+  if (elapsed < phases.holdCenterEnd) return 0;
+
+  // Second pass: down to the lowest point, hold, then return directly to center.
+  // Do not overshoot upward again.
+  if (elapsed < phases.down2End) return move(elapsed, phases.down2Start, phases.down2End, 0, offset);
+  if (elapsed < phases.holdDown2End) return offset;
+  if (elapsed < phases.up2End) return move(elapsed, phases.up2Start, phases.up2End, offset, 0);
+  return 0;
+}
+
+// Keep the R60 head motion unchanged: down, up past center, then back to center.
+function animateInspectHead(instance, phases) {
+  if (!instance._headMotion?.animate) return;
+  const start = phases.down1Start;
+  const end = phases.center1End;
+  const duration = Math.max(1, end - start);
+  const offset = time => Math.max(0, Math.min(1, (time - start) / duration));
+
+  instance._headMotion.style.transformBox = 'view-box';
+  instance._headMotion.style.transformOrigin = '120px 120px';
+  const anim = instance._headMotion.animate([
+    { transform: 'translateY(0px)', offset: 0, easing: 'cubic-bezier(.38,0,.25,1)' },
+    { transform: 'translateY(5px)', offset: offset(phases.down1End) },
+    { transform: 'translateY(5px)', offset: offset(phases.holdDown1End), easing: 'cubic-bezier(.35,0,.22,1)' },
+    { transform: 'translateY(-4px)', offset: offset(phases.up1End) },
+    { transform: 'translateY(-4px)', offset: offset(phases.holdUp1End), easing: 'cubic-bezier(.35,0,.22,1)' },
+    { transform: 'translateY(0px)', offset: 1 },
+  ], {
+    duration,
+    delay: start,
+    easing: 'linear',
+    fill: 'forwards',
+  });
+  anim.onfinish = () => { instance._headMotion.style.transform = 'translateY(0px)'; };
+}
+
+proto.inspect = async function() {
+  this.noteActivity();
+  this._inputWanted = false;
+
+  const config = currentInspectConfig();
+  this.reset();
+  if (!(await this._prepareExpression({ normalizePose: true, duration: 160, pause: config.prepPause }))) return;
+
+  const token = this._transitionToken;
+  this._expressionLock = true;
+  this._look.x = 0;
+  this._look.y = 0;
+
+  const phases = makeTimeline(config);
+  this._inspectFx = { start: performance.now(), duration: phases.duration, config, phases };
+  dispatchInspectState(this, 'inspect');
+  animateInspectHead(this, phases);
+
+  await this._wait(phases.duration + 30);
+  if (token !== this._transitionToken) return;
+
+  this._inspectFx = null;
+  this._look.x = 0;
+  this._look.y = 0;
+  this._releaseExpressionLock();
+  dispatchInspectState(this, 'idle');
+};
+
+function drawInspect(now) {
+  const fx = this._inspectFx;
+  if (!fx) return;
+
+  const config = fx.config || currentInspectConfig();
+  const phases = fx.phases || makeTimeline(config);
+  const elapsed = Math.max(0, Math.min(phases.duration, now - fx.start));
+
+  let lidBlend = 1;
+  if (elapsed < phases.closeEnd) {
+    lidBlend = smooth(elapsed / Math.max(1, config.close));
+  } else if (elapsed >= phases.openStart) {
+    lidBlend = 1 - smooth((elapsed - phases.openStart) / Math.max(1, config.open));
+  }
+
+  const yShift = verticalShift(elapsed, phases, config.scanOffset);
+
+  // Keep the original eye geometry. The squint is made only by the top/bottom masks.
+  this._leftEye.setAttribute('transform', `translate(86 ${(126 + yShift).toFixed(2)}) scale(1 1)`);
+  this._rightEye.setAttribute('transform', `translate(154 ${(126 + yShift).toFixed(2)}) scale(1 1)`);
+
+  const apertureHalf = config.aperture / 2;
+  const topEdge = lerp(-36, -apertureHalf, lidBlend);
+  const bottomEdge = lerp(36, apertureHalf, lidBlend);
+
+  for (const top of [this._leftTop, this._rightTop]) {
+    top.setAttribute('y', (topEdge - 90).toFixed(2));
+    top.setAttribute('height', '90');
+    top.setAttribute('transform', `rotate(0 0 ${topEdge.toFixed(2)})`);
+  }
+  for (const bottom of [this._leftBottom, this._rightBottom]) {
+    bottom.setAttribute('y', bottomEdge.toFixed(2));
+    bottom.setAttribute('height', '90');
+    bottom.setAttribute('transform', `rotate(0 0 ${bottomEdge.toFixed(2)})`);
+  }
+}
+
+registerAvatarExtension({
+  name: 'inspect',
+  actions: {
+    inspect() { return this.inspect(); },
+    verify() { return this.inspect(); },
+    review() { return this.inspect(); },
+  },
+  beforePlay(action) {
+    if (action === 'inspect' || action === 'verify' || action === 'review') return;
+    this._inspectFx = null;
+  },
+  reset() {
+    this._inspectFx = null;
+  },
+  draw: drawInspect,
+});
+
+export { AgentRobotAvatar, INSPECT_DEFAULTS };
+export default AgentRobotAvatar;

package/src/agent-robot-avatar-version.js

@@ -0,0 +1,3 @@
+const VERSION = '0.2.0';
+
+export { VERSION };

package/src/agent-robot-avatar-waiting.js

@@ -0,0 +1,121 @@
+import AgentRobotAvatar, { registerAvatarExtension } from './agent-robot-avatar-extension-host.js';
+
+const WAITING_CYCLE = 3200;
+const proto = AgentRobotAvatar.prototype;
+
+const clamp01 = value => Math.max(0, Math.min(1, value));
+
+function dispatchWaitingState(instance, state) {
+  instance.dispatchEvent(new CustomEvent('face-state', {
+    detail: { state }
+  }));
+}
+
+function readEyeY(eye) {
+  const raw = eye?.getAttribute('transform') || '';
+  const match = raw.match(/translate\(\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s*\)/);
+  return match ? Number(match[2]) : 126;
+}
+
+function setEyeOrbitTransform(eye, x, scaleX, scaleY) {
+  if (!eye) return;
+  const y = readEyeY(eye);
+  eye.setAttribute(
+    'transform',
+    `translate(${x.toFixed(2)} ${y.toFixed(2)}) scale(${scaleX.toFixed(4)} ${scaleY.toFixed(4)})`
+  );
+}
+
+async function enterWaiting(instance, continuous, source) {
+  instance.noteActivity();
+  instance._inputWanted = false;
+
+  instance.reset();
+  instance._waitingRequested = true;
+  if (!(await instance._prepareExpression({ normalizePose: true, duration: 120, pause: 0 }))) return null;
+  if (!instance._waitingRequested) return null;
+
+  const token = instance._transitionToken;
+  instance._expressionLock = true;
+  instance._look.x = 0;
+  instance._look.y = 0;
+  instance._waitingFx = {
+    start: performance.now(),
+    duration: WAITING_CYCLE,
+    continuous: continuous === true,
+    source,
+  };
+  dispatchWaitingState(instance, 'waiting');
+  return token;
+}
+
+proto.waiting = async function() {
+  const token = await enterWaiting(this, false, 'play');
+  if (token == null) return;
+
+  await this._wait(WAITING_CYCLE);
+  if (token !== this._transitionToken || !this._waitingRequested) return;
+  this._waitingRequested = false;
+  this._waitingFx = null;
+  this._releaseExpressionLock();
+  dispatchWaitingState(this, 'idle');
+};
+
+// Runtime/Agent behavior: call when a request has been sent and the reply has not arrived yet.
+// It stays seamless until another action or stopWaiting() occurs.
+proto.startWaiting = async function() {
+  await enterWaiting(this, true, 'runtime');
+  return this;
+};
+
+proto.stopWaiting = function() {
+  return this.reset();
+};
+
+function drawWaiting(now) {
+  const fx = this._waitingFx;
+  if (!fx) return;
+
+  const elapsed = Math.max(0, now - fx.start);
+  const phaseMs = fx.continuous
+    ? (elapsed % fx.duration)
+    : Math.min(fx.duration, elapsed);
+  const t = clamp01(phaseMs / fx.duration);
+
+  // Original R43 waiting-eye motion: two continuous horizontal orbits per 3.2 s cycle.
+  const angle = t * Math.PI * 4;
+  const cosA = Math.cos(angle);
+  const sinA = Math.sin(angle);
+
+  const leftX = 120 - 34 * cosA;
+  const rightX = 120 + 34 * cosA;
+
+  // Original R43 perspective/size treatment retained exactly.
+  const foreshorten = 0.72 + 0.28 * Math.abs(cosA);
+  const leftDepth = 1 + 0.08 * sinA;
+  const rightDepth = 1 - 0.08 * sinA;
+
+  setEyeOrbitTransform(this._leftEye, leftX, foreshorten * leftDepth, leftDepth);
+  setEyeOrbitTransform(this._rightEye, rightX, foreshorten * rightDepth, rightDepth);
+}
+
+registerAvatarExtension({
+  name: 'waiting',
+  actions: {
+    waiting() { return this.waiting(); },
+    wait() { return this.waiting(); },
+  },
+  beforePlay(action) {
+    if (action === 'waiting' || action === 'wait') return;
+    this._waitingRequested = false;
+    this._waitingFx = null;
+  },
+  reset() {
+    this._waitingRequested = false;
+    this._waitingFx = null;
+  },
+  draw: drawWaiting,
+});
+
+export { AgentRobotAvatar, WAITING_CYCLE };
+export default AgentRobotAvatar;