@everfur/sdk 0.1.0

package/dist/animations/index.d.cts

@@ -0,0 +1,517 @@
+import { ReactNode } from 'react';
+import { StyleProp, ViewStyle } from 'react-native';
+import { E as EverfurResult, f as EverfurError } from '../EverfurResult-D92-uL82.cjs';
+export { g as EverfurErrorCategory, a as EverfurErrorCode } from '../EverfurResult-D92-uL82.cjs';
+import { A as AuthContext } from '../identity-Brl-lDd6.cjs';
+export { I as IdentityProvider, n as newSessionId } from '../identity-Brl-lDd6.cjs';
+import { P as PetRef } from '../ids-CJ1S6adf.cjs';
+export { B as Brand, U as UserRef, _ as __brand } from '../ids-CJ1S6adf.cjs';
+import { z } from 'zod';
+import { K as KvPort, C as CacheEpochGuard, I as ImageCachePort } from '../cacheEpoch-DknKn3S0.cjs';
+export { a as CACHE_EPOCH_STORAGE_KEY, c as createCacheEpochGuard } from '../cacheEpoch-DknKn3S0.cjs';
+import { T as TelemetryPort } from '../TelemetryPort-BDNr00hu.cjs';
+import { c as DisabledLevel, C as CapabilityDecision } from '../resolve-Dq_4_agU.cjs';
+export { a as CapabilityDisabled, b as CapabilityName } from '../resolve-Dq_4_agU.cjs';
+export { A as AcceptedFrame, b as AnalysisCompleteFrame, c as AnalysisStartedFrame, f as DeltaFrame, g as DoneFrame, j as ErrorFrame, E as EverfurRequest, p as EverfurRequestBase, F as Frame, s as FrameBase, t as FrameKind, H as HeartbeatFrame, u as HttpMethod, M as MultipartBody, T as TransportPort, U as UnknownFrame, G as UrgencyLevel } from '../config-BSjBdxrZ.cjs';
+
+/**
+ * The full /state payload. `degraded` + `cache_epoch` + `cache_key` are additive fields an older backend
+ * omits; the schema defaults them identically to the reference client so one parser serves either revision.
+ */
+declare const petStateResponseWireSchema: z.ZodObject<{
+    category: z.ZodEnum<["health", "attention", "moment", "activity", "mood", "idle"]>;
+    tiers: z.ZodDefault<z.ZodObject<{
+        animation: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            kind: z.ZodDefault<z.ZodEnum<["webp", "video"]>>;
+            loop_duration_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            expires_at: z.ZodString;
+            cache_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        }, {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        }>>;
+        image: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            kind: z.ZodDefault<z.ZodEnum<["webp", "video"]>>;
+            loop_duration_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            expires_at: z.ZodString;
+            cache_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        }, {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        animation?: {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+        image?: {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+    }, {
+        animation?: {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+        image?: {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+    }>>;
+    overlays: z.ZodDefault<z.ZodObject<{
+        weather_alert: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            kind: z.ZodDefault<z.ZodEnum<["webp", "video"]>>;
+            loop_duration_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            expires_at: z.ZodString;
+            cache_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        }, {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        weather_alert?: {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+    }, {
+        weather_alert?: {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+    }>>;
+    idle: z.ZodDefault<z.ZodLiteral<"bundled">>;
+    ttl_seconds: z.ZodNumber;
+    degraded: z.ZodDefault<z.ZodBoolean>;
+    cache_epoch: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    category: "health" | "attention" | "moment" | "activity" | "mood" | "idle";
+    idle: "bundled";
+    tiers: {
+        animation?: {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+        image?: {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+    };
+    overlays: {
+        weather_alert?: {
+            kind: "webp" | "video";
+            url: string;
+            expires_at: string;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+    };
+    ttl_seconds: number;
+    degraded: boolean;
+    cache_epoch: number;
+}, {
+    category: "health" | "attention" | "moment" | "activity" | "mood" | "idle";
+    ttl_seconds: number;
+    idle?: "bundled" | undefined;
+    tiers?: {
+        animation?: {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+        image?: {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+    } | undefined;
+    overlays?: {
+        weather_alert?: {
+            url: string;
+            expires_at: string;
+            kind?: "webp" | "video" | undefined;
+            loop_duration_ms?: number | null | undefined;
+            cache_key?: string | null | undefined;
+        } | undefined;
+    } | undefined;
+    degraded?: boolean | undefined;
+    cache_epoch?: number | undefined;
+}>;
+type PetStateWire = z.infer<typeof petStateResponseWireSchema>;
+/**
+ * Parse an untrusted /state body into the wire shape. Settles: returns null on a parse failure rather than
+ * throwing, so the repository degrades to the bundled idle instead of surfacing a crash. Additive unknown
+ * keys are stripped (zod `.object` default), so a newer backend never trips this.
+ */
+declare function parsePetStateWire(raw: unknown): PetStateWire | null;
+
+type MediaKind = 'webp' | 'video';
+type PetStateCategory = 'health' | 'attention' | 'moment' | 'activity' | 'mood' | 'idle';
+interface PetStateTier {
+    readonly url: string;
+    readonly kind: MediaKind;
+    readonly loopDurationMs?: number;
+    readonly expiresAt: string;
+    /**
+     * Verbatim cache identity `{s3_key}@r{asset_revision}`; NEVER derived from `url`. Absent -> the renderer
+     * falls back to the presign-stripped path (`stableMediaKey`).
+     */
+    readonly cacheKey?: string;
+}
+interface PetStateResponse {
+    readonly category: PetStateCategory;
+    readonly tiers: {
+        readonly animation?: PetStateTier;
+        readonly image?: PetStateTier;
+    };
+    readonly overlays: {
+        readonly weatherAlert?: PetStateTier;
+    };
+    readonly idle: 'bundled';
+    readonly ttlSeconds: number;
+    /** true => transient idle: keep last-good, re-poll on the short ttl (don't-clobber). */
+    readonly degraded: boolean;
+    /** monotonic; on ANY increase the client drops its whole image cache once. */
+    readonly cacheEpoch?: number;
+}
+/**
+ * The total, never-throwing snake->camel projection. Identical defaults to the reference client so the SDK
+ * parses against a backend at either contract revision. Returns a frozen value.
+ */
+declare function mapPetStateResponse(wire: PetStateWire): PetStateResponse;
+
+interface PetStateRepository {
+    /**
+     * GET /widget/v1/pets/{pet_ref}/state. Settles to:
+     *  - `ok(PetStateResponse)` on a 200 that parses;
+     *  - `ok(null)` on a 404 (dark surface / revoked / not-in-namespace) - an EXPECTED terminal outcome the
+     *    controller degrades to the bundled idle;
+     *  - `err(EverfurError)` for transient (5xx/timeout) or terminal-auth (403 accessDenied, second-401
+     *    authRejected) failures, plus an unparseable 200 (internalError).
+     */
+    getState(petRef: PetRef, opts?: {
+        signal?: AbortSignal;
+    }): Promise<EverfurResult<PetStateResponse | null>>;
+}
+/** Build the repository over a device AuthContext (personalized bearer XOR anonymous pk). */
+declare function createPetStateRepository(auth: AuthContext): PetStateRepository;
+
+/** A compiled-in bundled asset (the neutral, org-agnostic idle). Rendered by the platform via its id. */
+interface BundledAsset {
+    readonly kind: 'bundled';
+    readonly id: string;
+}
+/** A remote presigned source with its revision-bound cache identity. */
+interface UriSource {
+    readonly kind: 'uri';
+    readonly uri: string;
+    /** expo-image cacheKey: server `cacheKey` when present, else the presign-stripped path. */
+    readonly cacheKey: string;
+}
+/** What the view renders. ALWAYS resolvable - a dead tier degrades to the bundled idle, never blank. */
+type MediaSource = UriSource | BundledAsset;
+/**
+ * Object identity with the presign query stripped (`?`-onwards removed). A re-signed URL for the SAME
+ * object yields the SAME key (no remount / no animation restart). A bundled asset keys as `bundled:<id>`.
+ * Never derived when a server `cacheKey` is present (that is revision-bound); this is the fallback only.
+ */
+declare function stableMediaKey(source: number | {
+    uri: string;
+} | BundledAsset | undefined): string;
+/** Ordered high->low: the pet's own photo outranks every server tier; idle is the total floor. */
+type AnimationTier = 'photo' | 'animation' | 'image' | 'idle';
+interface TierInputs {
+    readonly hasPhoto: boolean;
+    readonly photoFailed: boolean;
+    /** animation present && kind==='webp' && !reducedMotion (the #6 non-webp guard). */
+    readonly canAnimate: boolean;
+    readonly animationFailed: boolean;
+    readonly hasImage: boolean;
+    readonly imageFailed: boolean;
+}
+/**
+ * photo -> animation -> image -> idle. Pure. Returns the highest surviving (present-and-unfailed) tier.
+ * `idle` is always available, so this is total and never yields a broken tier.
+ */
+declare function selectTier(i: TierInputs): AnimationTier;
+type FallbackReason = 'none' | 'network_error' | 'anim_cutoff' | 'dark_or_missing' | 'idle_asset_failed';
+interface FailedTiers {
+    readonly photo: boolean;
+    readonly animation: boolean;
+    readonly image: boolean;
+}
+/**
+ * onError transition: retire `current`, set the reason. Retiring `idle` is the truly-terminal
+ * `idle_asset_failed` (no lower rung), kept DISTINCT from a recoverable `network_error` downgrade so an
+ * alarm can fire only on the terminal floor failure.
+ */
+declare function retireTier(current: AnimationTier, failed: FailedTiers): {
+    failed: FailedTiers;
+    reason: FallbackReason;
+};
+declare const NO_FAILURES: FailedTiers;
+/**
+ * A loader (walk splash, pet-switch splash) may surface ONLY the gentle bands. health + attention are
+ * SUPPRESSED - a splash must never show a concern or a med reminder. True for activity | mood | moment | idle.
+ */
+declare function isLoaderSafeCategory(category: PetStateCategory): boolean;
+
+/** The manifest schema this build understands. A live manifest above this is refused (forward-compat). */
+declare const SUPPORTED_SCHEMA_VERSION = 1;
+/** KvPort key for the last-accepted manifest (last-known-good). Non-secret durable state only. */
+declare const MANIFEST_LKG_STORAGE_KEY = "everfur.manifest.lastKnownGood";
+/** The neutral, org-agnostic compiled-in idle silhouette. A partner's real art arrives only from config. */
+declare const COMPILED_DEFAULT_IDLE: BundledAsset;
+/** The animations surface: whether the surface renders live tiers, and the neutral idle fallback. */
+interface AnimationsSurface {
+    readonly enabled: boolean;
+    readonly idle: BundledAsset;
+}
+/** The whole surface manifest. `revision` + `schemaVersion` select live vs last-known-good vs compiled. */
+interface CapabilityManifest {
+    readonly schemaVersion: number;
+    readonly revision: string;
+    readonly surfaces: {
+        readonly animations?: AnimationsSurface;
+    };
+}
+type ManifestSource = 'live' | 'last-known-good' | 'compiled-default';
+/** The compiled default baked into the build; its animations surface references the neutral idle. */
+declare const COMPILED_DEFAULT_MANIFEST: CapabilityManifest;
+type ParseManifestResult = {
+    readonly ok: true;
+    readonly manifest: CapabilityManifest;
+} | {
+    readonly ok: false;
+    readonly reason: 'unparseable' | 'newer_schema';
+};
+/**
+ * Parse an untrusted manifest block. REFUSES a schema_version above SUPPORTED (structural forward-compat)
+ * and rejects a body that does not parse. Strips unknown surfaces / tokens / a `disclaimer` override.
+ * Never throws.
+ */
+declare function parseManifest(raw: unknown): ParseManifestResult;
+interface ResolvedManifest {
+    readonly manifest: CapabilityManifest;
+    readonly source: ManifestSource;
+}
+/**
+ * Resolve the surface manifest via the never-blank ladder. `liveRaw` is the `.manifest` block off the
+ * client-config channel (or null when that fetch failed). Accepts live only when it parses and is not a
+ * newer schema, writing it to last-known-good; else falls to the last accepted manifest, else to the
+ * compiled default. Every KvPort failure is swallowed (a cosmetic persistence miss never blocks a render).
+ */
+declare function resolveManifest(liveRaw: unknown, kv: KvPort, tel: TelemetryPort): Promise<ResolvedManifest>;
+/** Read the animations surface from a resolved manifest, or the compiled default when the surface is absent. */
+declare function animationsSurfaceOf(manifest: CapabilityManifest): AnimationsSurface;
+
+/** Injectable timers so the SWR window is testable with a fake clock (no direct setTimeout). */
+interface StoreTimers {
+    setTimeout(handler: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+    now(): number;
+}
+interface PetStateSnapshot {
+    /** Current render data - may be the kept-previous pet during a switch (C2). null => no data yet / dark. */
+    readonly data: PetStateResponse | null;
+    /** true during the initial cold resolve for the current pet (no data to show). */
+    readonly isPending: boolean;
+    /** true while a transient error is being retried; last-good `data` stays on screen. */
+    readonly isError: boolean;
+    readonly error: EverfurError | null;
+    /** Settled terminal dark (404) or access-denied (403): render the idle, no spinner, no further fetch. */
+    readonly isDark: boolean;
+}
+interface PetStateStore {
+    observe(petRef: PetRef | null, opts: {
+        readonly isFocused: boolean;
+    }): void;
+    getSnapshot(): PetStateSnapshot;
+    subscribe(listener: () => void): () => void;
+    /** Freshness-gated synchronous read: the warm entry ONLY while younger than its ttl; else null. */
+    getCachedPetStateMedia(petRef: PetRef): PetStateResponse | null;
+    dispose(): void;
+}
+declare function createPetStateStore(deps: {
+    readonly repo: PetStateRepository;
+    readonly cacheEpoch: CacheEpochGuard;
+    readonly timers: StoreTimers;
+}): PetStateStore;
+/**
+ * Terminal iff the settled error is a 403 or 404 (duck-typed on `status` / `httpStatus`). A 404 is folded to
+ * `ok(null)` at the repository, so at the store this fires for a 403; the predicate stays general for the
+ * parity vectors that feed a bare `{ status: 404 }`.
+ */
+declare function isTerminalPetStateError(error: unknown): boolean;
+
+interface PetStateViewProps {
+    readonly petRef: PetRef | null;
+    readonly repo: PetStateRepository;
+    readonly cache: ImageCachePort;
+    readonly kv: KvPort;
+    readonly isFocused?: boolean;
+    readonly photoUrl?: string | null;
+    readonly telemetry?: TelemetryPort;
+    readonly reducedMotion?: () => boolean;
+    readonly manifest?: () => CapabilityManifest;
+    readonly timers?: StoreTimers;
+    readonly now?: () => number;
+    readonly style?: StyleProp<ViewStyle>;
+    /** Accessible label for the media node; omit + set `decorative` to hide it from the a11y tree. */
+    readonly accessibilityLabel?: string;
+    /** Decorative-only: hide the media from assistive tech without leaving a focusable blank gap. */
+    readonly decorative?: boolean;
+}
+/**
+ * Entitlement-gated, never-blank pet-state media. Denied / pending-entitlement render the bundled idle via
+ * the CapabilityGate slots; otherwise the body maps the controller view state to a deliberate state.
+ */
+declare function PetStateView(props: PetStateViewProps): ReactNode;
+
+interface AnimationControllerDeps {
+    readonly repo: PetStateRepository;
+    readonly cache: ImageCachePort;
+    /** Non-secret durable KV, backing the cache-epoch guard's one-time purge latch. */
+    readonly kv: KvPort;
+    readonly telemetry?: TelemetryPort;
+    readonly reducedMotion: () => boolean;
+    readonly now: () => number;
+    /** Already-resolved surface manifest getter (RN resolves via resolveManifest once). Defaults to compiled. */
+    readonly manifest?: () => CapabilityManifest;
+    /** Injectable timers for the SWR window (tests drive a fake clock). */
+    readonly timers?: StoreTimers;
+}
+type AnimationViewState = {
+    readonly kind: 'pending';
+    readonly showSkeleton: true;
+    readonly source: MediaSource;
+} | {
+    readonly kind: 'disabled';
+    readonly reason: string;
+    readonly level: DisabledLevel;
+    readonly source: MediaSource;
+    readonly idle: BundledAsset;
+} | {
+    readonly kind: 'ready';
+    readonly tier: AnimationTier;
+    readonly source: MediaSource;
+    readonly recyclingKey: string;
+    readonly category: PetStateCategory;
+    readonly loopDurationMs: number | null;
+    readonly paused: boolean;
+    readonly reducedMotion: boolean;
+    readonly cacheHit: boolean;
+    readonly fallbackReason: FallbackReason;
+    /** Settled dark (404) surface: the genuine bundled idle, no spinner. */
+    readonly isDark: boolean;
+    /** A transient 5xx/offline error is being retried; last-good media stays on screen. */
+    readonly isTransientError: boolean;
+};
+interface AnimationController {
+    observe(petRef: PetRef | null, opts: {
+        readonly isFocused: boolean;
+        readonly photoUrl?: string | null;
+    }): void;
+    getState(): AnimationViewState;
+    subscribe(listener: () => void): () => void;
+    /** The view calls this from the media node's onError -> retire the current tier (§5.1). */
+    onMediaError(): void;
+    /** Decoupled from `tier`: pausing never remounts. */
+    setPaused(paused: boolean): void;
+    dispose(): void;
+}
+declare function createAnimationController(deps: AnimationControllerDeps): AnimationController;
+
+interface UseAnimationsParams {
+    readonly petRef: PetRef | null;
+    /**
+     * INTERNAL / TESTING override: the /state read layer. When `repo`, `cache`, and `kv` are ALL supplied the
+     * hook constructs the controller locally from them; otherwise it acquires one from the runtime registry.
+     */
+    readonly repo?: PetStateRepository;
+    /** INTERNAL / TESTING override: platform image-cache seam for the fleet-wide epoch purge (see `repo`). */
+    readonly cache?: ImageCachePort;
+    /** INTERNAL / TESTING override: non-secret durable KV backing the cache-epoch purge latch (see `repo`). */
+    readonly kv?: KvPort;
+    /** Focus gates the SWR poll (§4.2). Defaults to true. */
+    readonly isFocused?: boolean;
+    /** The pet's own real photo (top tier when present + unfailed). */
+    readonly photoUrl?: string | null;
+    readonly telemetry?: TelemetryPort;
+    /** System reduced-motion read; defaults to a fail-safe AccessibilityInfo reader (reduced until known). */
+    readonly reducedMotion?: () => boolean;
+    /** Already-resolved surface manifest (RN resolves via resolveManifest once). Defaults to compiled. */
+    readonly manifest?: () => CapabilityManifest;
+    readonly timers?: StoreTimers;
+    readonly now?: () => number;
+}
+interface UseAnimationsResult {
+    /** The server-resolved 'animations' verdict (render-of-verdict). */
+    readonly capability: CapabilityDecision;
+    /** The current frozen view state; ALWAYS carries a resolvable source (never blank). */
+    readonly state: AnimationViewState;
+    /** Forward the media node's onError -> retire the current tier. */
+    readonly onMediaError: () => void;
+    /** Pause / resume without remounting the media node. */
+    readonly setPaused: (paused: boolean) => void;
+}
+declare function useAnimations(params: UseAnimationsParams): UseAnimationsResult;
+
+export { type AnimationController, type AnimationControllerDeps, type AnimationTier, type AnimationViewState, type AnimationsSurface, AuthContext, type BundledAsset, COMPILED_DEFAULT_IDLE, COMPILED_DEFAULT_MANIFEST, CacheEpochGuard, CapabilityDecision, type CapabilityManifest, DisabledLevel, EverfurError, EverfurResult, type FailedTiers, type FallbackReason, ImageCachePort, KvPort, MANIFEST_LKG_STORAGE_KEY, type ManifestSource, type MediaKind, type MediaSource, NO_FAILURES, type ParseManifestResult, PetRef, type PetStateCategory, type PetStateRepository, type PetStateResponse, type PetStateSnapshot, type PetStateStore, type PetStateTier, PetStateView, type PetStateViewProps, type PetStateWire, type ResolvedManifest, SUPPORTED_SCHEMA_VERSION, type StoreTimers, TelemetryPort, type TierInputs, type UriSource, type UseAnimationsParams, type UseAnimationsResult, animationsSurfaceOf, createAnimationController, createPetStateRepository, createPetStateStore, isLoaderSafeCategory, isTerminalPetStateError, mapPetStateResponse, parseManifest, parsePetStateWire, petStateResponseWireSchema, resolveManifest, retireTier, selectTier, stableMediaKey, useAnimations };