@voqalize/avatar 0.4.4 → 0.5.0

package/README.md

@@ -1,187 +1,98 @@
 # @voqalize/avatar
 
-A 2-D talking head for AI voice calls, driven by your pipecat client. The
-avatars are lip-synced to the audio and they are state aware: they know when
-they have been interrupted, when the user is talking versus idle, when a tool
-call has started and stopped.
-
-No video track, no per-minute avatar vendor, no second media path. SVG faces
-and 2.5-D characters ship with it, one per entry point, so you pay for the one
-you import, and you can author your own.
-
-This is the browser half. The pipeline half is
-[`voqalize-avatar`](https://pypi.org/project/voqalize-avatar/) on PyPI; they are
-two ends of one wire format and release independently, kept compatible by the
-wire contract rather than a shared version number
-([RELEASING.md § Compatibility](https://github.com/voqalize/avatar/blob/main/RELEASING.md#compatibility)).
-
-**Licence: MIT for the code and the SVG avatars, CC-BY 4.0 for the
-2.5-D character binaries** (`assets/*.glb` — see `assets/README.md` for the
-credit line). Which applies is decided by the kind of avatar, so adding a
-character never moves the line. The manifest declares the pair as
-`MIT AND CC-BY-4.0`.
+A talking head for AI voice calls. Give it your live `PipecatClient` and an
+element, and a character in that element speaks the bot's audio, lip-synced,
+and shows the state of the call: listening, thinking, being interrupted.
+
+This package is the loader. The avatar itself (the characters, the renderer and
+everything that follows the call) is the Voqalize avatar runtime, which this
+package imports from `https://avatar.voqalize.com` when the first avatar mounts.
+Each release of this package is pinned to the runtime it was released with, so
+upgrading the package is how you upgrade the avatar.
 
 ## Install
 
 ```sh
-npm install @voqalize/avatar      # this package, the browser half
-pip install voqalize-avatar       # the pipecat half
+npm install @voqalize/avatar
 ```
 
-Node 20+. The package is ESM with **no runtime dependencies** and ships its own
-types. `@pipecat-ai/client-js` (`>=1.4 <2`) and React (`>=18`) are declared as
-*optional* peers: the pipecat import is types-only, so nothing fails to load
-without it, and React is only for `@voqalize/avatar/react`.
+The package is ESM, has no runtime dependencies and ships its own types.
+`@pipecat-ai/client-js` (`>=1.4 <2`) and React (`>=18`) are optional peers. The
+pipecat import is used only for types, and React is used only by
+`@voqalize/avatar/react`.
 
-## Getting started
+## Mount a character
 
-In the browser, wherever your app already renders the bot's tile:
+Mount it wherever your app renders the bot's tile:
 
 ```js
-import { createAvatar } from '@voqalize/avatar';
+import { createAvatar } from "@voqalize/avatar";
 
-const avatar = createAvatar({ mount: el, client: pipecatClient });
-```
+const avatar = createAvatar({
+  mount: document.querySelector("#bot-tile"),
+  client: pipecatClient,
+  character: "<name>",
+});
 
-```jsx
-import { Avatar } from '@voqalize/avatar/react';
-import { wren } from '@voqalize/avatar/faces/wren';   // `peep` is the default
-
-<Avatar client={pipecatClient} options={{ face: wren }} className="call-tile" />
+// when the call ends, or the tile goes away
+avatar.destroy();
 ```
 
-In the pipeline, between the TTS service and the transport's output — the seat
-where it can see the audio that is about to be spoken, at generation speed:
-
-```python
-from voqalize_avatar import AvatarProcessor
-
-pipeline = Pipeline([..., tts, AvatarProcessor(), transport.output()])
-```
-
-That is the integration, both halves of it. Neither takes an argument.
-`createAvatar` returns `{ destroy() }` and nothing else — the avatar is an
-embodiment of your `PipecatClient` and reacts to it, so there is no avatar to
-drive and no state to read back.
-
-## What you get for free
-
-Most of the avatar works on any pipecat application without customization — not
-because integrations were enumerated, but because the behaviour is derived from
-frames and events a pipecat pipeline already emits. `SPEAKING`, `LISTENING`,
-`MUTED`, `OFFLINE` and `DEGRADED` come from your `PipecatClient` with no backend
-involvement at all; `THINKING`, `WORKING` and `CANT_HEAR` come from
-`AvatarProcessor` watching turn boundaries, LLM response boundaries and
-function-call frames; lipsync comes from the same karaoke frames pipecat already
-pushes for word-level captions; blink, breath, gaze aversion and idle motion are
-always the renderer's.
-
-What is left over is small, specific, and each item is a case the library
-refuses to guess at — a deliberate nod or greeting, a tool whose calls never
-enter your pipeline, a pose richer than the core states, a backend that is not
-ours. [The wire
-contract](https://github.com/voqalize/avatar/blob/main/docs/contract-wire.md) is
-the canonical reference for all of it.
-
-## The wire protocol
-
-`state`, `action` and `cues`, one envelope
-([contract-wire.md](https://github.com/voqalize/avatar/blob/main/docs/contract-wire.md)):
-
-```json
-{ "type": "avatar", "cmd": "state",  "state": "WORKING" }
-{ "type": "avatar", "cmd": "action", "id": "ACKNOWLEDGE" }
-{ "type": "avatar", "cmd": "cues",   "ctx": "tts-context", "from_ms": 0, "cues": [] }
-```
+`createAvatar` returns at once, and the face appears when the runtime and the
+character have loaded. The avatar owns the contents of `mount` and sizes itself
+to it. `destroy()` is safe to call at any time, including before the face has
+appeared.
 
-**States are durable and they are prioritised.** A state holds until the facts
-change; it does not complete on a timer. **The state pipecat reports always
-wins** — bot-output lifecycle and user speech are observed Pipecat facts, and a
-state the server sends is a *candidate* underneath them. **Actions are
-point-in-time animations** that land on top of whatever state is effective at
-the time; they are finite, they complete on their own, and they never establish
-state.
+`character` names one of the characters you can meet at
+https://voqalize.com/demos/avatar. Each release of this package can mount a
+fixed set of them, and a name it does not have throws, listing the ones it
+does.
 
-Emission is overwrite, never merge: a `cues` message says "discard everything
-queued at or after `from_ms`, then append these". The server decides; the client
-has no say and no way to refuse.
+The gains are optional, from `0` to `2`, and `1` is as authored:
 
-**Not using our backend?** Any server can produce cues; the ways, best first:
-If your TTS emits native viseme events, map the integer ids through
-`AZURE_VISEME_TO_LETTER` and ship `{t, v}` as they stream. Otherwise force-align
-the text against the audio and map ARPAbet through `ARPABET_TO_VISEME`. With no
-server work at all, `textToCues(text)` is a crude grapheme guesser, fit for
-previews only. Each is exported from `@voqalize/avatar/internal`.
+- `mouthGain` sets how far the mouth moves.
+- `gestureGain` sets the size of nods and other gestures.
+- `motionGain` sets the amount of idle motion.
 
-## The faces
+The client must be connected to a Voqalize session that has the avatar turned on.
 
-All hand-authored line art: **`peep`** (the default),
-**`wren`**, **`myna`**. Each is its own entry point, and you pass the value
-rather than a name:
+### React
 
-```js
-import { myna } from '@voqalize/avatar/faces/myna';
+```jsx
+import { Avatar } from "@voqalize/avatar/react";
 
-createAvatar({ mount, client, face: myna });
+<Avatar client={client} character="<name>" className="bot-tile" />
 ```
 
-A name would need a table, and a table is a dynamic index no bundler can shake —
-every drawing in every consumer's bundle to render one.
-
-## The 2.5-D characters
-
-The characters ship as compiled binaries, each its own `createAvatar` module:
+Nothing mounts while `client` is `null`. A new `client` or `character` rebuilds
+the avatar. The gains are read when the avatar mounts. Every other prop goes to
+the `<div>` the avatar renders into.
 
-```js
-import { createAvatar } from '@voqalize/avatar/avatars/tara';
-// or: @voqalize/avatar/avatars/tushar
-//     @voqalize/avatar/avatars/tanya
-//     @voqalize/avatar/avatars/tess
-//     @voqalize/avatar/avatars/tanvi
-
-const avatar = createAvatar({ mount, client: pipecatClient });
-```
+## Content Security Policy
 
-A photograph of a face projected onto shallow geometry, with the parts that have
-to move — eyes, teeth, the lip line — built as geometry rather than painted.
-Three.js is an *optional* peer (`three`, `>=0.180 <0.187`) behind those
-entry points only, so an SVG consumer never downloads it, and the `.glb`
-is fetched when the avatar mounts.
+If your page sets a Content-Security-Policy, add these sources:
 
-Nothing above the renderer changes: the same wire, the same states, the same
-cue-synced mouth, and a server that has never heard of these characters drives one
-correctly. How far a character's head may turn is not an option either: it is a
-limit read off that face by eye, carried per character in
-`client/three/motion-limits.json`, which `HEAD_DEG` in
-`client/three/character-rig.ts` turns into a pose channel's degrees.
+- `script-src https://avatar.voqalize.com`, because the runtime is a module
+  imported from there.
+- `connect-src https://avatar.voqalize.com blob:`, because the runtime fetches
+  the character from there and decodes the character's textures from `blob:`
+  URLs.
+- `img-src https://avatar.voqalize.com blob:`. The asset host serves the
+  still photograph shown where a browser has no WebGL 2, as a call whose other
+  side has turned their camera off; without it that tile shows an empty circle.
+  `blob:` is for Safari before 17 and Firefox before 98, which decode the
+  character's textures through an image element.
 
-**The binaries are artwork under CC-BY 4.0**, separately from the MIT code
-around them; the credit line is in `assets/README.md`. Mounting, sizing, the asset
-budget and what the characters can be asked to do:
-[characters.md](https://github.com/voqalize/avatar/blob/main/docs/characters.md).
+The runtime needs nothing else: no workers, no inline styles and no `eval`.
 
-## Shipping your own avatar
+## Bundlers
 
-A whole different rendering technology is not a face; it is a different
-`createAvatar`, published as its own module — which is why there is no registry.
-The interface is small enough to state in one line:
+The runtime is imported with a literal `import()` of its URL, marked so that
+Vite and webpack leave it alone. Your bundle carries only this package, a few
+kilobytes, and the browser fetches the runtime once per page however many
+avatars mount.
 
-```ts
-createAvatar({ mount, client, ...yourOptions }) -> { destroy() }
-```
+## Licence
 
-What such an implementation needs to understand is the *wire*, because states,
-actions and cues are all an avatar is ever told. `VisemeTrack` in
-`@voqalize/avatar/internal` turns a cue array plus a clock into the mouth shape
-for the current frame; every renderer needs that and none should write it twice.
-
-An implementation may also export `supports` — one object naming the action ids
-it answers to. Nothing in the library reads it; it is there because the wire's
-action id is open and an unknown one is ignored in silence, so a page that
-drives an avatar otherwise cannot tell a face that has no such motion from one
-that did nothing ([design-avatar-interface.md](https://github.com/voqalize/avatar/blob/main/docs/design-avatar-interface.md)).
-Omitting it is conforming.
-
-**There is deliberately no renderer interface.** The pose channels our SVG mixer
-uses to talk to our faces are internal, and a second public contract stays
-premature until a second renderer says what it needs.
+This package is MIT; see [LICENSE](./LICENSE). The runtime it loads is not open
+source. Its terms are at https://avatar.voqalize.com/LICENSE.

package/dist/index.d.ts

@@ -3,32 +3,43 @@
  *
  *     import { createAvatar } from "@voqalize/avatar";
  *
- *     const avatar = createAvatar({ mount: el, client: pipecatClient });
+ *     const avatar = createAvatar({ mount: el, client: pipecatClient, character: "tara" });
+ *     // …
+ *     avatar.destroy();
  *
- * That is the whole public surface. Put an `AvatarProcessor` in the pipecat
- * pipeline (`pip install voqalize-avatar`), mount this in the bot's tile, and
- * the face listens, thinks, claims the floor and lipsyncs what the TTS says.
+ * This package is the loader and nothing else. The avatar itself — the
+ * characters, the renderer and everything that reads the call — is the
+ * Voqalize avatar runtime, which this module imports from
+ * `avatar.voqalize.com` at the version it was released with and which is
+ * licensed separately. `createAvatar` returns at once; the face appears when
+ * the runtime and the character have arrived.
  *
- * Entry points, and the split is the design rather than packaging taste:
- *
- * - `@voqalize/avatar` — this one. Framework-free. `@pipecat-ai/client-js` is
- *   a type-only import, so even that peer is genuinely optional at runtime.
- *   It carries exactly one drawing: `peep`, the default face.
- * - `@voqalize/avatar/faces/{peep,wren,myna}` — one drawing each. Import the
- *   one you want and pass it as `face`; the others never enter your bundle.
- * - `@voqalize/avatar/react` — `<Avatar>`. Pulls React; nothing here does.
- * - `@voqalize/avatar/internal` — the SVG widget, the behavior catalog and the
- *   viseme clock. **No semver promise**: these move in any minor. They are
- *   exported because an avatar author building on our renderer needs them, not
- *   because they are an interface.
- *
- * To ship your own avatar, publish a module exporting `createAvatar` and import
- * that instead — see `createAvatar.ts` and docs/design-avatar-interface.md. A
- * module may also export `supports`, which is how a page that *drives* an
- * avatar learns which action ids this one answers to; every consumer that only
- * mounts a face can ignore it.
+ * A page with a Content-Security-Policy needs `https://avatar.voqalize.com` in
+ * `script-src` (the runtime), `connect-src` (the character it fetches) and
+ * `img-src` (the camera-off still, where there is no WebGL 2), and `blob:` in
+ * `connect-src` (the character's textures are decoded from blob URLs;
+ * `img-src` too on Safari before 17 and Firefox before 98).
  */
-export { createAvatar } from "./createAvatar.js";
-export { supports } from "./supports.js";
-export type { AvatarOptions, AvatarInstance, AvatarFactory, AvatarSupport, SvgAvatarOptions, Face, FaceTheme, Gain, HandSide, } from "./createAvatar.js";
-//# sourceMappingURL=index.d.ts.map
+import type { PipecatClient } from "@pipecat-ai/client-js";
+/** Amplitude, 0..2. `1` is as authored. */
+export type Gain = number;
+export interface AvatarOptions {
+    /** The element to render into. The avatar owns its contents. */
+    readonly mount: HTMLElement;
+    /** The live `PipecatClient` the avatar embodies. */
+    readonly client: PipecatClient;
+    /** Which character, by name — `"tara"`, for example. */
+    readonly character: string;
+    /** Mouth movement. */
+    readonly mouthGain?: Gain;
+    /** Nods and other gestures. */
+    readonly gestureGain?: Gain;
+    /** Idle motion. */
+    readonly motionGain?: Gain;
+}
+export interface AvatarInstance {
+    /** Stop embodying the client and empty the mount. Safe to call at any time,
+     * including before the avatar has appeared. */
+    destroy(): void;
+}
+export declare function createAvatar(options: AvatarOptions): AvatarInstance;

package/dist/index.js

@@ -3,31 +3,54 @@
  *
  *     import { createAvatar } from "@voqalize/avatar";
  *
- *     const avatar = createAvatar({ mount: el, client: pipecatClient });
+ *     const avatar = createAvatar({ mount: el, client: pipecatClient, character: "tara" });
+ *     // …
+ *     avatar.destroy();
  *
- * That is the whole public surface. Put an `AvatarProcessor` in the pipecat
- * pipeline (`pip install voqalize-avatar`), mount this in the bot's tile, and
- * the face listens, thinks, claims the floor and lipsyncs what the TTS says.
+ * This package is the loader and nothing else. The avatar itself — the
+ * characters, the renderer and everything that reads the call — is the
+ * Voqalize avatar runtime, which this module imports from
+ * `avatar.voqalize.com` at the version it was released with and which is
+ * licensed separately. `createAvatar` returns at once; the face appears when
+ * the runtime and the character have arrived.
  *
- * Entry points, and the split is the design rather than packaging taste:
- *
- * - `@voqalize/avatar` — this one. Framework-free. `@pipecat-ai/client-js` is
- *   a type-only import, so even that peer is genuinely optional at runtime.
- *   It carries exactly one drawing: `peep`, the default face.
- * - `@voqalize/avatar/faces/{peep,wren,myna}` — one drawing each. Import the
- *   one you want and pass it as `face`; the others never enter your bundle.
- * - `@voqalize/avatar/react` — `<Avatar>`. Pulls React; nothing here does.
- * - `@voqalize/avatar/internal` — the SVG widget, the behavior catalog and the
- *   viseme clock. **No semver promise**: these move in any minor. They are
- *   exported because an avatar author building on our renderer needs them, not
- *   because they are an interface.
- *
- * To ship your own avatar, publish a module exporting `createAvatar` and import
- * that instead — see `createAvatar.ts` and docs/design-avatar-interface.md. A
- * module may also export `supports`, which is how a page that *drives* an
- * avatar learns which action ids this one answers to; every consumer that only
- * mounts a face can ignore it.
+ * A page with a Content-Security-Policy needs `https://avatar.voqalize.com` in
+ * `script-src` (the runtime), `connect-src` (the character it fetches) and
+ * `img-src` (the camera-off still, where there is no WebGL 2), and `blob:` in
+ * `connect-src` (the character's textures are decoded from blob URLs;
+ * `img-src` too on Safari before 17 and Firefox before 98).
  */
-export { createAvatar } from "./createAvatar.js";
-export { supports } from "./supports.js";
-//# sourceMappingURL=index.js.map
+import { PROTOCOL, RUNTIME_URL } from "./pin.js";
+let runtime;
+function load() {
+    // One import per page, however many avatars mount; a failure is forgotten so
+    // the next mount tries again rather than inheriting a dead promise.
+    runtime ??= import(/* @vite-ignore */ /* webpackIgnore: true */ RUNTIME_URL).catch((error) => {
+        runtime = undefined;
+        throw error;
+    });
+    return runtime;
+}
+export function createAvatar(options) {
+    if (!options?.mount)
+        throw new TypeError("createAvatar: `mount` is required");
+    if (!options.client)
+        throw new TypeError("createAvatar: `client` is required");
+    if (!options.character)
+        throw new TypeError("createAvatar: `character` is required");
+    let instance;
+    let destroyed = false;
+    load()
+        .then((rt) => {
+        if (!destroyed)
+            instance = rt.mount({ ...options, protocol: PROTOCOL });
+    })
+        .catch((error) => console.error(`[avatar] could not start the avatar from ${RUNTIME_URL}`, error));
+    return {
+        destroy() {
+            destroyed = true;
+            instance?.destroy();
+            instance = undefined;
+        },
+    };
+}

package/dist/pin.d.ts

@@ -0,0 +1,2 @@
+export declare const RUNTIME_URL = "https://avatar.voqalize.com/runtime/runtime.Y7EOKTPQ.js";
+export declare const PROTOCOL = 1;

package/dist/pin.js

@@ -0,0 +1,3 @@
+// Written by scripts/build-runtime.mjs — the runtime this shim is released with.
+export const RUNTIME_URL = "https://avatar.voqalize.com/runtime/runtime.Y7EOKTPQ.js";
+export const PROTOCOL = 1;

package/dist/react.d.ts

@@ -3,11 +3,26 @@
  *
  *     import { Avatar } from "@voqalize/avatar/react";
  *
- *     <Avatar client={session.client} className="avatar-tile" />
+ *     <Avatar client={session.client} character="tara" className="avatar-tile" />
  *
- * Separate from the main entry so that `createAvatar` costs nothing to a
- * caller who is not on React — React is an optional peer, and a barrel that
- * re-exported this would make it a hard one.
+ * Separate from the main entry so that `createAvatar` costs nothing to a caller
+ * who is not on React. Everything but the avatar's own props is forwarded to
+ * the mount `<div>`, so it sizes and styles like the tile it lives in.
  */
-export { Avatar, type AvatarProps } from "./Avatar.js";
-//# sourceMappingURL=react.d.ts.map
+import { type HTMLAttributes } from "react";
+import type { PipecatClient } from "@pipecat-ai/client-js";
+import { type Gain } from "./index.js";
+export type AvatarProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    /** The live `PipecatClient`, or `null` before connect. Nothing mounts until
+     * it is non-null. */
+    client?: PipecatClient | null;
+    /** Which character, by name. */
+    character: string;
+    /** Read at mount only. */
+    mouthGain?: Gain;
+    /** Read at mount only. */
+    gestureGain?: Gain;
+    /** Read at mount only. */
+    motionGain?: Gain;
+};
+export declare function Avatar({ client, character, mouthGain, gestureGain, motionGain, ...rest }: AvatarProps): import("react").JSX.Element;

package/dist/react.js

@@ -1,13 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * `@voqalize/avatar/react` — the avatar as one component.
  *
  *     import { Avatar } from "@voqalize/avatar/react";
  *
- *     <Avatar client={session.client} className="avatar-tile" />
+ *     <Avatar client={session.client} character="tara" className="avatar-tile" />
  *
- * Separate from the main entry so that `createAvatar` costs nothing to a
- * caller who is not on React — React is an optional peer, and a barrel that
- * re-exported this would make it a hard one.
+ * Separate from the main entry so that `createAvatar` costs nothing to a caller
+ * who is not on React. Everything but the avatar's own props is forwarded to
+ * the mount `<div>`, so it sizes and styles like the tile it lives in.
  */
-export { Avatar } from "./Avatar.js";
-//# sourceMappingURL=react.js.map
+import { useEffect, useRef } from "react";
+import { createAvatar } from "./index.js";
+export function Avatar({ client, character, mouthGain, gestureGain, motionGain, ...rest }) {
+    const ref = useRef(null);
+    // The gains are read at mount through a ref, so a fresh literal on every
+    // render does not rebuild the face.
+    const gains = useRef({ mouthGain, gestureGain, motionGain });
+    gains.current = { mouthGain, gestureGain, motionGain };
+    useEffect(() => {
+        const mount = ref.current;
+        if (!mount || !client)
+            return;
+        const avatar = createAvatar({ mount, client, character, ...gains.current });
+        return () => avatar.destroy();
+        // A new client or character is a new thing to embody, so the avatar is
+        // rebuilt rather than re-pointed.
+    }, [client, character]);
+    return _jsx("div", { role: "img", "aria-label": "avatar", ...rest, ref: ref });
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@voqalize/avatar",
-  "version": "0.4.4",
-  "description": "A JavaScript-programmable talking head for AI voice calls: line-art or 2.5-D faces, server-synced lipsync, state through motion, no runtime dependencies.",
-  "license": "MIT AND CC-BY-4.0 AND Apache-2.0",
+  "version": "0.5.0",
+  "description": "A talking head for AI voice calls that embodies your pipecat client. This package loads the Voqalize avatar runtime.",
+  "license": "MIT",
   "author": "Voqalize",
   "homepage": "https://github.com/voqalize/avatar#readme",
   "repository": {
@@ -17,14 +17,8 @@
     "avatar",
     "talking-head",
     "lipsync",
-    "viseme",
-    "rhubarb",
     "pipecat",
-    "voice-agent",
-    "svg",
-    "animation",
-    "3d",
-    "threejs"
+    "voice-agent"
   ],
   "engines": {
     "node": ">=20"
@@ -45,66 +39,20 @@
       "types": "./dist/react.d.ts",
       "default": "./dist/react.js"
     },
-    "./internal": {
-      "types": "./dist/internal.d.ts",
-      "default": "./dist/internal.js"
-    },
-    "./internal/three": {
-      "types": "./dist/three/internal.d.ts",
-      "default": "./dist/three/internal.js"
-    },
-    "./faces/peep": {
-      "types": "./src/face-peep.d.ts",
-      "default": "./src/face-peep.js"
-    },
-    "./faces/wren": {
-      "types": "./src/face-wren.d.ts",
-      "default": "./src/face-wren.js"
-    },
-    "./faces/myna": {
-      "types": "./src/face-myna.d.ts",
-      "default": "./src/face-myna.js"
-    },
-    "./avatars/tara": {
-      "types": "./dist/three/tara.d.ts",
-      "default": "./dist/three/tara.js"
-    },
-    "./avatars/tushar": {
-      "types": "./dist/three/tushar.d.ts",
-      "default": "./dist/three/tushar.js"
-    },
-    "./avatars/tanya": {
-      "types": "./dist/three/tanya.d.ts",
-      "default": "./dist/three/tanya.js"
-    },
-    "./avatars/tess": {
-      "types": "./dist/three/tess.d.ts",
-      "default": "./dist/three/tess.js"
-    },
-    "./avatars/tanvi": {
-      "types": "./dist/three/tanvi.d.ts",
-      "default": "./dist/three/tanvi.js"
-    },
     "./package.json": "./package.json"
   },
   "files": [
-    "src",
-    "client",
-    "dist",
-    "assets",
-    "LICENSE-CC-BY-4.0",
-    "LICENSE-APACHE-2.0"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "prepare": "tsc -p tsconfig.json"
+    "prepare": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json"
   },
   "peerDependencies": {
     "@pipecat-ai/client-js": ">=1.4 <2",
     "react": ">=18",
-    "react-dom": ">=18",
-    "three": ">=0.180 <0.187"
+    "react-dom": ">=18"
   },
   "peerDependenciesMeta": {
     "@pipecat-ai/client-js": {
@@ -115,13 +63,6 @@
     },
     "react-dom": {
       "optional": true
-    },
-    "three": {
-      "optional": true
     }
-  },
-  "devDependencies": {
-    "@types/three": "^0.185.4",
-    "three": "^0.180.0"
   }
 }