react-native-capped-scrollview 0.1.0

package/CappedScrollView.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "CappedScrollView"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/leonsilicon/react-native-capped-scrollview.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Leon Si
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# react-native-capped-scrollview
+
+A drop-in replacement for React Native's `ScrollView` that lets you cap how
+fast the user can fling the list. Useful for surfaces where you want to keep
+the visual scroll speed inside a comfortable, readable range — long-form
+content, kiosk-style UIs, accessibility modes — without disabling momentum
+entirely.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/leonsilicon/react-native-capped-scrollview/main/scrollview-capped.gif" width="320" alt="Side-by-side demo: capped column on the left flings at a controlled speed while the plain ScrollView on the right coasts naturally." />
+</p>
+
+## Installation
+
+```sh
+npm install react-native-capped-scrollview
+# or
+yarn add react-native-capped-scrollview
+# or
+pnpm add react-native-capped-scrollview
+```
+
+Then on iOS run `pod install` inside the `ios/` directory (or `npx expo prebuild` if you're on Expo). Android picks the library up automatically via autolinking.
+
+Requires the New Architecture (Fabric + TurboModules). Tested against React Native 0.83; should work on any RN ≥ 0.80.
+
+## Usage
+
+```tsx
+import { CappedScrollView } from 'react-native-capped-scrollview';
+
+export function MyList() {
+  return (
+    <CappedScrollView maxVelocity={0.25} style={{ flex: 1 }}>
+      {items.map((item) => (
+        <Row key={item.id} item={item} />
+      ))}
+    </CappedScrollView>
+  );
+}
+```
+
+`CappedScrollView` accepts every prop the built-in `ScrollView` accepts (it renders one under the hood) and adds a single new prop, `maxVelocity`.
+
+The GIF above is the example app from `example/` — a `CappedScrollView` on the left and a plain `ScrollView` on the right being flung with the same gesture. Run it with `yarn example ios` or `yarn example android`.
+
+## API
+
+### `maxVelocity?: number | null`
+
+Normalized fling-velocity cap.
+
+| Value          | Behaviour                                                                                                                                             |
+| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `null`/omitted | No capper installed. Behaves exactly like a plain `ScrollView`. **Default.**                                                                          |
+| `0`            | List cannot fling. Drag still works; releasing the finger stops the scroll dead.                                                                      |
+| `1`            | Capper installed but set to the reference maximum. Human-paced flings pass through untouched; only faster-than-human programmatic flings get clamped. |
+| `0 < x < 1`    | Peak fling velocity is clamped to `x × 8000 dp/s` on Android (`x × 8000 pt/s` on iOS). The two units are identical, so the cap on each platform corresponds to the same logical scroll speed.       |
+
+The reference max is **8000 dp/s** on Android (scaled to physical pixels via `displayMetrics.density`) and **8000 pt/s** on iOS. Because a `dp` and a `pt` are the same logical unit, the same `maxVelocity` value applies the same peak-velocity cap on both platforms.
+
+> [!NOTE]
+> The cap controls *peak velocity*, not fling distance. iOS's `UIScrollView` decelerates exponentially while Android's `OverScroller` uses a spline whose distance is roughly `velocity^1.7`, so a single `maxVelocity` value produces a similar starting speed on both platforms but Android's fling will cover proportionally less distance than iOS's. If you need pixel-for-pixel cross-platform parity, drive the scroll yourself via `scrollTo` with an animation library.
+
+The distinction between `null` and `1` is intentional: at `1` the cap mechanism is wired up (so future runtime changes via state are instant), whereas `null` skips the install entirely (the scroll view is byte-for-byte identical to RN's default).
+
+### Ref
+
+The ref returned by `CappedScrollView` is the underlying RN `ScrollView` instance — so `scrollTo`, `scrollToEnd`, `getScrollableNode`, etc. all work as you'd expect.
+
+```tsx
+const ref = useRef<CappedScrollViewRef>(null);
+// ...
+ref.current?.scrollTo({ y: 0, animated: true });
+```
+
+## How it works
+
+The library never re-implements `ScrollView`. It wraps RN's own `<ScrollView>` (so every prop, every event, sticky headers, refresh control, etc. continue to work) and attaches a small native hook to the underlying platform scroll view to intercept fling velocity.
+
+### iOS
+
+A TurboModule resolves the React tag (`getScrollableNode()`) to the underlying `RCTScrollViewComponentView` by walking the window hierarchy and matching on `UIView.tag`, which Fabric sets to the React tag at mount time. Resolution retries every ~33 ms for up to ~1 s, because in Fabric the scroll view's UIView may not exist at the moment `useEffect` runs.
+
+Once found, the module attaches a `UIScrollViewDelegate` proxy to the scroll view's `scrollViewDelegateSplitter` — RN exposes this as the official extension point for adding delegates without replacing the primary one, so all of RN's own scroll event plumbing keeps working.
+
+The proxy implements `scrollViewWillEndDragging:withVelocity:targetContentOffset:`. UIScrollView reports velocity in points-per-millisecond and accepts an `inout` target offset. The proxy:
+
+1. Computes `cap = fraction × 8000 pt/s` (converted to pt/ms to match UIScrollView's units).
+2. If the user's fling is already within `cap`, leaves the target untouched.
+3. Otherwise multiplies `(target − current)` by `cap / peak`, which produces a fling whose peak velocity is exactly `cap` and whose distance is linearly proportional to how much the velocity was clamped.
+
+When `maxVelocity` becomes `null`, the proxy is removed via `[splitter removeDelegate:]` — the scroll view returns to its exact default state.
+
+### Android
+
+A TurboModule resolves the React tag via `UIManagerHelper.getUIManagerForReactTag(...).resolveView(tag)` (with a Fabric UIManager fallback), retrying on the main thread for up to ~1 s for the same Fabric mount-timing reason.
+
+Once the `ReactScrollView` is found, the module replaces its `OverScroller` (Android's deceleration physics object — `mScroller` on the framework `ScrollView` class, plus RN's cached reference on `ReactScrollView`) with a subclass that overrides both `fling(...)` signatures. Both fields are written via reflection because they're declared `private`.
+
+The replacement scroller:
+
+1. Computes `cap = fraction × 8000 dp/s × displayMetrics.density` (matching the iOS reference of 8000 pt/s — same numeric value, same logical unit).
+2. If the requested fling already fits the cap, forwards the fling unmodified.
+3. Otherwise scales both `velocityX` and `velocityY` by `cap / peak` and calls `super.fling(...)`. The framework's deceleration physics then run from the clamped start velocity, producing a fling whose peak velocity is exactly `cap`. Distance is governed by `OverScroller`'s spline (≈ `velocity^1.7`), so fast flings end up coasting somewhat less than the equivalent iOS fling.
+
+When `maxVelocity` becomes `null`, the module restores the original `OverScroller` it captured at install time, so the scroll view returns to its exact default state.
+
+### JS glue
+
+`src/CappedScrollView.tsx` is a `forwardRef` wrapper around `<ScrollView>`. On `maxVelocity` change, it calls `innerRef.current?.getScrollableNode()` to get the native React tag and forwards `(tag, value)` to the TurboModule. `null` is encoded as the sentinel `-1`, which the native side interprets as "remove the cap from this scroll view."
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/build.gradle

@@ -0,0 +1,67 @@
+buildscript {
+  ext.CappedScrollview = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return CappedScrollview[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.cappedscrollview"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/cappedscrollview/CappedScrollViewModule.kt

@@ -0,0 +1,205 @@
+package com.cappedscrollview
+
+import android.os.Handler
+import android.os.Looper
+import android.widget.OverScroller
+import android.widget.ScrollView
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.views.scroll.ReactScrollView
+import java.lang.reflect.Field
+import kotlin.math.abs
+
+@ReactModule(name = CappedScrollViewModule.NAME)
+class CappedScrollViewModule(reactContext: ReactApplicationContext) :
+  NativeCappedScrollViewSpec(reactContext) {
+
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  override fun getName(): String = NAME
+
+  override fun setMaxVelocity(reactTag: Double, maxVelocity: Double) {
+    val tag = reactTag.toInt()
+    attemptInstall(tag, maxVelocity, attemptsRemaining = MAX_RESOLVE_ATTEMPTS)
+  }
+
+  private fun attemptInstall(tag: Int, value: Double, attemptsRemaining: Int) {
+    mainHandler.post {
+      val view = resolveView(reactApplicationContext, tag)
+      if (view !is ReactScrollView) {
+        if (attemptsRemaining > 0) {
+          mainHandler.postDelayed({
+            attemptInstall(tag, value, attemptsRemaining - 1)
+          }, RETRY_DELAY_MS)
+        }
+        return@post
+      }
+      if (value < 0) {
+        uninstallCap(view)
+      } else {
+        installCap(view, value)
+      }
+    }
+  }
+
+  private fun uninstallCap(view: ReactScrollView) {
+    val baseField = scrollViewScrollerField() ?: return
+    val current = try {
+      baseField.get(view) as? OverScroller
+    } catch (_: Throwable) {
+      null
+    }
+    val original = (current as? CappedOverScroller)?.original ?: return
+    try {
+      baseField.set(view, original)
+    } catch (_: Throwable) {
+      return
+    }
+    try {
+      reactScrollViewScrollerField()?.set(view, original)
+    } catch (_: Throwable) {
+      // Best-effort.
+    }
+  }
+
+  private fun resolveView(context: ReactContext, tag: Int): android.view.View? {
+    val byTag = try {
+      UIManagerHelper.getUIManagerForReactTag(context, tag)?.resolveView(tag)
+    } catch (_: Throwable) {
+      null
+    }
+    if (byTag != null) return byTag
+    return try {
+      UIManagerHelper.getUIManager(context, UIManagerType.FABRIC)?.resolveView(tag)
+    } catch (_: Throwable) {
+      null
+    }
+  }
+
+  private fun installCap(view: ReactScrollView, fraction: Double) {
+    val baseField = scrollViewScrollerField() ?: return
+    val rnField = reactScrollViewScrollerField()
+    val current = try {
+      baseField.get(view) as? OverScroller
+    } catch (_: Throwable) {
+      null
+    }
+    if (current is CappedOverScroller) {
+      current.fraction = fraction
+      return
+    }
+    // The cap reference is 8000 dp/s — the same numeric value used on iOS,
+    // expressed in dp/pt so the two platforms produce the same scroll feel
+    // at the same `maxVelocity` value. Convert to physical pixels for the
+    // OverScroller (which accepts px/s).
+    val density = view.resources.displayMetrics.density
+    val referenceMaxPxPerSec = REFERENCE_MAX_DP_PER_SEC * density
+    val replacement = CappedOverScroller(
+      view.context,
+      fraction,
+      referenceMaxPxPerSec.toDouble(),
+      current,
+    )
+    try {
+      baseField.set(view, replacement)
+    } catch (_: Throwable) {
+      return
+    }
+    try {
+      rnField?.set(view, replacement)
+    } catch (_: Throwable) {
+      // Best-effort; RN's cached reference will fall back to base ScrollView behavior.
+    }
+  }
+
+  private fun scrollViewScrollerField(): Field? = scrollerFieldCache ?: run {
+    try {
+      val field = ScrollView::class.java.getDeclaredField("mScroller")
+      field.isAccessible = true
+      scrollerFieldCache = field
+      field
+    } catch (_: Throwable) {
+      null
+    }
+  }
+
+  private fun reactScrollViewScrollerField(): Field? = rnScrollerFieldCache ?: run {
+    try {
+      val field = ReactScrollView::class.java.getDeclaredField("mScroller")
+      field.isAccessible = true
+      rnScrollerFieldCache = field
+      field
+    } catch (_: NoSuchFieldException) {
+      null
+    }
+  }
+
+  companion object {
+    const val NAME = "CappedScrollView"
+    private const val RETRY_DELAY_MS = 33L
+    private const val MAX_RESOLVE_ATTEMPTS = 30
+    // Public 0..1 cap scale is anchored to 8000 dp/s (matches iOS's 8000 pt/s).
+    private const val REFERENCE_MAX_DP_PER_SEC = 8000f
+    @Volatile private var scrollerFieldCache: Field? = null
+    @Volatile private var rnScrollerFieldCache: Field? = null
+  }
+}
+
+/**
+ * OverScroller subclass that caps peak fling velocity at
+ * `referenceMax * fraction` (where `referenceMax` is 8000 dp/s converted to
+ * physical pixels, matching iOS's 8000 pt/s reference). The base RN/Android
+ * deceleration physics are otherwise left alone, so the resulting fling
+ * decelerates naturally from the clamped peak.
+ */
+private class CappedOverScroller(
+  context: android.content.Context,
+  @Volatile var fraction: Double,
+  private val referenceMaxPxPerSec: Double,
+  val original: OverScroller?,
+) : OverScroller(context) {
+
+  override fun fling(
+    startX: Int,
+    startY: Int,
+    velocityX: Int,
+    velocityY: Int,
+    minX: Int,
+    maxX: Int,
+    minY: Int,
+    maxY: Int,
+    overX: Int,
+    overY: Int,
+  ) {
+    val (cx, cy) = applyCap(velocityX, velocityY)
+    super.fling(startX, startY, cx, cy, minX, maxX, minY, maxY, overX, overY)
+  }
+
+  override fun fling(
+    startX: Int,
+    startY: Int,
+    velocityX: Int,
+    velocityY: Int,
+    minX: Int,
+    maxX: Int,
+    minY: Int,
+    maxY: Int,
+  ) {
+    val (cx, cy) = applyCap(velocityX, velocityY)
+    super.fling(startX, startY, cx, cy, minX, maxX, minY, maxY)
+  }
+
+  private fun applyCap(velocityX: Int, velocityY: Int): Pair<Int, Int> {
+    val f = fraction.coerceIn(0.0, 1.0)
+    if (f >= 1.0) return velocityX to velocityY
+    if (f <= 0.0) return 0 to 0
+    val cap = referenceMaxPxPerSec * f
+    val peak = maxOf(abs(velocityX), abs(velocityY)).toDouble()
+    if (peak <= cap) return velocityX to velocityY
+    val scale = cap / peak
+    return (velocityX * scale).toInt() to (velocityY * scale).toInt()
+  }
+}

package/android/src/main/java/com/cappedscrollview/CappedScrollViewPackage.kt

@@ -0,0 +1,25 @@
+package com.cappedscrollview
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class CappedScrollViewPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == CappedScrollViewModule.NAME) CappedScrollViewModule(reactContext) else null
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      CappedScrollViewModule.NAME to ReactModuleInfo(
+        CappedScrollViewModule.NAME,
+        CappedScrollViewModule::class.java.name,
+        false,
+        false,
+        false,
+        true,
+      )
+    )
+  }
+}

package/ios/CappedScrollView.h

@@ -0,0 +1,9 @@
+#import <React/RCTBridgeModule.h>
+#import <CappedScrollViewSpec/CappedScrollViewSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CappedScrollView : NSObject <NativeCappedScrollViewSpec>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/CappedScrollView.mm

@@ -0,0 +1,160 @@
+#import "CappedScrollView.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTScrollViewComponentView.h>
+#import <React/RCTUtils.h>
+
+@interface CappedScrollViewVelocityCapper : NSObject <UIScrollViewDelegate>
+@property (nonatomic, assign) CGFloat maxVelocity;
+@end
+
+static RCTScrollViewComponentView *_Nullable CappedScrollViewSearch(UIView *root, NSInteger tag)
+{
+  if (root.tag == tag && [root isKindOfClass:[RCTScrollViewComponentView class]]) {
+    return (RCTScrollViewComponentView *)root;
+  }
+  for (UIView *child in root.subviews) {
+    RCTScrollViewComponentView *match = CappedScrollViewSearch(child, tag);
+    if (match) {
+      return match;
+    }
+  }
+  return nil;
+}
+
+static RCTScrollViewComponentView *_Nullable CappedScrollViewFindScrollView(NSInteger tag)
+{
+  for (UIScene *scene in UIApplication.sharedApplication.connectedScenes) {
+    if (![scene isKindOfClass:[UIWindowScene class]]) continue;
+    for (UIWindow *window in ((UIWindowScene *)scene).windows) {
+      RCTScrollViewComponentView *match = CappedScrollViewSearch(window, tag);
+      if (match) {
+        return match;
+      }
+    }
+  }
+  return nil;
+}
+
+// Cross-platform reference for the public 0..1 cap scale: 8000 pt/s on iOS,
+// 8000 dp/s on Android. At maxVelocity=1 the cap exactly matches this value;
+// at 0.5 it is 4000 pt/s, etc.
+static const CGFloat kCappedScrollViewReferenceMaxPtsPerSec = 8000.0;
+
+@implementation CappedScrollViewVelocityCapper
+
+- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView
+                     withVelocity:(CGPoint)velocity
+              targetContentOffset:(inout CGPoint *)targetContentOffset
+{
+  CGFloat fraction = MAX(0.0, MIN(1.0, self.maxVelocity));
+  if (fraction >= 1.0) {
+    return;
+  }
+  if (fraction <= 0.0) {
+    *targetContentOffset = scrollView.contentOffset;
+    return;
+  }
+
+  // UIScrollView reports velocity in points-per-millisecond.
+  CGFloat capPerMs = (kCappedScrollViewReferenceMaxPtsPerSec * fraction) / 1000.0;
+  CGFloat peak = MAX(fabs(velocity.x), fabs(velocity.y));
+  if (peak <= capPerMs) {
+    // Natural fling already within the cap — leave it untouched.
+    return;
+  }
+
+  // Speed-limit model: scale the predicted target offset toward current by
+  // (cap / peak). Linear scaling here means the fling distance is exactly
+  // proportional to how much we've clamped peak velocity, matching the
+  // Android behaviour (which clamps `velocityY` to `cap` directly).
+  CGFloat scale = capPerMs / peak;
+  CGPoint current = scrollView.contentOffset;
+  CGPoint target = *targetContentOffset;
+  target.x = current.x + (target.x - current.x) * scale;
+  target.y = current.y + (target.y - current.y) * scale;
+  *targetContentOffset = target;
+}
+
+@end
+
+@implementation CappedScrollView {
+  NSMapTable<NSNumber *, CappedScrollViewVelocityCapper *> *_cappersByTag;
+}
+
+RCT_EXPORT_MODULE()
+
+@synthesize bridge = _bridge;
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _cappersByTag = [NSMapTable strongToStrongObjectsMapTable];
+  }
+  return self;
+}
+
+- (void)setMaxVelocity:(double)reactTag maxVelocity:(double)maxVelocity
+{
+  NSInteger tag = (NSInteger)reactTag;
+  CGFloat cap = (CGFloat)maxVelocity;
+  __weak __typeof(self) weakSelf = self;
+  [self attemptInstallForTag:tag cap:cap attemptsRemaining:30 weakSelf:weakSelf];
+}
+
+- (void)attemptInstallForTag:(NSInteger)tag
+                         cap:(CGFloat)cap
+           attemptsRemaining:(NSInteger)attemptsRemaining
+                    weakSelf:(__weak CappedScrollView *)weakSelf
+{
+  RCTExecuteOnMainQueue(^{
+    __typeof(self) strongSelf = weakSelf;
+    if (!strongSelf) {
+      return;
+    }
+
+    RCTScrollViewComponentView *scrollComponent = CappedScrollViewFindScrollView(tag);
+    if (!scrollComponent) {
+      if (attemptsRemaining > 0) {
+        // Fabric mounting can lag the JS-side ref attachment; retry up to ~1s.
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(33 * NSEC_PER_MSEC)),
+                       dispatch_get_main_queue(), ^{
+          [strongSelf attemptInstallForTag:tag
+                                       cap:cap
+                         attemptsRemaining:attemptsRemaining - 1
+                                  weakSelf:weakSelf];
+        });
+      }
+      return;
+    }
+
+    NSNumber *key = @(tag);
+    CappedScrollViewVelocityCapper *capper = [strongSelf->_cappersByTag objectForKey:key];
+
+    if (cap < 0) {
+      // Sentinel: caller wants no capper at all.
+      if (capper) {
+        [scrollComponent.scrollViewDelegateSplitter removeDelegate:capper];
+        [strongSelf->_cappersByTag removeObjectForKey:key];
+      }
+      return;
+    }
+
+    if (!capper) {
+      capper = [CappedScrollViewVelocityCapper new];
+      [strongSelf->_cappersByTag setObject:capper forKey:key];
+      [scrollComponent.scrollViewDelegateSplitter addDelegate:capper];
+    }
+    capper.maxVelocity = cap;
+  });
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeCappedScrollViewSpecJSI>(params);
+}
+
+@end

