@pollen-robotics/reachy-mini-sdk 1.7.3-main.5cd69ad

package/host/dist/components/EmbedFrame.d.ts

@@ -0,0 +1,16 @@
+export interface EmbedFrameProps {
+    /** Same-origin URL of the embedded app's `index.html`.
+     *  Defaults to `${origin}/?embedded=1`. */
+    src: string;
+    /** Allow microphone capture inside the iframe (apps that need
+     *  WebRTC mic input). Maps to the `allow="microphone; ..."`
+     *  attribute. */
+    enableMicrophone: boolean;
+    /** Title attribute for a11y. */
+    title: string;
+    /** Set `visibility` so the iframe can stay mounted (and keep
+     *  the SDK socket) while the ConnectingView overlay is on top. */
+    visible: boolean;
+}
+export declare const EmbedFrame: import("react").ForwardRefExoticComponent<EmbedFrameProps & import("react").RefAttributes<HTMLIFrameElement>>;
+//# sourceMappingURL=EmbedFrame.d.ts.map

package/host/dist/components/EmbedFrame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbedFrame.d.ts","sourceRoot":"","sources":["../../src/components/EmbedFrame.tsx"],"names":[],"mappings":"AAgBA,MAAM,WAAW,eAAe;IAC9B;+CAC2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ;;qBAEiB;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd;sEACkE;IAClE,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,UAAU,+GAoCtB,CAAC"}

package/host/dist/components/ErrorView.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Terminal error screen. Reached when:
+ *  - The SDK throws on `connect()` / `startSession()`.
+ *  - The embed reports `embed:error { fatal: true }`.
+ *  - The host catches an uncaught render error (via the React
+ *    error boundary in `ReachyHost`).
+ *
+ * Always offers a "Reload" action (full page reload) and a
+ * "Back to picker" action that resets the host phase to picking
+ * without losing the OAuth session.
+ */
+import type { JSX } from 'react';
+export interface ErrorViewProps {
+    title?: string;
+    message: string;
+    detail?: unknown;
+    onReload(): void;
+    onBackToPicker(): void;
+}
+export declare function ErrorView({ title, message, detail, onReload, onBackToPicker, }: ErrorViewProps): JSX.Element;
+//# sourceMappingURL=ErrorView.d.ts.map

package/host/dist/components/ErrorView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorView.d.ts","sourceRoot":"","sources":["../../src/components/ErrorView.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAMjC,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,IAAI,IAAI,CAAC;IACjB,cAAc,IAAI,IAAI,CAAC;CACxB;AAED,wBAAgB,SAAS,CAAC,EACxB,KAA8B,EAC9B,OAAO,EACP,MAAM,EACN,QAAQ,EACR,cAAc,GACf,EAAE,cAAc,GAAG,GAAG,CAAC,OAAO,CA6D9B"}

package/host/dist/components/LeavingView.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Transition view rendered while the host is tearing the iframe
+ * session down (user clicked "End session" / power-off).
+ *
+ * 1-to-1 port of
+ * `reachy_mini_mobile_app/src/ui/screens/session/LeavingView.tsx`
+ * — the desktop host and the mobile shell deliberately share the
+ * exact same disconnection visual so a user moving between the
+ * two clients sees a consistent "Putting Reachy to sleep…" beat.
+ *
+ * Visual posture
+ * ──────────────
+ * Mirrors `<ConnectingView>`'s anatomy (stack centred on the
+ * vertical axis, primary visual on top, title below) so the
+ * leave-screen reads as the symmetric counterpart of the join-
+ * screen. But where Connecting carries a 3-dot stepper + bold
+ * headline + a two-line caption to narrate a multi-phase
+ * bring-up, Leaving is intentionally one beat lighter:
+ *
+ *   - a small, low-contrast spinner instead of the stepper
+ *     (the user already decided to leave - we don't need to
+ *     dramatise the wait),
+ *   - a single short headline, no caption (the goto-sleep
+ *     trajectory is short enough that a sub-line of explanation
+ *     reads as filler by the time it lands).
+ *
+ * The trailing ellipsis on the headline is enough of a
+ * "something's still happening" cue without needing a second line
+ * of copy.
+ */
+import type { JSX } from 'react';
+export declare function LeavingView(): JSX.Element;
+//# sourceMappingURL=LeavingView.d.ts.map

package/host/dist/components/LeavingView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeavingView.d.ts","sourceRoot":"","sources":["../../src/components/LeavingView.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAKjC,wBAAgB,WAAW,IAAI,GAAG,CAAC,OAAO,CA2CzC"}

