@reddb-io/client 1.26.3 → 1.26.5

package/README.md

@@ -75,6 +75,14 @@ For `http://` and `https://` connections, `connect()` verifies readiness with
 a lightweight `SELECT 1` round-trip. `/health` states such as `degraded` are
 transient during boot and are not fatal as long as queries succeed.
 
+RedWire query parameters retain `Float32Array`, `Float64Array`, `Uint8Array`
+and `Buffer` views through normalization, avoiding intermediate number arrays
+and base64 strings. The request owns its encoded bytes before `query()` yields;
+later mutations of caller-owned views do not change the sent request. The
+transport drops input-view references before waiting for the network. HTTP/gRPC
+keep the same JSON-compatible parameter envelopes. See the measured
+[encoding results](../../docs/perf/client-codecs-2026-10-23.md).
+
 ## Transactions
 
 Use `db.transaction()` when a group of writes must commit or roll back together.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reddb-io/client",
-  "version": "1.26.3",
+  "version": "1.26.5",
   "description": "Thin remote-only RedDB driver. Pure JavaScript — no install scripts, no native binary. Speaks RedWire/gRPC/HTTP. Embedded URIs (memory://, file://, red:///path) are rejected — use @reddb-io/sdk for those.",
   "type": "module",
   "main": "src/index.js",

package/src/core/reddb.js