package/lib/module/CappedScrollView.js

@@ -0,0 +1,30 @@
+"use strict";
+
+import { forwardRef, useEffect, useRef, useImperativeHandle } from 'react';
+import { ScrollView } from 'react-native';
+import NativeCappedScrollView from "./NativeCappedScrollView.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+// Sentinel sent to native when consumers pass `null`/omit the prop, meaning
+// "no capper installed at all." Negative values are unreachable from the
+// public [0, 1] range, so this is unambiguous on the native side.
+const NO_CAP_SENTINEL = -1;
+export const CappedScrollView = /*#__PURE__*/forwardRef(function CappedScrollView({
+  maxVelocity,
+  ...rest
+}, ref) {
+  const innerRef = useRef(null);
+  useImperativeHandle(ref, () => innerRef.current);
+  useEffect(() => {
+    const handle = innerRef.current?.getScrollableNode?.();
+    if (handle == null) {
+      return;
+    }
+    const value = maxVelocity == null ? NO_CAP_SENTINEL : maxVelocity;
+    NativeCappedScrollView.setMaxVelocity(handle, value);
+  }, [maxVelocity]);
+  return /*#__PURE__*/_jsx(ScrollView, {
+    ref: innerRef,
+    ...rest
+  });
+});
+//# sourceMappingURL=CappedScrollView.js.map

