agent-robot-avatar 0.2.1 → 0.3.0

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

@@ -0,0 +1,744 @@
+import AgentRobotAvatar, { registerAvatarExtension } from './agent-robot-avatar-extension-host.js';
+
+const proto = AgentRobotAvatar.prototype;
+const basePlay = proto.play;
+const baseNoteActivity = proto.noteActivity;
+const baseSleep = proto.sleep;
+const baseWake = proto.wake;
+const baseAutoSleep = proto._autoSleep;
+const baseResetToIdle = proto._resetToIdle;
+const baseStartMorph = proto._startMorph;
+const baseAnimateHead = proto._animateHead;
+const baseUpdateBlink = proto._updateBlink;
+const baseUpdateLook = proto._updateLook;
+const baseUpdateHeadFollow = proto._updateHeadFollow;
+const baseUpdateDragJelly = proto._updateDragJelly;
+const baseOnPointerMove = proto._onPointerMove;
+const baseOnDragMove = proto._onDragMove;
+const baseOnDragStart = proto._onDragStart;
+const baseOnDragEnd = proto._onDragEnd;
+const baseResumeFrames = proto._resumeFrames;
+const baseCanPauseFrames = proto._canPauseFrames;
+const baseInput = proto.input;
+const baseStartWaiting = proto.startWaiting;
+const baseStopWaiting = proto.stopWaiting;
+
+const DEFAULT_SIZE = 112;
+const ACTION_ALIASES = Object.freeze({
+  idle: 'idle',
+  bored: 'bored',
+  waiting: 'waiting',
+  wait: 'waiting',
+  input: 'input',
+  send: 'send',
+  success: 'success',
+  failure: 'failure',
+  failed: 'failure',
+  fail: 'failure',
+  warning: 'warning',
+  inspect: 'inspect',
+  verify: 'inspect',
+  review: 'inspect',
+  angry: 'angry',
+  blocked: 'blocked',
+  'policy-blocked': 'blocked',
+  error: 'error',
+  'system-error': 'error',
+  'connection-error': 'error',
+  surprise: 'surprise',
+  sleep: 'sleep',
+  wake: 'wake',
+});
+
+let environmentEvent = null;
+let environmentClearQueued = false;
+
+function markEnvironmentEvent(event) {
+  environmentEvent = event;
+  if (environmentClearQueued) return;
+  environmentClearQueued = true;
+  queueMicrotask(() => {
+    environmentEvent = null;
+    environmentClearQueued = false;
+  });
+}
+
+// Core already owns the single shared window listeners. Capture on document so
+// policy context is available before the core's bubbling window handlers run,
+// without adding a second global window listener set per runtime feature.
+if (typeof document !== 'undefined') {
+  document.addEventListener('pointerdown', markEnvironmentEvent, true);
+  document.addEventListener('keydown', markEnvironmentEvent, true);
+}
+
+function normalizeAction(name) {
+  const raw = String(name || '').trim().toLowerCase();
+  return { raw, canonical: ACTION_ALIASES[raw] || null };
+}
+
+function wakePolicy(instance) {
+  const value = String(instance.getAttribute('wake-on') || 'activity').trim().toLowerCase();
+  return value === 'manual' || value === 'interaction' ? value : 'activity';
+}
+
+function requestedMotion(instance) {
+  const value = String(instance.getAttribute('motion') || 'auto').trim().toLowerCase();
+  return value === 'reduce' || value === 'full' ? value : 'auto';
+}
+
+function reducedMotion(instance) {
+  const requested = requestedMotion(instance);
+  if (requested === 'reduce') return true;
+  if (requested === 'full') return false;
+  if (instance._runtimeMotionQuery) return instance._runtimeMotionQuery.matches;
+  return typeof window !== 'undefined' && typeof window.matchMedia === 'function'
+    ? window.matchMedia('(prefers-reduced-motion: reduce)').matches
+    : false;
+}
+
+function emitActionState(instance, record, phase, silent = false) {
+  if (!record || (phase !== 'start' && record.terminal)) return;
+  if (phase !== 'start') record.terminal = true;
+  if (silent) return;
+  instance.dispatchEvent(new CustomEvent('action-state', {
+    detail: { action: record.action, phase, source: record.source },
+    bubbles: true,
+    composed: true,
+  }));
+}
+
+function cancelActiveAction(instance, { silent = false } = {}) {
+  const record = instance._activeActionState;
+  if (!record || record.terminal) return;
+  if (instance._activeActionState === record) instance._activeActionState = null;
+  emitActionState(instance, record, 'cancel', silent);
+}
+
+function beginAction(instance, action, source, continuous = false) {
+  cancelActiveAction(instance);
+  const record = {
+    id: (instance._actionStateSequence || 0) + 1,
+    action,
+    source,
+    continuous,
+    terminal: false,
+  };
+  instance._actionStateSequence = record.id;
+  instance._activeActionState = record;
+  emitActionState(instance, record, 'start');
+  return record;
+}
+
+function finishAction(instance, record, phase = 'end') {
+  if (!record || record.terminal) return;
+  if (instance._activeActionState !== record) return;
+  instance._activeActionState = null;
+  emitActionState(instance, record, phase);
+}
+
+function trackFiniteAction(instance, record, result) {
+  if (record.continuous) return;
+  if (result && typeof result.then === 'function') {
+    Promise.resolve(result).then(
+      () => finishAction(instance, record, 'end'),
+      () => finishAction(instance, record, 'cancel'),
+    );
+  } else {
+    finishAction(instance, record, 'end');
+  }
+}
+
+function parseSize(value) {
+  const text = String(value ?? '').trim();
+  const match = text.match(/^(?:\d+(?:\.\d+)?|\.\d+)(?:px)?$/i);
+  if (!match) return DEFAULT_SIZE;
+  const numeric = Number.parseFloat(text);
+  if (!Number.isFinite(numeric) || numeric <= 0) return DEFAULT_SIZE;
+  return numeric;
+}
+
+function applySize(instance) {
+  if (!instance.hasAttribute('size')) {
+    if (instance._runtimeSizeApplied) instance.style.removeProperty('--face-size');
+    instance._runtimeSizeApplied = false;
+    return;
+  }
+  const size = parseSize(instance.getAttribute('size'));
+  instance.style.setProperty('--face-size', `${size}px`);
+  instance._runtimeSizeApplied = true;
+}
+
+function hasVisibleLayout(instance) {
+  if (!instance.isConnected) return false;
+  const rects = instance.getClientRects?.();
+  if (!rects || rects.length === 0) return false;
+  const rect = instance.getBoundingClientRect();
+  return rect.width > 0 && rect.height > 0;
+}
+
+function cancelHeadAnimations(instance) {
+  const animations = instance._headMotion?.getAnimations?.() || [];
+  for (const animation of animations) animation.cancel();
+  if (instance._headMotion) instance._headMotion.style.transform = '';
+}
+
+function clearDragGeometry(instance, { preserveClick = false, releaseCapture = true } = {}) {
+  const drag = instance._dragJelly;
+  if (!drag) return;
+  const pointerId = drag.pointerId;
+  const suppressClick = preserveClick && drag.moved;
+
+  drag.active = false;
+  drag.returning = false;
+  drag.snapped = false;
+  drag.pointerId = null;
+  drag.pendingReaction = null;
+  drag.targetX = drag.targetY = drag.x = drag.y = drag.vx = drag.vy = 0;
+  drag.targetStretch = drag.stretch = drag.stretchVel = 0;
+  drag.targetShear = drag.shear = drag.shearVel = 0;
+  drag.targetPullX = drag.targetPullY = drag.pullX = drag.pullY = drag.pullVX = drag.pullVY = 0;
+  drag.angle = 0;
+  drag.maxDist = 0;
+  drag.ux = drag.uy = 0;
+  drag.anchorX = drag.anchorY = 50;
+  instance._pendingDragEvent = null;
+
+  if (releaseCapture && pointerId != null) {
+    try { instance.releasePointerCapture(pointerId); } catch (_) {}
+  }
+  if (instance._dragMotion) {
+    instance._dragMotion.style.transform = '';
+    instance._dragMotion.style.transformOrigin = '';
+  }
+  if (instance._headShape && instance._baseHeadPathD) {
+    instance._headShape.setAttribute('d', instance._baseHeadPathD);
+  }
+  instance._suppressClick = suppressClick;
+}
+
+function programActionOwnsExpression(instance) {
+  const record = instance._activeActionState;
+  if (record && !record.terminal && record.source !== 'interaction') return true;
+  return Boolean(
+    instance._waitingRequested ||
+    instance._waitingFx ||
+    instance._inputWanted ||
+    instance._inspectFx ||
+    instance._failureFx ||
+    instance._warningFx ||
+    instance._systemErrorShake ||
+    instance._sleeping ||
+    (instance._expressionLock && instance._state !== 'idle')
+  );
+}
+
+function startDragReaction(instance, reaction) {
+  if (!reaction || programActionOwnsExpression(instance)) return;
+  const result = reaction === 'angry'
+    ? instance.angry({ fromDrag: true })
+    : instance.success({ fromDrag: true });
+  const record = beginAction(instance, 'reaction', 'interaction', false);
+  trackFiniteAction(instance, record, result);
+}
+
+function finishDragReturn(instance, reaction) {
+  clearDragGeometry(instance, { preserveClick: true, releaseCapture: false });
+  startDragReaction(instance, reaction);
+}
+
+function applyDragTransform(instance) {
+  const drag = instance._dragJelly;
+  if (!drag) return;
+  instance._applyHeadDeform?.();
+  if (!instance._dragMotion) return;
+  const sx = 1 + drag.stretch;
+  const sy = 1 - drag.stretch * 0.30;
+  const shearDeg = drag.shear * 180 / Math.PI;
+  instance._dragMotion.style.transformOrigin = `${drag.anchorX.toFixed(2)}% ${drag.anchorY.toFixed(2)}%`;
+  instance._dragMotion.style.transform = `translate(${drag.x.toFixed(2)}px, ${drag.y.toFixed(2)}px) rotate(${drag.angle.toFixed(4)}rad) scale(${sx.toFixed(4)}, ${sy.toFixed(4)}) skewY(${shearDeg.toFixed(3)}deg) rotate(${(-drag.angle).toFixed(4)}rad)`;
+}
+
+function flushPointerWork(instance) {
+  const pointer = instance._pendingPointerEvent;
+  instance._pendingPointerEvent = null;
+  if (pointer) {
+    baseOnPointerMove.call(instance, pointer);
+    instance._runtimePointerFlushCount = (instance._runtimePointerFlushCount || 0) + 1;
+  }
+
+  const drag = instance._pendingDragEvent;
+  instance._pendingDragEvent = null;
+  if (drag && instance._dragJelly?.active && drag.pointerId === instance._dragJelly.pointerId) {
+    baseOnDragMove.call(instance, drag);
+    instance._runtimeDragFlushCount = (instance._runtimeDragFlushCount || 0) + 1;
+  }
+}
+
+function setRuntimeVisible(instance, visible) {
+  const next = visible === true;
+  if (instance._runtimeVisible === next) return;
+  instance._runtimeVisible = next;
+  if (!next) {
+    if (instance._raf) cancelAnimationFrame(instance._raf);
+    instance._raf = 0;
+    instance._framePaused = true;
+    instance._pendingPointerEvent = null;
+    if (instance._dragJelly?.active || instance._dragJelly?.returning) {
+      clearDragGeometry(instance, { preserveClick: true });
+    }
+    cancelHeadAnimations(instance);
+    if (instance._antennaSpring) {
+      instance._antennaSpring.vx = 0;
+      instance._antennaSpring.vy = 0;
+      instance._antennaSpring.initialized = false;
+    }
+    return;
+  }
+  instance._resumeFrames?.();
+}
+
+function handleMotionChange(instance) {
+  if (reducedMotion(instance)) {
+    cancelHeadAnimations(instance);
+    instance._blinkAnim = null;
+    instance._blink = 1;
+    instance._boredRoutine = null;
+    instance._boredLookSpeed = null;
+    instance._wanderTarget.x = 0;
+    instance._wanderTarget.y = 0;
+    instance._look.x = 0;
+    instance._look.y = 0;
+    instance._pose = { ...instance._toPose };
+    instance._fromPose = { ...instance._toPose };
+    instance._morphDuration = 0;
+    if (instance._dragJelly?.returning) finishDragReturn(instance, instance._dragJelly.pendingReaction);
+  }
+  instance._resumeFrames?.();
+}
+
+function ensureRuntime(instance) {
+  if (instance._runtimePolicyReady) return;
+  instance._runtimePolicyReady = true;
+  if (!instance.style.touchAction) instance.style.touchAction = 'pinch-zoom';
+  applySize(instance);
+
+  if (typeof window !== 'undefined' && typeof window.matchMedia === 'function') {
+    const query = window.matchMedia('(prefers-reduced-motion: reduce)');
+    const listener = () => handleMotionChange(instance);
+    instance._runtimeMotionQuery = query;
+    instance._runtimeMotionListener = listener;
+    if (query.addEventListener) query.addEventListener('change', listener);
+    else query.addListener?.(listener);
+  }
+
+  if (typeof MutationObserver !== 'undefined') {
+    instance._runtimeAttributeObserver = new MutationObserver(records => {
+      let motionChanged = false;
+      for (const record of records) {
+        if (record.attributeName === 'size') applySize(instance);
+        if (record.attributeName === 'motion') motionChanged = true;
+      }
+      if (motionChanged) handleMotionChange(instance);
+    });
+    instance._runtimeAttributeObserver.observe(instance, {
+      attributes: true,
+      attributeFilter: ['size', 'motion', 'wake-on'],
+    });
+  }
+
+  if (typeof IntersectionObserver !== 'undefined') {
+    instance._runtimeIntersectionObserver = new IntersectionObserver(entries => {
+      const entry = entries[entries.length - 1];
+      if (!entry) return;
+      instance._runtimeIntersecting = entry.isIntersecting;
+      setRuntimeVisible(instance, entry.isIntersecting && hasVisibleLayout(instance));
+    });
+    instance._runtimeIntersectionObserver.observe(instance);
+  }
+
+  if (typeof ResizeObserver !== 'undefined') {
+    instance._runtimeResizeObserver = new ResizeObserver(() => {
+      const inView = instance._runtimeIntersecting !== false;
+      setRuntimeVisible(instance, inView && hasVisibleLayout(instance));
+    });
+    instance._runtimeResizeObserver.observe(instance);
+  }
+
+  instance._runtimeVisible = hasVisibleLayout(instance);
+  instance._runtimeLostCapture = event => {
+    if (instance._dragJelly?.active && event.pointerId === instance._dragJelly.pointerId) {
+      clearDragGeometry(instance, { preserveClick: false, releaseCapture: false });
+    }
+  };
+  instance.addEventListener('lostpointercapture', instance._runtimeLostCapture);
+
+  if (!instance._runtimeLoopWrapped && typeof instance._loop === 'function') {
+    const loop = instance._loop;
+    instance._loop = ts => {
+      flushPointerWork(instance);
+      return loop(ts);
+    };
+    instance._runtimeLoopWrapped = true;
+  }
+}
+
+function teardownRuntime(instance) {
+  instance._runtimeIntersectionObserver?.disconnect();
+  instance._runtimeResizeObserver?.disconnect();
+  instance._runtimeAttributeObserver?.disconnect();
+  if (instance._runtimeMotionQuery && instance._runtimeMotionListener) {
+    if (instance._runtimeMotionQuery.removeEventListener) {
+      instance._runtimeMotionQuery.removeEventListener('change', instance._runtimeMotionListener);
+    } else {
+      instance._runtimeMotionQuery.removeListener?.(instance._runtimeMotionListener);
+    }
+  }
+  if (instance._runtimeLostCapture) {
+    instance.removeEventListener('lostpointercapture', instance._runtimeLostCapture);
+  }
+  instance._runtimeIntersectionObserver = null;
+  instance._runtimeResizeObserver = null;
+  instance._runtimeAttributeObserver = null;
+  instance._runtimeMotionQuery = null;
+  instance._runtimeMotionListener = null;
+  instance._runtimeLostCapture = null;
+  instance._runtimePolicyReady = false;
+  instance._runtimeVisible = false;
+}
+
+function eventTargetsAvatar(event, instance) {
+  const path = event?.composedPath?.();
+  if (Array.isArray(path)) return path.includes(instance);
+  return event?.target === instance || instance.contains?.(event?.target);
+}
+
+proto._isReducedMotion = function() {
+  return reducedMotion(this);
+};
+
+proto.noteActivity = function(wake = true) {
+  ensureRuntime(this);
+  if (!wake || !this._sleeping) return baseNoteActivity.call(this, wake);
+
+  const event = environmentEvent;
+  if (!event) return baseNoteActivity.call(this, wake);
+
+  const policy = wakePolicy(this);
+  const shouldWake = policy === 'activity' || (policy === 'interaction' && eventTargetsAvatar(event, this));
+  if (!shouldWake) return baseNoteActivity.call(this, false);
+
+  const previousSource = this._runtimeActionSource;
+  this._runtimeActionSource = 'automatic';
+  try {
+    return baseNoteActivity.call(this, true);
+  } finally {
+    this._runtimeActionSource = previousSource;
+  }
+};
+
+proto._resetToIdle = function(notify = true) {
+  const previous = this._runtimeResetNotify;
+  this._runtimeResetNotify = notify;
+  try {
+    return baseResetToIdle.call(this, notify);
+  } finally {
+    this._runtimeResetNotify = previous;
+  }
+};
+
+proto._startMorph = function(target, duration, ease) {
+  return baseStartMorph.call(this, target, reducedMotion(this) ? 0 : duration, ease);
+};
+
+proto._animateHead = function(frames, duration) {
+  if (reducedMotion(this)) {
+    cancelHeadAnimations(this);
+    return undefined;
+  }
+  return baseAnimateHead.call(this, frames, duration);
+};
+
+proto._updateBlink = function(now) {
+  if (!reducedMotion(this)) return baseUpdateBlink.call(this, now);
+  this._blinkAnim = null;
+  this._blink = 1;
+};
+
+proto._updateLook = function(now, dt) {
+  if (!reducedMotion(this)) return baseUpdateLook.call(this, now, dt);
+  this._boredRoutine = null;
+  this._boredLookSpeed = null;
+  this._wanderTarget.x = this._wanderTarget.y = 0;
+  this._wander.x = this._wander.y = 0;
+  this._look.x = this._look.y = 0;
+};
+
+proto._updateHeadFollow = function(now, dt) {
+  if (!reducedMotion(this)) return baseUpdateHeadFollow.call(this, now, dt);
+  this._headFollowPose.x = this._headFollowPose.y = this._headFollowPose.rot = 0;
+  this._headFollowVel.x = this._headFollowVel.y = this._headFollowVel.rot = 0;
+  if (this._headFollow) this._headFollow.setAttribute('transform', '');
+};
+
+proto._updateDragJelly = function(dt) {
+  if (!reducedMotion(this)) return baseUpdateDragJelly.call(this, dt);
+  const drag = this._dragJelly;
+  if (!drag) return;
+  if (drag.active) {
+    drag.x = drag.targetX;
+    drag.y = drag.targetY;
+    drag.stretch = drag.targetStretch;
+    drag.shear = drag.targetShear;
+    drag.pullX = drag.targetPullX;
+    drag.pullY = drag.targetPullY;
+    applyDragTransform(this);
+  } else if (drag.returning) {
+    finishDragReturn(this, drag.pendingReaction);
+  }
+};
+
+proto._onPointerMove = function(event) {
+  ensureRuntime(this);
+  if (this._runtimeVisible === false) return;
+  this._pendingPointerEvent = {
+    clientX: event.clientX,
+    clientY: event.clientY,
+  };
+  this._resumeFrames?.();
+};
+
+proto._onDragMove = function(event) {
+  ensureRuntime(this);
+  if (!this._dragJelly?.active || event.pointerId !== this._dragJelly.pointerId) return;
+  this._pendingDragEvent = {
+    clientX: event.clientX,
+    clientY: event.clientY,
+    pointerId: event.pointerId,
+  };
+  this._resumeFrames?.();
+};
+
+proto._onDragStart = function(event) {
+  ensureRuntime(this);
+  if (this._dragJelly?.active) return;
+  if (event.pointerType === 'touch' && event.isPrimary === false) return;
+  return baseOnDragStart.call(this, event);
+};
+
+proto._onDragEnd = function(event) {
+  const drag = this._dragJelly;
+  if (!drag?.active || event.pointerId !== drag.pointerId) return;
+  flushPointerWork(this);
+  if (event.type === 'pointercancel') {
+    clearDragGeometry(this, { preserveClick: false });
+    return;
+  }
+  baseOnDragEnd.call(this, event);
+  if (reducedMotion(this) && drag.returning) finishDragReturn(this, drag.pendingReaction);
+};
+
+proto._finishDragReturn = function(reaction) {
+  finishDragReturn(this, reaction);
+};
+
+proto._resumeFrames = function() {
+  ensureRuntime(this);
+  if (this._runtimeVisible === false) return;
+  return baseResumeFrames.call(this);
+};
+
+proto._canPauseFrames = function(now) {
+  if (this._runtimeVisible === false) return true;
+  if (!reducedMotion(this)) return baseCanPauseFrames.call(this, now);
+  if (this._pendingPointerEvent || this._pendingDragEvent) return false;
+  return true;
+};
+
+function playNoOp(instance, canonical) {
+  if (canonical === 'wake') return !instance._sleeping && instance._state !== 'sleep';
+  if (canonical === 'sleep') return instance._sleeping === true;
+  if (canonical === 'input') return instance._inputWanted || instance._state === 'input';
+  return false;
+}
+
+function leaveSleepForAction(instance) {
+  if (!instance._sleeping && instance._state !== 'sleep') return;
+  instance._sleeping = false;
+  instance.setState('idle', { duration: reducedMotion(instance) ? 0 : 120 });
+}
+
+function prepareReplacement(instance, canonical) {
+  cancelActiveAction(instance);
+  clearDragGeometry(instance, { preserveClick: true });
+  instance._cancelPendingWaits?.();
+  if (canonical !== 'sleep' && canonical !== 'wake' && canonical !== 'idle') {
+    leaveSleepForAction(instance);
+  }
+}
+
+proto.play = function(name) {
+  ensureRuntime(this);
+  const { raw, canonical } = normalizeAction(name);
+  if (!canonical) throw new Error(`Unknown Agent Robot Avatar action: ${name}`);
+  if (playNoOp(this, canonical)) return this;
+  if (canonical === 'idle') return basePlay.call(this, raw);
+
+  prepareReplacement(this, canonical);
+
+  let result;
+  this._runtimeInPlay = true;
+  try {
+    result = basePlay.call(this, raw);
+  } finally {
+    this._runtimeInPlay = false;
+  }
+
+  const record = beginAction(this, canonical, 'api', canonical === 'input');
+  trackFiniteAction(this, record, result);
+  if (reducedMotion(this)) queueMicrotask(() => cancelHeadAnimations(this));
+  return result;
+};
+
+proto.input = function(active = true) {
+  if (this._runtimeInPlay) return baseInput.call(this, active);
+  ensureRuntime(this);
+  if (active) {
+    if (this._inputWanted || this._state === 'input') return this;
+    prepareReplacement(this, 'input');
+    const result = baseInput.call(this, true);
+    beginAction(this, 'input', 'api', true);
+    return result;
+  }
+
+  const record = this._activeActionState?.action === 'input' ? this._activeActionState : null;
+  const result = baseInput.call(this, false);
+  if (record) finishAction(this, record, 'end');
+  return result;
+};
+
+proto.startWaiting = async function() {
+  ensureRuntime(this);
+  const result = await baseStartWaiting.call(this);
+  if (this._waitingRequested && this._waitingFx) beginAction(this, 'waiting', 'api', true);
+  return result;
+};
+
+proto.stopWaiting = function() {
+  ensureRuntime(this);
+  const record = this._activeActionState?.action === 'waiting' ? this._activeActionState : null;
+  this._runtimeEndingWaiting = true;
+  let result;
+  try {
+    result = baseStopWaiting.call(this);
+  } finally {
+    this._runtimeEndingWaiting = false;
+  }
+  if (record) finishAction(this, record, 'end');
+  return result;
+};
+
+proto.sleep = function() {
+  if (this._runtimeInPlay) return baseSleep.call(this);
+  ensureRuntime(this);
+  if (this._sleeping) return this;
+  prepareReplacement(this, 'sleep');
+  const source = this._runtimeActionSource || 'api';
+  const result = baseSleep.call(this);
+  const record = beginAction(this, 'sleep', source, false);
+  trackFiniteAction(this, record, result);
+  return result;
+};
+
+proto.wake = function() {
+  if (this._runtimeInPlay) return baseWake.call(this);
+  ensureRuntime(this);
+  if (!this._sleeping && this._state !== 'sleep') return this;
+  prepareReplacement(this, 'wake');
+  const source = this._runtimeActionSource || 'api';
+  const result = baseWake.call(this);
+  const record = beginAction(this, 'wake', source, false);
+  trackFiniteAction(this, record, result);
+  return result;
+};
+
+proto._autoSleep = function(now) {
+  const previousSource = this._runtimeActionSource;
+  this._runtimeActionSource = 'automatic';
+  try {
+    return baseAutoSleep.call(this, now);
+  } finally {
+    this._runtimeActionSource = previousSource;
+  }
+};
+
+function setMask(top, bottom, topY, bottomY, topAngle = 0, bottomAngle = 0) {
+  if (top) {
+    top.setAttribute('y', (topY - 90).toFixed(2));
+    top.setAttribute('height', '90');
+    top.setAttribute('transform', `rotate(${topAngle.toFixed(2)} 0 ${topY.toFixed(2)})`);
+  }
+  if (bottom) {
+    bottom.setAttribute('y', bottomY.toFixed(2));
+    bottom.setAttribute('height', '90');
+    bottom.setAttribute('transform', `rotate(${bottomAngle.toFixed(2)} 0 ${bottomY.toFixed(2)})`);
+  }
+}
+
+function setEye(eye, x, y = 126, sx = 1, sy = 1) {
+  if (eye) eye.setAttribute('transform', `translate(${x.toFixed(2)} ${y.toFixed(2)}) scale(${sx.toFixed(3)} ${sy.toFixed(3)})`);
+}
+
+function drawReducedState(instance) {
+  if (!reducedMotion(instance)) return;
+  if (instance._state === 'input') {
+    instance._leftInputBase?.setAttribute('opacity', '1');
+    instance._rightInputBase?.setAttribute('opacity', '1');
+  }
+  if (instance._antennaDot) instance._antennaDot.style.opacity = '1';
+
+  if (instance._waitingFx) {
+    setEye(instance._leftEye, 100, 126, 0.92, 1);
+    setEye(instance._rightEye, 140, 126, 0.92, 1);
+    return;
+  }
+  if (instance._inspectFx) {
+    setEye(instance._leftEye, 86);
+    setEye(instance._rightEye, 154);
+    setMask(instance._leftTop, instance._leftBottom, -8, 8);
+    setMask(instance._rightTop, instance._rightBottom, -8, 8);
+    return;
+  }
+  if (instance._warningFx) {
+    setEye(instance._leftEye, 100, 126, 1.16, 1.10);
+    setEye(instance._rightEye, 172, 132, 0.84, 0.96);
+    setMask(instance._leftTop, instance._leftBottom, -18, 35, 8, 0);
+    setMask(instance._rightTop, instance._rightBottom, -20, 36, -7, 0);
+    return;
+  }
+  if (instance._systemErrorShake) {
+    setMask(instance._leftTop, instance._leftBottom, -5, 36, -15, 0);
+    setMask(instance._rightTop, instance._rightBottom, -5, 36, 15, 0);
+  }
+}
+
+registerAvatarExtension({
+  name: 'runtime-policy',
+  reset() {
+    const silent = this._runtimeResetNotify === false;
+    if (!this._runtimeEndingWaiting) cancelActiveAction(this, { silent });
+    clearDragGeometry(this, { preserveClick: !silent });
+    this._pendingPointerEvent = null;
+    if (!this.isConnected) teardownRuntime(this);
+  },
+  draw() {
+    ensureRuntime(this);
+    drawReducedState(this);
+  },
+});
+
+export {
+  AgentRobotAvatar,
+  ACTION_ALIASES,
+  DEFAULT_SIZE,
+};
+export default AgentRobotAvatar;