@voqalize/avatar 0.2.1 → 0.3.0

package/client/useAvatar.ts

@@ -0,0 +1,74 @@
+/**
+ * useAvatar — mount an avatar into a ref'd element for as long as there is a
+ * client to embody, and tear it down after.
+ *
+ * Internal; `<Avatar>` is the only thing the React entry exports. The whole
+ * hook is one effect, because the factory takes the client at construction:
+ * there is no separate attach step to keep in its own lifecycle any more.
+ */
+
+import { useEffect, useRef } from "react";
+import type { PipecatClient } from "@pipecat-ai/client-js";
+import {
+  createAvatar as createSvgAvatar,
+  type AvatarFactory,
+  type AvatarOptions,
+  type SvgAvatarOptions,
+} from "./createAvatar.js";
+
+export interface UseAvatarOptions<O extends AvatarOptions = SvgAvatarOptions> {
+  /** The live `PipecatClient`, or `null` before connect. Nothing mounts until
+   * this is non-null — an avatar with nothing to embody has nothing to do. */
+  client?: PipecatClient | null;
+  /** The avatar implementation. Defaults to the bundled SVG faces. */
+  create?: AvatarFactory<O>;
+  /** Implementation options, forwarded verbatim. Read at mount only. */
+  options?: Omit<O, keyof AvatarOptions>;
+}
+
+/**
+ * The mount ref's type, written out rather than named as React's `RefObject`.
+ *
+ * React 18 and 19 declare that alias with different type arguments — 18's
+ * `useRef<T>(null)` yields `RefObject<T>`, 19's yields `RefObject<T | null>` —
+ * and because both are the *same alias*, TypeScript compares them by variance
+ * and rejects whichever one we didn't pick. An anonymous shape forces a
+ * structural comparison instead, which both versions satisfy, and which the
+ * `ref` prop accepts on both. This is the only place the 18-vs-19 split shows
+ * up in the binding; keep it that way.
+ */
+export type AvatarMountRef = { current: HTMLDivElement | null };
+
+export interface UseAvatarHandle {
+  /** Attach to the mount element: `<div ref={containerRef} />`. */
+  containerRef: AvatarMountRef;
+}
+
+export function useAvatar<O extends AvatarOptions = SvgAvatarOptions>(
+  { client, create, options }: UseAvatarOptions<O> = {},
+): UseAvatarHandle {
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  // Latest-options ref, so the mount effect reads the live values without
+  // remounting the face every time a caller passes a fresh object literal.
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+
+  useEffect(() => {
+    const mount = containerRef.current;
+    if (!mount || !client) return;
+    const factory = (create ?? createSvgAvatar) as AvatarFactory<O>;
+    // The cast is the seam between "O minus the two we supply" and O. It is
+    // sound by construction and TypeScript cannot see through the spread of a
+    // generic; the two halves are typed at the boundary the caller touches.
+    const instance = factory({ mount, client, ...optionsRef.current } as unknown as O);
+    return () => instance.destroy();
+    // A new client identity is a new thing to embody, so the avatar is rebuilt
+    // rather than re-pointed. Hosts keep one `PipecatClient` across
+    // connect/disconnect cycles, so this does not fire on an ordinary
+    // reconnect; if yours constructs a fresh client per session, expect the
+    // face to remount with it.
+  }, [client, create]);
+
+  return { containerRef };
+}

package/client/vikram.ts

@@ -0,0 +1,24 @@
+/** Polished professional male avatar, authored to read at call-tile size. */
+
+import { createCanvasAvatar } from './createCanvasAvatar.js';
+import type { CanvasAvatarOptions } from './createCanvasAvatar.js';
+import type { AvatarInstance } from './createAvatar.js';
+
+const RIG_URL = new URL('../src/canvas/data/professional-male-a.rig.json', import.meta.url);
+const IMAGES = {
+  'professional-male-a-top-body.webp': new URL('../src/canvas/data/img/professional-male-a-top-body.webp', import.meta.url),
+  'professional-male-a-hair-back.webp': new URL('../src/canvas/data/img/professional-male-a-hair-back.webp', import.meta.url),
+  'professional-male-a-hair-front.webp': new URL('../src/canvas/data/img/professional-male-a-hair-front.webp', import.meta.url),
+} as const;
+const FACE = () => import('../src/canvas/avatars/round/face.mjs');
+
+export type { CanvasAvatarOptions };
+
+export function createAvatar(options: CanvasAvatarOptions): AvatarInstance {
+  return createCanvasAvatar(options, {
+    rigUrl: RIG_URL,
+    images: IMAGES,
+    face: FACE,
+    label: 'Vikram — polished professional male avatar',
+  });
+}

