mt-lang 0.3.24 → 0.3.26

data/lib/milk_tea/core/lowering/events.rb

@@ -1,798 +1,632 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module LowererEvents
-    def event_method_kind(receiver_type, member_name)
-      return unless receiver_type.is_a?(Types::Event)
-
-      case member_name
-      when "subscribe" then :event_subscribe
-      when "subscribe_once" then :event_subscribe_once
-      when "unsubscribe" then :event_unsubscribe
-      when "emit" then :event_emit
-      when "wait" then :event_wait
+  module Lowering
+    module Events
+      def event_method_kind(receiver_type, member_name)
+        return unless receiver_type.is_a?(Types::Event)
+
+        case member_name
+        when "subscribe" then :event_subscribe
+        when "subscribe_once" then :event_subscribe_once
+        when "unsubscribe" then :event_unsubscribe
+        when "emit" then :event_emit
+        when "wait" then :event_wait
+        end
       end
-    end
 
-    def event_method_type(kind, event_type)
-      case kind
-      when :event_subscribe, :event_subscribe_once
-        Types::Registry.function(
-          kind.to_s,
-          params: [Types::Registry.parameter("listener", event_listener_function_type(event_type))],
-          return_type: event_subscription_result_type,
-        )
-      when :event_subscribe_stateful, :event_subscribe_once_stateful
-        Types::Registry.function(
-          kind.to_s,
-          params: [
-            Types::Registry.parameter("state", pointer_to(@ctx.types.fetch("void"))),
-            Types::Registry.parameter("listener", event_stateful_listener_function_type(event_type)),
-          ],
-          return_type: event_subscription_result_type,
-        )
-      when :event_unsubscribe
-        Types::Registry.function(
-          kind.to_s,
-          params: [Types::Registry.parameter("subscription", @ctx.types.fetch("Subscription"))],
-          return_type: @ctx.types.fetch("bool"),
-        )
-      when :event_emit
-        params = []
-        params << Types::Registry.parameter("payload", event_type.payload_type) if event_type.payload_type
-        Types::Registry.function(kind.to_s, params:, return_type: @ctx.types.fetch("void"))
-      when :event_wait
-        Types::Registry.function(kind.to_s, params: [], return_type: Types::Registry.task(event_wait_result_type(event_type)))
-      else
-        raise LoweringError.new("unsupported event method #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def event_method_type(kind, event_type)
+        case kind
+        when :event_subscribe, :event_subscribe_once
+          Types::Registry.function(
+            kind.to_s,
+            params: [Types::Registry.parameter("listener", event_listener_function_type(event_type))],
+            return_type: event_subscription_result_type,
+          )
+        when :event_subscribe_stateful, :event_subscribe_once_stateful
+          Types::Registry.function(
+            kind.to_s,
+            params: [
+              Types::Registry.parameter("state", pointer_to(@ctx.types.fetch("void"))),
+              Types::Registry.parameter("listener", event_stateful_listener_function_type(event_type)),
+            ],
+            return_type: event_subscription_result_type,
+          )
+        when :event_unsubscribe
+          Types::Registry.function(
+            kind.to_s,
+            params: [Types::Registry.parameter("subscription", @ctx.types.fetch("Subscription"))],
+            return_type: @ctx.types.fetch("bool"),
+          )
+        when :event_emit
+          params = []
+          params << Types::Registry.parameter("payload", event_type.payload_type) if event_type.payload_type
+          Types::Registry.function(kind.to_s, params:, return_type: @ctx.types.fetch("void"))
+        when :event_wait
+          Types::Registry.function(kind.to_s, params: [], return_type: Types::Registry.task(event_wait_result_type(event_type)))
+        else
+          raise LoweringError.new("unsupported event method #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
       end
-    end
 
-    def event_member_from_owner_type(receiver_type, member_name)
-      owner_type = receiver_type
-      loop do
-        case owner_type
-        when Types::Nullable
-          owner_type = owner_type.base
-        when Types::GenericInstance
-          if %w[ptr const_ptr own ref].include?(owner_type.name) && owner_type.arguments.length == 1
-            owner_type = owner_type.arguments.first
+      def event_member_from_owner_type(receiver_type, member_name)
+        owner_type = receiver_type
+        loop do
+          case owner_type
+          when Types::Nullable
+            owner_type = owner_type.base
+          when Types::GenericInstance
+            if %w[ptr const_ptr own ref].include?(owner_type.name) && owner_type.arguments.length == 1
+              owner_type = owner_type.arguments.first
+            else
+              break
+            end
           else
             break
           end
-        else
-          break
         end
+
+        return unless owner_type.respond_to?(:event)
+
+        owner_type.event(member_name)
       end
 
-      return unless owner_type.respond_to?(:event)
+      def lower_event_storage_pointer(expression, env:)
+        event_type = infer_expression_type(expression, env:)
+        IR::AddressOf.new(
+          expression: lower_expression(expression, env:, expected_type: event_type),
+          type: pointer_to(event_type),
+        )
+      end
 
-      owner_type.event(member_name)
-    end
+      def event_listener_function_type(event_type)
+        params = []
+        params << Types::Registry.parameter("payload", event_type.payload_type) if event_type.payload_type
+        Types::Registry.function("#{event_type.name}__listener", params:, return_type: @ctx.types.fetch("void"))
+      end
 
-    def lower_event_storage_pointer(expression, env:)
-      event_type = infer_expression_type(expression, env:)
-      IR::AddressOf.new(
-        expression: lower_expression(expression, env:, expected_type: event_type),
-        type: pointer_to(event_type),
-      )
-    end
+      def event_stateful_listener_function_type(event_type)
+        params = [Types::Registry.parameter("state", pointer_to(@ctx.types.fetch("void")))]
+        params << Types::Registry.parameter("payload", event_type.payload_type) if event_type.payload_type
+        Types::Registry.function("#{event_type.name}__stateful_listener", params:, return_type: @ctx.types.fetch("void"))
+      end
 
-    def event_listener_function_type(event_type)
-      params = []
-      params << Types::Registry.parameter("payload", event_type.payload_type) if event_type.payload_type
-      Types::Registry.function("#{event_type.name}__listener", params:, return_type: @ctx.types.fetch("void"))
-    end
+      def array_of(type, length)
+        Types::Registry.generic_instance("array", [type, Types::LiteralTypeArg.new(length)])
+      end
 
-    def event_stateful_listener_function_type(event_type)
-      params = [Types::Registry.parameter("state", pointer_to(@ctx.types.fetch("void")))]
-      params << Types::Registry.parameter("payload", event_type.payload_type) if event_type.payload_type
-      Types::Registry.function("#{event_type.name}__stateful_listener", params:, return_type: @ctx.types.fetch("void"))
-    end
+      def ensure_subscription_runtime
+        return if @artifacts.subscription_runtime_emitted
 
-    def array_of(type, length)
-      Types::Registry.generic_instance("array", [type, Types::LiteralTypeArg.new(length)])
-    end
+        subscription_type = @ctx.types.fetch("Subscription")
+        @artifacts.synthetic_structs << IR::StructDecl.new(
+          name: subscription_type.name,
+          linkage_name: subscription_type.linkage_name,
+          fields: [
+            IR::Field.new(name: "slot", type: @ctx.types.fetch("ptr_uint")),
+            IR::Field.new(name: "generation", type: @ctx.types.fetch("ptr_uint")),
+          ],
+          packed: false,
+          alignment: nil,
+        )
+        @artifacts.subscription_runtime_emitted = true
+      end
 
-    def ensure_subscription_runtime
-      return if @artifacts.subscription_runtime_emitted
-
-      subscription_type = @ctx.types.fetch("Subscription")
-      @artifacts.synthetic_structs << IR::StructDecl.new(
-        name: subscription_type.name,
-        linkage_name: subscription_type.linkage_name,
-        fields: [
-          IR::Field.new(name: "slot", type: @ctx.types.fetch("ptr_uint")),
-          IR::Field.new(name: "generation", type: @ctx.types.fetch("ptr_uint")),
-        ],
-        packed: false,
-        alignment: nil,
-      )
-      @artifacts.subscription_runtime_emitted = true
-    end
+      def ensure_event_error_enum
+        return if @artifacts.event_error_enum_emitted
+
+        event_error_type = @ctx.types.fetch("EventError")
+        @artifacts.synthetic_enums << IR::EnumDecl.new(
+          name: event_error_type.name,
+          linkage_name: c_type_name(event_error_type),
+          backing_type: event_error_type.backing_type,
+          members: [
+            IR::EnumMember.new(
+              name: "full",
+              linkage_name: enum_member_c_name(event_error_type, "full"),
+              value: IR::IntegerLiteral.new(value: 0, type: event_error_type.backing_type),
+            ),
+          ],
+          flags: false,
+        )
+        @artifacts.event_error_enum_emitted = true
+      end
 
-    def ensure_event_error_enum
-      return if @artifacts.event_error_enum_emitted
-
-      event_error_type = @ctx.types.fetch("EventError")
-      @artifacts.synthetic_enums << IR::EnumDecl.new(
-        name: event_error_type.name,
-        linkage_name: c_type_name(event_error_type),
-        backing_type: event_error_type.backing_type,
-        members: [
-          IR::EnumMember.new(
-            name: "full",
-            linkage_name: enum_member_c_name(event_error_type, "full"),
-            value: IR::IntegerLiteral.new(value: 0, type: event_error_type.backing_type),
-          ),
-        ],
-        flags: false,
-      )
-      @artifacts.event_error_enum_emitted = true
-    end
+      def ensure_event_runtime(event_type)
+        return @artifacts.event_runtime_infos.fetch(event_type) if @artifacts.event_runtime_infos.key?(event_type)
+
+        ensure_subscription_runtime
+        ensure_event_error_enum
+
+        void_ptr = pointer_to(@ctx.types.fetch("void"))
+        listener_type = event_listener_function_type(event_type)
+        subscription_result_type = event_subscription_result_type
+        wait_result_type = event_wait_result_type(event_type)
+        task_type = Types::Registry.task(wait_result_type)
+        wake_type = task_type.field("ready").params.fetch(0).type == void_ptr ? task_type.field("set_waiter").params.fetch(2).type : Types::Registry.function(nil, params: [Types::Registry.parameter("frame", void_ptr)], return_type: @ctx.types.fetch("void"))
+        slot_type = Types::Struct.new("#{event_type.linkage_name}__slot").define_fields(
+          "active" => @ctx.types.fetch("bool"),
+          "once" => @ctx.types.fetch("bool"),
+          "generation" => @ctx.types.fetch("ptr_uint"),
+          "state" => void_ptr,
+          "listener" => void_ptr,
+          "wait_frame" => void_ptr,
+        )
+        snapshot_type = Types::Struct.new("#{event_type.linkage_name}__snapshot").define_fields(
+          "slot" => @ctx.types.fetch("ptr_uint"),
+          "generation" => @ctx.types.fetch("ptr_uint"),
+          "once" => @ctx.types.fetch("bool"),
+          "wait_slot" => @ctx.types.fetch("bool"),
+          "stateful" => @ctx.types.fetch("bool"),
+          "state" => void_ptr,
+          "listener" => void_ptr,
+        )
+        wait_frame_type = Types::Struct.new("#{event_type.linkage_name}__wait_frame").define_fields(
+          "ready" => @ctx.types.fetch("bool"),
+          "waiter_frame" => void_ptr,
+          "waiter" => wake_type,
+          "event" => void_ptr,
+          "subscription" => @ctx.types.fetch("Subscription"),
+          "result" => wait_result_type,
+        )
+        slots_type = array_of(slot_type, event_type.capacity)
+        snapshots_type = array_of(snapshot_type, event_type.capacity)
+
+        @artifacts.synthetic_structs << IR::StructDecl.new(
+          name: slot_type.name,
+          linkage_name: slot_type.name,
+          fields: [
+            IR::Field.new(name: "active", type: @ctx.types.fetch("bool")),
+            IR::Field.new(name: "once", type: @ctx.types.fetch("bool")),
+            IR::Field.new(name: "generation", type: @ctx.types.fetch("ptr_uint")),
+            IR::Field.new(name: "state", type: void_ptr),
+            IR::Field.new(name: "listener", type: void_ptr),
+            IR::Field.new(name: "wait_frame", type: void_ptr),
+          ],
+          packed: false,
+          alignment: nil,
+        )
+        @artifacts.synthetic_structs << IR::StructDecl.new(
+          name: snapshot_type.name,
+          linkage_name: snapshot_type.name,
+          fields: [
+            IR::Field.new(name: "slot", type: @ctx.types.fetch("ptr_uint")),
+            IR::Field.new(name: "generation", type: @ctx.types.fetch("ptr_uint")),
+            IR::Field.new(name: "once", type: @ctx.types.fetch("bool")),
+            IR::Field.new(name: "wait_slot", type: @ctx.types.fetch("bool")),
+            IR::Field.new(name: "stateful", type: @ctx.types.fetch("bool")),
+            IR::Field.new(name: "state", type: void_ptr),
+            IR::Field.new(name: "listener", type: void_ptr),
+          ],
+          packed: false,
+          alignment: nil,
+        )
+        @artifacts.synthetic_structs << IR::StructDecl.new(
+          name: wait_frame_type.name,
+          linkage_name: wait_frame_type.name,
+          fields: [
+            IR::Field.new(name: "ready", type: @ctx.types.fetch("bool")),
+            IR::Field.new(name: "waiter_frame", type: void_ptr),
+            IR::Field.new(name: "waiter", type: wake_type),
+            IR::Field.new(name: "event", type: void_ptr),
+            IR::Field.new(name: "subscription", type: @ctx.types.fetch("Subscription")),
+            IR::Field.new(name: "result", type: wait_result_type),
+          ],
+          packed: false,
+          alignment: nil,
+        )
+        @artifacts.synthetic_structs << IR::StructDecl.new(
+          name: event_type.name,
+          linkage_name: event_type.linkage_name,
+          fields: [IR::Field.new(name: "slots", type: slots_type)],
+          packed: false,
+          alignment: nil,
+        )
 
-    def ensure_event_runtime(event_type)
-      return @artifacts.event_runtime_infos.fetch(event_type) if @artifacts.event_runtime_infos.key?(event_type)
-
-      ensure_subscription_runtime
-      ensure_event_error_enum
-
-      void_ptr = pointer_to(@ctx.types.fetch("void"))
-      listener_type = event_listener_function_type(event_type)
-      subscription_result_type = event_subscription_result_type
-      wait_result_type = event_wait_result_type(event_type)
-      task_type = Types::Registry.task(wait_result_type)
-      wake_type = task_type.field("ready").params.fetch(0).type == void_ptr ? task_type.field("set_waiter").params.fetch(2).type : Types::Registry.function(nil, params: [Types::Registry.parameter("frame", void_ptr)], return_type: @ctx.types.fetch("void"))
-      slot_type = Types::Struct.new("#{event_type.linkage_name}__slot").define_fields(
-        "active" => @ctx.types.fetch("bool"),
-        "once" => @ctx.types.fetch("bool"),
-        "generation" => @ctx.types.fetch("ptr_uint"),
-        "state" => void_ptr,
-        "listener" => void_ptr,
-        "wait_frame" => void_ptr,
-      )
-      snapshot_type = Types::Struct.new("#{event_type.linkage_name}__snapshot").define_fields(
-        "slot" => @ctx.types.fetch("ptr_uint"),
-        "generation" => @ctx.types.fetch("ptr_uint"),
-        "once" => @ctx.types.fetch("bool"),
-        "wait_slot" => @ctx.types.fetch("bool"),
-        "stateful" => @ctx.types.fetch("bool"),
-        "state" => void_ptr,
-        "listener" => void_ptr,
-      )
-      wait_frame_type = Types::Struct.new("#{event_type.linkage_name}__wait_frame").define_fields(
-        "ready" => @ctx.types.fetch("bool"),
-        "waiter_frame" => void_ptr,
-        "waiter" => wake_type,
-        "event" => void_ptr,
-        "subscription" => @ctx.types.fetch("Subscription"),
-        "result" => wait_result_type,
-      )
-      slots_type = array_of(slot_type, event_type.capacity)
-      snapshots_type = array_of(snapshot_type, event_type.capacity)
-
-      @artifacts.synthetic_structs << IR::StructDecl.new(
-        name: slot_type.name,
-        linkage_name: slot_type.name,
-        fields: [
-          IR::Field.new(name: "active", type: @ctx.types.fetch("bool")),
-          IR::Field.new(name: "once", type: @ctx.types.fetch("bool")),
-          IR::Field.new(name: "generation", type: @ctx.types.fetch("ptr_uint")),
-          IR::Field.new(name: "state", type: void_ptr),
-          IR::Field.new(name: "listener", type: void_ptr),
-          IR::Field.new(name: "wait_frame", type: void_ptr),
-        ],
-        packed: false,
-        alignment: nil,
-      )
-      @artifacts.synthetic_structs << IR::StructDecl.new(
-        name: snapshot_type.name,
-        linkage_name: snapshot_type.name,
-        fields: [
-          IR::Field.new(name: "slot", type: @ctx.types.fetch("ptr_uint")),
-          IR::Field.new(name: "generation", type: @ctx.types.fetch("ptr_uint")),
-          IR::Field.new(name: "once", type: @ctx.types.fetch("bool")),
-          IR::Field.new(name: "wait_slot", type: @ctx.types.fetch("bool")),
-          IR::Field.new(name: "stateful", type: @ctx.types.fetch("bool")),
-          IR::Field.new(name: "state", type: void_ptr),
-          IR::Field.new(name: "listener", type: void_ptr),
-        ],
-        packed: false,
-        alignment: nil,
-      )
-      @artifacts.synthetic_structs << IR::StructDecl.new(
-        name: wait_frame_type.name,
-        linkage_name: wait_frame_type.name,
-        fields: [
-          IR::Field.new(name: "ready", type: @ctx.types.fetch("bool")),
-          IR::Field.new(name: "waiter_frame", type: void_ptr),
-          IR::Field.new(name: "waiter", type: wake_type),
-          IR::Field.new(name: "event", type: void_ptr),
-          IR::Field.new(name: "subscription", type: @ctx.types.fetch("Subscription")),
-          IR::Field.new(name: "result", type: wait_result_type),
-        ],
-        packed: false,
-        alignment: nil,
-      )
-      @artifacts.synthetic_structs << IR::StructDecl.new(
-        name: event_type.name,
-        linkage_name: event_type.linkage_name,
-        fields: [IR::Field.new(name: "slots", type: slots_type)],
-        packed: false,
-        alignment: nil,
-      )
-
-      runtime = {
-        event_type:,
-        event_pointer_type: pointer_to(event_type),
-        listener_type:,
-        stateful_listener_type: event_stateful_listener_function_type(event_type),
-        slot_type:,
-        slot_pointer_type: pointer_to(slot_type),
-        slots_type:,
-        snapshot_type:,
-        snapshots_type:,
-        wait_frame_type:,
-        wait_frame_pointer_type: pointer_to(wait_frame_type),
-        void_ptr:,
-        wake_type:,
-        subscription_result_type:,
-        wait_result_type:,
-        task_type:,
-        subscribe_linkage_name: "#{event_type.linkage_name}__subscribe",
-        subscribe_once_linkage_name: "#{event_type.linkage_name}__subscribe_once",
-        subscribe_stateful_linkage_name: "#{event_type.linkage_name}__subscribe_stateful",
-        subscribe_once_stateful_linkage_name: "#{event_type.linkage_name}__subscribe_once_stateful",
-        unsubscribe_linkage_name: "#{event_type.linkage_name}__unsubscribe",
-        emit_linkage_name: "#{event_type.linkage_name}__emit",
-        wait_linkage_name: "#{event_type.linkage_name}__wait",
-        wait_ready_linkage_name: "#{event_type.linkage_name}__wait__ready",
-        wait_set_waiter_linkage_name: "#{event_type.linkage_name}__wait__set_waiter",
-        wait_release_linkage_name: "#{event_type.linkage_name}__wait__release",
-        wait_take_result_linkage_name: "#{event_type.linkage_name}__wait__take_result",
-      }
-
-      @artifacts.synthetic_functions << build_event_subscribe_function(runtime, once: false)
-      @artifacts.synthetic_functions << build_event_subscribe_function(runtime, once: true)
-      @artifacts.synthetic_functions << build_event_subscribe_stateful_function(runtime, once: false)
-      @artifacts.synthetic_functions << build_event_subscribe_stateful_function(runtime, once: true)
-      @artifacts.synthetic_functions << build_event_unsubscribe_function(runtime)
-      @artifacts.synthetic_functions << build_event_emit_function(runtime)
-      @artifacts.synthetic_functions << build_event_wait_ready_function(runtime)
-      @artifacts.synthetic_functions << build_event_wait_set_waiter_function(runtime)
-      @artifacts.synthetic_functions << build_event_wait_release_function(runtime)
-      @artifacts.synthetic_functions << build_event_wait_take_result_function(runtime)
-      @artifacts.synthetic_functions << build_event_wait_function(runtime)
-
-      @artifacts.event_runtime_infos[event_type] = runtime
-    end
+        runtime = {
+          event_type:,
+          event_pointer_type: pointer_to(event_type),
+          listener_type:,
+          stateful_listener_type: event_stateful_listener_function_type(event_type),
+          slot_type:,
+          slot_pointer_type: pointer_to(slot_type),
+          slots_type:,
+          snapshot_type:,
+          snapshots_type:,
+          wait_frame_type:,
+          wait_frame_pointer_type: pointer_to(wait_frame_type),
+          void_ptr:,
+          wake_type:,
+          subscription_result_type:,
+          wait_result_type:,
+          task_type:,
+          subscribe_linkage_name: "#{event_type.linkage_name}__subscribe",
+          subscribe_once_linkage_name: "#{event_type.linkage_name}__subscribe_once",
+          subscribe_stateful_linkage_name: "#{event_type.linkage_name}__subscribe_stateful",
+          subscribe_once_stateful_linkage_name: "#{event_type.linkage_name}__subscribe_once_stateful",
+          unsubscribe_linkage_name: "#{event_type.linkage_name}__unsubscribe",
+          emit_linkage_name: "#{event_type.linkage_name}__emit",
+          wait_linkage_name: "#{event_type.linkage_name}__wait",
+          wait_ready_linkage_name: "#{event_type.linkage_name}__wait__ready",
+          wait_set_waiter_linkage_name: "#{event_type.linkage_name}__wait__set_waiter",
+          wait_release_linkage_name: "#{event_type.linkage_name}__wait__release",
+          wait_take_result_linkage_name: "#{event_type.linkage_name}__wait__take_result",
+        }
+
+        @artifacts.synthetic_functions << build_event_subscribe_function(runtime, once: false)
+        @artifacts.synthetic_functions << build_event_subscribe_function(runtime, once: true)
+        @artifacts.synthetic_functions << build_event_subscribe_stateful_function(runtime, once: false)
+        @artifacts.synthetic_functions << build_event_subscribe_stateful_function(runtime, once: true)
+        @artifacts.synthetic_functions << build_event_unsubscribe_function(runtime)
+        @artifacts.synthetic_functions << build_event_emit_function(runtime)
+        @artifacts.synthetic_functions << build_event_wait_ready_function(runtime)
+        @artifacts.synthetic_functions << build_event_wait_set_waiter_function(runtime)
+        @artifacts.synthetic_functions << build_event_wait_release_function(runtime)
+        @artifacts.synthetic_functions << build_event_wait_take_result_function(runtime)
+        @artifacts.synthetic_functions << build_event_wait_function(runtime)
+
+        @artifacts.event_runtime_infos[event_type] = runtime
+      end
 
-    def build_event_subscribe_function(runtime, once:)
-      event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
-      listener_expr = IR::Name.new(name: "listener", type: runtime.fetch(:listener_type), pointer: false)
-      slot_index_expr = IR::Name.new(name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      generation_expr = IR::Name.new(name: "__mt_generation", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
-
-      body = [
-        IR::ForStmt.new(
-          init: IR::LocalDecl.new(
-            name: "__mt_slot_index",
-            linkage_name: "__mt_slot_index",
-            type: @ctx.types.fetch("ptr_uint"),
-            value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
-          ),
-          condition: IR::Binary.new(
-            operator: "<",
-            left: slot_index_expr,
-            right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")),
-            type: @ctx.types.fetch("bool"),
-          ),
-          post: IR::Assignment.new(target: slot_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-          body: [
-            event_slot_local_decl(event_expr, slot_index_expr, runtime),
-            active_event_slot_continue_guard(slot_pointer_expr),
-            IR::LocalDecl.new(
-              name: "__mt_generation",
-              linkage_name: "__mt_generation",
+      def build_event_subscribe_function(runtime, once:)
+        event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
+        listener_expr = IR::Name.new(name: "listener", type: runtime.fetch(:listener_type), pointer: false)
+        slot_index_expr = IR::Name.new(name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        generation_expr = IR::Name.new(name: "__mt_generation", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
+
+        body = [
+          IR::ForStmt.new(
+            init: IR::LocalDecl.new(
+              name: "__mt_slot_index",
+              linkage_name: "__mt_slot_index",
               type: @ctx.types.fetch("ptr_uint"),
-              value: event_next_generation_expression(slot_pointer_expr),
+              value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
             ),
-            *event_slot_activate_statements(
-              slot_pointer_expr,
-              runtime,
-              generation_expr: generation_expr,
-              once: once,
-              wait_frame_expr: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
-              listener_expr: IR::Cast.new(target_type: runtime.fetch(:void_ptr), expression: listener_expr, type: runtime.fetch(:void_ptr)),
+            condition: IR::Binary.new(
+              operator: "<",
+              left: slot_index_expr,
+              right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")),
+              type: @ctx.types.fetch("bool"),
             ),
-            IR::ReturnStmt.new(value: event_subscription_success_literal(runtime.fetch(:subscription_result_type), slot_index_expr, generation_expr)),
+            post: IR::Assignment.new(target: slot_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+            body: [
+              event_slot_local_decl(event_expr, slot_index_expr, runtime),
+              active_event_slot_continue_guard(slot_pointer_expr),
+              IR::LocalDecl.new(
+                name: "__mt_generation",
+                linkage_name: "__mt_generation",
+                type: @ctx.types.fetch("ptr_uint"),
+                value: event_next_generation_expression(slot_pointer_expr),
+              ),
+              *event_slot_activate_statements(
+                slot_pointer_expr,
+                runtime,
+                generation_expr: generation_expr,
+                once: once,
+                wait_frame_expr: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+                listener_expr: IR::Cast.new(target_type: runtime.fetch(:void_ptr), expression: listener_expr, type: runtime.fetch(:void_ptr)),
+              ),
+              IR::ReturnStmt.new(value: event_subscription_success_literal(runtime.fetch(:subscription_result_type), slot_index_expr, generation_expr)),
+            ],
+          ),
+          IR::ReturnStmt.new(value: event_failure_literal(runtime.fetch(:subscription_result_type))),
+        ]
+
+        IR::Function.new(
+          name: once ? "#{runtime.fetch(:subscribe_once_linkage_name)}_fn" : "#{runtime.fetch(:subscribe_linkage_name)}_fn",
+          linkage_name: once ? runtime.fetch(:subscribe_once_linkage_name) : runtime.fetch(:subscribe_linkage_name),
+          params: [
+            IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false),
+            IR::Param.new(name: "listener", linkage_name: "listener", type: runtime.fetch(:listener_type), pointer: false),
           ],
-        ),
-        IR::ReturnStmt.new(value: event_failure_literal(runtime.fetch(:subscription_result_type))),
-      ]
-
-      IR::Function.new(
-        name: once ? "#{runtime.fetch(:subscribe_once_linkage_name)}_fn" : "#{runtime.fetch(:subscribe_linkage_name)}_fn",
-        linkage_name: once ? runtime.fetch(:subscribe_once_linkage_name) : runtime.fetch(:subscribe_linkage_name),
-        params: [
-          IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false),
-          IR::Param.new(name: "listener", linkage_name: "listener", type: runtime.fetch(:listener_type), pointer: false),
-        ],
-        return_type: runtime.fetch(:subscription_result_type),
-        body:,
-        entry_point: false,
-      )
-    end
+          return_type: runtime.fetch(:subscription_result_type),
+          body:,
+          entry_point: false,
+        )
+      end
 
-    def build_event_subscribe_stateful_function(runtime, once:)
-      event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
-      state_expr = IR::Name.new(name: "state", type: runtime.fetch(:void_ptr), pointer: false)
-      listener_expr = IR::Name.new(name: "listener", type: runtime.fetch(:void_ptr), pointer: false)
-      slot_index_expr = IR::Name.new(name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      generation_expr = IR::Name.new(name: "__mt_generation", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
-
-      body = [
-        IR::ForStmt.new(
-          init: IR::LocalDecl.new(
-            name: "__mt_slot_index",
-            linkage_name: "__mt_slot_index",
-            type: @ctx.types.fetch("ptr_uint"),
-            value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
-          ),
-          condition: IR::Binary.new(
-            operator: "<",
-            left: slot_index_expr,
-            right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")),
-            type: @ctx.types.fetch("bool"),
-          ),
-          post: IR::Assignment.new(target: slot_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-          body: [
-            event_slot_local_decl(event_expr, slot_index_expr, runtime),
-            active_event_slot_continue_guard(slot_pointer_expr),
-            IR::LocalDecl.new(
-              name: "__mt_generation",
-              linkage_name: "__mt_generation",
+      def build_event_subscribe_stateful_function(runtime, once:)
+        event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
+        state_expr = IR::Name.new(name: "state", type: runtime.fetch(:void_ptr), pointer: false)
+        listener_expr = IR::Name.new(name: "listener", type: runtime.fetch(:void_ptr), pointer: false)
+        slot_index_expr = IR::Name.new(name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        generation_expr = IR::Name.new(name: "__mt_generation", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
+
+        body = [
+          IR::ForStmt.new(
+            init: IR::LocalDecl.new(
+              name: "__mt_slot_index",
+              linkage_name: "__mt_slot_index",
               type: @ctx.types.fetch("ptr_uint"),
-              value: event_next_generation_expression(slot_pointer_expr),
+              value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
             ),
-            *event_slot_activate_stateful_statements(
-              slot_pointer_expr,
-              runtime,
-              generation_expr: generation_expr,
-              once: once,
-              state_expr: state_expr,
-              wait_frame_expr: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
-              listener_expr: listener_expr,
+            condition: IR::Binary.new(
+              operator: "<",
+              left: slot_index_expr,
+              right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")),
+              type: @ctx.types.fetch("bool"),
             ),
-            IR::ReturnStmt.new(value: event_subscription_success_literal(runtime.fetch(:subscription_result_type), slot_index_expr, generation_expr)),
-          ],
-        ),
-        IR::ReturnStmt.new(value: event_failure_literal(runtime.fetch(:subscription_result_type))),
-      ]
-
-      linkage_name = once ? runtime.fetch(:subscribe_once_stateful_linkage_name) : runtime.fetch(:subscribe_stateful_linkage_name)
-      IR::Function.new(
-        name: "#{linkage_name}_fn",
-        linkage_name:,
-        params: [
-          IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false),
-          IR::Param.new(name: "state", linkage_name: "state", type: runtime.fetch(:void_ptr), pointer: false),
-          IR::Param.new(name: "listener", linkage_name: "listener", type: runtime.fetch(:void_ptr), pointer: false),
-        ],
-        return_type: runtime.fetch(:subscription_result_type),
-        body:,
-        entry_point: false,
-      )
-    end
-
-    def build_event_unsubscribe_function(runtime)
-      event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
-      subscription_expr = IR::Name.new(name: "subscription", type: @ctx.types.fetch("Subscription"), pointer: false)
-      slot_index_expr = subscription_field_expression(subscription_expr, "slot", @ctx.types.fetch("ptr_uint"))
-      slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
-
-      false_value = IR::BooleanLiteral.new(value: false, type: @ctx.types.fetch("bool"))
-      true_value = IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool"))
-      body = [
-        IR::IfStmt.new(
-          condition: IR::Binary.new(
-            operator: ">=",
-            left: slot_index_expr,
-            right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")),
-            type: @ctx.types.fetch("bool"),
-          ),
-          then_body: [IR::ReturnStmt.new(value: false_value)],
-          else_body: nil,
-        ),
-        IR::LocalDecl.new(
-          name: "__mt_slot",
-          linkage_name: "__mt_slot",
-          type: runtime.fetch(:slot_pointer_type),
-          value: event_slot_pointer_expression(event_expr, slot_index_expr, runtime),
-        ),
-        IR::IfStmt.new(
-          condition: IR::Unary.new(operator: "not", operand: event_slot_active_expression(slot_pointer_expr), type: @ctx.types.fetch("bool")),
-          then_body: [IR::ReturnStmt.new(value: false_value)],
-          else_body: nil,
-        ),
-        IR::IfStmt.new(
-          condition: IR::Binary.new(
-            operator: "!=",
-            left: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint")),
-            right: subscription_field_expression(subscription_expr, "generation", @ctx.types.fetch("ptr_uint")),
-            type: @ctx.types.fetch("bool"),
-          ),
-          then_body: [IR::ReturnStmt.new(value: false_value)],
-          else_body: nil,
-        ),
-        *event_slot_clear_statements(slot_pointer_expr, runtime),
-        IR::ReturnStmt.new(value: true_value),
-      ]
-
-      IR::Function.new(
-        name: "#{runtime.fetch(:unsubscribe_linkage_name)}_fn",
-        linkage_name: runtime.fetch(:unsubscribe_linkage_name),
-        params: [
-          IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false),
-          IR::Param.new(name: "subscription", linkage_name: "subscription", type: @ctx.types.fetch("Subscription"), pointer: false),
-        ],
-        return_type: @ctx.types.fetch("bool"),
-        body:,
-        entry_point: false,
-      )
-    end
-
-    def build_event_emit_function(runtime)
-      event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
-      payload_expr = runtime.fetch(:event_type).payload_type ? IR::Name.new(name: "payload", type: runtime.fetch(:event_type).payload_type, pointer: false) : nil
-      snapshots_expr = IR::Name.new(name: "__mt_snapshots", type: runtime.fetch(:snapshots_type), pointer: false)
-      snapshot_count_expr = IR::Name.new(name: "__mt_snapshot_count", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      slot_index_expr = IR::Name.new(name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      dispatch_index_expr = IR::Name.new(name: "__mt_dispatch_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
-      frame_pointer_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
-
-      collect_body = [
-        event_slot_local_decl(event_expr, slot_index_expr, runtime),
-        inactive_event_slot_continue_guard(slot_pointer_expr),
-        IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "slot", @ctx.types.fetch("ptr_uint")), operator: "=", value: slot_index_expr),
-        IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "generation", @ctx.types.fetch("ptr_uint")), operator: "=", value: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint"))),
-        IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "once", @ctx.types.fetch("bool")), operator: "=", value: event_slot_field_expression(slot_pointer_expr, "once", @ctx.types.fetch("bool"))),
-        IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "wait_slot", @ctx.types.fetch("bool")),
-          operator: "=",
-          value: IR::Binary.new(
-            operator: "!=",
-            left: event_slot_wait_frame_expression(slot_pointer_expr, runtime),
-            right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
-            type: @ctx.types.fetch("bool"),
-          ),
-        ),
-        IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "stateful", @ctx.types.fetch("bool")), operator: "=", value: IR::Binary.new(operator: "!=", left: event_slot_field_expression(slot_pointer_expr, "state", runtime.fetch(:void_ptr)), right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)), type: @ctx.types.fetch("bool"))),
-        IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "state", runtime.fetch(:void_ptr)), operator: "=", value: event_slot_field_expression(slot_pointer_expr, "state", runtime.fetch(:void_ptr))),
-        IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "listener", runtime.fetch(:void_ptr)), operator: "=", value: event_slot_field_expression(slot_pointer_expr, "listener", runtime.fetch(:void_ptr))),
-        IR::Assignment.new(target: snapshot_count_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-      ]
-
-      snapshot_subscription_expr = event_subscription_literal(
-        snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "slot", @ctx.types.fetch("ptr_uint")),
-        snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "generation", @ctx.types.fetch("ptr_uint")),
-      )
-      current_slot_active = event_slot_active_expression(slot_pointer_expr)
-      current_slot_generation = event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint"))
-      current_wait_frame = event_slot_wait_frame_expression(slot_pointer_expr, runtime)
-      wait_slot_condition = IR::Binary.new(
-        operator: "and",
-        left: current_slot_active,
-        right: IR::Binary.new(
-          operator: "and",
-          left: IR::Binary.new(
-            operator: "==",
-            left: current_slot_generation,
-            right: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "generation", @ctx.types.fetch("ptr_uint")),
-            type: @ctx.types.fetch("bool"),
-          ),
-          right: IR::Binary.new(
-            operator: "!=",
-            left: current_wait_frame,
-            right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
-            type: @ctx.types.fetch("bool"),
-          ),
-          type: @ctx.types.fetch("bool"),
-        ),
-        type: @ctx.types.fetch("bool"),
-      )
-
-      wait_result_value = event_wait_success_literal(runtime.fetch(:wait_result_type), payload_expr)
-      waiter_frame_expr = wait_frame_field_expression(frame_pointer_expr, "waiter_frame", runtime.fetch(:void_ptr))
-
-      dispatch_body = [
-        IR::IfStmt.new(
-          condition: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "wait_slot", @ctx.types.fetch("bool")),
-          then_body: [
-            IR::LocalDecl.new(
-              name: "__mt_slot",
-              linkage_name: "__mt_slot",
-              type: runtime.fetch(:slot_pointer_type),
-              value: event_slot_pointer_expression(
-                event_expr,
-                snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "slot", @ctx.types.fetch("ptr_uint")),
+            post: IR::Assignment.new(target: slot_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+            body: [
+              event_slot_local_decl(event_expr, slot_index_expr, runtime),
+              active_event_slot_continue_guard(slot_pointer_expr),
+              IR::LocalDecl.new(
+                name: "__mt_generation",
+                linkage_name: "__mt_generation",
+                type: @ctx.types.fetch("ptr_uint"),
+                value: event_next_generation_expression(slot_pointer_expr),
+              ),
+              *event_slot_activate_stateful_statements(
+                slot_pointer_expr,
                 runtime,
+                generation_expr: generation_expr,
+                once: once,
+                state_expr: state_expr,
+                wait_frame_expr: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+                listener_expr: listener_expr,
               ),
-            ),
-            IR::IfStmt.new(
-              condition: wait_slot_condition,
-              then_body: [
-                IR::LocalDecl.new(
-                  name: "__mt_wait_frame",
-                  linkage_name: "__mt_wait_frame",
-                  type: runtime.fetch(:wait_frame_pointer_type),
-                  value: IR::Cast.new(target_type: runtime.fetch(:wait_frame_pointer_type), expression: current_wait_frame, type: runtime.fetch(:wait_frame_pointer_type)),
-                ),
-                IR::ExpressionStmt.new(expression: event_unsubscribe_call(runtime, event_expr, snapshot_subscription_expr)),
-                IR::Assignment.new(target: wait_frame_field_expression(frame_pointer_expr, "result", runtime.fetch(:wait_result_type)), operator: "=", value: wait_result_value),
-                IR::Assignment.new(target: wait_frame_field_expression(frame_pointer_expr, "ready", @ctx.types.fetch("bool")), operator: "=", value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool"))),
-                IR::IfStmt.new(
-                  condition: IR::Binary.new(
-                    operator: "!=",
-                    left: waiter_frame_expr,
-                    right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
-                    type: @ctx.types.fetch("bool"),
-                  ),
-                  then_body: [
-                    IR::LocalDecl.new(name: "__mt_waiter_frame", linkage_name: "__mt_waiter_frame", type: runtime.fetch(:void_ptr), value: waiter_frame_expr),
-                    IR::Assignment.new(target: waiter_frame_expr, operator: "=", value: IR::NullLiteral.new(type: runtime.fetch(:void_ptr))),
-                    IR::ExpressionStmt.new(
-                      expression: IR::Call.new(
-                        callee: wait_frame_field_expression(frame_pointer_expr, "waiter", runtime.fetch(:wake_type)),
-                        arguments: [IR::Name.new(name: "__mt_waiter_frame", type: runtime.fetch(:void_ptr), pointer: false)],
-                        type: @ctx.types.fetch("void"),
-                      ),
-                    ),
-                  ],
-                  else_body: nil,
-                ),
-              ],
-              else_body: nil,
-            ),
-          ],
-          else_body: [
-            IR::IfStmt.new(
-              condition: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "once", @ctx.types.fetch("bool")),
-              then_body: [IR::ExpressionStmt.new(expression: event_unsubscribe_call(runtime, event_expr, snapshot_subscription_expr))],
-              else_body: nil,
-            ),
-            IR::IfStmt.new(
-              condition: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "stateful", @ctx.types.fetch("bool")),
-              then_body: [
-                IR::ExpressionStmt.new(expression: event_stateful_listener_call_expression(runtime, snapshots_expr, dispatch_index_expr, payload_expr)),
-              ],
-              else_body: [
-                IR::ExpressionStmt.new(expression: event_listener_call_expression(runtime, snapshots_expr, dispatch_index_expr, payload_expr)),
-              ],
-            ),
+              IR::ReturnStmt.new(value: event_subscription_success_literal(runtime.fetch(:subscription_result_type), slot_index_expr, generation_expr)),
+            ],
+          ),
+          IR::ReturnStmt.new(value: event_failure_literal(runtime.fetch(:subscription_result_type))),
+        ]
+
+        linkage_name = once ? runtime.fetch(:subscribe_once_stateful_linkage_name) : runtime.fetch(:subscribe_stateful_linkage_name)
+        IR::Function.new(
+          name: "#{linkage_name}_fn",
+          linkage_name:,
+          params: [
+            IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false),
+            IR::Param.new(name: "state", linkage_name: "state", type: runtime.fetch(:void_ptr), pointer: false),
+            IR::Param.new(name: "listener", linkage_name: "listener", type: runtime.fetch(:void_ptr), pointer: false),
           ],
-        ),
-      ]
-
-      body = [
-        IR::LocalDecl.new(name: "__mt_snapshots", linkage_name: "__mt_snapshots", type: runtime.fetch(:snapshots_type), value: IR::ZeroInit.new(type: runtime.fetch(:snapshots_type))),
-        IR::LocalDecl.new(name: "__mt_snapshot_count", linkage_name: "__mt_snapshot_count", type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
-        IR::ForStmt.new(
-          init: IR::LocalDecl.new(name: "__mt_slot_index", linkage_name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
-          condition: IR::Binary.new(operator: "<", left: slot_index_expr, right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")), type: @ctx.types.fetch("bool")),
-          post: IR::Assignment.new(target: slot_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-          body: collect_body,
-        ),
-        IR::ForStmt.new(
-          init: IR::LocalDecl.new(name: "__mt_dispatch_index", linkage_name: "__mt_dispatch_index", type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
-          condition: IR::Binary.new(operator: "<", left: dispatch_index_expr, right: snapshot_count_expr, type: @ctx.types.fetch("bool")),
-          post: IR::Assignment.new(target: dispatch_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-          body: dispatch_body,
-        ),
-        IR::ReturnStmt.new(value: nil),
-      ]
-
-      params = [IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)]
-      params << IR::Param.new(name: "payload", linkage_name: "payload", type: runtime.fetch(:event_type).payload_type, pointer: false) if runtime.fetch(:event_type).payload_type
-
-      IR::Function.new(
-        name: "#{runtime.fetch(:emit_linkage_name)}_fn",
-        linkage_name: runtime.fetch(:emit_linkage_name),
-        params:,
-        return_type: @ctx.types.fetch("void"),
-        body:,
-        entry_point: false,
-      )
-    end
+          return_type: runtime.fetch(:subscription_result_type),
+          body:,
+          entry_point: false,
+        )
+      end
 
-    def build_event_wait_ready_function(runtime)
-      frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
-      raw_frame_expr = IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false)
+      def build_event_unsubscribe_function(runtime)
+        event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
+        subscription_expr = IR::Name.new(name: "subscription", type: @ctx.types.fetch("Subscription"), pointer: false)
+        slot_index_expr = subscription_field_expression(subscription_expr, "slot", @ctx.types.fetch("ptr_uint"))
+        slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
 
-      IR::Function.new(
-        name: "#{runtime.fetch(:wait_ready_linkage_name)}_fn",
-        linkage_name: runtime.fetch(:wait_ready_linkage_name),
-        params: [IR::Param.new(name: "frame", linkage_name: "frame", type: runtime.fetch(:void_ptr), pointer: false)],
-        return_type: @ctx.types.fetch("bool"),
-        body: [
+        false_value = IR::BooleanLiteral.new(value: false, type: @ctx.types.fetch("bool"))
+        true_value = IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool"))
+        body = [
           IR::IfStmt.new(
             condition: IR::Binary.new(
-              operator: "==",
-              left: raw_frame_expr,
-              right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+              operator: ">=",
+              left: slot_index_expr,
+              right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")),
               type: @ctx.types.fetch("bool"),
             ),
-            then_body: [IR::ReturnStmt.new(value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")))],
+            then_body: [IR::ReturnStmt.new(value: false_value)],
             else_body: nil,
           ),
           IR::LocalDecl.new(
-            name: "__mt_wait_frame",
-            linkage_name: "__mt_wait_frame",
-            type: runtime.fetch(:wait_frame_pointer_type),
-            value: IR::Cast.new(
-              target_type: runtime.fetch(:wait_frame_pointer_type),
-              expression: IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false),
-              type: runtime.fetch(:wait_frame_pointer_type),
-            ),
+            name: "__mt_slot",
+            linkage_name: "__mt_slot",
+            type: runtime.fetch(:slot_pointer_type),
+            value: event_slot_pointer_expression(event_expr, slot_index_expr, runtime),
           ),
-          IR::ReturnStmt.new(value: wait_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool"))),
-        ],
-        entry_point: false,
-      )
-    end
-
-    def build_event_wait_set_waiter_function(runtime)
-      frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
-      raw_frame_expr = IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false)
-      waiter_frame_expr = IR::Name.new(name: "waiter_frame", type: runtime.fetch(:void_ptr), pointer: false)
-      waiter_expr = IR::Name.new(name: "waiter", type: runtime.fetch(:wake_type), pointer: false)
-
-      IR::Function.new(
-        name: "#{runtime.fetch(:wait_set_waiter_linkage_name)}_fn",
-        linkage_name: runtime.fetch(:wait_set_waiter_linkage_name),
-        params: [
-          IR::Param.new(name: "frame", linkage_name: "frame", type: runtime.fetch(:void_ptr), pointer: false),
-          IR::Param.new(name: "waiter_frame", linkage_name: "waiter_frame", type: runtime.fetch(:void_ptr), pointer: false),
-          IR::Param.new(name: "waiter", linkage_name: "waiter", type: runtime.fetch(:wake_type), pointer: false),
-        ],
-        return_type: @ctx.types.fetch("void"),
-        body: [
           IR::IfStmt.new(
-            condition: IR::Binary.new(
-              operator: "==",
-              left: raw_frame_expr,
-              right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
-              type: @ctx.types.fetch("bool"),
-            ),
-            then_body: [
-              IR::ExpressionStmt.new(expression: IR::Call.new(callee: waiter_expr, arguments: [waiter_frame_expr], type: @ctx.types.fetch("void"))),
-              IR::ReturnStmt.new(value: nil),
-            ],
+            condition: IR::Unary.new(operator: "not", operand: event_slot_active_expression(slot_pointer_expr), type: @ctx.types.fetch("bool")),
+            then_body: [IR::ReturnStmt.new(value: false_value)],
             else_body: nil,
           ),
-          IR::LocalDecl.new(
-            name: "__mt_wait_frame",
-            linkage_name: "__mt_wait_frame",
-            type: runtime.fetch(:wait_frame_pointer_type),
-            value: IR::Cast.new(target_type: runtime.fetch(:wait_frame_pointer_type), expression: IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false), type: runtime.fetch(:wait_frame_pointer_type)),
-          ),
           IR::IfStmt.new(
-            condition: wait_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")),
-            then_body: [
-              IR::ExpressionStmt.new(expression: IR::Call.new(callee: waiter_expr, arguments: [waiter_frame_expr], type: @ctx.types.fetch("void"))),
-              IR::ReturnStmt.new(value: nil),
-            ],
+            condition: IR::Binary.new(
+              operator: "!=",
+              left: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint")),
+              right: subscription_field_expression(subscription_expr, "generation", @ctx.types.fetch("ptr_uint")),
+              type: @ctx.types.fetch("bool"),
+            ),
+            then_body: [IR::ReturnStmt.new(value: false_value)],
             else_body: nil,
           ),
-          IR::Assignment.new(target: wait_frame_field_expression(frame_expr, "waiter_frame", runtime.fetch(:void_ptr)), operator: "=", value: waiter_frame_expr),
-          IR::Assignment.new(target: wait_frame_field_expression(frame_expr, "waiter", runtime.fetch(:wake_type)), operator: "=", value: waiter_expr),
-          IR::ReturnStmt.new(value: nil),
-        ],
-        entry_point: false,
-      )
-    end
+          *event_slot_clear_statements(slot_pointer_expr, runtime),
+          IR::ReturnStmt.new(value: true_value),
+        ]
 
-    def build_event_wait_release_function(runtime)
-      frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
-      raw_frame_expr = IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false)
+        IR::Function.new(
+          name: "#{runtime.fetch(:unsubscribe_linkage_name)}_fn",
+          linkage_name: runtime.fetch(:unsubscribe_linkage_name),
+          params: [
+            IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false),
+            IR::Param.new(name: "subscription", linkage_name: "subscription", type: @ctx.types.fetch("Subscription"), pointer: false),
+          ],
+          return_type: @ctx.types.fetch("bool"),
+          body:,
+          entry_point: false,
+        )
+      end
 
-      IR::Function.new(
-        name: "#{runtime.fetch(:wait_release_linkage_name)}_fn",
-        linkage_name: runtime.fetch(:wait_release_linkage_name),
-        params: [IR::Param.new(name: "frame", linkage_name: "frame", type: runtime.fetch(:void_ptr), pointer: false)],
-        return_type: @ctx.types.fetch("void"),
-        body: [
-          IR::IfStmt.new(
-            condition: IR::Binary.new(
-              operator: "==",
-              left: raw_frame_expr,
+      def build_event_emit_function(runtime)
+        event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
+        payload_expr = runtime.fetch(:event_type).payload_type ? IR::Name.new(name: "payload", type: runtime.fetch(:event_type).payload_type, pointer: false) : nil
+        snapshots_expr = IR::Name.new(name: "__mt_snapshots", type: runtime.fetch(:snapshots_type), pointer: false)
+        snapshot_count_expr = IR::Name.new(name: "__mt_snapshot_count", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        slot_index_expr = IR::Name.new(name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        dispatch_index_expr = IR::Name.new(name: "__mt_dispatch_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
+        frame_pointer_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
+
+        collect_body = [
+          event_slot_local_decl(event_expr, slot_index_expr, runtime),
+          inactive_event_slot_continue_guard(slot_pointer_expr),
+          IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "slot", @ctx.types.fetch("ptr_uint")), operator: "=", value: slot_index_expr),
+          IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "generation", @ctx.types.fetch("ptr_uint")), operator: "=", value: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint"))),
+          IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "once", @ctx.types.fetch("bool")), operator: "=", value: event_slot_field_expression(slot_pointer_expr, "once", @ctx.types.fetch("bool"))),
+          IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "wait_slot", @ctx.types.fetch("bool")),
+            operator: "=",
+            value: IR::Binary.new(
+              operator: "!=",
+              left: event_slot_wait_frame_expression(slot_pointer_expr, runtime),
               right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
               type: @ctx.types.fetch("bool"),
             ),
-            then_body: [IR::ReturnStmt.new(value: nil)],
-            else_body: nil,
           ),
-          IR::LocalDecl.new(
-            name: "__mt_wait_frame",
-            linkage_name: "__mt_wait_frame",
-            type: runtime.fetch(:wait_frame_pointer_type),
-            value: IR::Cast.new(target_type: runtime.fetch(:wait_frame_pointer_type), expression: raw_frame_expr, type: runtime.fetch(:wait_frame_pointer_type)),
+          IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "stateful", @ctx.types.fetch("bool")), operator: "=", value: IR::Binary.new(operator: "!=", left: event_slot_field_expression(slot_pointer_expr, "state", runtime.fetch(:void_ptr)), right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)), type: @ctx.types.fetch("bool"))),
+          IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "state", runtime.fetch(:void_ptr)), operator: "=", value: event_slot_field_expression(slot_pointer_expr, "state", runtime.fetch(:void_ptr))),
+          IR::Assignment.new(target: snapshot_field_expression(snapshots_expr, snapshot_count_expr, runtime, "listener", runtime.fetch(:void_ptr)), operator: "=", value: event_slot_field_expression(slot_pointer_expr, "listener", runtime.fetch(:void_ptr))),
+          IR::Assignment.new(target: snapshot_count_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+        ]
+
+        snapshot_subscription_expr = event_subscription_literal(
+          snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "slot", @ctx.types.fetch("ptr_uint")),
+          snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "generation", @ctx.types.fetch("ptr_uint")),
+        )
+        current_slot_active = event_slot_active_expression(slot_pointer_expr)
+        current_slot_generation = event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint"))
+        current_wait_frame = event_slot_wait_frame_expression(slot_pointer_expr, runtime)
+        wait_slot_condition = IR::Binary.new(
+          operator: "and",
+          left: current_slot_active,
+          right: IR::Binary.new(
+            operator: "and",
+            left: IR::Binary.new(
+              operator: "==",
+              left: current_slot_generation,
+              right: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "generation", @ctx.types.fetch("ptr_uint")),
+              type: @ctx.types.fetch("bool"),
+            ),
+            right: IR::Binary.new(
+              operator: "!=",
+              left: current_wait_frame,
+              right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+              type: @ctx.types.fetch("bool"),
+            ),
+            type: @ctx.types.fetch("bool"),
           ),
