agent-robot-avatar 0.3.2 → 0.6.0

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

@@ -1,78 +1,78 @@
-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;
-};
-
-// Called dynamically by core reset and disconnect; custom-element lifecycle
-// callbacks themselves were already registered before extensions loaded.
-proto._resetExtensionEffects = function() {
-  for (const hook of resetHooks) hook.call(this);
-};
-
-proto.reset = function() {
-  this._resumeFrames?.();
-  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;
+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;
+};
+
+// Called dynamically by core reset and disconnect; custom-element lifecycle
+// callbacks themselves were already registered before extensions loaded.
+proto._resetExtensionEffects = function() {
+  for (const hook of resetHooks) hook.call(this);
+};
+
+proto.reset = function() {
+  this._resumeFrames?.();
+  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

@@ -1,131 +1,131 @@
-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;
-  const token = instance._transitionToken;
-  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 = () => {
-    if (token === instance._transitionToken) {
-      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);
-  if (token !== this._transitionToken) return;
-  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;
+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;
+  const token = instance._transitionToken;
+  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 = () => {
+    if (token === instance._transitionToken) {
+      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);
+  if (token !== this._transitionToken) return;
+  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-geometry.js

@@ -1,40 +1,40 @@
-const DEFAULT_HEAD_HEIGHT_SCALE = 0.9;
-
-const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
-const smooth01 = value => {
-  const t = clamp(value, 0, 1);
-  return t * t * (3 - 2 * t);
-};
-
-function flattenHeadPoints(points, heightScale = DEFAULT_HEAD_HEIGHT_SCALE) {
-  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;
-  if (!(height > 0)) return source;
-
-  const scale = clamp(Number(heightScale), 0.1, 1);
-  const centerY = (minY + maxY) / 2;
-  const inset = height * (1 - 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 };
-  });
-}
-
-export { DEFAULT_HEAD_HEIGHT_SCALE, flattenHeadPoints };
+const DEFAULT_HEAD_HEIGHT_SCALE = 0.9;
+
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+const smooth01 = value => {
+  const t = clamp(value, 0, 1);
+  return t * t * (3 - 2 * t);
+};
+
+function flattenHeadPoints(points, heightScale = DEFAULT_HEAD_HEIGHT_SCALE) {
+  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;
+  if (!(height > 0)) return source;
+
+  const scale = clamp(Number(heightScale), 0.1, 1);
+  const centerY = (minY + maxY) / 2;
+  const inset = height * (1 - 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 };
+  });
+}
+
+export { DEFAULT_HEAD_HEIGHT_SCALE, flattenHeadPoints };

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

