@voqalize/avatar 0.2.2 → 0.3.0

package/client/dist/AvatarClient.d.ts

@@ -1,139 +0,0 @@
-/**
- * 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
- *
- * A turn's `t0` is anchored to `performance.now()` **at the moment this client
- * receives the `{cmd:"speech", event:"start"}` message** — cues are
- * client-anchored, not per-cue server-released. That message rides the RTVI
- * data channel, ahead of the jitter-buffered audio path, so the residual error
- * lands on the video-leads side — the side `docs/contract-protocol.md` says
- * perceptual tolerance favours (+125 ms vs -45 ms).
- *
- * We investigated anchoring on pipecat client-js's own `RTVIEvent
- * .BotStartedSpeaking`/`BotStoppedSpeaking` instead (or as a refinement) and
- * chose not to, for two reasons:
- *
- *   1. **No turn correlation.** Those events carry no payload — no `ctx` — so
- *      there is no way to tell which turn a firing belongs to. Our own
- *      `speech` command carries `ctx`, which the splice logic below needs
- *      regardless, so anchoring off it costs nothing extra.
- *   2. **Same source, same path, no accuracy gain.** The `AvatarProcessor`
- *      sits between the TTS service and the output transport and observes the
- *      transport's own `BotStarted/StoppedSpeakingFrame` broadcasts — the exact
- *      frame pipecat's built-in speaking detection is *also* driven from. Both
- *      notifications travel the same data-channel path to the browser. There is
- *      no local "truly audible now" signal cheaply available: the audio arrives
- *      on a `MediaStreamTrack` whose only lifecycle events (`unmute`/`mute`)
- *      fire once per call, not per utterance. Tapping the decoded remote audio
- *      with a WebAudio `AnalyserNode` RMS gate *would* give one, but it adds
- *      its own onset latency and a real audio pipeline to build and tune, and
- *      it would eat into the intentional video-first safety margin rather than
- *      improve it. Left as a documented option, not built.
- *
- * `attach()` therefore subscribes to exactly one pipecat event,
- * `serverMessage`. It used to also subscribe to both speaking events to report
- * a diagnostic drift between our anchor and pipecat's; that hook is gone with
- * the rest of the observability surface (`docs/removed.md` § Client callbacks).
- *
- * ## 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** `speech start` — the fast leg starts the
- * moment a sentence is handed to TTS, well before `BotStartedSpeakingFrame`.
- * Chunks that arrive before the clock is anchored are spliced into the
- * canonical array but not yet handed to the widget; `speech start` 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 — see `index.ts` for the public
- * surface, which is `<Avatar>` 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. See docs/removed.md § The accept
- * predicate.
- */
-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;
-}
-/**
- * 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. `client/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";
-};
-export declare class AvatarClient {
-    private readonly avatar;
-    private readonly opts;
-    private readonly now;
-    private turn;
-    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[];
-    /** 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 handleState;
-    private ensureTurn;
-    private handleCues;
-    private handleSpeech;
-    /**
-     * Subscribe to a live `PipecatClient`'s server messages and dispatch the
-     * avatar commands among them — the ones in the protocol's own
-     * `{type:"avatar"}` envelope, which `isAvatarMessage` is the definition of.
-     * Never throws on a malformed or irrelevant message.
-     *
-     * @returns an unsubscribe function; call it on unmount or disconnect.
-     */
-    attach(client: PipecatClient): () => void;
-}
-//# sourceMappingURL=AvatarClient.d.ts.map

package/client/dist/AvatarClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AvatarClient.d.ts","sourceRoot":"","sources":["../src/AvatarClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,SAAS,EAIf,MAAM,YAAY,CAAC;AAYpB;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC;wDACoD;IACpD,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,aAAa,KAAK,IAAI,CAAC;IACrD,yDAAyD;IACzD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;CAEmB,CAAC;AAU5C,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,IAAI,CAAqB;gBAErB,MAAM,EAAE,SAAS,EAAE,IAAI,GAAE,mBAAwB;IAM7D,+EAA+E;IAC/E,IAAI,OAAO,IAAI,MAAM,GAAG,IAAI,CAE3B;IAED,wFAAwF;IACxF,IAAI,QAAQ,IAAI,SAAS,EAAE,CAE1B;IAED;;0EAEsE;IACtE,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAkC5B,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,UAAU;IAkBlB,OAAO,CAAC,YAAY;IAkBpB;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,IAAI;CAM1C"}