+          type: @ctx.types.fetch("bool"),
+        )
+
+        wait_result_value = event_wait_success_literal(runtime.fetch(:wait_result_type), payload_expr)
+        waiter_frame_expr = wait_frame_field_expression(frame_pointer_expr, "waiter_frame", runtime.fetch(:void_ptr))
+
+        dispatch_body = [
           IR::IfStmt.new(
-            condition: IR::Unary.new(operator: "not", operand: wait_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")), type: @ctx.types.fetch("bool")),
+            condition: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "wait_slot", @ctx.types.fetch("bool")),
             then_body: [
-              IR::ExpressionStmt.new(
-                expression: event_unsubscribe_call(
+              IR::LocalDecl.new(
+                name: "__mt_slot",
+                linkage_name: "__mt_slot",
+                type: runtime.fetch(:slot_pointer_type),
+                value: event_slot_pointer_expression(
+                  event_expr,
+                  snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "slot", @ctx.types.fetch("ptr_uint")),
                   runtime,
-                  IR::Cast.new(target_type: runtime.fetch(:event_pointer_type), expression: wait_frame_field_expression(frame_expr, "event", runtime.fetch(:void_ptr)), type: runtime.fetch(:event_pointer_type)),
-                  wait_frame_field_expression(frame_expr, "subscription", @ctx.types.fetch("Subscription")),
                 ),
               ),
+              IR::IfStmt.new(
+                condition: wait_slot_condition,
+                then_body: [
+                  IR::LocalDecl.new(
+                    name: "__mt_wait_frame",
+                    linkage_name: "__mt_wait_frame",
+                    type: runtime.fetch(:wait_frame_pointer_type),
+                    value: IR::Cast.new(target_type: runtime.fetch(:wait_frame_pointer_type), expression: current_wait_frame, type: runtime.fetch(:wait_frame_pointer_type)),
+                  ),
+                  IR::ExpressionStmt.new(expression: event_unsubscribe_call(runtime, event_expr, snapshot_subscription_expr)),
+                  IR::Assignment.new(target: wait_frame_field_expression(frame_pointer_expr, "result", runtime.fetch(:wait_result_type)), operator: "=", value: wait_result_value),
+                  IR::Assignment.new(target: wait_frame_field_expression(frame_pointer_expr, "ready", @ctx.types.fetch("bool")), operator: "=", value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool"))),
+                  IR::IfStmt.new(
+                    condition: IR::Binary.new(
+                      operator: "!=",
+                      left: waiter_frame_expr,
+                      right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+                      type: @ctx.types.fetch("bool"),
+                    ),
+                    then_body: [
+                      IR::LocalDecl.new(name: "__mt_waiter_frame", linkage_name: "__mt_waiter_frame", type: runtime.fetch(:void_ptr), value: waiter_frame_expr),
+                      IR::Assignment.new(target: waiter_frame_expr, operator: "=", value: IR::NullLiteral.new(type: runtime.fetch(:void_ptr))),
+                      IR::ExpressionStmt.new(
+                        expression: IR::Call.new(
+                          callee: wait_frame_field_expression(frame_pointer_expr, "waiter", runtime.fetch(:wake_type)),
+                          arguments: [IR::Name.new(name: "__mt_waiter_frame", type: runtime.fetch(:void_ptr), pointer: false)],
+                          type: @ctx.types.fetch("void"),
+                        ),
+                      ),
+                    ],
+                    else_body: nil,
+                  ),
+                ],
+                else_body: nil,
+              ),
+            ],
+            else_body: [
+              IR::IfStmt.new(
+                condition: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "once", @ctx.types.fetch("bool")),
+                then_body: [IR::ExpressionStmt.new(expression: event_unsubscribe_call(runtime, event_expr, snapshot_subscription_expr))],
+                else_body: nil,
+              ),
+              IR::IfStmt.new(
+                condition: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "stateful", @ctx.types.fetch("bool")),
+                then_body: [
+                  IR::ExpressionStmt.new(expression: event_stateful_listener_call_expression(runtime, snapshots_expr, dispatch_index_expr, payload_expr)),
+                ],
+                else_body: [
+                  IR::ExpressionStmt.new(expression: event_listener_call_expression(runtime, snapshots_expr, dispatch_index_expr, payload_expr)),
+                ],
+              ),
             ],
-            else_body: nil,
           ),
-          IR::ExpressionStmt.new(expression: IR::Call.new(callee: "mt_async_free", arguments: [raw_frame_expr], type: @ctx.types.fetch("void"))),
-          IR::ReturnStmt.new(value: nil),
-        ],
-        entry_point: false,
-      )
-    end
-
-    def build_event_wait_take_result_function(runtime)
-      frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
-      raw_frame_expr = IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false)
-
-      IR::Function.new(
-        name: "#{runtime.fetch(:wait_take_result_linkage_name)}_fn",
-        linkage_name: runtime.fetch(:wait_take_result_linkage_name),
-        params: [IR::Param.new(name: "frame", linkage_name: "frame", type: runtime.fetch(:void_ptr), pointer: false)],
-        return_type: runtime.fetch(:wait_result_type),
-        body: [
-          IR::IfStmt.new(
-            condition: IR::Binary.new(
-              operator: "==",
-              left: raw_frame_expr,
-              right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
-              type: @ctx.types.fetch("bool"),
-            ),
-            then_body: [IR::ReturnStmt.new(value: event_failure_literal(runtime.fetch(:wait_result_type)))],
-            else_body: nil,
+        ]
+
+        body = [
+          IR::LocalDecl.new(name: "__mt_snapshots", linkage_name: "__mt_snapshots", type: runtime.fetch(:snapshots_type), value: IR::ZeroInit.new(type: runtime.fetch(:snapshots_type))),
+          IR::LocalDecl.new(name: "__mt_snapshot_count", linkage_name: "__mt_snapshot_count", type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
+          IR::ForStmt.new(
+            init: IR::LocalDecl.new(name: "__mt_slot_index", linkage_name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
+            condition: IR::Binary.new(operator: "<", left: slot_index_expr, right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")), type: @ctx.types.fetch("bool")),
+            post: IR::Assignment.new(target: slot_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+            body: collect_body,
           ),
-          IR::LocalDecl.new(
-            name: "__mt_wait_frame",
-            linkage_name: "__mt_wait_frame",
-            type: runtime.fetch(:wait_frame_pointer_type),
-            value: IR::Cast.new(target_type: runtime.fetch(:wait_frame_pointer_type), expression: IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false), type: runtime.fetch(:wait_frame_pointer_type)),
+          IR::ForStmt.new(
+            init: IR::LocalDecl.new(name: "__mt_dispatch_index", linkage_name: "__mt_dispatch_index", type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
+            condition: IR::Binary.new(operator: "<", left: dispatch_index_expr, right: snapshot_count_expr, type: @ctx.types.fetch("bool")),
+            post: IR::Assignment.new(target: dispatch_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+            body: dispatch_body,
           ),
-          IR::ReturnStmt.new(value: wait_frame_field_expression(frame_expr, "result", runtime.fetch(:wait_result_type))),
-        ],
-        entry_point: false,
-      )
-    end
+          IR::ReturnStmt.new(value: nil),
+        ]
+
+        params = [IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)]
+        params << IR::Param.new(name: "payload", linkage_name: "payload", type: runtime.fetch(:event_type).payload_type, pointer: false) if runtime.fetch(:event_type).payload_type
+
+        IR::Function.new(
+          name: "#{runtime.fetch(:emit_linkage_name)}_fn",
+          linkage_name: runtime.fetch(:emit_linkage_name),
+          params:,
+          return_type: @ctx.types.fetch("void"),
+          body:,
+          entry_point: false,
+        )
+      end
+
+      def build_event_wait_ready_function(runtime)
+        frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
+        raw_frame_expr = IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false)
 
-    def build_event_wait_function(runtime)
-      event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
-      frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
-      raw_frame_expr = IR::Cast.new(target_type: runtime.fetch(:void_ptr), expression: frame_expr, type: runtime.fetch(:void_ptr))
-      slot_index_expr = IR::Name.new(name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      generation_expr = IR::Name.new(name: "__mt_generation", type: @ctx.types.fetch("ptr_uint"), pointer: false)
-      slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
-
-      body = [
-        IR::ForStmt.new(
-          init: IR::LocalDecl.new(name: "__mt_slot_index", linkage_name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
-          condition: IR::Binary.new(operator: "<", left: slot_index_expr, right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")), type: @ctx.types.fetch("bool")),
-          post: IR::Assignment.new(target: slot_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+        IR::Function.new(
+          name: "#{runtime.fetch(:wait_ready_linkage_name)}_fn",
+          linkage_name: runtime.fetch(:wait_ready_linkage_name),
+          params: [IR::Param.new(name: "frame", linkage_name: "frame", type: runtime.fetch(:void_ptr), pointer: false)],
+          return_type: @ctx.types.fetch("bool"),
           body: [
-            IR::LocalDecl.new(name: "__mt_slot", linkage_name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), value: event_slot_pointer_expression(event_expr, slot_index_expr, runtime)),
-            active_event_slot_continue_guard(slot_pointer_expr),
-            IR::LocalDecl.new(
-              name: "__mt_generation",
-              linkage_name: "__mt_generation",
-              type: @ctx.types.fetch("ptr_uint"),
-              value: event_next_generation_expression(slot_pointer_expr),
+            IR::IfStmt.new(
+              condition: IR::Binary.new(
+                operator: "==",
+                left: raw_frame_expr,
+                right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+                type: @ctx.types.fetch("bool"),
+              ),
+              then_body: [IR::ReturnStmt.new(value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")))],
+              else_body: nil,
             ),
             IR::LocalDecl.new(
               name: "__mt_wait_frame",
@@ -800,253 +634,421 @@ module MilkTea
               type: runtime.fetch(:wait_frame_pointer_type),
               value: IR::Cast.new(
                 target_type: runtime.fetch(:wait_frame_pointer_type),
-                expression: IR::Call.new(callee: "mt_async_alloc", arguments: [IR::SizeofExpr.new(target_type: runtime.fetch(:wait_frame_type), type: @ctx.types.fetch("ptr_uint"))], type: runtime.fetch(:void_ptr)),
+                expression: IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false),
                 type: runtime.fetch(:wait_frame_pointer_type),
               ),
             ),
-            IR::Assignment.new(
-              target: IR::Unary.new(operator: "*", operand: frame_expr, type: runtime.fetch(:wait_frame_type)),
-              operator: "=",
-              value: IR::ZeroInit.new(type: runtime.fetch(:wait_frame_type)),
+            IR::ReturnStmt.new(value: wait_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool"))),
+          ],
+          entry_point: false,
+        )
+      end
+
+      def build_event_wait_set_waiter_function(runtime)
+        frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
+        raw_frame_expr = IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false)
+        waiter_frame_expr = IR::Name.new(name: "waiter_frame", type: runtime.fetch(:void_ptr), pointer: false)
+        waiter_expr = IR::Name.new(name: "waiter", type: runtime.fetch(:wake_type), pointer: false)
+
+        IR::Function.new(
+          name: "#{runtime.fetch(:wait_set_waiter_linkage_name)}_fn",
+          linkage_name: runtime.fetch(:wait_set_waiter_linkage_name),
+          params: [
+            IR::Param.new(name: "frame", linkage_name: "frame", type: runtime.fetch(:void_ptr), pointer: false),
+            IR::Param.new(name: "waiter_frame", linkage_name: "waiter_frame", type: runtime.fetch(:void_ptr), pointer: false),
+            IR::Param.new(name: "waiter", linkage_name: "waiter", type: runtime.fetch(:wake_type), pointer: false),
+          ],
+          return_type: @ctx.types.fetch("void"),
+          body: [
+            IR::IfStmt.new(
+              condition: IR::Binary.new(
+                operator: "==",
+                left: raw_frame_expr,
+                right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+                type: @ctx.types.fetch("bool"),
+              ),
+              then_body: [
+                IR::ExpressionStmt.new(expression: IR::Call.new(callee: waiter_expr, arguments: [waiter_frame_expr], type: @ctx.types.fetch("void"))),
+                IR::ReturnStmt.new(value: nil),
+              ],
+              else_body: nil,
             ),
-            IR::Assignment.new(target: wait_frame_field_expression(frame_expr, "event", runtime.fetch(:void_ptr)), operator: "=", value: IR::Cast.new(target_type: runtime.fetch(:void_ptr), expression: event_expr, type: runtime.fetch(:void_ptr))),
-            *event_slot_activate_statements(
-              slot_pointer_expr,
-              runtime,
-              generation_expr: generation_expr,
-              once: true,
-              wait_frame_expr: raw_frame_expr,
+            IR::LocalDecl.new(
+              name: "__mt_wait_frame",
+              linkage_name: "__mt_wait_frame",
+              type: runtime.fetch(:wait_frame_pointer_type),
+              value: IR::Cast.new(target_type: runtime.fetch(:wait_frame_pointer_type), expression: IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false), type: runtime.fetch(:wait_frame_pointer_type)),
             ),
-            IR::Assignment.new(target: wait_frame_field_expression(frame_expr, "subscription", @ctx.types.fetch("Subscription")), operator: "=", value: event_subscription_literal(slot_index_expr, generation_expr)),
-            IR::ReturnStmt.new(value: event_task_literal(runtime, frame_expr)),
+            IR::IfStmt.new(
+              condition: wait_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")),
+              then_body: [
+                IR::ExpressionStmt.new(expression: IR::Call.new(callee: waiter_expr, arguments: [waiter_frame_expr], type: @ctx.types.fetch("void"))),
+                IR::ReturnStmt.new(value: nil),
+              ],
+              else_body: nil,
+            ),
+            IR::Assignment.new(target: wait_frame_field_expression(frame_expr, "waiter_frame", runtime.fetch(:void_ptr)), operator: "=", value: waiter_frame_expr),
+            IR::Assignment.new(target: wait_frame_field_expression(frame_expr, "waiter", runtime.fetch(:wake_type)), operator: "=", value: waiter_expr),
+            IR::ReturnStmt.new(value: nil),
           ],
-        ),
-        IR::ReturnStmt.new(value: event_immediate_failure_task_literal(runtime)),
-      ]
-
-      IR::Function.new(
-        name: "#{runtime.fetch(:wait_linkage_name)}_fn",
-        linkage_name: runtime.fetch(:wait_linkage_name),
-        params: [IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)],
-        return_type: runtime.fetch(:task_type),
-        body:,
-        entry_point: false,
-      )
-    end
+          entry_point: false,
+        )
+      end
 
-    def event_slot_pointer_expression(event_expr, slot_index_expr, runtime)
-      IR::AddressOf.new(
-        expression: IR::Index.new(
-          receiver: IR::Member.new(receiver: event_expr, member: "slots", type: runtime.fetch(:slots_type)),
-          index: slot_index_expr,
-          type: runtime.fetch(:slot_type),
-        ),
-        type: runtime.fetch(:slot_pointer_type),
-      )
-    end
+      def build_event_wait_release_function(runtime)
+        frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
+        raw_frame_expr = IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false)
 
-    def event_slot_local_decl(event_expr, slot_index_expr, runtime, local_name: "__mt_slot")
-      IR::LocalDecl.new(
-        name: local_name,
-        linkage_name: local_name,
-        type: runtime.fetch(:slot_pointer_type),
-        value: event_slot_pointer_expression(event_expr, slot_index_expr, runtime),
-      )
-    end
+        IR::Function.new(
+          name: "#{runtime.fetch(:wait_release_linkage_name)}_fn",
+          linkage_name: runtime.fetch(:wait_release_linkage_name),
+          params: [IR::Param.new(name: "frame", linkage_name: "frame", type: runtime.fetch(:void_ptr), pointer: false)],
+          return_type: @ctx.types.fetch("void"),
+          body: [
+            IR::IfStmt.new(
+              condition: IR::Binary.new(
+                operator: "==",
+                left: raw_frame_expr,
+                right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+                type: @ctx.types.fetch("bool"),
+              ),
+              then_body: [IR::ReturnStmt.new(value: nil)],
+              else_body: nil,
+            ),
+            IR::LocalDecl.new(
+              name: "__mt_wait_frame",
+              linkage_name: "__mt_wait_frame",
+              type: runtime.fetch(:wait_frame_pointer_type),
+              value: IR::Cast.new(target_type: runtime.fetch(:wait_frame_pointer_type), expression: raw_frame_expr, type: runtime.fetch(:wait_frame_pointer_type)),
+            ),
+            IR::IfStmt.new(
+              condition: IR::Unary.new(operator: "not", operand: wait_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")), type: @ctx.types.fetch("bool")),
+              then_body: [
+                IR::ExpressionStmt.new(
+                  expression: event_unsubscribe_call(
+                    runtime,
+                    IR::Cast.new(target_type: runtime.fetch(:event_pointer_type), expression: wait_frame_field_expression(frame_expr, "event", runtime.fetch(:void_ptr)), type: runtime.fetch(:event_pointer_type)),
+                    wait_frame_field_expression(frame_expr, "subscription", @ctx.types.fetch("Subscription")),
+                  ),
+                ),
+              ],
+              else_body: nil,
+            ),
+            IR::ExpressionStmt.new(expression: IR::Call.new(callee: "mt_async_free", arguments: [raw_frame_expr], type: @ctx.types.fetch("void"))),
+            IR::ReturnStmt.new(value: nil),
+          ],
+          entry_point: false,
+        )
+      end
 
-    def event_slot_active_expression(slot_pointer_expr)
-      event_slot_field_expression(slot_pointer_expr, "active", @ctx.types.fetch("bool"))
-    end
+      def build_event_wait_take_result_function(runtime)
+        frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
+        raw_frame_expr = IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false)
 
-    def event_slot_wait_frame_expression(slot_pointer_expr, runtime)
-      event_slot_field_expression(slot_pointer_expr, "wait_frame", runtime.fetch(:void_ptr))
-    end
+        IR::Function.new(
+          name: "#{runtime.fetch(:wait_take_result_linkage_name)}_fn",
+          linkage_name: runtime.fetch(:wait_take_result_linkage_name),
+          params: [IR::Param.new(name: "frame", linkage_name: "frame", type: runtime.fetch(:void_ptr), pointer: false)],
+          return_type: runtime.fetch(:wait_result_type),
+          body: [
+            IR::IfStmt.new(
+              condition: IR::Binary.new(
+                operator: "==",
+                left: raw_frame_expr,
+                right: IR::NullLiteral.new(type: runtime.fetch(:void_ptr)),
+                type: @ctx.types.fetch("bool"),
+              ),
+              then_body: [IR::ReturnStmt.new(value: event_failure_literal(runtime.fetch(:wait_result_type)))],
+              else_body: nil,
+            ),
+            IR::LocalDecl.new(
+              name: "__mt_wait_frame",
+              linkage_name: "__mt_wait_frame",
+              type: runtime.fetch(:wait_frame_pointer_type),
+              value: IR::Cast.new(target_type: runtime.fetch(:wait_frame_pointer_type), expression: IR::Name.new(name: "frame", type: runtime.fetch(:void_ptr), pointer: false), type: runtime.fetch(:wait_frame_pointer_type)),
+            ),
+            IR::ReturnStmt.new(value: wait_frame_field_expression(frame_expr, "result", runtime.fetch(:wait_result_type))),
+          ],
+          entry_point: false,
+        )
+      end
 
-    def active_event_slot_continue_guard(slot_pointer_expr)
-      IR::IfStmt.new(
-        condition: event_slot_active_expression(slot_pointer_expr),
-        then_body: [IR::ContinueStmt.new],
-        else_body: nil,
-      )
-    end
+      def build_event_wait_function(runtime)
+        event_expr = IR::Name.new(name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)
+        frame_expr = IR::Name.new(name: "__mt_wait_frame", type: runtime.fetch(:wait_frame_pointer_type), pointer: false)
+        raw_frame_expr = IR::Cast.new(target_type: runtime.fetch(:void_ptr), expression: frame_expr, type: runtime.fetch(:void_ptr))
+        slot_index_expr = IR::Name.new(name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        generation_expr = IR::Name.new(name: "__mt_generation", type: @ctx.types.fetch("ptr_uint"), pointer: false)
+        slot_pointer_expr = IR::Name.new(name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), pointer: false)
+
+        body = [
+          IR::ForStmt.new(
+            init: IR::LocalDecl.new(name: "__mt_slot_index", linkage_name: "__mt_slot_index", type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
+            condition: IR::Binary.new(operator: "<", left: slot_index_expr, right: IR::IntegerLiteral.new(value: runtime.fetch(:event_type).capacity, type: @ctx.types.fetch("ptr_uint")), type: @ctx.types.fetch("bool")),
+            post: IR::Assignment.new(target: slot_index_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+            body: [
+              IR::LocalDecl.new(name: "__mt_slot", linkage_name: "__mt_slot", type: runtime.fetch(:slot_pointer_type), value: event_slot_pointer_expression(event_expr, slot_index_expr, runtime)),
+              active_event_slot_continue_guard(slot_pointer_expr),
+              IR::LocalDecl.new(
+                name: "__mt_generation",
+                linkage_name: "__mt_generation",
+                type: @ctx.types.fetch("ptr_uint"),
+                value: event_next_generation_expression(slot_pointer_expr),
+              ),
+              IR::LocalDecl.new(
+                name: "__mt_wait_frame",
+                linkage_name: "__mt_wait_frame",
+                type: runtime.fetch(:wait_frame_pointer_type),
+                value: IR::Cast.new(
+                  target_type: runtime.fetch(:wait_frame_pointer_type),
+                  expression: IR::Call.new(callee: "mt_async_alloc", arguments: [IR::SizeofExpr.new(target_type: runtime.fetch(:wait_frame_type), type: @ctx.types.fetch("ptr_uint"))], type: runtime.fetch(:void_ptr)),
+                  type: runtime.fetch(:wait_frame_pointer_type),
+                ),
+              ),
+              IR::Assignment.new(
+                target: IR::Unary.new(operator: "*", operand: frame_expr, type: runtime.fetch(:wait_frame_type)),
+                operator: "=",
+                value: IR::ZeroInit.new(type: runtime.fetch(:wait_frame_type)),
+              ),
+              IR::Assignment.new(target: wait_frame_field_expression(frame_expr, "event", runtime.fetch(:void_ptr)), operator: "=", value: IR::Cast.new(target_type: runtime.fetch(:void_ptr), expression: event_expr, type: runtime.fetch(:void_ptr))),
+              *event_slot_activate_statements(
+                slot_pointer_expr,
+                runtime,
+                generation_expr: generation_expr,
+                once: true,
+                wait_frame_expr: raw_frame_expr,
+              ),
+              IR::Assignment.new(target: wait_frame_field_expression(frame_expr, "subscription", @ctx.types.fetch("Subscription")), operator: "=", value: event_subscription_literal(slot_index_expr, generation_expr)),
+              IR::ReturnStmt.new(value: event_task_literal(runtime, frame_expr)),
+            ],
+          ),
+          IR::ReturnStmt.new(value: event_immediate_failure_task_literal(runtime)),
+        ]
+
+        IR::Function.new(
+          name: "#{runtime.fetch(:wait_linkage_name)}_fn",
+          linkage_name: runtime.fetch(:wait_linkage_name),
+          params: [IR::Param.new(name: "event", linkage_name: "event", type: runtime.fetch(:event_pointer_type), pointer: false)],
+          return_type: runtime.fetch(:task_type),
+          body:,
+          entry_point: false,
+        )
+      end
 
-    def inactive_event_slot_continue_guard(slot_pointer_expr)
-      IR::IfStmt.new(
-        condition: IR::Unary.new(operator: "not", operand: event_slot_active_expression(slot_pointer_expr), type: @ctx.types.fetch("bool")),
-        then_body: [IR::ContinueStmt.new],
-        else_body: nil,
-      )
-    end
+      def event_slot_pointer_expression(event_expr, slot_index_expr, runtime)
+        IR::AddressOf.new(
+          expression: IR::Index.new(
+            receiver: IR::Member.new(receiver: event_expr, member: "slots", type: runtime.fetch(:slots_type)),
+            index: slot_index_expr,
+            type: runtime.fetch(:slot_type),
+          ),
+          type: runtime.fetch(:slot_pointer_type),
+        )
+      end
 
-    def event_next_generation_expression(slot_pointer_expr)
-      IR::Binary.new(
-        operator: "+",
-        left: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint")),
-        right: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint")),
-        type: @ctx.types.fetch("ptr_uint"),
-      )
-    end
+      def event_slot_local_decl(event_expr, slot_index_expr, runtime, local_name: "__mt_slot")
+        IR::LocalDecl.new(
+          name: local_name,
+          linkage_name: local_name,
+          type: runtime.fetch(:slot_pointer_type),
+          value: event_slot_pointer_expression(event_expr, slot_index_expr, runtime),
+        )
+      end
 
-    def event_slot_activate_statements(slot_pointer_expr, runtime, generation_expr:, once:, wait_frame_expr:, listener_expr: nil)
-      statements = [
-        IR::Assignment.new(target: event_slot_active_expression(slot_pointer_expr), operator: "=", value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool"))),
-        IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "once", @ctx.types.fetch("bool")), operator: "=", value: IR::BooleanLiteral.new(value: once, type: @ctx.types.fetch("bool"))),
-        IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint")), operator: "=", value: generation_expr),
-        IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "state", runtime.fetch(:void_ptr)), operator: "=", value: IR::NullLiteral.new(type: runtime.fetch(:void_ptr))),
-      ]
-      statements << IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "listener", runtime.fetch(:listener_type)), operator: "=", value: listener_expr) if listener_expr
-      statements << IR::Assignment.new(target: event_slot_wait_frame_expression(slot_pointer_expr, runtime), operator: "=", value: wait_frame_expr)
-      statements
-    end
+      def event_slot_active_expression(slot_pointer_expr)
+        event_slot_field_expression(slot_pointer_expr, "active", @ctx.types.fetch("bool"))
+      end
 
-    def event_slot_activate_stateful_statements(slot_pointer_expr, runtime, generation_expr:, once:, state_expr:, wait_frame_expr:, listener_expr: nil)
-      statements = [
-        IR::Assignment.new(target: event_slot_active_expression(slot_pointer_expr), operator: "=", value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool"))),
-        IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "once", @ctx.types.fetch("bool")), operator: "=", value: IR::BooleanLiteral.new(value: once, type: @ctx.types.fetch("bool"))),
-        IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint")), operator: "=", value: generation_expr),
-        IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "state", runtime.fetch(:void_ptr)), operator: "=", value: state_expr),
-      ]
-      statements << IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "listener", runtime.fetch(:listener_type)), operator: "=", value: listener_expr) if listener_expr
-      statements << IR::Assignment.new(target: event_slot_wait_frame_expression(slot_pointer_expr, runtime), operator: "=", value: wait_frame_expr)
-      statements
-    end
+      def event_slot_wait_frame_expression(slot_pointer_expr, runtime)
+        event_slot_field_expression(slot_pointer_expr, "wait_frame", runtime.fetch(:void_ptr))
+      end
 
