diff --git a/scroll-animations/progress-based-current-time.tenative.html b/scroll-animations/progress-based-current-time.tenative.html
new file mode 100644
index 00000000000000..8a8ccfcff8b2ba
--- /dev/null
+++ b/scroll-animations/progress-based-current-time.tenative.html
@@ -0,0 +1,501 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>ScrollTimeline current time algorithm</title>
+<link rel="help" href="https://wicg.github.io/scroll-animations/#current-time-algorithm">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/web-animations/testcommon.js"></script>
+<script src="./resources/scrolltimeline-utils.js"></script>
+<script src="./testcommon.js"></script>
+
+<body></body>
+
+<script>
+'use strict';
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollerSize = scroller.scrollHeight - scroller.clientHeight;
+  const blockScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller
+  });
+
+  assert_equals(blockScrollTimeline.duration.unit, "percent",
+      "duration returns as a percent for scroll timelines");
+  assert_equals(blockScrollTimeline.duration.value, 100, "duration is 100%");
+}, "Scroll timeline correctly returns duration as 100%");
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollerSize = scroller.scrollHeight - scroller.clientHeight;
+
+  const blockScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block'
+  });
+  const inlineScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'inline'
+  });
+  const horizontalScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'horizontal'
+  });
+  const verticalScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'vertical'
+  });
+
+  // Unscrolled, all timelines should read a currentTime of 0.
+  assert_percent_css_unit_value_approx_equals(
+      blockScrollTimeline.currentTime, 0, 0, 'Unscrolled block timeline');
+  assert_percent_css_unit_value_approx_equals(
+      inlineScrollTimeline.currentTime, 0, 0, 'Unscrolled inline timeline');
+  assert_percent_css_unit_value_approx_equals(
+      horizontalScrollTimeline.currentTime, 0, 0,
+      'Unscrolled horizontal timeline');
+  assert_percent_css_unit_value_approx_equals(
+      verticalScrollTimeline.currentTime, 0, 0, 'Unscrolled vertical timeline');
+
+  // Do some scrolling and make sure that the ScrollTimelines update.
+  scroller.scrollTop = 50;
+  scroller.scrollLeft = 75;
+  // Wait for new animation frame  which allows the timeline to compute new
+  // current time.
+  await waitForNextFrame();
+
+  assert_percent_css_unit_value_approx_equals(
+      blockScrollTimeline.currentTime, 12.048, 0.01, 'Scrolled block timeline');
+  assert_percent_css_unit_value_approx_equals(
+      inlineScrollTimeline.currentTime, 18.072, 0.01, 'Scrolled inline timeline');
+  assert_percent_css_unit_value_approx_equals(
+      horizontalScrollTimeline.currentTime, 18.072, 0.01, 'Scrolled horizontal timeline');
+  assert_percent_css_unit_value_approx_equals(
+      verticalScrollTimeline.currentTime, 12.048, 0.01, 'Scrolled vertical timeline');
+}, 'currentTime calculates the correct time based on scroll progress');
+
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollerSize = scroller.scrollHeight - scroller.clientHeight;
+
+  const lengthScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    startScrollOffset: CSS.px(20)
+  });
+  const percentageScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    startScrollOffset: CSS.percent(20)
+  });
+  const calcScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    startScrollOffset: CSS.percent(20).sub(CSS.px(5))
+  });
+
+  // Unscrolled all timelines should read a current time of 0, as the
+  // current offset (0) will be less than the startScrollOffset.
+  assert_percent_css_unit_value_approx_equals(
+      lengthScrollTimeline.currentTime, 0, 0,
+      'Unscrolled length-based timeline current time');
+  assert_equals(
+      lengthScrollTimeline.phase, "before",
+      'Unscrolled length-based timeline phase');
+  assert_percent_css_unit_value_approx_equals(
+      percentageScrollTimeline.currentTime, 0, 0,
+      'Unscrolled percentage-based timeline current time');
+  assert_equals(
+    percentageScrollTimeline.phase, "before",
+      'Unscrolled percentage-based timeline phase');
+  assert_percent_css_unit_value_approx_equals(
+      calcScrollTimeline.currentTime, 0, 0,
+      'Unscrolled calc-based timeline current time');
+  assert_equals(
+      calcScrollTimeline.phase, "before",
+      'Unscrolled calc-based timeline phase');
+
+  // Check the length-based ScrollTimeline.
+  scroller.scrollTop = 19;
+  // Wait for new animation frame  which allows the timeline to compute new
+  // current time.
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      lengthScrollTimeline.currentTime, 0, 0,
+      'Length-based timeline current time before the startScrollOffset'
+      + ' point');
+  assert_equals(
+      lengthScrollTimeline.phase, "before",
+      'Length-based timeline phase before the startScrollOffset point');
+  scroller.scrollTop = 20;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      lengthScrollTimeline.currentTime, 0, 0,
+      'Length-based timeline current time at the startScrollOffset point');
+  assert_equals(
+      lengthScrollTimeline.phase, "active",
+      'Length-based timeline phase at the startScrollOffset point');
+  scroller.scrollTop = 50;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      lengthScrollTimeline.currentTime,
+      calculateCurrentTime(50, 20, scrollerSize, 100), 0.01,
+      'Length-based timeline current time after the startScrollOffset point');
+  assert_equals(
+      lengthScrollTimeline.phase, "active",
+      'Length-based timeline phase after the startScrollOffset point');
+
+  // Check the percentage-based ScrollTimeline.
+  scroller.scrollTop = 0.19 * scrollerSize;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      percentageScrollTimeline.currentTime, 0, 0,
+      'Percentage-based timeline current time before the startScrollOffset'
+      + ' point');
+  assert_equals(
+      percentageScrollTimeline.phase, "before",
+      'Percentage-based timeline phase before the startScrollOffset point');
+  scroller.scrollTop = 0.20 * scrollerSize;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      percentageScrollTimeline.currentTime, 0, 0,
+      'Percentage-based timeline current time at the startScrollOffset point');
+  assert_equals(
+      percentageScrollTimeline.phase, "active",
+      'Percentage-based timeline phase at the startScrollOffset point');
+  scroller.scrollTop = 0.50 * scrollerSize;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      percentageScrollTimeline.currentTime,
+      calculateCurrentTime(
+          scroller.scrollTop, 0.2 * scrollerSize, scrollerSize, 100), 0.01,
+      'Percentage-based timeline current time after the startScrollOffset'
+      + ' point');
+  assert_equals(
+      percentageScrollTimeline.phase, "active",
+      'Percentage-based timeline phase after the startScrollOffset point');
+
+  // Check the calc-based ScrollTimeline.
+  scroller.scrollTop = 0.2 * scrollerSize - 10;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      calcScrollTimeline.currentTime, 0, 0,
+      'Calc-based timeline current time before the startScrollOffset point');
+  assert_equals(
+      calcScrollTimeline.phase, "before",
+      'Calc-based timeline phase at the startScrollOffset point');
+  scroller.scrollTop = 0.2 * scrollerSize - 5;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      calcScrollTimeline.currentTime, 0, 0,
+      'Calc-based timeline current time at the startScrollOffset point');
+  assert_equals(
+      calcScrollTimeline.phase, "active",
+      'Calc-based timeline phase at the startScrollOffset point');
+  scroller.scrollTop = 0.2 * scrollerSize;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      calcScrollTimeline.currentTime,
+      calculateCurrentTime(
+          scroller.scrollTop, 0.2 * scrollerSize - 5, scrollerSize,
+          100), 0.01,
+      'Calc-based timeline current time after the startScrollOffset point');
+  assert_equals(
+      calcScrollTimeline.phase, "active",
+      'Calc-based timeline phase at the startScrollOffset point');
+}, 'currentTime handles startScrollOffset correctly');
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollerSize = scroller.scrollHeight - scroller.clientHeight;
+
+  // When the endScrollOffset is equal to the maximum scroll offset (and there
+  // are no fill modes), the endScrollOffset is treated as inclusive.
+  const inclusiveAutoScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    endScrollOffset: 'auto'
+  });
+  const inclusiveLengthScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    endScrollOffset: CSS.px(scrollerSize)
+  });
+  const inclusivePercentageScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    endScrollOffset: CSS.percent(100)
+  });
+  const inclusiveCalcScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    endScrollOffset: CSS.percent(80).add(CSS.px(0.2 * scrollerSize))
+  });
+
+  scroller.scrollTop = scrollerSize;
+  let expectedCurrentTime = calculateCurrentTime(
+      scroller.scrollTop, 0, scrollerSize, 100);
+
+  // Wait for new animation frame  which allows the timeline to compute new
+  // current time.
+  await waitForNextFrame();
+
+  assert_percent_css_unit_value_approx_equals(
+    inclusiveAutoScrollTimeline.currentTime, expectedCurrentTime, 0.01,
+    'Inclusive auto timeline at the endScrollOffset point');
+  assert_percent_css_unit_value_approx_equals(
+    inclusiveLengthScrollTimeline.currentTime, expectedCurrentTime, 0.01, 0.01,
+    'Inclusive length-based timeline at the endScrollOffset point');
+  assert_percent_css_unit_value_approx_equals(
+    inclusivePercentageScrollTimeline.currentTime, expectedCurrentTime, 0.01,
+    'Inclusive percentage-based timeline at the endScrollOffset point');
+  assert_percent_css_unit_value_approx_equals(
+    inclusiveCalcScrollTimeline.currentTime, expectedCurrentTime, 0.01,
+    'Inclusive calc-based timeline at the endScrollOffset point');
+}, 'currentTime handles endScrollOffset correctly (inclusive cases)');
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollerSize = scroller.scrollHeight - scroller.clientHeight;
+
+  const lengthScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    endScrollOffset: CSS.px(scrollerSize - 20)
+  });
+  const percentageScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    endScrollOffset: CSS.percent(80)
+  });
+  const calcScrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    endScrollOffset: CSS.percent(80).add(CSS.px(5))
+  });
+
+  // Check the length-based ScrollTimeline.
+  scroller.scrollTop = scrollerSize;
+  // Wait for new animation frame  which allows the timeline to compute new
+  // current time.
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      lengthScrollTimeline.currentTime, 100, 0.01,
+      'Length-based timeline current time after the endScrollOffset point');
+  assert_equals(
+      lengthScrollTimeline.phase, "after",
+      'Length-based timeline phase after the endScrollOffset point');
+  scroller.scrollTop = scrollerSize - 20;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      lengthScrollTimeline.currentTime, 100, 0.01,
+      'Length-based timeline current time at the endScrollOffset point');
+  assert_equals(
+      lengthScrollTimeline.phase, "after",
+      'Length-based timeline phase at the endScrollOffset point');
+  scroller.scrollTop = scrollerSize - 50;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      lengthScrollTimeline.currentTime,
+      calculateCurrentTime(
+          scrollerSize - 50, 0, scrollerSize - 20, 100), 0.01,
+      'Length-based timeline current time before the endScrollOffset point');
+  assert_equals(
+      lengthScrollTimeline.phase, "active",
+      'Length-based timeline phase before the endScrollOffset point');
+
+  // Check the percentage-based ScrollTimeline.
+  scroller.scrollTop = 0.81 * scrollerSize;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      percentageScrollTimeline.currentTime, 100, 0.01,
+      'Percentage-based timeline current time after the endScrollOffset point');
+  assert_equals(
+      percentageScrollTimeline.phase, "after",
+      'Percentage-based timeline phase after the endScrollOffset point');
+  scroller.scrollTop = 0.80 * scrollerSize;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      percentageScrollTimeline.currentTime, 100, 0.01,
+      'Percentage-based timeline current time at the endScrollOffset point');
+  assert_equals(
+      percentageScrollTimeline.phase, "after",
+      'Percentage-based timeline phase at the endScrollOffset point');
+  scroller.scrollTop = 0.50 * scrollerSize;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      percentageScrollTimeline.currentTime,
+      calculateCurrentTime(
+          scroller.scrollTop, 0, 0.8 * scrollerSize, 100), 0.01,
+      'Percentage-based timeline current time before the endScrollOffset point');
+  assert_equals(
+      percentageScrollTimeline.phase, "active",
+      'Percentage-based timeline phase before the endScrollOffset point');
+
+  // Check the calc-based ScrollTimeline.
+  scroller.scrollTop = 0.8 * scrollerSize + 6;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      calcScrollTimeline.currentTime, 100, 0.01,
+      'Calc-based timeline current time after the endScrollOffset point');
+  assert_equals(
+      calcScrollTimeline.phase, "after",
+      'Calc-based timeline phase after the endScrollOffset point');
+  scroller.scrollTop = 0.8 * scrollerSize + 5;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      calcScrollTimeline.currentTime, 100, 0.01,
+      'Calc-based timeline current time at the endScrollOffset point');
+  assert_equals(
+      calcScrollTimeline.phase, "after",
+      'Calc-based timeline phase at the endScrollOffset point');
+  scroller.scrollTop = 0.5 * scrollerSize;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      calcScrollTimeline.currentTime,
+      calculateCurrentTime(
+          scroller.scrollTop, 0, 0.8 * scrollerSize + 5, 100), 0.01,
+      'Calc-based timeline current time before the endScrollOffset point');
+  assert_equals(
+      calcScrollTimeline.phase, "active",
+      'Calc-based timeline phase before the endScrollOffset point');
+}, 'currentTime handles endScrollOffset correctly');
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollerSize = scroller.scrollHeight - scroller.clientHeight;
+
+  const scrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    startScrollOffset: CSS.px(20),
+    endScrollOffset: CSS.px(scrollerSize - 50)
+  });
+
+  scroller.scrollTop = 150;
+  // Wait for new animation frame  which allows the timeline to compute new
+  // current time.
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+      scrollTimeline.currentTime,
+      calculateCurrentTime(150, 20, scrollerSize - 50, 100), 0.01);
+}, 'currentTime handles startScrollOffset and endScrollOffset together correctly');
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    startScrollOffset: CSS.px(20),
+    endScrollOffset: CSS.px(20)
+  });
+
+  scroller.scrollTop = 150;
+  // Wait for new animation frame  which allows the timeline to compute new
+  // current time.
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(scrollTimeline.currentTime,
+      100, 0.01);
+}, 'currentTime handles startScrollOffset == endScrollOffset correctly');
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    startScrollOffset: CSS.px(50),
+    endScrollOffset: CSS.px(10)
+  });
+
+  scroller.scrollTop = 40;
+  // Wait for new animation frame  which allows the timeline to compute new
+  // current time.
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(scrollTimeline.currentTime, 0, 0.01);
+  scroller.scrollTop = 60;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(scrollTimeline.currentTime, 100, 0.01);
+}, 'currentTime handles startScrollOffset > endScrollOffset correctly');
+
+promise_test(async t => {
+  const scroller = setupScrollTimelineTest();
+  const scrollTimeline = new ScrollTimeline({
+    scrollSource: scroller,
+    orientation: 'block',
+    scrollOffsets: [CSS.px(10), CSS.px(20), CSS.px(40), CSS.px(70), CSS.px(90)],
+  });
+
+  var offset = 0;
+  var w = 1 / 4; // offset weight
+  var p = 0;         // progress within the offset
+
+  scroller.scrollTop = 10;
+  // Wait for new animation frame  which allows the timeline to compute new
+  // current time.
+  await waitForNextFrame();
+
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, (offset + p) * w * 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+
+  p = (12 - 10) / (20 - 10);
+  scroller.scrollTop = 12;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, (offset + p) * w * 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+
+  offset = 1;
+  p = 0;
+  scroller.scrollTop = 20;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, (offset + p) * w * 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+
+  p = (35 - 20) / (40 - 20);
+  scroller.scrollTop = 35;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, (offset + p) * w * 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+
+  offset = 2;
+  p = 0;
+  scroller.scrollTop = 40;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, (offset + p) * w * 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+
+  p = (60 - 40) / (70 - 40);
+  scroller.scrollTop = 60;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, (offset + p) * w * 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+
+  offset = 3;
+  p = 0;
+  scroller.scrollTop = 70;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, (offset + p) * w * 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+
+  p = (80 - 70) / (90 - 70);
+  scroller.scrollTop = 80;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, (offset + p) * w * 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+
+  scroller.scrollTop = 90;
+  await waitForNextFrame();
+  assert_percent_css_unit_value_approx_equals(
+    scrollTimeline.currentTime, 100, 0.01,
+    "current time calculation when scroll = " + scroller.scrollTop);
+}, 'currentTime calculations when multiple scroll offsets are specified');
+
+</script>
diff --git a/scroll-animations/testcommon.js b/scroll-animations/testcommon.js
index d9fc153887c5fc..9b3e82228fcdb3 100644
--- a/scroll-animations/testcommon.js
+++ b/scroll-animations/testcommon.js
@@ -55,3 +55,11 @@ function assert_approx_equals_or_null(actual, expected, tolerance, name){
     assert_approx_equals(actual, expected, tolerance, name);
   }
 }
+
+// actual should be a CSSUnitValue and expected should be a double value 0-100
+function assert_percent_css_unit_value_approx_equals(actual, expected, tolerance, name){
+  assert_true(actual instanceof CSSUnitValue, "'actual' must be of type CSSUnitValue");
+  assert_equals(typeof expected, "number", "'expected' should be a number (0-100)");
+  assert_equals(actual.unit, "percent", "'actual' unit type must be 'percent'");
+  assert_approx_equals(actual.value, expected, tolerance, name);
+}
\ No newline at end of file
