Skip to main content
On this pageFunctions

Ui/VirtualList

Functions

create

functionsource
/** Creates a completed VirtualList Block refined to one item type. */
<Item>(): Completed<Item>

Types

InitConfig

typesource
/** Configuration for creating a virtual list model with `init`. */
type InitConfig = Readonly<{
  followEnd: Readonly<{
    thresholdPx: number
  }>
  id: string
  initialScroll: Readonly<{
    alignment: ScrollAlignment
    target: ScrollTarget
  }>
  initialScrollTop: number
  rowHeightPx: number
}>

RowHeightInputs

typesource
/**
 * Mutually exclusive configuration for fixed, exact variable, or measured
 *  dynamic row heights.
 */
type RowHeightInputs = Readonly<{
  dynamicRowHeights: undefined
  itemToEstimatedRowHeightPx: never
  itemToRowHeightPx: undefined
}> | Readonly<{
  dynamicRowHeights: true
  itemToEstimatedRowHeightPx: (item: Item, index: number) => number
  itemToRowHeightPx: never
}> | Readonly<{
  dynamicRowHeights: never
  itemToEstimatedRowHeightPx: never
  itemToRowHeightPx: (item: Item, index: number) => number
}>

ScrollToOptions

typesource
/** Options shared by row-targeted programmatic scrolling helpers. */
type ScrollToOptions = Readonly<{
  alignment: ScrollAlignment
}>

ViewInputs

typesource
type ViewInputs = BaseViewInputs<Item> & RowHeightInputs<Item>

Interfaces

Completed

