bindings-typescript: share the string codec and add an ASCII fast path to writeString (#5783)

# Description of Changes

`BinaryWriter.writeString` allocates a fresh `TextEncoder` plus a
temporary `Uint8Array` for every string it writes, and
`BinaryReader.readString` a fresh `TextDecoder` for every string it
reads. Both run once per string column per row on every
insert/update/find/scan inside a module, so the per-call allocations
dominate the cost of string columns.

This PR:

- **Writer:** writes pure-ASCII strings straight into the writer buffer,
one byte per char, with no intermediate allocation; non-ASCII input
falls back to a single shared `TextEncoder`. (`TextEncoder.encodeInto`
would be the natural tool, but the module host's `TextEncoder` does not
provide it, so the fast path is a plain loop.)
- **Reader:** one shared `TextDecoder` instead of one per call. The
decode itself is unchanged; a per-char ASCII loop was measured and is
slower than a single `decode` at typical field lengths, so the reader
keeps it.

Output is byte-identical to the previous implementation (tests compare
against `TextEncoder` for empty, ASCII, Latin-1, CJK, astral/surrogate
pairs, mixed, 10k-char strings, and buffer growth from a 1-byte initial
capacity).

Measured inside a module on a stock 2.8.2 server (20k inserts,
`Date.now()` around the loop):

| table | before | after |
|---|---|---|
| 12 string columns | 255-300 ms | 78-88 ms |
| 12 f64 columns (control) | ~42-124 ms | unchanged |
| 1 string column holding a 305-byte JSON blob | ~80 ms | ~60 ms |

The same bytes through fewer allocations; the f64 control shows the rest
of the insert path was never the bottleneck.

# API and ABI breaking changes

None. Same wire bytes, same public surface.

# Expected complexity level and risk

1. Two methods, no behavior change beyond allocation; covered by
byte-equality tests.

# Testing

- [x] `crates/bindings-typescript`: `vitest run` (29 files, 301 tests)
including the new `writeString` suite (encodes like `TextEncoder` for
empty / ASCII / Latin-1 / CJK / astral / mixed / 10k-char inputs, grows
from a 1-byte buffer, round-trips through `readString`, consecutive
writes stay contiguous).
- [x] `eslint` and `prettier --check` on the touched files.
- [x] Exercised end to end by a module publishing to a 2.8.2 server with
string, option<string> and mixed-type rows, including non-ASCII round
trips through the HTTP call path.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

# Rollback safety impact

n/a

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: TheUltDev

crates/bindings-typescript/src/lib/binary_reader.ts

@@ -1,3 +1,6 @@
+// Shared decoder: `readString` is called once per string column per row.
+const textDecoder = new TextDecoder('utf-8');
+
 export default class BinaryReader {
   /**
    * The DataView used to read values from the binary data.
@@ -196,6 +199,6 @@ export default class BinaryReader {
     // A view is safe here: TextDecoder copies the bytes synchronously, so nothing
     // retains a reference to the reader's buffer. Avoids readUInt8Array's copy.
     const bytes = this.readBytes(length);
-    return new TextDecoder('utf-8').decode(bytes);
+    return textDecoder.decode(bytes);
   }
 }

crates/bindings-typescript/src/lib/binary_writer.ts

@@ -1,5 +1,8 @@
 import { fromByteArray } from 'base64-js';
 
+// Shared encoder: `writeString` is called once per string column per row.
+const textEncoder = new TextEncoder();
+
 const ArrayBufferPrototypeTransfer =
   ArrayBuffer.prototype.transfer ??
   function (this: ArrayBuffer, newByteLength) {
@@ -206,8 +209,26 @@ export default class BinaryWriter {
   }
 
   writeString(value: string): void {
-    const encoder = new TextEncoder();
-    const encodedString = encoder.encode(value);
-    this.writeUInt8Array(encodedString);
+    // Fast path: pure-ASCII strings are written straight into the buffer,
+    // one byte per char, with no intermediate allocation. Non-ASCII input
+    // falls back to the shared encoder. This method runs once per string
+    // column per row on every insert/update, so per-call allocations
+    // (a fresh TextEncoder and a temporary Uint8Array) dominated its cost.
+    const len = value.length;
+    this.expandBuffer(4 + len);
+    const bytes = new Uint8Array(this.buffer.buffer);
+    let offset = this.offset + 4;
+    let i = 0;
+    for (; i < len; i++) {
+      const c = value.charCodeAt(i);
+      if (c >= 0x80) break;
+      bytes[offset++] = c;
+    }
+    if (i === len) {
+      this.view.setUint32(this.offset, len, true);
+      this.offset = offset;
+      return;
+    }
+    this.writeUInt8Array(textEncoder.encode(value));
   }
 }

crates/bindings-typescript/tests/binary_read_write.test.ts

@@ -186,3 +186,60 @@ describe('readUInt8Array buffer ownership', () => {
     expect(value).toBe('héllo ☃');
   });
 });
+
+describe('writeString', () => {
+  // BSATN layout for `string`: u32 byte length (LE) followed by UTF-8 bytes.
+  const expected = (value: string): number[] => {
+    const utf8 = new TextEncoder().encode(value);
+    return [
+      utf8.length & 0xff,
+      (utf8.length >> 8) & 0xff,
+      (utf8.length >> 16) & 0xff,
+      (utf8.length >> 24) & 0xff,
+      ...utf8,
+    ];
+  };
+  const written = (value: string, initialCapacity = 8): number[] => {
+    const writer = new BinaryWriter(initialCapacity);
+    writer.writeString(value);
+    return [...writer.getBuffer()];
+  };
+
+  test.each([
+    ['empty', ''],
+    ['ascii', 'hello world'],
+    ['ascii at the fast-path boundary', '\x7f'],
+    ['latin-1', 'héllo'],
+    ['cjk', '日本語'],
+    ['astral (surrogate pair)', 'emoji 🎉 mix'],
+    ['ascii prefix then non-ascii', 'ascii then ÿ'],
+    ['long ascii', 'x'.repeat(10_000)],
+    ['long non-ascii', 'ü'.repeat(10_000)],
+  ])('%s encodes like TextEncoder', (_name, value) => {
+    expect(written(value)).toEqual(expected(value));
+  });
+
+  test('grows the buffer from a tiny initial capacity', () => {
+    expect(written('hello world', 1)).toEqual(expected('hello world'));
+    expect(written('héllo', 1)).toEqual(expected('héllo'));
+  });
+
+  test('round-trips through readString', () => {
+    for (const value of ['', 'plain', 'héllo ☃', '🎉'.repeat(100)]) {
+      const writer = new BinaryWriter(4);
+      writer.writeString(value);
+      expect(new BinaryReader(writer.getBuffer()).readString()).toBe(value);
+    }
+  });
+
+  test('consecutive writes stay contiguous', () => {
+    const writer = new BinaryWriter(4);
+    writer.writeString('ab');
+    writer.writeString('ç');
+    writer.writeU8(7);
+    const reader = new BinaryReader(writer.getBuffer());
+    expect(reader.readString()).toBe('ab');
+    expect(reader.readString()).toBe('ç');
+    expect(reader.readU8()).toBe(7);
+  });
+});