package/lib/module/CappedScrollView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["forwardRef","useEffect","useRef","useImperativeHandle","ScrollView","NativeCappedScrollView","jsx","_jsx","NO_CAP_SENTINEL","CappedScrollView","maxVelocity","rest","ref","innerRef","current","handle","getScrollableNode","value","setMaxVelocity"],"sourceRoot":"../../src","sources":["CappedScrollView.tsx"],"mappings":";;AAAA,SACEA,UAAU,EACVC,SAAS,EACTC,MAAM,EACNC,mBAAmB,QAGd,OAAO;AACd,SAASC,UAAU,QAA8B,cAAc;AAC/D,OAAOC,sBAAsB,MAAM,6BAA0B;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAwB9D;AACA;AACA;AACA,MAAMC,eAAe,GAAG,CAAC,CAAC;AAE1B,OAAO,MAAMC,gBAAgB,gBAAGT,UAAU,CAAC,SAASS,gBAAgBA,CAClE;EAAEC,WAAW;EAAE,GAAGC;AAA4B,CAAC,EAC/CC,GAA6B,EAC7B;EACA,MAAMC,QAAQ,GAAGX,MAAM,CAA6B,IAAI,CAAC;EAEzDC,mBAAmB,CAACS,GAAG,EAAE,MAAMC,QAAQ,CAACC,OAA8B,CAAC;EAEvEb,SAAS,CAAC,MAAM;IACd,MAAMc,MAAM,GAAGF,QAAQ,CAACC,OAAO,EAAEE,iBAAiB,GAAG,CAAC;IACtD,IAAID,MAAM,IAAI,IAAI,EAAE;MAClB;IACF;IACA,MAAME,KAAK,GAAGP,WAAW,IAAI,IAAI,GAAGF,eAAe,GAAGE,WAAW;IACjEL,sBAAsB,CAACa,cAAc,CAACH,MAAM,EAAEE,KAAK,CAAC;EACtD,CAAC,EAAE,CAACP,WAAW,CAAC,CAAC;EAEjB,oBAAOH,IAAA,CAACH,UAAU;IAACQ,GAAG,EAAEC,QAAS;IAAA,GAAKF;EAAI,CAAG,CAAC;AAChD,CAAC,CAAC","ignoreList":[]}