package/dist/Avatar.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Avatar — `createAvatar` as a call tile, and the whole of `@voqalize/avatar/react`.
+ *
+ *     <Avatar client={session.client} className="avatar-tile" />
+ *
+ * Three props of its own; everything else is forwarded to the mount `<div>`, so
+ * it sizes and styles like the tile it lives in. There is nothing to configure
+ * because there is nothing the server does not already say: the
+ * `AvatarProcessor` in the pipeline drives the state, the gaze and the mouth.
+ *
+ * `create` is how you use a different avatar — any module exporting
+ * `createAvatar` (docs/design-avatar-interface.md), including a Rive or WebGL
+ * one. The component is generic over that implementation's options, so
+ * `options` is checked against the factory you passed rather than being a bag:
+ *
+ *     <Avatar client={c} create={createMascot} options={{ mood: "sly" }} />
+ *
+ * With no `create` it is the bundled SVG avatar and `options` is
+ * `SvgAvatarOptions` minus `mount`/`client`, which the component supplies.
+ *
+ * The component renders an empty div and a static `role="img"`. It does not
+ * label the avatar with its current state: the implementation owns the DOM
+ * inside the mount and is the only thing that knows what it is portraying —
+ * and a live label would be this package reading back an avatar's internal
+ * state, which is the one thing the interface refuses to promise. Pass your
+ * own `aria-label` to override.
+ */
+import type { HTMLAttributes } from "react";
+import type { PipecatClient } from "@pipecat-ai/client-js";
+import type { AvatarFactory, AvatarOptions, SvgAvatarOptions } from "./createAvatar.js";
+/** An implementation's own options: everything it takes past the two the
+ * component supplies itself. */
+export type ImplementationOptions<O extends AvatarOptions> = Omit<O, keyof AvatarOptions>;
+export type AvatarProps<O extends AvatarOptions = SvgAvatarOptions> = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    /** The live `PipecatClient`, or `null` before connect. Nothing renders
+     * until it is non-null. */
+    client?: PipecatClient | null;
+    /** An avatar implementation. Omit for the bundled SVG faces. */
+    create?: AvatarFactory<O>;
+    /** Options for that implementation. Read at mount only. */
+    options?: ImplementationOptions<O>;
+};
+export declare function Avatar<O extends AvatarOptions = SvgAvatarOptions>({ client, create, options, ...rest }: AvatarProps<O>): import("react").JSX.Element;
+//# sourceMappingURL=Avatar.d.ts.map

package/dist/Avatar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Avatar.d.ts","sourceRoot":"","sources":["../client/Avatar.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAExF;gCACgC;AAChC,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,aAAa,IAAI,IAAI,CAAC,CAAC,EAAE,MAAM,aAAa,CAAC,CAAC;AAE1F,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,aAAa,GAAG,gBAAgB,IAChE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,EAAE,UAAU,CAAC,GAAG;IACjD;+BAC2B;IAC3B,MAAM,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAC9B,gEAAgE;IAChE,MAAM,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAC1B,2DAA2D;IAC3D,OAAO,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;CACpC,CAAC;AAEJ,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,GAAG,gBAAgB,EAAE,EACjE,MAAM,EACN,MAAM,EACN,OAAO,EACP,GAAG,IAAI,EACR,EAAE,WAAW,CAAC,CAAC,CAAC,+BAGhB"}