@@ -122,7 +122,7 @@ export class RedDB {
 
   /** Execute a SQL query. Returns `{ statement, affected, columns, rows }`. */
   query(sql, ...params) {
-    const wireParams = normalizeQueryParams(params)
+    const wireParams = normalizeQueryParams(params, this.client.binaryQueryParams === true)
     if (wireParams == null) {
       return this.client.call('query', { sql }).then(normalizeExactNumbers)
     }

package/src/core/serialization.js

@@ -126,10 +126,20 @@ export function assertSupportedParam(value) {
   )
 }
 
-export function normalizeQueryParams(args) {
+function serializeBinaryParam(value) {
+  if (value instanceof Uint8Array || value instanceof Float32Array || value instanceof Float64Array) {
+    // Preserve the existing handling of empty, detached and resized views.
+    if (value.byteLength === 0) return serializeParam(value)
+    return value
+  }
+  return serializeParam(value)
+}
+
+export function normalizeQueryParams(args, binary = false) {
   if (args.length === 0) return null
-  if (args.length === 1 && Array.isArray(args[0])) return args[0].map(serializeParam)
-  return args.map(serializeParam)
+  const serialize = binary ? serializeBinaryParam : serializeParam
+  if (args.length === 1 && Array.isArray(args[0])) return args[0].map(serialize)
+  return args.map(serialize)
 }
 
 export function bytesToBase64(value) {

package/src/redwire-core.js

@@ -226,6 +226,8 @@ export class RedWireClient {
     this.reader = reader
     this.session = session
     this.serverFeatures = serverFeatures >>> 0
+    // RedWire consumes typed views directly; JSON transports use envelopes.
+    this.binaryQueryParams = true
     this.nextCorr = 1n
     this.nextStream = 1
     this.closed = false
@@ -357,6 +359,8 @@ export class RedWireClient {
       kind = isSelectQuery(sql) ? MessageKind.QueryBinary : MessageKind.Query
       payload = new TextEncoder().encode(sql)
     }
+    // The encoded payload owns its bytes; release caller views before suspending.
+    params = undefined
     await writeFrame(this.socket, kind, corr, payload)
     const resp = await this.reader.next()
     if (resp.kind === MessageKind.Result) {
@@ -668,28 +672,30 @@ export function decodeFrame(buf) {
 class FrameReader {
   constructor(socket) {
     this.chunks = []
+    this.chunkIndex = 0
+    this.chunkOffset = 0
     this.totalLen = 0
+    this.frameLength = 0
     this.waiters = []
     this.error = null
     this.eof = false
     socket.on('data', (chunk) => {
+      if (this.error || this.eof) return
       // chunk is Buffer (Node) or Uint8Array (Bun/Deno)
       const u8 = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk)
+      if (u8.length === 0) return
       this.chunks.push(u8)
       this.totalLen += u8.length
       this.#tryDeliver()
     })
-    socket.on('error', (err) => {
-      this.error = err
-      this.#flushWaiters()
-    })
+    socket.on('error', (err) => this.#fail(err))
     socket.on('end', () => {
       this.eof = true
-      this.#flushWaiters()
+      this.#tryDeliver()
     })
     socket.on('close', () => {
       this.eof = true
-      this.#flushWaiters()
+      this.#tryDeliver()
     })
   }
 
@@ -702,57 +708,79 @@ class FrameReader {
   }
 
   #tryDeliver() {
-    while (this.waiters.length > 0 && this.totalLen > 0) {
-      const flat = this.#flatten()
+    while (this.waiters.length > 0 && this.totalLen >= FRAME_HEADER_SIZE) {
       let frame
       try {
-        frame = decodeFrame(flat)
+        if (this.frameLength === 0) this.frameLength = this.#readLength()
+        if (this.totalLen < this.frameLength) break
+        frame = decodeFrame(this.#take(this.frameLength))
+        this.frameLength = 0
       } catch (err) {
-        const w = this.waiters.shift()
-        w.reject(err)
-        return
-      }
-      if (frame == null) {
-        // Need more bytes — put the flattened buffer back as a
-        // single chunk so we don't keep flattening repeatedly.
-        this.chunks = [flat]
+        this.#fail(err)
         return
       }
-      this.chunks = [flat.subarray(frame.consumed)]
-      this.totalLen = this.chunks[0].length
       const w = this.waiters.shift()
       w.resolve(frame)
     }
-    if (this.eof && this.waiters.length > 0 && this.totalLen === 0) {
-      const err = this.error ?? new RedDBError('CONNECTION_CLOSED', 'redwire: connection closed')
-      while (this.waiters.length > 0) {
-        this.waiters.shift().reject(err)
-      }
+    if (this.eof && this.waiters.length > 0) {
+      this.#fail(new RedDBError('CONNECTION_CLOSED', 'redwire: connection closed'))
     }
   }
 
-  #flushWaiters() {
-    if (this.waiters.length === 0) return
-    if (this.totalLen > 0) {
-      this.#tryDeliver()
-      return
+  #readLength() {
+    let length = 0
+    let shift = 0
+    for (let index = this.chunkIndex; shift < 32; index++) {
+      const chunk = this.chunks[index]
+      const start = index === this.chunkIndex ? this.chunkOffset : 0
+      for (let offset = start; offset < chunk.length && shift < 32; offset++, shift += 8) {
+        length += chunk[offset] * 2 ** shift
+      }
     }
-    const err = this.error ?? new RedDBError('CONNECTION_CLOSED', 'redwire: connection closed')
+    if (length < FRAME_HEADER_SIZE || length > MAX_FRAME_SIZE) {
+      throw new RedDBError('FRAME_INVALID_LENGTH', `length=${length}`)
+    }
+    return length
+  }
+
+  #fail(error) {
+    this.error ??= error
+    this.chunks = []
+    this.chunkIndex = 0
+    this.chunkOffset = 0
+    this.totalLen = 0
+    this.frameLength = 0
     while (this.waiters.length > 0) {
-      this.waiters.shift().reject(err)
+      this.waiters.shift().reject(this.error)
     }
   }
 
-  #flatten() {
-    if (this.chunks.length === 1) return this.chunks[0]
-    const out = new Uint8Array(this.totalLen)
-    let off = 0
-    for (const c of this.chunks) {
-      out.set(c, off)
-      off += c.length
+  #take(length) {
+    const first = this.chunks[this.chunkIndex]
+    const contiguous = first.length - this.chunkOffset >= length
+    // A plain Uint8Array keeps decodeFrame's payload slice owned, even for Buffer input.
+    const bytes = contiguous
+      ? new Uint8Array(first.buffer, first.byteOffset + this.chunkOffset, length)
+      : new Uint8Array(length)
+    let written = 0
+    while (written < length) {
+      const chunk = this.chunks[this.chunkIndex]
+      const count = Math.min(length - written, chunk.length - this.chunkOffset)
+      if (!contiguous) bytes.set(chunk.subarray(this.chunkOffset, this.chunkOffset + count), written)
+      written += count
+      this.chunkOffset += count
+      if (this.chunkOffset === chunk.length) {
+        this.chunks[this.chunkIndex++] = null
+        this.chunkOffset = 0
+      }
     }
-    this.chunks = [out]
-    return out
+    this.totalLen -= length
+    // Release consumed buffers immediately; compact references only after half are consumed.
+    if (this.chunkIndex * 2 >= this.chunks.length) {
+      this.chunks = this.chunks.slice(this.chunkIndex)
+      this.chunkIndex = 0
+    }
+    return bytes
   }
 }