-    def event_slot_clear_statements(slot_pointer_expr, runtime)
-      [
-        IR::Assignment.new(target: event_slot_active_expression(slot_pointer_expr), operator: "=", value: IR::BooleanLiteral.new(value: false, type: @ctx.types.fetch("bool"))),
-        IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "once", @ctx.types.fetch("bool")), operator: "=", value: IR::BooleanLiteral.new(value: false, type: @ctx.types.fetch("bool"))),
-        IR::Assignment.new(target: event_slot_wait_frame_expression(slot_pointer_expr, runtime), operator: "=", value: IR::NullLiteral.new(type: runtime.fetch(:void_ptr))),
-      ]
-    end
+      def active_event_slot_continue_guard(slot_pointer_expr)
+        IR::IfStmt.new(
+          condition: event_slot_active_expression(slot_pointer_expr),
+          then_body: [IR::ContinueStmt.new],
+          else_body: nil,
+        )
+      end
 
-    def event_slot_field_expression(slot_pointer_expr, field_name, field_type)
-      IR::Member.new(receiver: slot_pointer_expr, member: field_name, type: field_type)
-    end
+      def inactive_event_slot_continue_guard(slot_pointer_expr)
+        IR::IfStmt.new(
+          condition: IR::Unary.new(operator: "not", operand: event_slot_active_expression(slot_pointer_expr), type: @ctx.types.fetch("bool")),
+          then_body: [IR::ContinueStmt.new],
+          else_body: nil,
+        )
+      end
 