package/lib/module/NativeCappedScrollView.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('CappedScrollView');
+//# sourceMappingURL=NativeCappedScrollView.js.map

package/lib/module/NativeCappedScrollView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeCappedScrollView.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AAMlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,kBAAkB,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { CappedScrollView } from "./CappedScrollView.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CappedScrollView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,QAAQ,uBAAoB","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/CappedScrollView.d.ts

@@ -0,0 +1,248 @@
+import { type ComponentRef } from 'react';
+import { ScrollView, type ScrollViewProps } from 'react-native';
+export type CappedScrollViewRef = ComponentRef<typeof ScrollView>;
+export type CappedScrollViewProps = ScrollViewProps & {
+    /**
+     * Fling velocity cap as a normalized fraction in [0, 1], or `null` to
+     * disable the cap mechanism entirely.
+     *
+     * The reference maximum is 8000 dp/s on Android and 8000 pt/s on iOS
+     * (same logical unit), so the same `maxVelocity` value produces the same
+     * visual scroll speed on both platforms.
+     *
+     * - `null` / `undefined` (default) — no capper installed; behaves exactly
+     *   like a plain RN `ScrollView`.
+     * - `1` — capper installed at the reference maximum. Human-paced flings
+     *   pass through untouched.
+     * - `0` — list cannot fling at all.
+     * - `0 < x < 1` — peak fling velocity is clamped to `x × 8000` (dp/s on
+     *   Android, pt/s on iOS). Fling distance scales linearly with `x`.
+     */
+    maxVelocity?: number | null;
+};
+export declare const CappedScrollView: import("react").ForwardRefExoticComponent<Readonly<Omit<Omit<Readonly<Omit<Readonly<{
+    onAccessibilityAction?: ((event: import("react-native").AccessibilityActionEvent) => unknown) | undefined;
+    onAccessibilityTap?: (() => unknown) | undefined;
+    onLayout?: ((event: import("react-native").LayoutChangeEvent) => unknown) | undefined;
+    onMagicTap?: (() => unknown) | undefined;
+    onAccessibilityEscape?: (() => unknown) | undefined;
+}>, "onMoveShouldSetResponder" | "onMoveShouldSetResponderCapture" | "onResponderGrant" | "onResponderMove" | "onResponderReject" | "onResponderRelease" | "onResponderStart" | "onResponderEnd" | "onResponderTerminate" | "onResponderTerminationRequest" | "onStartShouldSetResponder" | "onStartShouldSetResponderCapture" | "onMouseEnter" | "onMouseLeave" | "onClick" | "onClickCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onBlur" | "onBlurCapture" | "onFocus" | "onFocusCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "nativeBackgroundAndroid" | "nativeForegroundAndroid" | "renderToHardwareTextureAndroid" | "hasTVPreferredFocus" | "nextFocusDown" | "nextFocusForward" | "nextFocusLeft" | "nextFocusRight" | "nextFocusUp" | "focusable" | "tabIndex" | "shouldRasterizeIOS" | "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden" | "accessibilityLabelledBy" | "aria-labelledby" | "accessibilityLiveRegion" | "aria-live" | "importantForAccessibility" | "screenReaderFocusable" | "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<{
+    onMoveShouldSetResponder?: ((e: import("react-native").GestureResponderEvent) => boolean) | undefined;
+    onMoveShouldSetResponderCapture?: ((e: import("react-native").GestureResponderEvent) => boolean) | undefined;
+    onResponderGrant?: ((e: import("react-native").GestureResponderEvent) => void | boolean) | undefined;
+    onResponderMove?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onResponderReject?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onResponderRelease?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onResponderStart?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onResponderEnd?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onResponderTerminate?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onResponderTerminationRequest?: ((e: import("react-native").GestureResponderEvent) => boolean) | undefined;
+    onStartShouldSetResponder?: ((e: import("react-native").GestureResponderEvent) => boolean) | undefined;
+    onStartShouldSetResponderCapture?: ((e: import("react-native").GestureResponderEvent) => boolean) | undefined;
+}>, "onMouseEnter" | "onMouseLeave" | "onClick" | "onClickCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onBlur" | "onBlurCapture" | "onFocus" | "onFocusCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "nativeBackgroundAndroid" | "nativeForegroundAndroid" | "renderToHardwareTextureAndroid" | "hasTVPreferredFocus" | "nextFocusDown" | "nextFocusForward" | "nextFocusLeft" | "nextFocusRight" | "nextFocusUp" | "focusable" | "tabIndex" | "shouldRasterizeIOS" | "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden" | "accessibilityLabelledBy" | "aria-labelledby" | "accessibilityLiveRegion" | "aria-live" | "importantForAccessibility" | "screenReaderFocusable" | "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<{
+    onMouseEnter?: ((event: import("react-native").MouseEvent) => void) | undefined;
+    onMouseLeave?: ((event: import("react-native").MouseEvent) => void) | undefined;
+}>, "onClick" | "onClickCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onBlur" | "onBlurCapture" | "onFocus" | "onFocusCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "nativeBackgroundAndroid" | "nativeForegroundAndroid" | "renderToHardwareTextureAndroid" | "hasTVPreferredFocus" | "nextFocusDown" | "nextFocusForward" | "nextFocusLeft" | "nextFocusRight" | "nextFocusUp" | "focusable" | "tabIndex" | "shouldRasterizeIOS" | "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden" | "accessibilityLabelledBy" | "aria-labelledby" | "accessibilityLiveRegion" | "aria-live" | "importantForAccessibility" | "screenReaderFocusable" | "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<{
+    onClick?: ((event: import("react-native").PointerEvent) => void) | undefined;
+    onClickCapture?: ((event: import("react-native").PointerEvent) => void) | undefined;
+    onPointerEnter?: ((event: import("react-native").PointerEvent) => void) | undefined;
+    onPointerEnterCapture?: ((event: import("react-native").PointerEvent) => void) | undefined;
+    onPointerLeave?: ((event: import("react-native").PointerEvent) => void) | undefined;
+    onPointerLeaveCapture?: ((event: import("react-native").PointerEvent) => void) | undefined;
+    onPointerMove?: ((event: import("react-native").PointerEvent) => void) | undefined;
+    onPointerMoveCapture?: ((event: import("react-native").PointerEvent) => void) | undefined;
+    onPointerCancel?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerCancelCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerDown?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerDownCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerUp?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerUpCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerOver?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerOverCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerOut?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onPointerOutCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onGotPointerCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onGotPointerCaptureCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onLostPointerCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+    onLostPointerCaptureCapture?: ((e: import("react-native").PointerEvent) => void) | undefined;
+}>, "onClick" | "onBlur" | "onBlurCapture" | "onFocus" | "onFocusCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "nativeBackgroundAndroid" | "nativeForegroundAndroid" | "renderToHardwareTextureAndroid" | "hasTVPreferredFocus" | "nextFocusDown" | "nextFocusForward" | "nextFocusLeft" | "nextFocusRight" | "nextFocusUp" | "focusable" | "tabIndex" | "shouldRasterizeIOS" | "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden" | "accessibilityLabelledBy" | "aria-labelledby" | "accessibilityLiveRegion" | "aria-live" | "importantForAccessibility" | "screenReaderFocusable" | "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<{
+    onBlur?: ((event: import("react-native").BlurEvent) => void) | undefined;
+    onBlurCapture?: ((event: import("react-native").BlurEvent) => void) | undefined;
+    onFocus?: ((event: import("react-native").FocusEvent) => void) | undefined;
+    onFocusCapture?: ((event: import("react-native").FocusEvent) => void) | undefined;
+}>, "onClick" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "nativeBackgroundAndroid" | "nativeForegroundAndroid" | "renderToHardwareTextureAndroid" | "hasTVPreferredFocus" | "nextFocusDown" | "nextFocusForward" | "nextFocusLeft" | "nextFocusRight" | "nextFocusUp" | "focusable" | "tabIndex" | "shouldRasterizeIOS" | "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden" | "accessibilityLabelledBy" | "aria-labelledby" | "accessibilityLiveRegion" | "aria-live" | "importantForAccessibility" | "screenReaderFocusable" | "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<{
+    onTouchCancel?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onTouchCancelCapture?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onTouchEnd?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onTouchEndCapture?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onTouchMove?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onTouchMoveCapture?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onTouchStart?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+    onTouchStartCapture?: ((e: import("react-native").GestureResponderEvent) => void) | undefined;
+}>, "onClick" | "nativeBackgroundAndroid" | "nativeForegroundAndroid" | "renderToHardwareTextureAndroid" | "hasTVPreferredFocus" | "nextFocusDown" | "nextFocusForward" | "nextFocusLeft" | "nextFocusRight" | "nextFocusUp" | "focusable" | "tabIndex" | "shouldRasterizeIOS" | "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden" | "accessibilityLabelledBy" | "aria-labelledby" | "accessibilityLiveRegion" | "aria-live" | "importantForAccessibility" | "screenReaderFocusable" | "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<{
+    nativeBackgroundAndroid?: import("react-native/types_generated/Libraries/Components/View/ViewPropTypes").AndroidDrawable | undefined;
+    nativeForegroundAndroid?: import("react-native/types_generated/Libraries/Components/View/ViewPropTypes").AndroidDrawable | undefined;
+    renderToHardwareTextureAndroid?: boolean | undefined;
+    hasTVPreferredFocus?: boolean | undefined;
+    nextFocusDown?: number | undefined;
+    nextFocusForward?: number | undefined;
+    nextFocusLeft?: number | undefined;
+    nextFocusRight?: number | undefined;
+    nextFocusUp?: number | undefined;
+    focusable?: boolean | undefined;
+    tabIndex?: 0 | -1;
+    onClick?: ((event: import("react-native").GestureResponderEvent) => unknown) | undefined;
+}>, "shouldRasterizeIOS" | "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden" | "accessibilityLabelledBy" | "aria-labelledby" | "accessibilityLiveRegion" | "aria-live" | "importantForAccessibility" | "screenReaderFocusable" | "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<{
+    shouldRasterizeIOS?: boolean | undefined;
+}>, "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden" | "accessibilityLabelledBy" | "aria-labelledby" | "accessibilityLiveRegion" | "aria-live" | "importantForAccessibility" | "screenReaderFocusable" | "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<Omit<Readonly<{
+    accessibilityLabelledBy?: (string | undefined) | (Array<string> | undefined);
+    "aria-labelledby"?: string | undefined;
+    accessibilityLiveRegion?: ("none" | "polite" | "assertive") | undefined;
+    "aria-live"?: ("polite" | "assertive" | "off") | undefined;
+    importantForAccessibility?: ("auto" | "yes" | "no" | "no-hide-descendants") | undefined;
+    screenReaderFocusable?: boolean;
+}>, "accessibilityIgnoresInvertColors" | "accessibilityViewIsModal" | "accessibilityShowsLargeContentViewer" | "accessibilityLargeContentTitle" | "aria-modal" | "accessibilityElementsHidden" | "accessibilityLanguage" | "accessibilityRespondsToUserInteraction" | "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden"> & Omit<Readonly<{
+    accessibilityIgnoresInvertColors?: boolean | undefined;
+    accessibilityViewIsModal?: boolean | undefined;
+    accessibilityShowsLargeContentViewer?: boolean | undefined;
+    accessibilityLargeContentTitle?: string | undefined;
+    "aria-modal"?: boolean | undefined;
+    accessibilityElementsHidden?: boolean | undefined;
+    accessibilityLanguage?: string | undefined;
+    accessibilityRespondsToUserInteraction?: boolean | undefined;
+}>, "accessible" | "accessibilityLabel" | "accessibilityHint" | "aria-label" | "accessibilityRole" | "role" | "accessibilityState" | "accessibilityValue" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "accessibilityActions" | "aria-busy" | "aria-checked" | "aria-disabled" | "aria-expanded" | "aria-selected" | "aria-hidden"> & {
+    accessible?: boolean | undefined;
+    accessibilityLabel?: string | undefined;
+    accessibilityHint?: string | undefined;
+    "aria-label"?: string | undefined;
+    accessibilityRole?: import("react-native").AccessibilityRole | undefined;
+    role?: import("react-native").Role | undefined;
+    accessibilityState?: import("react-native").AccessibilityState | undefined;
+    accessibilityValue?: import("react-native").AccessibilityValue | undefined;
+    "aria-valuemax"?: import("react-native").AccessibilityValue["max"] | undefined;
+    "aria-valuemin"?: import("react-native").AccessibilityValue["min"] | undefined;
+    "aria-valuenow"?: import("react-native").AccessibilityValue["now"] | undefined;
+    "aria-valuetext"?: import("react-native").AccessibilityValue["text"] | undefined;
+    accessibilityActions?: ReadonlyArray<import("react-native/types_generated/Libraries/Components/View/ViewAccessibility").AccessibilityActionInfo> | undefined;
+    "aria-busy"?: boolean | undefined;
+    "aria-checked"?: (boolean | undefined) | "mixed";
+    "aria-disabled"?: boolean | undefined;
+    "aria-expanded"?: boolean | undefined;
+    "aria-selected"?: boolean | undefined;
+    "aria-hidden"?: boolean | undefined;
+}>, "children" | "style" | "collapsable" | "collapsableChildren" | "id" | "testID" | "nativeID" | "needsOffscreenAlphaCompositing" | "hitSlop" | "pointerEvents" | "removeClippedSubviews" | "experimental_accessibilityOrder"> & Omit<Readonly<{
+    children?: React.ReactNode;
+    style?: import("react-native/types_generated/Libraries/StyleSheet/StyleSheet").ViewStyleProp | undefined;
+    collapsable?: boolean | undefined;
+    collapsableChildren?: boolean | undefined;
+    id?: string;
+    testID?: string | undefined;
+    nativeID?: string | undefined;
+    needsOffscreenAlphaCompositing?: boolean | undefined;
+    hitSlop?: import("react-native/types_generated/Libraries/StyleSheet/EdgeInsetsPropType").EdgeInsetsOrSizeProp | undefined;
+    pointerEvents?: ("auto" | "box-none" | "box-only" | "none") | undefined;
+    removeClippedSubviews?: boolean | undefined;
+    experimental_accessibilityOrder?: Array<string> | undefined;
+}>, never>>, "experimental_accessibilityOrder">, "children" | "removeClippedSubviews" | "automaticallyAdjustContentInsets" | "automaticallyAdjustKeyboardInsets" | "automaticallyAdjustsScrollIndicatorInsets" | "contentInset" | "bounces" | "disableScrollViewPanResponder" | "bouncesZoom" | "alwaysBounceHorizontal" | "alwaysBounceVertical" | "centerContent" | "indicatorStyle" | "directionalLockEnabled" | "canCancelContentTouches" | "maximumZoomScale" | "minimumZoomScale" | "pinchGestureEnabled" | "scrollIndicatorInsets" | "scrollToOverflowEnabled" | "scrollsToTop" | "onScrollToTop" | "showsHorizontalScrollIndicator" | "zoomScale" | "contentInsetAdjustmentBehavior" | "nestedScrollEnabled" | "endFillColor" | "scrollPerfTag" | "overScrollMode" | "persistentScrollbar" | "fadingEdgeLength" | "contentContainerStyle" | "contentOffset" | "disableIntervalMomentum" | "decelerationRate" | "experimental_endDraggingSensitivityMultiplier" | "horizontal" | "invertStickyHeaders" | "keyboardDismissMode" | "keyboardShouldPersistTaps" | "maintainVisibleContentPosition" | "onMomentumScrollBegin" | "onMomentumScrollEnd" | "onScroll" | "onScrollBeginDrag" | "onScrollEndDrag" | "onContentSizeChange" | "onKeyboardDidShow" | "onKeyboardDidHide" | "onKeyboardWillShow" | "onKeyboardWillHide" | "pagingEnabled" | "scrollEnabled" | "scrollEventThrottle" | "showsVerticalScrollIndicator" | "stickyHeaderHiddenOnScroll" | "stickyHeaderIndices" | "StickyHeaderComponent" | "snapToAlignment" | "snapToInterval" | "snapToOffsets" | "snapToStart" | "snapToEnd" | "refreshControl" | "innerViewRef" | "scrollViewRef"> & Omit<Readonly<{
+    automaticallyAdjustContentInsets?: boolean | undefined;
+    automaticallyAdjustKeyboardInsets?: boolean | undefined;
+    automaticallyAdjustsScrollIndicatorInsets?: boolean | undefined;
+    contentInset?: import("react-native/types_generated/Libraries/StyleSheet/EdgeInsetsPropType").EdgeInsetsProp | undefined;
+    bounces?: boolean | undefined;
+    disableScrollViewPanResponder?: boolean | undefined;
+    bouncesZoom?: boolean | undefined;
+    alwaysBounceHorizontal?: boolean | undefined;
+    alwaysBounceVertical?: boolean | undefined;
+    centerContent?: boolean | undefined;
+    indicatorStyle?: ("default" | "black" | "white") | undefined;
+    directionalLockEnabled?: boolean | undefined;
+    canCancelContentTouches?: boolean | undefined;
+    maximumZoomScale?: number | undefined;
+    minimumZoomScale?: number | undefined;
+    pinchGestureEnabled?: boolean | undefined;
+    scrollIndicatorInsets?: import("react-native/types_generated/Libraries/StyleSheet/EdgeInsetsPropType").EdgeInsetsProp | undefined;
+    scrollToOverflowEnabled?: boolean | undefined;
+    scrollsToTop?: boolean | undefined;
+    onScrollToTop?: (event: import("react-native").ScrollEvent) => void;
+    showsHorizontalScrollIndicator?: boolean | undefined;
+    zoomScale?: number | undefined;
+    contentInsetAdjustmentBehavior?: ("automatic" | "scrollableAxes" | "never" | "always") | undefined;
+}>, "children" | "removeClippedSubviews" | "nestedScrollEnabled" | "endFillColor" | "scrollPerfTag" | "overScrollMode" | "persistentScrollbar" | "fadingEdgeLength" | "contentContainerStyle" | "contentOffset" | "disableIntervalMomentum" | "decelerationRate" | "experimental_endDraggingSensitivityMultiplier" | "horizontal" | "invertStickyHeaders" | "keyboardDismissMode" | "keyboardShouldPersistTaps" | "maintainVisibleContentPosition" | "onMomentumScrollBegin" | "onMomentumScrollEnd" | "onScroll" | "onScrollBeginDrag" | "onScrollEndDrag" | "onContentSizeChange" | "onKeyboardDidShow" | "onKeyboardDidHide" | "onKeyboardWillShow" | "onKeyboardWillHide" | "pagingEnabled" | "scrollEnabled" | "scrollEventThrottle" | "showsVerticalScrollIndicator" | "stickyHeaderHiddenOnScroll" | "stickyHeaderIndices" | "StickyHeaderComponent" | "snapToAlignment" | "snapToInterval" | "snapToOffsets" | "snapToStart" | "snapToEnd" | "refreshControl" | "innerViewRef" | "scrollViewRef"> & Omit<Readonly<{
+    nestedScrollEnabled?: boolean | undefined;
+    endFillColor?: import("react-native").ColorValue | undefined;
+    scrollPerfTag?: string | undefined;
+    overScrollMode?: ("auto" | "always" | "never") | undefined;
+    persistentScrollbar?: boolean | undefined;
+    fadingEdgeLength?: (number | undefined) | {
+        start: number;
+        end: number;
+    };
+}>, "children" | "removeClippedSubviews" | "contentContainerStyle" | "contentOffset" | "disableIntervalMomentum" | "decelerationRate" | "experimental_endDraggingSensitivityMultiplier" | "horizontal" | "invertStickyHeaders" | "keyboardDismissMode" | "keyboardShouldPersistTaps" | "maintainVisibleContentPosition" | "onMomentumScrollBegin" | "onMomentumScrollEnd" | "onScroll" | "onScrollBeginDrag" | "onScrollEndDrag" | "onContentSizeChange" | "onKeyboardDidShow" | "onKeyboardDidHide" | "onKeyboardWillShow" | "onKeyboardWillHide" | "pagingEnabled" | "scrollEnabled" | "scrollEventThrottle" | "showsVerticalScrollIndicator" | "stickyHeaderHiddenOnScroll" | "stickyHeaderIndices" | "StickyHeaderComponent" | "snapToAlignment" | "snapToInterval" | "snapToOffsets" | "snapToStart" | "snapToEnd" | "refreshControl" | "innerViewRef" | "scrollViewRef"> & Omit<Readonly<{
+    contentContainerStyle?: import("react-native/types_generated/Libraries/StyleSheet/StyleSheet").ViewStyleProp | undefined;
+    contentOffset?: import("react-native/types_generated/Libraries/StyleSheet/PointPropType").PointProp | undefined;
+    disableIntervalMomentum?: boolean | undefined;
+    decelerationRate?: import("react-native/types_generated/Libraries/Components/ScrollView/ScrollView").DecelerationRateType | undefined;
+    experimental_endDraggingSensitivityMultiplier?: number | undefined;
+    horizontal?: boolean | undefined;
+    invertStickyHeaders?: boolean | undefined;
+    keyboardDismissMode?: ("none" | "on-drag" | "interactive") | undefined;
+    keyboardShouldPersistTaps?: ("always" | "never" | "handled" | true | false) | undefined;
+    maintainVisibleContentPosition?: Readonly<{
+        minIndexForVisible: number;
+        autoscrollToTopThreshold?: number | undefined;
+    }> | undefined;
+    onMomentumScrollBegin?: ((event: import("react-native").ScrollEvent) => void) | undefined;
+    onMomentumScrollEnd?: ((event: import("react-native").ScrollEvent) => void) | undefined;
+    onScroll?: ((event: import("react-native").ScrollEvent) => void) | undefined;
+    onScrollBeginDrag?: ((event: import("react-native").ScrollEvent) => void) | undefined;
+    onScrollEndDrag?: ((event: import("react-native").ScrollEvent) => void) | undefined;
+    onContentSizeChange?: (contentWidth: number, contentHeight: number) => void;
+    onKeyboardDidShow?: (event: import("react-native").KeyboardEvent) => void;
+    onKeyboardDidHide?: (event: import("react-native").KeyboardEvent) => void;
+    onKeyboardWillShow?: (event: import("react-native").KeyboardEvent) => void;
+    onKeyboardWillHide?: (event: import("react-native").KeyboardEvent) => void;
+    pagingEnabled?: boolean | undefined;
+    scrollEnabled?: boolean | undefined;
+    scrollEventThrottle?: number | undefined;
+    showsVerticalScrollIndicator?: boolean | undefined;
+    stickyHeaderHiddenOnScroll?: boolean | undefined;
+    stickyHeaderIndices?: ReadonlyArray<number> | undefined;
+    StickyHeaderComponent?: (props: Omit<import("react-native/types_generated/Libraries/Components/ScrollView/ScrollViewStickyHeader").ScrollViewStickyHeaderProps, keyof {
+        ref?: React.Ref<Readonly<{
+            setNextHeaderY: ($$PARAM_0$$: number) => void;
+        }>>;
+    }> & {
+        ref?: React.Ref<Readonly<{
+            setNextHeaderY: ($$PARAM_0$$: number) => void;
+        }>>;
+    }) => React.ReactNode;
+    snapToAlignment?: ("start" | "center" | "end") | undefined;
+    snapToInterval?: number | undefined;
+    snapToOffsets?: ReadonlyArray<number> | undefined;
+    snapToStart?: boolean | undefined;
+    snapToEnd?: boolean | undefined;
+    removeClippedSubviews?: boolean | undefined;
+    refreshControl?: React.JSX.Element | undefined;
+    children?: React.ReactNode;
+    innerViewRef?: React.Ref<import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default>;
+    scrollViewRef?: React.Ref<import("react-native/types_generated/Libraries/Components/ScrollView/ScrollView").PublicScrollViewInstance>;
+}>, never>> & {
+    /**
+     * Fling velocity cap as a normalized fraction in [0, 1], or `null` to
+     * disable the cap mechanism entirely.
+     *
+     * The reference maximum is 8000 dp/s on Android and 8000 pt/s on iOS
+     * (same logical unit), so the same `maxVelocity` value produces the same
+     * visual scroll speed on both platforms.
+     *
+     * - `null` / `undefined` (default) — no capper installed; behaves exactly
+     *   like a plain RN `ScrollView`.
+     * - `1` — capper installed at the reference maximum. Human-paced flings
+     *   pass through untouched.
+     * - `0` — list cannot fling at all.
+     * - `0 < x < 1` — peak fling velocity is clamped to `x × 8000` (dp/s on
+     *   Android, pt/s on iOS). Fling distance scales linearly with `x`.
+     */
+    maxVelocity?: number | null;
+} & import("react").RefAttributes<import("react-native/types_generated/Libraries/Components/ScrollView/ScrollView").PublicScrollViewInstance>>;
+//# sourceMappingURL=CappedScrollView.d.ts.map