package/host/dist/components/PickerView.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Robot picker, aligned with `reachy_mini_mobile_app/src/ui/
+ * screens/ScanScreen.tsx`.
+ *
+ * Layout (the shared TopBar - identity + sign-out - sits ABOVE
+ * this view and is owned by `ReachyHostShell`):
+ *   ┌──────────────────────────────────────────┐
+ *   │              (reachy-buste)              │
+ *   │                                          │
+ *   │            Your Reachies                 │
+ *   │   N online · linked to your HF account   │
+ *   │                                          │
+ *   │   ┌────────────────────────────────┐     │
+ *   │   │ [reachy] ● Name             >  │     │
+ *   │   └────────────────────────────────┘     │
+ *   │   ┌────────────────────────────────┐     │
+ *   │   │ [reachy] ● Other            🔒 │     │  (busy)
+ *   │   └────────────────────────────────┘     │
+ *   │                                          │
+ *   │  ────────────────────────────────────────│
+ *   │              ↻ Refresh                   │  Sticky bottom
+ *   └──────────────────────────────────────────┘
+ *
+ *  - Hero illustration: `reachy-buste.svg`, same asset as the
+ *    splash, gives the screen a brand identity beyond the cards.
+ *  - Robot cards: avatar + name + hardware-id tag + trailing
+ *    chevron (or lock when busy).
+ *  - Sticky refresh: pinned to the bottom, out of the scrollable
+ *    area, so it's always one tap away.
+ */
+import type { JSX } from 'react';
+import type { RobotInfo } from '../lib/sdk-types';
+export interface PickerViewProps {
+    robots: RobotInfo[];
+    /** `true` while the picker is fetching its first robot list or
+     *  the user just clicked "Refresh" - drives the header spinner. */
+    isRefreshing: boolean;
+    /** Last error message from the central listener / REST fetch,
+     *  or `null` if everything's healthy. Surfaces as an error state
+     *  card when the list is empty so the user knows the screen is
+     *  silent for a reason. */
+    error?: string | null;
+    preselectedRobotId: string | null;
+    onSelect(robotId: string): void;
+    /** Asks the picker source to re-fetch the robot list. Defaults
+     *  to a no-op if the host has nothing to refresh; the spinner
+     *  still plays for ~1 s as visual feedback. */
+    onRefresh?(): void;
+}
+export declare function PickerView({ robots, isRefreshing, error, preselectedRobotId, onSelect, onRefresh, }: PickerViewProps): JSX.Element;
+//# sourceMappingURL=PickerView.d.ts.map

package/host/dist/components/PickerView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PickerView.d.ts","sourceRoot":"","sources":["../../src/components/PickerView.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAqBjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB;uEACmE;IACnE,YAAY,EAAE,OAAO,CAAC;IACtB;;;+BAG2B;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC;;mDAE+C;IAC/C,SAAS,CAAC,IAAI,IAAI,CAAC;CACpB;AAED,wBAAgB,UAAU,CAAC,EACzB,MAAM,EACN,YAAY,EACZ,KAAK,EACL,kBAAkB,EAClB,QAAQ,EACR,SAAS,GACV,EAAE,eAAe,GAAG,GAAG,CAAC,OAAO,CAiF/B"}

package/host/dist/components/ReachyHostShell.d.ts

@@ -0,0 +1,21 @@
+import type { JSX } from 'react';
+import type { ReachyMiniInstance } from '../lib/sdk-types';
+import { type ConfigPayload, type ThemeMode } from '../lib/protocol';
+export interface ReachyHostShellProps {
+    sdk: ReachyMiniInstance | null;
+    appName: string;
+    appIconUrl?: string;
+    appEmoji?: string;
+    hostName: string;
+    theme: ThemeMode;
+    initialConfig?: ConfigPayload;
+    enableMicrophone: boolean;
+    /** Path of the embedded app entry within the same origin.
+     *  Defaults to `/?embedded=1`. */
+    embedPath?: string;
+    /** Surface a dev hint on the sign-in screen when no OAuth
+     *  client ID is reachable and no dev token has been seeded. */
+    isLocalDevMissingConfig?: boolean;
+}
+export declare function ReachyHostShell(props: ReachyHostShellProps): JSX.Element;
+//# sourceMappingURL=ReachyHostShell.d.ts.map

package/host/dist/components/ReachyHostShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReachyHostShell.d.ts","sourceRoot":"","sources":["../../src/components/ReachyHostShell.tsx"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAKjC,OAAO,KAAK,EAAE,kBAAkB,EAAa,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAEL,KAAK,aAAa,EAGlB,KAAK,SAAS,EACf,MAAM,iBAAiB,CAAC;AAmBzB,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAE/B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IAEjB,KAAK,EAAE,SAAS,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,CAAC;IAE9B,gBAAgB,EAAE,OAAO,CAAC;IAC1B;sCACkC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;mEAC+D;IAC/D,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AA6DD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,oBAAoB,GAC1B,GAAG,CAAC,OAAO,CAMb"}

