fix: AWS-CORS-safe byteLength discovery in asyncBufferFromStore

AWS S3 (and many other backends) strip `Content-Range` from CORS
responses by default. The old 1-byte range trick then fell back to the
partial `Content-Length` of 1, so hyparquet saw `byteLength = 1`, tried
to read the 8-byte footer, and tripped `RangeError: Offset is outside
the bounds of the DataView` on any public-S3-backed parquet.

Two changes:

- `asyncBufferFromStore`: when `store.getUrl` is defined, do an HTTP
  HEAD first — its `Content-Length` is the full object size (200, not
  206) and survives CORS. Fall back to the 1-byte trick for stores
  without `getUrl` (native R2 binding, HTTP proxies that expose
  `Content-Range`).
- `S3Store.get`: don't trust `Content-Length` as `totalSize` on a 206
  response. Only set `totalSize` from `Content-Length` for 200s, or
  from a present `Content-Range`. Avoids the same misread bleeding into
  callers that don't use `asyncBufferFromStore`.

Reproed on `ctbk/stations/ids_201306:202209.parquet` (88 KB, 3257 rows);
now renders the full table.

Author: ryan-williams

src/react/asyncBuffer.ts

@@ -18,10 +18,28 @@ export interface AsyncBuffer {
 }
 
 export async function asyncBufferFromStore(store: Store, path: string): Promise<AsyncBuffer> {
-  // Need `byteLength` upfront. A 1-byte range read returns `totalSize`
-  // from Content-Range (cheaper than fetching the whole object).
-  const head = await store.get(path, { offset: 0, length: 1 })
-  const byteLength = head.totalSize ?? head.bytes.byteLength
+  // Prefer an HTTP HEAD via `store.getUrl(path)` when available. AWS S3
+  // (and many other backends) strip `Content-Range` from CORS responses
+  // by default, which makes the 1-byte range trick fall back to a
+  // partial `Content-Length` of 1 — wrong, and hyparquet later trips
+  // `RangeError: Offset is outside the bounds of the DataView`.
+  // HEAD returns a 200 whose `Content-Length` is the full object size.
+  let byteLength: number | undefined
+  if (typeof store.getUrl === 'function') {
+    try {
+      const r = await fetch(store.getUrl(path), { method: 'HEAD' })
+      if (r.ok) {
+        const cl = parseInt(r.headers.get('Content-Length') ?? '', 10)
+        if (Number.isFinite(cl) && cl > 0) byteLength = cl
+      }
+    } catch { /* HEAD blocked / unsupported — fall through */ }
+  }
+  if (byteLength === undefined) {
+    // Fallback: 1-byte range read. Works for native bindings (R2Store)
+    // and HTTP proxies that expose `Content-Range`.
+    const head = await store.get(path, { offset: 0, length: 1 })
+    byteLength = head.totalSize ?? head.bytes.byteLength
+  }
   return {
     byteLength,
     async slice(start: number, end?: number): Promise<ArrayBuffer> {

src/stores/s3.ts

@@ -216,9 +216,15 @@ export function S3Store(opts: S3StoreOptions): Store {
         throw new Error(`S3 get ${path}: ${res.status} ${await res.text()}`)
       }
       const cr = res.headers.get('Content-Range')
+      // 206 + no `Content-Range` (common: AWS S3 default CORS strips
+      // it) means we can't know the total size from this response —
+      // `Content-Length` is the partial length, not the full file's.
+      // Only trust `Content-Length` for 200 responses.
       const totalSize = cr
         ? parseInt(cr.split('/')[1], 10)
-        : parseInt(res.headers.get('Content-Length') ?? '', 10)
+        : res.status === 200
+          ? parseInt(res.headers.get('Content-Length') ?? '', 10)
+          : NaN
       const bytes = new Uint8Array(await res.arrayBuffer())
       const out: GetResult = { bytes }
       if (Number.isFinite(totalSize)) out.totalSize = totalSize