diff --git a/src/Ramstack.HtmxToolkit/HtmxResponse.cs b/src/Ramstack.HtmxToolkit/HtmxResponse.cs
index ac4f4cc..84195c8 100644
--- a/src/Ramstack.HtmxToolkit/HtmxResponse.cs
+++ b/src/Ramstack.HtmxToolkit/HtmxResponse.cs
@@ -11,6 +11,10 @@ namespace Ramstack.HtmxToolkit;
 /// <summary>
 /// Represents HTTP response to set htmx response headers.
 /// </summary>
+/// <remarks>
+/// Like <see cref="HttpContext"/> and <see cref="HttpResponse"/> themselves, this type is not thread-safe.
+/// Its members should not be called concurrently from multiple threads for the same request.
+/// </remarks>
 [DebuggerTypeProxy(typeof(HtmxResponseDebugView))]
 public readonly struct HtmxResponse
 {
@@ -211,7 +215,7 @@ public HtmxResponse TriggerEvent(string eventName, object detail, HtmxTriggerTim
         return TriggerEventImpl(this, eventName, detail, timing);
 
         static HtmxResponse TriggerEventImpl(HtmxResponse response, string eventName, object detail, HtmxTriggerTiming timing) =>
-            SetEvents(response, new Dictionary<string, object> { [eventName] = detail }, timing);
+            AddEvents(response, new Dictionary<string, object> { [eventName] = detail }, timing);
     }
 
     /// <summary>
@@ -224,7 +228,7 @@ static HtmxResponse TriggerEventImpl(HtmxResponse response, string eventName, ob
     /// The current <see cref="HtmxResponse"/> instance.
     /// </returns>
     public HtmxResponse TriggerEvents(IReadOnlyDictionary<string, object> events, HtmxTriggerTiming timing = HtmxTriggerTiming.Receive) =>
-        SetEvents(this, events, timing);
+        AddEvents(this, events, timing);
 
     /// <summary>
     /// Sets the special HTTP status code <c>286</c> that is used to stop the polling.
@@ -256,34 +260,9 @@ private static HtmxResponse SetHeader(HtmxResponse response, string key, string
         return response;
     }
 
-    private static HtmxResponse SetEvents(HtmxResponse response, IReadOnlyDictionary<string, object> events, HtmxTriggerTiming timing)
+    private static HtmxResponse AddEvents(HtmxResponse response, IReadOnlyDictionary<string, object> events, HtmxTriggerTiming timing)
     {
-        var key = timing switch
-        {
-            HtmxTriggerTiming.Receive => HtmxResponseHeaderNames.Trigger,
-            HtmxTriggerTiming.AfterSettle => HtmxResponseHeaderNames.TriggerAfterSettle,
-            _ => HtmxResponseHeaderNames.TriggerAfterSwap
-        };
-
-        if (response._response.Headers.TryGetValue(key, out var values))
-        {
-            var current = JsonSerializer.Deserialize<Dictionary<string, object>>(values.ToString())!;
-
-            if (events is Dictionary<string, object> dictionary)
-            {
-                foreach (var (k, v) in dictionary)
-                    current.TryAdd(k, v);
-            }
-            else
-            {
-                foreach (var (k, v) in events)
-                    current.TryAdd(k, v);
-            }
-
-            events = current;
-        }
-
-        response._response.Headers[key] = JsonSerializer.Serialize(events, JsonOptions.CamelCase);
+        PendingEvents.GetOrCreate(response._response).AddEvents(timing, events);
         return response;
     }
 
diff --git a/src/Ramstack.HtmxToolkit/HtmxResponseHeaders.cs b/src/Ramstack.HtmxToolkit/HtmxResponseHeaders.cs
index 379318f..a63b1e6 100644
--- a/src/Ramstack.HtmxToolkit/HtmxResponseHeaders.cs
+++ b/src/Ramstack.HtmxToolkit/HtmxResponseHeaders.cs
@@ -1,7 +1,5 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Text.Json;
-
 using Microsoft.AspNetCore.Http;
 
 using Ramstack.HtmxToolkit.Internal;
@@ -14,14 +12,14 @@ namespace Ramstack.HtmxToolkit;
 [DebuggerTypeProxy(typeof(HtmxResponseHeadersDebugView))]
 public sealed class HtmxResponseHeaders
 {
-    private readonly IHeaderDictionary _headers;
+    private readonly HttpResponse _response;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="HtmxResponseHeaders"/> structure.
     /// </summary>
     /// <param name="response">The HTTP response.</param>
     internal HtmxResponseHeaders(HttpResponse response) =>
-        _headers = response.Headers;
+        _response = response;
 
     /// <summary>
     /// Gets or sets the <c>HX-Location</c> header to perform a client-side redirect without a full page reload.
@@ -29,8 +27,8 @@ internal HtmxResponseHeaders(HttpResponse response) =>
     [MaybeNull]
     public string Location
     {
-        get => GetHeader(_headers, HtmxResponseHeaderNames.Location);
-        set => SetHeader(_headers, HtmxResponseHeaderNames.Location, value);
+        get => GetHeader(_response.Headers, HtmxResponseHeaderNames.Location);
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.Location, value);
     }
 
     /// <summary>
@@ -39,8 +37,8 @@ public string Location
     [MaybeNull]
     public string PushUrl
     {
-        get => GetHeader(_headers, HtmxResponseHeaderNames.PushUrl);
-        set => SetHeader(_headers, HtmxResponseHeaderNames.PushUrl, value);
+        get => GetHeader(_response.Headers, HtmxResponseHeaderNames.PushUrl);
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.PushUrl, value);
     }
 
     /// <summary>
@@ -49,8 +47,8 @@ public string PushUrl
     [MaybeNull]
     public string Redirect
     {
-        get => GetHeader(_headers, HtmxResponseHeaderNames.Redirect);
-        set => SetHeader(_headers, HtmxResponseHeaderNames.Redirect, value);
+        get => GetHeader(_response.Headers, HtmxResponseHeaderNames.Redirect);
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.Redirect, value);
     }
 
     /// <summary>
