Method writeValue

src/lib/json_buffer.ts:481–564

(value: any)

  }

  private writeValue(value: any): { type: number; payload: number } {
    if (typeof value === "number") {
      const ptr = this.alloc(8);
      this.f64[ptr >> 3] = value;
      return { type: TYPE_NUMBER, payload: ptr };
    }
    if (value === null || value === undefined) {
      return { type: TYPE_NULL, payload: 0 };
    }
    if (value === true) return { type: TYPE_TRUE, payload: 0 };
    if (value === false) return { type: TYPE_FALSE, payload: 0 };

    if (typeof value === "string") {
      // Get current free pointer directly (bypass alloc() overhead for now)
      const freePtrIdx = OFFSET_FREE_PTR >> 2;
      let currentPtr = Atomics.load(this.u32, freePtrIdx);

      // Ensure alignment for the 4-byte length header
      currentPtr = (currentPtr + 3) & ~3;

      // Calculate worst-case size (3 bytes per char for UTF-8 + 4 bytes header)
      const maxBytes = value.length * 3 + 4;

      // Safety Check: If near end of buffer, fallback to standard alloc() (which handles GC and OOM errors properly)
      if (currentPtr + maxBytes > this.buffer.byteLength) {
        const encoded = this.textEncoder.encode(value); // Slow path allocation
        const len = encoded.byteLength;
        const ptr = this.alloc(4 + len);
        this.u32[ptr >> 2] = len;
        this.u8.set(encoded, ptr + 4);
        return { type: TYPE_STRING, payload: ptr };
      }

      // This faster because it writes directly to shared memory but does not work in the browser because of security reasons:
      // TextEncoder.encodeInto: Argument 2 can't be a SharedArrayBuffer or an ArrayBufferView backed by a SharedArrayBuffer

      // const { written } = this.textEncoder.encodeInto(
      //   value,
      //   this.u8.subarray(currentPtr + 4, currentPtr + maxBytes),
      // );

      // So alternatively we use the (slower) approach below to stay compatible with browsers
      const encoded = this.textEncoder.encode(value);
      const written = Math.min(encoded.length, maxBytes);
      this.u8.set(encoded.subarray(0, written), currentPtr + 4);

      // Write actual length
      this.u32[currentPtr >> 2] = written!;

      // Manually advance free pointer (Align to 8 bytes for future number writes)
      const actualSize = 4 + written!;
      const nextPtr = (currentPtr + actualSize + 7) & ~7;
      Atomics.store(this.u32, freePtrIdx, nextPtr);

      return { type: TYPE_STRING, payload: currentPtr };
    }

    if (Array.isArray(value)) {