-    def snapshot_field_expression(snapshots_expr, index_expr, runtime, field_name, field_type)
-      IR::Member.new(
-        receiver: IR::Index.new(receiver: snapshots_expr, index: index_expr, type: runtime.fetch(:snapshot_type)),
-        member: field_name,
-        type: field_type,
-      )
-    end
+      def event_next_generation_expression(slot_pointer_expr)
+        IR::Binary.new(
+          operator: "+",
+          left: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint")),
+          right: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint")),
+          type: @ctx.types.fetch("ptr_uint"),
+        )
+      end
 
-    def subscription_field_expression(subscription_expr, field_name, field_type)
-      IR::Member.new(receiver: subscription_expr, member: field_name, type: field_type)
-    end
+      def event_slot_activate_statements(slot_pointer_expr, runtime, generation_expr:, once:, wait_frame_expr:, listener_expr: nil)
+        statements = [
+          IR::Assignment.new(target: event_slot_active_expression(slot_pointer_expr), operator: "=", value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool"))),
+          IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "once", @ctx.types.fetch("bool")), operator: "=", value: IR::BooleanLiteral.new(value: once, type: @ctx.types.fetch("bool"))),
+          IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint")), operator: "=", value: generation_expr),
+          IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "state", runtime.fetch(:void_ptr)), operator: "=", value: IR::NullLiteral.new(type: runtime.fetch(:void_ptr))),
+        ]
+        statements << IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "listener", runtime.fetch(:listener_type)), operator: "=", value: listener_expr) if listener_expr
+        statements << IR::Assignment.new(target: event_slot_wait_frame_expression(slot_pointer_expr, runtime), operator: "=", value: wait_frame_expr)
+        statements
+      end
 
