diff --git a/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-playbackrate-negative.html b/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-playbackrate-negative.html
new file mode 100644
index 00000000000000..f6083299c5c8fd
--- /dev/null
+++ b/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-playbackrate-negative.html
@@ -0,0 +1,278 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>AudioBufferSourceNode: Negative PlaybackRate Edge Cases</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+</head>
+
+<body>
+  <script>
+    /**
+     * Helper to run a test on AudioBufferSourceNode.
+     * @param {number} renderFrames - Total frames to render in
+     *     OfflineAudioContext.
+     * @param {number} bufferFrames - Number of frames in the AudioBuffer.
+     * @param {Function} setupSource - Callback to configure:
+     *     (source, sampleRate) => void
+     * @param {Function} verifyResult - Callback to verify the output:
+     *     (renderedData) => void
+     * @param {Array|null} bufferData - Optional initial buffer data. If null,
+     *     populated with 1.0, 2.0, 3.0...
+     */
+    async function runSourceNodeTest(
+      renderFrames, bufferFrames, setupSource, verifyResult,
+      bufferData = null) {
+      const sampleRate = 44100;
+      const context = new OfflineAudioContext(1, renderFrames, sampleRate);
+      const buffer = new AudioBuffer({
+        numberOfChannels: 1,
+        length: bufferFrames,
+        sampleRate: sampleRate
+      });
+      const channelData = buffer.getChannelData(0);
+
+      if (bufferData) {
+        channelData.set(bufferData);
+      } else {
+        // Populate with distinct values to easily verify interpolation.
+        for (let i = 0; i < bufferFrames; i++) {
+          channelData[i] = i + 1.0;
+        }
+      }
+
+      const source = new AudioBufferSourceNode(context, { buffer });
+      source.connect(context.destination);
+
+      setupSource(source, sampleRate);
+
+      const renderedBuffer = await context.startRendering();
+      verifyResult(renderedBuffer.getChannelData(0));
+    }
+
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 4,
+        (source, sampleRate) => {
+          source.playbackRate.value = -1.0;
+          source.start(0, 3 / sampleRate);
+        },
+        (renderedData) => {
+          assert_equals(renderedData[0], 4.0, 'Frame 0 should be 4.0');
+          assert_equals(renderedData[1], 3.0, 'Frame 1 should be 3.0');
+          assert_equals(renderedData[2], 2.0, 'Frame 2 should be 2.0');
+          assert_equals(renderedData[3], 1.0, 'Frame 3 should be 1.0');
+        }
+      );
+    }, 'AudioBufferSourceNode supports negative playbackRate (-1.0)');
+
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 4,
+        (source, sampleRate) => {
+          source.playbackRate.value = -2.0;
+          source.start(0, 3 / sampleRate);
+        },
+        (renderedData) => {
+          assert_equals(renderedData[0], 4.0, 'Frame 0 should be 4.0');
+          assert_equals(renderedData[1], 2.0, 'Frame 1 should be 2.0');
+          assert_equals(renderedData[2], 0.0, 'Frame 2 should be silence');
+          assert_equals(renderedData[3], 0.0, 'Frame 3 should be silence');
+        }
+      );
+    }, 'AudioBufferSourceNode supports high negative playbackRate (-2.0)');
+
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 8,
+        (source, sampleRate) => {
+          source.playbackRate.value = -5.0;
+          source.start(0, 7 / sampleRate);
+        },
+        (renderedData) => {
+          assert_equals(renderedData[0], 8.0, 'Frame 0 should be 8.0');
+          assert_equals(renderedData[1], 3.0, 'Frame 1 should be 3.0');
+          assert_equals(renderedData[2], 0.0, 'Frame 2 should be silence');
+          assert_equals(renderedData[3], 0.0, 'Frame 3 should be silence');
+        }
+      );
+    }, 'AudioBufferSourceNode supports high negative playbackRate (-5.0)');
+
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 2,
+        (source, sampleRate) => {
+          source.playbackRate.value = -0.5;
+          source.start(0, 1 / sampleRate);
+        },
+        (renderedData) => {
+          assert_equals(renderedData[0], 2.0, 'Frame 0 should be 2.0');
+          assert_equals(renderedData[1], 1.5, 'Frame 1 should be 1.5');
+          assert_equals(renderedData[2], 1.0, 'Frame 2 should be 1.0');
+          assert_equals(renderedData[3], 0.0, 'Frame 3 should be silence');
+        }
+      );
+    }, 'AudioBufferSourceNode supports fractional negative playbackRate');
+
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 4,
+        (source, sampleRate) => {
+          source.playbackRate.value = -0.02;
+          source.start(0, 3 / sampleRate);
+        },
+        (renderedData) => {
+          assert_approx_equals(renderedData[0], 4.00, 1e-4, 'Frame 0');
+          assert_approx_equals(renderedData[1], 3.98, 1e-4, 'Frame 1');
+          assert_approx_equals(renderedData[2], 3.96, 1e-4, 'Frame 2');
+          assert_approx_equals(renderedData[3], 3.94, 1e-4, 'Frame 3');
+        }
+      );
+    }, 'AudioBufferSourceNode supports very low negative playbackRate (-0.02)');
+
+    // EDGE CASE: Offset post loopEnd
+    promise_test(async () => {
+      await runSourceNodeTest(
+        6, 8,
+        (source, sampleRate) => {
+          source.loop = true;
+          source.loopStart = 2 / sampleRate;
+          source.loopEnd = 4 / sampleRate;
+          source.playbackRate.value = -1.0;
+          source.start(0, 6 / sampleRate);
+        },
+        (renderedData) => {
+          const expected = [7.0, 6.0, 5.0, 4.0, 3.0, 4.0];
+          for (let i = 0; i < expected.length; i++) {
+            assert_equals(
+              renderedData[i], expected[i],
+              `Frame ${i} should be ${expected[i]}`);
+          }
+        }
+      );
+    }, 'AudioBufferSourceNode enters loop backwards from offset > loopEnd');
+
+    // EDGE CASE: offset < loopStart
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 8,
+        (source, sampleRate) => {
+          source.loop = true;
+          source.loopStart = 4 / sampleRate;
+          source.loopEnd = 6 / sampleRate;
+          source.playbackRate.value = -1.0;
+          source.start(0, 2 / sampleRate);
+        },
+        (renderedData) => {
+          // Spec clamps offset to loopStart when playbackRate < 0.
+          const expected = [5.0, 6.0, 5.0, 6.0];
+          for (let i = 0; i < expected.length; i++) {
+            assert_equals(
+              renderedData[i], expected[i],
+              `Frame ${i} should be ${expected[i]}`);
+          }
+        }
+      );
+    }, 'AudioBufferSourceNode clamps offset to loopStart for playbackRate < 0');
+
+    // EDGE CASE: offset in loop
+    promise_test(async () => {
+      await runSourceNodeTest(
+        8, 4,
+        (source, sampleRate) => {
+          source.playbackRate.value = -1.0;
+          source.loop = true;
+          source.loopStart = 1 / sampleRate;
+          source.loopEnd = 3 / sampleRate;
+          source.start(0, 2 / sampleRate);
+        },
+        (renderedData) => {
+          const expected = [3.0, 2.0, 3.0, 2.0, 3.0, 2.0, 3.0, 2.0];
+          for (let i = 0; i < expected.length; i++) {
+            assert_equals(
+              renderedData[i], expected[i],
+              `Frame ${i} should be ${expected[i]}`);
+          }
+        }
+      );
+    }, 'AudioBufferSourceNode loops backwards with negative rate ' +
+    '(offset in loop)');
+
+    // EDGE CASE: offset = buffer.duration
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 4,
+        (source, sampleRate) => {
+          source.playbackRate.value = -1.0;
+          source.start(0, 4 / sampleRate);
+        },
+        (renderedData) => {
+          const expected = [0.0, 4.0, 3.0, 2.0];
+          for (let i = 0; i < expected.length; i++) {
+            assert_equals(
+              renderedData[i], expected[i],
+              `Frame ${i} should be ${expected[i]}`);
+          }
+        }
+      );
+    }, 'AudioBufferSourceNode handles offset exactly at duration with ' +
+    'negative rate');
+
+    // EDGE CASE: offset > buffer.duration (out-of-bounds offset clamped)
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 4,
+        (source, sampleRate) => {
+          source.playbackRate.value = -1.0;
+          source.start(0, 10 / sampleRate);
+        },
+        (renderedData) => {
+          assert_equals(renderedData[0], 0.0, 'Frame 0 should be silence');
+          assert_equals(renderedData[1], 4.0, 'Frame 1 should be 4.0');
+          assert_equals(renderedData[2], 3.0, 'Frame 2 should be 3.0');
+          assert_equals(renderedData[3], 2.0, 'Frame 3 should be 2.0');
+        }
+      );
+    }, 'AudioBufferSourceNode handles out-of-bounds start offset correctly');
+
+    // Sub-sample interpolation backwards
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 4,
+        (source, sampleRate) => {
+          source.playbackRate.value = -1.0;
+          source.start(0, 2.5 / sampleRate);
+        },
+        (renderedData) => {
+          const expected = [3.5, 2.5, 1.5, 0.0];
+          for (let i = 0; i < expected.length; i++) {
+            assert_approx_equals(
+              renderedData[i], expected[i], 1e-4,
+              `Frame ${i} should be approx ${expected[i]}`);
+          }
+        }
+      );
+    }, 'AudioBufferSourceNode performs sub-sample interpolation backwards');
+
+    promise_test(async () => {
+      await runSourceNodeTest(
+        4, 4,
+        (source, sampleRate) => {
+          source.loop = true;
+          source.loopStart = 2 / sampleRate;
+          source.loopEnd = 2 / sampleRate;
+          source.playbackRate.value = 0;
+          source.start(0, 2 / sampleRate);
+        },
+        (renderedData) => {
+          assert_true(true, 'Test ran successfully!');
+        }
+      );
+    }, 'AudioBufferSourceNode ran successfully with zero delta and ' +
+    'playbackRate 0');
+
+  </script>
+</body>
+
+</html>
