@voqalize/avatar 0.2.2 → 0.4.0

package/client/three/tara.ts

@@ -0,0 +1,76 @@
+/**
+ * tara — the first 3-D character, as a complete `createAvatar` module.
+ *
+ * Structurally this is the canvas avatars' shape, one layer down: the mixer
+ * (`@voqalize/avatar/internal`) does states, layers, gaze, idle, blinks, clips
+ * and per-channel smoothing exactly as it does for every SVG face, and the only
+ * thing tara replaces is the renderer at the end of it. That is the whole
+ * argument for authoring her morph targets under the library's pose-channel
+ * names: nothing above this line knows there is a GPU involved, and every clip,
+ * viseme and co-articulation rule the SVG faces have works here unmodified.
+ *
+ * The Three.js import lives behind this module rather than in the barrel so an
+ * SVG or Canvas consumer never downloads it.
+ */
+
+import type { PipecatClient } from "@pipecat-ai/client-js";
+import { AvatarClient, createSvgAvatar } from "../internal.js";
+import { BLENDER_ACTIONS, BLENDER_SEQUENCES, BLENDER_SUPPORTS } from "./sequences.js";
+import { headHold } from "./holds.js";
+import { createTaraRig, TARA_TUNING } from "./tara-rig.js";
+import type { TaraRigOptions } from "./tara-rig.js";
+
+export interface AvatarOptions {
+  readonly mount: HTMLElement;
+  readonly client: PipecatClient;
+  /** Viseme amplitude, 0..2. `1` is as authored. */
+  readonly mouthGain?: number;
+  /** Gesture-clip amplitude, 0..2. */
+  readonly gestureGain?: number;
+  /** Idle/liveness amplitude, 0..2. */
+  readonly motionGain?: number;
+  /** Fires when the GLB is in the scene — for a capture tool, not a consumer. */
+  readonly onReady?: () => void;
+}
+
+export interface AvatarInstance { destroy(): void; }
+
+/** The optional driving-UI declaration; one list for all three characters
+ *  (`sequences.ts`), because they are one rig. */
+export const supports = BLENDER_SUPPORTS;
+
+export function createAvatar(options: AvatarOptions): AvatarInstance {
+  const { mount, client, onReady, ...gains } = options;
+  if (!mount) throw new TypeError("createAvatar: `mount` is required");
+  if (!client) throw new TypeError("createAvatar: `client` is required");
+
+  const rigOptions: TaraRigOptions = { onReady };
+  // `hand: false` disables the bundled SVG hand renderer only; the semantic
+  // hand frame still reaches the rig, which ignores it — tara has no arms, and
+  // that is the library's oldest standing constraint rather than an omission.
+  // `sequences` is what a server can address on *this* avatar beyond the two
+  // ids every avatar owes it — the three nod types the listening research
+  // separates, and a head shake sized for a rig whose pose unit is a degree.
+  // The wire's action id is open, so nothing here needed promoting; a server
+  // that does not know tara is mounted sends `ACKNOWLEDGE` and is never wrong.
+  // `actions` is the other half: her own shape for an id the mixer already has,
+  // whose shared keys land outside what it means on a head that turns in degrees.
+  const widget = createSvgAvatar({
+    mount, rig: createTaraRig, rigOptions, hand: false,
+    sequences: BLENDER_SEQUENCES, actions: BLENDER_ACTIONS, ...TARA_TUNING,
+    headHold: headHold("tara"), ...gains,
+  });
+  const driver = new AvatarClient(widget);
+  const detach = driver.attach(client);
+
+  let destroyed = false;
+  return {
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      detach();
+      driver.destroy();
+      widget.destroy();
+    },
+  };
+}

package/client/three/tushar.ts