package/client/dist/AvatarClient.js

@@ -1,223 +0,0 @@
-/**
- * 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
- *
- * A turn's `t0` is anchored to `performance.now()` **at the moment this client
- * receives the `{cmd:"speech", event:"start"}` message** — cues are
- * client-anchored, not per-cue server-released. That message rides the RTVI
- * data channel, ahead of the jitter-buffered audio path, so the residual error
- * lands on the video-leads side — the side `docs/contract-protocol.md` says
- * perceptual tolerance favours (+125 ms vs -45 ms).
- *
- * We investigated anchoring on pipecat client-js's own `RTVIEvent
- * .BotStartedSpeaking`/`BotStoppedSpeaking` instead (or as a refinement) and
- * chose not to, for two reasons:
- *
- *   1. **No turn correlation.** Those events carry no payload — no `ctx` — so
- *      there is no way to tell which turn a firing belongs to. Our own
- *      `speech` command carries `ctx`, which the splice logic below needs
- *      regardless, so anchoring off it costs nothing extra.
- *   2. **Same source, same path, no accuracy gain.** The `AvatarProcessor`
- *      sits between the TTS service and the output transport and observes the
- *      transport's own `BotStarted/StoppedSpeakingFrame` broadcasts — the exact
- *      frame pipecat's built-in speaking detection is *also* driven from. Both
- *      notifications travel the same data-channel path to the browser. There is
- *      no local "truly audible now" signal cheaply available: the audio arrives
- *      on a `MediaStreamTrack` whose only lifecycle events (`unmute`/`mute`)
- *      fire once per call, not per utterance. Tapping the decoded remote audio
- *      with a WebAudio `AnalyserNode` RMS gate *would* give one, but it adds
- *      its own onset latency and a real audio pipeline to build and tune, and
- *      it would eat into the intentional video-first safety margin rather than
- *      improve it. Left as a documented option, not built.
- *
- * `attach()` therefore subscribes to exactly one pipecat event,
- * `serverMessage`. It used to also subscribe to both speaking events to report
- * a diagnostic drift between our anchor and pipecat's; that hook is gone with
- * the rest of the observability surface (`docs/removed.md` § Client callbacks).
- *
- * ## 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** `speech start` — the fast leg starts the
- * moment a sentence is handed to TTS, well before `BotStartedSpeakingFrame`.
- * Chunks that arrive before the clock is anchored are spliced into the
- * canonical array but not yet handed to the widget; `speech start` 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 { isAvatarMessage, } from "./types.js";
-/**
- * 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. `client/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 const RTVI_EVENTS = {
-    serverMessage: "serverMessage",
-};
-/** Defensive unwrap for the `RTVIEvent.ServerMessage` `{ data }` quirk: some
- * transports deliver the payload directly and some wrap it once more. */
-function unwrapServerMessage(raw) {
-    const obj = (raw ?? {});
-    const inner = obj["data"];
-    return inner && "type" in inner ? inner : obj;
-}
-export class AvatarClient {
-    avatar;
-    opts;
-    now;
-    turn = null;
-    constructor(avatar, opts = {}) {
-        this.avatar = avatar;
-        this.opts = opts;
-        this.now = opts.now ?? (() => performance.now());
-    }
-    /** The active turn's ctx, or `null` between turns. For tests and telemetry. */
-    get turnCtx() {
-        return this.turn?.ctx ?? null;
-    }
-    /** The active turn's canonical (already-spliced) cue track. For tests and telemetry. */
-    get turnCues() {
-        return this.turn ? [...this.turn.cues] : [];
-    }
-    /** 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) {
-        if (!isAvatarMessage(raw))
-            return;
-        const msg = raw;
-        try {
-            switch (msg.cmd) {
-                case "state":
-                    this.handleState(msg);
-                    break;
-                case "interject":
-                    this.avatar.interject(msg.id);
-                    break;
-                case "gesture":
-                    this.avatar.gesture(msg.id);
-                    break;
-                case "cues":
-                    this.handleCues(msg);
-                    break;
-                case "speech":
-                    this.handleSpeech(msg);
-                    break;
-                case "user":
-                    this.avatar.setUserSpeaking(msg.speaking);
-                    break;
-                // No default: an unknown `cmd` is a newer server talking to an older
-                // widget, and the protocol's forward-compat rule says ignore it. There
-                // is no callback for it — a hook nobody could act on is observability,
-                // not an interface (`docs/removed.md` § Client callbacks).
-            }
-        }
-        catch (err) {
-            if (this.opts.onError)
-                this.opts.onError(err, msg);
-            else
-                console.warn("[avatar] dispatch failed", msg, err);
-        }
-    }
-    handleState(msg) {
-        // Deliberately no client-side dedup: pass every `state` command straight
-        // through. The widget's own setState already no-ops the parts that matter
-        // for an unchanged name (`changed` gates the blink and the 'state' event in
-        // avatar.js), and a server resending the same state name as a
-        // keepalive/resync must still land so an `emotion`/`gaze` override on this
-        // particular message takes effect.
-        this.avatar.setState(msg.name, { emotion: msg.emotion, gaze: msg.gaze });
-    }
-    ensureTurn(ctx) {
-        if (!this.turn || this.turn.ctx !== ctx) {
-            // A different ctx supersedes whatever turn we had — a stale trailing
-            // message for the old ctx will find `this.turn.ctx !== ctx` in
-            // handleSpeech's stop-guard and be ignored, rather than cutting off the
-            // new turn.
-            this.turn = { ctx, cues: [], started: false, clock: null };
-        }
-        return this.turn;
-    }
-    handleCues(msg) {
-        const turn = this.ensureTurn(msg.ctx);
-        const kept = turn.cues.filter((c) => c.t < msg.from_ms);
-        const discarded = turn.cues.length - kept.length;
-        turn.cues = [...kept, ...msg.cues].sort((a, b) => a.t - b.t);
-        if (!turn.started) {
-            // No clock yet — buffer. `speech start` will hand this over as the turn's
-            // first speak() call.
-            return;
-        }
-        if (discarded === 0) {
-            this.avatar.pushCues(msg.cues);
-        }
-        else {
-            this.avatar.speak({ cues: turn.cues, clock: turn.clock });
-        }
-    }
-    handleSpeech(msg) {
-        if (msg.event === "start") {
-            const turn = this.ensureTurn(msg.ctx);
-            const t0 = this.now();
-            const clock = () => this.now() - t0;
-            turn.clock = clock;
-            turn.started = true;
-            this.avatar.speak({ cues: turn.cues, clock });
-            return;
-        }
-        // "stop": only act if it names the turn we're actually riding. A stale stop
-        // for an already-superseded ctx must not cut off a newer turn.
-        if (this.turn && this.turn.ctx === msg.ctx) {
-            this.avatar.stopSpeaking();
-            this.turn = null;
-        }
-    }
-    /**
-     * Subscribe to a live `PipecatClient`'s server messages and dispatch the
-     * avatar commands among them — the ones in the protocol's own
-     * `{type:"avatar"}` envelope, which `isAvatarMessage` is the definition of.
-     * Never throws on a malformed or irrelevant message.
-     *
-     * @returns an unsubscribe function; call it on unmount or disconnect.
-     */
-    attach(client) {
-        const onServerMessage = (raw) => this.dispatch(unwrapServerMessage(raw));
-        const serverMessage = RTVI_EVENTS.serverMessage;
-        client.on(serverMessage, onServerMessage);
-        return () => client.off(serverMessage, onServerMessage);
-    }
-}
-//# sourceMappingURL=AvatarClient.js.map