-    def wait_frame_field_expression(frame_expr, field_name, field_type)
-      IR::Member.new(receiver: frame_expr, member: field_name, type: field_type)
-    end
+      def event_slot_activate_stateful_statements(slot_pointer_expr, runtime, generation_expr:, once:, state_expr:, wait_frame_expr:, listener_expr: nil)
+        statements = [
+          IR::Assignment.new(target: event_slot_active_expression(slot_pointer_expr), operator: "=", value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool"))),
+          IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "once", @ctx.types.fetch("bool")), operator: "=", value: IR::BooleanLiteral.new(value: once, type: @ctx.types.fetch("bool"))),
+          IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "generation", @ctx.types.fetch("ptr_uint")), operator: "=", value: generation_expr),
+          IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "state", runtime.fetch(:void_ptr)), operator: "=", value: state_expr),
+        ]
+        statements << IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "listener", runtime.fetch(:listener_type)), operator: "=", value: listener_expr) if listener_expr
+        statements << IR::Assignment.new(target: event_slot_wait_frame_expression(slot_pointer_expr, runtime), operator: "=", value: wait_frame_expr)
+        statements
+      end
 
-    def event_subscription_literal(slot_expr, generation_expr)
-      IR::AggregateLiteral.new(
-        type: @ctx.types.fetch("Subscription"),
-        fields: [
-          IR::AggregateField.new(name: "slot", value: slot_expr),
-          IR::AggregateField.new(name: "generation", value: generation_expr),
-        ],
-      )
-    end
+      def event_slot_clear_statements(slot_pointer_expr, runtime)
+        [
+          IR::Assignment.new(target: event_slot_active_expression(slot_pointer_expr), operator: "=", value: IR::BooleanLiteral.new(value: false, type: @ctx.types.fetch("bool"))),
+          IR::Assignment.new(target: event_slot_field_expression(slot_pointer_expr, "once", @ctx.types.fetch("bool")), operator: "=", value: IR::BooleanLiteral.new(value: false, type: @ctx.types.fetch("bool"))),
+          IR::Assignment.new(target: event_slot_wait_frame_expression(slot_pointer_expr, runtime), operator: "=", value: IR::NullLiteral.new(type: runtime.fetch(:void_ptr))),
+        ]
+      end
 
