@voqalize/avatar 0.4.1 → 0.4.2

package/src/avatar.d.ts

@@ -195,7 +195,7 @@ export interface AvatarApi {
   readonly gestureGain: Gain;
   setMotionGain(g: Gain): AvatarApi;
   readonly motionGain: Gain;
-  blink(double?: boolean): AvatarApi;
+  blink(): AvatarApi;
   /** Advance one frame by hand — only meaningful under `{ manual: true }`. */
   step(dt: number): AvatarApi;
   /** Pin channels to fixed values, above the whole mix. `null` releases. */
@@ -316,7 +316,12 @@ export function createAvatar(opts: CreateAvatarOptions): AvatarApi;
 export const STATES: Readonly<Record<AvatarStateName, Readonly<Record<string, unknown>>>>;
 export const STATE_NAMES: readonly AvatarStateName[];
 export const GAZE_NAMES: readonly AvatarGazeName[];
-export const GAZE_TARGETS: Readonly<Record<AvatarGazeName, { x: number; y: number }>>;
+/** Where each named direction puts the eyes and the head: pupil offset
+ *  (`px`/`py`), the head's share of it (`hx`/`hy`) and any roll. Pose units, and
+ *  the head deliberately carries less than the whole (`src/gaze.js`). */
+export const GAZE_TARGETS: Readonly<Record<AvatarGazeName, {
+  px: number; py: number; hx: number; hy: number; roll?: number;
+}>>;
 export const EMOTION_NAMES: readonly AvatarEmotionName[];
 export const ACTIONS: Readonly<Record<AvatarActionId, unknown>>;
 export const ACTION_IDS: readonly AvatarActionId[];
@@ -334,12 +339,24 @@ export const REST: Readonly<Record<PoseChannel, number>>;
 export const CHANNELS: readonly PoseChannel[];
 /** Post-mix clamp per channel, `[min, max]`. */
 export const RANGE: Readonly<Record<PoseChannel, readonly [number, number]>>;
+/** Each channel's smoothing time constant, in seconds. */
+export const TAU: Readonly<Record<PoseChannel, number>>;
+export function clamp(v: number, lo?: number, hi?: number): number;
+/** One frame of exponential smoothing: where `cur` lands `dt` seconds into a
+ *  chase of `target` with time constant `tau`. */
+export function approach(cur: number, target: number, tau: number, dt: number): number;
 export const VISEME_LETTERS: readonly VisemeLetter[];
 export const VISEME_SHAPES: Readonly<Record<VisemeLetter, PoseOverrides>>;
 /** Cues lead the audio by this many ms — perceptual tolerance is asymmetric. */
 export const LEAD_MS: number;
 /** The shoulder line's share of a held `headRoll`, per pose unit. */
 export const SHOULDER_TILT: number;
+/** A full pose from a handful of overrides: every unnamed channel takes its
+ *  `REST` value. The only correct way to build a frame by hand. */
+export function makeParams(overrides?: PoseOverrides): Record<PoseChannel, number>;
+/** One named emotion's channel deltas at `intensity` (0..1). */
+export function emotionPose(name: AvatarEmotionName, intensity?: number): PoseOverrides;
+export { avatarFrame, createSvgRig } from "./rig.js";
 export const ARPABET_TO_VISEME: Readonly<Record<string, VisemeLetter>>;
 export const AZURE_VISEME_TO_LETTER: Readonly<Record<number, VisemeLetter>>;
 
@@ -365,6 +382,52 @@ export class VisemeTrack {
   readonly playing: boolean;
 }
 
+/**
+ * One authored gesture: a short multi-channel timeline of additive deltas,
+ * optionally with its own mouth track, gaze override and blink beats.
+ */
+export interface Clip {
+  readonly id: string;
+  readonly label: string;
+  readonly text: string;
+  /** Milliseconds, end to end. */
+  readonly duration: number;
+  /** Per channel, `[u, delta]` keys against normalized clip time. */
+  readonly keys: Readonly<Record<string, ReadonlyArray<readonly [number, number]>>>;
+  readonly mouthCues?: readonly Cue[];
+  readonly gaze?: AvatarGazeName;
+  readonly blinkAt?: readonly number[];
+}
+
+/**
+ * Every clip this renderer has, keyed by id — the authoring library, not the
+ * wire's vocabulary. Most are reachable only from inside the mixer: `ACTIONS`
+ * is what a server may name.
+ */
+export const INTERNAL_CLIPS: Readonly<Record<string, Clip>>;
+
+/** What one tick of a clip contributes: additive channel deltas, the ramp
+ *  weight they already carry, and the mouth when the clip owns it. */
+export interface ClipSample {
+  delta: Record<string, number> | null;
+  weight: number;
+  mouth: { letter: VisemeLetter; intensity: number } | null;
+  ownsMouth: boolean;
+}
+
+/** Plays one clip forward in ticks you supply. Fixed-`dt` stepping is what
+ *  makes a rendered gesture reproducible. */
+export class ClipPlayer {
+  constructor(hooks?: { onGaze?: (name: string | null) => void; onBlink?: () => void });
+  play(clip: Clip, audio?: HTMLMediaElement | null, opts?: { queue?: boolean }): void;
+  /** Advance by `dtMs` and report this frame's contribution. */
+  update(dtMs: number): ClipSample;
+  stop(immediate?: boolean): void;
+  onEnd: ((clip: Clip | null) => void) | null;
+  readonly playing: boolean;
+  readonly id: string | null;
+}
+
 export function attachAudio(id: string, url: string): void;
 export function normalizeActions(actions: AvatarAction[]): AvatarAction[];
 export function normalizeCues(cues: Cue[]): Cue[];

package/src/avatar.js

@@ -91,8 +91,8 @@ export const STATES = {
   // is kept to a fifth of looks because on a face this real it reads as
   // downcast. The pose takes back `thoughtful`'s lid drop: a thinking face is
   // alert, and the two together measured past the 0.15 that reads drowsy.
-  // The handoff to SPEAKING is in setState: a reply that starts mid-look
-  // finishes the look instead of snapping back.
+  // There is no handoff to SPEAKING any more: a reply that starts mid-look
+  // brings the eyes back with its first word (see enterGaze, 2026-09-21).
   THINKING:           { gaze: 'AWAY_SIDE', emotion: 'thoughtful', engagement: false,
                         // Fixational jumps rare and small: a thinker's eyes rest
                         // where they land. At the default gap the look jittered
@@ -138,11 +138,11 @@ export const STATES = {
                         // eyes drawn inside a head tipped back aimed every look
                         // meant to be level at the ceiling.
                         pose: { lidL: -0.10, lidR: -0.10 } },
-  // Eyes on the user, with the speaker's own looks away (AVERSION.SPEAK):
-  // a planning look at the start of most turns, a short one every ~5 s at a
-  // phrase boundary, and none as the turn ends. A speaker who never looks
-  // away is staring the listener down.
-  SPEAKING:           { gaze: 'USER',     emotion: 'neutral',    aversion: 'SPEAK',
+  // Eyes on the user for the whole turn, and no `aversion`: gaze.js has why a
+  // speaker's measured looks away are not this rig's to render. What moves
+  // while it talks is the head it holds per phrase and the trunk under it
+  // (prosody.js), never the eyes leaving the user.
+  SPEAKING:           { gaze: 'USER',     emotion: 'neutral',
                         idle: { sway: 0.55 }, engagement: false },
   REVIEWING_SCREEN:   { gaze: 'SCREEN_CENTER', emotion: 'thoughtful', engagement: false,
                         idle: { sway: 0.8, blinkGap: [4.0, 6.5] },
@@ -450,7 +450,7 @@ export function createAvatar(opts = {}) {
   // coordinates or the hand layer's private geometry.
   const rig = opts.rig ? opts.rig(mount, opts.rigOptions) : createSvgRig(face, hand);
 
-  gaze.onLargeShift = (forced) => idle.blink(false, true, forced);
+  gaze.onLargeShift = (forced) => idle.blink(true, forced);
 
   const listeners = {
     state: [], speakEnd: [], clipEnd: [], performEnd: [], gestureEnd: [],
@@ -617,7 +617,6 @@ export function createAvatar(opts = {}) {
   let wanderAt = 0;
   let driftAt = 0;
   let trunkYaw = 0;
-  let turnStartPending = false;
   let glanceAt = 0;
   let glanceUntil = 0;
   let lastBack = null;
@@ -627,8 +626,6 @@ export function createAvatar(opts = {}) {
   const dart = { x: 0, y: 0 };
   // THINKING -> SPEAKING mid-look: when the eyes go back to the user, and
   // when that handoff happened (it stands in for the turn-start look).
-  let returnAt = 0;
-  let carriedAt = -Infinity;
   // The state whose gaze is showing, and when the current state takes it
   // over if that is still pending (GAP_SETTLE). Usually the same state.
   let gazeState = 'IDLE';
@@ -754,11 +751,7 @@ export function createAvatar(opts = {}) {
     // spot every time. Either leg's gaze-evoked blink is the shift's odds
     // unless the state says (`blinkTo`, `blinkBack`), because which leg blinks
     // is part of what the glance means.
-    if (returnAt && elapsed > returnAt) {
-      returnAt = 0;
-      setGaze(gst.gaze);
-    }
-    if (gst.glance && !returnAt) {
+    if (gst.glance) {
       const gl = gst.glance;
       if (glanceUntil && elapsed > glanceUntil) {
         glanceUntil = 0;
@@ -807,25 +800,7 @@ export function createAvatar(opts = {}) {
     // mixer's one-frame veto — anything that means "the user is checking
     // whether I am with them" sets it (see api.attend).
     gaze.setAversion(gst.aversion ? AVERSION[gst.aversion] : null);
-    // A speaking turn ends under mutual gaze: no look in the last 2.4 s of the
-    // cue track as far as it has arrived, nor once it has run out (§4.2). The
-    // mid-turn looks wait for a silent cue, which is a phrase boundary. Both
-    // read last frame's sample, a frame late and harmlessly so.
-    let floorReturn = false;
-    gaze.gate = true;
-    if (gst.aversion === 'SPEAK') {
-      const cues = speech.cues;
-      floorReturn = !speech.playing || !cues.length
-        || cues[cues.length - 1].t - speech.now < FLOOR_RETURN_MS;
-      const cue = cues[speech.index];
-      gaze.gate = !!cue && cue.v === SILENT;
-    }
-    gaze.hold = attendUntil > elapsed || clip.playing || floorReturn;
-    if (turnStartPending) {
-      turnStartPending = false;
-      // A reply that began mid-think has had its planning look already.
-      if (elapsed - carriedAt > 1.5) gaze.startTurn();
-    }
+    gaze.hold = attendUntil > elapsed || clip.playing;
 
     engagement.enabled = !!st.engagement && !clip.playing;
     engagement.update(dt);
@@ -1041,11 +1016,6 @@ export function createAvatar(opts = {}) {
   // sliding.
   const TRUNK_FOLLOW = opts.trunkFollow ?? 0.45;
 
-  // Speakers are back on the listener's eyes this long before they stop
-  // (Andrist, docs/research-biomechanics.md §4.2): the floor is handed over
-  // under mutual gaze, and a look away there declines it.
-  const FLOOR_RETURN_MS = 2400;
-
   // The channels speech owns outright — exactly the params.js mouth group
   // (mouth corners stay free: a clip may smile over a sentence).
   const MOUTH_LOCK = new Set(GROUPS.mouth);
@@ -1059,13 +1029,6 @@ export function createAvatar(opts = {}) {
 const ENGAGE_SHOULDER = 0.10;
 const SPEAK_SMILE_RETAIN = 0.35;
 
-  // How long a reply that starts mid-think keeps the look before it comes
-  // back. Speakers look away to find the words and back to deliver them
-  // (§4.2); a reply that snapped to the user on its first syllable and then,
-  // three times in four, left again for the turn-start look did both halves
-  // twice.
-  const THINK_CARRY = [0.25, 0.6];
-
   // Between the user's turn and the reply the server's claim can change
   // several times a second — THINKING, a tool's WORKING, THINKING again, a
   // grace timer's CANT_HEAR — and every change used to retarget the eyes and
@@ -1152,25 +1115,40 @@ const SPEAK_SMILE_RETAIN = 0.35;
     const deferrable = !o.gaze && !o.keepGaze && GAP_STATES.has(gazeState) && GAP_STATES.has(name);
     if (deferrable && changed) settleAt = name === gazeState ? 0 : elapsed + GAP_SETTLE;
     else if (!(deferrable && settleAt)) { settleAt = 0; enterGaze(name, o, changed); }
+    // The floor has come back to the user: the face receives it (prosody.js
+    // `listen`). It is a state change rather than a VAD event on purpose —
+    // what is being welcomed is the turn, and the server is the one that knows
+    // a turn has changed hands.
+    if (changed && name === 'LISTENING') prosody.listen();
     if (changed) emit('state', name);
     return api;
   }
 
+  // Whether the eyes were last aimed by somebody who meant it — the public
+  // `setGaze`, or a performance's `gaze` verb — rather than by the state's own
+  // schedule. It is the one thing that outranks a state's `gaze`, and it is
+  // why `speak()` can take the eyes back without overriding a caller.
+  let gazeExplicit = false;
+
   /** The state `name` takes the gaze: its target and its schedules. */
   function enterGaze(name, o, blink) {
-    const prev = gazeState;
     gazeState = name;
     const st = states[name];
     const gl = st.glance;
-    // A reply that starts while THINKING is looking away finishes that look
-    // first, and the look stands in for the turn-start one.
-    const carry = prev === 'THINKING' && name === 'SPEAKING'
-      && !o.gaze && !o.keepGaze && gazeName !== st.gaze && !glanceUntil;
-    returnAt = carry ? elapsed + rand(THINK_CARRY) : 0;
-    if (carry) carriedAt = elapsed;
+    // **A reply brings the eyes back with its first word, and that is the
+    // whole of it (2026-09-21).** A THINKING look that was still running used
+    // to be carried a quarter to six tenths of a second into the turn, on the
+    // reasoning that a speaker looks away to find the words and back to
+    // deliver them — but what the owner sees at the top of a turn is the
+    // avatar talking while looking somewhere else, and then a dart back. The
+    // carry's own justification was the turn-start aversion it would otherwise
+    // have doubled with, and that aversion is deleted (gaze.js), so nothing is
+    // left for it to avoid. `setGaze` glides; the return is a saccade, not a
+    // cut, and it now lands on the first word instead of after it.
+    //
     // A state with an `opening` enters as though its check-in on the user is
     // already under way, and leaves it when that runs out.
-    if (!o.keepGaze && !carry) setGaze(o.gaze || (gl && gl.opening ? gl.to : st.gaze));
+    if (!o.keepGaze) { setGaze(o.gaze || (gl && gl.opening ? gl.to : st.gaze)); gazeExplicit = false; }
     // Arm every scheduler fresh, so entering a state never fires a timestamp
     // left over from the last one — the wander in particular, which used to
     // pick a new target on the first frame and override the state's own gaze.
@@ -1181,7 +1159,7 @@ const SPEAK_SMILE_RETAIN = 0.35;
     readCol = readCols = readRow = readRows = 0;
     dartAt = dartBrowUntil = 0;
     dart.x = dart.y = 0;
-    if (blink) idle.blink(false, true);
+    if (blink) idle.blink(true);
   }
 
   function setEmotion(name, intensity = 1) { emotion = name; emotionAmt = intensity; return api; }
@@ -1217,8 +1195,18 @@ const SPEAK_SMILE_RETAIN = 0.35;
         : () => performance.now() - speakStart;
     speech.start(o.cues || [], speakClock);
     prosody.reset(newTurn);
-    if (newTurn) turnStartPending = true;
-    if (stateName !== 'SPEAKING') setState('SPEAKING', { keepGaze: true });
+    // **The eyes come back to the user when the audio starts, and that is the
+    // point of inferring the state at all (2026-09-21).** This used to keep
+    // whatever gaze was already set, which meant a reply arriving while
+    // THINKING was looking away spent its *whole turn* aimed off the user —
+    // 11.9 deg off it in `presence.test.ts`, never returning, because nothing
+    // in SPEAKING retargets. The owner's report was of the eyes being
+    // elsewhere as the bot starts talking, and this is the half of it that
+    // survives in a real call: the audit drives the state directly and so
+    // never took this path. `keepGaze` stays for the one caller that means
+    // it — a performance that aimed the eyes with its own `gaze` verb keeps
+    // them, since that is an instruction and not a leftover schedule.
+    if (stateName !== 'SPEAKING') setState('SPEAKING', { keepGaze: gazeExplicit });
     if (o.audio && o.audio.paused) o.audio.play().catch(() => {});
     return api;
   }
@@ -1376,7 +1364,7 @@ const SPEAK_SMILE_RETAIN = 0.35;
       // composed turn in the demo already behaves.
       if (a.do === 'state') setState(a.name, { keepGaze: a.keepGaze !== false });
       else if (a.do === 'emotion') setEmotion(a.name, a.i ?? 1);
-      else if (a.do === 'gaze') setGaze(a.name);
+      else if (a.do === 'gaze') { setGaze(a.name); gazeExplicit = true; }
       else if (a.do === 'action') action(a.id);
     } catch (e) {
       console.warn(`perform: ${a.do} at ${a.t}ms skipped — ${e.message}`);
@@ -1417,7 +1405,7 @@ const SPEAK_SMILE_RETAIN = 0.35;
   }
 
   const api = {
-    setState, setEmotion, setGaze: (name, custom) => setGaze(name, custom), speak, pushCues, stopSpeaking, attend,
+    setState, setEmotion, setGaze: (name, custom) => { gazeExplicit = true; return setGaze(name, custom); }, speak, pushCues, stopSpeaking, attend,
     action, perform,
     /** Which hand the character gestures with: +1 the viewer's right (its own
      *  left), -1 the other. Both are anatomically real — the thumb splays away
@@ -1433,7 +1421,7 @@ const SPEAK_SMILE_RETAIN = 0.35;
     /** Idle body-motion gain: 1 is the liveness layer as authored, 0 freezes it. */
     setMotionGain: (g) => { idle.gain = g; return api; },
     get motionGain() { return idle.gain; },
-    blink: (dbl) => { idle.blink(dbl); return api; },
+    blink: () => { idle.blink(); return api; },
     /** Advance one frame by hand. Only meaningful under `{manual: true}`;
      *  fixed-dt stepping is what makes a motion render reproducible. */
     step: (dt) => { elapsed += dt; step(dt, dt * 1000); return api; },
@@ -1474,12 +1462,29 @@ const SPEAK_SMILE_RETAIN = 0.35;
 // this channel's neutral value" before it can map the channel onto whatever it
 // controls — a morph target's influence is `(pose - rest) / (1 - rest)`, and a
 // rig that hard-codes those rests has quietly forked `params.js`.
-export { REST, CHANNELS, RANGE } from './params.js';
+export { REST, CHANNELS, RANGE, TAU, clamp, approach, makeParams } from './params.js';
+// The smoothing law itself, for a tool that steps the rig by hand. A
+// filmstrip that reimplemented `approach` would be measuring its own copy of
+// the thing under test — and the smoothing between keyframes is what the face
+// actually does (docs/internal-mixer.md § Smoothing).
+// A pose with no mixer above it: `makeParams(overrides)` fills the rests,
+// `avatarFrame` wraps it, `createSvgRig(face).apply` draws it. That is the whole
+// path an instrument needs to hold a face at one named extreme — no clock, no
+// client, no animation — and the reason it is exported is that a pose sheet
+// that cannot reach it forks the channel rests instead.
+export { avatarFrame, createSvgRig } from './rig.js';
 export { ACTION_IDS, ACTIONS, attachAudio } from './interjections.js';
+// The full authoring catalogue and the player that steps it. Not a server
+// vocabulary — `ACTIONS` is that, and most of these clips are reachable only
+// from inside the mixer. They are exported for the filmstrip instrument,
+// which lays one clip out as frames and therefore has to drive a real
+// `ClipPlayer` rather than re-sample its keys.
+export { INTERNAL_CLIPS } from './interjections.js';
+export { ClipPlayer } from './clips.js';
 export { GAZE_NAMES, GAZE_TARGETS } from './gaze.js';
 export { normalizeActions } from './perform.js';
 export { checkHandFraming } from './hand.js';
-export { EMOTION_NAMES } from './emotions.js';
+export { EMOTION_NAMES, emotionPose } from './emotions.js';
 // The mouth clock travels with the rest of it. Someone has to turn a cue array
 // plus a clock into "which letter is on screen right now", every renderer needs
 // exactly that, and none of them should write it twice — so it is a plain class

package/src/faces.js

@@ -2,7 +2,7 @@
  * The faces we ship, as a table — for tooling that wants every one of them.
  *
  * **Importing this costs all three drawings** (~2k lines of path data). That is
- * the right trade for `rig-check`, the contact sheets, the sweep and Studio,
+ * the right trade for the pose sheet, the sweep and Studio,
  * which exist to compare faces against each other. It is the wrong trade for an
  * application, which renders one: those import a single face module and hand
  * the record to `createAvatar` directly.

package/src/gaze.js

@@ -84,9 +84,6 @@ const LID_FOLLOW = { down: 0.34, up: 0 };
 // peaks mid-turn, is gone when the head lands, and sizes itself on a rig whose
 // head moves four times faster. A 0.75-unit look on tara sinks ~0.8°.
 const HEAD_DIP = 0.06;
-// A gated aversion waits this long past its due time for a phrase boundary,
-// then goes anyway: a run of speech with no pause in it still gets its look.
-const GATE_WAIT = 1.5;
 // How much of a drift the head joins. Little: a drift is a reader's scan or a
 // thinker's gaze moving where it rests, and both are eye movements. At 0.35
 // the head nodded along with every step of a reading scan, which on a
@@ -219,30 +216,24 @@ export const AVERSION = {
     mag: [0.30, 0.44],
     dirs: [[-1, 0.06], [-1, 0.06], [1, 0.02], [1, 0.02], [-0.7, -0.5], [0.5, 0.35]],
   },
-  // While speaking: 1.96 s every 4.75 s mid-turn, a turn-start look on 73% of
-  // turns — the planning look, away to find the words and back to deliver
-  // them — and none in the last 2.4 s, because the floor is handed back under
-  // mutual gaze (§4.2; the mixer owns that hold, since only it can see the
-  // cue track). Human speakers hold the listener's eyes for about 41% of a
-  // turn. This is set for 70-80% instead — the
-  // listener here watches a face on a screen, where 41% reads as evasive — so
-  // the looks keep about Andrist's length and come a little less often.
-  // `every` sits under Andrist's 4.75 s because the phrase gate and the
-  // end-of-turn hold both stretch it: at 3.8-5.8 a turn measured 6-8 looks a
-  // minute and 76-82% contact, the top edge of the band rather than its middle.
-  // `gated`: a mid-turn look waits for a phrase boundary, because speakers
-  // break gaze between clauses, not in the middle of a word.
-  SPEAK: {
-    every: [3.4, 5.2],
-    dur: [1.5, 2.3],
-    mag: [0.34, 0.48],
-    dirs: [[-1, 0.12], [1, 0.12], [-0.75, 0.55], [0.7, 0.5], [-0.6, -0.45]],
-    gated: true,
-    start: { p: 0.73, dur: [1.1, 1.8], window: 0.8 },
-  },
 };
-// There is deliberately no THINK profile. The *cognitive* aversion — 3.54 s
-// (SD 1.26), splitting 39.3% down / 29.4% up / 31.3% side (§4.2) — is longer
+// **There is deliberately no SPEAK profile, and that is the owner's call
+// (2026-09-21): while the avatar talks, its eyes are on the user.** There was
+// one — Andrist's measured speaker, a planning look away at the start of most
+// turns and a short one every few seconds at a phrase boundary — and in a live
+// call it read as the eyes darting off and coming back. The research it came
+// from is not disputed and the reason it does not transfer is structural: a
+// human speaker's look away is a *head and body* movement that the eyes only
+// lead, and this rig has no such movement to give it. Eye travel on its own is
+// not a smaller version of that, it is a different thing, and on tara the
+// amplitude it needed to be visible at all (`aversionGain` 1.8) is exactly what
+// made it read as a dart. What the speaking face moves instead is the head it
+// holds per phrase and the trunk under it (prosody.js), which is communicative
+// rather than evasive. If the face and body half is ever built, this is where
+// the eye half comes back.
+//
+// There is deliberately no THINK profile either. The *cognitive* aversion —
+// 3.54 s (SD 1.26), splitting 39.3% down / 29.4% up / 31.3% side (§4.2) — is longer
 // and deeper than the listening kind, and THINKING renders it with its own
 // dwell cycle (a `glance` in STATES), which moves the whole gaze target rather
 // than nudging off it. Two mechanisms producing the same look would fight.
@@ -296,9 +287,6 @@ export class GazeLayer {
     this._avHead = { x: 0, y: 0 };
     this._avVel = { x: 0, y: 0 };
     this._avProfileRef = undefined;
-    /** Whether now is a phrase boundary, for a `gated` profile. Set by the mixer. */
-    this.gate = true;
-    this._avStartBy = 0;       // a turn-start look may still fire until this time
     // --- drift: a small held offset about the target, set by the mixer
     this.drift = { x: 0, y: 0 };
     this._drift = { x: 0, y: 0 };
@@ -313,15 +301,6 @@ export class GazeLayer {
     // it is entered off a stale timestamp from one that didn't.
     this._avNext = this._t + (p ? p.every[0] + Math.random() * (p.every[1] - p.every[0]) : 0);
     this._avUntil = 0;
-    this._avStartBy = 0;
-  }
-
-  /** A turn begins. If the profile has a turn-start look and the dice take it,
-   *  it fires as soon as `hold` allows inside its window, or not at all — a
-   *  planning look that arrives a second into the words is just a look. */
-  startTurn() {
-    const s = this.aversion && this.aversion.start;
-    if (s && Math.random() < s.p) this._avStartBy = this._t + s.window;
   }
 
   _avert(t, dt) {
@@ -339,17 +318,13 @@ export class GazeLayer {
       // moment the hold lifted — out, back and out again across one turn
       // edge, which is three saccades where the floor wanted none.
       this._avUntil = 0;
-      this._avStartBy = 0;
       this._avNext = t + p.every[0] + Math.random() * (p.every[1] - p.every[0]);
     } else if (this._avUntil && t >= this._avUntil) {
       this._avUntil = 0;
       this._nextMicro = 0;
       this._avNext = t + p.every[0] + Math.random() * (p.every[1] - p.every[0]);
-    } else if (!this._avUntil && !this.hold && (t < this._avStartBy || (t >= this._avNext
-        && (this.gate || !p.gated || t >= this._avNext + GATE_WAIT)))) {
-      const dur = t < this._avStartBy ? p.start.dur : p.dur;
-      this._avStartBy = 0;
-      this._avUntil = t + dur[0] + Math.random() * (dur[1] - dur[0]);
+    } else if (!this._avUntil && !this.hold && t >= this._avNext) {
+      this._avUntil = t + p.dur[0] + Math.random() * (p.dur[1] - p.dur[0]);
       this._nextMicro = 0;
       const d = p.dirs[(Math.random() * p.dirs.length) | 0];
       const m = (p.mag[0] + Math.random() * (p.mag[1] - p.mag[0])) * this.avertGain;