@@ -0,0 +1,170 @@
+import AgentRobotAvatar, { registerAvatarExtension } from './agent-robot-avatar-extension-host.js';
+
+const proto=AgentRobotAvatar.prototype;
+const clamp=(v,a,b)=>Math.max(a,Math.min(b,v));
+const disabled=(face,key)=>face.getAttribute(key)==='false';
+const emit=(face,state)=>face.dispatchEvent(new CustomEvent('face-state',{detail:{state}}));
+const gazeTarget=(box,event)=>({
+  x:clamp((event.clientX-box.left-box.width/2)*.42,-48,48),
+  y:clamp((event.clientY-box.top-box.height/2)*.38,-34,34),
+});
+const SQUEEZE_HOLD_SECONDS=.14;
+
+function restore(face) {
+  face._headMotion.style.transform='';face._headMotion.removeAttribute('transform');
+  face._dragMotion.style.transform='';face._dragMotion.style.transformOrigin='';
+  face._headShape.setAttribute('d',face._baseHeadPathD);
+  face._antennaDot?.removeAttribute('transform');
+  if(face._antennaSpring)face._antennaSpring.initialized=false;
+  face._releaseExpressionLock();
+}
+
+proto._cancelGesture=function(silent=false) {
+  const fx=this._gestureFx;if(!fx)return;
+  this._gestureFx=null;
+  try{if(fx.pointerId!=null&&this.hasPointerCapture(fx.pointerId))this.releasePointerCapture(fx.pointerId);}catch(_){ }
+  if(!fx.committed)return;
+  restore(this);this._endGestureAction?.('cancel',false,silent);
+};
+
+function commit(face,s,look=null) {
+  if(s.committed||face._gestureFx!==s)return false;
+  face._gestureFx=null;
+  face.reset();
+  face._gestureFx=s;s.committed=true;face.noteActivity(false);face._expressionLock=true;
+  if(look){face._look.x=look.x;face._look.y=look.y;}
+  face._beginGestureAction?.(s.kind);emit(face,s.kind);face._resumeFrames();
+  return true;
+}
+
+proto.setPressSqueeze=function(enabled=true){
+  this.setAttribute('press-squeeze',String(Boolean(enabled)));
+  if(!enabled && this._gestureFx?.kind==='squeeze')this._cancelGesture();
+  return this;
+};
+// Antenna blinking was removed in 0.6. The method stays so existing calls keep working.
+let warnedAntennaFlash=false;
+proto.setAntennaFlash=function(){
+  if(!warnedAntennaFlash){
+    warnedAntennaFlash=true;
+    console.warn('agent-robot-avatar: setAntennaFlash() was removed in 0.6 and does nothing. It will be deleted in 1.0.');
+  }
+  return this;
+};
+proto.setAntennaDrag=function(enabled=true){
+  this.setAttribute('antenna-drag',String(Boolean(enabled)));
+  if(!enabled && this._gestureFx?.kind==='antenna-drag')this._cancelGesture();
+  return this;
+};
+
+proto._startGesture=function(event) {
+  if(event.button!==0||event.isPrimary===false||this._gestureFx?.held)return false;
+  const box=this.getBoundingClientRect(),dot=this._antennaDot;
+  const x=(event.clientX-box.left)/box.width-.5,y=(event.clientY-box.top)/box.height-.5;
+  const r=dot?.getBoundingClientRect(),radius=r?Math.max(10,Math.max(r.width,r.height)/2+3):0;
+  const onAntenna=r && Number(dot.getAttribute('opacity')??1)>.01 &&
+    Math.hypot(event.clientX-r.left-r.width/2,event.clientY-r.top-r.height/2)<=radius;
+  const kind=onAntenna&&!disabled(this,'antenna-drag')?'antenna-drag':
+    !onAntenna&&event.pointerType!=='touch'&&!disabled(this,'press-squeeze')&&x*x+y*y<=.32*.32?'squeeze':null;
+  if(!kind)return false;
+  event.preventDefault();
+  const home={x:Number(dot?.getAttribute('cx')??120),y:Number(dot?.getAttribute('cy')??12)};
+  const gaze=kind==='antenna-drag'?gazeTarget(box,event):null;
+  const currentLook=gaze?{...this._look}:null;
+  this._gestureFx={kind,held:true,pointerId:event.pointerId,startX:event.clientX,startY:event.clientY,
+    pointerType:event.pointerType,size:Math.max(1,box.width),threshold:clamp(box.width*.4,24,46),home,
+    start:performance.now(),last:performance.now(),age:0,releaseAge:0,maxDist:0,react:false,committed:false,
+    gazeX:gaze?.x??0,gazeY:gaze?.y??0,
+    q:0,v:0,pressure:0,apex:0,releaseDepth:1,x:0,y:0,vx:0,vy:0,hx:0,hy:0,hvx:0,hvy:0,tx:0,ty:0};
+  try{this.setPointerCapture(event.pointerId);}catch(_){ }
+  if(kind==='antenna-drag')commit(this,this._gestureFx,currentLook);
+  this._resumeFrames();return true;
+};
+
+proto._moveGesture=function(event) {
+  const s=this._gestureFx;if(!s?.held||s.pointerId!==event.pointerId)return;
+  if(s.kind==='antenna-drag'){
+    const gaze=gazeTarget(this.getBoundingClientRect(),event);s.gazeX=gaze.x;s.gazeY=gaze.y;
+  }
+  const dx=event.clientX-s.startX,dy=event.clientY-s.startY,dist=Math.hypot(dx,dy);
+  s.maxDist=Math.max(s.maxDist,dist);
+  if(s.kind==='squeeze'&&dist>4){
+    this._cancelGesture(true);this._startHeadDragFromGesture?.(event,s);return;
+  }
+  if(dist>2.5)this._suppressClick=true;
+  const gain=dist>s.threshold*.6 ? .24 : .19,scale=240/s.size;
+  s.tx=clamp(dx*scale*gain,-25,25);s.ty=clamp(dy*scale*gain,-25,25);
+  this._runtimeVisualDirty=true;this._resumeFrames();
+};
+
+proto._endGesture=function(event) {
+  const s=this._gestureFx;if(!s?.held||s.pointerId!==event.pointerId)return;
+  if(event.type==='pointercancel'){this._cancelGesture();return;}
+  if(!s.committed){this._cancelGesture(true);return;}
+  s.held=false;s.releaseAge=0;s.react=s.kind==='antenna-drag'&&s.maxDist>2.5;s.releaseDepth=Math.min(1,Math.abs(s.q));
+  const id=s.pointerId;s.pointerId=null;
+  try{if(this.hasPointerCapture(id))this.releasePointerCapture(id);}catch(_){ }
+  if(s.kind==='squeeze'&&s.age>.15)this._suppressClick=true;
+  this._runtimeVisualDirty=true;this._resumeFrames();
+};
+
+function finish(face,s) {
+  face._gestureFx=null;restore(face);emit(face,'idle');
+  face._endGestureAction?.('end',s.react);
+}
+
+function drawSqueeze(face,s,dt,reduced) {
+  if(reduced){s.q=s.held?1:0;s.v=0;}
+  else {
+    const omega=6/.57,k=s.held?omega*omega:190,d=s.held?2*omega:9,oldV=s.v;
+    for(let remaining=dt;remaining>0;){const h=Math.min(1/240,remaining);remaining-=h;s.v+=((s.held?1:0)-s.q)*k*h-s.v*d*h;s.q+=s.v*h;}
+    if(!s.held&&!s.apex&&oldV<0&&s.v>=0&&s.q<0)s.apex=s.age;
+  }
+  const pressure=s.held?clamp((s.q-.94)/.06,0,1):s.pressure*Math.exp(-s.releaseAge*20);
+  if(s.held)s.pressure=pressure;
+  const phase=s.age*2*Math.PI,jitter=reduced?0:2*pressure;
+  const ripple=s.apex ? .012*Math.exp(-(s.age-s.apex)*12)*Math.sin((s.age-s.apex)*72)*s.releaseDepth : 0;
+  const jelly=jitter*.005*Math.sin(phase*11)+ripple,scale=1-.29*s.q;
+  face._headFollow.setAttribute('transform','');
+  face._headMotion.style.transform=`translate(${jitter*(.7*Math.sin(phase*13)+.3*Math.sin(phase*19))}px,${jitter*.45*Math.sin(phase*17)}px) scale(${scale+jelly},${scale-jelly})`;
+  for(const [side,home,delta] of [['left',86,24],['right',154,-24]]) {
+    face['_'+side+'Eye'].setAttribute('transform',`translate(${home+delta*s.q} 126)`);
+    const eye=face['_'+side+'Base'];eye.setAttribute('rx',Math.max(0,54-31*s.q)/2);eye.setAttribute('ry',Math.max(.1,58-20*s.q)/2);eye.setAttribute('opacity','1');
+    face['_'+side+'InputBase'].setAttribute('opacity','0');
+    face['_'+side+'Top'].setAttribute('y','-126');face['_'+side+'Top'].setAttribute('height','90');
+    face['_'+side+'Bottom'].setAttribute('y','36');
+  }
+  if(face._antennaDot){face._antennaDot.setAttribute('cx',s.home.x+jitter*.6*Math.sin(phase*11-.5));face._antennaDot.setAttribute('cy',s.home.y+(1-scale+jelly)*78-s.v*.5);}
+  return !s.held&&(reduced||(s.releaseAge>.35&&Math.abs(s.q)<.0015&&Math.abs(s.v)<.018));
+}
+
+function drawAntennaDrag(face,s,dt,reduced) {
+  const settle=clamp((s.releaseAge-.45)/.35,0,1);
+  if(reduced){s.x=s.held?s.tx:0;s.y=s.held?s.ty:0;s.hx=s.x*.45;s.hy=s.y*.45;}
+  else for(let remaining=dt;remaining>0;){
+    const h=Math.min(1/240,remaining);remaining-=h;
+    if(s.held){const b=1-Math.exp(-45*h);s.x+=(s.tx-s.x)*b;s.y+=(s.ty-s.y)*b;s.vx=s.vy=0;}
+    else {const d=10+14*settle;s.vx+=(-460*s.x-d*s.vx)*h;s.vy+=(-460*s.y-d*s.vy)*h;s.x+=s.vx*h;s.y+=s.vy*h;}
+    const k=s.held?118:330,d=s.held?7.1:10+12*settle;
+    s.hvx+=(k*((s.held?s.x*.45:0)-s.hx)-d*s.hvx)*h;s.hvy+=(k*((s.held?s.y*.45:0)-s.hy)-d*s.hvy)*h;
+    s.hx+=s.hvx*h;s.hy+=s.hvy*h;
+  }
+  const pullX=clamp(s.hx,-25,25),pullY=clamp(s.hy,-25,25),radius=(50+Math.hypot(pullX,pullY)*.8)*.92;
+  const points=face._baseHeadPoints.map(p=>{const w=Math.exp(-((p.x-s.home.x)**2+(p.y-clamp(s.home.y,20,220))**2)/(2*radius*radius));return{x:p.x+pullX*w,y:p.y+pullY*w};});
+  face._headShape.setAttribute('d',face._pointsToPath(points));face._headFollow.setAttribute('transform','');
+  face._headMotion.style.transform=`translate(${s.hx*.12}px,${s.hy*.12}px) rotate(${s.hx*.08}deg)`;
+  const dot=face._antennaDot;
+  if(dot){const x=s.home.x+s.x,y=s.home.y+s.y,stretch=clamp(s.vy*.0004,-.06,.06);dot.setAttribute('cx',x);dot.setAttribute('cy',y);dot.setAttribute('transform',`translate(${x} ${y}) scale(${1+stretch} ${1-stretch}) translate(${-x} ${-y})`);}
+  return !s.held&&(reduced||(Math.max(Math.abs(s.x),Math.abs(s.y),Math.abs(s.hx),Math.abs(s.hy))<.025&&Math.max(Math.abs(s.vx),Math.abs(s.vy),Math.abs(s.hvx),Math.abs(s.hvy))<.06));
+}
+
+registerAvatarExtension({name:'gestures',reset(){this._cancelGesture(this._runtimeResetNotify===false);},draw(now){
+  const s=this._gestureFx;if(!s)return;
+  const dt=Math.min(.034,Math.max(0,(now-s.last)/1000));s.last=now;s.age+=dt;if(!s.held)s.releaseAge+=dt;
+  if(s.kind==='squeeze'&&!s.committed){
+    if(s.age<SQUEEZE_HOLD_SECONDS)return;
+    if(!commit(this,s))return;
+  }
+  const done=s.kind==='squeeze'?drawSqueeze(this,s,dt,this._isReducedMotion?.()):drawAntennaDrag(this,s,dt,this._isReducedMotion?.());
+  if(done)finish(this,s);
+}});