@factorialco/f0-react 6.25.0 → 6.27.0

package/dist/experimental.d.ts

@@ -31,7 +31,8 @@ import { CountryCellValue } from './types/country';
 import { DateCellValue } from './types/date';
 import { DateCellValue as DateCellValue_2 } from './experimental';
 import { DateFilterOptions } from './DateFilter/DateFilter';
-import { default as default_2 } from 'react';
+import { default as default_2 } from 'maplibre-gl';
+import { default as default_3 } from 'react';
 import { DeltaCellValue } from './types/delta';
 import { Dispatch } from 'react';
 import { DotTagCellValue } from './types/dotTag';
@@ -97,6 +98,7 @@ import { ScrollAreaProps } from '@radix-ui/react-scroll-area';
 import { SearchFilterOptions } from './SearchFilter/SearchFilter';
 import { StatusCellValue } from './types/status';
 import { StatusCellValue as StatusCellValue_2 } from './experimental';
+import { StyleSpecification } from 'maplibre-gl';
 import { SummaryCellValue } from './types/summary';
 import { SVGProps } from 'react';
 import { TagAlertProps } from './experimental';
@@ -381,8 +383,8 @@ declare const actionVariants: readonly ["default", "outline", "critical", "neutr
 /**
  * @experimental This is an experimental component use it at your own risk
  */
-export declare const ActivityItemList: (({ items, loadingMoreItems, onClickItem, onEndReached, onEndReachedItemsThreshold, }: ActivityItemListProps) => default_2.JSX.Element) & {
-    Skeleton: () => default_2.JSX.Element;
+export declare const ActivityItemList: (({ items, loadingMoreItems, onClickItem, onEndReached, onEndReachedItemsThreshold, }: ActivityItemListProps) => default_3.JSX.Element) & {
+    Skeleton: () => default_3.JSX.Element;
 };
 
 export declare type ActivityItemListProps = Pick<SectionProps, "items" | "onClickItem"> & {
@@ -391,7 +393,7 @@ export declare type ActivityItemListProps = Pick<SectionProps, "items" | "onClic
     loadingMoreItems?: boolean;
 };
 
-export declare const ActivityItemListSkeleton: () => default_2.JSX.Element;
+export declare const ActivityItemListSkeleton: () => default_3.JSX.Element;
 
 declare type ActivityItemProps = {
     id: string;
@@ -987,7 +989,7 @@ chart: BarChartProps;
 
 declare type BaseAction = Pick<F0ButtonProps, "label" | "onClick" | "icon" | "disabled">;
 
-export declare const BaseActivityItemList: ({ items, loadingMoreItems, onClickItem, onEndReached, onEndReachedItemsThreshold, }: ActivityItemListProps) => default_2.JSX.Element;
+export declare const BaseActivityItemList: ({ items, loadingMoreItems, onClickItem, onEndReached, onEndReachedItemsThreshold, }: ActivityItemListProps) => default_3.JSX.Element;
 
 declare const BaseAvatar: ForwardRefExoticComponent<BaseAvatarProps & RefAttributes<HTMLDivElement>>;
 
@@ -1161,6 +1163,8 @@ declare interface BaseHeaderProps_2 {
     onClose?: () => void;
 }
 
+declare type BaseMapMarkerColor = (typeof markerColors)[number];
+
 /**
  * Represents a base structure for paginated API responses, providing
  * details about the records on the current page and pagination metadata.
@@ -1850,22 +1854,22 @@ declare type CardPropertyDefinition<T> = PropertyDefinition_2<T> & {
 };
 
 declare const cardPropertyRenderers: {
-    readonly text: (args: TextCellValue_2, meta: ValueDisplayRendererContext_2) => default_2.JSX.Element;
-    readonly number: (args: NumberCellValue_2, meta: ValueDisplayRendererContext_2) => default_2.JSX.Element;
-    readonly date: (args: DateCellValue_2, meta: ValueDisplayRendererContext_2) => default_2.JSX.Element;
-    readonly amount: (args: AmountCellValue_2, meta: ValueDisplayRendererContext_2) => default_2.JSX.Element;
-    readonly person: (args: PersonCellValue_2, meta: ValueDisplayRendererContext_2) => default_2.JSX.Element;
-    readonly company: (args: CompanyCellValue_2, meta: ValueDisplayRendererContext_2) => default_2.JSX.Element;
-    readonly team: (args: TeamCellValue_2, meta: ValueDisplayRendererContext_2) => default_2.JSX.Element;
-    readonly status: (args: StatusCellValue_2) => default_2.JSX.Element;
-    readonly tag: (args: TagCellValue_2) => default_2.JSX.Element;
-    readonly avatarList: (args: AvatarListCellValue_2, meta: ValueDisplayRendererContext_2) => default_2.JSX.Element;
-    readonly tagList: (args: TagListCellValue_2) => default_2.JSX.Element;
-    readonly alertTag: (args: AlertTagCellValue_2) => default_2.JSX.Element;
-    readonly dotTag: (args: DotTagCellValue_2) => default_2.JSX.Element;
-    readonly file: (args: FileCellValue_2) => default_2.JSX.Element;
-    readonly folder: (args: FolderCellValue_2) => default_2.JSX.Element;
-    readonly progressBar: (args: ProgressBarCellValue_2, _meta: ValueDisplayRendererContext_2) => default_2.JSX.Element | null;
+    readonly text: (args: TextCellValue_2, meta: ValueDisplayRendererContext_2) => default_3.JSX.Element;
+    readonly number: (args: NumberCellValue_2, meta: ValueDisplayRendererContext_2) => default_3.JSX.Element;
+    readonly date: (args: DateCellValue_2, meta: ValueDisplayRendererContext_2) => default_3.JSX.Element;
+    readonly amount: (args: AmountCellValue_2, meta: ValueDisplayRendererContext_2) => default_3.JSX.Element;
+    readonly person: (args: PersonCellValue_2, meta: ValueDisplayRendererContext_2) => default_3.JSX.Element;
+    readonly company: (args: CompanyCellValue_2, meta: ValueDisplayRendererContext_2) => default_3.JSX.Element;
+    readonly team: (args: TeamCellValue_2, meta: ValueDisplayRendererContext_2) => default_3.JSX.Element;
+    readonly status: (args: StatusCellValue_2) => default_3.JSX.Element;
+    readonly tag: (args: TagCellValue_2) => default_3.JSX.Element;
+    readonly avatarList: (args: AvatarListCellValue_2, meta: ValueDisplayRendererContext_2) => default_3.JSX.Element;
+    readonly tagList: (args: TagListCellValue_2) => default_3.JSX.Element;
+    readonly alertTag: (args: AlertTagCellValue_2) => default_3.JSX.Element;
+    readonly dotTag: (args: DotTagCellValue_2) => default_3.JSX.Element;
+    readonly file: (args: FileCellValue_2) => default_3.JSX.Element;
+    readonly folder: (args: FolderCellValue_2) => default_3.JSX.Element;
+    readonly progressBar: (args: ProgressBarCellValue_2, _meta: ValueDisplayRendererContext_2) => default_3.JSX.Element | null;
 };
 
 declare type CardPropertyType = keyof typeof cardPropertyRenderers;
@@ -1979,7 +1983,7 @@ declare type CardVisualizationOptions<T, _Filters extends FiltersDefinition, _So
 /**
  * @experimental This is an experimental component use it at your own risk
  */
-export declare const Carousel: WithDataTestIdReturnType_3<({ children, columns, showArrows, showDots, autoplay, delay, showPeek, doubleColumns, }: CarouselProps) => default_2.JSX.Element>;
+export declare const Carousel: WithDataTestIdReturnType_3<({ children, columns, showArrows, showDots, autoplay, delay, showPeek, doubleColumns, }: CarouselProps) => default_3.JSX.Element>;
 
 declare interface CarouselBreakpoints {
     default?: ColumnNumber;
@@ -1991,7 +1995,7 @@ declare interface CarouselBreakpoints {
 }
 
 declare interface CarouselProps {
-    children: default_2.ReactNode;
+    children: default_3.ReactNode;
     showArrows?: boolean;
     showDots?: boolean;
     autoplay?: boolean;
@@ -3119,7 +3123,7 @@ declare type DataCollectionSettings = {
 };
 
 declare interface DataCollectionSettingsContextType {
-    setSettings: default_2.Dispatch<default_2.SetStateAction<DataCollectionSettings>>;
+    setSettings: default_3.Dispatch<default_3.SetStateAction<DataCollectionSettings>>;
     settings: DataCollectionSettings;
     setVisualizationSettings: (key: keyof VisualizationSettings, settings: VisualizationSettings[keyof VisualizationSettings] | ((prev: VisualizationSettings[keyof VisualizationSettings]) => VisualizationSettings[keyof VisualizationSettings])) => void;
 }
@@ -4711,6 +4715,25 @@ declare const defaultTranslations: {
             readonly navigation: "Graph navigation";
         };
     };
+    readonly map: {
+        readonly region: "Map";
+        readonly navigation: "Map navigation";
+        readonly listLabel: "Locations";
+        readonly location: "location";
+        readonly locations: "locations";
+        readonly unnamedLocation: "Location";
+        readonly cluster: "Cluster of {{count}} locations";
+        readonly skipToList: "Skip to location list";
+        readonly loadError: "Couldn't load the map.";
+        readonly retry: "Retry";
+        readonly currentLocation: "Your location";
+        readonly controls: {
+            readonly zoomIn: "Zoom in";
+            readonly zoomOut: "Zoom out";
+            readonly fit: "Fit to markers";
+            readonly locate: "My location";
+        };
+    };
     readonly wizard: {
         readonly previous: "Previous";
         readonly next: "Continue";
@@ -4824,7 +4847,7 @@ export declare type DetailsItemContent = (ComponentProps<typeof DataList.Item> &
 /**
  * @experimental This is an experimental component use it at your own risk
  */
-export declare const DetailsItemsList: default_2.ForwardRefExoticComponent<DetailsItemsListProps & default_2.RefAttributes<HTMLDivElement>>;
+export declare const DetailsItemsList: default_3.ForwardRefExoticComponent<DetailsItemsListProps & default_3.RefAttributes<HTMLDivElement>>;
 
 declare interface DetailsItemsListProps extends WithDataTestIdProps {
     title?: string;
@@ -4890,7 +4913,7 @@ declare type DropdownInternalProps = {
     items: DropdownItem[];
     icon?: IconType;
     size?: F0ButtonProps["size"];
-    children?: default_2.ReactNode;
+    children?: default_3.ReactNode;
     align?: "start" | "end" | "center";
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
@@ -6669,6 +6692,320 @@ declare type F0LinkProps = Omit<ActionLinkProps, "variant" | "href"> & {
     href?: string;
 };
 
+export declare const F0Map: ForwardRefExoticComponent<F0MapProps & RefAttributes<F0MapHandle>>;
+
+/**
+ * An arc: a curved connection between two coordinates (the flight-path /
+ * connection look). `F0Map` computes the curve; you give the endpoints.
+ */
+export declare interface F0MapArc extends F0MapLineStyle {
+    id: string;
+    /** `[lng, lat]` origin. */
+    from: [number, number];
+    /** `[lng, lat]` destination. */
+    to: [number, number];
+    /** Bow height as a fraction of the endpoint distance. Defaults to `0.3`. */
+    curvature?: number;
+}
+
+export declare type F0MapControlLabels = {
+    zoomIn?: string;
+    zoomOut?: string;
+    fit?: string;
+    locate?: string;
+};
+
+/**
+ * The map's navigation toolbar - locate, fit, zoom in/out - as a vertical stack
+ * of outline icon buttons. Presentational and engine-free: F0Map wires the
+ * callbacks to the MapLibre instance and positions this overlay. Mirrors
+ * F0GraphControls so the two spatial patterns share one control language.
+ */
+export declare const F0MapControls: ForwardRefExoticComponent<F0MapControlsProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface F0MapControlsProps extends WithDataTestIdProps {
+    /** Callback to zoom in. */
+    onZoomIn?: () => void;
+    /** Callback to zoom out. */
+    onZoomOut?: () => void;
+    /**
+     * Fit all markers in view. When omitted (e.g. no markers), the button is
+     * hidden.
+     */
+    onFit?: () => void;
+    /**
+     * Recenter on the user's location. When provided, a "locate" button renders
+     * as the first control; omit it (e.g. no geolocation) for a clean toolbar.
+     */
+    onLocate?: () => void;
+    /** Override the i18n control labels (tooltips / accessible names). */
+    labels?: F0MapControlLabels;
+}
+
+/** Imperative handle exposed via `ref`. */
+export declare interface F0MapHandle {
+    /** The raw MapLibre instance (escape hatch). `null` until the map has mounted. */
+    getMap: () => default_2.Map | null;
+    /** Center on a marker (and select it). Always animates unless reduced-motion. */
+    focusMarker: (id: string) => void;
+    /** Frame all markers in view. */
+    fitToMarkers: () => void;
+    /** Clear the current selection. */
+    clearSelection: () => void;
+}
+
+/**
+ * Palette hue for a drawn line (route or arc). Reuses the marker categorical
+ * palette so lines and pins share one set of on-brand colors.
+ */
+export declare type F0MapLineColor = BaseMapMarkerColor;
+
+/** Styling shared by both line kinds (routes and arcs). */
+export declare interface F0MapLineStyle {
+    /** Palette hue. Defaults to `radical`. Ignored when `color` is set. */
+    variant?: F0MapLineColor;
+    /** Escape-hatch CSS color string; overrides `variant`. */
+    color?: string;
+    /** Line width in px. Defaults to `3`. */
+    width?: number;
+    /** Render as a dashed line. Defaults to `false`. */
+    dashed?: boolean;
+    /** Line opacity, `0`-`1`. Defaults to `1`. */
+    opacity?: number;
+}
+
+/**
+ * The map's markers as a real, operable HTML list - the conformant text
+ * alternative to the WebGL canvas (which is opaque to assistive tech) and the
+ * visible fallback when the map can't render. Screen-reader and keyboard users
+ * drive the map through this: activating an item selects that marker (F0Map
+ * flies to it). Kept in sync with the map by rendering from the same `points`.
+ */
+export declare const F0MapList: ForwardRefExoticComponent<F0MapListProps & RefAttributes<HTMLElement>>;
+
+export declare interface F0MapListProps extends WithDataTestIdProps {
+    points: F0MapPoint[];
+    selectedId: string | null;
+    onSelect: (id: string) => void;
+    /**
+     * Render visibly (the WebGL/tile-error fallback). Otherwise the list is
+     * screen-reader-only - present in the DOM and operable, but not shown.
+     */
+    visible?: boolean;
+    /** Accessible name for the list landmark (and heading when visible). */
+    label?: string;
+    /** Anchor id, so a "skip to list" link can move focus here. */
+    id?: string;
+    /** Extra classes for the list container (e.g. when rendered as a fallback). */
+    className?: string;
+}
+
+export declare type F0MapMarkerVariant = (typeof f0MapMarkerVariants)[number];
+
+/**
+ * The data each semantic variant needs. Appearance is fixed by the variant:
+ *  - `default`: a plain pin, no icon or avatar (the generic marker).
+ *  - `workplace`: a building glyph on a fixed brand hue (all sites match).
+ *  - `employee` / `company`: an avatar whose color is its own identity color
+ *    (grey when a photo replaces the colored chip).
+ *  - `stop`: a route stop - a single letter (A, B, C...) on the same fixed
+ *    hue as the route/arc lines it punctuates.
+ */
+export declare type F0MapMarkerVariantProps = {
+    variant: "default";
+} | {
+    variant: "workplace";
+} | {
+    variant: "employee";
+    firstName: string;
+    lastName: string;
+    src?: string;
+} | {
+    variant: "company";
+    name: string;
+    src?: string;
+} | {
+    variant: "stop";
+    letter: string;
+};
+
+/**
+ * Product-semantic marker variants. Unlike the internal `BaseMapMarker` engine
+ * (which exposes every knob), each of these fixes its own color and rendering
+ * so a given concept looks and behaves the same everywhere on the map. Callers
+ * pick a variant and pass only its data.
+ */
+export declare const f0MapMarkerVariants: readonly ["default", "workplace", "employee", "company", "stop"];
+
+/**
+ * A point on the map: its coordinate plus the semantic marker variant and its
+ * data. `F0Map` owns everything about how the marker looks and behaves - color,
+ * size, label placement (collision-aware), selection and the pin indicator - so
+ * a map's markers stay uniform. Callers pick a variant and pass its data.
+ */
+export declare type F0MapPoint = {
+    id: string;
+    /** `[longitude, latitude]`. */
+    coordinates: [number, number];
+    label?: string;
+} & F0MapMarkerVariantProps;
+
+/**
+ * Map projection. `"globe"` renders the world as a 3D sphere (adaptive: it
+ * eases into a flat mercator view as you zoom in).
+ */
+export declare type F0MapProjection = "mercator" | "globe";
+
+export declare interface F0MapProps extends WithDataTestIdProps {
+    /**
+     * Points to render as markers. Pass a referentially stable array (memoize
+     * it): a new identity per render re-binds the clustering and label-collision
+     * listeners. Markers are DOM elements - keep counts at workplace scale
+     * (~200); beyond that pan/zoom degrades and a warning is logged.
+     */
+    markers?: F0MapPoint[];
+    /**
+     * Polylines drawn through their given coordinates, exactly as provided (no
+     * routing is computed - pass server-side / routing-engine output). Rendered
+     * as GL lines beneath the markers.
+     */
+    routes?: F0MapRoute[];
+    /**
+     * Curved connections between two coordinates (the flight-path look). `F0Map`
+     * computes the curve from each arc's `from` / `to`.
+     */
+    arcs?: F0MapArc[];
+    /** Fired when a route line is clicked. Providing it enables hover + click. */
+    onRouteClick?: (id: string) => void;
+    /** Fired when an arc line is clicked. Providing it enables hover + click. */
+    onArcClick?: (id: string) => void;
+    /** Controlled selected marker id. */
+    selectedMarkerId?: string | null;
+    /** Uncontrolled initial selection. */
+    defaultSelectedMarkerId?: string | null;
+    /** Fired when the selection changes (marker click or background click). */
+    onMarkerSelect?: (id: string | null) => void;
+    /**
+     * Emphasise a marker without selecting it - a separate channel for an
+     * external search/reveal. The highlighted marker floats above the rest, keeps
+     * its label, and the map flies to it when the id changes. Selection (the
+     * grown pin) stays driven by `selectedMarkerId`.
+     */
+    highlightedId?: string | null;
+    /**
+     * Frame all markers on load. Defaults to `true` when no `initialViewport` is
+     * given, `false` otherwise (an explicit viewport wins).
+     */
+    fitToMarkers?: boolean;
+    /** Initial camera. Defaults to a city-level view. Read once on mount. */
+    initialViewport?: F0MapViewport;
+    /** Light/dark style pair. Defaults to the f0-themed OpenFreeMap styles. */
+    mapStyle?: F0MapStylePair;
+    /**
+     * Allow pan/zoom. Defaults to `true`. Read on mount: changing it recreates
+     * the map (and resets the camera), so treat it as static.
+     */
+    interactive?: boolean;
+    /**
+     * Scroll/touch behaviour. `"cooperative"` (default) lets a plain wheel scroll
+     * the page and requires Ctrl/⌘ + wheel (or two fingers) to zoom, so an
+     * embedded map never traps the page scroll. `"greedy"` zooms on any wheel.
+     * Read on mount, like `interactive`.
+     */
+    gestureHandling?: "cooperative" | "greedy";
+    /**
+     * Farthest the user can zoom out. Fitted to the viewport when omitted.
+     * Read on mount, like `interactive`.
+     */
+    minZoom?: number;
+    /** Closest the user can zoom in. Defaults to `18`. Read on mount. */
+    maxZoom?: number;
+    /**
+     * Show the navigation controls (locate, fit, zoom). Defaults to `true`; only
+     * rendered when the map is `interactive`.
+     */
+    showControls?: boolean;
+    /** Override the controls' labels (tooltips / accessible names). */
+    controlLabels?: F0MapControlLabels;
+    /**
+     * Enable the current-location feature. Defaults to `false`, in which case the
+     * map never touches geolocation. When `true`, the dot auto-shows only if the
+     * browser permission is *already* granted (never prompting on load); the
+     * "locate me" control is the only thing that requests permission on demand.
+     */
+    showCurrentLocation?: boolean;
+    /**
+     * Edge-to-edge presentation. `false` (default) frames the map as a card -
+     * large rounded corners, a secondary border, and controls inset 16px. `true`
+     * drops the frame so the map bleeds to its container's edges, with controls
+     * inset 24px.
+     */
+    fullScreen?: boolean;
+    /**
+     * Map projection. `"mercator"` (default) is the flat web map; `"globe"`
+     * renders the world as a 3D sphere at low zoom and eases into mercator as you
+     * zoom in - best for a world-scale view. Changing it re-projects live.
+     */
+    projection?: F0MapProjection;
+    /** Show the skeleton instead of the map. */
+    loading?: boolean;
+    /** Accessible label for the map region. */
+    ariaLabel?: string;
+    /** @private */
+    className?: string;
+}
+
+/**
+ * A route: a polyline drawn through the given coordinates exactly as provided.
+ * `F0Map` renders the path; it does not compute routing - fetch that
+ * server-side (or from a routing engine) and pass the resulting vertices.
+ */
+export declare interface F0MapRoute extends F0MapLineStyle {
+    id: string;
+    /** Ordered `[lng, lat]` vertices the line passes through. */
+    coordinates: [number, number][];
+}
+
+/**
+ * Loading placeholder: a plain pulsing surface in the shared `Skeleton`
+ * component's tone. Shown while a consumer is still fetching what the map
+ * should display; the map paints its own basemap once mounted, so this needs
+ * no map-like illustration.
+ */
+export declare const F0MapSkeleton: ({ dataTestId, className, }: F0MapSkeletonProps) => JSX_2.Element;
+
+export declare interface F0MapSkeletonProps extends WithDataTestIdProps {
+    /** @private */
+    className?: string;
+}
+
+/**
+ * A light/dark pair of MapLibre styles. Each entry is either a hosted style
+ * URL or an inline `StyleSpecification`.
+ */
+export declare interface F0MapStylePair {
+    light: string | StyleSpecification;
+    dark: string | StyleSpecification;
+}
+
+/**
+ * f0-themed MapLibre styles over keyless OpenFreeMap vector tiles.
+ *
+ * Generated by `styles/buildStyles.mjs` from the OpenFreeMap Bright style: every
+ * layer color is remapped to the nearest f0 token (CIEDE2000) and muted, then
+ * resolved to concrete hex for the light and dark neutral ramps. Regenerate with
+ * `node src/patterns/F0Map/styles/buildStyles.mjs`.
+ */
+export declare const f0MapStyles: F0MapStylePair;
+
+/** Initial camera position for the map. */
+export declare interface F0MapViewport {
+    /** `[longitude, latitude]`. */
+    center: [number, number];
+    /** Zoom level (`0` world, higher = closer). Defaults to a city-level view. */
+    zoom?: number;
+}
+
 /**
  * @experimental This is an experimental component, use it at your own risk.
  */
@@ -9059,6 +9396,8 @@ declare interface LocalizedOption<T> {
     value: T;
 }
 
+declare const markerColors: readonly ["neutral", "grey", "radical", "malibu", "viridian", "flubber", "grass", "camel", "indigo", "lilac", "orange", "purple", "yellow", "red", "army", "smoke", "barbie"];
+
 export declare const MAX_EXPANDED_ACTIONS = 2;
 
 /**
@@ -9484,6 +9823,30 @@ export declare interface NewHomeLayoutProps {
      * dragging and the add placeholder; the others stay put. Both by default.
      */
     editableWidgetContainers?: WidgetContainerSide[];
+    /**
+     * Which containers keep ONLY THE WIDGETS YOU CAN SEE in the DOM. None by
+     * default: for a Home of a dozen widgets, mounting them all is what keeps a
+     * card's data, clock and animation alive across everything this layout does to
+     * it, and virtualizing would trade that away for nothing.
+     *
+     * Name a side once its widgets can outnumber a screen — a hundred cards is a
+     * hundred fetches and a hundred charts, and all but the three in view are work
+     * nobody asked for. Below `virtualization.threshold` widgets (12 by default) the
+     * column still renders them all, so naming a side here is a CEILING rather than
+     * a switch. What it costs is on `WidgetVirtualization`; in short, a widget that
+     * scrolls out is unmounted and comes back new, and only the cards in view get
+     * out of a dragged one's way.
+     *
+     * STACKED (below `md`) the rail's widgets belong to the main column, so "main"
+     * is what virtualizes them there.
+     */
+    virtualizedWidgetContainers?: WidgetContainerSide[];
+    /**
+     * Tuning for the above — the height a card is guessed at before it is measured,
+     * how many are kept past each edge, and the count it starts at. The scroll
+     * region is this layout's own, per side, and is not yours to set.
+     */
+    virtualization?: Omit<WidgetVirtualization, "scrollElement">;
     /**
      * Called with a widget id when its "Remove widget" menu item is used — the
      * three-dots menu in the widget's own header.
@@ -10112,8 +10475,8 @@ declare interface OnePaginationProps {
 /**
  * @experimental This is an experimental component use it at your own risk
  */
-export declare const OnePersonListItem: WithDataTestIdReturnType_3<default_2.ForwardRefExoticComponent<OnePersonListItemProps & default_2.RefAttributes<HTMLDivElement>> & {
-Skeleton: () => default_2.JSX.Element;
+export declare const OnePersonListItem: WithDataTestIdReturnType_3<default_3.ForwardRefExoticComponent<OnePersonListItemProps & default_3.RefAttributes<HTMLDivElement>> & {
+Skeleton: () => default_3.JSX.Element;
 }>;
 
 export declare type OnePersonListItemProps = {
@@ -12292,10 +12655,10 @@ export declare const ToggleGroupItem: React_2.ForwardRefExoticComponent<Omit<Tog
 /**
  * @experimental This is an experimental component use it at your own risk
  */
-export declare const Tooltip: WithDataTestIdReturnType_3<(props: TooltipProps) => default_2.JSX.Element>;
+export declare const Tooltip: WithDataTestIdReturnType_3<(props: TooltipProps) => default_3.JSX.Element>;
 
 declare type TooltipInternalProps = {
-    children: default_2.ReactNode;
+    children: default_3.ReactNode;
     shortcut?: ComponentProps<typeof Shortcut>["keys"];
     delay?: number;
     instant?: boolean;
@@ -12902,7 +13265,7 @@ export declare interface ViewportInset {
 /**
  * @experimental This is an experimental component use it at your own risk
  */
-export declare const VirtualList: default_2.ForwardRefExoticComponent<VirtualListProps & default_2.RefAttributes<HTMLDivElement>>;
+export declare const VirtualList: default_3.ForwardRefExoticComponent<VirtualListProps & default_3.RefAttributes<HTMLDivElement>>;
 
 declare type VirtualListProps = {
     height: number;
@@ -13078,10 +13441,10 @@ declare type WelcomeSuggestionClickEvent = {
 /**
  * @experimental This is an experimental component use it at your own risk
  */
-export declare const Widget: WithDataTestIdReturnType_3<default_2.ForwardRefExoticComponent<WidgetProps & {
+export declare const Widget: WithDataTestIdReturnType_3<default_3.ForwardRefExoticComponent<WidgetProps & {
 children: ReactNode;
-} & default_2.RefAttributes<HTMLDivElement>> & {
-Skeleton: default_2.ForwardRefExoticComponent<WidgetSkeletonProps & default_2.RefAttributes<HTMLDivElement>>;
+} & default_3.RefAttributes<HTMLDivElement>> & {
+Skeleton: default_3.ForwardRefExoticComponent<WidgetSkeletonProps & default_3.RefAttributes<HTMLDivElement>>;
 }>;
 
 export declare function WidgetAvatarsListItem({ id, title, subtitle, avatars, remainingCount, withPointerCursor, onClick, ...props }: WidgetAvatarsListItemProps): JSX_2.Element;
@@ -13363,6 +13726,45 @@ export declare const widgetTitle: (widget: {
     params?: WidgetParams;
 }) => string;
 
+/**
+ * VIRTUALIZATION — what a column does when it has more widgets than a screen.
+ *
+ * A widget is not a row: it is a card with its own data, its own chart, its own
+ * list of rows inside it. A hundred of them mounted is a hundred fetches, a
+ * hundred charts laid out and a DOM the browser spends every frame on, and all
+ * but the three you can see are work nobody asked for. So a virtualized column
+ * mounts ONLY the widgets in view (plus `overscan` past each edge) and holds the
+ * space of the rest open, so the scrollbar still describes the whole column.
+ *
+ * WHAT IT COSTS, and why it is opt-in rather than the default:
+ *
+ * - A widget that scrolls out is UNMOUNTED. Whatever it had loaded, timed or
+ *   animated is gone, and it starts again when it comes back — the opposite of
+ *   what the collapsed rail is built to guarantee. For a column of a few widgets
+ *   that trade is a bad one, which is what `threshold` is for.
+ * - Dragging still reorders correctly, but only the widgets that are MOUNTED
+ *   shuffle out of the way as you go: dnd-kit can't move a card that isn't
+ *   there. The dragged card itself is pinned into the DOM for the whole gesture.
+ * - `fullHeight` means nothing here. A virtualized column's height is the sum of
+ *   its cards, so there is no column height for a card to fill.
+ */
+export declare interface WidgetVirtualization {
+    /**
+     * Below this many widgets the column simply renders them all. Defaults to 12.
+     */
+    threshold?: number;
+    /** First guess at a card's height in px, before it is measured. */
+    estimateHeight?: number;
+    /** How many cards stay mounted past each edge of the viewport. */
+    overscan?: number;
+    /**
+     * The scroll region to virtualize against. Defaults to the column's nearest
+     * scrollable ancestor — pass it when you already have the element (it saves
+     * the walk, and it is exact).
+     */
+    scrollElement?: HTMLElement | null;
+}
+
 declare type WidgetWidth = "sm" | "md" | "lg";
 
 declare interface WiggleOptions {
@@ -13535,10 +13937,8 @@ declare module "@tiptap/core" {
 
 declare module "@tiptap/core" {
     interface Commands<ReturnType> {
-        indent: {
-            setIndent: (level: number) => ReturnType;
-            unsetIndent: () => ReturnType;
-            outdent: () => ReturnType;
+        moodTracker: {
+            insertMoodTracker: (data: MoodTrackerData) => ReturnType;
         };
     }
 }
@@ -13546,8 +13946,10 @@ declare module "@tiptap/core" {
 
 declare module "@tiptap/core" {
     interface Commands<ReturnType> {
-        moodTracker: {
-            insertMoodTracker: (data: MoodTrackerData) => ReturnType;
+        indent: {
+            setIndent: (level: number) => ReturnType;
+            unsetIndent: () => ReturnType;
+            outdent: () => ReturnType;
         };
     }
 }