-    def event_subscription_success_literal(result_type, slot_expr, generation_expr)
-      IR::VariantLiteral.new(
-        type: result_type,
-        arm_name: "success",
-        fields: [IR::AggregateField.new(name: "value", value: event_subscription_literal(slot_expr, generation_expr))],
-      )
-    end
+      def event_slot_field_expression(slot_pointer_expr, field_name, field_type)
+        IR::Member.new(receiver: slot_pointer_expr, member: field_name, type: field_type)
+      end
 
-    def event_wait_success_literal(result_type, payload_expr)
-      IR::VariantLiteral.new(
-        type: result_type,
-        arm_name: "success",
-        fields: [IR::AggregateField.new(name: "value", value: payload_expr || void_value_expression)],
-      )
-    end
+      def snapshot_field_expression(snapshots_expr, index_expr, runtime, field_name, field_type)
+        IR::Member.new(
+          receiver: IR::Index.new(receiver: snapshots_expr, index: index_expr, type: runtime.fetch(:snapshot_type)),
+          member: field_name,
+          type: field_type,
+        )
+      end
 
-    def event_failure_literal(result_type)
-      IR::VariantLiteral.new(
-        type: result_type,
-        arm_name: "failure",
-        fields: [
-          IR::AggregateField.new(
-            name: "error",
-            value: IR::Name.new(name: enum_member_c_name(@ctx.types.fetch("EventError"), "full"), type: @ctx.types.fetch("EventError"), pointer: false),
-          ),
-        ],
-      )
-    end
+      def subscription_field_expression(subscription_expr, field_name, field_type)
+        IR::Member.new(receiver: subscription_expr, member: field_name, type: field_type)
+      end
 