interfacesource
/** A completed VirtualList Block refined to one item type. */
interface Completed {
  [CompletionTypeId]: true
  [DefaultViewTypeId]: OwnedAuthoredView<BlockView<{
    endBehavior: {
      _tag: "PreserveAnchor"
    } | {
      _tag: "Follow"
      thresholdPx: number
    }
    id: string
    initialScroll: {
      _tag: "Pending"
      alignment: "Start" | "End" | "Center" | "Nearest"
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "Applied"
    }
    layoutVersion: number
    measuredRowHeights: {}
    measurement: {
      _tag: "Unmeasured"
    } | {
      _tag: "Measured"
      containerHeight: number
      containerWidth: number
    }
    pendingScroll: {
      _tag: "Idle"
    } | {
      _tag: "Pending"
      request: {
        _tag: "Target"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Anchor"
        anchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }
      version: number
    }
    pendingScrollVersion: number
    rowHeightPx: number
    scrollTop: number
    viewportAnchor: {
      _tag: "End"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    } | {
      _tag: "Offset"
      scrollTop: number
    }
  }, {
    _tag: "RequestedScrollTo"
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    target: {
      _tag: "Key"
      key: string
    } | {
      _tag: "Offset"
      offset: number
    } | {
      _tag: "End"
    } | {
      _tag: "Index"
      index: number
    }
  } | {
    _tag: "RequestedScrollToIndex"
    index: number
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToKey"
    key: string
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToOffset"
    offset: number
  } | {
    _tag: "RequestedScrollToEnd"
  } | {
    _tag: "InformedOfItemsChange"
    itemKeys: readonly Array<string>
  } | {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "CompletedApplyScroll"
    outcome: {
      _tag: "Skipped"
    } | {
      _tag: "Applied"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }
    version: number
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }, AuthoredViewInputs<ViewInputs<Item>>, Handler<"VirtualList/ObserveVirtualList", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }> & {
    id: string
  }, {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }>>, Owner<"VirtualList", true>, {
    endBehavior: {
      _tag: "PreserveAnchor"
    } | {
      _tag: "Follow"
      thresholdPx: number
    }
    id: string
    initialScroll: {
      _tag: "Pending"
      alignment: "Start" | "End" | "Center" | "Nearest"
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "Applied"
    }
    layoutVersion: number
    measuredRowHeights: {}
    measurement: {
      _tag: "Unmeasured"
    } | {
      _tag: "Measured"
      containerHeight: number
      containerWidth: number
    }
    pendingScroll: {
      _tag: "Idle"
    } | {
      _tag: "Pending"
      request: {
        _tag: "Target"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Anchor"
        anchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }
      version: number
    }
    pendingScrollVersion: number
    rowHeightPx: number
    scrollTop: number
    viewportAnchor: {
      _tag: "End"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    } | {
      _tag: "Offset"
      scrollTop: number
    }
  }, {
    _tag: "RequestedScrollTo"
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    target: {
      _tag: "Key"
      key: string
    } | {
      _tag: "Offset"
      offset: number
    } | {
      _tag: "End"
    } | {
      _tag: "Index"
      index: number
    }
  } | {
    _tag: "RequestedScrollToIndex"
    index: number
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToKey"
    key: string
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToOffset"
    offset: number
  } | {
    _tag: "RequestedScrollToEnd"
  } | {
    _tag: "InformedOfItemsChange"
    itemKeys: readonly Array<string>
  } | {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "CompletedApplyScroll"
    outcome: {
      _tag: "Skipped"
    } | {
      _tag: "Applied"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }
    version: number
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }, Handler<"VirtualList/ObserveVirtualList", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }> & {
    id: string
  }, {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }>>
  bindings: readonly []
  EffectsLayer: CompleteEffectsLayer<Layer<Handler<"VirtualList/ApplyScroll", {
    id: string
    request: {
      _tag: "Target"
      alignment: "Start" | "End" | "Center" | "Nearest"
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "Anchor"
      anchor: {
        _tag: "End"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      } | {
        _tag: "Offset"
        scrollTop: number
      }
    }
    version: number
  }, {
    _tag: "CompletedApplyScroll"
    outcome: {
      _tag: "Skipped"
    } | {
      _tag: "Applied"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }
    version: number
  }> | Handler<"VirtualList/ObserveVirtualList", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }> & {
    id: string
  }, {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }>, never, never>, readonly []>
  hostHandlers: readonly []
  init: (args: [
    config: Readonly<{
      followEnd: Readonly<{
        thresholdPx: number
      }>
      id: string
      initialScroll: Readonly<{
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      }>
      initialScrollTop: number
      rowHeightPx: number
    }>
  ]) => Return<{
    endBehavior: {
      _tag: "PreserveAnchor"
    } | {
      _tag: "Follow"
      thresholdPx: number
    }
    id: string
    initialScroll: {
      _tag: "Pending"
      alignment: "Start" | "End" | "Center" | "Nearest"
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "Applied"
    }
    layoutVersion: number
    measuredRowHeights: {}
    measurement: {
      _tag: "Unmeasured"
    } | {
      _tag: "Measured"
      containerHeight: number
      containerWidth: number
    }
    pendingScroll: {
      _tag: "Idle"
    } | {
      _tag: "Pending"
      request: {
        _tag: "Target"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Anchor"
        anchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }
      version: number
    }
    pendingScrollVersion: number
    rowHeightPx: number
    scrollTop: number
    viewportAnchor: {
      _tag: "End"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    } | {
      _tag: "Offset"
      scrollTop: number
    }
  }, {
    _tag: "RequestedScrollTo"
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    target: {
      _tag: "Key"
      key: string
    } | {
      _tag: "Offset"
      offset: number
    } | {
      _tag: "End"
    } | {
      _tag: "Index"
      index: number
    }
  } | {
    _tag: "RequestedScrollToIndex"
    index: number
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToKey"
    key: string
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToOffset"
    offset: number
  } | {
    _tag: "RequestedScrollToEnd"
  } | {
    _tag: "InformedOfItemsChange"
    itemKeys: readonly Array<string>
  } | {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "CompletedApplyScroll"
    outcome: {
      _tag: "Skipped"
    } | {
      _tag: "Applied"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }
    version: number
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }, never>
  makeView: DefineView<Owner<"VirtualList", true>, {
    endBehavior: {
      _tag: "PreserveAnchor"
    } | {
      _tag: "Follow"
      thresholdPx: number
    }
    id: string
    initialScroll: {
      _tag: "Pending"
      alignment: "Start" | "End" | "Center" | "Nearest"
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "Applied"
    }
    layoutVersion: number
    measuredRowHeights: {}
    measurement: {
      _tag: "Unmeasured"
    } | {
      _tag: "Measured"
      containerHeight: number
      containerWidth: number
    }
    pendingScroll: {
      _tag: "Idle"
    } | {
      _tag: "Pending"
      request: {
        _tag: "Target"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Anchor"
        anchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }
      version: number
    }
    pendingScrollVersion: number
    rowHeightPx: number
    scrollTop: number
    viewportAnchor: {
      _tag: "End"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    } | {
      _tag: "Offset"
      scrollTop: number
    }
  }, {
    _tag: "RequestedScrollTo"
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    target: {
      _tag: "Key"
      key: string
    } | {
      _tag: "Offset"
      offset: number
    } | {
      _tag: "End"
    } | {
      _tag: "Index"
      index: number
    }
  } | {
    _tag: "RequestedScrollToIndex"
    index: number
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToKey"
    key: string
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToOffset"
    offset: number
  } | {
    _tag: "RequestedScrollToEnd"
  } | {
    _tag: "InformedOfItemsChange"
    itemKeys: readonly Array<string>
  } | {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "CompletedApplyScroll"
    outcome: {
      _tag: "Skipped"
    } | {
      _tag: "Applied"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }
    version: number
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }, Handler<"VirtualList/ObserveVirtualList", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }> & {
    id: string
  }, {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }>>
  managedResources: Readonly<Record<never, never>>
  Message: MessageUnion
  Model: Struct
  mounts: readonly Array<LayeredStreamMountDefinitionWithArgs<"VirtualList/ObserveVirtualList", {
    id: String
  }, {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }> & Readonly<{
    layer: Layer<Handler<"VirtualList/ObserveVirtualList", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown | unknown>
    }> & {
      id: string
    }, {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }>, never, never>
  }>>
  operations: ImplementationExposedOperations<ImplementationValue>
  OutMessage: MessageUnion
  provideHandlers: never
  replaceEffectsLayer: ReplaceEffectsLayer<Owner<"VirtualList", true>, Struct<{
    endBehavior: TaggedUnion<{
      Follow: {
        thresholdPx: Number
      }
      PreserveAnchor: {}
    }>
    id: String
    initialScroll: TaggedUnion<{
      Applied: {}
      Pending: {
        alignment: Literals<readonly ["Start", "Center", "End", "Nearest"]>
        target: TaggedUnion<{
          End: {}
          Index: {
            index: Number
          }
          Key: {
            key: String
          }
          Offset: {
            offset: Number
          }
        }>
      }
    }>
    layoutVersion: Number
    measuredRowHeights: $Record<String, Number>
    measurement: TaggedUnion<{
      Measured: {
        containerHeight: Number
        containerWidth: Number
      }
      Unmeasured: {}
    }>
    pendingScroll: TaggedUnion<{
      Idle: {}
      Pending: {
        request: TaggedUnion<{
          Anchor: {
            anchor: TaggedUnion<{
              End: unknown
              Offset: unknown
              Row: unknown
            }>
          }
          Target: {
            alignment: Literals<readonly [unknown, unknown, unknown, unknown]>
            target: TaggedUnion<{
              End: unknown
              Index: unknown
              Key: unknown
              Offset: unknown
            }>
          }
        }>
        version: Number
      }
    }>
    pendingScrollVersion: Number
    rowHeightPx: Number
    scrollTop: Number
    viewportAnchor: TaggedUnion<{
      End: {}
      Offset: {
        scrollTop: Number
      }
      Row: {
        index: Number
        key: String
        viewportOffset: Number
      }
    }>
  }>, MessageUnion<{
    CompletedApplyScroll: {
      outcome: TaggedUnion<{
        Applied: {
          anchor: TaggedUnion<{
            None: {}
            Row: {
              index: Number
              key: String
              viewportOffset: Number
            }
          }>
          containerHeight: Number
          scrollHeight: Number
          scrollTop: Number
        }
        Skipped: {}
      }>
      version: Number
    }
    InformedOfItemsChange: {
      itemKeys: $Array<String>
    }
    MeasuredRows: {
      measurements: $Array<Struct<{
        height: Number
        key: String
        layoutVersion: Number
      }>>
    }
    ObservedContainerScroll: {
      anchor: TaggedUnion<{
        None: {}
        Row: {
          index: Number
          key: String
          viewportOffset: Number
        }
      }>
      containerHeight: Number
      scrollHeight: Number
      scrollTop: Number
    }
    RequestedScrollTo: {
      maybeAlignment: Option<Literals<readonly ["Start", "Center", "End", "Nearest"]>>
      target: TaggedUnion<{
        End: {}
        Index: {
          index: Number
        }
        Key: {
          key: String
        }
        Offset: {
          offset: Number
        }
      }>
    }
    RequestedScrollToEnd: {}
    RequestedScrollToIndex: {
      index: Number
      maybeAlignment: Option<Literals<readonly ["Start", "Center", "End", "Nearest"]>>
    }
    RequestedScrollToKey: {
      key: String
      maybeAlignment: Option<Literals<readonly ["Start", "Center", "End", "Nearest"]>>
    }
    RequestedScrollToOffset: {
      offset: Number
    }
    ResizedContainer: {
      containerHeight: Number
      containerWidth: Number
    }
  }>, MessageUnion<{
    ObservedContainerScroll: {
      anchor: TaggedUnion<{
        None: {}
        Row: {
          index: Number
          key: String
          viewportOffset: Number
        }
      }>
      containerHeight: Number
      scrollHeight: Number
      scrollTop: Number
    }
  }>, Array<LayeredStreamMountDefinitionWithArgs<"VirtualList/ObserveVirtualList", {
    id: String
  }, {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }> & Readonly<{
    layer: Layer<Handler<"VirtualList/ObserveVirtualList", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown>
    }> & {
      id: string
    }, {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: unknown
        key: unknown
        layoutVersion: unknown
      }>
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: unknown
      } | {
        _tag: unknown
        index: unknown
        key: unknown
        viewportOffset: unknown
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }>, never, never>
  }>>, readonly [], Readonly<{
    EffectsLayer: Layer<Handler<"VirtualList/ApplyScroll", {
      id: string
      request: {
        _tag: "Target"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: unknown
          key: unknown
        } | {
          _tag: unknown
          offset: unknown
        } | {
          _tag: unknown
        } | {
          _tag: unknown
          index: unknown
        }
      } | {
        _tag: "Anchor"
        anchor: {
          _tag: unknown
        } | {
          _tag: unknown
          index: unknown
          key: unknown
          viewportOffset: unknown
        } | {
          _tag: unknown
          scrollTop: unknown
        }
      }
      version: number
    }, {
      _tag: "CompletedApplyScroll"
      outcome: {
        _tag: "Skipped"
      } | {
        _tag: "Applied"
        anchor: {
          _tag: unknown
        } | {
          _tag: unknown
          index: unknown
          key: unknown
          viewportOffset: unknown
        }
        containerHeight: number
        scrollHeight: number
        scrollTop: number
      }
      version: number
    }> | Handler<"VirtualList/ObserveVirtualList", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown | unknown>
    }> & {
      id: string
    }, {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }>, never, never>
    init: (args: [
      config: Readonly<{
        followEnd: Readonly<{
          thresholdPx: unknown | unknown
        }>
        id: string
        initialScroll: Readonly<{
          alignment: unknown | unknown | unknown | unknown | unknown
          target: unknown | unknown | unknown | unknown
        }>
        initialScrollTop: number
        rowHeightPx: number
      }>
    ]) => Return<{
      endBehavior: {
        _tag: "PreserveAnchor"
      } | {
        _tag: "Follow"
        thresholdPx: number
      }
      id: string
      initialScroll: {
        _tag: "Pending"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Applied"
      }
      layoutVersion: number
      measuredRowHeights: {}
      measurement: {
        _tag: "Unmeasured"
      } | {
        _tag: "Measured"
        containerHeight: number
        containerWidth: number
      }
      pendingScroll: {
        _tag: "Idle"
      } | {
        _tag: "Pending"
        request: {
          _tag: "Target"
          alignment: unknown | unknown | unknown | unknown
          target: unknown | unknown | unknown | unknown
        } | {
          _tag: "Anchor"
          anchor: unknown | unknown | unknown
        }
        version: number
      }
      pendingScrollVersion: number
      rowHeightPx: number
      scrollTop: number
      viewportAnchor: {
        _tag: "End"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      } | {
        _tag: "Offset"
        scrollTop: number
      }
    }, {
      _tag: "RequestedScrollTo"
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "RequestedScrollToIndex"
      index: number
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToKey"
      key: string
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToOffset"
      offset: number
    } | {
      _tag: "RequestedScrollToEnd"
    } | {
      _tag: "InformedOfItemsChange"
      itemKeys: readonly Array<string>
    } | {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "CompletedApplyScroll"
      outcome: {
        _tag: "Skipped"
      } | {
        _tag: "Applied"
        anchor: {
          _tag: unknown
        } | {
          _tag: unknown
          index: unknown
          key: unknown
          viewportOffset: unknown
        }
        containerHeight: number
        scrollHeight: number
        scrollTop: number
      }
      version: number
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }, never>
    operations: Readonly<{
      informItemsChanged: (model: {
        endBehavior: {
          _tag: "PreserveAnchor"
        } | {
          _tag: "Follow"
          thresholdPx: number
        }
        id: string
        initialScroll: {
          _tag: "Pending"
          alignment: "Start" | "End" | "Center" | "Nearest"
          target: {
            _tag: unknown
            key: unknown
          } | {
            _tag: unknown
            offset: unknown
          } | {
            _tag: unknown
          } | {
            _tag: unknown
            index: unknown
          }
        } | {
          _tag: "Applied"
        }
        layoutVersion: number
        measuredRowHeights: {}
        measurement: {
          _tag: "Unmeasured"
        } | {
          _tag: "Measured"
          containerHeight: number
          containerWidth: number
        }
        pendingScroll: {
          _tag: "Idle"
        } | {
          _tag: "Pending"
          request: {
            _tag: unknown
            alignment: unknown
            target: unknown
          } | {
            _tag: unknown
            anchor: unknown
          }
          version: number
        }
        pendingScrollVersion: number
        rowHeightPx: number
        scrollTop: number
        viewportAnchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }, args: [itemKeys: readonly Array<string>]) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
      requestScrollTo: (model: {
        endBehavior: {
          _tag: "PreserveAnchor"
        } | {
          _tag: "Follow"
          thresholdPx: number
        }
        id: string
        initialScroll: {
          _tag: "Pending"
          alignment: "Start" | "End" | "Center" | "Nearest"
          target: {
            _tag: unknown
            key: unknown
          } | {
            _tag: unknown
            offset: unknown
          } | {
            _tag: unknown
          } | {
            _tag: unknown
            index: unknown
          }
        } | {
          _tag: "Applied"
        }
        layoutVersion: number
        measuredRowHeights: {}
        measurement: {
          _tag: "Unmeasured"
        } | {
          _tag: "Measured"
          containerHeight: number
          containerWidth: number
        }
        pendingScroll: {
          _tag: "Idle"
        } | {
          _tag: "Pending"
          request: {
            _tag: unknown
            alignment: unknown
            target: unknown
          } | {
            _tag: unknown
            anchor: unknown
          }
          version: number
        }
        pendingScrollVersion: number
        rowHeightPx: number
        scrollTop: number
        viewportAnchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }, args: [
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        },
        options: Readonly<{
          alignment: unknown | unknown | unknown | unknown | unknown
        }>
      ]) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
      requestScrollToEnd: (model: {
        endBehavior: {
          _tag: "PreserveAnchor"
        } | {
          _tag: "Follow"
          thresholdPx: number
        }
        id: string
        initialScroll: {
          _tag: "Pending"
          alignment: "Start" | "End" | "Center" | "Nearest"
          target: {
            _tag: unknown
            key: unknown
          } | {
            _tag: unknown
            offset: unknown
          } | {
            _tag: unknown
          } | {
            _tag: unknown
            index: unknown
          }
        } | {
          _tag: "Applied"
        }
        layoutVersion: number
        measuredRowHeights: {}
        measurement: {
          _tag: "Unmeasured"
        } | {
          _tag: "Measured"
          containerHeight: number
          containerWidth: number
        }
        pendingScroll: {
          _tag: "Idle"
        } | {
          _tag: "Pending"
          request: {
            _tag: unknown
            alignment: unknown
            target: unknown
          } | {
            _tag: unknown
            anchor: unknown
          }
          version: number
        }
        pendingScrollVersion: number
        rowHeightPx: number
        scrollTop: number
        viewportAnchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }, args: []) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
      requestScrollToIndex: (model: {
        endBehavior: {
          _tag: "PreserveAnchor"
        } | {
          _tag: "Follow"
          thresholdPx: number
        }
        id: string
        initialScroll: {
          _tag: "Pending"
          alignment: "Start" | "End" | "Center" | "Nearest"
          target: {
            _tag: unknown
            key: unknown
          } | {
            _tag: unknown
            offset: unknown
          } | {
            _tag: unknown
          } | {
            _tag: unknown
            index: unknown
          }
        } | {
          _tag: "Applied"
        }
        layoutVersion: number
        measuredRowHeights: {}
        measurement: {
          _tag: "Unmeasured"
        } | {
          _tag: "Measured"
          containerHeight: number
          containerWidth: number
        }
        pendingScroll: {
          _tag: "Idle"
        } | {
          _tag: "Pending"
          request: {
            _tag: unknown
            alignment: unknown
            target: unknown
          } | {
            _tag: unknown
            anchor: unknown
          }
          version: number
        }
        pendingScrollVersion: number
        rowHeightPx: number
        scrollTop: number
        viewportAnchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }, args: [
        index: number,
        options: Readonly<{
          alignment: unknown | unknown | unknown | unknown | unknown
        }>
      ]) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
      requestScrollToKey: (model: {
        endBehavior: {
          _tag: "PreserveAnchor"
        } | {
          _tag: "Follow"
          thresholdPx: number
        }
        id: string
        initialScroll: {
          _tag: "Pending"
          alignment: "Start" | "End" | "Center" | "Nearest"
          target: {
            _tag: unknown
            key: unknown
          } | {
            _tag: unknown
            offset: unknown
          } | {
            _tag: unknown
          } | {
            _tag: unknown
            index: unknown
          }
        } | {
          _tag: "Applied"
        }
        layoutVersion: number
        measuredRowHeights: {}
        measurement: {
          _tag: "Unmeasured"
        } | {
          _tag: "Measured"
          containerHeight: number
          containerWidth: number
        }
        pendingScroll: {
          _tag: "Idle"
        } | {
          _tag: "Pending"
          request: {
            _tag: unknown
            alignment: unknown
            target: unknown
          } | {
            _tag: unknown
            anchor: unknown
          }
          version: number
        }
        pendingScrollVersion: number
        rowHeightPx: number
        scrollTop: number
        viewportAnchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }, args: [
        key: string,
        options: Readonly<{
          alignment: unknown | unknown | unknown | unknown | unknown
        }>
      ]) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
      requestScrollToOffset: (model: {
        endBehavior: {
          _tag: "PreserveAnchor"
        } | {
          _tag: "Follow"
          thresholdPx: number
        }
        id: string
        initialScroll: {
          _tag: "Pending"
          alignment: "Start" | "End" | "Center" | "Nearest"
          target: {
            _tag: unknown
            key: unknown
          } | {
            _tag: unknown
            offset: unknown
          } | {
            _tag: unknown
          } | {
            _tag: unknown
            index: unknown
          }
        } | {
          _tag: "Applied"
        }
        layoutVersion: number
        measuredRowHeights: {}
        measurement: {
          _tag: "Unmeasured"
        } | {
          _tag: "Measured"
          containerHeight: number
          containerWidth: number
        }
        pendingScroll: {
          _tag: "Idle"
        } | {
          _tag: "Pending"
          request: {
            _tag: unknown
            alignment: unknown
            target: unknown
          } | {
            _tag: unknown
            anchor: unknown
          }
          version: number
        }
        pendingScrollVersion: number
        rowHeightPx: number
        scrollTop: number
        viewportAnchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }, args: [offset: number]) => PublicExposedUpdateReturn<ReturnType<UpdateFunction>>
    }>
    update: (message: {
      _tag: "RequestedScrollTo"
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "RequestedScrollToIndex"
      index: number
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToKey"
      key: string
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToOffset"
      offset: number
    } | {
      _tag: "RequestedScrollToEnd"
    } | {
      _tag: "InformedOfItemsChange"
      itemKeys: readonly Array<string>
    } | {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "CompletedApplyScroll"
      outcome: {
        _tag: "Skipped"
      } | {
        _tag: "Applied"
        anchor: {
          _tag: "None"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        }
        containerHeight: number
        scrollHeight: number
        scrollTop: number
      }
      version: number
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }) => (model: {
      endBehavior: {
        _tag: "PreserveAnchor"
      } | {
        _tag: "Follow"
        thresholdPx: number
      }
      id: string
      initialScroll: {
        _tag: "Pending"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Applied"
      }
      layoutVersion: number
      measuredRowHeights: {}
      measurement: {
        _tag: "Unmeasured"
      } | {
        _tag: "Measured"
        containerHeight: number
        containerWidth: number
      }
      pendingScroll: {
        _tag: "Idle"
      } | {
        _tag: "Pending"
        request: {
          _tag: "Target"
          alignment: unknown | unknown | unknown | unknown
          target: unknown | unknown | unknown | unknown
        } | {
          _tag: "Anchor"
          anchor: unknown | unknown | unknown
        }
        version: number
      }
      pendingScrollVersion: number
      rowHeightPx: number
      scrollTop: number
      viewportAnchor: {
        _tag: "End"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      } | {
        _tag: "Offset"
        scrollTop: number
      }
    }, context: readonly []) => ReturnWithOutMessage<{
      endBehavior: {
        _tag: "PreserveAnchor"
      } | {
        _tag: "Follow"
        thresholdPx: number
      }
      id: string
      initialScroll: {
        _tag: "Pending"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: unknown
          key: unknown
        } | {
          _tag: unknown
          offset: unknown
        } | {
          _tag: unknown
        } | {
          _tag: unknown
          index: unknown
        }
      } | {
        _tag: "Applied"
      }
      layoutVersion: number
      measuredRowHeights: {}
      measurement: {
        _tag: "Unmeasured"
      } | {
        _tag: "Measured"
        containerHeight: number
        containerWidth: number
      }
      pendingScroll: {
        _tag: "Idle"
      } | {
        _tag: "Pending"
        request: {
          _tag: unknown
          alignment: unknown
          target: unknown
        } | {
          _tag: unknown
          anchor: unknown
        }
        version: number
      }
      pendingScrollVersion: number
      rowHeightPx: number
      scrollTop: number
      viewportAnchor: {
        _tag: "End"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      } | {
        _tag: "Offset"
        scrollTop: number
      }
    }, {
      _tag: "RequestedScrollTo"
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "RequestedScrollToIndex"
      index: number
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToKey"
      key: string
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToOffset"
      offset: number
    } | {
      _tag: "RequestedScrollToEnd"
    } | {
      _tag: "InformedOfItemsChange"
      itemKeys: readonly Array<string>
    } | {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "CompletedApplyScroll"
      outcome: {
        _tag: "Skipped"
      } | {
        _tag: "Applied"
        anchor: unknown | unknown
        containerHeight: number
        scrollHeight: number
        scrollTop: number
      }
      version: number
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }, {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }, Handler<"VirtualList/ApplyScroll", {
      id: string
      request: {
        _tag: "Target"
        alignment: unknown | unknown | unknown | unknown
        target: unknown | unknown | unknown | unknown
      } | {
        _tag: "Anchor"
        anchor: unknown | unknown | unknown
      }
      version: number
    }, {
      _tag: "CompletedApplyScroll"
      outcome: {
        _tag: "Skipped"
      } | {
        _tag: "Applied"
        anchor: unknown | unknown
        containerHeight: number
        scrollHeight: number
        scrollTop: number
      }
      version: number
    }>>
    view: OwnedAuthoredView<BlockView<{
      endBehavior: {
        _tag: "PreserveAnchor"
      } | {
        _tag: "Follow"
        thresholdPx: number
      }
      id: string
      initialScroll: {
        _tag: "Pending"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Applied"
      }
      layoutVersion: number
      measuredRowHeights: {}
      measurement: {
        _tag: "Unmeasured"
      } | {
        _tag: "Measured"
        containerHeight: number
        containerWidth: number
      }
      pendingScroll: {
        _tag: "Idle"
      } | {
        _tag: "Pending"
        request: {
          _tag: "Target"
          alignment: unknown | unknown | unknown | unknown
          target: unknown | unknown | unknown | unknown
        } | {
          _tag: "Anchor"
          anchor: unknown | unknown | unknown
        }
        version: number
      }
      pendingScrollVersion: number
      rowHeightPx: number
      scrollTop: number
      viewportAnchor: {
        _tag: "End"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      } | {
        _tag: "Offset"
        scrollTop: number
      }
    }, {
      _tag: "RequestedScrollTo"
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "RequestedScrollToIndex"
      index: number
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToKey"
      key: string
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToOffset"
      offset: number
    } | {
      _tag: "RequestedScrollToEnd"
    } | {
      _tag: "InformedOfItemsChange"
      itemKeys: readonly Array<string>
    } | {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "CompletedApplyScroll"
      outcome: {
        _tag: "Skipped"
      } | {
        _tag: "Applied"
        anchor: {
          _tag: unknown
        } | {
          _tag: unknown
          index: unknown
          key: unknown
          viewportOffset: unknown
        }
        containerHeight: number
        scrollHeight: number
        scrollTop: number
      }
      version: number
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }, AuthoredViewInputs<ViewInputs<Item>>, Handler<"VirtualList/ObserveVirtualList", Readonly<{
      element: Element
      viewStateChanges: Stream<unknown | unknown>
    }> & {
      id: string
    }, {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }>>, Owner<"VirtualList", true>, {
      endBehavior: {
        _tag: "PreserveAnchor"
      } | {
        _tag: "Follow"
        thresholdPx: number
      }
      id: string
      initialScroll: {
        _tag: "Pending"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Applied"
      }
      layoutVersion: number
      measuredRowHeights: {}
      measurement: {
        _tag: "Unmeasured"
      } | {
        _tag: "Measured"
        containerHeight: number
        containerWidth: number
      }
      pendingScroll: {
        _tag: "Idle"
      } | {
        _tag: "Pending"
        request: {
          _tag: "Target"
          alignment: "Start" | "End" | "Center" | "Nearest"
          target: {
            _tag: unknown
            key: unknown
          } | {
            _tag: unknown
            offset: unknown
          } | {
            _tag: unknown
          } | {
            _tag: unknown
            index: unknown
          }
        } | {
          _tag: "Anchor"
          anchor: {
            _tag: unknown
          } | {
            _tag: unknown
            index: unknown
            key: unknown
            viewportOffset: unknown
          } | {
            _tag: unknown
            scrollTop: unknown
          }
        }
        version: number
      }
      pendingScrollVersion: number
      rowHeightPx: number
      scrollTop: number
      viewportAnchor: {
        _tag: "End"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      } | {
        _tag: "Offset"
        scrollTop: number
      }
    }, {
      _tag: "RequestedScrollTo"
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "RequestedScrollToIndex"
      index: number
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToKey"
      key: string
      maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    } | {
      _tag: "RequestedScrollToOffset"
      offset: number
    } | {
      _tag: "RequestedScrollToEnd"
    } | {
      _tag: "InformedOfItemsChange"
      itemKeys: readonly Array<string>
    } | {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "CompletedApplyScroll"
      outcome: {
        _tag: "Skipped"
      } | {
        _tag: "Applied"
        anchor: {
          _tag: "None"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        }
        containerHeight: number
        scrollHeight: number
        scrollTop: number
      }
      version: number
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }, Handler<"VirtualList/ObserveVirtualList", Readonly<{
      element: Element
      viewStateChanges: Stream<"Live" | "Paused">
    }> & {
      id: string
    }, {
      _tag: "ResizedContainer"
      containerHeight: number
      containerWidth: number
    } | {
      _tag: "MeasuredRows"
      measurements: readonly Array<{
        height: number
        key: string
        layoutVersion: number
      }>
    } | {
      _tag: "ObservedContainerScroll"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }>>
  }>>
  subscriptions: Readonly<Record<never, never>>
  update: (message: {
    _tag: "RequestedScrollTo"
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    target: {
      _tag: "Key"
      key: string
    } | {
      _tag: "Offset"
      offset: number
    } | {
      _tag: "End"
    } | {
      _tag: "Index"
      index: number
    }
  } | {
    _tag: "RequestedScrollToIndex"
    index: number
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToKey"
    key: string
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToOffset"
    offset: number
  } | {
    _tag: "RequestedScrollToEnd"
  } | {
    _tag: "InformedOfItemsChange"
    itemKeys: readonly Array<string>
  } | {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "CompletedApplyScroll"
    outcome: {
      _tag: "Skipped"
    } | {
      _tag: "Applied"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }
    version: number
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }) => (model: {
    endBehavior: {
      _tag: "PreserveAnchor"
    } | {
      _tag: "Follow"
      thresholdPx: number
    }
    id: string
    initialScroll: {
      _tag: "Pending"
      alignment: "Start" | "End" | "Center" | "Nearest"
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "Applied"
    }
    layoutVersion: number
    measuredRowHeights: {}
    measurement: {
      _tag: "Unmeasured"
    } | {
      _tag: "Measured"
      containerHeight: number
      containerWidth: number
    }
    pendingScroll: {
      _tag: "Idle"
    } | {
      _tag: "Pending"
      request: {
        _tag: "Target"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Anchor"
        anchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }
      version: number
    }
    pendingScrollVersion: number
    rowHeightPx: number
    scrollTop: number
    viewportAnchor: {
      _tag: "End"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    } | {
      _tag: "Offset"
      scrollTop: number
    }
  }, context: readonly []) => ReturnWithOutMessage<{
    endBehavior: {
      _tag: "PreserveAnchor"
    } | {
      _tag: "Follow"
      thresholdPx: number
    }
    id: string
    initialScroll: {
      _tag: "Pending"
      alignment: "Start" | "End" | "Center" | "Nearest"
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "Applied"
    }
    layoutVersion: number
    measuredRowHeights: {}
    measurement: {
      _tag: "Unmeasured"
    } | {
      _tag: "Measured"
      containerHeight: number
      containerWidth: number
    }
    pendingScroll: {
      _tag: "Idle"
    } | {
      _tag: "Pending"
      request: {
        _tag: "Target"
        alignment: "Start" | "End" | "Center" | "Nearest"
        target: {
          _tag: "Key"
          key: string
        } | {
          _tag: "Offset"
          offset: number
        } | {
          _tag: "End"
        } | {
          _tag: "Index"
          index: number
        }
      } | {
        _tag: "Anchor"
        anchor: {
          _tag: "End"
        } | {
          _tag: "Row"
          index: number
          key: string
          viewportOffset: number
        } | {
          _tag: "Offset"
          scrollTop: number
        }
      }
      version: number
    }
    pendingScrollVersion: number
    rowHeightPx: number
    scrollTop: number
    viewportAnchor: {
      _tag: "End"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    } | {
      _tag: "Offset"
      scrollTop: number
    }
  }, {
    _tag: "RequestedScrollTo"
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
    target: {
      _tag: "Key"
      key: string
    } | {
      _tag: "Offset"
      offset: number
    } | {
      _tag: "End"
    } | {
      _tag: "Index"
      index: number
    }
  } | {
    _tag: "RequestedScrollToIndex"
    index: number
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToKey"
    key: string
    maybeAlignment: Option<"Start" | "End" | "Center" | "Nearest">
  } | {
    _tag: "RequestedScrollToOffset"
    offset: number
  } | {
    _tag: "RequestedScrollToEnd"
  } | {
    _tag: "InformedOfItemsChange"
    itemKeys: readonly Array<string>
  } | {
    _tag: "ResizedContainer"
    containerHeight: number
    containerWidth: number
  } | {
    _tag: "MeasuredRows"
    measurements: readonly Array<{
      height: number
      key: string
      layoutVersion: number
    }>
  } | {
    _tag: "CompletedApplyScroll"
    outcome: {
      _tag: "Skipped"
    } | {
      _tag: "Applied"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }
    version: number
  } | {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }, {
    _tag: "ObservedContainerScroll"
    anchor: {
      _tag: "None"
    } | {
      _tag: "Row"
      index: number
      key: string
      viewportOffset: number
    }
    containerHeight: number
    scrollHeight: number
    scrollTop: number
  }, Handler<"VirtualList/ApplyScroll", {
    id: string
    request: {
      _tag: "Target"
      alignment: "Start" | "End" | "Center" | "Nearest"
      target: {
        _tag: "Key"
        key: string
      } | {
        _tag: "Offset"
        offset: number
      } | {
        _tag: "End"
      } | {
        _tag: "Index"
        index: number
      }
    } | {
      _tag: "Anchor"
      anchor: {
        _tag: "End"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      } | {
        _tag: "Offset"
        scrollTop: number
      }
    }
    version: number
  }, {
    _tag: "CompletedApplyScroll"
    outcome: {
      _tag: "Skipped"
    } | {
      _tag: "Applied"
      anchor: {
        _tag: "None"
      } | {
        _tag: "Row"
        index: number
        key: string
        viewportOffset: number
      }
      containerHeight: number
      scrollHeight: number
      scrollTop: number
    }
    version: number
  }>>
}

