feat: compute buffer size ahead of time

The current implementation loops over message fields and each field
encoder creates a `Uint8Array` which is added to a `Uint8ArrayList`
and stitched together at the end of the process.

Other implementations compute the expected length of the serialized
message, allocate a buffer that size then have encoders write their
data into it at the correct offsets.

This PR makes protons compute the final message buffer size first in
the same way.

Thing is, it doesn't seem to make a huge amount of difference to performance.

Before:

```
Running "Encode/Decode" suite...
Progress: 100%

  pbjs:
    12 166 ops/s, ±3.92%   | 5.12% slower

  protons:
    9 755 ops/s, ±2.19%    | slowest, 23.93% slower

  protobufjs:
    12 823 ops/s, ±2.02%   | fastest

Finished 3 cases!
  Fastest: protobufjs
  Slowest: protons
```

After:

```
Running "Encode/Decode" suite...
Progress: 100%

  pbjs:
    11 866 ops/s, ±3.43%   | 2.05% slower

  protons:
    9 356 ops/s, ±2.45%    | slowest, 22.77% slower

  protobufjs:
    12 114 ops/s, ±2.16%   | fastest

Finished 3 cases!
  Fastest: protobufjs
  Slowest: protons
```

Author: achingbrain

packages/protons-runtime/src/codecs/bool.ts

@@ -4,8 +4,10 @@ const encodingLength: EncodingLengthFunction<boolean> = function boolEncodingLen
   return 1
 }
 