@@ -58,8 +56,8 @@ public string Redirect
     /// </summary>
     public bool Refresh
     {
-        get => GetHeader(_headers, HtmxResponseHeaderNames.Refresh) == "true";
-        set => SetHeader(_headers, HtmxResponseHeaderNames.Refresh, value ? "true" : null);
+        get => GetHeader(_response.Headers, HtmxResponseHeaderNames.Refresh) == "true";
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.Refresh, value ? "true" : null);
     }
 
     /// <summary>
@@ -69,8 +67,8 @@ public bool Refresh
     [MaybeNull]
     public string ReplaceUrl
     {
-        get => GetHeader(_headers, HtmxResponseHeaderNames.ReplaceUrl);
-        set => SetHeader(_headers, HtmxResponseHeaderNames.ReplaceUrl, value);
+        get => GetHeader(_response.Headers, HtmxResponseHeaderNames.ReplaceUrl);
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.ReplaceUrl, value);
     }
 
     /// <summary>
@@ -79,8 +77,8 @@ public string ReplaceUrl
     [DisallowNull]
     public HtmxSwap? Reswap
     {
-        get => EnumHelper.ParseHtmxSwap(GetHeader(_headers, HtmxResponseHeaderNames.Reswap));
-        set => SetHeader(_headers, HtmxResponseHeaderNames.Reswap, value.GetValueOrDefault().GetSwapValue());
+        get => EnumHelper.ParseHtmxSwap(GetHeader(_response.Headers, HtmxResponseHeaderNames.Reswap));
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.Reswap, value.GetValueOrDefault().GetSwapValue());
     }
 
     /// <summary>
@@ -89,8 +87,8 @@ public HtmxSwap? Reswap
     [MaybeNull]
     public string ReswapExpression
     {
-        get => GetHeader(_headers, HtmxResponseHeaderNames.Reswap);
-        set => SetHeader(_headers, HtmxResponseHeaderNames.Reswap, value);
+        get => GetHeader(_response.Headers, HtmxResponseHeaderNames.Reswap);
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.Reswap, value);
     }
 
     /// <summary>
@@ -100,8 +98,8 @@ public string ReswapExpression
     [MaybeNull]
     public string Retarget
     {
-        get => GetHeader(_headers, HtmxResponseHeaderNames.Retarget);
-        set => SetHeader(_headers, HtmxResponseHeaderNames.Retarget, value);
+        get => GetHeader(_response.Headers, HtmxResponseHeaderNames.Retarget);
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.Retarget, value);
     }
 
     /// <summary>
@@ -111,41 +109,53 @@ public string Retarget
     [MaybeNull]
     public string Reselect
     {
-        get => GetHeader(_headers, HtmxResponseHeaderNames.Reselect);
-        set => SetHeader(_headers, HtmxResponseHeaderNames.Reselect, value);
+        get => GetHeader(_response.Headers, HtmxResponseHeaderNames.Reselect);
+        set => SetHeader(_response.Headers, HtmxResponseHeaderNames.Reselect, value);
     }
 
     /// <summary>
     /// Gets or sets the <c>HX-Trigger</c> header, which specifies a dictionary of client-side events
     /// to trigger after the server response is processed.
     /// </summary>