-    def void_value_expression
-      IR::Cast.new(
-        target_type: @ctx.types.fetch("void"),
-        expression: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("int")),
-        type: @ctx.types.fetch("void"),
-      )
-    end
+      def wait_frame_field_expression(frame_expr, field_name, field_type)
+        IR::Member.new(receiver: frame_expr, member: field_name, type: field_type)
+      end
 
-    def event_unsubscribe_call(runtime, event_expr, subscription_expr)
-      IR::Call.new(
-        callee: runtime.fetch(:unsubscribe_linkage_name),
-        arguments: [event_expr, subscription_expr],
-        type: @ctx.types.fetch("void"),
-      )
-    end
+      def event_subscription_literal(slot_expr, generation_expr)
+        IR::AggregateLiteral.new(
+          type: @ctx.types.fetch("Subscription"),
+          fields: [
+            IR::AggregateField.new(name: "slot", value: slot_expr),
+            IR::AggregateField.new(name: "generation", value: generation_expr),
+          ],
+        )
+      end
 
-    def event_listener_call_expression(runtime, snapshots_expr, dispatch_index_expr, payload_expr)
-      listener_type = runtime.fetch(:listener_type)
-      listener_expr = IR::Cast.new(
-        target_type: listener_type,
-        expression: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "listener", runtime.fetch(:void_ptr)),
-        type: listener_type,
-      )
-      arguments = []
-      arguments << payload_expr if runtime.fetch(:event_type).payload_type
-      IR::Call.new(
-        callee: listener_expr,
-        arguments:,
-        type: @ctx.types.fetch("void"),
-      )
-    end
+      def event_subscription_success_literal(result_type, slot_expr, generation_expr)
+        IR::VariantLiteral.new(
+          type: result_type,
+          arm_name: "success",
+          fields: [IR::AggregateField.new(name: "value", value: event_subscription_literal(slot_expr, generation_expr))],
+        )
+      end
 