package/client/dist/AvatarClient.js.map

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

package/client/dist/index.d.ts

@@ -1,22 +0,0 @@
-/**
- * `@voqalize/avatar` — the avatar as one React component.
- *
- *     import { Avatar } from "@voqalize/avatar";
- *
- *     <Avatar client={pipecatClient} className="avatar-tile" />
- *
- * That is the whole public surface. Put an `AvatarProcessor` in the pipecat
- * pipeline (`pip install voqalize-avatar`), drop this component into the bot's
- * tile, and the face listens, thinks, claims the floor and lipsyncs what the
- * TTS says.
- *
- * The widget underneath is framework-free, and the dispatcher between it and
- * the RTVI data channel is plain TypeScript — but neither is exported. Two
- * consumers wanted a call tile, both are React, and a public API is a promise
- * we have to keep across versions. `docs/removed.md` lists what used to be
- * here and how to get it back if a real third case argues for it.
- *
- * Peers: `react >= 18` and `@pipecat-ai/client-js`.
- */
-export { Avatar, type AvatarProps } from "./Avatar.js";
-//# sourceMappingURL=index.d.ts.map

package/client/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/client/dist/index.js

@@ -1,22 +0,0 @@
-/**
- * `@voqalize/avatar` — the avatar as one React component.
- *
- *     import { Avatar } from "@voqalize/avatar";
- *
- *     <Avatar client={pipecatClient} className="avatar-tile" />
- *
- * That is the whole public surface. Put an `AvatarProcessor` in the pipecat
- * pipeline (`pip install voqalize-avatar`), drop this component into the bot's
- * tile, and the face listens, thinks, claims the floor and lipsyncs what the
- * TTS says.
- *
- * The widget underneath is framework-free, and the dispatcher between it and
- * the RTVI data channel is plain TypeScript — but neither is exported. Two
- * consumers wanted a call tile, both are React, and a public API is a promise
- * we have to keep across versions. `docs/removed.md` lists what used to be
- * here and how to get it back if a real third case argues for it.
- *
- * Peers: `react >= 18` and `@pipecat-ai/client-js`.
- */
-export { Avatar } from "./Avatar.js";
-//# sourceMappingURL=index.js.map

