@npcify/web 0.7.3 → 0.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -130,6 +130,7 @@ animate()
130
130
  - `character.onConnectionClosed(callback)`: The server closed the conversation connection ([lifecycle](#runtime-and-lifecycle)).
131
131
  - **Voice Input** ([details](#voice-input-and-input-modes)):
132
132
  - `character.bindPushToTalk(options)`, `character.startListening(options)`, `character.stopListening()`, `character.cancelListening()`.
133
+ - `character.interruptible`, `character.interrupt()`, `character.onInterrupted(callback)`: stop a reply ([details](#interrupting-a-reply)).
133
134
  - `character.listeningState`, `character.onListeningState(callback)`, `character.onTranscript(callback)`, `character.inputModes`.
134
135
  - `character.notifyUserTyping(active)`, `character.playerActivity`, `character.onPlayerActivity(callback)`: listening reflexes ([details](#voice-input-and-input-modes)).
135
136
  - `await character.dispose()`: Ends conversation, detaches from the scene, removes the audio element, and disposes VRM GPU resources.
@@ -265,6 +266,38 @@ character.onListeningState((state) => {
265
266
  - The character owner pays the recognition at the price of the provider that
266
267
  the owner chose, as for the turn's language model.
267
268
 
269
+ ### Interrupting a reply
270
+
271
+ When the character owner turned on **Players can interrupt replies** (the
272
+ STT tab, Interruption; it needs custom replies and no baked conversation, not
273
+ voice input), the
274
+ player can stop a reply while it is generated or plays. The reply field and
275
+ push-to-talk need no lock during the reply:
276
+
277
+ ```js
278
+ character.onInterrupted(({ phase, stored }) => {
279
+ // 'thinking' (cancelled, its message joins the next one), 'speaking' or 'played' (kept, cut where it was heard)
280
+ })
281
+ sendButton.disabled = character.thinking && !character.interruptible
282
+ ```
283
+
284
+ - `sendMessage(text)` during a reply stops it at once (audio, mouth, face and
285
+ live motion ease to idle within 0.25 s) and sends the new message with the
286
+ heard position. The `sendMessage` of the stopped reply rejects with a
287
+ `NpcifyTurnError` whose `code` is `TURN_INTERRUPTED`
288
+ (`isTurnInterrupted(error)`); it is not an error for the UI.
289
+ - A push-to-talk press during a reply silences it at once. After `minHoldMs`
290
+ the reply stops and the server is told; a shorter press plays the reply
291
+ on. `startListening({ interruptAfterMs })` does the same from code.
292
+ - `interrupt()` stops the running reply without a message (a stop button).
293
+ - `interruptible` is true while a reply runs that the player can interrupt.
294
+ - Too many interrupts before the first sound (6 a minute, 30 an hour) give a
295
+ `NpcifyTurnError` with `code` `INTERRUPT_RATE_LIMITED`; the reply then goes
296
+ on.
297
+ - The owner pays the model tokens up to the stop; a reply stopped before its
298
+ first sound charges the player no message fee
299
+ ([pricing](../../docs/ai-pricing.md#interrupted-replies)).
300
+
268
301
  ## Sight
269
302
 
270
303
  The character can see the player's camera when the character owner turned
@@ -364,6 +397,10 @@ character.onSight(({ summary }) => { status.textContent = `The character sees: $
364
397
  `CONVERSATION_TIMEOUT`. A refused conversation fails at once with
365
398
  `CONVERSATION_ACCESS_DENIED` until `endConversation()`; after another join
366
399
  code (`CONVERSATION_JOIN_FAILED` or a newer one) the next call tries again.
400
+ - Spring bones (hair, skirts, tails, wings, the bust of a generated
401
+ character) step at 60 per second on displays faster than 60 Hz (0.8.1), as
402
+ the character generator tunes them; before, a 120 Hz display halved their
403
+ swing. At 60 Hz and slower they run as before.
367
404
  - ESM only; `require()` is not a supported package entry point. Browser APIs are
368
405
  used when creating a view; do not call `mountNpcify` during server rendering.
369
406
 
package/dist/index.d.ts CHANGED
@@ -147,6 +147,12 @@ interface AvatarPublicInfo {
147
147
  sdkMemoryEnabled?: boolean;
148
148
  /** On live turns, the character gets the player's local message time (missing on older servers: off). */
149
149
  messageTimeEnabled?: boolean;
150
+ /**
151
+ * Players can interrupt a reply while it plays. On the public info it is the
152
+ * effective value (custom replies on, baked playback off); on the owner's
153
+ * summary it is the owner's switch. Missing on older servers: off.
154
+ */
155
+ allowInterruption?: boolean;
150
156
  cameraSqt?: Sqt | null;
151
157
  /** Allowed appearance variants (`default` first) when the character has variants. */
152
158
  variants?: AvatarVariantSummary[];
@@ -178,6 +184,8 @@ interface ConversationWorldlineStaging {
178
184
  initialVariant?: string;
179
185
  activeVariant?: string;
180
186
  toolCalls?: StagingToolCall[];
187
+ /** The player interrupted this reply; `text` holds what the player heard. */
188
+ interrupted?: boolean;
181
189
  }
182
190
  interface ConversationWorldline {
183
191
  conversationId: string;
@@ -451,7 +459,29 @@ interface StagingStreamMotionFramesEvent {
451
459
  /** `frameCount x (3 + 4 x bones.length)` float32 values, little endian. */
452
460
  frames: Uint8Array;
453
461
  }
454
- type StagingStreamEvent = StagingStreamStartEvent | StagingStreamTextDeltaEvent | StagingStreamTimelineEvent | StagingStreamPrefixEvent | StagingStreamLiveEvent | StagingStreamSpeechChunkEvent | StagingStreamSpeechCompleteEvent | StagingStreamSpeechErrorEvent | StagingStreamOptionsEvent | StagingStreamErrorEvent | StagingStreamBillingEvent | StagingStreamMotionFramesEvent;
462
+ /** Where a reply was when the player interrupted it. */
463
+ type StagingInterruptPhase = 'thinking' | 'speaking' | 'played';
464
+ /**
465
+ * The player interrupted a reply (NPCP 1.2 stream event; older receivers
466
+ * ignore it). `stored` is true when the reply stays in the worldline as the
467
+ * parent of the next turn (cut at `heardSeconds` of the staging clock); false
468
+ * when it was cancelled before its first sound.
469
+ */
470
+ interface StagingStreamInterruptedEvent {
471
+ type: 'interrupted';
472
+ taskId: string;
473
+ stagingId: string;
474
+ phase: StagingInterruptPhase;
475
+ stored: boolean;
476
+ heardSeconds: number;
477
+ /**
478
+ * Only on the client: the SDK stopped the reply but the server did not
479
+ * (it had nothing to stop, refused, or did not answer). The worldline is
480
+ * unchanged; the player can reply.
481
+ */
482
+ local?: boolean;
483
+ }
484
+ type StagingStreamEvent = StagingStreamStartEvent | StagingStreamTextDeltaEvent | StagingStreamTimelineEvent | StagingStreamPrefixEvent | StagingStreamLiveEvent | StagingStreamSpeechChunkEvent | StagingStreamSpeechCompleteEvent | StagingStreamSpeechErrorEvent | StagingStreamOptionsEvent | StagingStreamErrorEvent | StagingStreamBillingEvent | StagingStreamMotionFramesEvent | StagingStreamInterruptedEvent;
455
485
 
456
486
  /**
457
487
  * Voice input of conversations (docs/voice-input.md): the input modes of the
@@ -507,8 +537,45 @@ interface ConversationTurnOptions {
507
537
  /** The turn's `Idempotency-Key`; a new UUID when absent. */
508
538
  requestId?: string;
509
539
  }
540
+ /** What the client played of a reply that the player interrupted. */
541
+ interface InterruptedReplyPosition {
542
+ stagingId: string | null;
543
+ /** Seconds of the staging clock that played; 0 before any sound. */
544
+ heardSeconds: number;
545
+ }
546
+ /**
547
+ * A turn failed with a code of the server that the SDK handles:
548
+ * `TURN_INTERRUPTED` (the player interrupted the reply; not an error for
549
+ * the UI) or `INTERRUPT_RATE_LIMITED` (too many interrupts before the first
550
+ * sound; the running reply goes on).
551
+ */
552
+ /** The codes of a refused or interrupted turn, or of a refused interrupt. */
553
+ type NpcifyTurnErrorCode = 'TURN_INTERRUPTED' | 'INTERRUPT_RATE_LIMITED' | 'INTERRUPTION_DISABLED' | 'CONVERSATION_ACCESS_DENIED';
554
+ declare class NpcifyTurnError extends Error {
555
+ readonly code: NpcifyTurnErrorCode;
556
+ readonly status: number;
557
+ constructor(code: NpcifyTurnErrorCode, status: number);
558
+ }
559
+ /** The code of a turn error of the SDK (`NpcifyTurnError`, `SpeechInputError`). */
560
+ declare const turnErrorCode: (error: unknown) => string | null;
561
+ /**
562
+ * True when the player interrupted the turn (a typed or a voice turn): not an
563
+ * error for the UI.
564
+ */
565
+ declare const isTurnInterrupted: (error: unknown) => boolean;
510
566
 
511
- type NpcifyAssetInfo = Pick<AvatarPublicInfo, 'animations' | 'idleAnimationId' | 'bakedConversationEnabled' | 'bakedConversationRevision'> & Partial<Pick<AvatarPublicInfo, 'allowCustomReply' | 'speechInputEnabled' | 'sight' | 'sdkMemoryEnabled' | 'variants'>>;
567
+ /** What started an interrupt: a sent message or a talk press. */
568
+ type InterruptSource = 'send' | 'talk';
569
+ /** A reply that the player interrupted. */
570
+ interface InterruptedReply extends InterruptedReplyPosition {
571
+ /** The server's task of the reply, when the client knows it. */
572
+ taskId: string | null;
573
+ source: InterruptSource;
574
+ /** Milliseconds from the player's action to silent audio. */
575
+ muteMs: number;
576
+ }
577
+
578
+ type NpcifyAssetInfo = Pick<AvatarPublicInfo, 'animations' | 'idleAnimationId' | 'bakedConversationEnabled' | 'bakedConversationRevision'> & Partial<Pick<AvatarPublicInfo, 'allowCustomReply' | 'allowInterruption' | 'speechInputEnabled' | 'sight' | 'sdkMemoryEnabled' | 'variants'>>;
512
579
  interface FetchVrmDownloadUrlOptions {
513
580
  apiToken?: string;
514
581
  assetProfile?: 'original' | 'web-optimized-v1';
@@ -577,6 +644,13 @@ declare class ClientTelemetry {
577
644
  latePhonemeCount: number;
578
645
  phonemeLateMs: number;
579
646
  }): void;
647
+ /** The time from the player's interrupt to silent audio. */
648
+ reportInterrupt(params: {
649
+ conversationId: string;
650
+ taskId: string;
651
+ stagingId: string;
652
+ muteMs: number;
653
+ }): void;
580
654
  }
581
655
 
582
656
  /** Deduplicate animation demand and discard results after model/catalog replacement. */
@@ -726,7 +800,7 @@ type PerformanceEventPayload = {
726
800
  state: 'requested' | 'succeeded' | 'blocked';
727
801
  } | {
728
802
  type: 'staging.stream';
729
- event: 'start' | 'timeline' | 'options' | 'error';
803
+ event: 'start' | 'timeline' | 'options' | 'error' | 'interrupted';
730
804
  stagingId: string;
731
805
  taskId: string;
732
806
  } | {
@@ -1124,6 +1198,8 @@ type ResumableAudioContext = BaseAudioContext & {
1124
1198
  };
1125
1199
  declare class AudioPlayer {
1126
1200
  private readonly visemePlayer;
1201
+ /** The caller paused the audio (`pausePlayback`), maybe before it started. */
1202
+ private pausedByCaller;
1127
1203
  private audioElement;
1128
1204
  private readonly streams;
1129
1205
  private unlocked;
@@ -1163,6 +1239,13 @@ declare class AudioPlayer {
1163
1239
  getCurrentTime(): number;
1164
1240
  updateVisemes(visemes: ConversationTimelineEntry[]): void;
1165
1241
  stop(): void;
1242
+ /** Pauses the playing or starting audio; `resumePlayback` continues it. */
1243
+ pausePlayback(): void;
1244
+ /**
1245
+ * Continues audio paused by `pausePlayback`, also one that had not started.
1246
+ * `started`: the audio played before the pause.
1247
+ */
1248
+ resumePlayback(started?: boolean): Promise<void>;
1166
1249
  reset(): void;
1167
1250
  cleanup(): void;
1168
1251
  private discardStream;
@@ -1211,12 +1294,19 @@ declare class StagingPlayer {
1211
1294
  private readonly appliedToolCallIds;
1212
1295
  private activeOptions?;
1213
1296
  constructor(audioPlayer: AudioPlayer, facialMixer: FacialPerformanceMixer, animationController: AnimationControllerLike);
1297
+ /** A staging plays (also while it is paused). */
1298
+ get playing(): boolean;
1214
1299
  get paused(): boolean;
1215
1300
  /**
1216
1301
  * Seconds of the staging clock that the tracks show now, or null when no
1217
1302
  * staging plays (also while playback waits for the next dialogue block).
1218
1303
  */
1219
1304
  get trackTime(): number | null;
1305
+ /**
1306
+ * Seconds of the staging clock that played: the track time, or between
1307
+ * dialogue blocks the time that played so far; 0 before any staging.
1308
+ */
1309
+ get positionSeconds(): number;
1220
1310
  pause(): void;
1221
1311
  resume(): Promise<void>;
1222
1312
  private waitUntilResumed;
@@ -1263,6 +1353,8 @@ declare class LiveMotionPlayer {
1263
1353
  private readonly blendIn;
1264
1354
  private readonly blendOut;
1265
1355
  private weight;
1356
+ /** A shorter blend-out after an interrupt, until the weight is 0. */
1357
+ private quickBlendOut;
1266
1358
  /** The last applied pose, to blend out of it after the frames end. */
1267
1359
  private lastPose;
1268
1360
  private readonly scratch;
@@ -1274,6 +1366,11 @@ declare class LiveMotionPlayer {
1274
1366
  load(stagingId: string, track: StagingMotionTrack, fetchBytes?: (url: string) => Promise<Uint8Array>): Promise<void>;
1275
1367
  has(stagingId: string): boolean;
1276
1368
  forget(stagingId: string): void;
1369
+ /**
1370
+ * The player interrupted the reply: its frames go, and the pose blends to
1371
+ * the mixer's pose (idle) within `seconds`.
1372
+ */
1373
+ stop(stagingId: string | null, seconds?: number): void;
1277
1374
  /** The current live weight, 0 (idle) to 1 (live frames). */
1278
1375
  get liveWeight(): number;
1279
1376
  /**
@@ -1509,6 +1606,11 @@ declare class StreamPlaybackController {
1509
1606
  private currentCursorValue;
1510
1607
  private readonly playedStagingIds;
1511
1608
  private readonly states;
1609
+ /** Events of a reply that the player is interrupting, kept until it is decided. */
1610
+ private readonly heldTasks;
1611
+ /** Replies that the player interrupted: their late events are dropped. */
1612
+ private readonly droppedTasks;
1613
+ private interruptedCallback;
1512
1614
  constructor(dependencies: StreamPlaybackDependencies);
1513
1615
  get speaking(): boolean;
1514
1616
  get currentSpeech(): StagingSpeechPlaybackEvent | null;
@@ -1518,6 +1620,16 @@ declare class StreamPlaybackController {
1518
1620
  get cursor(): CharacterPlaybackCursor | null;
1519
1621
  /** The staging that plays or waits to play, or null. */
1520
1622
  get activeStagingId(): string | null;
1623
+ /** The task of the staging that plays or waits to play, or null. */
1624
+ get activeTaskId(): string | null;
1625
+ /** The server stopped a reply that the player interrupted. */
1626
+ onInterrupted(callback: (event: StagingStreamInterruptedEvent) => void): () => void;
1627
+ /** Keeps the later events of a task until `release` or `drop`. */
1628
+ hold(taskId: string): void;
1629
+ /** The interrupt did not happen (a short press, a refused interrupt): play on. */
1630
+ release(taskId: string): void;
1631
+ /** The reply was interrupted: its held and later events are dropped. */
1632
+ drop(taskId: string): void;
1521
1633
  /**
1522
1634
  * A staging plays or waits to play (its audio or the rest of its stream).
1523
1635
  * False after it completed or when autoplay blocked it; the last staging
@@ -1531,13 +1643,21 @@ declare class StreamPlaybackController {
1531
1643
  onOptionsReady(callback: (payload: StagingOptionsReadyPayload) => void): () => void;
1532
1644
  onTimelineStart(callback: (timeline: StagingTimeline, playback: StagingPlaybackStart) => Promise<void> | void): () => void;
1533
1645
  onPlaybackCursor(callback: (cursor: CharacterPlaybackCursor) => void): () => void;
1534
- hasPlayed(stagingId: string): boolean;
1646
+ /** The staging played, or its task was stopped (it never plays later). */
1647
+ hasPlayed(stagingId: string, taskId?: string | null): boolean;
1535
1648
  playPayload(payload: StagingResultPayload, options?: {
1536
1649
  force?: boolean;
1537
1650
  timeline?: StagingTimeline;
1538
1651
  }): Promise<boolean>;
1652
+ /**
1653
+ * The SDK stopped a reply that the server did not stop: the app learns it
1654
+ * as an `interrupted` event with `local: true`.
1655
+ */
1656
+ notifyLocalInterrupt(event: StagingStreamInterruptedEvent): void;
1539
1657
  /** Returns the playback result for a timeline event. */
1540
1658
  handleEvent(event: StagingStreamEvent): Promise<boolean> | undefined;
1659
+ /** Stops the active staging at once; its audio and buffers go. */
1660
+ stopActive(): void;
1541
1661
  cleanup(): void;
1542
1662
  private resetRealtimeSpeech;
1543
1663
  private playTimeline;
@@ -1821,6 +1941,11 @@ declare class CharacterRuntime extends CharacterSceneAccess {
1821
1941
  set gazeTarget(target: Object3D | null);
1822
1942
  /** True while the character is actively delivering a speech block or playing voice audio. */
1823
1943
  get speaking(): boolean;
1944
+ /**
1945
+ * True while a staging plays or waits for the rest of its stream; false
1946
+ * after it ended or was stopped (an app opens its replies then).
1947
+ */
1948
+ get playbackActive(): boolean;
1824
1949
  /** True while waiting for the next AI turn to begin streaming or playing. */
1825
1950
  get thinking(): boolean;
1826
1951
  /** Active speech block metadata during playback, or `null` when silent. */
@@ -2030,6 +2155,14 @@ interface ListeningOptions {
2030
2155
  endOnSilenceMs?: number | null;
2031
2156
  parentStagingId?: string | null;
2032
2157
  silent?: boolean;
2158
+ /**
2159
+ * A press during a reply of a character with interruption: the reply is
2160
+ * silenced at once and stopped after this time (push-to-talk passes its
2161
+ * `minHoldMs`); a cancel before it plays the reply on. 0: stop at once.
2162
+ */
2163
+ interruptAfterMs?: number;
2164
+ /** Internal: the turn interrupts the running reply (`preempt`). */
2165
+ preempt?: boolean;
2033
2166
  }
2034
2167
  interface SpeechInputResult {
2035
2168
  /** The recognised text; empty when no speech was recognised (then no turn starts). */
@@ -2100,8 +2233,6 @@ declare class Character extends CharacterRuntime {
2100
2233
  private readonly notifiedStagingIds;
2101
2234
  private readonly liveConversation;
2102
2235
  private baked;
2103
- /** The conversation whose live motion was warmed up. */
2104
- private liveMotionPrepared;
2105
2236
  private readonly authoring;
2106
2237
  private hostedWebChat;
2107
2238
  private memoryIdentifier;
@@ -2110,6 +2241,10 @@ declare class Character extends CharacterRuntime {
2110
2241
  private readonly bakedAsset?;
2111
2242
  private animationRefreshId;
2112
2243
  private readonly voice;
2244
+ private readonly interruption;
2245
+ /** The character allows interruption (`allowInterruption` of its info). */
2246
+ private allowInterruption;
2247
+ private readonly talk;
2113
2248
  private readonly sight;
2114
2249
  private readonly inputs;
2115
2250
  private listeningStateCallback;
@@ -2140,6 +2275,15 @@ declare class Character extends CharacterRuntime {
2140
2275
  dispose(options?: CharacterDisposeOptions): Promise<void>;
2141
2276
  sendMessage(message: string, options?: ConversationTurnOptions): Promise<StagingResultPayload>;
2142
2277
  sendMessage(conversationId: string, message: string, options?: ConversationTurnOptions): Promise<StagingResultPayload>;
2278
+ /** A reply runs that the player can interrupt (no input lock is needed). */
2279
+ get interruptible(): boolean;
2280
+ /**
2281
+ * Stops the running reply (audio, mouth, face and motion ease to idle
2282
+ * within 0.25 s) and tells the server; null when nothing runs.
2283
+ */
2284
+ interrupt(): Promise<InterruptedReply | null>;
2285
+ /** The server stopped a reply that the player interrupted. */
2286
+ onInterrupted(callback: (event: StagingStreamInterruptedEvent) => void): () => void;
2143
2287
  replayStaging(stagingId: string): Promise<StagingResultPayload>;
2144
2288
  replayStaging(conversationId: string, stagingId: string, options?: PlayStagingOptions): Promise<StagingResultPayload>;
2145
2289
  get isBakedConversation(): boolean;
@@ -2327,4 +2471,4 @@ interface NpcifyView {
2327
2471
  /** Mount into an existing canvas. Its CSS must give it a nonzero width and height. */
2328
2472
  declare const mountNpcify: (options: MountNpcifyOptions) => Promise<NpcifyView>;
2329
2473
 
2330
- export { AnimationController, type AnimationControllerLike, type AnimationControllerOptions, type AssetLoadProgress, type AudioCapture, type AudioPerformanceFrameSnapshot, AudioPlayer, type AvatarVariantSummary, BakedConversation, type BakedConversationAsset, type CaptureFrame, Character, CharacterAnimation, type CharacterAnimationPlayOptions, CharacterAudio, type CharacterDisposeOptions, CharacterExpressions, type CharacterLookAtTarget, type CharacterOptions, type CharacterPlaybackCursor, CharacterRuntime, type CharacterRuntimeInitOptions, CharacterSceneRig, type CharacterShadowOptions, type CharacterSpeechState, type CharacterTransformOptions, type CharacterVariantChangeEvent, type ConversationConnectionClosedEvent, ConversationConnectionError, type ConversationConnectionErrorCode, type ConversationJoinFailure, type ConversationTurnOptions, DEFAULT_VARIANT_KEY, type FacialChannelName, type FacialCueOptions, type FacialMouthMode, type FacialPerformanceFrameSnapshot, FacialPerformanceLayer, type FacialPerformanceLayerId, FacialPerformanceMixer, type FacialPerformanceModelSnapshot, type FetchVrmDownloadUrlOptions, INPUT_MODES, type InputMode, InputModeError, type ListeningOptions, type ListeningState, type LiveMotionOptions, LiveMotionPlayer, type LiveMotionRootMode, type LlmThinkingPayload, type LoadCharacterOptions, MicrophoneError, type MountNpcifyOptions, NUDE_VARIANT_KEY, Npcify, type NpcifyAssetInfo, Character as NpcifyCharacter, type NpcifyEventMap, type NpcifyEventName, type NpcifyOptions, type NpcifyView, PERFORMANCE_FILE_EXTENSION, PERFORMANCE_MEDIA_TYPE, type PerformanceAnalysis, type PerformanceAnalysisOptions, type PerformanceEvent, type PerformanceFrame, type PerformanceIssue, type PerformanceKind, type PerformanceRecording, PerformanceRecordingSchemaVersion, type PerformanceRecordingStartOptions, type PerformanceTimelineSnapshot, type PlayStagingOptions, type PlayerActivity, type PushToTalkOptions, type PushToTalkTarget, RemoteAnimationController, type RepeatedVisemeTransitionAnalysis, SightError, type SightFailureCode, type SightObservation, type SightObservationEvent, type SightOptions, type SightPerson, type SightState, SpeechInputError, type SpeechInputResult, type StagingOptionsReadyPayload, type StagingPlaybackStart, type StagingSpeechPlaybackEvent, type StagingSwitchVariantArguments, type StagingToolCall, type StagingToolCallResult, type StagingToolName, type StagingToolResultStatus, type TranscriptEvent, type VariantChangeEvent, type Vector3Like, type Vector3Tuple, type VisemePerformanceFrameSnapshot, analyzePerformanceRecording, bindPushToTalk, createCharacter, decodePerformance, encodePerformance, fetchVariantVrmDownloadUrl, fetchVrmDownloadUrl, loadBakedConversation, loadCharacter, loadVariantVrm, loadVrm, mountNpcify };
2474
+ export { AnimationController, type AnimationControllerLike, type AnimationControllerOptions, type AssetLoadProgress, type AudioCapture, type AudioPerformanceFrameSnapshot, AudioPlayer, type AvatarVariantSummary, BakedConversation, type BakedConversationAsset, type CaptureFrame, Character, CharacterAnimation, type CharacterAnimationPlayOptions, CharacterAudio, type CharacterDisposeOptions, CharacterExpressions, type CharacterLookAtTarget, type CharacterOptions, type CharacterPlaybackCursor, CharacterRuntime, type CharacterRuntimeInitOptions, CharacterSceneRig, type CharacterShadowOptions, type CharacterSpeechState, type CharacterTransformOptions, type CharacterVariantChangeEvent, type ConversationConnectionClosedEvent, ConversationConnectionError, type ConversationConnectionErrorCode, type ConversationJoinFailure, type ConversationTurnOptions, DEFAULT_VARIANT_KEY, type FacialChannelName, type FacialCueOptions, type FacialMouthMode, type FacialPerformanceFrameSnapshot, FacialPerformanceLayer, type FacialPerformanceLayerId, FacialPerformanceMixer, type FacialPerformanceModelSnapshot, type FetchVrmDownloadUrlOptions, INPUT_MODES, type InputMode, InputModeError, type InterruptSource, type InterruptedReply, type InterruptedReplyPosition, type ListeningOptions, type ListeningState, type LiveMotionOptions, LiveMotionPlayer, type LiveMotionRootMode, type LlmThinkingPayload, type LoadCharacterOptions, MicrophoneError, type MountNpcifyOptions, NUDE_VARIANT_KEY, Npcify, type NpcifyAssetInfo, Character as NpcifyCharacter, type NpcifyEventMap, type NpcifyEventName, type NpcifyOptions, NpcifyTurnError, type NpcifyTurnErrorCode, type NpcifyView, PERFORMANCE_FILE_EXTENSION, PERFORMANCE_MEDIA_TYPE, type PerformanceAnalysis, type PerformanceAnalysisOptions, type PerformanceEvent, type PerformanceFrame, type PerformanceIssue, type PerformanceKind, type PerformanceRecording, PerformanceRecordingSchemaVersion, type PerformanceRecordingStartOptions, type PerformanceTimelineSnapshot, type PlayStagingOptions, type PlayerActivity, type PushToTalkOptions, type PushToTalkTarget, RemoteAnimationController, type RepeatedVisemeTransitionAnalysis, SightError, type SightFailureCode, type SightObservation, type SightObservationEvent, type SightOptions, type SightPerson, type SightState, SpeechInputError, type SpeechInputResult, type StagingInterruptPhase, type StagingOptionsReadyPayload, type StagingPlaybackStart, type StagingSpeechPlaybackEvent, type StagingStreamInterruptedEvent, type StagingSwitchVariantArguments, type StagingToolCall, type StagingToolCallResult, type StagingToolName, type StagingToolResultStatus, type TranscriptEvent, type VariantChangeEvent, type Vector3Like, type Vector3Tuple, type VisemePerformanceFrameSnapshot, analyzePerformanceRecording, bindPushToTalk, createCharacter, decodePerformance, encodePerformance, fetchVariantVrmDownloadUrl, fetchVrmDownloadUrl, isTurnInterrupted, loadBakedConversation, loadCharacter, loadVariantVrm, loadVrm, mountNpcify, turnErrorCode };