package/host/dist/components/SignInView.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Sign-in landing screen.
+ *
+ * Visual + copy mirror of `reachy_mini_mobile_app/src/ui/screens/
+ * RemoteSignInScreen.tsx` so a user moving between the mobile
+ * companion and a desktop browser tab lands on the same gateway.
+ *
+ * Composition:
+ *  - h1 "Sign in to Hugging Face" (NOT the app name; the app
+ *    name lives in the document title and the picker).
+ *  - Subtitle explaining why signing in is the gate.
+ *  - Single outlined CTA "Continue with Hugging Face" that
+ *    morphs to "Waiting for Hugging Face…" + spinner during the
+ *    OAuth redirect.
+ *
+ * Post-OAuth return is handled by the host-level
+ * `WelcomeBackOverlay`, NOT this screen, so we never need an
+ * inline "Restoring your session…" sub-state here.
+ */
+import type { JSX } from 'react';
+export interface SignInViewProps {
+    /** App name (used only in subtitle copy; not the heading). */
+    appName: string;
+    /** When `true`, the page has no obvious way to obtain an OAuth
+     *  client ID (no `?clientId=` prop, no `window.huggingface`
+     *  injection, no cached settings). Surfaces a dev-hint alert
+     *  pointing at the local `.env.local` workflow. */
+    isLocalDevMissingConfig: boolean;
+    onSignIn(): Promise<void>;
+}
+export declare function SignInView({ appName, isLocalDevMissingConfig, onSignIn, }: SignInViewProps): JSX.Element;
+//# sourceMappingURL=SignInView.d.ts.map

package/host/dist/components/SignInView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignInView.d.ts","sourceRoot":"","sources":["../../src/components/SignInView.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,GAAG,EAAa,MAAM,OAAO,CAAC;AAgB5C,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB;;;uDAGmD;IACnD,uBAAuB,EAAE,OAAO,CAAC;IACjC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,uBAAuB,EACvB,QAAQ,GACT,EAAE,eAAe,GAAG,GAAG,CAAC,OAAO,CAqK/B"}

package/host/dist/components/StepsProgressIndicator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Generic horizontal steps indicator with an integrated progress
+ * bar running BEHIND the steps.
+ *
+ *   ●━━━━━━━━━●━━━━━━━━━○
+ *   Link       Session    Wake-up
+ *
+ * - Completed steps render a checkmark (`pop-in` animation) on the
+ *   filled (green) bar.
+ * - The current step pulses gently and shows a tiny dot inside.
+ * - Future steps stay neutral on the unfilled track.
+ *
+ * 1-to-1 port of `reachy_mini_mobile_app/src/ui/design/
+ * StepsProgressIndicator.tsx`. Kept structurally identical so a
+ * change in the mobile app's connection animation can be ported
+ * back here verbatim - the two clients are explicitly meant to
+ * "feel built by the same hand".
+ */
+import type { JSX } from 'react';
+export interface StepsProgressStep {
+    /** Stable id used as React key. */
+    id: string;
+    /** Short uppercase label rendered under the dot (≤ ~10 chars). */
+    label: string;
+}
+export interface StepsProgressIndicatorProps {
+    steps: StepsProgressStep[];
+    /** 0-indexed current step. Steps before this index are rendered
+     *  as completed. Steps after are pending. */
+    currentStep: number;
+    /** Optional explicit progress percentage (0-100). When omitted
+     *  the bar is computed from `currentStep / (steps.length - 1)`. */
+    progress?: number;
+    /** When `true` the active step uses the primary tint instead of
+     *  the neutral active grey. Useful to signal "we're actively
+     *  recovering" (e.g. a retry attempt) vs the standard happy
+     *  path. */
+    accent?: boolean;
+}
+export declare function StepsProgressIndicator({ steps, currentStep, progress: progressOverride, accent, }: StepsProgressIndicatorProps): JSX.Element;
+//# sourceMappingURL=StepsProgressIndicator.d.ts.map

package/host/dist/components/StepsProgressIndicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepsProgressIndicator.d.ts","sourceRoot":"","sources":["../../src/components/StepsProgressIndicator.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAMjC,MAAM,WAAW,iBAAiB;IAChC,mCAAmC;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B;iDAC6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB;uEACmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;gBAGY;IACZ,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAuBD,wBAAgB,sBAAsB,CAAC,EACrC,KAAK,EACL,WAAW,EACX,QAAQ,EAAE,gBAAgB,EAC1B,MAAc,GACf,EAAE,2BAA2B,GAAG,GAAG,CAAC,OAAO,CAoL3C"}