package/client/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,MAAM,EAAoB,MAAM,aAAa,CAAC"}

package/client/dist/types.d.ts

@@ -1,86 +0,0 @@
-/**
- * types.ts — the avatar wire vocabulary, client side.
- *
- * The binding definition is `docs/contract-protocol.md`; this file is its
- * TypeScript restatement and must not drift from it. The Python half of the
- * same vocabulary is `py/src/voqalize_avatar/messages.py` — the three are
- * maintained together, and a command added to one without the others is
- * incomplete.
- *
- * A server pushes these as RTVI `server-message`s under the envelope
- * `{ type: "avatar", ...cmd-specific fields }`. {@link AvatarCommand} describes
- * what rides inside that envelope; {@link isAvatarMessage} is the envelope
- * itself, and is the only definition of "this message is for the avatar" the
- * client has. There is no protocol version field — see `docs/removed.md`
- * § The `v` field.
- */
-/** A viseme cue: `t` is a ms offset into the utterance's clock, `v` is a Rhubarb A–H (or X) letter. */
-export interface AvatarCue {
-    t: number;
-    v: string;
-    i?: number;
-}
-export interface AvatarStateCmd {
-    cmd: "state";
-    name: string;
-    emotion?: string;
-    gaze?: string;
-}
-export interface AvatarInterjectCmd {
-    cmd: "interject";
-    id: string;
-}
-/**
- * A hand gesture — the hand at the frame edge plus its face half. Separate from
- * `interject` on purpose: `interject("WAVE")` is the face alone and always was,
- * so a server that upgrades gets no hand until it asks for one.
- */
-export interface AvatarGestureCmd {
-    cmd: "gesture";
-    id: string;
-}
-export interface AvatarCuesCmd {
-    cmd: "cues";
-    ctx: string;
-    /** Discard queued cues at or after this offset (ms), then append `cues`. */
-    from_ms: number;
-    cues: AvatarCue[];
-    /**
-     * True on the one chunk that completes this turn's track: the TTS context is
-     * closed, so no further chunk will splice into `ctx`. What a client may
-     * assume, exactly — nothing about playout. The audio it describes is still
-     * ahead, and `speech stop` remains the end of the turn. It is safe to release
-     * per-turn cue state (the splice buffer for `ctx`) once the last cue has
-     * played, and safe to stop expecting more.
-     *
-     * Absent on an interrupted turn, deliberately: a turn that was cut never
-     * claims to have completed. Absent chunks are the normal case — the widget's
-     * own track already completes on the trailing `X`, so ignoring `final`
-     * entirely is a correct implementation.
-     */
-    final?: boolean;
-}
-export interface AvatarSpeechCmd {
-    cmd: "speech";
-    event: "start" | "stop";
-    ctx: string;
-}
-export interface AvatarUserCmd {
-    cmd: "user";
-    speaking: boolean;
-}
-export type AvatarCommand = AvatarStateCmd | AvatarInterjectCmd | AvatarGestureCmd | AvatarCuesCmd | AvatarSpeechCmd | AvatarUserCmd;
-/** The full server-message payload: the envelope plus its command. */
-export type AvatarServerMessage = AvatarCommand & {
-    type: "avatar";
-};
-/**
- * Is this server-message payload the avatar's? The envelope is the whole
- * answer: `{type:"avatar"}` with a string `cmd`. It used to be a per-deployment
- * `accept` predicate on the client, which meant the library could not state
- * what an avatar message *is* — see `docs/removed.md` § The accept predicate.
- */
-export declare function isAvatarMessage(msg: unknown): msg is AvatarServerMessage;
-/** The envelope `type` the protocol reserves for avatar traffic. */
-export declare const AVATAR_MESSAGE_TYPE = "avatar";
-//# sourceMappingURL=types.d.ts.map

