@lovelace_lol/polymer 0.0.10 → 0.0.11

package/dist/index.d.ts

@@ -197,14 +197,14 @@ export interface HairPhysicsProfileConfig {
   impulseClipDuration?: number;
   direction?: { yawSign?: 1 | -1; pitchSign?: 1 | -1 };
   morphTargets?: {
-    swayLeft?: HairMorphTargetMapping;
-    swayRight?: HairMorphTargetMapping;
-    swayFront?: HairMorphTargetMapping;
-    fluffRight?: HairMorphTargetMapping;
-    fluffBottom?: HairMorphTargetMapping;
-    headUp?: Record<string, HairMorphTargetValueMapping>;
-    headDown?: Record<string, HairMorphTargetValueMapping>;
-  };
+    swayLeft?: HairMorphTargetMapping | null;
+    swayRight?: HairMorphTargetMapping | null;
+    swayFront?: HairMorphTargetMapping | null;
+    fluffRight?: HairMorphTargetMapping | null;
+    fluffBottom?: HairMorphTargetMapping | null;
+    headUp?: Record<string, HairMorphTargetValueMapping | null> | null;
+    headDown?: Record<string, HairMorphTargetValueMapping | null> | null;
+  } | null;
 }
 
 export type VRMHumanoidRole =
@@ -369,13 +369,6 @@ export interface Profile {
   annotationRegions?: Region[];
   disabledRegions?: string[];
   hairPhysics?: HairPhysicsProfileConfig;
-  gazeCalibration?: {
-    head?: { opticalAxis?: PolymerVector3 };
-    leftEye?: { opticalAxis?: PolymerVector3 };
-    rightEye?: { opticalAxis?: PolymerVector3 };
-    /** Authored model coordinate units per physical meter, before root scaling. */
-    modelUnitsPerMeter?: number;
-  };
   humanoidCharacterization?: HumanoidCharacterization;
   /** Authored overrides may patch individual fields; null removes a preset control. */
   bodyControls?: Record<string, Partial<BodyControlDefinition> | null>;
@@ -488,8 +481,6 @@ export interface ModelAnalysisReport { model: ModelData; validation?: Validation
 
 export interface AnnotationLaterality { leftSideX: 1 | -1; confidence: number; evidence: string[]; }
 export interface BoneResolutionProfile { bonePrefix?: string; boneSuffix?: string; boneNodes?: Record<string, string>; suffixPattern?: string; }
-export interface CameraRelativeGazeOffset { x: number; y: number; }
-export interface CameraRelativeGazeOptions { yawWeight?: number; pitchWeight?: number; epsilon?: number; }
 export interface MarkerEndpointSeparationOptions { starts: ArrayLike<number>; ends: ArrayLike<number>; modelCenter: { x: number; y: number; z: number }; modelHeight: number; }
 
 export interface HumanoidSkeletonTemplateBone { readonly name: string; readonly parent: string | null; readonly translation: HumanoidSkeletonTemplateVec3; }
@@ -509,7 +500,7 @@ export interface CharacterHostCharacterOptions extends CharacterModelTransform {
 export interface CharacterHostExternalScene { scene: Scene; renderer: CharacterSceneRenderer; backend?: CharacterSceneBackend; rendering?: CharacterSceneRenderingController; camera: Camera; mountCanvas?: boolean; manageResize?: boolean; }
 /** Cancellation applies only until creation resolves; dispose the resolved host explicitly. */
 export interface CharacterHostOptions { signal?: AbortSignal; container: HTMLElement; character: CharacterHostCharacterOptions; embody?: RustEmbodyHostConfig; scene?: Omit<DefaultCharacterSceneAsyncOptions, 'signal'>; external?: CharacterHostExternalScene; loader?: CharacterModelLoadOptions; autoStart?: boolean; renderLoop?: boolean; autoFrame?: boolean; }
-export interface CharacterHost { engine: Embody; scene: Scene; readonly renderer: CharacterSceneRenderer; readonly backend: CharacterSceneBackend | null; readonly rendering: CharacterSceneRenderingController | null; camera: Camera | PerspectiveCamera; model: Object3D; meshes: Mesh[]; animations: AnimationClip[]; lighting: DefaultCharacterLightingController | null; ownsScene: boolean; container: HTMLElement; setCharacter(character: CharacterHostCharacterOptions, loader?: CharacterModelLoadOptions): Promise<void>; resize(): void; dispose(): Promise<void>; }
+export interface CharacterHost { engine: Embody; scene: Scene; readonly renderer: CharacterSceneRenderer | null; readonly backend: CharacterSceneBackend | null; readonly rendering: CharacterSceneRenderingController | null; camera: Camera | PerspectiveCamera; model: Object3D; meshes: Mesh[]; animations: AnimationClip[]; lighting: DefaultCharacterLightingController | null; ownsScene: boolean; container: HTMLElement; setCharacter(character: CharacterHostCharacterOptions, loader?: CharacterModelLoadOptions): Promise<void>; resize(): void; dispose(): Promise<void>; }
 
 export interface CharacterRegistry { characters: CharacterConfig[]; defaultCharacter?: string; }
 export type AnimationSource = 'baked' | 'clip' | 'snippet';
@@ -612,11 +603,8 @@ export interface WasmRuntimeCore {
   get_viseme(index: number): number;
   get_viseme_jaw_scale(index: number): number;
   set_viseme_slot_count(count: number): void;
-  transition_au(id: number, to: number, durationMs: number, balance: number): void;
-  transition_viseme(index: number, to: number, durationMs: number, jawScale: number): void;
-  update(dtSeconds: number): number;
-  active_transition_count(): number;
-  clear_transitions(): void;
+  build_live_clip(name: string, durationSec: number): string;
+  build_live_release_clip(name: string, previousClipJSON: string, durationSec: number): string;
   clear(): void;
   evaluate_morph_frame_delta(): Float32Array;
   evaluate_bone_frame_delta(): Float32Array;
@@ -654,19 +642,6 @@ export interface EmbodyCoreWasmModule {
     manualScale: number,
     manualTranslation: Float32Array
   ): Float32Array;
-  solve_profile_screen_space_gaze(
-    profileJson: string,
-    screenTarget: Float32Array,
-    cameraPosition: Float32Array,
-    cameraQuaternion: Float32Array,
-    gazeOrigin: Float32Array,
-    modelQuaternion: Float32Array,
-    verticalFovDegrees: number,
-    aspect: number,
-    eyesEnabled: boolean,
-    headEnabled: boolean,
-    headFollowFraction: number
-  ): Float32Array;
   default_hair_physics_config_values(): Float32Array;
   list_presets(): string[];
   has_preset(presetId: string): boolean;
@@ -701,13 +676,11 @@ export type RustEmbodyHostConfig =
     };
 
 /**
- * Polymer's CLJS-owned character runtime contract.
- *
- * Rust owns profile intake and frame evaluation. The remaining methods are the
- * public Three.js and AnimationMixer capabilities consumed by application
- * hosts; no concrete TypeScript Embody class is implied.
+ * Public character controls implemented by Embody's Three.js connector.
+ * Rust compiles clips; the existing Three renderer advances native playback.
  */
 export interface PolymerCharacterRuntime {
+  readonly model: Object3D | undefined;
   readonly meshes: unknown[];
   readonly meshByName: Map<string, unknown>;
   readonly bones: Record<string, unknown>;
@@ -734,7 +707,7 @@ export interface PolymerCharacterRuntime {
   applySemanticPose(pose: SemanticPose): void;
   validateSemanticAnimation(animation: SemanticAnimation, options?: SemanticAnimationOptions): void;
   semanticAnimationToClip(name: string, animation: SemanticAnimation, options?: SemanticAnimationOptions): AnimationPlaybackHandle;
-  /** Reset configured body actions atomically and apply one procedural frame. */
+  /** Reset configured body actions atomically; the next native mixer frame applies the pose. */
   resetBodyControls(): void;
   setContinuum(negAU: number, posAU: number, value: number, balance?: number): void;
   getContinuum(negAU: number, posAU: number): number;
@@ -746,7 +719,7 @@ export interface PolymerCharacterRuntime {
   /** Canonical direct jaw scale; unset, cleared or out-of-range slots return 1. */
   getVisemeJawScale(index: number): number;
   setVisemeById(slotId: string, value: number, jawScale?: number): void;
-  /** Mixer-timed live control; defaults to 80 ms. getViseme reports the sampled direct value. */
+  /** Mixer-timed live control; defaults to 80 ms. getViseme reports its destination immediately. */
   transitionViseme(index: number, to: number, durationMs?: number, jawScale?: number): TransitionHandle;
   transitionVisemeById(slotId: string, to: number, durationMs?: number, jawScale?: number): TransitionHandle;
   setAUMixWeight(id: number, weight: number): void;
@@ -792,7 +765,6 @@ export interface PolymerCharacterRuntime {
   setHairPhysicsConfig(config: HairPhysicsRuntimeConfigUpdate): void;
   getHairPhysicsConfig(): HairPhysicsRuntimeConfig;
   validateHairMorphTargets(): string[];
-  updateHairPhysics(dtSeconds: number): void;
   loadAnimationClips(clips: unknown[]): void;
   /**
    * Register additional baked sources on a bound model without starting clips
@@ -824,13 +796,6 @@ export interface PolymerCharacterRuntime {
     options?: Record<string, unknown>
   ): AnimationPlaybackHandle;
   cleanupSnippet(name: string): void;
-  /** Read-only seed for gaze motor controls in the current evaluated pose. */
-  getGazeControlState(options?: { worldTarget?: PolymerVector3; headIntensity?: number; eyeIntensity?: number }): GazeControlState | null;
-  /** Last evaluated optical-ray diagnostics; null without active focus controls. */
-  getGazeFocusDiagnostics(): GazeFocusDiagnostics | null;
-  /** Fresh immutable copy of the last positive-dt pose update; polling does not renew its stamp. */
-  getGazeObservation(): GazeObservation | null;
-  update(dtSeconds: number): void;
   start(): void;
   stop(): void;
   clear(): void;
@@ -838,7 +803,18 @@ export interface PolymerCharacterRuntime {
   dispose(): void;
 }
 
-export interface AnimationPlaybackHandle extends TransitionHandle {
+export interface AnimationPlaybackEvent {
+  type: 'completed' | 'cancelled' | 'error';
+  handle: string;
+  actionId?: string;
+  clipName?: string;
+  reason?: string;
+  message?: string;
+}
+
+export interface AnimationPlaybackHandle extends Omit<TransitionHandle, 'promise'> {
+  promise: Promise<AnimationPlaybackEvent>;
+  finished: Promise<AnimationPlaybackEvent>;
   name: string;
   actionId?: string;
   play(): AnimationPlaybackHandle;
@@ -856,6 +832,8 @@ export declare class Embody {
   [key: string]: any;
 }
 
+export declare function createScenePlaybackFrame(scene: Object3D, document?: Document): { onFrame(timestamp?: number): void; dispose(): void };
+
 export declare function createRustEmbodyHost(
   model: unknown,
   config?: RustEmbodyHostConfig
@@ -910,17 +888,9 @@ export declare function resolveBoneAxisChannel(profile: Profile, boneName: strin
 export declare function resolveBoneNameForNodeKey(profile: Profile, nodeKey: string): string | null;
 export declare function resolveContinuumDisplayLabel(profile: Pick<Profile, 'continuumPairs' | 'continuumLabels' | 'auInfo' | 'boneNodes' | 'bonePrefix' | 'boneSuffix'>, negativeAuId: number, positiveAuId: number): string;
 export declare function stripConfiguredBoneAffixes(profile: { bonePrefix?: string; boneSuffix?: string } | null | undefined, boneName: string): string;
-export declare function computeCameraRelativeGazeOffset(model: Object3D | null, cameraPosition: { x: number; y: number; z: number }, targetPosition: { x: number; y: number; z: number }, options?: CameraRelativeGazeOptions): CameraRelativeGazeOffset;
-export declare function solveScreenSpaceGaze(options: ScreenSpaceGazeOptions): ScreenSpaceGazeSolution;
-export declare function createEmbodyGazeRuntime(
-  profileProvider: Profile | (() => Profile),
-  host?: Pick<PolymerCharacterRuntime, 'getGazeControlState'>
-): EmbodyGazeRuntime;
 export declare function fuzzyNameMatch(objectName: string, targetName: string, suffixPattern?: string): boolean;
 export declare function getMeshNamesForAUProfile(profile: Profile, auId: number): string[];
-export declare function hasLeftRightMorphs(auId: number): boolean;
 export declare function hasLeftRightMorphs(profile: Profile, auId: number): boolean;
-export declare function isMixedAU(auId: number): boolean;
 export declare function isMixedAU(profile: Profile, auId: number): boolean;
 export declare function resolveBoneNames(names: string[] | undefined, profile?: BoneResolutionProfile): string[];
 /** All 55 VRM 1.0 roles, including required flags and optional-parent rules. */
@@ -932,8 +902,6 @@ export declare function setAUMorphTargets(profile: Profile, auId: number, side:
 export declare function resolveHumanoidCharacterization(profile: Profile): HumanoidCharacterizationResolution;
 /** With a model, reports missing bone/morph targets against the actual scene. */
 export declare function getBodyControls(profile: Profile, model?: Object3D): BodyControlDescriptor[];
-export declare function resolveCharacterGazeOrigin(model: Object3D, profile?: Profile | null): Vector3 | null;
-export declare const CC4_BONES: Record<string, string>;
 export declare const VISEME_KEYS: string[];
 export declare const HAIR_COLOR_PRESETS: Record<string, HairColorAppearance>;
 export declare const DEFAULT_HAIR_COLOR_APPEARANCE: HairColorAppearance;
@@ -984,409 +952,12 @@ export interface BlinkState {
 
 export type BlinkAgencyConfig = Partial<Omit<BlinkState, 'agency'>>;
 
-export interface GazeTarget {
+export interface PerceptionTarget {
   x: number;
   y: number;
   z?: number;
 }
 
-export interface GazeControlState {
-  headSeedLimited?: boolean;
-  eyeSeedLimited?: boolean;
-  target?: Required<GazeTarget>;
-  eyeTarget: Required<GazeTarget>;
-  headTarget: Required<GazeTarget>;
-  headRoll: number;
-}
-
-export interface GazeFocusRequest {
-  worldTarget: PolymerVector3;
-  target: Required<GazeTarget>;
-  headTarget?: Required<GazeTarget>;
-  eyesEnabled: boolean;
-  headEnabled: boolean;
-  /** Tracking contribution in [0, 1]; older values above 1 normalize to 1. Live changes use scheduled motion. */
-  eyeIntensity?: number;
-  /** Tracking contribution in [0, 1], composed over authored head motion. Live changes use scheduled motion. */
-  headIntensity?: number;
-  initialState?: GazeControlState;
-}
-
-export interface GazeFocusDiagnostics {
-  target: PolymerVector3;
-  eyes: Array<{ name: string; origin: PolymerVector3; direction: PolymerVector3; errorDegrees: number; limited: boolean }>;
-  headLimited: boolean;
-  missingHead: boolean;
-  missingEyes: boolean;
-}
-
-export interface GazeObservation {
-  sampleSequence: number;
-  observedAt: number;
-  bindingGeneration: number;
-  requestId: string | null;
-  diagnostics: GazeFocusDiagnostics;
-}
-
-export interface GazeAttentionOutcome {
-  status: 'moving' | 'settled' | 'unavailable' | 'failed';
-  reason: string;
-  angularErrorDeg?: number;
-  sampleSequence?: number;
-  observedAt?: number;
-  bindingGeneration?: number;
-}
-export interface GazeRetainedCandidate {
-  id: string;
-  source: string;
-  provenance: 'synthetic' | 'peer';
-  target: GazeTarget;
-  targetSpace: string;
-  confidence: number;
-  salience: number;
-  influence: number;
-  /** Actual accepted Society credit for peers, null for synthetic fixtures. */
-  routeCredit: number | null;
-  edgeId: string | null;
-  score: number;
-  observedAt: number;
-  expiresAt: number;
-  eligible: boolean;
-  reason: string;
-  lastOutcome?: GazeAttentionOutcome;
-}
-export interface GazeAttentionState {
-  /** The POC accepts static Conversation facts; live perception arbitration is deferred. */
-  lastRejectedInput?: { source: string; reason: 'moving-peer-arbitration-deferred' };
-  active: boolean;
-  sessionId: string | null;
-  scenario: GazeAttentionScenario | null;
-  phase: 'inactive' | 'waiting' | 'moving' | 'settled' | 'unavailable' | 'failed';
-  reason: string;
-  selectedId: string | null;
-  requestId: string | null;
-  configurationRevision: number;
-  candidates: GazeRetainedCandidate[];
-  feedback: GazeAttentionOutcome | null;
-  decisionCount: number;
-  updatedAt?: number;
-}
-export type GazeAttentionScenario = 'competition' | 'equal-score' | 'expiry' | 'unreachable';
-
-export interface ScreenSpaceGazeSolution {
-  kind: 'gaze.screen-space' | 'gaze.viewer-space';
-  focus?: GazeFocusRequest;
-  target: Required<GazeTarget>;
-  eyeTarget: Required<GazeTarget>;
-  headTarget: Required<GazeTarget>;
-  angles: {
-    yawDegrees: number;
-    pitchDegrees: number;
-    cameraYawDegrees: number;
-    cameraPitchDegrees: number;
-  };
-  /** World-space distance from the character's binocular eye origin to the render camera. */
-  distance: number;
-  viewerTarget: PolymerVector3;
-  screenTarget: Required<GazeTarget>;
-}
-
-export interface ScreenSpaceGazeOptions {
-  profile?: Profile;
-  screenTarget: GazeTarget;
-  cameraPosition: PolymerVector3;
-  cameraQuaternion: PolymerQuaternion;
-  gazeOrigin: PolymerVector3;
-  modelQuaternion: PolymerQuaternion;
-  verticalFovDegrees: number;
-  aspect: number;
-  eyesEnabled?: boolean;
-  headEnabled?: boolean;
-  /** Defaults to 1: full target bearing, bounded by the profile's head AU limits. */
-  headFollowFraction?: number;
-}
-
-export interface CameraGazeGeometry {
-  cameraPosition: PolymerVector3;
-  cameraQuaternion: PolymerQuaternion;
-  gazeOrigin: PolymerVector3;
-  modelQuaternion: PolymerQuaternion;
-  verticalFovDegrees: number;
-  aspect: number;
-  gazeGeometryComplete: boolean;
-  worldUnitsPerMeter?: number;
-}
-
-export interface EmbodyGazeRuntime {
-  solveTarget(
-    screenTarget: GazeTarget,
-    cameraFact: CameraGazeGeometry & Record<string, unknown>,
-    options: GazeApplyOptions & { eyesEnabled: boolean; headEnabled: boolean; headFollowEyes: boolean; headIntensity?: number }
-  ): ScreenSpaceGazeSolution;
-}
-
-export interface GazeConfig {
-  /** Explicitly synthetic lab:A and lab:B receiver influences, not graph-edge weights. */
-  attentionInfluenceA?: number;
-  attentionInfluenceB?: number;
-  attentionDwellMs?: number;
-  attentionSwitchMargin?: number;
-  attentionToleranceDeg?: number;
-  attentionTimeoutMs?: number;
-  enabled?: boolean;
-  eyesEnabled?: boolean;
-  headEnabled?: boolean;
-  /** Default true: follow the full target turn from reference neutral within head AU limits. False prefers neutral, with eye-limit overflow assistance. */
-  headFollowEyes?: boolean;
-  headFollowDelay?: number;
-  mirrored?: boolean;
-  smoothFactor?: number;
-  predictionEnabled?: boolean;
-  predictionFactor?: number;
-  maxPredictionDelta?: number;
-  minDelta?: number;
-  transitionDurationMs?: number;
-  /** Tracking contribution in [0, 1]; older values above 1 normalize to 1. With geometry-backed focus, live changes move directly toward the latest value without angular reversal braking. */
-  eyeIntensity?: number;
-  /** Tracking contribution in [0, 1], composed over authored head motion. With geometry-backed focus, live changes move directly toward the latest value without angular reversal braking. */
-  headIntensity?: number;
-  trackingSpeed?: number;
-  /** Braking interval for angular direction changes; geometry-backed strength changes bypass it. */
-  courseChangeDurationMs?: number;
-  coalesceMs?: number;
-}
-
-export interface GazeState {
-  attention: GazeAttentionState;
-  configuration: AgencyConfigurationState;
-  lastDecision: GazeDecision | null;
-  agency: 'gaze';
-  status: string;
-  mode: string;
-  active: boolean;
-  rawTarget: Required<GazeTarget>;
-  target: Required<GazeTarget>;
-  baseTarget: Required<GazeTarget>;
-  baseOptions: GazeApplyOptions;
-  cameraInvalidated: boolean;
-  sourceAvailable: boolean;
-  cameraRelativeOffset: Required<GazeTarget>;
-  lastCameraFact: null | Record<string, unknown>;
-  lastGazeSolution: ScreenSpaceGazeSolution | null;
-  lastRequestedTarget: Required<GazeTarget>;
-  pendingRequest: GazeLookRequest | null;
-  lastRequest: GazeLookRequest | GazeResetRequest | null;
-  lastIgnored: null | Record<string, unknown>;
-  lastPlan: null | Record<string, unknown>;
-  lastEvent: null | Record<string, unknown>;
-  receivedCount: number;
-  plannedCount: number;
-  requestedCount: number;
-  ignoredCount: number;
-  resetCount: number;
-  cancelCount: number;
-  config: Required<GazeConfig>;
-}
-
-export interface GazeApplyOptions {
-  eyeEnabled?: boolean;
-  headEnabled?: boolean;
-  headFollowEyes?: boolean;
-  headFollowDelay?: number;
-  /** Fraction of total target bearing assigned to the head from reference neutral. Defaults to 1; head AU limits still apply. */
-  headFollowFraction?: number;
-  viewerTarget?: PolymerVector3;
-  viewerTargetSpace?: 'webcam.viewer';
-  viewerVerticalFovDegrees?: number;
-  viewerAspect?: number;
-  rawViewerTarget?: PolymerVector3;
-  /** Default false. True explicitly prefers the camera bearing instead of reference-neutral target following. */
-  lockHeadToCamera?: boolean;
-  force?: boolean;
-}
-
-export interface GazeAttentionCandidate {
-  target?: GazeTarget;
-  screenTarget?: GazeTarget;
-  gazeTarget?: GazeTarget;
-  lookTarget?: GazeTarget;
-  x?: number;
-  y?: number;
-  z?: number;
-  priority?: number;
-  weight?: number;
-  confidence?: number;
-  source?: string;
-  label?: string;
-  id?: string;
-}
-
-export type GazeDispatch =
-  | { type: 'attention.start' | 'attention.stop'; sessionId: string }
-  | { type: 'attention.scenario'; sessionId: string; scenario: GazeAttentionScenario }
-  | { type: 'configure'; config: GazeConfig }
-  | { type: 'setMode' | 'set-mode'; mode: string }
-  | { type: 'setActive' | 'set-active'; active: boolean }
-  | { type: 'enable' }
-  | { type: 'disable' }
-  | { type: 'setTarget' | 'set-target' | 'focusTarget'; target: GazeTarget; options?: GazeApplyOptions }
-  | { type: 'attention.fact'; targets?: GazeAttentionCandidate[]; target?: GazeTarget; screenTarget?: GazeTarget; targetSpace?: string; source?: string }
-  | ({ type: 'camera.fact'; relativeOffset: GazeTarget; source?: string } & Partial<CameraGazeGeometry>)
-  | { type: 'camera.stale' | 'clearCameraOffset'; reason?: string; source?: string }
-  | Extract<PolymerDomainEvent, { type: 'userPerception.faceLost' | 'userPerception.status' }>
-  | { type: 'reset'; durationMs?: number; eyes?: boolean; head?: boolean }
-  | { type: 'cancel'; reason?: string };
-
-export interface GazeLookRequest {
-  attentionFeedback?: { sessionId: string; requestId: string; worldTarget: PolymerVector3 | null; timeoutMs: number; toleranceDeg: number } | null;
-  configurationRevision?: number;
-  coalesceMs?: number;
-  type: 'eyeHeadTracking.requestGaze';
-  agency: 'gaze';
-  targetAgency: 'eyeHeadTracking';
-  requestId: string;
-  source?: string;
-  label?: string;
-  mode: string;
-  target: Required<GazeTarget>;
-  eyeTarget: Required<GazeTarget>;
-  headTarget: Required<GazeTarget>;
-  gazeSolution?: ScreenSpaceGazeSolution;
-  rawTarget: Required<GazeTarget>;
-  predictedTarget: Required<GazeTarget>;
-  predictive: boolean;
-  previousTarget: Required<GazeTarget>;
-  eyeEnabled: boolean;
-  headEnabled: boolean;
-  headFollowEyes: boolean;
-  eyeIntensity: number;
-  headIntensity: number;
-  eyeDurationMs: number;
-  headDurationMs: number;
-  createdAt: number;
-  queuedAt?: number;
-  publishedAt?: number;
-}
-
-export interface GazeResetRequest {
-  type: 'eyeHeadTracking.requestReset';
-  agency: 'gaze';
-  targetAgency: 'eyeHeadTracking';
-  requestId: string;
-  durationMs: number;
-  eyes: boolean;
-  head: boolean;
-  requestedAt: number;
-}
-
-export interface GazeCancelRequest {
-  type: 'eyeHeadTracking.requestCancel';
-  agency: 'gaze';
-  targetAgency: 'eyeHeadTracking';
-  requestId: string;
-  reason: string;
-  requestedAt: number;
-}
-
-export interface EyeHeadTrackingConfig {
-  gazeMode?: 'engine' | 'legacy' | 'experimental';
-  enabled?: boolean;
-  eyeTrackingEnabled?: boolean;
-  eyeSaccadeSpeed?: number;
-  eyeSmoothPursuit?: boolean;
-  eyeBlinkRate?: number;
-  headTrackingEnabled?: boolean;
-  headFollowEyes?: boolean;
-  headFollowDelay?: number;
-  headSpeed?: number;
-  lookAtSpeaker?: boolean;
-  idleVariation?: boolean;
-  idleVariationInterval?: number;
-  /** Tracking contribution in [0, 1]; older values above 1 normalize to 1. With geometry-backed focus, live changes move toward the latest value without angular reversal braking. */
-  eyeIntensity?: number;
-  eyeBlendWeight?: number;
-  /** Tracking contribution in [0, 1], composed over authored head motion. With geometry-backed focus, live changes move toward the latest value without angular reversal braking. */
-  headIntensity?: number;
-  trackingSpeed?: number;
-  /** Angular braking interval; geometry-backed strength changes bypass it. */
-  courseChangeDurationMs?: number;
-  headBlendWeight?: number;
-  headRoll?: number;
-  eyePriority?: number;
-  headPriority?: number;
-  snippetPriority?: number;
-  transitionDurationMs?: number;
-  agencyTransitionDuration?: number;
-  returnToCenterDurationMs?: number;
-  returnToNeutralEnabled?: boolean;
-  returnToNeutralDelay?: number;
-  returnToNeutralDuration?: number;
-  coalesceMs?: number;
-  replaceExisting?: boolean;
-  webcamTrackingEnabled?: boolean;
-  webcamLookAtUser?: boolean;
-  webcamActivationInterval?: number;
-  mouthSyncEnabled?: boolean;
-  engine?: Embody | EmbodyRuntime | unknown;
-  cameraController?: unknown;
-  animationAgency?: AnimationService | unknown;
-  useAnimationAgency?: boolean;
-}
-
-export interface EyeHeadTrackingState {
-  agency: 'eyeHeadTracking';
-  status: string;
-  mode: string;
-  currentTarget: Required<GazeTarget>;
-  pendingRequest: EyeHeadGazeRequest | null;
-  lastRequest: EyeHeadGazeRequest | null;
-  lastSnippet: PolymerAnimationSnippet | null;
-  activeSnippetNames: string[];
-  lastIgnored: null | Record<string, unknown>;
-  lastPlan: null | Record<string, unknown>;
-  scheduledCount: number;
-  removedCount: number;
-  resetCount: number;
-  cancelCount: number;
-  ignoredCount: number;
-  config: Required<EyeHeadTrackingConfig>;
-}
-
-export interface EyeHeadGazeRequest {
-  type: 'eyeHeadTracking.requestGaze';
-  agency: 'eyeHeadTracking' | 'gaze';
-  sourceAgency?: string;
-  requestId: string;
-  target: Required<GazeTarget>;
-  eyeTarget?: Required<GazeTarget>;
-  headTarget?: Required<GazeTarget>;
-  gazeSolution?: ScreenSpaceGazeSolution;
-  gazeFocus?: GazeFocusRequest;
-  rawTarget?: Required<GazeTarget>;
-  mode?: string;
-  eyeEnabled?: boolean;
-  headEnabled?: boolean;
-  headFollowEyes?: boolean;
-  headFollowDelay?: number;
-  /** Tracking contribution in [0, 1]; older values above 1 normalize to 1. Live changes use scheduled motion. */
-  eyeIntensity?: number;
-  /** Tracking contribution in [0, 1], composed over authored head motion. Live changes use scheduled motion. */
-  headIntensity?: number;
-  headRoll?: number;
-  eyeDurationMs?: number;
-  headDurationMs?: number;
-  createdAt?: number;
-}
-
-export type EyeHeadTrackingDispatch =
-  | { type: 'configure'; config: EyeHeadTrackingConfig }
-  | { type: 'enable' }
-  | { type: 'disable' }
-  | { type: 'setTarget' | 'set-target' | 'requestGaze'; target: GazeTarget }
-  | EyeHeadGazeRequest
-  | { type: 'reset' | 'eyeHeadTracking.requestReset'; durationMs?: number; eyes?: boolean; head?: boolean; reason?: string }
-  | { type: 'cancel' | 'eyeHeadTracking.requestCancel'; reason?: string };
-
 export interface BlinkTriggerOptions {
   intensity?: number;
   duration?: number;
@@ -1543,12 +1114,10 @@ export interface PolymerAnimationHandle {
   seek?: (offsetSec: number) => unknown;
   updateParams?: (params: Record<string, unknown>) => unknown;
   setParams?: (params: Record<string, unknown>) => unknown;
-  finished?: Promise<unknown> | { then: (onFulfilled?: () => unknown, onRejected?: (error: unknown) => unknown) => unknown };
+  finished?: Promise<AnimationPlaybackEvent>;
 }
 
 export interface PolymerAnimationRuntime {
-  /** Optional capability. Unsupported engines never produce confirmed Gaze alignment. */
-  getGazeObservation?: () => GazeObservation | null;
   buildClip?: (
     name: string,
     curves: Record<string, PolymerSnippetKeyframe[]>,
@@ -1900,10 +1469,6 @@ export interface ProsodicParameter extends AgencyParameter<keyof ProsodicEditabl
 export type GestureEditableConfiguration = Pick<GestureConfig,
   'intensity' | 'priority' | 'defaultDurationMs' | 'cooldownMs' | 'rampRatio'
   | 'holdRatio' | 'returnToBase' | 'replaceActive' | 'maxActive'>;
-export type GazeEditableConfiguration = Pick<GazeConfig,
-  'headFollowDelay' | 'predictionEnabled' | 'trackingSpeed' | 'coalesceMs'
-  | 'attentionInfluenceA' | 'attentionInfluenceB' | 'attentionDwellMs'
-  | 'attentionSwitchMargin' | 'attentionToleranceDeg' | 'attentionTimeoutMs'>;
 export type CameraContextEditableConfiguration = Pick<CameraContextConfig,
   'coalesceMs' | 'staleAfterMs' | 'yawWeight' | 'pitchWeight'>;
 
@@ -1913,12 +1478,6 @@ export interface GestureDefinition {
   definitionVersion: 1;
   parameters: AgencyParameter<keyof GestureEditableConfiguration>[];
 }
-export interface GazeDefinition {
-  id: 'gaze';
-  family: 'cognition';
-  definitionVersion: 2;
-  parameters: AgencyParameter<keyof GazeEditableConfiguration>[];
-}
 export interface CameraContextDefinition {
   id: 'cameraContext';
   family: 'perception';
@@ -1927,18 +1486,6 @@ export interface CameraContextDefinition {
 }
 
 /** Safe decision projection, not an execution receipt or replay record. */
-export interface GazeDecision {
-  trigger: string;
-  configurationRevision: number;
-  source: string;
-  mode: string;
-  predictive: boolean;
-  outcome: 'requested' | 'reset-requested' | 'cancel-requested' | 'ignored' | 'rejected' | 'state-updated';
-  reason: string | null;
-  confirmation: 'unobserved';
-  at: number;
-}
-
 export interface GestureDecision {
   sequence: number;
   trigger: string;
@@ -2054,7 +1601,6 @@ export interface ConversationConfig {
   /** Minimum playback time for transcript fallback; sustained audio is accepted immediately. */
   minSpeakTime?: number;
   allowTranscriptInterruptionFallback?: boolean;
-  eyeHeadTracking?: EyeHeadTrackingService | unknown;
   prosodicService?: unknown;
 }
 
@@ -2293,7 +1839,7 @@ export interface CameraContextState {
   verticalFovDegrees: number;
   aspect: number;
   gazeGeometryComplete: boolean;
-  relativeOffset: Required<GazeTarget>;
+  relativeOffset: Required<PerceptionTarget>;
   lastUpdatedAt: number | null;
   lastPublishedAt: number | null;
   lastFact: Record<string, unknown> | null;
@@ -2404,7 +1950,7 @@ export interface UserPerceptionState {
   modelStatus: string;
   faceDetected: boolean;
   selectedFaceConfidence: number | null;
-  target: Required<GazeTarget>;
+  target: Required<PerceptionTarget>;
   /** Fixed display-right/up normalized eye-midpoint offset for this activation; never persisted across sessions. */
   eyeContactReference: { x: number; y: number } | null;
   lastObservationAt: number | null;
@@ -2697,12 +2243,6 @@ export interface PolymerInputStream<TCommand> extends PolymerStream<{ type: 'com
 
 
 export type PolymerDomainEvent =
-  | { type: 'gaze.attention'; agency: 'gaze'; attention: GazeAttentionState }
-  | { type: 'animation.requestObserveGaze'; agency: 'eyeHeadTracking'; requestId: string; sessionId: string; worldTarget: PolymerVector3 | null; timeoutMs: number; toleranceDeg: number }
-  | { type: 'animation.requestCancelGazeObservation'; agency: 'eyeHeadTracking'; requestId: string | null }
-  | { type: 'animation.gazeFeedback'; agency: 'animation'; requestId: string; status: 'observed' | 'unavailable'; reason: string; angularErrorDeg?: number; sampleSequence?: number; observedAt?: number; bindingGeneration?: number }
-  | { type: 'gaze.configurationChanged'; agency: 'gaze'; configuration: AgencyConfigurationState; configure: GazeEditableConfiguration }
-  | { type: 'gaze.decision'; agency: 'gaze'; decision: GazeDecision }
   | { type: 'gestureDecision'; agency: 'gesture'; decision: GestureDecision }
   | { type: 'gestureCommandRejected'; agency: 'gesture'; commandType: string; reason: 'revision-exhausted' }
   | {
@@ -2723,7 +2263,7 @@ export type PolymerDomainEvent =
     }
   | {
       type: 'animation.requestScheduleSnippet';
-      agency: 'blink' | 'lipSync' | 'gesture' | 'prosodic' | 'eyeHeadTracking';
+      agency: 'blink' | 'lipSync' | 'gesture' | 'prosodic';
       requestId: string;
       snippet: PolymerAnimationSnippet;
       options: { autoPlay?: boolean; [key: string]: unknown };
@@ -2733,7 +2273,7 @@ export type PolymerDomainEvent =
     }
   | {
       type: 'animation.requestRemoveSnippet';
-      agency: 'lipSync' | 'gesture' | 'prosodic' | 'eyeHeadTracking';
+      agency: 'lipSync' | 'gesture' | 'prosodic';
       requestId: string;
       name: string;
       reason: string;
@@ -2797,31 +2337,6 @@ export type PolymerDomainEvent =
       nextDelayMs: number | null;
     }
   | { type: 'signal'; agency: 'blink'; signal: 'blink-fast'; plan: Record<string, unknown> }
-  | { type: 'gaze.status'; agency: 'gaze'; status: string; mode: string; active: boolean; enabled: boolean; reason?: string; at: number }
-  | { type: 'gaze.targetReceived'; agency: 'gaze'; requestId: string; rawTarget: Required<GazeTarget>; source?: string; label?: string; at: number }
-  | {
-      type: 'gaze.targetPlanned';
-      agency: 'gaze';
-      requestId: string;
-      rawTarget: Required<GazeTarget>;
-      target: Required<GazeTarget>;
-      delta: number;
-      eyeDurationMs: number;
-      headDurationMs: number;
-      at: number;
-    }
-  | {
-      type: 'gaze.targetIgnored';
-      agency: 'gaze';
-      requestId: string;
-      rawTarget: Required<GazeTarget>;
-      target: Required<GazeTarget>;
-      reason: 'disabled' | 'min-delta' | string;
-      ignoredAt: number;
-    }
-  | GazeLookRequest
-  | GazeResetRequest
-  | GazeCancelRequest
   | { type: 'camera.status'; agency: 'cameraContext'; status: string; stale: boolean; reason?: string; at: number; configurationRevision: number }
   | {
       type: 'camera.fact';
@@ -2840,7 +2355,7 @@ export type PolymerDomainEvent =
       verticalFovDegrees: number;
       aspect: number;
       gazeGeometryComplete: boolean;
-      relativeOffset: Required<GazeTarget>;
+      relativeOffset: Required<PerceptionTarget>;
       stale: false;
     }
   | {
@@ -2851,7 +2366,7 @@ export type PolymerDomainEvent =
       invalidatedAt: number;
       lastPublishedAt?: number;
       lastObservedAt?: number;
-      lastRelativeOffset?: Required<GazeTarget>;
+      lastRelativeOffset?: Required<PerceptionTarget>;
     }
   | {
       type: 'userPerception.status';
@@ -2870,23 +2385,21 @@ export type PolymerDomainEvent =
   | {
       type: 'attention.fact';
       agency: 'userPerception';
-      targetAgency: 'gaze';
       source: 'userPerception';
       label: string;
       observedAt: number;
       confidence?: number | null;
       priority: number;
-      target: Required<GazeTarget>;
-      screenTarget: Required<GazeTarget>;
+      target: Required<PerceptionTarget>;
+      screenTarget: Required<PerceptionTarget>;
       targetSpace: 'screen.ndc';
-      viewerTarget: Required<GazeTarget>;
+      viewerTarget: Required<PerceptionTarget>;
       viewerTargetSpace: 'webcam.viewer';
       viewerVerticalFovDegrees: number;
       viewerAspect: number;
       cameraMetadata?: UserPerceptionCameraMetadata | null;
-      rawViewerTarget: Required<GazeTarget>;
-      options?: GazeApplyOptions;
-      rawTarget: Required<GazeTarget>;
+      rawViewerTarget: Required<PerceptionTarget>;
+      rawTarget: Required<PerceptionTarget>;
       face: Pick<UserPerceptionFaceObservation, 'id' | 'bounds' | 'eyeMidpoint' | 'interocularDistance' | 'headPose' | 'irisDirection'>;
     }
   | {
@@ -2894,38 +2407,14 @@ export type PolymerDomainEvent =
       agency: 'userPerception';
       observedAt: number;
       confidence?: number | null;
-      target: Required<GazeTarget>;
-      viewerTarget: Required<GazeTarget>;
+      target: Required<PerceptionTarget>;
+      viewerTarget: Required<PerceptionTarget>;
       cameraMetadata?: UserPerceptionCameraMetadata | null;
       face: Record<string, unknown>;
       at: number;
     }
   | { type: 'userPerception.faceLost'; agency: 'userPerception'; reason: string; lastSeenAt?: number; at: number }
   | { type: 'userPerception.ignored'; agency: 'userPerception'; reason: string; commandType?: string; at: number }
-  | {
-      type: 'eyeHeadTracking.status';
-      agency: 'eyeHeadTracking';
-      status: string;
-      enabled: boolean;
-      activeSnippetNames: string[];
-      reason?: string;
-      at: number;
-    }
-  | {
-      type: 'eyeHeadTracking.requestIgnored';
-      agency: 'eyeHeadTracking';
-      requestId: string;
-      reason: string;
-      target?: Required<GazeTarget>;
-      ignoredAt: number;
-    }
-  | {
-      type: 'eyeHeadTracking.cancelled';
-      agency: 'eyeHeadTracking';
-      requestId: string;
-      reason: string;
-      at: number;
-    }
   | { type: 'lipSyncPlanCreated'; agency: 'lipSync'; plan: Record<string, unknown> }
   | { type: 'lipSyncConfigChanged'; agency: 'lipSync'; state: LipSyncState }
   | {
@@ -3040,8 +2529,6 @@ export type PolymerDomainEvent =
         | 'character'
         | 'blink'
         | 'animation'
-        | 'gaze'
-        | 'eyeHeadTracking'
         | 'lipSync'
         | 'tts'
         | 'gesture'
@@ -3101,55 +2588,6 @@ export interface AnimationAgency {
   dispose(): void;
 }
 
-export interface GazeAgency {
-  /** Applies between decisions; pending requests retain their accepted policy. */
-  applyConfiguration(update: { revision: number; configure: GazeEditableConfiguration }): AgencyConfigurationReceipt;
-  input: PolymerInputStream<GazeDispatch>;
-  events: PolymerStream<PolymerDomainEvent>;
-  dispatch(command: GazeDispatch): void;
-  snapshot(): GazeState;
-  subscribeInput(listener: (event: { type: 'command'; agency: 'gaze'; command: GazeDispatch }) => void): () => void;
-  subscribeEvents(listener: (event: PolymerDomainEvent) => void): () => void;
-  /** Compatibility alias for events. Prefer subscribeEvents. */
-  subscribe(listener: (event: PolymerStatusEvent) => void): () => void;
-  /** Compatibility alias for events. Prefer subscribeEvents. */
-  subscribeStatus(listener: (event: PolymerStatusEvent) => void): () => void;
-  setTarget(target: GazeTarget, options?: GazeApplyOptions): void;
-  focusTarget(target: GazeTarget): void;
-  configure(config: GazeConfig): void;
-  setMode(mode: string): void;
-  setActive(active: boolean): void;
-  enable(): void;
-  disable(): void;
-  reset(durationMs?: number): void;
-  cancel(reason?: string): void;
-  flush(): void;
-  queue(): Array<Record<string, unknown>>;
-  dispose(): void;
-}
-
-export interface EyeHeadTrackingAgency {
-  input: PolymerInputStream<EyeHeadTrackingDispatch>;
-  events: PolymerStream<PolymerDomainEvent>;
-  dispatch(command: EyeHeadTrackingDispatch): void;
-  snapshot(): EyeHeadTrackingState;
-  subscribeInput(listener: (event: { type: 'command'; agency: 'eyeHeadTracking'; command: EyeHeadTrackingDispatch }) => void): () => void;
-  subscribeEvents(listener: (event: PolymerDomainEvent) => void): () => void;
-  /** Compatibility alias for events. Prefer subscribeEvents. */
-  subscribe(listener: (event: PolymerStatusEvent) => void): () => void;
-  /** Compatibility alias for events. Prefer subscribeEvents. */
-  subscribeStatus(listener: (event: PolymerStatusEvent) => void): () => void;
-  setTarget(target: GazeTarget): void;
-  configure(config: EyeHeadTrackingConfig): void;
-  enable(): void;
-  disable(): void;
-  reset(durationMs?: number): void;
-  cancel(reason?: string): void;
-  flush(): void;
-  queue(): Array<Record<string, unknown>>;
-  dispose(): void;
-}
-
 export interface LipSyncAgency {
   input: PolymerInputStream<LipSyncDispatch>;
   events: PolymerStream<PolymerDomainEvent>;
@@ -3328,8 +2766,6 @@ export interface UserPerceptionAgency {
 
 export interface CharacterAgencySnapshot {
   blink: BlinkState;
-  gaze: GazeState;
-  eyeHeadTracking: EyeHeadTrackingState;
   gesture: GestureState;
   cameraContext: CameraContextState;
   userPerception: UserPerceptionState;
@@ -3344,8 +2780,6 @@ export interface CharacterAgencySnapshot {
 
 export type CharacterAgencyDispatch =
   | { agency: 'blink'; command: BlinkDispatch }
-  | { agency: 'gaze'; command: GazeDispatch }
-  | { agency: 'eyeHeadTracking'; command: EyeHeadTrackingDispatch }
   | { agency: 'gesture'; command: GestureDispatch }
   | { agency: 'cameraContext'; command: CameraContextDispatch }
   | { agency: 'userPerception'; command: UserPerceptionDispatch }
@@ -3369,8 +2803,6 @@ export interface CharacterAgencies {
   updateSocietyRouting(society: AgencySociety): AgencySociety;
   agency(name: 'animation'): AnimationAgency;
   agency(name: 'blink'): BlinkAgency | null;
-  agency(name: 'gaze'): GazeAgency | null;
-  agency(name: 'eyeHeadTracking'): EyeHeadTrackingAgency | null;
   agency(name: 'gesture'): GestureAgency | null;
   agency(name: 'cameraContext'): CameraContextAgency | null;
   agency(name: 'userPerception'): UserPerceptionAgency | null;
@@ -3398,8 +2830,7 @@ export type MixerLoopMode = 'repeat' | 'once' | 'pingpong';
 export type SnippetCategoryKey =
   | 'emotionAnimationsList'
   | 'speakingAnimationsList'
-  | 'visemeAnimationsList'
-  | 'eyeHeadTrackingAnimationsList';
+  | 'visemeAnimationsList';
 
 export interface AIExpressionInterpretationMetadata {
   emotion?: string;
@@ -3438,7 +2869,7 @@ export interface Snippet {
   maxTime?: number;
   cleanupMaxTime?: number;
   duration?: number;
-  snippetCategory?: 'auSnippet' | 'visemeSnippet' | 'eyeHeadTracking' | 'combined' | 'default' | string;
+  snippetCategory?: 'auSnippet' | 'visemeSnippet' | 'combined' | 'default' | string;
   snippetPriority?: number;
   snippetPlaybackRate?: number;
   snippetIntensityScale?: number;
@@ -3467,7 +2898,7 @@ export interface NormalizedSnippet extends Snippet {
   lastLoopTime: number;
   snippetPlaybackRate: number;
   snippetIntensityScale: number;
-  snippetCategory: 'auSnippet' | 'visemeSnippet' | 'eyeHeadTracking' | 'combined' | 'default' | string;
+  snippetCategory: 'auSnippet' | 'visemeSnippet' | 'combined' | 'default' | string;
   snippetPriority: number;
   snippetBlendMode: 'replace' | 'additive';
   snippetJawScale: number;
@@ -3683,65 +3114,6 @@ export interface AnimationService {
   getPlayingBakedAnimations(): BakedAnimationUIState[];
 }
 
-export interface EyeHeadTrackingRuntimeState {
-  eyeStatus: 'idle' | 'tracking' | 'lagging';
-  headStatus: 'idle' | 'tracking' | 'lagging';
-  currentGaze: GazeTarget;
-  targetGaze: GazeTarget;
-  eyeIntensity: number;
-  lastBlinkTime: number | null;
-  headIntensity: number;
-  headFollowTimer: number | null;
-  isSpeaking: boolean;
-  isListening: boolean;
-  returnToNeutralTimer: number | null;
-  lastGazeUpdateTime: number;
-  mode?: string;
-}
-
-export interface EyeHeadTrackingCallbacks {
-  onEyeStart?: () => void;
-  onEyeStop?: () => void;
-  onHeadStart?: () => void;
-  onHeadStop?: () => void;
-  onGazeChange?: (target: GazeTarget) => void;
-  onBlink?: () => void;
-  onError?: (error: Error) => void;
-}
-
-export interface EyeHeadTrackingMachineContext {
-  config: EyeHeadTrackingConfig;
-  mode: 'manual' | 'mouse' | 'webcam' | string;
-  target: GazeTarget;
-  lastApplied: GazeTarget;
-  status: {
-    eye: 'idle' | 'tracking' | 'lagging';
-    head: 'idle' | 'tracking' | 'lagging';
-  };
-}
-
-export interface EyeHeadTrackingService {
-  start(): void;
-  stop(): void;
-  setGazeTarget(target: GazeTarget): void;
-  resetToNeutral(durationMs?: number): void;
-  blink(): void;
-  setSpeaking(isSpeaking: boolean): void;
-  setListening(isListening: boolean): void;
-  setEyeBlendWeight(value: number): void;
-  setHeadBlendWeight(value: number): void;
-  updateConfig(config: Partial<EyeHeadTrackingConfig>): void;
-  getState(): EyeHeadTrackingRuntimeState;
-  getMachineContext(): EyeHeadTrackingMachineContext | null;
-  getSnippets(): { eye: Map<string, unknown>; head: Map<string, unknown> };
-  setMode(mode: 'manual' | 'mouse' | 'webcam' | string): void;
-  getMode(): 'manual' | 'mouse' | 'webcam' | string;
-  subscribeToWebcam(callback: (detected: boolean, landmarks?: Array<{ x: number; y: number }>) => void): () => void;
-  getWebcamVideoElement(): HTMLVideoElement | null;
-  isWebcamActive(): boolean;
-  dispose(): void;
-}
-
 export interface BoundaryEvent {
   word: string;
   index: number;
@@ -3865,17 +3237,12 @@ export function createAnimationService(
   engine: Embody | EmbodyRuntime,
   options?: { agency?: AnimationAgency },
 ): AnimationService;
-export function createEyeHeadTrackingService(config?: EyeHeadTrackingConfig, callbacks?: EyeHeadTrackingCallbacks): EyeHeadTrackingService;
 export function createTranscriptionService(config?: TranscriptionConfig, callbacks?: TranscriptionCallbacks): TranscriptionService;
 export function createCharacterConversationService(agencies: CharacterAgencies, config?: ConversationConfig, callbacks?: ConversationCallbacks): ConversationService;
 /** @deprecated Character hosts should use createCharacterConversationService. */
 export function createConversationService(tts: { speak(text: string): Promise<unknown>; stop(): void }, transcription: TranscriptionService, config?: ConversationConfig, callbacks?: ConversationCallbacks): ConversationService;
 export const DEFAULT_HAIR_PHYSICS_ENABLED: boolean;
 export const DEFAULT_AGENCY_SOCIETY: AgencySociety;
-export const DEFAULT_EYE_HEAD_CONFIG: Required<Pick<EyeHeadTrackingConfig, 'gazeMode' | 'eyeTrackingEnabled' | 'headTrackingEnabled' | 'headFollowEyes' | 'eyeIntensity' | 'headIntensity' | 'returnToNeutralEnabled' | 'returnToNeutralDelay' | 'returnToNeutralDuration' | 'useAnimationAgency'>>;
-export const DEFAULT_ANIMATION_KEYS: Record<string, string>;
-export const EYE_AUS: Record<string, number>;
-export const HEAD_AUS: Record<string, number>;
 export function getBundledSnippetNames(listKey: SnippetCategoryKey): string[];
 export function getStoredSnippetNames(listKey: SnippetCategoryKey, storage?: Pick<Storage, 'getItem' | 'removeItem'>): string[];
 export function getAvailableSnippetNames(listKey: SnippetCategoryKey, storage?: Pick<Storage, 'getItem' | 'removeItem'>): string[];
@@ -3928,14 +3295,11 @@ export interface AgencySociety {
 
 export function createBlinkAgency(config?: BlinkAgencyConfig): BlinkAgency;
 export function createAnimationAgency(config?: AnimationAgencyConfig): AnimationAgency;
-export function createGazeAgency(config?: GazeConfig, runtime?: EmbodyGazeRuntime): GazeAgency;
-export function createEyeHeadTrackingAgency(config?: EyeHeadTrackingConfig): EyeHeadTrackingAgency;
 export function createLipSyncAgency(config?: LipSyncConfig, runtime?: LipSyncRuntime): LipSyncAgency;
 export function createTTSAgency(config?: TTSConfig): TTSAgency;
 export function createGestureAgency(config?: GestureOptions): GestureAgency;
 export function getProsodicDefinition(): ProsodicDefinition;
 export function getGestureDefinition(): GestureDefinition;
-export function getGazeDefinition(): GazeDefinition;
 export function getCameraContextDefinition(): CameraContextDefinition;
 export function createProsodicAgency(config?: ProsodicOptions): ProsodicAgency;
 export function createConversationAgency(config?: ConversationAgencyConfig): ConversationAgency;
@@ -3944,9 +3308,6 @@ export function createCameraContextAgency(config?: CameraContextConfig): CameraC
 export function createUserPerceptionAgency(config?: UserPerceptionConfig, runtime?: UserPerceptionRuntime): UserPerceptionAgency;
 export function createCharacterAgencies(config?: {
   blink?: BlinkAgencyConfig;
-  gaze?: GazeConfig;
-  gazeRuntime?: EmbodyGazeRuntime;
-  eyeHeadTracking?: EyeHeadTrackingConfig;
   gesture?: GestureOptions;
   cameraContext?: CameraContextConfig;
   userPerception?: UserPerceptionConfig;