@@ -0,0 +1,65 @@
+/**
+ * tushar — the second 3-D character, and deliberately a copy of `tara.ts`.
+ *
+ * His GLB is tara's scripts run with his landmarks and atlas layout in place of
+ * hers (`characters/tushar/`, whose README has the provenance and the commands),
+ * so the rig, the mixer, the sequences and her tuning are all hers, unmodified;
+ * the one seam is `TaraRigOptions.url`. What turns out to be hers rather than
+ * general is marked TARA-SPECIFIC where it lives, and generalised only once a
+ * third character agrees.
+ */
+
+import type { PipecatClient } from "@pipecat-ai/client-js";
+import { AvatarClient, createSvgAvatar } from "../internal.js";
+import { ASSETS } from "./assets.js";
+import { BLENDER_ACTIONS, BLENDER_SEQUENCES, BLENDER_SUPPORTS } from "./sequences.js";
+import { headHold } from "./holds.js";
+import { createTaraRig, TARA_TUNING } from "./tara-rig.js";
+import type { TaraRigOptions } from "./tara-rig.js";
+
+export interface AvatarOptions {
+  readonly mount: HTMLElement;
+  readonly client: PipecatClient;
+  /** Viseme amplitude, 0..2. `1` is as authored. */
+  readonly mouthGain?: number;
+  /** Gesture-clip amplitude, 0..2. */
+  readonly gestureGain?: number;
+  /** Idle/liveness amplitude, 0..2. */
+  readonly motionGain?: number;
+  /** Fires when the GLB is in the scene — for a capture tool, not a consumer. */
+  readonly onReady?: () => void;
+}
+
+export interface AvatarInstance { destroy(): void; }
+
+/** The optional driving-UI declaration; one list for all three characters
+ *  (`sequences.ts`), because they are one rig. */
+export const supports = BLENDER_SUPPORTS;
+
+export function createAvatar(options: AvatarOptions): AvatarInstance {
+  const { mount, client, onReady, ...gains } = options;
+  if (!mount) throw new TypeError("createAvatar: `mount` is required");
+  if (!client) throw new TypeError("createAvatar: `client` is required");
+
+  const rigOptions: TaraRigOptions = { onReady, url: ASSETS.tushar };
+  // TARA-SPECIFIC, kept on purpose: `TARA_TUNING` (her mouth and motion gains)
+  // is the first thing to question if he reads wrong in a call.
+  const widget = createSvgAvatar({
+    mount, rig: createTaraRig, rigOptions, hand: false,
+    sequences: BLENDER_SEQUENCES, actions: BLENDER_ACTIONS, ...TARA_TUNING,
+    headHold: headHold("tushar"), ...gains,
+  });
+  const driver = new AvatarClient(widget);
+  const detach = driver.attach(client);
+
+  let destroyed = false;
+  return {
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      detach();
+      driver.destroy();
+      widget.destroy();
+    },
+  };
+}

package/client/types.ts