Constants

ApplyScrollOutcome

constsource
/** Outcome of applying a logical scroll request after the view commits. */
const ApplyScrollOutcome: TaggedUnion<{
  Applied: {
    anchor: TaggedUnion<{
      None: {}
      Row: {
        index: Number
        key: String
        viewportOffset: Number
      }
    }>
    containerHeight: Number
    scrollHeight: Number
    scrollTop: Number
  }
  Skipped: {}
}>

ContainerScrollObservation

constsource
/** Public snapshot of a user or browser driven container scroll. */
const ContainerScrollObservation: Struct<{
  anchor: TaggedUnion<{
    None: {}
    Row: {
      index: Number
      key: String
      viewportOffset: Number
    }
  }>
  containerHeight: Number
  scrollHeight: Number
  scrollTop: Number
}>

ContentAlignment

constsource
/** Alignment of content when its total height is shorter than the viewport. */
const ContentAlignment: Literals<readonly ["Start", "End"]>

ObservedAnchor

constsource
/** Stable row observation captured from the live scroll container. */
const ObservedAnchor: TaggedUnion<{
  None: {}
  Row: {
    index: Number
    key: String
    viewportOffset: Number
  }
}>

ScrollAlignment

constsource
/** Alignment of a row within the viewport after a programmatic scroll. */
const ScrollAlignment: Literals<readonly ["Start", "Center", "End", "Nearest"]>

ScrollTarget

constsource
/** Logical destination for initial and programmatic scrolling. */
const ScrollTarget: TaggedUnion<{
  End: {}
  Index: {
    index: Number
  }
  Key: {
    key: String
  }
  Offset: {
    offset: Number
  }
}>