package/client/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,uGAAuG;AACvG,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,WAAW,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,SAAS,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,QAAQ,CAAC;IACd,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,aAAa,GACrB,cAAc,GACd,kBAAkB,GAClB,gBAAgB,GAChB,aAAa,GACb,eAAe,GACf,aAAa,CAAC;AAElB,sEAAsE;AACtE,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAErE;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,mBAAmB,CAIxE;AAED,oEAAoE;AACpE,eAAO,MAAM,mBAAmB,WAAW,CAAC"}

package/client/dist/types.js

@@ -1,31 +0,0 @@
-/**
- * types.ts — the avatar wire vocabulary, client side.
- *
- * The binding definition is `docs/contract-protocol.md`; this file is its
- * TypeScript restatement and must not drift from it. The Python half of the
- * same vocabulary is `py/src/voqalize_avatar/messages.py` — the three are
- * maintained together, and a command added to one without the others is
- * incomplete.
- *
- * A server pushes these as RTVI `server-message`s under the envelope
- * `{ type: "avatar", ...cmd-specific fields }`. {@link AvatarCommand} describes
- * what rides inside that envelope; {@link isAvatarMessage} is the envelope
- * itself, and is the only definition of "this message is for the avatar" the
- * client has. There is no protocol version field — see `docs/removed.md`
- * § The `v` field.
- */
-/**
- * Is this server-message payload the avatar's? The envelope is the whole
- * answer: `{type:"avatar"}` with a string `cmd`. It used to be a per-deployment
- * `accept` predicate on the client, which meant the library could not state
- * what an avatar message *is* — see `docs/removed.md` § The accept predicate.
- */
-export function isAvatarMessage(msg) {
-    if (typeof msg !== "object" || msg === null)
-        return false;
-    const m = msg;
-    return m.type === AVATAR_MESSAGE_TYPE && typeof m.cmd === "string";
-}
-/** The envelope `type` the protocol reserves for avatar traffic. */
-export const AVATAR_MESSAGE_TYPE = "avatar";
-//# sourceMappingURL=types.js.map

package/client/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA2EH;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,GAAY;IAC1C,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC1D,MAAM,CAAC,GAAG,GAA8B,CAAC;IACzC,OAAO,CAAC,CAAC,IAAI,KAAK,mBAAmB,IAAI,OAAO,CAAC,CAAC,GAAG,KAAK,QAAQ,CAAC;AACrE,CAAC;AAED,oEAAoE;AACpE,MAAM,CAAC,MAAM,mBAAmB,GAAG,QAAQ,CAAC"}