package/{client/dist → dist}/Avatar.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useAvatar } from "./useAvatar.js";
-export function Avatar({ client, avatar, ...rest }) {
-    const { containerRef } = useAvatar({ client, avatar });
+export function Avatar({ client, create, options, ...rest }) {
+    const { containerRef } = useAvatar({ client, create, options });
     return _jsx("div", { role: "img", "aria-label": "avatar", ...rest, ref: containerRef });
 }
 //# sourceMappingURL=Avatar.js.map

package/dist/Avatar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Avatar.js","sourceRoot":"","sources":["../client/Avatar.tsx"],"names":[],"mappings":";AA8BA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAkB3C,MAAM,UAAU,MAAM,CAA6C,EACjE,MAAM,EACN,MAAM,EACN,OAAO,EACP,GAAG,IAAI,EACQ;IACf,MAAM,EAAE,YAAY,EAAE,GAAG,SAAS,CAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IACnE,OAAO,cAAK,IAAI,EAAC,KAAK,gBAAY,QAAQ,KAAK,IAAI,EAAE,GAAG,EAAE,YAAY,GAAI,CAAC;AAC7E,CAAC"}

package/dist/AvatarClient.d.ts

@@ -0,0 +1,196 @@
+/**
+ * AvatarClient — the avatar's server-message dispatcher, turn clock, and cue
+ * splice, framework-free (no React; the hook and component wrap this).
+ *
+ * ## Turn clock anchoring
+ *
+ * Base Pipecat TTS gives each serialized TTS context an opaque `context_id`.
+ * The server uses it only to group and splice cue chunks. `botStartedSpeaking`
+ * has no context payload, so the browser FIFO-claims the next buffered context
+ * at that Pipecat output-lifecycle event and anchors its clock there.
+ * `botStoppedSpeaking` closes the active context. Neither event observes the
+ * browser's audio device, and no avatar-specific speech marker exists.
+ *
+ * `attach()` subscribes to the avatar server-message channel *and* Pipecat's
+ * standard lifecycle events. Server messages carry only what Pipecat cannot:
+ * correlated speech/cue timing and deliberate application instructions. The
+ * lifecycle events project the factual presence states locally. The server
+ * supplies only lower-priority `THINKING` / `WORKING` claims and deliberate,
+ * self-completing actions. This keeps the face tied to Pipecat's output truth
+ * even if a server claim is delayed or stale.
+ *
+ * ## Cue splice
+ *
+ * The widget has two cue-track primitives: `speak({cues, clock})` (a full
+ * replace) and `pushCues(cues)` (a pure union that can only grow the track,
+ * never shrink it). Neither is "discard queued cues at or after `from_ms`,
+ * then append" on its own — `pushCues` has no way to drop a stale tail. So
+ * this client keeps the turn's canonical cue array itself (kept portion +
+ * every appended chunk, spliced on each `cues` message) and picks the cheapest
+ * widget call that stays correct:
+ *
+ *   - if the splice's `from_ms` doesn't reach back into anything already
+ *     queued — the common case past a turn's first sentence, since only the
+ *     first sentence genuinely plays fast-leg cues — nothing needs discarding:
+ *     `pushCues(newCues)` is the cheap, correct append.
+ *   - if it does reach back (a real fast→accurate splice), `pushCues` cannot
+ *     express the discard; we call `speak()` again with the full spliced
+ *     canonical array on the turn's original clock. `speak()` is otherwise
+ *     documented as also killing an in-flight spoken interjection and
+ *     re-entering `SPEAKING` — both harmless mid-splice (an interjection
+ *     should not be running while a server track owns the mouth; re-entering
+ *     an unchanged state is a no-op past the profile/gaze reset the widget
+ *     already does for a same-name `setState`).
+ *
+ * Cues commonly arrive **before** `botStartedSpeaking` — the fast leg starts
+ * the moment a sentence is handed to TTS, well before bot output begins.
+ * Chunks that arrive before the clock is anchored are spliced into the
+ * canonical array but not yet handed to the widget; `botStartedSpeaking` hands over
+ * whatever has accumulated as the turn's first `speak()` call. So "the first
+ * chunk of a turn starts speak()" means the first *widget* call, not
+ * necessarily the first *message*.
+ */
+import type { PipecatClient } from "@pipecat-ai/client-js";
+import type { AvatarApi } from "../src/avatar.js";
+import { type AvatarCommand, type AvatarCue } from "./types.js";
+/**
+ * Internal. Not exported from the package — the public surface is
+ * `createAvatar({ mount, client })` and nothing else.
+ *
+ * There is deliberately no `accept` predicate here any more. Avatar commands
+ * travel in one envelope, `{type:"avatar"}`, in both directions and from every
+ * source: a `AvatarProcessor` in the pipeline and a brain driving the face
+ * out of band emit the same shape. A per-deployment predicate meant the
+ * library could not state what an avatar message *is*, which is the one thing
+ * a wire format has to be able to say.
+ */
+export interface AvatarClientOptions {
+    /** A dispatch threw (e.g. an unknown state or interjection id, which the
+     * widget throws on). Defaults to `console.warn`. */
+    onError?: (err: unknown, msg: AvatarCommand) => void;
+    /** Override for tests. Defaults to `performance.now`. */
+    now?: () => number;
+    /** Quiet time in listening before the client-owned idle loop begins. */
+    idleDelayMs?: number;
+    /** Timer seams keep lifecycle behavior deterministic in tests. */
+    setTimeout?: typeof setTimeout;
+    clearTimeout?: typeof clearTimeout;
+    /**
+     * Internal, for Studio's inspector — the resolved projection, so a developer
+     * tool can show what the lifecycle decided. It is *not* on the public
+     * surface and must not become one: a presence callback is a contract, and
+     * publishing it would oblige every avatar implementation to emit these seven
+     * states with this precedence, which is exactly the second public contract
+     * the design exists to avoid.
+     */
+    onPresenceChange?: (state: AvatarPresenceState) => void;
+}
+/**
+ * The one `RTVIEvent` member `attach()` subscribes to, spelled as its value.
+ *
+ * Written out rather than imported because that enum was this module's *only*
+ * runtime reference to `@pipecat-ai/client-js`, and one runtime reference makes
+ * the whole `/pipecat` subpath fail to load without the peer installed — even
+ * for a host that drives `dispatch()` from its own transport and never calls
+ * `attach()`. The peer is declared optional; this is what makes that true
+ * rather than aspirational.
+ *
+ * String enums are nominal in TypeScript, so the compiler cannot check these
+ * against the real ones from a type-only import. `packages/avatar/test/AvatarClient.test.ts`
+ * does it instead, against the actual enum — the devDependency is present
+ * exactly where the check belongs and absent from what we ship.
+ */
+export declare const RTVI_EVENTS: {
+    readonly serverMessage: "serverMessage";
+    readonly connected: "connected";
+    readonly disconnected: "disconnected";
+    readonly botReady: "botReady";
+    readonly error: "error";
+    readonly userStartedSpeaking: "userStartedSpeaking";
+    readonly userStoppedSpeaking: "userStoppedSpeaking";
+    readonly botStartedSpeaking: "botStartedSpeaking";
+    readonly botStoppedSpeaking: "botStoppedSpeaking";
+    readonly userMuteStarted: "userMuteStarted";
+    readonly userMuteStopped: "userMuteStopped";
+};
+/** The resolved, factual presence state a host may render around the avatar. */
+export type AvatarPresenceState = "IDLE" | "LISTENING" | "STRAINING" | "THINKING" | "WORKING" | "MUTED" | "SPEAKING" | "DEGRADED" | "OFFLINE";
+export declare class AvatarClient {
+    private readonly avatar;
+    /** Maps factual/wire intent into the broader client behavior catalog. */
+    private readonly behavior;
+    private readonly opts;
+    private readonly now;
+    private turn;
+    private readonly turns;
+    private readonly pendingCtxs;
+    private readonly closedCtxs;
+    private projected;
+    private serverClaim;
+    private userSpeaking;
+    private botSpeaking;
+    private muted;
+    private listening;
+    private idle;
+    private failure;
+    private idleTimer;
+    private pendingInterruptedAction;
+    private discardQueuedContextsOnBotStop;
+    private readonly idleDelayMs;
+    private readonly setTimer;
+    private readonly clearTimer;
+    constructor(avatar: AvatarApi, opts?: AvatarClientOptions);
+    /** The active turn's ctx, or `null` between turns. For tests and telemetry. */
+    get turnCtx(): string | null;
+    /** The active turn's canonical (already-spliced) cue track. For tests and telemetry. */
+    get turnCues(): AvatarCue[];
+    /** Current resolved projection. Internal — for tests and Studio's inspector.
+     * Before the first lifecycle fact the renderer is simply at its ready rest
+     * pose, so `LISTENING` is the safe value; it is not a session status. */
+    get presenceState(): AvatarPresenceState;
+    /** Re-apply the currently resolved factual projection after an embedding
+     * tool has temporarily used raw renderer controls. This does not invent a
+     * lifecycle event or cancel a finite action. */
+    restoreProjection(): void;
+    /** Dispatch one server message. Anything that isn't in the avatar envelope
+     * is not ours and is ignored; so is an envelope carrying a `cmd` this build
+     * has never heard of, per the wire protocol's forward-compat rule. */
+    dispatch(raw: unknown): void;
+    private handleClaim;
+    private handleAction;
+    private playAction;
+    private ensureTurn;
+    private handleCues;
+    private activateNextTurn;
+    private discardQueuedTurns;
+    private lifecycleState;
+    private applyProjection;
+    private clearIdleTimer;
+    private armIdleIfEligible;
+    private eligibleForIdle;
+    private enterListening;
+    private clearClaimForTurnBoundary;
+    private maybePlayInterrupted;
+    private clearRecoverableFailure;
+    private onUserStartedSpeaking;
+    private onUserStoppedSpeaking;
+    private onBotStartedSpeaking;
+    private onBotStoppedSpeaking;
+    private onUserMuteStarted;
+    private onUserMuteStopped;
+    private onError;
+    private onDisconnected;
+    private onConnectedOrReady;
+    /**
+     * Subscribe to a live `PipecatClient`. Standard client events own the normal
+     * lifecycle projection; avatar server-messages carry correlated visemes and
+     * explicit application intent. Never throws on malformed or irrelevant
+     * server messages.
+     *
+     * @returns an unsubscribe function; call it on unmount or disconnect.
+     */
+    attach(client: PipecatClient): () => void;
+    /** Dispose controller-owned timers when its mounted avatar is destroyed. */
+    destroy(): void;
+}
+//# sourceMappingURL=AvatarClient.d.ts.map

package/dist/AvatarClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AvatarClient.d.ts","sourceRoot":"","sources":["../client/AvatarClient.ts"],"names":[],"mappings":"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"}