package/host/dist/components/TopBar.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Persistent host top bar.
+ *
+ * Provides the same chrome as the pre-migration standalone host:
+ *
+ * Layout (signed in, no session):
+ *
+ *   [ logo ]  Telepresence                  [ avatar @user ▾ ]
+ *
+ * Layout (signed in, streaming):
+ *
+ *   [ logo ]  Telepresence  [ ⏻ End session ]  [ avatar @user ▾ ]
+ *
+ * UX rationale
+ * ────────────
+ * The destructive actions are visually distinct:
+ *   - "End session" is a labeled red button that ONLY renders while a
+ *     session is live. When there's no session it disappears, so the
+ *     bar isn't cluttered with a permanent disabled glyph.
+ *   - "Sign out" lives inside an account menu opened by clicking the
+ *     avatar+username chip. Standard "click your face to see account
+ *     actions" pattern, prevents accidental sign-out clicks.
+ *
+ * Signed-out
+ * ──────────
+ * The bar STAYS visible on the sign-in screen, with the embedded app's
+ * logo + name on the left and an empty right slot - no avatar, no
+ * End-session button, since neither makes sense before the user has
+ * authenticated. Anchors "where am I" for users landing on the host
+ * through `huggingface.co/spaces/<app>`.
+ */
+import { type JSX } from 'react';
+export type HostPhase = 'signing-in' | 'picking' | 'embedded' | 'leaving' | 'error';
+export interface TopBarProps {
+    appName: string;
+    /** Resolved app icon URL probed from `${embedUrl}/icon.svg`. Best
+     *  signal: the app shipped a real icon. */
+    appIconUrl?: string | null;
+    /** Fallback emoji from the HF Spaces frontmatter (`cardData.emoji`).
+     *  Used when no `appIconUrl` is available. */
+    appEmoji?: string | null;
+    hostPhase: HostPhase;
+    userName: string | null;
+    /** Resolved HF avatar URL from `/api/whoami-v2`, or `null` while in
+     *  flight / failed. The chip falls back to a first-letter glyph. */
+    avatarUrl?: string | null;
+    selectedRobotName?: string | null;
+    onSignOut(): void;
+    onEndSession(): void;
+}
+export declare function TopBar({ appName, appIconUrl, appEmoji, hostPhase, userName, avatarUrl, selectedRobotName: _selectedRobotName, onSignOut, onEndSession, }: TopBarProps): JSX.Element;
+//# sourceMappingURL=TopBar.d.ts.map

package/host/dist/components/TopBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TopBar.d.ts","sourceRoot":"","sources":["../../src/components/TopBar.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAuB,KAAK,GAAG,EAAE,MAAM,OAAO,CAAC;AAqBtD,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,SAAS,GACT,UAAU,GACV,SAAS,GACT,OAAO,CAAC;AAEZ,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB;+CAC2C;IAC3C,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;kDAC8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;wEACoE;IACpE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,SAAS,IAAI,IAAI,CAAC;IAClB,YAAY,IAAI,IAAI,CAAC;CACtB;AAED,wBAAgB,MAAM,CAAC,EACrB,OAAO,EACP,UAAiB,EACjB,QAAe,EACf,SAAS,EACT,QAAQ,EACR,SAAgB,EAChB,iBAAiB,EAAE,kBAAkB,EACrC,SAAS,EACT,YAAY,GACb,EAAE,WAAW,GAAG,GAAG,CAAC,OAAO,CAmH3B"}

package/host/dist/components/WelcomeBackOverlay.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Brief celebratory transition shown after a successful HF
+ * sign-in.
+ *
+ * Mirrors `reachy_mini_mobile_app/src/ui/screens/
+ * WelcomeBackScreen.tsx` so the desktop host and the mobile shell
+ * use the same beat between OAuth return and the picker reveal.
+ *
+ * Bridges two states the user otherwise experiences as a hard cut:
+ *  - the browser OAuth flow returns focus to the tab,
+ *  - the host suddenly switches from SignInView to PickerView.
+ *
+ * Without this, the user lands on a list of robots with no
+ * acknowledgment of who they are. This overlay surfaces their
+ * username for ~3.4 s with a subtle entrance animation, then
+ * fades out on top of the (already-mounted) picker.
+ *
+ * Pure presentational, no network calls. The picker behind us
+ * is already warming its data via `useRobots`, so the user
+ * lands on a populated list when the overlay clears.
+ */
+import type { JSX } from 'react';
+export interface WelcomeBackOverlayProps {
+    userName: string | null;
+    onDone(): void;
+}
+export declare function WelcomeBackOverlay({ userName, onDone, }: WelcomeBackOverlayProps): JSX.Element;
+//# sourceMappingURL=WelcomeBackOverlay.d.ts.map

package/host/dist/components/WelcomeBackOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WelcomeBackOverlay.d.ts","sourceRoot":"","sources":["../../src/components/WelcomeBackOverlay.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AA8BjC,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,MAAM,GACP,EAAE,uBAAuB,GAAG,GAAG,CAAC,OAAO,CA6EvC"}