package/client/dist/useAvatar.d.ts

@@ -1,42 +0,0 @@
-/**
- * useAvatar — mount the widget, wire it to a live session, dispatch its
- * server-messages, and clean up.
- *
- * Internal: `<Avatar>` is the only thing the package exports. It is a separate
- * module anyway because the two lifecycles genuinely differ — mounting the
- * widget happens once (an avatar swap remounts by design; see the note in the
- * effect), while attaching to the pipecat client re-runs whenever the client
- * identity changes, which a session reconnect makes it do.
- */
-import type { PipecatClient } from "@pipecat-ai/client-js";
-import { type AvatarApi } from "../../src/avatar.js";
-export interface UseAvatarOptions {
-    /** Which face. Omit for the widget's own default. */
-    avatar?: string;
-    /** The live `PipecatClient` to dispatch server-messages from, or `null`
-     * before connect. `useAvatar` (dis)connects the subscription as this
-     * changes; it does not create or own the client. */
-    client?: PipecatClient | null;
-}
-/**
- * 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;
-    /** The live widget instance once mounted, else `null`. */
-    avatar: AvatarApi | null;
-}
-export declare function useAvatar(options?: UseAvatarOptions): UseAvatarHandle;
-//# sourceMappingURL=useAvatar.d.ts.map

package/client/dist/useAvatar.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAvatar.d.ts","sourceRoot":"","sources":["../src/useAvatar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGnE,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;wDAEoD;IACpD,MAAM,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;CAAE,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,YAAY,EAAE,cAAc,CAAC;IAC7B,0DAA0D;IAC1D,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CAC1B;AAED,wBAAgB,SAAS,CAAC,OAAO,GAAE,gBAAqB,GAAG,eAAe,CAuCzE"}

package/client/dist/useAvatar.js

@@ -1,51 +0,0 @@
-/**
- * useAvatar — mount the widget, wire it to a live session, dispatch its
- * server-messages, and clean up.
- *
- * Internal: `<Avatar>` is the only thing the package exports. It is a separate
- * module anyway because the two lifecycles genuinely differ — mounting the
- * widget happens once (an avatar swap remounts by design; see the note in the
- * effect), while attaching to the pipecat client re-runs whenever the client
- * identity changes, which a session reconnect makes it do.
- */
-import { useEffect, useRef, useState } from "react";
-import { createAvatar } from "../../src/avatar.js";
-import { AvatarClient } from "./AvatarClient.js";
-export function useAvatar(options = {}) {
-    const containerRef = useRef(null);
-    const [avatar, setAvatar] = useState(null);
-    const avatarClientRef = useRef(null);
-    // Latest-options ref, so the mount effect (which runs once) still reads the
-    // live props without re-subscribing.
-    const optionsRef = useRef(options);
-    optionsRef.current = options;
-    useEffect(() => {
-        const mount = containerRef.current;
-        if (!mount)
-            return;
-        const instance = createAvatar({ mount, avatar: optionsRef.current.avatar });
-        avatarClientRef.current = new AvatarClient(instance);
-        setAvatar(instance);
-        return () => {
-            instance.destroy();
-            avatarClientRef.current = null;
-            setAvatar(null);
-        };
-        // Mount once. `avatar` is read at mount time only — the widget has no
-        // hot-swap-avatar API (`createFace` runs once per mount), so changing it
-        // re-renders nothing here by design; a caller that needs a different face
-        // remounts with a `key` prop (see the component's doc).
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
-    useEffect(() => {
-        const wrapper = avatarClientRef.current;
-        const pipecatClient = options.client;
-        if (!wrapper || !pipecatClient)
-            return;
-        return wrapper.attach(pipecatClient);
-        // Re-subscribe when the widget mounts or the session's client changes.
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [avatar, options.client]);
-    return { containerRef, avatar };
-}
-//# sourceMappingURL=useAvatar.js.map