Merge pull request #7516 from cloudflare/jasnell/ts-streams-detached-dataview

Read detached and out-of-bounds DataView chunks as empty

Author: jasnell

src/per_isolate/crypto/digest-stream.ts

@@ -55,18 +55,16 @@ import type {
   UnderlyingSink,
   WritableStream as WritableStreamType,
 } from '../webstreams/types';
+import type { ViewExtentHelpers } from '../webstreams/view-extent';
 
 const {
   ArrayBufferPrototypeByteLengthGet,
   BigInt,
-  DataViewPrototypeGetByteLength,
   ObjectDefineProperties,
   PromiseWithResolvers,
   SymbolDispose,
   SymbolToStringTag,
   TypeError,
-  TypedArrayPrototypeGetByteLength,
-  TypedArrayPrototypeGetSymbolToStringTag,
 } = primordials;
 
 const {
@@ -79,6 +77,8 @@ const {
 const { WritableStream } = require('webstreams/writable') as {
   WritableStream: typeof WritableStreamType;
 };
+const { viewByteLength } =
+  require('webstreams/view-extent') as ViewExtentHelpers;
 
 type Chunk = ArrayBuffer | ArrayBufferView | string;
 
@@ -104,12 +104,9 @@ function byteLengthOf(chunk: ArrayBuffer | ArrayBufferView): number {
   if (isArrayBuffer(chunk)) {
     return ArrayBufferPrototypeByteLengthGet(chunk);
   }
-  // A view: either a TypedArray or a DataView. The tag getter returns the
-  // internal [[TypedArrayName]], and undefined for a DataView.
-  if (TypedArrayPrototypeGetSymbolToStringTag(chunk) !== undefined) {
-    return TypedArrayPrototypeGetByteLength(chunk as Uint8Array);
-  }
-  return DataViewPrototypeGetByteLength(chunk as DataView);
+  // A detached or out-of-bounds view, DataViews included, is empty (see
+  // webstreams/view-extent.ts).
+  return viewByteLength(chunk);
 }
 
 // Collapses the WebCrypto-style `string | { name }` algorithm parameter to a

src/per_isolate/webstreams/AGENTS.md

@@ -13,6 +13,7 @@ private-brand dispatch, no `instanceof`) apply here — see
 | File          | Role                                                                                         |
 | ------------- | -------------------------------------------------------------------------------------------- |
 | `ring-buffer.ts` | O(1) FIFO with indexed access backing every internal queue below; leaf module             |
+| `view-extent.ts` | A caller-supplied view's byte extent through captured getters; detached/out-of-bounds views (DataViews included) read as empty; leaf module |
 | `queue.ts`    | QUEUED backend: single-queue/multi-cursor, JS sources; fence interfaces; invariant list      |
 | `native.ts`   | NATIVE backend: C++-backed pull conduit; **the C++/JS contract** + invariants                |
 | `readable.ts` | Reader layer + queued controllers + the BACKEND-DISPATCH points (constructor, tee, chains, byte-capable gate, JS-to-C++ extraction) |

src/per_isolate/webstreams/compression.ts

@@ -37,19 +37,16 @@ import type {
   RingBuffer as RingBufferType,
   RingBufferConstructor,
 } from './ring-buffer';
+import type { ViewExtentHelpers } from './view-extent';
 
 const {
   ArrayBufferPrototypeByteLengthGet,
   DataViewPrototypeGetBuffer,
-  DataViewPrototypeGetByteLength,
-  DataViewPrototypeGetByteOffset,
   MathMin,
   ObjectDefineProperties,
   SymbolToStringTag,
   TypeError,
   TypedArrayPrototypeGetBuffer,
-  TypedArrayPrototypeGetByteLength,
-  TypedArrayPrototypeGetByteOffset,
   TypedArrayPrototypeSet,
   Uint8Array,
   uncurryThis,
@@ -71,6 +68,8 @@ const {
   WritableStreamDefaultController,
   internalsForPipe: writableInternals,
 } = require('webstreams/writable');
+const { viewByteExtent } =
+  require('webstreams/view-extent') as ViewExtentHelpers;
 const { RingBuffer } = require('webstreams/ring-buffer') as {
   RingBuffer: RingBufferConstructor;
 };
@@ -142,8 +141,8 @@ function isValidChunk(chunk: unknown): boolean {
 // detaching, or mutating the buffer after write() returns cannot change
 // what the codec consumes — matching the C++ implementation, whose adapter
 // copies inside write() for exactly these hazards. Detached or
-// out-of-bounds inputs report zero length through the captured getters and
-// copy as empty (a codec no-op).
+// out-of-bounds inputs, DataViews included, copy as empty (a codec no-op;
+// see view-extent.ts).
 function snapshotChunk(chunk: unknown): Uint8Array {
   if (!isValidChunk(chunk)) {
     throw new TypeError(
@@ -157,15 +156,11 @@ function snapshotChunk(chunk: unknown): Uint8Array {
     buffer = chunk as ArrayBuffer;
     byteOffset = 0;
     byteLength = ArrayBufferPrototypeByteLengthGet(chunk) as number;
-  } else if (isDataView(chunk)) {
-    buffer = DataViewPrototypeGetBuffer(chunk) as ArrayBuffer;
-    byteOffset = DataViewPrototypeGetByteOffset(chunk) as number;
-    byteLength = DataViewPrototypeGetByteLength(chunk) as number;
   } else {
-    const view = chunk as ArrayBufferView;
-    buffer = TypedArrayPrototypeGetBuffer(view) as ArrayBuffer;
-    byteOffset = TypedArrayPrototypeGetByteOffset(view) as number;
-    byteLength = TypedArrayPrototypeGetByteLength(view) as number;
+    const extent = viewByteExtent(chunk as ArrayBufferView);
+    buffer = extent.buffer as ArrayBuffer;
+    byteOffset = extent.byteOffset;
+    byteLength = extent.byteLength;
   }
   const copy = new Uint8Array(byteLength);
   if (byteLength > 0) {

src/per_isolate/webstreams/identity.ts

@@ -20,7 +20,8 @@
 //     processChunk copies inside write() for exactly these hazards).
 //   - Zero-length writes are accepted as NO-OPS: the write resolves
 //     immediately without touching the readable queue (no zero-length
-//     chunk enqueued, no backpressure interaction, no pull).
+//     chunk enqueued, no backpressure interaction, no pull). A view whose
+//     buffer is detached or out of bounds is zero-length, as in C++.
 //
 // See /src/tests/streams/identity/AGENTS.md for the IdentityTransformStream
 // and FixedLengthStream specification.
@@ -90,15 +91,13 @@ import type {
   RingBuffer as RingBufferType,
   RingBufferConstructor,
 } from './ring-buffer';
+import type { ViewExtentHelpers } from './view-extent';
 
 const {
   ArrayBuffer,
   ArrayPrototypePush,
   ArrayBufferPrototypeByteLengthGet,
   BigInt,
-  DataViewPrototypeGetBuffer,
-  DataViewPrototypeGetByteLength,
-  DataViewPrototypeGetByteOffset,
   Number,
   ObjectDefineProperties,
   ObjectFreeze,
@@ -115,7 +114,6 @@ const {
   TypedArrayPrototypeGetBuffer,
   TypedArrayPrototypeGetByteLength,
   TypedArrayPrototypeGetByteOffset,
-  TypedArrayPrototypeGetSymbolToStringTag,
   TypedArrayPrototypeSet,
   Uint8Array,
   uncurryThis,
@@ -134,6 +132,8 @@ const {
   WritableStreamDefaultController,
   internalsForPipe: writableInternals,
 } = require('webstreams/writable');
+const { viewByteExtent, viewByteLength } =
+  require('webstreams/view-extent') as ViewExtentHelpers;
 const { RingBuffer } = require('webstreams/ring-buffer') as {
   RingBuffer: RingBufferConstructor;
 };
@@ -205,28 +205,13 @@ function validateAndCopyChunk(chunk: unknown): Uint8Array | undefined {
     return copy;
   }
   if (isArrayBufferView(chunk)) {
-    const isDataView =
-      TypedArrayPrototypeGetSymbolToStringTag(chunk) === undefined;
-    const byteOffset = (
-      isDataView
-        ? DataViewPrototypeGetByteOffset(chunk)
-        : TypedArrayPrototypeGetByteOffset(chunk)
-    ) as number;
-    const byteLength = (
-      isDataView
-        ? DataViewPrototypeGetByteLength(chunk)
-        : TypedArrayPrototypeGetByteLength(chunk)
-    ) as number;
+    // A detached or out-of-bounds view is empty (see view-extent.ts).
+    const { buffer, byteOffset, byteLength } = viewByteExtent(chunk);
     if (byteLength === 0) return undefined;
-    const buffer = (
-      isDataView
-        ? DataViewPrototypeGetBuffer(chunk)
-        : TypedArrayPrototypeGetBuffer(chunk)
-    ) as ArrayBuffer;
     const copy = new Uint8Array(new ArrayBuffer(byteLength));
     TypedArrayPrototypeSet(
       copy,
-      new Uint8Array(buffer, byteOffset, byteLength)
+      new Uint8Array(buffer as ArrayBuffer, byteOffset, byteLength)
     );
     return copy;
   }
@@ -271,13 +256,7 @@ function byteSize(chunk: unknown): number {
   // byteSize runs only on chunks validateAndCopyChunk has already
   // accepted (sizeAndSnapshot validates before sizing), so anything that
   // is not a string or (Shared)ArrayBuffer is an ArrayBufferView.
-  const isDataView =
-    TypedArrayPrototypeGetSymbolToStringTag(chunk) === undefined;
-  return (
-    isDataView
-      ? DataViewPrototypeGetByteLength(chunk)
-      : TypedArrayPrototypeGetByteLength(chunk)
-  ) as number;
+  return viewByteLength(chunk as ArrayBufferView);
 }
 
 let assertIsIdentityTransformStream: (self: IdentityTransformStream) => void;

src/per_isolate/webstreams/readable.ts

@@ -110,6 +110,10 @@ const {
   internalsForPipe: writableInternals,
 } = require('webstreams/writable');
 
+import type { ViewExtentHelpers } from './view-extent';
+const { viewByteExtent } =
+  require('webstreams/view-extent') as ViewExtentHelpers;
+
 // The native backend (see the fence conventions in native.ts and
 // queue.ts). The cast restores the real shape the untyped loader erases,
 // so the brand predicates keep their type-guard narrowing.
@@ -4838,27 +4842,16 @@ async function collectChunks<R>(
       // Drained chunks are untrusted values: any BufferSource contributes
       // its bytes, with the extent pinned at drain time; anything else
       // fails with the same TypeError the C++ bridge pump uses. Detached
-      // inputs are skipped with the other empties.
+      // or out-of-bounds inputs are skipped with the other empties (see
+      // view-extent.ts).
       let buffer: ArrayBufferLike;
       let byteOffset: number;
       let byteLength: number;
       if (isArrayBufferView(chunk)) {
-        // Probe detachment through the buffer before getViewInfo: a
-        // detached DataView's byteLength getter throws (typed arrays and
-        // raw buffers just report 0). A SharedArrayBuffer cannot be
-        // detached, and the probe rejects it as a receiver.
-        buffer =
-          TypedArrayPrototypeGetSymbolToStringTag(chunk) !== undefined
-            ? TypedArrayPrototypeGetBuffer(chunk)
-            : DataViewPrototypeGetBuffer(chunk as DataView);
-        if (
-          !isSharedArrayBuffer(buffer) &&
-          ArrayBufferPrototypeDetachedGet(buffer)
-        )
-          continue;
-        const info = getViewInfo(chunk);
-        byteOffset = info.byteOffset;
-        byteLength = info.byteLength;
+        const extent = viewByteExtent(chunk);
+        buffer = extent.buffer;
+        byteOffset = extent.byteOffset;
+        byteLength = extent.byteLength;
       } else if (isArrayBuffer(chunk)) {
         buffer = chunk;
         byteOffset = 0;

src/per_isolate/webstreams/view-extent.ts

@@ -0,0 +1,75 @@
+'use strict';
+
+// The byte extent of an ArrayBufferView, read through captured getters, for
+// code that consumes caller-supplied views (the internal transform pairs'
+// write paths, the digest stream, byte-counting strategies, body
+// collection).
+//
+// A view whose buffer has been detached, or that a resizable buffer has
+// shrunk out from under, has no bytes: the typed-array getters report
+// byteOffset and byteLength 0 for it, but the DataView getters throw a
+// TypeError. These helpers give a DataView the typed arrays' answer, so
+// such a view reads as empty whichever kind it is — as it does in the C++
+// implementation, which treats it as zero-length. Leaf module: requires
+// nothing.
+
+const {
+  DataViewPrototypeGetBuffer,
+  DataViewPrototypeGetByteLength,
+  DataViewPrototypeGetByteOffset,
+  TypedArrayPrototypeGetBuffer,
+  TypedArrayPrototypeGetByteLength,
+  TypedArrayPrototypeGetByteOffset,
+  TypedArrayPrototypeGetSymbolToStringTag,
+} = primordials;
+
+interface ViewExtent {
+  buffer: ArrayBufferLike;
+  byteOffset: number;
+  byteLength: number;
+}
+
+// PRECONDITION: isArrayBufferView(view). A view without a [[TypedArrayName]]
+// is a DataView, whose getters brand-check the receiver; they throw only for
+// a detached or out-of-bounds view.
+function viewByteLength(view: ArrayBufferView): number {
+  if (TypedArrayPrototypeGetSymbolToStringTag(view) !== undefined) {
+    return TypedArrayPrototypeGetByteLength(view) as number;
+  }
+  try {
+    return DataViewPrototypeGetByteLength(view as DataView) as number;
+  } catch {
+    return 0;
+  }
+}
+
+// PRECONDITION: isArrayBufferView(view). The buffer getters never throw.
+function viewByteExtent(view: ArrayBufferView): ViewExtent {
+  if (TypedArrayPrototypeGetSymbolToStringTag(view) !== undefined) {
+    return {
+      __proto__: null,
+      buffer: TypedArrayPrototypeGetBuffer(view),
+      byteOffset: TypedArrayPrototypeGetByteOffset(view),
+      byteLength: TypedArrayPrototypeGetByteLength(view),
+    } as ViewExtent;
+  }
+  const dataView = view as DataView;
+  const buffer = DataViewPrototypeGetBuffer(dataView) as ArrayBufferLike;
+  let byteOffset = 0;
+  let byteLength = 0;
+  try {
+    byteOffset = DataViewPrototypeGetByteOffset(dataView) as number;
+    byteLength = DataViewPrototypeGetByteLength(dataView) as number;
+  } catch {
+    byteOffset = 0;
+    byteLength = 0;
+  }
+  return { __proto__: null, buffer, byteOffset, byteLength } as ViewExtent;
+}
+
+export type ViewExtentHelpers = {
+  viewByteLength: typeof viewByteLength;
+  viewByteExtent: typeof viewByteExtent;
+};
+
+module.exports = { viewByteLength, viewByteExtent };

src/per_isolate/webstreams/writable.ts

@@ -28,7 +28,6 @@ const {
   AbortControllerAbort,
   AbortControllerSignalGet,
   ArrayBufferPrototypeByteLengthGet,
-  DataViewPrototypeGetByteLength,
   NumberIsNaN,
   ObjectDefineProperties,
   ObjectDefineProperty,
@@ -42,17 +41,11 @@ const {
   SymbolFor,
   SymbolToStringTag,
   TypeError,
-  TypedArrayPrototypeGetByteLength,
   uncurryThis,
 } = primordials;
 
-const {
-  isArrayBuffer,
-  isArrayBufferView,
-  isDataView,
-  isPromise,
-  markPromiseHandled,
-} = utils;
+const { isArrayBuffer, isArrayBufferView, isPromise, markPromiseHandled } =
+  utils;
 
 // The native backend (see the fence conventions in native.ts). The cast
 // restores the real shape.
@@ -62,6 +55,10 @@ const { nativeStreamInternals } = require('webstreams/native') as {
 };
 const { kExtractNativeSink, isNativeUnderlyingSink } = nativeStreamInternals;
 
+import type { ViewExtentHelpers } from './view-extent';
+const { viewByteLength } =
+  require('webstreams/view-extent') as ViewExtentHelpers;
+
 const { RingBuffer } = require('webstreams/ring-buffer') as {
   RingBuffer: RingBufferConstructor;
 };
@@ -1843,9 +1840,8 @@ function writableStreamFlush<W>(stream: WritableStream<W>): Promise<void> {
 // heuristic).
 function byteSizeOf(chunk: unknown): number {
   if (isArrayBufferView(chunk)) {
-    return isDataView(chunk)
-      ? DataViewPrototypeGetByteLength(chunk)
-      : TypedArrayPrototypeGetByteLength(chunk);
+    // A detached or out-of-bounds view counts 0 (see view-extent.ts).
+    return viewByteLength(chunk);
   }
   if (isArrayBuffer(chunk)) {
     return ArrayBufferPrototypeByteLengthGet(chunk);

src/tests/streams/compression/AGENTS.md

@@ -178,7 +178,7 @@ pedantic branches shifting anything the suite pins.
 | `corrupt-input.js` | write-time rejection with "Decompression failed."; both-sides error; iteration rejection; bad magic bytes |
 | `strict-checks.js` | trailing-data write rejection; close-with-no-data rejection; truncated-member close rejection |
 | `chunk-types.js` | BufferSource acceptance incl. offsets; string (#1), SAB (#2), invalid-chunk message+aftermath (#3, #4) |
-| `buffer-lifecycle.js` | snapshot-at-write: post-write mutation/detach/shrink invisible; already-detached no-op; lying metadata getters never consulted |
+| `buffer-lifecycle.js` | snapshot-at-write: post-write mutation/detach/shrink invisible; already-detached no-op; detached/out-of-bounds typed-array and DataView views are no-ops; lying metadata getters never consulted |
 | `byob.js` | BYOB reader fills a 2-byte destination with the gzip magic |
 | `backpressure.js` | eager write settlement without reads; desiredSize accounting (#8) |
 | `propagation.js` | abort rejects pending read (reason per #9), errors both sides; cancel settles parked read (#12); write-after-abort (#10); non-Error reasons (#11); writes after a queued close reject (message per impl) without disturbing the close or output; cancel→writable aftermath (#13) |