package/lib/typescript/src/CappedScrollView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CappedScrollView.d.ts","sourceRoot":"","sources":["../../../src/CappedScrollView.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,YAAY,EAElB,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAGhE,MAAM,MAAM,mBAAmB,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;AAElE,MAAM,MAAM,qBAAqB,GAAG,eAAe,GAAG;IACpD;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAOF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAmB4jb,CAAC;;;;;;;;;;;;;;;;;;;WAA74K,CAAC;;;;WAA6F,CAAC;;;;;;;;;;;;;;;IA3C1yQ;;;;;;;;;;;;;;;OAeG;kBACW,MAAM,GAAG,IAAI;8IA0B3B,CAAC"}

package/lib/typescript/src/NativeCappedScrollView.d.ts

@@ -0,0 +1,7 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    setMaxVelocity(reactTag: number, maxVelocity: number): void;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeCappedScrollView.d.ts.map

package/lib/typescript/src/NativeCappedScrollView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeCappedScrollView.d.ts","sourceRoot":"","sources":["../../../src/NativeCappedScrollView.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7D;;AAED,wBAA0E"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,3 @@
+export { CappedScrollView } from './CappedScrollView';
+export type { CappedScrollViewProps, CappedScrollViewRef, } from './CappedScrollView';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EACV,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC"}