package/host/dist/embed/index.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Embedded-app client.
+ *
+ * Vanilla TypeScript helper that lives in the iframe side of the
+ * host / app split. Consumed by `src/embed.{ts,tsx}` in each app
+ * (or via the CDN entry
+ * `@pollen-robotics/reachy-mini-sdk/host/embed` script tag).
+ *
+ *   import { connectToHost } from '@pollen-robotics/reachy-mini-sdk/host/embed';
+ *
+ *   const handle = await connectToHost<MyAppConfig>();
+ *   handle.onLeave(() => { /* clean up before unmount *\/ });
+ *   handle.reachy.setHeadRpyDeg(0, 10, 0);
+ *
+ * Boot sequence (canonical reference: SPEC.md §6.4):
+ *  1. Read `#creds=<base64>` synchronously and wipe the hash
+ *     with `history.replaceState`.
+ *  2. Wait for `window.ReachyMini` (8 s timeout).
+ *  3. Instantiate the SDK, seed the HF token into
+ *     `sessionStorage`.
+ *  4. Send `embed:ready` to the parent.
+ *  5. Wait for `host:init` (2 s soft timeout; on hit we proceed
+ *     from the hash creds alone via `liveStateFromCreds`, which
+ *     carries the same fields as `liveStateFromInit`).
+ *  6. `connect()` → `startSession()` → `ensureAwake()`, emitting
+ *     `embed:app-state` at each step.
+ *  7. Resolve `connectToHost()` with the live SDK handle.
+ *
+ * Strict Mode safety (SPEC §8.4): the function is idempotent
+ * across multiple awaits via a module-level promise. Calling
+ * `connectToHost()` twice returns the same in-flight promise;
+ * a single SDK instance is created, a single `embed:ready` is
+ * posted.
+ */
+import type { ReachyMiniInstance, ReachyMiniOptions } from '../lib/sdk-types';
+import type { AppConnectingStep, AppPhase, ThemeMode } from '../lib/protocol';
+/**
+ * Stable surface for the robot's WebRTC media. All accessors are
+ * synchronous and safe to read at any point after the handle is
+ * returned by `connectToHost()`. References are cached: calling
+ * `media.robotStream` repeatedly returns the same `MediaStream`
+ * instance (good for React effect deps), and the stream auto-clears
+ * on `sessionStopped`.
+ */
+export interface RobotMedia {
+    /**
+     * Bind the robot's video element. Internally:
+     *   1. Calls the SDK's own `attachVideo()` (which keeps the
+     *      element's `muted` flag in sync with `audioMuted`, kicks
+     *      off the latency monitor, and resets `srcObject` on
+     *      `sessionStopped`).
+     *   2. Replays the cached `robotStream` so a late-mounting
+     *      `<video>` element catches up immediately.
+     *
+     * Returns a cleanup function that detaches the SDK listeners.
+     */
+    attachVideo(el: HTMLVideoElement): () => void;
+    /**
+     * Robot's outbound MediaStream (video + audio in a single
+     * stream, as the daemon emits it). `null` until the WebRTC
+     * tracks have arrived; cleared on `sessionStopped`.
+     *
+     * Hand it to `<video>.srcObject`, an `AudioContext`'s
+     * `createMediaStreamSource`, or any other consumer.
+     */
+    readonly robotStream: MediaStream | null;
+    /**
+     * Local microphone MediaStream. Mirrors `reachy._micStream` so
+     * apps don't reach into underscore-prefixed SDK internals.
+     * `null` when `enableMicrophone` was `false` at construction
+     * time, when the daemon refused bidirectional audio, or when
+     * the session has stopped.
+     */
+    readonly micStream: MediaStream | null;
+}
+/** Resolved state at the moment `connectToHost()` returns. */
+export interface ConnectedHandle<TConfig = unknown> {
+    /** Live SDK instance: connected, session started, robot awake. */
+    reachy: ReachyMiniInstance;
+    /** Current theme; updated via `onThemeChange`. */
+    theme: ThemeMode;
+    /** Initial config (from URL `?config=` or mobile handoff).
+     *  Updates pushed via `onConfigChange`. */
+    config: TConfig | null;
+    /** App display name as passed by the host. */
+    appName: string;
+    /** Host display name (e.g. "Reachy Mini"). */
+    hostName: string;
+    /** HF user name when known (from `host:init`). */
+    userName: string | null;
+    /**
+     * Stable accessors for the WebRTC media streams negotiated
+     * during `startSession()`.
+     *
+     * Why apps must use these (not `reachy.attachVideo` /
+     * `reachy._pc` / `reachy._micStream`):
+     *   `connectToHost()` fully completes the WebRTC handshake
+     *   before the embedded app's React tree mounts. The SDK's
+     *   one-shot `videoTrack` event and the underlying `pc.ontrack`
+     *   event have therefore ALREADY fired by the time a
+     *   freshly-mounted component subscribes - any listener
+     *   registered after `connectToHost()` resolves will sit silent
+     *   until the next `startSession()`, which embeds never
+     *   trigger. This API replays the streams from a synchronous
+     *   snapshot of the peer-connection's receivers, so
+     *   late-mounting consumers see the camera + audio immediately.
+     *
+     * For the data channel, mute toggles, motor commands and state
+     * updates there is no race: the bridge only resolves once ICE
+     * AND the data channel are connected, and state events stream
+     * continuously at 50 Hz from the daemon. Apps can keep using
+     * `reachy.setHeadRpyDeg(…)`, `reachy.setMicMuted(…)`,
+     * `reachy.addEventListener('state', …)` directly.
+     */
+    readonly media: RobotMedia;
+    /** Register a teardown callback. Fires on `host:leaving`
+     *  (one-shot) or `pagehide`. Return a promise to keep the host
+     *  waiting (bounded by the host's `timeoutMs`). Returns an
+     *  unsubscribe function. */
+    onLeave(cb: () => void | Promise<void>): () => void;
+    /** Register a theme-change handler. */
+    onThemeChange(cb: (theme: ThemeMode) => void): () => void;
+    /** Register a config-change handler. */
+    onConfigChange(cb: (config: TConfig | null) => void): () => void;
+    /** Push an app-level state update upstream so the host can
+     *  drive its ConnectingView overlay. */
+    setAppState(state: {
+        phase: AppPhase;
+        connectingStep?: AppConnectingStep | null;
+        message?: string | null;
+    }): void;
+    /** Ask the host to start the leave sequence. */
+    requestLeave(): void;
+    /** Report an error. `fatal: true` switches the host to ErrorView. */
+    reportError(message: string, opts?: {
+        fatal?: boolean;
+        detail?: unknown;
+    }): void;
+}
+export interface ConnectToHostOptions {
+    /** Forwarded to the SDK constructor. `appName`, `signalingUrl`,
+     *  `clientId` are auto-set from the creds bundle. */
+    sdkOptions?: Partial<ReachyMiniOptions>;
+    /** Origin of the host's window. Defaults to
+     *  `window.location.origin` (same-origin iframe). */
+    expectedOrigin?: string;
+}
+/** Boot the embedded app. Idempotent: calling twice returns the
+ *  same in-flight promise. */
+export declare function connectToHost<TConfig = unknown>(options?: ConnectToHostOptions): Promise<ConnectedHandle<TConfig>>;
+//# sourceMappingURL=index.d.ts.map

package/host/dist/embed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/embed/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAO1B,OAAO,KAAK,EACV,iBAAiB,EACjB,QAAQ,EAMR,SAAS,EACV,MAAM,iBAAiB,CAAC;AAazB;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,EAAE,gBAAgB,GAAG,MAAM,IAAI,CAAC;IAC9C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IACzC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,WAAW,GAAG,IAAI,CAAC;CACxC;AAED,8DAA8D;AAC9D,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,OAAO;IAChD,kEAAkE;IAClE,MAAM,EAAE,kBAAkB,CAAC;IAC3B,kDAAkD;IAClD,KAAK,EAAE,SAAS,CAAC;IACjB;+CAC2C;IAC3C,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAE3B;;;gCAG4B;IAC5B,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC;IACpD,uCAAuC;IACvC,aAAa,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC1D,wCAAwC;IACxC,cAAc,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAEjE;4CACwC;IACxC,WAAW,CAAC,KAAK,EAAE;QACjB,KAAK,EAAE,QAAQ,CAAC;QAChB,cAAc,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;QAC1C,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACzB,GAAG,IAAI,CAAC;IACT,gDAAgD;IAChD,YAAY,IAAI,IAAI,CAAC;IACrB,qEAAqE;IACrE,WAAW,CACT,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAC3C,IAAI,CAAC;CACT;AAED,MAAM,WAAW,oBAAoB;IACnC;yDACqD;IACrD,UAAU,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACxC;yDACqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAsCD;8BAC8B;AAC9B,wBAAsB,aAAa,CAAC,OAAO,GAAG,OAAO,EACnD,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAKnC"}

package/host/dist/entry/auto.d.ts

@@ -0,0 +1,12 @@
+import { mountHost } from '../mountHost';
+import type { MountHostOptions, MountedHost } from '../mountHost';
+declare global {
+    interface Window {
+        ReachyMiniHost?: {
+            mountHost(options: MountHostOptions): MountedHost;
+        };
+    }
+}
+export { mountHost };
+export type { MountHostOptions, MountedHost };
+//# sourceMappingURL=auto.d.ts.map

package/host/dist/entry/auto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto.d.ts","sourceRoot":"","sources":["../../src/entry/auto.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAElE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,cAAc,CAAC,EAAE;YACf,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,WAAW,CAAC;SACnD,CAAC;KACH;CACF;AAUD,OAAO,EAAE,SAAS,EAAE,CAAC;AACrB,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,CAAC"}

package/host/dist/entry/auto.js

@@ -0,0 +1,7 @@
+import { R as i } from "../chunks/reachy-mini-sdk-eBYlC77N.js";
+import { m as n } from "../chunks/mountHost-8f-laxwI.js";
+typeof window < "u" && (window.ReachyMini || (window.ReachyMini = i, window.dispatchEvent(new Event("reachymini:ready"))), window.ReachyMiniHost = { mountHost: n });
+export {
+  n as mountHost
+};
+//# sourceMappingURL=auto.js.map

package/host/dist/entry/auto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto.js","sources":["../../src/entry/auto.ts"],"sourcesContent":["/**\n * CDN \"auto\" entry: the single script tag loaded from an app's\n * `index.html` to bring up the host shell.\n *\n *   <script type=\"module\"\n *     src=\"https://cdn.jsdelivr.net/npm/@pollen-robotics/reachy-mini-sdk@1/host/dist/entry/auto.js\">\n *   </script>\n *   <script type=\"module\" src=\"/src/dispatch.ts\"></script>\n *\n * The auto bundle exposes `mountHost` on `window.ReachyMiniHost`\n * for legacy / non-module callers. ESM consumers import it the\n * normal way.\n *\n * SDK auto-install\n * ────────────────\n * The host depends on `window.ReachyMini` for its OAuth helpers\n * (`useSdk`) and the embed client. Now that the SDK lives in the\n * same npm package, we import it directly and assign it to\n * `window.ReachyMini` here as a side effect, then dispatch the\n * `reachymini:ready` event the host's wait loops listen for.\n * Existing apps that still set `window.ReachyMini` themselves\n * (e.g. via the old jsdelivr `<script type=\"module\">` tag) are\n * untouched: we only assign when the global is unset.\n */\nimport { ReachyMini } from '../../../reachy-mini-sdk';\nimport { mountHost } from '../mountHost';\nimport type { MountHostOptions, MountedHost } from '../mountHost';\n\ndeclare global {\n  interface Window {\n    ReachyMiniHost?: {\n      mountHost(options: MountHostOptions): MountedHost;\n    };\n  }\n}\n\nif (typeof window !== 'undefined') {\n  if (!window.ReachyMini) {\n    window.ReachyMini = ReachyMini;\n    window.dispatchEvent(new Event('reachymini:ready'));\n  }\n  window.ReachyMiniHost = { mountHost };\n}\n\nexport { mountHost };\nexport type { MountHostOptions, MountedHost };\n"],"names":["ReachyMini","mountHost"],"mappings":";;AAoCI,OAAO,SAAW,QACf,OAAO,eACV,OAAO,aAAaA,GACpB,OAAO,cAAc,IAAI,MAAM,kBAAkB,CAAC,IAEpD,OAAO,iBAAiB,EAAE,WAAAC,EAAA;"}

package/host/dist/entry/embed.d.ts

@@ -0,0 +1,12 @@
+import { connectToHost } from '../embed';
+import type { ConnectedHandle, ConnectToHostOptions } from '../embed';
+declare global {
+    interface Window {
+        ReachyMiniHostEmbed?: {
+            connectToHost<TConfig = unknown>(opts?: ConnectToHostOptions): Promise<ConnectedHandle<TConfig>>;
+        };
+    }
+}
+export { connectToHost };
+export type { ConnectedHandle, ConnectToHostOptions };
+//# sourceMappingURL=embed.d.ts.map

package/host/dist/entry/embed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed.d.ts","sourceRoot":"","sources":["../../src/entry/embed.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,UAAU,CAAC;AAElB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,mBAAmB,CAAC,EAAE;YACpB,aAAa,CAAC,OAAO,GAAG,OAAO,EAC7B,IAAI,CAAC,EAAE,oBAAoB,GAC1B,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;SACtC,CAAC;KACH;CACF;AAUD,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,CAAC"}

package/host/dist/entry/embed.js

@@ -0,0 +1,7 @@
+import { R as i } from "../chunks/reachy-mini-sdk-eBYlC77N.js";
+import { c as n } from "../chunks/index-CyLPysJS.js";
+typeof window < "u" && (window.ReachyMini || (window.ReachyMini = i, window.dispatchEvent(new Event("reachymini:ready"))), window.ReachyMiniHostEmbed = { connectToHost: n });
+export {
+  n as connectToHost
+};
+//# sourceMappingURL=embed.js.map

package/host/dist/entry/embed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed.js","sources":["../../src/entry/embed.ts"],"sourcesContent":["/**\n * CDN \"embed\" entry: vanilla TS, no React / MUI, ~5 KB gz\n * (plus the SDK runtime bundled in).\n *\n * Loaded inside the embedded app's iframe:\n *\n *   <script type=\"module\"\n *     src=\"https://cdn.jsdelivr.net/npm/@pollen-robotics/reachy-mini-sdk@1/host/dist/entry/embed.js\">\n *   </script>\n *\n * The bundle exposes `connectToHost` on\n * `window.ReachyMiniHostEmbed` for legacy callers. ESM consumers\n * import normally.\n *\n * SDK auto-install\n * ────────────────\n * The embed client instantiates `new window.ReachyMini(...)`. Now\n * that the SDK ships in the same npm package we import it here\n * and self-assign onto `window.ReachyMini` (when unset) so apps\n * no longer need the old jsdelivr `<script type=\"module\">` tag.\n * Existing apps that set `window.ReachyMini` themselves keep\n * working — we only assign when the global is missing.\n */\nimport { ReachyMini } from '../../../reachy-mini-sdk';\nimport { connectToHost } from '../embed';\nimport type {\n  ConnectedHandle,\n  ConnectToHostOptions,\n} from '../embed';\n\ndeclare global {\n  interface Window {\n    ReachyMiniHostEmbed?: {\n      connectToHost<TConfig = unknown>(\n        opts?: ConnectToHostOptions,\n      ): Promise<ConnectedHandle<TConfig>>;\n    };\n  }\n}\n\nif (typeof window !== 'undefined') {\n  if (!window.ReachyMini) {\n    window.ReachyMini = ReachyMini;\n    window.dispatchEvent(new Event('reachymini:ready'));\n  }\n  window.ReachyMiniHostEmbed = { connectToHost };\n}\n\nexport { connectToHost };\nexport type { ConnectedHandle, ConnectToHostOptions };\n"],"names":["ReachyMini","connectToHost"],"mappings":";;AAwCI,OAAO,SAAW,QACf,OAAO,eACV,OAAO,aAAaA,GACpB,OAAO,cAAc,IAAI,MAAM,kBAAkB,CAAC,IAEpD,OAAO,sBAAsB,EAAE,eAAAC,EAAA;"}

package/host/dist/hooks/useHfProfile.d.ts

@@ -0,0 +1,7 @@
+export interface HfProfile {
+    username: string | null;
+    /** Fully-qualified avatar URL ready to drop into an `<img>` `src`. */
+    avatarUrl: string | null;
+}
+export declare function useHfProfile(token: string | null): HfProfile;
+//# sourceMappingURL=useHfProfile.d.ts.map

package/host/dist/hooks/useHfProfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHfProfile.d.ts","sourceRoot":"","sources":["../../src/hooks/useHfProfile.ts"],"names":[],"mappings":"AAmBA,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,sEAAsE;IACtE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAgDD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CA+B5D"}

package/host/dist/hooks/useHostBridge.d.ts

@@ -0,0 +1,37 @@
+import type { AppConnectingStep, AppPhase, ConfigPayload, HostInitMsg, LeavingReason, ThemeMode } from '../lib/protocol';
+export interface EmbedAppState {
+    phase: AppPhase;
+    connectingStep: AppConnectingStep | null;
+    message: string | null;
+}
+export interface UseHostBridgeOptions {
+    /** Called once per session, when the embed posts
+     *  `embed:ready`. The host MUST respond with `host:init`
+     *  via `sendInit` before resolving the picker phase. */
+    onEmbedReady(): void;
+    /** Called on every `embed:app-state` envelope. */
+    onAppState(state: EmbedAppState): void;
+    /** App requests a clean leave (in-app button, etc.). Host
+     *  should run the same tear-down as a user-initiated end. */
+    onRequestLeave(): void;
+    /** App reported an error. Fatal errors should switch the host
+     *  to ErrorView; non-fatal can be toasted or logged. */
+    onError(payload: {
+        message: string;
+        fatal: boolean;
+        detail?: unknown;
+    }): void;
+}
+export interface HostBridge {
+    /** `host:init`. Sends credentials + initial state to the embed. */
+    sendInit(iframe: HTMLIFrameElement, payload: Omit<HostInitMsg, 'source' | 'type' | 'version'>): void;
+    /** `host:theme-changed`. Push a theme update without reload. */
+    sendThemeChanged(iframe: HTMLIFrameElement, theme: ThemeMode): void;
+    /** `host:config-changed`. Push a config update without reload. */
+    sendConfigChanged(iframe: HTMLIFrameElement, config: ConfigPayload): void;
+    /** `host:leaving`. Notify the embed to tear down. The host
+     *  unmounts the iframe after `timeoutMs` regardless. */
+    sendLeaving(iframe: HTMLIFrameElement, reason: LeavingReason, timeoutMs: number): void;
+}
+export declare function useHostBridge(opts: UseHostBridgeOptions): HostBridge;
+//# sourceMappingURL=useHostBridge.d.ts.map

package/host/dist/hooks/useHostBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHostBridge.d.ts","sourceRoot":"","sources":["../../src/hooks/useHostBridge.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EACV,iBAAiB,EACjB,QAAQ,EACR,aAAa,EAEb,WAAW,EACX,aAAa,EACb,SAAS,EACV,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,QAAQ,CAAC;IAChB,cAAc,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACzC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC;;4DAEwD;IACxD,YAAY,IAAI,IAAI,CAAC;IACrB,kDAAkD;IAClD,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IACvC;iEAC6D;IAC7D,cAAc,IAAI,IAAI,CAAC;IACvB;4DACwD;IACxD,OAAO,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CAC/E;AAED,MAAM,WAAW,UAAU;IACzB,mEAAmE;IACnE,QAAQ,CACN,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC,GACxD,IAAI,CAAC;IACR,gEAAgE;IAChE,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACpE,kEAAkE;IAClE,iBAAiB,CACf,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,aAAa,GACpB,IAAI,CAAC;IACR;4DACwD;IACxD,WAAW,CACT,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,MAAM,GAChB,IAAI,CAAC;CACT;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,oBAAoB,GAAG,UAAU,CA2GpE"}