-const encode: EncodeFunction<boolean> = function boolEncode (value) {
-  return Uint8Array.from([value ? 1 : 0])
+const encode: EncodeFunction<boolean> = function boolEncode (val, buf, offset) {
+  buf.set(offset, val ? 1 : 0)
+
+  return offset + encodingLength(val)
 }
 
 const decode: DecodeFunction<boolean> = function boolDecode (buffer, offset) {

packages/protons-runtime/src/codecs/bytes.ts

@@ -1,5 +1,4 @@
 
-import { Uint8ArrayList } from 'uint8arraylist'
 import { unsigned } from '../utils/varint.js'
 import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
 
@@ -8,12 +7,11 @@ const encodingLength: EncodingLengthFunction<Uint8Array> = function bytesEncodin
   return unsigned.encodingLength(len) + len
 }
 
-const encode: EncodeFunction<Uint8Array> = function bytesEncode (val) {
-  const prefix = new Uint8Array(unsigned.encodingLength(val.byteLength))
+const encode: EncodeFunction<Uint8Array> = function bytesEncode (val, buf, offset) {
+  offset = unsigned.encode(val.byteLength, buf, offset)
+  buf.write(val, offset)
 
-  unsigned.encode(val.byteLength, prefix)
-
-  return new Uint8ArrayList(prefix, val)
+  return offset + val.byteLength
 }
 
 const decode: DecodeFunction<Uint8Array> = function bytesDecode (buf, offset) {

packages/protons-runtime/src/codecs/codec.ts

@@ -11,7 +11,7 @@ export enum CODEC_TYPES {
 }
 
 export interface EncodeFunction<T> {
-  (value: T): Uint8Array | Uint8ArrayList
+  (value: T, buf: Uint8ArrayList, offset: number): number
 }
 
 export interface DecodeFunction<T> {

packages/protons-runtime/src/codecs/double.ts

@@ -1,15 +1,13 @@
-import { Uint8ArrayList } from 'uint8arraylist'
 import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function doubleEncodingLength () {
   return 8
 }
 
-const encode: EncodeFunction<number> = function doubleEncode (val) {
-  const buf = new Uint8ArrayList(new Uint8Array(encodingLength(val)))
-  buf.setFloat64(0, val, true)
+const encode: EncodeFunction<number> = function doubleEncode (val, buf, offset) {
+  buf.setFloat64(offset, val, true)
 
-  return buf
+  return offset + encodingLength(val)
 }
 
 const decode: DecodeFunction<number> = function doubleDecode (buf, offset) {

packages/protons-runtime/src/codecs/enum.ts

@@ -10,14 +10,11 @@ export function enumeration <T> (e: T): Codec<T> {
     return unsigned.encodingLength(index)
   }
 
-  const encode: EncodeFunction<string> = function enumEncode (val) {
+  const encode: EncodeFunction<string> = function enumEncode (val, buf, offset) {
     const keys = Object.keys(e)
     const index = keys.indexOf(val)
-    const buf = new Uint8Array(unsigned.encodingLength(index))
 
-    unsigned.encode(index, buf)
-
-    return buf
+    return unsigned.encode(index, buf, offset)
   }
 
   const decode: DecodeFunction<string> = function enumDecode (buf, offset) {

packages/protons-runtime/src/codecs/fixed32.ts

@@ -1,15 +1,13 @@
-import { Uint8ArrayList } from 'uint8arraylist'
 import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function fixed32EncodingLength () {
   return 4
 }
 
-const encode: EncodeFunction<number> = function fixed32Encode (val) {
-  const buf = new Uint8ArrayList(new Uint8Array(encodingLength(val)))
-  buf.setInt32(0, val, true)
+const encode: EncodeFunction<number> = function fixed32Encode (val, buf, offset) {
+  buf.setInt32(offset, val, true)
 
-  return buf
+  return offset + encodingLength(val)
 }
 
 const decode: DecodeFunction<number> = function fixed32Decode (buf, offset) {

packages/protons-runtime/src/codecs/fixed64.ts

@@ -1,15 +1,13 @@
-import { Uint8ArrayList } from 'uint8arraylist'
 import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function int64EncodingLength (val) {
   return 8
 }
 
-const encode: EncodeFunction<bigint> = function int64Encode (val) {
-  const buf = new Uint8ArrayList(new Uint8Array(encodingLength(val)))
-  buf.setBigInt64(0, val, true)
+const encode: EncodeFunction<bigint> = function int64Encode (val, buf, offset) {
+  buf.setBigInt64(offset, val, true)
 
-  return buf
+  return offset + encodingLength(val)
 }
 
 const decode: DecodeFunction<bigint> = function int64Decode (buf, offset) {

packages/protons-runtime/src/codecs/float.ts

@@ -1,15 +1,13 @@
-import { Uint8ArrayList } from 'uint8arraylist'
 import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function floatEncodingLength () {
   return 4
 }
 
-const encode: EncodeFunction<number> = function floatEncode (val) {
-  const buf = new Uint8ArrayList(new Uint8Array(encodingLength(1)))
-  buf.setFloat32(0, val, true)
+const encode: EncodeFunction<number> = function floatEncode (val, buf, offset) {
+  buf.setFloat32(offset, val, true)
 
-  return buf
+  return offset + encodingLength(val)
 }
 
 const decode: DecodeFunction<number> = function floatDecode (buf, offset) {

packages/protons-runtime/src/codecs/int32.ts

@@ -5,11 +5,8 @@ const encodingLength: EncodingLengthFunction<number> = function int32EncodingLen
   return signed.encodingLength(val)
 }
 
-const encode: EncodeFunction<number> = function int32Encode (val) {
-  const buf = new Uint8Array(encodingLength(val))
-  signed.encode(val, buf)
-
-  return buf
+const encode: EncodeFunction<number> = function int32Encode (val, buf, offset) {
+  return signed.encode(val, buf, offset)
 }
 
 const decode: DecodeFunction<number> = function int32Decode (buf, offset) {

packages/protons-runtime/src/codecs/int64.ts

@@ -5,11 +5,8 @@ const encodingLength: EncodingLengthFunction<bigint> = function int64EncodingLen
   return signed.encodingLength(val)
 }
 
-const encode: EncodeFunction<bigint> = function int64Encode (val) {
-  const buf = new Uint8Array(encodingLength(val))
-  signed.encode(val, buf)
-
-  return buf
+const encode: EncodeFunction<bigint> = function int64Encode (val, buf, offset) {
+  return signed.encode(val, buf, offset)
 }
 
 const decode: DecodeFunction<bigint> = function int64Decode (buf, offset) {