+    /// <remarks>
+    /// Event values are accumulated for the current response and serialized into the header immediately
+    /// before the response starts.
+    /// </remarks>
     [MaybeNull]
     public IReadOnlyDictionary<string, object> Trigger
     {
-        get => GetEvents(_headers, HtmxResponseHeaderNames.Trigger);
-        set => SetEvents(_headers, HtmxResponseHeaderNames.Trigger, value);
+        get => PendingEvents.TryGet(_response)?.GetEvents(HtmxTriggerTiming.Receive);
+        set => PendingEvents.GetOrCreate(_response).SetEvents(HtmxTriggerTiming.Receive, value);
     }
 
     /// <summary>
     /// Gets or sets the <c>HX-Trigger-After-Settle</c> header, which specifies a dictionary of client-side events
     /// to trigger after the htmx request has settled.
     /// </summary>
+    /// <remarks>
+    /// Event values are accumulated for the current response and serialized into the header immediately
+    /// before the response starts.
+    /// </remarks>
     [MaybeNull]
     public IReadOnlyDictionary<string, object> TriggerAfterSettle
     {
-        get => GetEvents(_headers, HtmxResponseHeaderNames.TriggerAfterSettle);
-        set => SetEvents(_headers, HtmxResponseHeaderNames.TriggerAfterSettle, value);
+        get => PendingEvents.TryGet(_response)?.GetEvents(HtmxTriggerTiming.AfterSettle);
+        set => PendingEvents.GetOrCreate(_response).SetEvents(HtmxTriggerTiming.AfterSettle, value);
     }
 
     /// <summary>
     /// Gets or sets the <c>HX-Trigger-After-Swap</c> header, which specifies a dictionary of client-side events
     /// to trigger after the response content has been swapped into the DOM.
     /// </summary>
+    /// <remarks>
+    /// Event values are accumulated for the current response and serialized into the header immediately
+    /// before the response starts.
+    /// </remarks>
     [MaybeNull]
     public IReadOnlyDictionary<string, object> TriggerAfterSwap
     {
-        get => GetEvents(_headers, HtmxResponseHeaderNames.TriggerAfterSwap);
-        set => SetEvents(_headers, HtmxResponseHeaderNames.TriggerAfterSwap, value);
+        get => PendingEvents.TryGet(_response)?.GetEvents(HtmxTriggerTiming.AfterSwap);
+        set => PendingEvents.GetOrCreate(_response).SetEvents(HtmxTriggerTiming.AfterSwap, value);
     }
 
     private static string? GetHeader(IHeaderDictionary headers, string key)
@@ -160,23 +170,12 @@ private static void SetHeader(IHeaderDictionary headers, string key, string? val
             headers[key] = value;
     }
 