-    def event_stateful_listener_call_expression(runtime, snapshots_expr, dispatch_index_expr, payload_expr)
-      listener_type = runtime.fetch(:stateful_listener_type)
-      listener_expr = IR::Cast.new(
-        target_type: listener_type,
-        expression: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "listener", runtime.fetch(:void_ptr)),
-        type: listener_type,
-      )
-      state_expr = snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "state", runtime.fetch(:void_ptr))
-      arguments = [state_expr]
-      arguments << payload_expr if runtime.fetch(:event_type).payload_type
-      IR::Call.new(
-        callee: listener_expr,
-        arguments:,
-        type: @ctx.types.fetch("void"),
-      )
-    end
+      def event_wait_success_literal(result_type, payload_expr)
+        IR::VariantLiteral.new(
+          type: result_type,
+          arm_name: "success",
+          fields: [IR::AggregateField.new(name: "value", value: payload_expr || void_value_expression)],
+        )
+      end
 
-    def event_task_literal(runtime, frame_expr)
-      raw_frame_expr = IR::Cast.new(target_type: runtime.fetch(:void_ptr), expression: frame_expr, type: runtime.fetch(:void_ptr))
-      event_task_literal_from_raw_frame(runtime, raw_frame_expr)
-    end
+      def event_failure_literal(result_type)
+        IR::VariantLiteral.new(
+          type: result_type,
+          arm_name: "failure",
+          fields: [
+            IR::AggregateField.new(
+              name: "error",
+              value: IR::Name.new(name: enum_member_c_name(@ctx.types.fetch("EventError"), "full"), type: @ctx.types.fetch("EventError"), pointer: false),
+            ),
+          ],
+        )
+      end
 
-    def event_immediate_failure_task_literal(runtime)
-      event_task_literal_from_raw_frame(runtime, IR::NullLiteral.new(type: runtime.fetch(:void_ptr)))
-    end
+      def void_value_expression
+        IR::Cast.new(
+          target_type: @ctx.types.fetch("void"),
+          expression: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("int")),
+          type: @ctx.types.fetch("void"),
+        )
+      end
+
+      def event_unsubscribe_call(runtime, event_expr, subscription_expr)
+        IR::Call.new(
+          callee: runtime.fetch(:unsubscribe_linkage_name),
+          arguments: [event_expr, subscription_expr],
+          type: @ctx.types.fetch("void"),
+        )
+      end
+
+      def event_listener_call_expression(runtime, snapshots_expr, dispatch_index_expr, payload_expr)
+        listener_type = runtime.fetch(:listener_type)
+        listener_expr = IR::Cast.new(
+          target_type: listener_type,
+          expression: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "listener", runtime.fetch(:void_ptr)),
+          type: listener_type,
+        )
+        arguments = []
+        arguments << payload_expr if runtime.fetch(:event_type).payload_type
+        IR::Call.new(
+          callee: listener_expr,
+          arguments:,
+          type: @ctx.types.fetch("void"),
+        )
+      end
 
-    def event_task_literal_from_raw_frame(runtime, raw_frame_expr)
-      IR::AggregateLiteral.new(
-        type: runtime.fetch(:task_type),
-        fields: [
-          IR::AggregateField.new(name: "frame", value: raw_frame_expr),
-          IR::AggregateField.new(name: "ready", value: IR::Name.new(name: runtime.fetch(:wait_ready_linkage_name), type: runtime.fetch(:task_type).field("ready"), pointer: false)),
-          IR::AggregateField.new(name: "set_waiter", value: IR::Name.new(name: runtime.fetch(:wait_set_waiter_linkage_name), type: runtime.fetch(:task_type).field("set_waiter"), pointer: false)),
-          IR::AggregateField.new(name: "release", value: IR::Name.new(name: runtime.fetch(:wait_release_linkage_name), type: runtime.fetch(:task_type).field("release"), pointer: false)),
-          IR::AggregateField.new(name: "take_result", value: IR::Name.new(name: runtime.fetch(:wait_take_result_linkage_name), type: runtime.fetch(:task_type).field("take_result"), pointer: false)),
-        ],
-      )
+      def event_stateful_listener_call_expression(runtime, snapshots_expr, dispatch_index_expr, payload_expr)
+        listener_type = runtime.fetch(:stateful_listener_type)
+        listener_expr = IR::Cast.new(
+          target_type: listener_type,
+          expression: snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "listener", runtime.fetch(:void_ptr)),
+          type: listener_type,
+        )
+        state_expr = snapshot_field_expression(snapshots_expr, dispatch_index_expr, runtime, "state", runtime.fetch(:void_ptr))
+        arguments = [state_expr]
+        arguments << payload_expr if runtime.fetch(:event_type).payload_type
+        IR::Call.new(
+          callee: listener_expr,
+          arguments:,
+          type: @ctx.types.fetch("void"),
+        )
+      end
+
+      def event_task_literal(runtime, frame_expr)
+        raw_frame_expr = IR::Cast.new(target_type: runtime.fetch(:void_ptr), expression: frame_expr, type: runtime.fetch(:void_ptr))
+        event_task_literal_from_raw_frame(runtime, raw_frame_expr)
+      end
+
+      def event_immediate_failure_task_literal(runtime)
+        event_task_literal_from_raw_frame(runtime, IR::NullLiteral.new(type: runtime.fetch(:void_ptr)))
+      end
+
+      def event_task_literal_from_raw_frame(runtime, raw_frame_expr)
+        IR::AggregateLiteral.new(
+          type: runtime.fetch(:task_type),
+          fields: [
+            IR::AggregateField.new(name: "frame", value: raw_frame_expr),
+            IR::AggregateField.new(name: "ready", value: IR::Name.new(name: runtime.fetch(:wait_ready_linkage_name), type: runtime.fetch(:task_type).field("ready"), pointer: false)),
+            IR::AggregateField.new(name: "set_waiter", value: IR::Name.new(name: runtime.fetch(:wait_set_waiter_linkage_name), type: runtime.fetch(:task_type).field("set_waiter"), pointer: false)),
+            IR::AggregateField.new(name: "release", value: IR::Name.new(name: runtime.fetch(:wait_release_linkage_name), type: runtime.fetch(:task_type).field("release"), pointer: false)),
+            IR::AggregateField.new(name: "take_result", value: IR::Name.new(name: runtime.fetch(:wait_take_result_linkage_name), type: runtime.fetch(:task_type).field("take_result"), pointer: false)),
+          ],
+        )
+      end
     end
   end
 end