package/package.json

@@ -0,0 +1,188 @@
+{
+  "name": "react-native-capped-scrollview",
+  "version": "0.1.0",
+  "description": "Drop-in React Native ScrollView that caps fling velocity via a 0-1 maxVelocity prop. Fabric + TurboModules, iOS and Android.",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace react-native-capped-scrollview-example",
+    "clean": "del-cli lib",
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "test": "jest",
+    "release": "release-it --only-version"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "scrollview",
+    "scroll",
+    "fling",
+    "velocity",
+    "max-velocity",
+    "fabric",
+    "turbomodule"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leonsilicon/react-native-capped-scrollview.git"
+  },
+  "author": "Leon Si <leon@leonsilicon.com> (https://github.com/leonsilicon)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/leonsilicon/react-native-capped-scrollview/issues"
+  },
+  "homepage": "https://github.com/leonsilicon/react-native-capped-scrollview#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^20.5.0",
+    "@eslint/compat": "^2.0.3",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^10.0.1",
+    "@jest/globals": "^30.0.0",
+    "@react-native/babel-preset": "0.85.0",
+    "@react-native/eslint-config": "0.85.0",
+    "@react-native/jest-preset": "0.85.0",
+    "@release-it/conventional-changelog": "^10.0.6",
+    "@types/react": "^19.2.0",
+    "commitlint": "^20.5.0",
+    "del-cli": "^7.0.0",
+    "eslint": "^9.39.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-ft-flow": "^3.0.11",
+    "eslint-plugin-prettier": "^5.5.5",
+    "jest": "^30.3.0",
+    "lefthook": "^2.1.4",
+    "prettier": "^3.8.1",
+    "react": "19.2.0",
+    "react-native": "0.83.6",
+    "react-native-builder-bob": "^0.41.0",
+    "release-it": "^19.2.4",
+    "turbo": "^2.8.21",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-native": ">=0.80.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@4.11.0",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "CappedScrollViewSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.cappedscrollview"
+    },
+    "ios": {
+      "modules": {
+        "CappedScrollView": {
+          "className": "CappedScrollView"
+        }
+      }
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "jest": {
+    "preset": "@react-native/jest-preset",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "tools": [
+      "eslint",
+      "jest",
+      "lefthook",
+      "release-it"
+    ],
+    "version": "0.62.0"
+  }
+}