-    private static Dictionary<string, object>? GetEvents(IHeaderDictionary headers, string key)
-    {
-        if (headers.TryGetValue(key, out var values))
-            return JsonSerializer.Deserialize<Dictionary<string, object>>(values.ToString());
-
-        return null;
-    }
-
-    private static void SetEvents(IHeaderDictionary headers, string key, IReadOnlyDictionary<string, object> events) =>
-        headers[key] = JsonSerializer.Serialize(events, JsonOptions.CamelCase);
-
     #region Inner type: HtmxResponseHeadersDebugView
 
     private sealed class HtmxResponseHeadersDebugView(HtmxResponseHeaders headers)
     {
         [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-        public KeyValuePair<string, string>[] Items => DebugHelpers.GetHeaders(headers._headers);
+        public KeyValuePair<string, string>[] Items => DebugHelpers.GetHeaders(headers._response.Headers);
     }
 
     #endregion
diff --git a/src/Ramstack.HtmxToolkit/PendingEvents.cs b/src/Ramstack.HtmxToolkit/PendingEvents.cs
new file mode 100644
index 0000000..6b08225
--- /dev/null
+++ b/src/Ramstack.HtmxToolkit/PendingEvents.cs
@@ -0,0 +1,136 @@
+using System.Text.Json;
+
+using Microsoft.AspNetCore.Http;
+
+using Ramstack.HtmxToolkit.Internal;
+
+namespace Ramstack.HtmxToolkit;
+
+/// <summary>
+/// Accumulates htmx events per <see cref="HtmxTriggerTiming"/> for a single request,
+/// deferring header serialization until the response is about to start.
+/// </summary>
+internal sealed class PendingEvents(HttpResponse response)
+{
+    private Dictionary<string, object>? _receive;
+    private Dictionary<string, object>? _afterSettle;
+    private Dictionary<string, object>? _afterSwap;
+
+    /// <summary>
+    /// Adds the specified events to the pending set for the given <paramref name="timing"/>.
+    /// Keys already present are preserved.
+    /// </summary>
+    /// <param name="timing">The time at which the events will be triggered.</param>
+    /// <param name="events">A dictionary containing event names as keys and event details as values.</param>
+    public void AddEvents(HtmxTriggerTiming timing, IReadOnlyDictionary<string, object> events)
+    {
+        var current = timing switch
+        {
+            HtmxTriggerTiming.Receive => _receive ??= new Dictionary<string, object>(),
+            HtmxTriggerTiming.AfterSettle => _afterSettle ??= new Dictionary<string, object>(),
+            _ => _afterSwap ??= new Dictionary<string, object>()
+        };
+
+        if (events is Dictionary<string, object> dictionary)
+        {
+            foreach (var (k, v) in dictionary)
+                current.TryAdd(k, v);
+        }
+        else
+        {
+            foreach (var (k, v) in events)
+                current.TryAdd(k, v);
+        }
+    }
+
+    /// <summary>
+    /// Returns the pending events for the specified <paramref name="timing"/>.
+    /// </summary>
+    /// <param name="timing">The time at which the events will be triggered.</param>
+    /// <returns>
+    /// The pending events, or <see langword="null"/> if none were registered.
+    /// </returns>
+    public IReadOnlyDictionary<string, object>? GetEvents(HtmxTriggerTiming timing)
+    {
+        return timing switch
+        {
+            HtmxTriggerTiming.Receive => _receive,
+            HtmxTriggerTiming.AfterSettle => _afterSettle,
+            _ => _afterSwap
+        };
+    }
+
+    /// <summary>
+    /// Replaces the pending events for the specified <paramref name="timing"/>.
+    /// </summary>
+    /// <param name="timing">The time at which the events will be triggered.</param>
+    /// <param name="events">A dictionary containing event names as keys and event details as values.</param>
+    public void SetEvents(HtmxTriggerTiming timing, IReadOnlyDictionary<string, object> events)
+    {
+        var replacement = new Dictionary<string, object>(events);
+        switch (timing)
+        {
+            case HtmxTriggerTiming.Receive:
+                _receive = replacement;
+                break;
+            case HtmxTriggerTiming.AfterSettle:
+                _afterSettle = replacement;
+                break;
+            default:
+                _afterSwap = replacement;
+                break;
+        }
+    }
+
+    /// <summary>
+    /// Serializes the accumulated events, if any, into the corresponding <c>HX-Trigger</c> response headers.
+    /// </summary>
+    public void Flush()
+    {
+        SetHeader(HtmxResponseHeaderNames.Trigger, _receive);
+        SetHeader(HtmxResponseHeaderNames.TriggerAfterSettle, _afterSettle);
+        SetHeader(HtmxResponseHeaderNames.TriggerAfterSwap, _afterSwap);
+    }
+
+    /// <summary>
+    /// Returns the events accumulator previously registered for the response.
+    /// </summary>
+    /// <param name="response">The HTTP response that owns the events.</param>
+    /// <returns>
+    /// The pending events accumulator, or <see langword="null"/> if none was registered.
+    /// </returns>
+    public static PendingEvents? TryGet(HttpResponse response) =>
+        response.HttpContext.Items[typeof(PendingEvents)] as PendingEvents;
+
+    /// <summary>
+    /// Returns the pending events accumulator, creating and registering it for the response when necessary.
+    /// </summary>
+    /// <param name="response">The HTTP response that owns the events.</param>
+    /// <returns>
+    /// The pending events accumulator for the response.
+    /// </returns>
+    public static PendingEvents GetOrCreate(HttpResponse response)
+    {
+        var context = response.HttpContext;
+        if (TryGet(response) is { } pending)
+            return pending;
+
+        pending = new PendingEvents(response);
+        context.Items[typeof(PendingEvents)] = pending;
+
+        response.OnStarting(static o =>
+        {
+            var state = (PendingEvents)o;
+            state.Flush();
+            return Task.CompletedTask;
+        }, pending);
+
+        return pending;
+    }
+
+    private void SetHeader(string name, Dictionary<string, object>? events)
+    {
+        if (events is not null)
+            response.Headers[name] = JsonSerializer.Serialize(events, JsonOptions.CamelCase);
+    }
+}