@@ -0,0 +1,235 @@
+/**
+ * types.ts — the avatar wire vocabulary, client side.
+ *
+ * The binding definition is `docs/contract-wire.md`; this file is its
+ * TypeScript restatement and must not drift from it. The Python half of the
+ * same vocabulary is `packages/avatar-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 — an unknown `cmd` is simply
+ * ignored, which is the whole forward-compatibility rule.
+ */
+
+import { VISEME_LETTERS } from "../src/avatar.js";
+import type { VisemeLetter } from "../src/avatar.js";
+
+/** 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: VisemeLetter;
+  /** 0..1 loudness. Absent means full. */
+  i?: number;
+  /**
+   * The phone being articulated under `v`, absent during silence.
+   *
+   * `v` is a nine-way projection of the recogniser's ~40 phones and the loss is
+   * concentrated — `B` alone absorbs IY, IH, T, D, CH, JH, TH, DH, S, Z, SH,
+   * ZH, N and Y — so a renderer with a mouth for "tongue between the teeth"
+   * cannot ask for it from `v` and can from here. **Not a closed set**: it is
+   * whatever the engine labels its own segments with, which today is Arpabet
+   * plus `Schwa` and four non-speech labels, and a later engine may say
+   * something else. Validated as an identifier and passed through unread —
+   * the letter stays the thing every face must handle, and a face that wants
+   * the finer signal opts in.
+   */
+  p?: string;
+}
+
+/**
+ * A durable, lower-priority server state. `null` explicitly clears it.
+ *
+ * Three values, and the server can send no others: the remaining six of the
+ * nine are Pipecat facts the browser already holds, and a server spelling of a
+ * fact would be a second, lower-authority copy of it. It was `cmd: "claim"`
+ * until the wire redesign, when the concept and the command were given the one
+ * name the rest of the system already used for it.
+ */
+export interface AvatarStateCmd {
+  cmd: "state";
+  state: "CANT_HEAR" | "THINKING" | "WORKING" | null;
+}
+
+/**
+ * One self-completing motion, by name: face, body, and optionally a hand.
+ *
+ * **The id is open.** Two of them — {@link CORE_ACTION_IDS} — are intents every
+ * renderer owes a server and are the only ones a server may send without
+ * knowing what is mounted. Everything else is a name from the mounted avatar's
+ * own catalogue, and **an unknown one is ignored, not an error**: that is the
+ * same forward-compatibility rule an unknown `cmd` gets, arrived at from the
+ * other direction. There, a newer server meets an older widget; here, any
+ * server meets a face that cannot do the thing. Neither is worth breaking a
+ * call over, and there is deliberately no fallback — an action sits on top of a
+ * state, so nothing is missing when one is dropped.
+ *
+ * This replaced a closed seven-id vocabulary plus a second command,
+ * `sequence`, for a renderer's own motions. The split cost a promotion ritual
+ * for every new portable intent and still could not say what the closed set was
+ * for: the listening research separates a continuer nod from an assessment nod
+ * from a realisation, and all three were the one id `ACK_NOD` spelled. Now the
+ * server says *when* to acknowledge and the avatar owns the variety.
+ */
+export interface AvatarActionCmd {
+  cmd: "action";
+  id: string;
+}
+
+/**
+ * The two actions every renderer must answer to.
+ *
+ * `ACKNOWLEDGE` is the whole backchannel family in one word — receipt, nod,
+ * realisation, empathy — because which of those a face does is a rendering
+ * decision and the server is not the one holding the drawing.
+ * `RESPONSE_INTERRUPTED` is the one transition a server can explain and the
+ * browser cannot infer.
+ *
+ * A renderer may draw either in its own shape; it may never redefine one, and
+ * a name in its own catalogue never shadows one of these.
+ */
+export const CORE_ACTION_IDS = Object.freeze(["ACKNOWLEDGE", "RESPONSE_INTERRUPTED"] as const);
+
+export type CoreActionId = (typeof CORE_ACTION_IDS)[number];
+
+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 Pipecat's `botStoppedSpeaking` remains the end of the turn. It
+   * is safe to stop expecting more cue chunks after `final`.
+   *
+   * 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 type AvatarCommand =
+  | AvatarStateCmd
+  | AvatarActionCmd
+  | AvatarCuesCmd;
+
+/** The full server-message payload: the envelope plus its command. */
+export type AvatarServerMessage = AvatarCommand & { type: "avatar" };
+
+/** An envelope addressed to the avatar, before its payload has been read. */
+export type AvatarEnvelope = { type: "avatar"; cmd: string } & Record<string, unknown>;
+
+/**
+ * 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*.
+ *
+ * Addressed to us is not the same as understood by us: {@link parseAvatarCommand}
+ * is the second half.
+ */
+export function isAvatarMessage(msg: unknown): msg is AvatarEnvelope {
+  if (typeof msg !== "object" || msg === null) return false;
+  const m = msg as Record<string, unknown>;
+  return m.type === AVATAR_MESSAGE_TYPE && typeof m.cmd === "string";
+}
+
+/**
+ * What an action id may look like. Not which ones exist — that is the mounted
+ * avatar's business and this function has never met it. `CATEGORY_INTENT` in
+ * upper case, bounded so a malformed or hostile message cannot smuggle
+ * anything through as a name.
+ */
+const ACTION_ID = /^[A-Z][A-Z0-9_]{1,63}$/;
+const LETTERS = new Set<string>(VISEME_LETTERS);
+/**
+ * What a phone label may look like. Letters only, because every label any
+ * engine we have seen is one word of them — `AO`, `NG`, `Schwa`, `Breath` —
+ * and the bound is what stops a name being a payload.
+ */
+const PHONE_LABEL = /^[A-Za-z]{1,12}$/;
+
+/**
+ * Read an envelope's payload into the wire vocabulary, or `null` if this build
+ * cannot act on it — an unknown `cmd`, a state outside the three, an action id
+ * that is not a name, a malformed `cues` chunk.
+ *
+ * `null` is the forward-compat rule with a type attached: a newer server
+ * talking to an older widget is *expected*, and the older widget ignores what
+ * it does not know rather than guessing. Doing the check here rather than at
+ * each use site is what lets the wire types be closed unions instead of
+ * `string` — the boundary is one function, so it can be the only place that
+ * has to be honest about untrusted input.
+ *
+ * Cues survive individually: one unrecognised letter in a chunk drops that cue,
+ * not the utterance around it. Losing a frame of articulation is a far smaller
+ * regression than losing a sentence of it.
+ */
+export function parseAvatarCommand(msg: AvatarEnvelope): AvatarCommand | null {
+  switch (msg.cmd) {
+    // `claim` was this command's name, and `STRAINING` one of its values, until
+    // the wire redesign. Both are accepted and translated here, in the one
+    // place that reads untrusted input, so no layer above has ever heard of
+    // either spelling. Servers that predate the rename keep working; the old
+    // names appear nowhere else and come out when the last one has shipped.
+    case "claim":
+    case "state": {
+      const state = msg.state === "STRAINING" ? "CANT_HEAR" : msg.state;
+      if (state === null || state === "CANT_HEAR" || state === "THINKING" || state === "WORKING") {
+        return { cmd: "state", state };
+      }
+      return null;
+    }
+    // `sequence` was a second command for the same thing: a name resolved
+    // against the mounted avatar rather than against a closed list. Now that
+    // `action` is that, the two are one command and the old one is an alias.
+    case "sequence":
+    case "action":
+      // Shape only, both for a core id and for one of the avatar's own. There
+      // is nothing to check a name against here — the catalogue belongs to
+      // whatever is mounted, and this function has never met it.
+      return typeof msg.id === "string" && ACTION_ID.test(msg.id)
+        ? { cmd: "action", id: msg.id }
+        : null;
+    case "cues": {
+      if (typeof msg.ctx !== "string" || !Number.isFinite(msg.from_ms) || !Array.isArray(msg.cues)) {
+        return null;
+      }
+      const cues: AvatarCue[] = [];
+      for (const c of msg.cues as unknown[]) {
+        if (typeof c !== "object" || c === null) continue;
+        const { t, v, i, p } = c as Record<string, unknown>;
+        if (typeof t !== "number" || !Number.isFinite(t)) continue;
+        if (typeof v !== "string" || !LETTERS.has(v)) continue;
+        const cue: AvatarCue = { t, v: v as VisemeLetter };
+        if (typeof i === "number") cue.i = i;
+        // Bounded as a name, not checked against a list. The set belongs to
+        // whatever produced the cue, so enumerating it here would make this
+        // library the thing that has to be released before a better recogniser
+        // can say a new word.
+        if (typeof p === "string" && PHONE_LABEL.test(p)) cue.p = p;
+        cues.push(cue);
+      }
+      return {
+        cmd: "cues",
+        ctx: msg.ctx,
+        from_ms: msg.from_ms as number,
+        cues,
+        ...(msg.final === true ? { final: true as const } : {}),
+      };
+    }
+    default:
+      return null;
+  }
+}
+
+/** The envelope `type` the protocol reserves for avatar traffic. */
+export const AVATAR_MESSAGE_TYPE = "avatar";

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,26 @@
+/** 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 };
+// Same mixer, same clip library, so the same declaration (`supports.ts`).
+export { supports } from './supports.js';
+
+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"}