@factorialco/f0-react 7.12.0 → 7.14.0

package/dist/experimental.d.ts

@@ -1072,7 +1072,7 @@ declare const ANCHOR_ATTRIBUTE = "data-f0-coachmark";
  */
 export declare const ApplicationFrame: typeof _ApplicationFrame;
 
-declare function _ApplicationFrame({ children, sidebar, banner, ai, aiPromotion, sidePanel, }: ApplicationFrameProps): JSX_2.Element;
+declare function _ApplicationFrame({ children, sidebar, banner, ai, aiPromotion, sidePanel, meeting, }: ApplicationFrameProps): JSX_2.Element;
 
 export declare interface ApplicationFrameProps {
     ai?: Omit<AiChatProviderProps, "children">;
@@ -1082,6 +1082,16 @@ export declare interface ApplicationFrameProps {
      * behaves exactly as before: present when `ai.enabled`, absent otherwise.
      */
     sidePanel?: ApplicationFrameSidePanelProps;
+    /**
+     * Live meeting. The frame owns the one place a call can render; the host owns
+     * the runtime. `runtime: null` (or omitting the prop) means no meeting.
+     *
+     * In `panel` mode the call IS the side panel's content, like a conversation.
+     * In every other mode its window portals to `document.body`, because a
+     * floating window cannot work under a transformed, overflow-hidden ancestor.
+     * See `F0MeetingSurface`.
+     */
+    meeting?: Omit<F0MeetingProviderProps, "children">;
     banner?: React.ReactNode;
     sidebar: React.ReactNode;
     children: React.ReactNode;
@@ -1160,6 +1170,22 @@ export declare const AUTO_PER_PAGE_MAX = 30;
  */
 export declare const AUTO_PER_PAGE_MIN_RESERVED_ROWS = 10;
 
+declare type AutoFocusInput = {
+    tiles: F0MeetingTile[];
+    /** What the user asked for, if anything. */
+    intent: F0MeetingFocusIntent;
+    /** Screen shares already auto-focused once, so they are not re-focused. */
+    seenShareKeys: ReadonlySet<string>;
+};
+
+declare type AutoFocusResult = {
+    focusKey: string | null;
+    /** Share keys to remember as already auto-focused. */
+    seenShareKeys: ReadonlySet<string>;
+    /** True when the stored intent no longer matches a live tile. */
+    clearIntent: boolean;
+};
+
 export declare const AutoGrid: ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
 tileSize?: "lg" | "md" | "sm" | undefined;
 gap?: "0" | "1" | "2" | "3" | "4" | "lg" | "md" | "sm" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "14" | "16" | "px" | "xl" | "1.5" | "0.5" | "2.5" | undefined;
@@ -1655,6 +1681,13 @@ declare interface BreakType {
     isPaid: boolean;
 }
 
+/**
+ * Flattens the roster into tiles, preserving the host's participant order.
+ * Screen shares come first so they are never pushed off the visible page by a
+ * long roster.
+ */
+export declare const buildTiles: (participants: F0MeetingParticipant[]) => F0MeetingTile[];
+
 /**
  * Represents a bulk action that can be performed on a collection.
  */
@@ -4240,6 +4273,17 @@ declare const counterVariants: (props?: ({
 
 declare type CountryCode = keyof TranslationsType["countries"];
 
+/**
+ * External store for the volatile per-participant signals. These never go
+ * through React context: with a dozen participants that would re-render the
+ * whole room a hundred times a second. Only the leaf that draws the waveform
+ * subscribes, so a burst of audio events repaints five `<div>`s.
+ *
+ * F0 ships the factory so hosts only have to call the setters from their
+ * transport listeners — nobody should hand-roll subscribe/getSnapshot.
+ */
+export declare const createMeetingSignalStore: () => MeetingSignalStore;
+
 /**
  * Credits usage data returned by the host app
  */
@@ -5251,8 +5295,10 @@ declare const defaultTranslations: {
         readonly tomorrow: "Tomorrow";
         readonly inProgress: "In progress";
         readonly inProgressTitle: "Call in progress";
+        readonly ringing: "Ringing…";
         readonly summarizing: "Summarizing";
         readonly finished: "Finished";
+        readonly missed: "Missed";
         readonly cancelled: "Cancelled";
         readonly startingNow: "Starting now";
         readonly startsIn: {
@@ -5850,6 +5896,12 @@ declare const defaultTranslations: {
             readonly membersWithLast: "{{names}} and {{last}}";
             readonly membersWithMore: "{{names}} and {{count}} more";
         };
+        readonly call: {
+            readonly startedBy: "{{name}} started a huddle";
+            readonly ended: "Huddle ended";
+            readonly missed: "Missed huddle";
+            readonly start: "Start huddle";
+        };
         readonly unreadCount: {
             readonly one: "{{count}} unread";
             readonly other: "{{count}} unread";
@@ -5940,6 +5992,82 @@ declare const defaultTranslations: {
         readonly noData: "No data";
         readonly canceled: "Canceled";
     };
+    readonly meeting: {
+        readonly you: "You";
+        readonly muted: "Muted";
+        readonly waitingToJoin: "Waiting…";
+        readonly sharingScreen: "Sharing screen";
+        readonly chatPanel: "Chat";
+        readonly transcriptPanel: "Transcript";
+        readonly notesPanel: "Notes";
+        readonly openChat: "Open chat";
+        readonly closeChat: "Close chat";
+        readonly closePanel: "Close panel";
+        readonly notesPlaceholder: "Take notes for everyone in the call…";
+        readonly roomChatPlaceholder: "Message this call…";
+        readonly roomChatEmpty: "Messages here are only for this call and disappear when it ends.";
+        readonly sendMessage: "Send";
+        readonly notesReadOnly: "Only the host can edit these notes.";
+        readonly transcriptEmpty: "The transcript will appear here as people speak.";
+        readonly copyLink: "Copy link";
+        readonly linkCopied: "Link copied";
+        readonly handRaised: "Hand raised";
+        readonly morePeople: "{{count}} more";
+        readonly connecting: "Connecting…";
+        readonly reconnecting: "Reconnecting…";
+        readonly connectionLost: "Connection lost";
+        readonly ended: "The meeting has ended";
+        readonly rejoin: "Rejoin";
+        readonly weakConnection: "Weak connection";
+        readonly recording: "Recording";
+        readonly cameraBlocked: "Camera access is blocked. Allow it in your browser settings to turn it on.";
+        readonly microphoneBlocked: "Microphone access is blocked. Allow it in your browser settings to speak.";
+        readonly cameraUnavailable: "No camera found";
+        readonly microphoneUnavailable: "No microphone found";
+        readonly cameraInUse: "Your camera is being used by another app";
+        readonly microphoneInUse: "Your microphone is being used by another app";
+        readonly audioBlocked: "Click to enable sound";
+        readonly turnOnMicrophone: "Turn on microphone";
+        readonly turnOffMicrophone: "Turn off microphone";
+        readonly turnOnCamera: "Turn on camera";
+        readonly turnOffCamera: "Turn off camera";
+        readonly shareScreen: "Share screen";
+        readonly stopSharing: "Stop sharing";
+        readonly raiseHand: "Raise hand";
+        readonly lowerHand: "Lower hand";
+        readonly leave: "Leave";
+        readonly moreActions: "More actions";
+        readonly controls: "Meeting controls";
+        readonly unreadCount: "{{count}} unread";
+        readonly selectMicrophone: "Select microphone";
+        readonly systemDefault: "System default";
+        readonly selectCamera: "Select camera";
+        readonly enterFullscreen: "Expand to fullscreen";
+        readonly exitFullscreen: "Exit fullscreen";
+        readonly meetingWindow: "Meeting window";
+        readonly moveWindow: "Move meeting window";
+        readonly pinParticipant: "Pin";
+        readonly unpinParticipant: "Unpin";
+        readonly modeSwitch: "Meeting position";
+        readonly modeSidePanel: "Show in the side panel";
+        readonly modeFloating: "Show in a floating window";
+        readonly modeFullscreen: "Fill the screen";
+        readonly exitPictureInPicture: "Back to the tab";
+        readonly resizePanel: "Resize the meeting panel";
+        readonly movedToCorner: "Meeting window moved to the {{corner}}";
+        readonly cornerTopLeft: "top left";
+        readonly cornerTopRight: "top right";
+        readonly cornerBottomLeft: "bottom left";
+        readonly cornerBottomRight: "bottom right";
+        readonly participantJoined: "{{name}} joined";
+        readonly participantLeft: "{{name}} left";
+        readonly movedToFullscreen: "Meeting fills the screen";
+        readonly movedToFloating: "Meeting in a floating window";
+        readonly movedToSidePanel: "Meeting in the side panel";
+        readonly movedToMinimized: "Meeting minimized";
+        readonly movedInline: "Meeting on the page";
+        readonly movedToPictureInPicture: "Meeting in a picture-in-picture window";
+    };
     readonly select: {
         readonly noResults: "No results found";
         readonly loadingMore: "Loading...";
@@ -7705,6 +7833,73 @@ export declare type F0ChatAttachment = F0ChatImageAttachment | F0ChatFileAttachm
  * {@link F0ChatRuntime.uploadFiles} cannot tell these apart. */
 export declare type F0ChatAttachSource = "button" | "drop" | "paste";
 
+declare type F0ChatCall = {
+    id: string;
+    state: F0ChatCallState;
+    /** Who started it. */
+    startedBy: F0ChatUser;
+    /** ISO timestamp the call was started. */
+    startedAt: string;
+    /** ISO timestamp it ended. Drives the duration on `ended`. */
+    endedAt?: string;
+    /**
+     * Who is in the room right now while `ringing` or `live`, and who was in it
+     * once it has `ended`.
+     */
+    participants?: F0ChatUser[];
+    /**
+     * Present only while the call can be joined. Its absence is what removes the
+     * button — the same convention as the rest of the contract: no callback, no
+     * action. A host that omits it on an `ended` call needs no other flag.
+     *
+     * Return the promise and the button spins until it settles. Joining is never
+     * instant — a room has to be asked for first — so a host that drops the
+     * promise leaves the card looking as if the press did nothing.
+     */
+    join?: () => void | Promise<unknown>;
+    /**
+     * What the call was about, shown once it has `ended`. Plain text: the card
+     * renders it whole, and a transcript-sized block does not belong in a row of
+     * a conversation.
+     */
+    summary?: string;
+    /**
+     * Footer buttons on the ended card. The transcript is the reason this exists
+     * — it is long, and where it opens (a drawer, a modal, a page) is the host's
+     * decision, not the card's.
+     */
+    actions?: {
+        label: string;
+        icon?: IconType;
+        onClick: () => void;
+    }[];
+};
+
+/**
+ * A call in the transcript, rendered as a card with a Join button. Like a system
+ * message it has no author, no reactions and no replies — but unlike one it is
+ * INTERACTIVE and it MUTATES: the same id carries the call from ringing to
+ * ended, so the history keeps one line per call.
+ *
+ * factorial → a Stream message whose custom fields carry the call state, patched
+ * in place from LiveKit's webhooks (see `F0Meeting/SPEC.md`).
+ */
+declare type F0ChatCallMessage = {
+    type: "call";
+    id: string;
+    /** ISO timestamp — participates in day separators and ordering. */
+    createdAt: string;
+    call: F0ChatCall;
+};
+
+/**
+ * Where a call is in its life. One call is ONE transcript item that moves
+ * through these — not a live card plus a log line afterwards.
+ */
+declare type F0ChatCallState = (typeof f0ChatCallStates)[number];
+
+declare const f0ChatCallStates: readonly ["ringing", "live", "ended", "missed"];
+
 /**
  * Per-channel permissions, one per verb. Everything is optional and defaults to
  * today's behavior, so hosts only express what their transport restricts
@@ -8111,8 +8306,14 @@ export declare type F0ChatHeaderAction = {
     label: string;
     icon?: IconType;
     /** The host decides what happens: call a runtime method (togglePin,
-     * toggleMute), open its own modal, navigate… */
-    onClick: (channel: F0ChatChannel) => void;
+     * toggleMute), open its own modal, navigate…
+     *
+     * An `inline` action that returns a promise spins until it settles, and
+     * refuses further presses while it does. Actions that only toggle something
+     * local return nothing and never spin; the ones worth returning are those
+     * that go to a server before anything visibly happens — starting a huddle
+     * being the case this was built for. */
+    onClick: (channel: F0ChatChannel) => void | Promise<unknown>;
     /** Where the action renders: inside the ellipsis overflow menu (default) or
      * as its own icon button next to it. Inline requires `icon` — an inline
      * action without one falls back to the menu. */
@@ -8146,7 +8347,7 @@ export declare type F0ChatImageAttachment = {
 };
 
 /** Anything that can appear in the transcript, oldest → newest. */
-export declare type F0ChatItem = F0ChatMessage | F0ChatSystemMessage | F0ChatPost;
+export declare type F0ChatItem = F0ChatMessage | F0ChatSystemMessage | F0ChatPost | F0ChatCallMessage;
 
 /**
  * Open Graph preview of a URL in the body (WhatsApp-style card above the text).
@@ -8508,6 +8709,14 @@ export declare type F0ChatProps = {
      * the array per render with the current label/icon.
      */
     headerActions?: F0ChatHeaderAction[] | ((channel: F0ChatChannel) => F0ChatHeaderAction[]);
+    /**
+     * Replaces the built-in header. `null` removes it entirely, for hosts that
+     * already frame the chat with their own chrome — the in-call panel puts its
+     * Chat / Transcript / Notes tabs where this header would be.
+     *
+     * Undefined keeps the default header, so no existing usage changes.
+     */
+    header?: ReactNode | null;
 };
 
 /**
@@ -9960,6 +10169,8 @@ export declare interface F0MapProps extends WithDataTestIdProps {
      * zoom in - best for a world-scale view. Changing it re-projects live.
      */
     projection?: F0MapProjection;
+    /** Rendering engine to draw the map with. */
+    provider?: F0MapProvider;
     /** Show the skeleton instead of the map. */
     loading?: boolean;
     /** Accessible label for the map region. */
@@ -9968,11 +10179,6 @@ export declare interface F0MapProps extends WithDataTestIdProps {
     className?: string;
 }
 
-/**
- * Which rendering engine a style is written for. The tag exists so a style
- * built for one engine can never be handed to another: the shapes are not
- * interchangeable, and without it the mismatch would only surface at runtime.
- */
 export declare type F0MapProvider = "maplibre";
 
 /**
@@ -10029,6 +10235,109 @@ export declare interface F0MapViewport {
     zoom?: number;
 }
 
+/**
+ * Makes a meeting available to the app and renders its surface.
+ *
+ * `runtime: null` means there is no call: no window exists and the meeting hooks
+ * throw, exactly as they do outside a provider. This mirrors `F0AiChatProvider`
+ * — the host owns the transport, F0 owns the UI.
+ *
+ * The providers render whether or not there is a call, and ONLY the surface is
+ * conditional. That is load-bearing: `children` here is the host's entire
+ * application, and if it moved between the root and three providers deep as a
+ * call starts, React would reconcile the two shapes as different elements and
+ * remount the whole app — losing all component state and, for a host that
+ * fetches on mount, re-issuing every request on screen.
+ *
+ * `children` cannot simply sit outside the providers instead: in `panel` mode
+ * the room renders as side-panel content, which the host mounts from within its
+ * own tree, so it has to be able to read the meeting from here.
+ */
+export declare const F0Meeting: ({ runtime, actions, actionOrder, defaultMode, pictureInPicture, sidePanel, headerContent, overlay, children, }: F0MeetingProviderProps) => ReactNode;
+
+export declare type F0MeetingAction = {
+    /**
+     * Reusing a core id (see {@link f0MeetingCoreActionIds}) PATCHES the
+     * synthesized action instead of adding a new one, so a host can restyle the
+     * mic button without reimplementing it.
+     */
+    id: string;
+    /** Already localized. For toggles the host rebuilds it per render. */
+    label: string;
+    icon: IconType;
+    /** Shown while `pressed` — mic → MicrophoneNegative. */
+    activeIcon?: IconType;
+    /** Toggle semantics: renders `aria-pressed` and the active treatment. */
+    pressed?: boolean;
+    onClick?: () => void;
+    disabled?: boolean;
+    /** Why it is disabled. Without this, a disabled button is a dead end. */
+    disabledReason?: string;
+    /** An operation is in flight: spinner, no double-fire. */
+    pending?: boolean;
+    variant?: "default" | "critical";
+    /** Collapse priority; higher survives longer. */
+    priority?: number;
+    /** Never collapses into the overflow menu. */
+    pinned?: boolean;
+    /** Actions sharing a group render adjacent, separated by a hairline. */
+    group?: string;
+    badge?: number | "dot";
+    /** Restrict to some surface modes. Omit for all. */
+    modes?: F0MeetingSurfaceMode[];
+    /**
+     * Shortcut hint for the tooltip. F0 renders it but does NOT bind it — global
+     * key binding belongs to the host, which owns the rest of the app.
+     */
+    shortcut?: string;
+    /** Removes a synthesized core action entirely. */
+    hidden?: boolean;
+};
+
+export declare type F0MeetingActionInput = F0MeetingAction | F0MeetingActionPatch;
+
+/**
+ * A partial override of a synthesized core action. Patching only needs the id,
+ * so relabelling the mic button does not mean restating its icon, priority and
+ * pinning — which would be both noise and a chance to get them wrong.
+ */
+export declare type F0MeetingActionPatch = Partial<Omit<F0MeetingAction, "id">> & {
+    id: F0MeetingCoreActionId;
+};
+
+export declare type F0MeetingActionsProp = F0MeetingActionInput[] | ((runtime: F0MeetingRuntime) => F0MeetingActionInput[]);
+
+/**
+ * Binds a media track to a DOM element that F0 owns. F0 calls `attach` in a
+ * layout effect and the returned cleanup on unmount / track change.
+ *
+ * factorial → LiveKit: `(el) => { track.attach(el); return () => track.detach(el) }`.
+ * Going through the transport's own attach (instead of assigning `srcObject`)
+ * is what keeps adaptive stream and dynacast working: LiveKit observes the
+ * attached element's size and visibility to pick the simulcast layer and to
+ * pause off-screen tracks.
+ */
+export declare type F0MeetingBinding = (element: HTMLMediaElement) => () => void;
+
+/**
+ * Per-room permissions, defaulting to allowed so hosts only express what their
+ * token or role restricts.
+ *
+ * Capabilities are PERMISSIONS; the optional actions on the runtime are FEATURE
+ * SUPPORT. Omitting `startRecording` means "this deployment has no recording";
+ * `canRecord: false` means "recording exists but not for you".
+ */
+export declare type F0MeetingCapabilities = {
+    canPublishAudio?: boolean;
+    canPublishVideo?: boolean;
+    canShareScreen?: boolean;
+    canRecord?: boolean;
+    canMuteOthers?: boolean;
+    canRemoveParticipants?: boolean;
+    /** Per-participant moderation gate (e.g. you cannot remove another host). */
+    canModerate?: (participant: F0MeetingParticipant) => boolean;
+};
+
 /**
  * @experimental This is an experimental component, use it at your own risk.
  */
@@ -10100,6 +10409,506 @@ export declare interface F0MeetingCardProps extends WithDataTestIdProps, DataAtt
     secondaryActions?: CardSecondaryAction[];
 }
 
+export declare const f0MeetingConnectionQualities: readonly ["excellent", "good", "poor", "lost"];
+
+export declare type F0MeetingConnectionQuality = (typeof f0MeetingConnectionQualities)[number];
+
+export declare type F0MeetingCoreActionId = (typeof f0MeetingCoreActionIds)[number];
+
+export declare const f0MeetingCoreActionIds: readonly ["core:microphone", "core:microphoneSettings", "core:camera", "core:cameraSettings", "core:screenShare", "core:raiseHand", "core:chat", "core:leave"];
+
+export declare type F0MeetingDevice = {
+    /** MediaDeviceInfo.deviceId. */
+    id: string;
+    label: string;
+    /** Marks the OS default entry so the UI can render "System default". */
+    isDefault?: boolean;
+};
+
+/** Why the room ended — drives the copy of the end state. */
+export declare type F0MeetingDisconnectReason = (typeof f0MeetingDisconnectReasons)[number];
+
+export declare const f0MeetingDisconnectReasons: readonly ["user-left", "removed", "room-closed", "duplicate-identity", "server-shutdown", "connection-lost", "unknown"];
+
+/**
+ * Which tile is in the spotlight, as an INTENT rather than a key.
+ *
+ * A plain `string | null` cannot tell "nobody has pinned anything" apart from
+ * "the user dismissed the spotlight", so in a one-to-one the auto rule kept
+ * re-applying itself and the pin button did nothing. The three states make
+ * dismissal expressible.
+ */
+export declare type F0MeetingFocusIntent = {
+    type: "auto";
+} | {
+    type: "pinned";
+    key: string;
+} | {
+    type: "none";
+};
+
+/**
+ * The local participant's media, split from the roster because it changes on a
+ * different cadence and drives the control bar directly.
+ */
+export declare type F0MeetingLocalMedia = {
+    microphone: F0MeetingLocalSource;
+    camera: F0MeetingLocalSource;
+    /** Omit when the host cannot share (mobile web, restricted tenants). */
+    screenShare?: F0MeetingLocalSource;
+    /**
+     * Browsers block autoplay of remote audio until a user gesture. When true,
+     * F0 renders an affordance wired to `unlockAudio`.
+     * factorial → LiveKit `room.canPlaybackAudio === false`, resolved by
+     * `room.startAudio()`.
+     */
+    audioBlocked?: boolean;
+    unlockAudio?: () => void | Promise<void>;
+};
+
+/** State of one local media source. */
+export declare type F0MeetingLocalSource = {
+    enabled: boolean;
+    /** A toggle is in flight. Renders the pending state and blocks double-clicks. */
+    pending?: boolean;
+    permission?: F0MeetingPermission;
+    /** Devices for the inline picker. Omit to hide the chevron entirely. */
+    devices?: F0MeetingDevice[];
+    selectedDeviceId?: string;
+    selectDevice?: (deviceId: string) => void | Promise<void>;
+};
+
+export declare type F0MeetingParticipant = {
+    id: string;
+    /** Display name, already resolved by the host. LiveKit `Participant.name`. */
+    name: string;
+    avatar?: AvatarVariant;
+    isLocal: boolean;
+    /**
+     * Moderator flag — drives moderation affordances. Not a transport concept:
+     * the host derives it from token grants or `participant.metadata`.
+     */
+    isHost?: boolean;
+    /**
+     * A bot rather than a person (AI notetaker, transcription bot). Renders with
+     * a distinct treatment and never counts toward "N people in the call".
+     */
+    isAgent?: boolean;
+    /** Joined but has not published anything yet. */
+    isConnecting?: boolean;
+    /**
+     * Whether this person is actually in the room. Absent means `joined`, so a
+     * host that only ever reports real participants needs no change.
+     *
+     * `invited` is someone the call is waiting for: they hold a tile that reads
+     * "Waiting…", publish nothing, and do NOT count toward "N people in the
+     * call". LiveKit does not know them — they come from the host's own list of
+     * attendees, which is why this cannot be derived from the transport.
+     */
+    presence?: F0MeetingPresence;
+    tracks: F0MeetingTrack[];
+    /**
+     * ISO timestamp the hand was raised, so "who raised first" has an order.
+     * factorial → LiveKit participant attributes or a data-channel message.
+     */
+    raisedHandAt?: string;
+    /** Free-form host label shown in the tile chip. F0 never parses it. */
+    subtitle?: string;
+    /**
+     * Never crop this person's video: it is letterboxed inside its tile instead
+     * of filling it.
+     *
+     * Tiles take the shape of their cell and crop the sides to fill it, which is
+     * safe for a centred face and NOT safe for someone signing — it takes their
+     * hands with it. Meet exposes the same escape hatch as "Show my full video to
+     * others". The person owns the preference; F0 only honours it.
+     */
+    preventCrop?: boolean;
+};
+
+/**
+ * Media permission as the browser reports it. Modelling it explicitly is what
+ * lets the UI explain a black tile instead of just showing one.
+ *
+ * factorial → the DOMException name from `getUserMedia`: `NotAllowedError` →
+ * "denied", `NotFoundError` → "unavailable", `NotReadableError` → "in-use".
+ */
+export declare type F0MeetingPermission = (typeof f0MeetingPermissions)[number];
+
+export declare const f0MeetingPermissions: readonly ["granted", "prompt", "denied", "unavailable", "in-use"];
+
+export declare type F0MeetingPresence = (typeof f0MeetingPresences)[number];
+
+/**
+ * A person in the room. `id` is the transport identity — the SAME string the
+ * transport uses, so F0 never cross-references two id spaces internally. The
+ * domain lookup (identity → employee name/avatar) belongs to the adapter.
+ *
+ * factorial → LiveKit `Participant.identity` (the employee id).
+ */
+export declare const f0MeetingPresences: readonly ["invited", "joined"];
+
+/**
+ * Makes a {@link F0MeetingRuntime} available to the meeting UI. The host owns
+ * the runtime (a mock in stories, a LiveKit adapter in factorial); F0 only
+ * reads it and never imports the transport.
+ */
+export declare const F0MeetingProvider: ({ runtime, children, }: {
+    /**
+     * `null` while there is no call. The provider still renders, so `children`
+     * keep their position in the tree — see {@link F0Meeting}. Every hook below
+     * throws on a null context, which keeps the contract intact: you may only read
+     * a meeting from inside one.
+     */
+    runtime: F0MeetingRuntime | null;
+    children: ReactNode;
+}) => ReactNode;
+
+export declare type F0MeetingProviderProps = {
+    /** `null` when there is no active meeting: nothing mounts. */
+    runtime: F0MeetingRuntime | null;
+    /** Host actions, merged by id with the synthesized core ones. */
+    actions?: F0MeetingActionsProp;
+    /** Explicit left-to-right order by action id. Unlisted ids keep their slot. */
+    actionOrder?: string[];
+    /** Surface mode when a meeting first appears. */
+    defaultMode?: F0MeetingSurfaceDestination;
+    /**
+     * Whether the browser may move the call into its picture-in-picture window
+     * when the user leaves the tab. On by default. There is no button for it,
+     * and nothing happens on a browser without either PiP API.
+     */
+    pictureInPicture?: boolean;
+    /**
+     * The tabs of the in-call side panel (chat, transcript, notes). F0 renders
+     * the bar and owns whether the panel is open, because the button that opens
+     * it lives in F0's own control bar — a bare `ReactNode` could not supply the
+     * tab labels or the unread badge that button needs.
+     */
+    sidePanel?: F0MeetingSidePanel;
+    /** Host content rendered in the window header, before the mode controls. */
+    headerContent?: React.ReactNode;
+    /** Host content rendered above the whole room (banners, upsells). */
+    overlay?: React.ReactNode;
+    children?: React.ReactNode;
+};
+
+export declare type F0MeetingReaction = {
+    id: string;
+    participantId: string;
+    emoji: string;
+    at: string;
+};
+
+export declare type F0MeetingRecording = {
+    active: boolean;
+    startedBy?: F0MeetingParticipant;
+    startedAt?: string;
+    /** Legal copy is host-provided and already localized. */
+    consentNotice?: string;
+};
+
+/**
+ * The room itself: grid, controls and state chrome. It knows nothing about the
+ * window that hosts it — the surface owns position, size and mode, exactly as
+ * `F0Chat` takes its window controls as callbacks.
+ */
+export declare const F0MeetingRoom: ({ actions, actionOrder, sidePanel, overlay, }: F0MeetingRoomProps) => JSX_2.Element;
+
+export declare type F0MeetingRoomInfo = {
+    id: string;
+    /** Shown in the header and in the minimized pill. */
+    title: string;
+    avatar?: AvatarVariant;
+    /**
+     * ISO timestamp the call started — drives the elapsed timer. LiveKit exposes
+     * no room start time, so the adapter uses its own backend value and falls
+     * back to local join time.
+     */
+    startedAt?: string;
+    /** Where this meeting came from, so the header can link back to it. */
+    origin?: {
+        label: string;
+        onNavigate: () => void;
+    };
+};
+
+export declare type F0MeetingRoomProps = {
+    actions?: F0MeetingActionsProp;
+    actionOrder?: string[];
+    sidePanel?: F0MeetingSidePanel;
+    overlay?: React.ReactNode;
+};
+
+/** The roster slice: changes on join/leave/publish, not on every packet. */
+export declare type F0MeetingRoster = {
+    room: F0MeetingRoomInfo;
+    status: F0MeetingStatus;
+    participants: F0MeetingParticipant[];
+    localMedia: F0MeetingLocalMedia;
+    recording?: F0MeetingRecording;
+    signals?: F0MeetingSignalStore;
+};
+
+/**
+ * The data and actions a host provides to drive the meeting UI. F0 is headless:
+ * it never touches the transport. A mock runtime powers Storybook; factorial
+ * implements this against LiveKit.
+ *
+ * As in {@link F0ChatRuntime}, optional callbacks are CAPABILITY DETECTION:
+ * omitting `setScreenShareEnabled` removes the screen-share button entirely.
+ */
+export declare type F0MeetingRuntime = {
+    room: F0MeetingRoomInfo;
+    status: F0MeetingStatus;
+    /** Only meaningful with `status: "disconnected"`. */
+    disconnectReason?: F0MeetingDisconnectReason;
+    /** Human-readable failure, already localized. `status: "error"` only. */
+    errorMessage?: string;
+    localParticipantId: string;
+    /**
+     * Everyone in the room INCLUDING the local participant, in a stable order the
+     * host controls (join order). F0 owns speaker promotion and pagination on top
+     * of this — a host that reorders on every speaker change makes the grid churn.
+     */
+    participants: F0MeetingParticipant[];
+    localMedia: F0MeetingLocalMedia;
+    /**
+     * Volatile per-participant signals. Omit and F0 degrades gracefully to muted
+     * flags with no waveform and no quality bars, which is what tests and simple
+     * hosts want.
+     */
+    signals?: F0MeetingSignalStore;
+    /**
+     * Leave the room. F0 never calls this implicitly — not on unmount, not on
+     * Escape, not on navigation. Hanging up must be an explicit user act.
+     */
+    leave: () => void | Promise<void>;
+    setMicrophoneEnabled: (enabled: boolean) => void | Promise<void>;
+    setCameraEnabled: (enabled: boolean) => void | Promise<void>;
+    setScreenShareEnabled?: (enabled: boolean) => void | Promise<void>;
+    startRecording?: () => void | Promise<void>;
+    stopRecording?: () => void | Promise<void>;
+    recording?: F0MeetingRecording;
+    setHandRaised?: (raised: boolean) => void | Promise<void>;
+    sendReaction?: (emoji: string) => void | Promise<void>;
+    /** Transient reactions to animate; the host prunes them after a few seconds. */
+    reactions?: F0MeetingReaction[];
+    muteParticipant?: (participantId: string) => void | Promise<void>;
+    removeParticipant?: (participantId: string) => void | Promise<void>;
+    /**
+     * Live transcription. Omit and the panel has no Transcript tab at all —
+     * the usual capability-by-presence rule.
+     */
+    transcript?: F0MeetingTranscriptSegment[];
+    /** Shared notes for the room. Present without `setNotes` means read-only. */
+    notes?: string;
+    setNotes?: (value: string) => void;
+    /** Retry after a failed connect — wires the Rejoin action. */
+    reconnect?: () => void | Promise<void>;
+    capabilities?: F0MeetingCapabilities;
+};
+
+export declare type F0MeetingSidePanel = {
+    tabs: F0MeetingSidePanelTab[];
+    defaultTabId?: string;
+};
+
+/**
+ * A tab in the room's side panel. F0 owns the bar, the selection and the close
+ * button; the host owns what is inside each tab.
+ */
+export declare type F0MeetingSidePanelTab = {
+    id: string;
+    label: string;
+    content: React.ReactNode;
+    /** Unread count on the tab and on the control-bar button that opens it. */
+    badge?: number;
+};
+
+/**
+ * Per-participant volatile state. Read through `useSyncExternalStore`, never
+ * through context: with a dozen participants LiveKit emits these at 10–20 Hz,
+ * which would re-render the whole tree a hundred times a second.
+ */
+export declare type F0MeetingSignal = {
+    /** 0..1, smoothed by the host. LiveKit `Participant.audioLevel`. */
+    audioLevel: number;
+    isSpeaking: boolean;
+    quality: F0MeetingConnectionQuality;
+};
+
+/**
+ * Minimal external-store protocol. F0 exports `createMeetingSignalStore` so
+ * hosts never implement subscribe/getSnapshot themselves — the adapter just
+ * calls the setters from its transport listeners.
+ */
+export declare type F0MeetingSignalStore = {
+    subscribe: (participantId: string, listener: () => void) => () => void;
+    /**
+     * MUST return the same object identity while nothing changed, or
+     * `useSyncExternalStore` loops forever.
+     */
+    getSnapshot: (participantId: string) => F0MeetingSignal;
+    subscribeSpeakers: (listener: () => void) => () => void;
+    /** Identity changes only when the SET changes, so the grid doesn't churn. */
+    getSpeakers: () => readonly string[];
+};
+
+/**
+ * Reserves space for the meeting on a dedicated page.
+ *
+ * It renders nothing: it is an empty box that publishes its viewport rect, and
+ * the window — which stays in its portal — animates to that rect. Teleporting
+ * by measurement instead of reparenting is what keeps the `<video>` elements
+ * mounted across navigation, and it makes the fullscreen ↔ inline ↔ floating
+ * transition a single animation of x/y/width/height.
+ */
+export declare const F0MeetingSlot: () => JSX_2.Element;
+
+/**
+ * The slow-moving slice, behind a SEPARATE context with a stable value. LiveKit
+ * emits audio levels, speaking changes and quality updates at 10–20 Hz per
+ * participant; anything mounted per-tile that read the full runtime would
+ * re-render on every one of them, defeating the tile memoization.
+ *
+ * The action callbacks are identity-stable delegates into the latest runtime.
+ */
+export declare type F0MeetingStable = {
+    roomId: string;
+    localParticipantId: string;
+    capabilities?: F0MeetingCapabilities;
+    /**
+     * Presence flags, not the callbacks themselves: optional runtime actions gate
+     * UI affordances by PRESENCE, so the memo tracks presence, not identity.
+     */
+    hasScreenShare: boolean;
+    hasRecording: boolean;
+    hasReactions: boolean;
+    hasRaiseHand: boolean;
+    hasModeration: boolean;
+    hasReconnect: boolean;
+    setMicrophoneEnabled: (enabled: boolean) => void;
+    setCameraEnabled: (enabled: boolean) => void;
+    setScreenShareEnabled: (enabled: boolean) => void;
+    setHandRaised: (raised: boolean) => void;
+    sendReaction: (emoji: string) => void;
+    muteParticipant: (participantId: string) => void;
+    removeParticipant: (participantId: string) => void;
+    reconnect: () => void;
+    leave: () => void;
+};
+
+/**
+ * Room lifecycle. `reconnecting` shows a non-blocking banner and FREEZES the
+ * last video frame instead of clearing tiles — clearing on a two-second ICE
+ * restart is the worst thing a call UI can do.
+ *
+ * factorial → LiveKit `Room.state` plus the `Disconnected` event's reason.
+ */
+export declare type F0MeetingStatus = (typeof f0MeetingStatuses)[number];
+
+export declare const f0MeetingStatuses: readonly ["idle", "connecting", "connected", "reconnecting", "disconnected", "error"];
+
+/**
+ * Mounts the room into a portal on `document.body`, once, for the whole life of
+ * the meeting — for every mode EXCEPT `panel` and `pip`.
+ *
+ * It lives outside the application frame on purpose. The frame's root is
+ * `overflow-hidden` and contains transformed elements, and a transformed
+ * ancestor breaks `position: fixed` for everything inside it — which is exactly
+ * what a free-floating window needs. Portalling also keeps the frame's own
+ * z-index map untouched: the surface only claims the 40–49 band at body level,
+ * deliberately below Radix dialogs so a modal can still cover the call.
+ *
+ * `panel` is the one mode with no window at all: there the room is the side
+ * panel's content (see `MeetingPanelContent`), so it needs no chrome of its own
+ * and no rect — the panel supplies both. `pip` has a window, but it is the
+ * browser's: the room portals into that window's document (see `PipFrame`).
+ *
+ * The body-level portal element stays mounted regardless, because two things
+ * must never leave the main document: the live region announcing the call, and
+ * the `<audio>` elements — a media element moved to another document stops
+ * playing, and remounting one in the middle of a sentence is a dropped word.
+ */
+export declare const F0MeetingSurface: () => JSX_2.Element | null;
+
+export declare type F0MeetingSurfaceDestination = (typeof f0MeetingSurfaceDestinations)[number];
+
+/** The places a call can be sent to — by the user, or by `defaultMode`. */
+export declare const f0MeetingSurfaceDestinations: readonly ["fullscreen", "panel", "floating", "minimized", "inline"];
+
+export declare type F0MeetingSurfaceMode = (typeof f0MeetingSurfaceModes)[number];
+
+/**
+ * Everything the surface can render as. `pip` is the one mode nobody chooses:
+ * the browser moves the call into its picture-in-picture window when the tab
+ * is left, whatever mode it was in, and closing that window returns to it.
+ * Never persisted, never a `defaultMode`, never a button.
+ */
+export declare const f0MeetingSurfaceModes: readonly ["fullscreen", "panel", "floating", "minimized", "inline", "pip"];
+
+/**
+ * A rendered cell. One per published camera (with a placeholder when the camera
+ * is off) plus one per screen share, so a participant who is sharing occupies
+ * two tiles — the same behaviour as every other call product.
+ */
+export declare type F0MeetingTile = {
+    /** `${participantId}:${kind}` — stable across re-solves. */
+    key: string;
+    participant: F0MeetingParticipant;
+    kind: Extract<F0MeetingTrackKind, "camera" | "screenShare">;
+    /** Undefined when nothing is published: the tile renders the avatar. */
+    track?: F0MeetingTrack;
+};
+
+export declare type F0MeetingTrack = {
+    /** Stable publication id. factorial → LiveKit `TrackPublication.trackSid`. */
+    id: string;
+    kind: F0MeetingTrackKind;
+    /**
+     * Identity key for the binding. F0 re-runs attach ONLY when this changes —
+     * never on `binding`'s identity, which hosts rebuild on every transport
+     * event. Republishing the same source (camera restart, device switch) MUST
+     * change it. factorial → `${trackSid}:${track.mediaStreamID}`.
+     */
+    bindingKey: string;
+    binding?: F0MeetingBinding;
+    /** Muted at the source. factorial → LiveKit `TrackPublication.isMuted`. */
+    muted: boolean;
+    /** Subscribed and flowing. factorial → `isSubscribed && !isMuted`. */
+    live: boolean;
+    /**
+     * Intrinsic dimensions, when known — lets the tile letterbox before the
+     * first frame lands. Screen shares are rarely 16:9, so forcing them into it
+     * is visible. factorial → LiveKit `TrackPublication.dimensions`.
+     */
+    width?: number;
+    height?: number;
+};
+
+export declare type F0MeetingTrackKind = (typeof f0MeetingTrackKinds)[number];
+
+export declare const f0MeetingTrackKinds: readonly ["camera", "microphone", "screenShare", "screenShareAudio"];
+
+/**
+ * One line of live transcription.
+ *
+ * Modelled on LiveKit's own shape so the adapter is a rename: segments arrive
+ * on the `lk.transcription` text-stream topic, and a non-final segment is
+ * REPLACED by its final version under the same id rather than appended.
+ * (`RoomEvent.TranscriptionReceived` is deprecated; do not wire it.)
+ */
+export declare type F0MeetingTranscriptSegment = {
+    /** LiveKit `lk.segment_id` — shared between the interim and final versions. */
+    id: string;
+    participantId: string;
+    text: string;
+    at: string;
+    /** LiveKit `lk.transcription_final`. Interim lines render as provisional. */
+    isFinal: boolean;
+};
+
 declare type F0Message = {
     id: string;
     role: "user" | "assistant" | "system" | "tool";
@@ -10323,6 +11132,13 @@ export declare type F0ProgressSeriesSize = (typeof f0ProgressSeriesSizes)[number
 
 export declare const f0ProgressSeriesSizes: readonly ["sm", "md", "lg"];
 
+export declare type F0Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
 /**
  * Header for a resource detail page: avatar, title, description, status,
  * metadata and its primary, secondary and overflow actions.
@@ -10916,6 +11732,29 @@ export declare interface F0VersionHistoryProps {
     activeVersionId?: "current" | (string & {});
 }
 
+export declare type F0WindowCorner = (typeof f0WindowCorners)[number];
+
+export declare const f0WindowCorners: readonly ["tl", "tr", "bl", "br"];
+
+/**
+ * Anchored placement. Storing absolute coordinates is the classic mistake:
+ * shrinking the browser leaves the window off-screen. Anchoring to a corner
+ * keeps it where the user expects across viewport changes.
+ *
+ * It describes the FLOATING window only. `panel` mode stores nothing here: the
+ * room is the side panel's content there, so its width is the panel's and is
+ * persisted by the panel — which is also why docking and undocking returns the
+ * exact floating size the user had chosen.
+ */
+export declare type F0WindowPlacement = {
+    corner: F0WindowCorner;
+    /** Distance from the anchored corner, in px, always positive. */
+    dx: number;
+    dy: number;
+    width: number;
+    height: number;
+};
+
 /**
  * @deprecated Renamed to `F0SearchInput` to match the F0 input vocabulary
  * (any component where the user types in a box has the `Input` suffix and
@@ -11569,6 +12408,55 @@ declare type GraphVisualizationSettings = {
     hidden?: string[];
 };
 
+/** One row of the grid. Rows may hold different counts, so also different widths. */
+declare type GridRow = {
+    count: number;
+    tileWidth: number;
+    tileHeight: number;
+};
+
+export declare type GridSolution = {
+    rows: number;
+    /** Widest row's tile count. */
+    cols: number;
+    /** The NARROWEST row's tile — the worst case, which is what limits are about. */
+    tileWidth: number;
+    tileHeight: number;
+    /** Tiles that fit. `count - visibleCount` go to the overflow chip. */
+    visibleCount: number;
+    rowSpecs: GridRow[];
+    /** Σ tile areas: how much of the container the layout actually covers. */
+    totalArea: number;
+};
+
+export declare type GridSolverInput = {
+    count: number;
+    width: number;
+    height: number;
+    gap: number;
+    /**
+     * How far a tile may stray from `preferredAspect` to fill its cell. Inside
+     * this range the tile simply IS the cell, so the grid leaves no dead space.
+     */
+    minAspect: number;
+    maxAspect: number;
+    /** Only breaks ties between layouts of equal quality. */
+    preferredAspect: number;
+    /** Below this a tile stops being useful; the solver overflows instead. */
+    minTileWidth: number;
+    /**
+     * The same floor for height. Optional, and 0 means "no floor" — a caller with
+     * only a width in mind gets exactly the old behaviour.
+     */
+    minTileHeight?: number;
+    /**
+     * How much smaller than the best possible worst tile a layout may make its
+     * smallest tile to compete on total coverage. `1` (the default) is pure
+     * maximin; `COVERAGE_TOLERANCE` is what the room uses.
+     */
+    coverageTolerance?: number;
+};
+
 /**
  * Symbol used to identify the groupId in the data
  */
@@ -12669,6 +13557,19 @@ export declare type lastIntentType = {
 /** Sentinel for {@link F0ChatRuntime.loadMessageContext} meaning "the live tail". */
 export declare const LATEST: "latest";
 
+/**
+ * Places the solved tiles. Rows sit in equal-height slots that span the
+ * container, and each row centres its own tiles inside its slot — so a row
+ * that the aspect clamp shrank is centred rather than pinned to a corner.
+ *
+ * Returns absolute rects so the caller can animate x/y/width/height directly —
+ * no `scale`, which is what would warp the video mid-flight.
+ */
+export declare const layoutGrid: (solution: GridSolution, box: {
+    width: number;
+    height: number;
+}, gap: number) => F0Rect[];
+
 declare type Level = (typeof levels)[number];
 
 declare const levels: readonly ["info", "warning", "critical", "positive"];
@@ -12991,8 +13892,15 @@ export declare type MeetingAttendee = {
 };
 
 export declare interface MeetingJoin {
-    /** Called when the Join button is pressed. */
-    onJoin?: () => void;
+    /**
+     * Called when the Join button is pressed.
+     *
+     * Return the promise and the button shows a spinner until it settles, which
+     * is what joining actually needs: a room has to be asked for before there is
+     * anything to walk into, and without this the card sits there looking as if
+     * the press did nothing.
+     */
+    onJoin?: () => void | Promise<unknown>;
     /** Navigates to the meeting room instead of handling the click. */
     href?: string;
     /**
@@ -13009,6 +13917,93 @@ export declare interface MeetingJoin {
     label?: string;
 }
 
+/**
+ * Shared notes for the room.
+ *
+ * Uncontrolled-looking but fully controlled: the value comes from the host, so
+ * whatever it syncs the notes through — a data channel, a document, a poll —
+ * arrives here as a re-render rather than as a second source of truth.
+ */
+export declare const MeetingNotes: ({ value, onChange }: MeetingNotesProps) => JSX_2.Element;
+
+declare type MeetingNotesProps = {
+    value: string;
+    /** Absent means read-only: the notes exist but this person cannot edit them. */
+    onChange?: (value: string) => void;
+};
+
+/**
+ * The room AS THE SIDE PANEL'S CONTENT — not a window that covers it.
+ *
+ * Everything `FloatingWindow` would draw is deliberately absent: the card, the
+ * border, the shadow, the rect, the drag handles and the resize seam all belong
+ * to the panel, which already has one of each. What is left is the header row
+ * and the room, filling whatever space the panel gives them.
+ *
+ * It takes no props ON PURPOSE. The element is handed to `present()` and stored
+ * in the panel's state, so it must be referentially stable — a fresh element on
+ * every render would re-present in a loop. Everything the chrome needs comes
+ * from {@link useMeetingChrome} instead.
+ *
+ * ## Why it renders nothing when there is no call
+ *
+ * That same `present()` is what makes this OUTLIVE the call. The element lives
+ * in the side panel's state, in the host's tree, so it is not removed with the
+ * meeting surface — it is taken out by `MeetingPanelPresenter`'s effect cleanup,
+ * a whole commit after the runtime became null. There is therefore exactly one
+ * render where this is on screen with no call behind it, and reading the meeting
+ * there used to throw and take the page down on hanging up.
+ */
+export declare const MeetingPanelContent: () => ReactNode;
+
+/**
+ * The call's own chat, for the room's side panel.
+ *
+ * Deliberately plainer than `F0Chat`: this transport has no reactions, no
+ * threads, no read receipts and no history — in production it is LiveKit's data
+ * channel, which delivers a string and forgets it. Rendering it with the full
+ * conversation surface would promise all of those.
+ */
+export declare const MeetingRoomChat: ({ messages, onSend }: MeetingRoomChatProps) => JSX_2.Element;
+
+declare type MeetingRoomChatMessage = {
+    id: string;
+    participantId: string;
+    text: string;
+    at: string;
+};
+
+declare type MeetingRoomChatProps = {
+    messages: MeetingRoomChatMessage[];
+    onSend: (text: string) => void;
+};
+
+/**
+ * The in-call panel: chat, transcript and notes beside the grid.
+ *
+ * F0 owns the bar, the selection and the close button because the control that
+ * opens the panel lives in F0's own action bar and needs the tab labels and
+ * unread counts. What goes inside each tab is entirely the host's.
+ *
+ * Only one tab is mounted at a time. That is deliberate for the chat tab in
+ * particular: its transcript is virtualized, and measuring rows inside a
+ * display:none subtree yields zero heights that the list then has to correct
+ * on reveal.
+ */
+export declare const MeetingSidePanel: ({ panel }: MeetingSidePanelProps) => JSX_2.Element | null;
+
+declare type MeetingSidePanelProps = {
+    panel: F0MeetingSidePanel;
+};
+
+export declare type MeetingSignalStore = F0MeetingSignalStore & {
+    setAudioLevel: (participantId: string, level: number) => void;
+    setSpeaking: (participantIds: readonly string[]) => void;
+    setQuality: (participantId: string, quality: F0MeetingConnectionQuality) => void;
+    remove: (participantId: string) => void;
+    reset: () => void;
+};
+
 export declare type MeetingState = (typeof meetingStates)[number];
 
 /**
@@ -13018,7 +14013,102 @@ export declare type MeetingState = (typeof meetingStates)[number];
  * the elapsed label, whether Join is actionable) is computed from `startsAt` and
  * `now`.
  */
-export declare const meetingStates: readonly ["scheduled", "inProgress", "summarizing", "finished", "cancelled"];
+export declare const meetingStates: readonly ["ringing", "scheduled", "inProgress", "summarizing", "finished", "missed", "cancelled"];
+
+declare type MeetingSurfaceContextValue = {
+    /** What the user chose. Never mutated by the environment. */
+    mode: F0MeetingSurfaceDestination;
+    /**
+     * What actually renders. A small viewport or an unmounted inline slot derives
+     * a different mode without destroying the user's preference; so does an open
+     * picture-in-picture window, which is `pip` for as long as it is open.
+     */
+    effectiveMode: F0MeetingSurfaceMode;
+    setMode: (mode: F0MeetingSurfaceDestination) => void;
+    /** Absolute rect the window animates to, in viewport coordinates. */
+    rect: F0Rect;
+    isDragging: boolean;
+    setIsDragging: (dragging: boolean) => void;
+    /** Commit an absolute rect after a drag (re-anchors and snaps). */
+    settleRect: (rect: F0Rect) => void;
+    /** Commit a resize, keeping the current anchor. */
+    resizeRect: (rect: F0Rect) => void;
+    /** True below the md breakpoint: no dragging, pill instead of window. */
+    isCompactViewport: boolean;
+    /**
+     * The frame's content area. `panel` mode does NOT use it — there the room is
+     * the side panel's content and the panel places itself. It is what a window
+     * sizes itself against when it has to sit BESIDE the panel (see
+     * `fitToContent`), and the viewport when no frame published one.
+     */
+    panelArea: F0Rect;
+    /**
+     * Whether there is a side panel for the call to be the content of.
+     *
+     * Registered by the application frame, the same way `F0MeetingSlot`
+     * registers a rect for `inline`. A call rendered on its own — a story, a
+     * test, a host with no frame — has nowhere to dock, so `panel` derives to
+     * `floating` and the switch stops offering it.
+     */
+    hasPanelSlot: boolean;
+    setPanelSlot: (available: boolean) => void;
+    /** Registered by `F0MeetingSlot` so `inline` knows where to fly to. */
+    setInlineRect: (rect: F0Rect | null) => void;
+    /**
+     * The application frame's content region, published by the frame itself. The
+     * side panel lives inside it — between the navigation and the content —
+     * rather than on top of the whole viewport.
+     */
+    setFrameRect: (rect: F0Rect | null) => void;
+    /** What the user asked the spotlight to do, if anything. */
+    focusIntent: F0MeetingFocusIntent;
+    setFocusIntent: (intent: F0MeetingFocusIntent) => void;
+    /** Whether the in-call side panel is open, and on which tab. */
+    isSidePanelOpen: boolean;
+    setSidePanelOpen: (open: boolean) => void;
+    activeTabId: string | null;
+    setActiveTabId: (id: string) => void;
+    announce: (message: string) => void;
+    liveMessage: string;
+    /** What the browser offers for picture-in-picture, after the host's opt-out. */
+    pipSupport: PipSupport;
+    /** The Document PiP window, while the room renders inside it. */
+    pipWindow: Window | null;
+    /**
+     * Move the call into the browser's picture-in-picture. Deliberately not a
+     * destination of `setMode`: the only caller is the browser itself, from the
+     * Media Session `enterpictureinpicture` action when the tab is left — so the
+     * call follows you out of the tab the way Meet's does, and never by a button.
+     */
+    enterPictureInPicture: () => void;
+    exitPictureInPicture: () => void;
+    /**
+     * Every live `<video>` by tile key, kept by `TileVideo`, so video PiP has an
+     * element to hand to the browser.
+     */
+    registerVideo: (key: string, element: HTMLVideoElement | null) => void;
+};
+
+export declare const MeetingSurfaceProvider: ({ defaultMode, roomId, pictureInPicture, children, }: {
+    defaultMode?: F0MeetingSurfaceDestination;
+    /** Scopes the remembered mode. A different meeting starts at `defaultMode`. */
+    roomId?: string;
+    pictureInPicture?: boolean;
+    children: ReactNode;
+}) => ReactNode;
+
+/**
+ * Live transcription, newest at the bottom.
+ *
+ * Interim segments render at reduced emphasis and are REPLACED by their final
+ * version under the same id — appending both is what turns a transcript into
+ * the same sentence three times, each a word longer.
+ */
+export declare const MeetingTranscript: ({ segments }: MeetingTranscriptProps) => JSX_2.Element;
+
+declare type MeetingTranscriptProps = {
+    segments: F0MeetingTranscriptSegment[];
+};
 
 export declare type MentionedUser = {
     id: string | number;
@@ -13348,6 +14438,9 @@ export declare type NavigationTarget = {
 
 declare type NavTarget = HTMLAttributeAnchorTarget;
 
+/** The quadrant the rect's centre falls into. */
+export declare const nearestCorner: (rect: F0Rect, viewport: Viewport) => F0WindowCorner;
+
 /**
  * Utility type to extract all possible paths from nested object.
  * Generates hyphenated paths from nested object structure
@@ -14432,7 +15525,13 @@ declare interface PieComputation {
     limit?: number;
 }
 
+declare type PipSupport = "document" | "video" | "none";
+
+/** Re-expresses an absolute rect against a given corner. */
+export declare const placementFromRect: (rect: F0Rect, corner: F0WindowCorner, viewport: Viewport) => F0WindowPlacement;
+
 declare type PopoverContentProps = React_2.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> & {
+    /** Portal target. Defaults to the nearest `PortalContainerProvider`. */
     container?: HTMLElement | null;
 };
 
@@ -14859,6 +15958,16 @@ declare type RelaxedNumericWithFormatter = Omit<NumericWithFormatter, "numericVa
 
 declare type RendererDefinition = ValueDisplayRendererDefinition;
 
+/**
+ * Promotes off-page speakers into the visible page, replacing the tile that has
+ * been quiet the longest rather than the first one — swapping into slot 0 makes
+ * the grid jump on every turn.
+ *
+ * The hold window stops two people alternating from shuffling tiles on every
+ * exchange, which is the single most distracting thing a video grid can do.
+ */
+export declare const reorderForSpeakers: ({ tiles, speakerIds, pageSize, lastSpokenAt, now, holdMs, }: SpeakerOrderInput) => F0MeetingTile[];
+
 export declare interface ReplaceBlockNotesTextEditorPageDocumentPatch {
     type: "replace_block";
     targetId: string;
@@ -14885,6 +15994,19 @@ declare type RequisitionProfile = {
     };
 };
 
+/**
+ * Decides which tile is spotlighted. Pure, so every branch is a unit test.
+ *
+ * Priority: the user's pin, then a screen share we have not focused yet, then
+ * the remote participant in a one-to-one.
+ *
+ * The `none` intent is what makes the pin button work in a one-to-one. With a
+ * plain nullable key, dismissing the spotlight fell straight back into the
+ * two-camera rule below and re-focused the same person in the same render, so
+ * the control did nothing at all.
+ */
+export declare const resolveAutoFocus: ({ tiles, intent, seenShareKeys, }: AutoFocusInput) => AutoFocusResult;
+
 export declare type ResolvedRecordType<R> = R extends RecordType ? R : RecordType;
 
 /**
@@ -14894,6 +16016,14 @@ export declare type ResolvedRecordType<R> = R extends RecordType ? R : RecordTyp
  */
 export declare const resolveGranularityDefinition: (key: NavigationGranularityKey) => GranularityDefinition;
 
+/**
+ * Resolves an anchored placement into an absolute rect, clamped into the
+ * current viewport. Anchoring to a corner (rather than storing x/y) is what
+ * keeps the window sensible when the browser is resized: it stays glued to
+ * "its" corner instead of drifting off-screen.
+ */
+export declare const resolvePlacement: (placement: F0WindowPlacement, viewport: Viewport, minWidth?: number, minHeight?: number) => F0Rect;
+
 /** A renderer entry in its full form — a bare function is just its `render`. */
 export declare const resolveSlotRenderer: (entry: SlotRendererEntry | undefined) => {
     render: SlotRenderer;
@@ -15187,6 +16317,12 @@ export declare const selectSizes: readonly ["sm", "md"];
 
 export declare const selectVariants: readonly ["field", "inline"];
 
+/**
+ * Placement after a drag: always re-anchored to the nearest corner, and pulled
+ * flush to it when the window was dropped close enough.
+ */
+export declare const settlePlacement: (rect: F0Rect, viewport: Viewport) => F0WindowPlacement;
+
 /**
  * @experimental This is an experimental component use it at your own risk
  */
@@ -15961,6 +17097,30 @@ export declare type SlotWidgetProps = HomeWidgetChrome & {
     ctx?: HomeRenderCtx;
 };
 
+/**
+ * Picks the row split for the most people the floors admit, each row filling
+ * the container's width on its own.
+ *
+ * Two ideas do the work. A tile takes the shape of its own cell within
+ * `[minAspect, maxAspect]`, so inside that range the tile IS the cell and the
+ * block covers the container instead of letterboxing a fixed 16:9 box in every
+ * cell. And rows are sized independently, so an incomplete last row spreads its
+ * tiles over the full width rather than leaving the missing cells as a hole —
+ * three people fill the room, they do not sit next to an empty square.
+ *
+ * Selection is coverage within a tolerance of maximin — see `pick`.
+ *
+ * Pure, so it is tested without rendering.
+ */
+export declare const solveGrid: (input: GridSolverInput) => GridSolution;
+
+/**
+ * Spotlight plus a thumbnail strip. The strip is a PROPORTION of the container
+ * rather than a fixed height: the previous implementation hard-coded 125px,
+ * which is most of a small floating window.
+ */
+export declare const solveSpotlight: ({ stripCount, width, height, gap, stripRange, spotlightRange, }: SpotlightSolverInput) => SpotlightSolution;
+
 /**
  * Type helper to extract keys from a SortingsDefinition
  */
@@ -15985,6 +17145,20 @@ export declare type SortingsStateMultiple = {
 
 export declare type SortOrder = "asc" | "desc";
 
+declare type SpeakerOrderInput = {
+    tiles: F0MeetingTile[];
+    /** Participants currently speaking. */
+    speakerIds: readonly string[];
+    /** How many tiles the grid can show at once. */
+    pageSize: number;
+    /** participantId → epoch ms of their last turn. */
+    lastSpokenAt: Readonly<Record<string, number>>;
+    /** Now, injected so the function stays pure and testable. */
+    now: number;
+    /** A visible tile is only displaced after being quiet this long. */
+    holdMs: number;
+};
+
 /**
  * @experimental This is an experimental component use it at your own risk
  */
@@ -16036,6 +17210,43 @@ class?: never;
 className?: ClassValue;
 })) | undefined) => string> & RefAttributes<HTMLDivElement>, "ref"> & RefAttributes<HTMLElement | SVGElement>>;
 
+export declare type SpotlightSolution = {
+    spotlight: F0Rect;
+    strip: F0Rect[];
+    /** Thumbnails that did not fit, for the "+N" chip. */
+    stripOverflow: number;
+    stripSide: "bottom" | "right" | "none";
+};
+
+export declare type SpotlightSolverInput = {
+    /** Participants that are NOT the spotlight. */
+    stripCount: number;
+    width: number;
+    height: number;
+    gap: number;
+    /**
+     * How far a thumbnail may stray to take the shape of its own slot. Uniform
+     * across the strip, but derived from the container rather than fixed: a wide
+     * room gets nearly square thumbnails, a side panel portrait ones.
+     */
+    stripRange: {
+        min: number;
+        max: number;
+    };
+    /**
+     * Cameras pass a range: the spotlight takes the shape of its box, clamped, so
+     * it crops the sides rather than leaving most of a tall panel empty.
+     *
+     * Screen shares omit it and the spotlight takes the WHOLE box, letterboxing
+     * the presentation inside its own tile. That is what puts the black exactly
+     * where the picture is missing instead of darkening the whole room.
+     */
+    spotlightRange?: {
+        min: number;
+        max: number;
+    };
+};
+
 export declare const Stack: ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
 overflow?: "hidden" | "auto" | undefined;
 paddingX?: "none" | "p-4" | "p-2" | "p-8" | "p-12" | "p-16" | undefined;
@@ -16601,6 +17812,11 @@ declare type TextCellConfig = {
 /** The HTML-ish input type of a text cell. Drives a default leading icon. */
 declare type TextCellInputType = "text" | "email" | "url" | "tel";
 
+/** Ratio to lay a tile out with: screen shares keep their intrinsic one. */
+export declare const tileAspectRatio: (tile: F0MeetingTile, fallback: number) => number;
+
+export declare const tileKey: (participantId: string, kind: string) => string;
+
 /** A button rendered in the footer at the bottom of the table of contents */
 export declare type TOCAction = {
     label: string;
@@ -17125,6 +18341,26 @@ declare interface UseExportActionProps<R extends RecordType, Filters extends Fil
 /** Read the chat runtime. Throws when used outside an {@link F0ChatProvider}. */
 export declare function useF0Chat(): F0ChatRuntime;
 
+export declare const useF0Meeting: () => F0MeetingRuntime;
+
+export declare const useF0MeetingRoster: () => F0MeetingRoster;
+
+export declare const useF0MeetingStable: () => F0MeetingStable;
+
+/**
+ * Whether there is a call at all.
+ *
+ * The providers render with or without one (see {@link F0Meeting}), so being
+ * inside them does NOT imply a live runtime and the three hooks below still
+ * throw. Ask this first from anywhere that can outlive the call.
+ *
+ * Which is not a rare corner: anything the HOST mounts — panel content, a slot,
+ * its own chrome — is removed by an effect, a commit after the runtime went
+ * null. That one render is enough to take the page down, and it is exactly what
+ * hanging up out of `panel` mode used to do.
+ */
+export declare const useHasF0Meeting: () => boolean;
+
 export declare const useInfiniteScrollPagination: (paginationInfo: PaginationInfo | null, isLoading: boolean, isLoadingMore: boolean, loadMore: () => void) => {
     loadingIndicatorRef: RefObject<HTMLTableCellElement>;
 };
@@ -17136,6 +18372,34 @@ export declare const useInfiniteScrollPagination: (paginationInfo: PaginationInf
  */
 export declare const useIsBulkChange: (count: number, threshold?: number) => boolean;
 
+/**
+ * Subscribes to one participant's volatile signals. Call it as deep in the tree
+ * as possible — ideally in the leaf that draws the waveform — so an audio burst
+ * repaints a handful of bars instead of the whole tile.
+ *
+ * With a `selector` the component re-renders only when the SELECTED value
+ * changes: the quality bars can watch `quality` and sit out every audio level.
+ * `isEqual` defaults to `Object.is`, which is all a primitive needs.
+ *
+ * When the host provides no signal store the hook returns a frozen default, so
+ * the room degrades to muted flags with no waveform instead of breaking.
+ */
+export declare function useMeetingSignal(participantId: string): F0MeetingSignal;
+
+export declare function useMeetingSignal<T>(participantId: string, selector: (signal: F0MeetingSignal) => T, isEqual?: (previous: T, next: T) => boolean): T;
+
+/** The set of currently speaking participants, for the layout's ordering. */
+export declare const useMeetingSpeakers: () => readonly string[];
+
+export declare const useMeetingSurface: () => MeetingSurfaceContextValue;
+
+/**
+ * The same state, for consumers that render whether or not a call exists — the
+ * application frame reads this to decide how much width to reserve, and there
+ * is no provider at all when `runtime` is null.
+ */
+export declare const useMeetingSurfaceOptional: () => MeetingSurfaceContextValue | null;
+
 /**
  * Converts an item-navigation result into the `NavigationProps` shape that
  * `PageHeader` and `F0Dialog` accept (directly or via
@@ -17207,6 +18471,18 @@ export declare const useSidebarChats: () => SidebarChatStore;
  */
 export declare function useSidePanel(): SidePanelContextValue;
 
+/**
+ * Attaches a track to a media element F0 owns.
+ *
+ * The effect depends on `bindingKey` and on WHETHER there is a binding — never
+ * on the function's identity. Hosts rebuild the runtime, and with it every
+ * `binding` closure, on each transport event, so depending on identity would
+ * detach and re-attach the element around twenty times a second, black-flashing
+ * the video continuously. The presence flag is what lets a binding that arrives
+ * a commit after its key (a stream that opened late) still get attached.
+ */
+export declare const useTrackBinding: <T extends HTMLMediaElement>(track: F0MeetingTrack | undefined) => React.RefObject<T>;
+
 export declare const useWidgetIsWide: () => boolean;
 
 /**
@@ -17354,6 +18630,11 @@ declare interface VideoPlayerContent {
     descriptions?: Localized<string>;
 }
 
+declare type Viewport = {
+    width: number;
+    height: number;
+};
+
 /**
  * Region of the canvas (in screen px) covered by external chrome — typically a
  * side panel / drawer opened over the graph. All fly-to paths shift their target
@@ -17372,6 +18653,9 @@ export declare interface ViewportInset {
     left?: number;
 }
 
+/** The whole viewport as a rect, for hosts that publish no content area. */
+export declare const viewportRect: (viewport: Viewport) => F0Rect;
+
 /**
  * @experimental This is an experimental component use it at your own risk
  */