package/src/CappedScrollView.tsx

@@ -0,0 +1,57 @@
+import {
+  forwardRef,
+  useEffect,
+  useRef,
+  useImperativeHandle,
+  type ComponentRef,
+  type Ref,
+} from 'react';
+import { ScrollView, type ScrollViewProps } from 'react-native';
+import NativeCappedScrollView from './NativeCappedScrollView';
+
+export type CappedScrollViewRef = ComponentRef<typeof ScrollView>;
+
+export type CappedScrollViewProps = ScrollViewProps & {
+  /**
+   * Fling velocity cap as a normalized fraction in [0, 1], or `null` to
+   * disable the cap mechanism entirely.
+   *
+   * The reference maximum is 8000 dp/s on Android and 8000 pt/s on iOS
+   * (same logical unit), so the same `maxVelocity` value produces the same
+   * visual scroll speed on both platforms.
+   *
+   * - `null` / `undefined` (default) — no capper installed; behaves exactly
+   *   like a plain RN `ScrollView`.
+   * - `1` — capper installed at the reference maximum. Human-paced flings
+   *   pass through untouched.
+   * - `0` — list cannot fling at all.
+   * - `0 < x < 1` — peak fling velocity is clamped to `x × 8000` (dp/s on
+   *   Android, pt/s on iOS). Fling distance scales linearly with `x`.
+   */
+  maxVelocity?: number | null;
+};
+
+// Sentinel sent to native when consumers pass `null`/omit the prop, meaning
+// "no capper installed at all." Negative values are unreachable from the
+// public [0, 1] range, so this is unambiguous on the native side.
+const NO_CAP_SENTINEL = -1;
+
+export const CappedScrollView = forwardRef(function CappedScrollView(
+  { maxVelocity, ...rest }: CappedScrollViewProps,
+  ref: Ref<CappedScrollViewRef>
+) {
+  const innerRef = useRef<CappedScrollViewRef | null>(null);
+
+  useImperativeHandle(ref, () => innerRef.current as CappedScrollViewRef);
+
+  useEffect(() => {
+    const handle = innerRef.current?.getScrollableNode?.();
+    if (handle == null) {
+      return;
+    }
+    const value = maxVelocity == null ? NO_CAP_SENTINEL : maxVelocity;
+    NativeCappedScrollView.setMaxVelocity(handle, value);
+  }, [maxVelocity]);
+
+  return <ScrollView ref={innerRef} {...rest} />;
+});

package/src/NativeCappedScrollView.ts

@@ -0,0 +1,8 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setMaxVelocity(reactTag: number, maxVelocity: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('CappedScrollView');

package/src/index.tsx

@@ -0,0 +1,5 @@
+export { CappedScrollView } from './CappedScrollView';
+export type {
+  CappedScrollViewProps,
+  CappedScrollViewRef,
+} from './CappedScrollView';