A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
refactor(gateway): separate thread payload masking, drop tests
Hampus45e43a050623
diff --git a/fluxer_gateway/src/guild/guild_data.erl b/fluxer_gateway/src/guild/guild_data.erlindex c4c31ac98..4f35fc915 100644--- a/fluxer_gateway/src/guild/guild_data.erl+++ b/fluxer_gateway/src/guild/guild_data.erl@@ -25,9 +25,9 @@]).-define(CONNECT_SNAPSHOT_HEAVY_SESSION_KEYS, [active_guilds, user_roles, viewable_channels]).--export_type([guild_state/0, guild_reply/1, user_id/0]).+-export_type([guild_state/0]).--spec get_guild_data(map(), guild_state()) -> guild_reply(map()).+-spec get_guild_data(map(), guild_state()) -> {reply, map(), guild_state()}.get_guild_data(#{user_id := UserId}, State) ->Data = guild_data_index:ensure_data_map(State),case UserId of@@ -38,7 +38,7 @@ get_guild_data(#{user_id := UserId}, State) ->get_guild_data_for_user(UserId, Data, State)end.--spec get_auth_context(map(), guild_state()) -> guild_reply(map()).+-spec get_auth_context(map(), guild_state()) -> {reply, map(), guild_state()}.get_auth_context(#{user_id := UserId, channel_id := ChannelId}, State) ->Data = guild_data_index:ensure_data_map(State),case UserId of@@ -97,7 +97,7 @@ find_thread_parent_channel(ChannelId, Index, Data) when is_integer(ChannelId) ->find_thread_parent_channel(_ChannelId, _Index, _Data) ->null.--spec get_first_viewable_text_channel(guild_state()) -> guild_reply(map()).+-spec get_first_viewable_text_channel(guild_state()) -> {reply, map(), guild_state()}.get_first_viewable_text_channel(State) ->get_everyone_viewable_text_channel(State).@@ -109,11 +109,11 @@ get_everyone_viewable_text_channel(State) ->),{reply, #{channel_id => EveryoneChannelId}, State}.--spec get_guild_state(user_id(), guild_state()) -> map().+-spec get_guild_state(integer(), guild_state()) -> map().get_guild_state(UserId, State) ->get_guild_state(UserId, State, #{}).--spec get_guild_state(user_id(), guild_state(), map()) -> map().+-spec get_guild_state(integer(), guild_state(), map()) -> map().get_guild_state(UserId, State, Opts) ->GuildState = base_guild_state(UserId, State),case guild_thread_gate:needs_variant(State) of@@ -131,7 +131,7 @@ apply_thread_view(UserId, _Opts, State, GuildState) ->UserId, Member, State, maps:get(<<"channels">>, GuildState, [])),Roles = [- guild_thread_gate:mask_role(R)+ guild_thread_payload:mask_role(R)|| R <- maps:get(<<"roles">>, GuildState, []), is_map(R)],GuildState#{<<"channels">> => Channels, <<"roles">> => Roles}.@@ -186,16 +186,16 @@ build_connect_snapshot(Items, State) ->-spec project_snapshot_sessions(map()) -> map().project_snapshot_sessions(#{sessions := Sessions} = Snapshot) when is_map(Sessions) ->- case snapshot_reads_sessions(Snapshot) of- true ->- Projected = maps:map(- fun(_SessionId, SessionData) -> project_snapshot_session(SessionData) end,- Sessions- ),- Snapshot#{sessions => Projected};- false ->- Snapshot#{sessions => #{}}- end;+ Retained =+ case snapshot_reads_sessions(Snapshot) of+ true -> Sessions;+ false -> #{}+ end,+ Projected = maps:map(+ fun(_SessionId, SessionData) -> project_snapshot_session(SessionData) end,+ Retained+ ),+ Snapshot#{sessions => Projected};project_snapshot_sessions(Snapshot) ->Snapshot.@@ -496,91 +496,3 @@ guild_id_wire_value(undefined) ->null;guild_id_wire_value(GuildId) ->integer_to_binary(GuildId).---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").--staff_only_data() ->- #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE_BUT_STAFF">>]}}.--projection_snapshot() ->- #{- data => staff_only_data(),- sessions => #{- <<"s1">> => #{- session_id => <<"s1">>,- user_id => 7,- pid => self(),- bot => false,- is_staff => true,- pending_connect => false,- active_guilds => sets:new(),- user_roles => [1, 2],- viewable_channels => #{10 => true}- }- }- }.--projection_entry(Snapshot) ->- maps:get(<<"s1">>, maps:get(sessions, Snapshot)).--project_snapshot_sessions_drops_only_heavy_keys_test() ->- Entry = projection_entry(project_snapshot_sessions(projection_snapshot())),- ?assertEqual(7, maps:get(user_id, Entry)),- ?assertEqual(true, maps:get(is_staff, Entry)),- ?assertEqual(false, maps:get(pending_connect, Entry)),- ?assertEqual(<<"s1">>, maps:get(session_id, Entry)),- ?assertNot(maps:is_key(active_guilds, Entry)),- ?assertNot(maps:is_key(user_roles, Entry)),- ?assertNot(maps:is_key(viewable_channels, Entry)).--projection_keeps_session_staff_lookup_test() ->- Projected = project_snapshot_sessions(projection_snapshot()),- ?assertEqual(true, guild_availability_check:is_user_staff(7, Projected)).--projection_leaves_snapshot_data_untouched_test() ->- Data = #{<<"members">> => #{7 => #{}}, members_ets => make_ref()},- Snapshot = maps:put(data, Data, projection_snapshot()),- ?assertEqual(Data, maps:get(data, project_snapshot_sessions(Snapshot))).--projection_keeps_non_map_session_entries_test() ->- Snapshot = #{data => staff_only_data(), sessions => #{<<"broken">> => not_a_map}},- ?assertEqual(Snapshot, project_snapshot_sessions(Snapshot)).--projection_drops_sessions_unless_staff_only_test() ->- Snapshot = projection_snapshot(),- lists:foreach(- fun(Data) ->- Projected = project_snapshot_sessions(Snapshot#{data => Data}),- ?assertEqual(#{}, maps:get(sessions, Projected)),- ?assertEqual(Data, maps:get(data, Projected))- end,- [- #{},- #{<<"guild">> => #{<<"features">> => []}},- #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}}- ]- ).--projection_keeps_snapshot_without_sessions_test() ->- Snapshot = #{id => 42, member_count => 3},- ?assertEqual(Snapshot, project_snapshot_sessions(Snapshot)).--trim_state(MemberCount) ->- #{id => 42, member_count => MemberCount, data => #{members_ets => make_ref()}}.--trim_applies_at_every_member_count_test() ->- ?assertEqual(true, should_trim_connect_snapshot(trim_state(49435))),- ?assertEqual(true, should_trim_connect_snapshot(trim_state(5000))),- ?assertEqual(true, should_trim_connect_snapshot(trim_state(1))),- ?assertEqual(true, should_trim_connect_snapshot(maps:remove(member_count, trim_state(1)))).--trim_needs_members_ets_test() ->- ?assertEqual(false, should_trim_connect_snapshot(#{member_count => 10, data => #{}})),- ?assertEqual(- false,- should_trim_connect_snapshot(#{member_count => 10, data => #{members_ets => 7}})- ),- ?assertEqual(false, should_trim_connect_snapshot(#{member_count => 10})).---endif.diff --git a/fluxer_gateway/src/guild/guild_dispatch.erl b/fluxer_gateway/src/guild/guild_dispatch.erlindex ba5b96b44..6a1dac18f 100644--- a/fluxer_gateway/src/guild/guild_dispatch.erl+++ b/fluxer_gateway/src/guild/guild_dispatch.erl@@ -10,7 +10,6 @@normalize_event/1,is_member_list_updates_enabled/1]).--export_type([event/0, event_data/0, guild_state/0]).-type guild_state() :: map().-type event() :: atom().@@ -22,7 +21,7 @@ normalize_event(Event) when is_atom(Event) ->normalize_event(Event) when is_binary(Event) ->event_atoms:normalize(Event).--spec handle_dispatch(term(), event_data(), guild_state()) -> {noreply, guild_state()}.+-spec handle_dispatch(atom() | binary(), map(), map()) -> {noreply, map()}.handle_dispatch(Event, EventData, State) ->case should_skip_dispatch(Event, State) oftrue ->@@ -45,7 +44,7 @@ normalized_event_atom(Event, _EventData, State) when is_binary(Event) ->should_skip_dispatch(guild_update, _State) ->false;should_skip_dispatch(_Event, State) ->- Data = maps:get(data, State, #{}),+ Data = maps:get(data, State),Guild = maps:get(<<"guild">>, Data, #{}),Features = maps:get(<<"features">>, Guild, []),lists:member(<<"UNAVAILABLE_FOR_EVERYONE">>, Features) orelse@@ -53,21 +52,26 @@ should_skip_dispatch(_Event, State) ->-spec process_dispatch(event(), event_data(), guild_state()) -> {noreply, guild_state()}.process_dispatch(Event, EventData, State) ->- case guild_thread_gate:pre_update_filter(Event, EventData, State) of- drop ->+ case+ {+ guild_thread_gate:pre_update_filter(Event, EventData, State),+ guild_thread_dispatch:handles(Event)+ }+ of+ {drop, _HandlesThread} ->ok = maybe_self_heal(State),{noreply, guild_thread_flip:hold(Event, EventData, State)};- {filtered, FilteredData} ->+ {{filtered, FilteredData}, _HandlesThread} ->ok = maybe_self_heal(State),process_regular_dispatch(Event, FilteredData, guild_thread_flip:hold(Event, EventData, State));- pass ->+ {pass, true} ->+ State1 = guild_thread_flip:hold(Event, EventData, State),+ guild_thread_dispatch:handle(Event, EventData, State1);+ {pass, false} ->State1 = guild_thread_flip:hold(Event, EventData, State),- case guild_thread_dispatch:handles(Event) of- true -> guild_thread_dispatch:handle(Event, EventData, State1);- false -> process_regular_dispatch(Event, EventData, State1)- end+ process_regular_dispatch(Event, EventData, State1)end.-spec maybe_self_heal(guild_state()) -> ok.@@ -89,7 +93,7 @@ process_regular_dispatch(Event, EventData, State) ->UpdatedState0 = guild_state:update_state(Event, FinalData0, State),UpdatedState = guild_state_threads:after_regular_event(Event, FinalData0, UpdatedState0),FilterState = filter_state_for_event(Event, State, UpdatedState),- Sessions = maps:get(sessions, UpdatedState, #{}),+ Sessions = maps:get(sessions, UpdatedState),FilteredSessions = filter_dispatch_sessions(Event, FinalData0, SessionIdOpt, Sessions, FilterState),@@ -127,7 +131,7 @@ filter_dispatch_sessions(Event, Data, SessionIdOpt, Sessions, State) ->-spec strip_thread_internal(event_data(), guild_state()) -> event_data().strip_thread_internal(Data, State) ->case guild_thread_gate:needs_variant(State) of- true -> guild_thread_gate:strip_internal(Data);+ true -> guild_thread_payload:strip_internal(Data);false -> Dataend.@@ -146,176 +150,6 @@ extract_session_id_if_needed(message_reaction_remove, EventData) ->extract_session_id_if_needed(_, EventData) ->{undefined, EventData}.--spec is_member_list_updates_enabled(guild_state()) -> boolean().+-spec is_member_list_updates_enabled(map()) -> boolean().is_member_list_updates_enabled(State) ->guild_dispatch_config:is_member_list_updates_enabled(State).---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").--should_skip_dispatch_guild_update_never_skipped_test() ->- State = #{- data => #{- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}- }- },- ?assertEqual(false, should_skip_dispatch(guild_update, State)).--should_skip_dispatch_unavailable_for_everyone_test() ->- State = #{- data => #{- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}- }- },- ?assertEqual(true, should_skip_dispatch(message_create, State)).--should_skip_dispatch_unavailable_for_everyone_but_staff_test() ->- State = #{- data => #{- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE_BUT_STAFF">>]}- }- },- ?assertEqual(true, should_skip_dispatch(message_create, State)).--unknown_binary_event_is_dropped_without_crashing_test() ->- State = #{id => 1, data => #{<<"guild">> => #{}}, sessions => #{}},- ?assertEqual(- {noreply, State},- handle_dispatch(<<"FUTURE_EVENT_THE_GATEWAY_HAS_NEVER_SEEN">>, #{}, State)- ).--normalize_event_keeps_unknown_binaries_test() ->- ?assertEqual(<<"FUTURE_EVENT_ZZZ">>, normalize_event(<<"FUTURE_EVENT_ZZZ">>)),- ?assertEqual(thread_create, normalize_event(<<"THREAD_CREATE">>)).--channel_delete_dispatch_filters_by_pre_delete_visibility_test() ->- Parent = self(),- VisiblePid = start_dispatch_capture(visible, Parent),- HiddenPid = start_dispatch_capture(hidden, Parent),- try- State = build_channel_delete_dispatch_state(VisiblePid, HiddenPid),- HiddenMember = guild_permissions_check:find_member_by_user_id(1001, State),- VisibleMember = guild_permissions_check:find_member_by_user_id(1002, State),- ?assertEqual(- false, guild_permissions_check:can_view_channel(1001, 10, HiddenMember, State)- ),- ?assertEqual(- true, guild_permissions_check:can_view_channel(1002, 10, VisibleMember, State)- ),- {noreply, _} = handle_dispatch(channel_delete, #{<<"id">> => <<"10">>}, State),- assert_visible_channel_delete_dispatched(),- assert_hidden_channel_delete_not_dispatched()- after- VisiblePid ! stop,- HiddenPid ! stop- end.---spec start_dispatch_capture(atom(), pid()) -> pid().-start_dispatch_capture(Tag, Parent) ->- spawn(fun() -> dispatch_capture_loop(Tag, Parent) end).---spec dispatch_capture_loop(atom(), pid()) -> ok.-dispatch_capture_loop(Tag, Parent) ->- receive- stop ->- ok;- {'$gen_cast', Msg} ->- Parent ! {Tag, Msg},- dispatch_capture_loop(Tag, Parent);- _Other ->- dispatch_capture_loop(Tag, Parent)- after 5000 ->- dispatch_capture_loop(Tag, Parent)- end.---spec assert_visible_channel_delete_dispatched() -> ok.-assert_visible_channel_delete_dispatched() ->- receive- {visible, {dispatch, channel_delete, Payload0}} ->- Payload = decode_dispatch_payload(Payload0),- ?assertEqual(<<"10">>, maps:get(<<"id">>, Payload));- {visible, Other} ->- ?assert(false, {unexpected_visible_message, Other})- after 1000 ->- ?assert(false, visible_channel_delete_not_dispatched)- end.---spec assert_hidden_channel_delete_not_dispatched() -> ok.-assert_hidden_channel_delete_not_dispatched() ->- receive- {hidden, {dispatch, channel_delete, _Payload}} ->- ?assert(false, hidden_user_received_channel_delete)- after 200 ->- ok- end.---spec decode_dispatch_payload(term()) -> map().-decode_dispatch_payload({pre_encoded, Bin}) when is_binary(Bin) ->- decoded_dispatch_payload(json:decode(Bin));-decode_dispatch_payload(Map) when is_map(Map) ->- Map.---spec decoded_dispatch_payload(term()) -> map().-decoded_dispatch_payload(Payload) when is_map(Payload) ->- Payload.---spec build_channel_delete_dispatch_state(pid(), pid()) -> guild_state().-build_channel_delete_dispatch_state(VisiblePid, HiddenPid) ->- GuildId = 1,- GuildIdBin = integer_to_binary(GuildId),- ViewPermissionBin = integer_to_binary(constants:view_channel_permission()),- #{- id => GuildId,- member_count => 100,- sessions => build_test_sessions(GuildId, VisiblePid, HiddenPid),- data => build_test_data(GuildIdBin, ViewPermissionBin),- member_list_subscriptions => guild_member_list_subs:new()- }.---spec build_test_sessions(integer(), pid(), pid()) -> map().-build_test_sessions(GuildId, VisiblePid, HiddenPid) ->- #{- <<"visible">> => #{- user_id => 1002,- pid => VisiblePid,- active_guilds => sets:from_list([GuildId])- },- <<"hidden">> => #{- user_id => 1001,- pid => HiddenPid,- active_guilds => sets:from_list([GuildId])- }- }.---spec build_test_data(binary(), binary()) -> map().-build_test_data(GuildIdBin, ViewPermissionBin) ->- #{- <<"guild">> => #{- <<"id">> => GuildIdBin,- <<"owner_id">> => <<"999">>,- <<"features">> => []- },- <<"roles">> => [- #{<<"id">> => GuildIdBin, <<"permissions">> => ViewPermissionBin},- #{<<"id">> => <<"200">>, <<"permissions">> => <<"0">>}- ],- <<"members">> => [- #{<<"user">> => #{<<"id">> => <<"1001">>}, <<"roles">> => [<<"200">>]},- #{<<"user">> => #{<<"id">> => <<"1002">>}, <<"roles">> => []}- ],- <<"channels">> => [- #{- <<"id">> => <<"10">>,- <<"permission_overwrites">> => [- #{- <<"id">> => <<"200">>,- <<"type">> => 0,- <<"allow">> => <<"0">>,- <<"deny">> => ViewPermissionBin- }- ]- }- ]- }.---endif.diff --git a/fluxer_gateway/src/guild/guild_dispatch_send.erl b/fluxer_gateway/src/guild/guild_dispatch_send.erlindex 04a0a8e91..5baa43f17 100644--- a/fluxer_gateway/src/guild/guild_dispatch_send.erl+++ b/fluxer_gateway/src/guild/guild_dispatch_send.erl@@ -16,14 +16,12 @@-type guild_state() :: map().-type session_id() :: binary().-type guild_id() :: integer().--type user_id() :: integer().-type session_pair() :: {session_id(), map()}.-type bulk_group_key() :: [term()].-type bulk_groups() :: #{bulk_group_key() => {[map()], [pid()]}}.-type bulk_acc() :: {bulk_groups(), non_neg_integer()}.--export_type([event/0, event_data/0, guild_state/0, user_id/0, session_pair/0]).--spec dispatch_to_sessions([session_pair()], event(), event_data(), guild_state()) ->+-spec dispatch_to_sessions([{binary(), map()}], atom(), map(), map()) ->non_neg_integer().dispatch_to_sessions(FilteredSessions, Event, FinalData, UpdatedState) ->case guild_thread_gate:needs_variant(UpdatedState) of@@ -36,7 +34,7 @@ dispatch_to_sessions(FilteredSessions, Event, FinalData, UpdatedState) ->-spec dispatch_masked_variants([session_pair()], event(), event_data(), guild_state()) ->non_neg_integer().dispatch_masked_variants(FilteredSessions, Event, FinalData, UpdatedState) ->- Masked = guild_thread_gate:mask_payload(Event, FinalData),+ Masked = guild_thread_payload:mask_payload(Event, FinalData),{Viewers, Others} = lists:partition(fun({_Sid, Session}) -> guild_thread_gate:session_viewer(Session) end, FilteredSessions),@@ -323,204 +321,3 @@ normalize_success(_) -> 0.-spec normalize_dispatched([pid()]) -> non_neg_integer().normalize_dispatched([]) -> 0;normalize_dispatched([_ | _]) -> 1.---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").---define(OVERFLOW_CHANNEL_BITS, 11).--passive_channel_update_bulk_dispatches_visible_channels_test() ->- flush_dispatches(),- Data = #{- <<"guild_id">> => <<"42">>,- <<"channels">> => [- #{<<"id">> => <<"100">>, <<"name">> => <<"visible">>},- #{<<"id">> => <<"200">>, <<"name">> => <<"hidden">>}- ]- },- ?assertEqual(- 1,- dispatch_to_sessions(- [passive_session_pair()], channel_update_bulk, Data, passive_dispatch_state()- )- ),- Payload = receive_pre_encoded_payload(channel_update_bulk),- ?assertEqual(- [#{<<"id">> => <<"100">>, <<"name">> => <<"visible">>}],- maps:get(<<"channels">>, Payload)- ).--grouped_bulk_encodes_once_per_visible_set_test() ->- flush_dispatches(),- Data = bulk_channel_data(),- State = passive_dispatch_state(),- Sessions = [- bulk_session_pair(<<"a">>, #{100 => true}),- bulk_session_pair(<<"b">>, #{100 => true}),- bulk_session_pair(<<"c">>, #{200 => true})- ],- ?assertEqual(1, dispatch_to_sessions(Sessions, channel_update_bulk, Data, State)),- Bins = [receive_pre_encoded_binary(channel_update_bulk) || _ <- lists:seq(1, 3)],- ?assertEqual(2, length(lists:usort(Bins))),- Sets = [maps:get(<<"channels">>, json:decode(Bin)) || Bin <- Bins],- ?assertEqual(2, length([S || S <- Sets, S =:= [bulk_channel(<<"100">>, <<"first">>)]])),- ?assertEqual(1, length([S || S <- Sets, S =:= [bulk_channel(<<"200">>, <<"second">>)]])).--grouped_bulk_skips_sessions_without_visible_channels_test() ->- flush_dispatches(),- Data = bulk_channel_data(),- State = passive_dispatch_state(),- Sessions = [- bulk_session_pair(<<"a">>, #{}),- bulk_session_pair(<<"b">>, #{200 => true})- ],- ?assertEqual(1, dispatch_to_sessions(Sessions, channel_update_bulk, Data, State)),- ?assertEqual(- [bulk_channel(<<"200">>, <<"second">>)],- maps:get(<<"channels">>, receive_pre_encoded_payload(channel_update_bulk))- ),- ?assertEqual(ok, assert_no_further_dispatch()).--grouped_bulk_dispatches_overflow_recipients_without_retaining_them_test() ->- flush_dispatches(),- Total = ?MAX_BULK_ENCODE_GROUPS + 1,- State = passive_dispatch_state(),- Data = #{- <<"guild_id">> => <<"42">>,- <<"channels">> => [- bulk_channel(integer_to_binary(Id), <<"c">>)- || Id <- lists:seq(1, ?OVERFLOW_CHANNEL_BITS)- ]- },- Sessions = [overflow_session_pair(N) || N <- lists:seq(1, Total)],- ?assertEqual(1, dispatch_to_sessions(Sessions, channel_update_bulk, Data, State)),- Received = collect_bulk_channel_ids(Total, []),- Expected = [overflow_channel_ids(N) || N <- lists:seq(1, Total)],- ?assertEqual(lists:sort(Expected), lists:sort(Received)),- ?assertEqual(ok, assert_no_further_dispatch()).--overflow_session_pair(N) ->- Base = passive_session_data(),- Sid = integer_to_binary(N),- Viewable = maps:from_list([{Id, true} || Id <- overflow_visible_ids(N)]),- {Sid, Base#{session_id => Sid, viewable_channels => Viewable}}.--overflow_visible_ids(N) ->- [Id || Id <- lists:seq(1, ?OVERFLOW_CHANNEL_BITS), (N bsr (Id - 1)) band 1 =:= 1].--overflow_channel_ids(N) ->- [integer_to_binary(Id) || Id <- overflow_visible_ids(N)].--collect_bulk_channel_ids(0, Acc) ->- Acc;-collect_bulk_channel_ids(N, Acc) ->- Payload = receive_pre_encoded_payload(channel_update_bulk),- Ids = [maps:get(<<"id">>, Ch) || Ch <- maps:get(<<"channels">>, Payload)],- collect_bulk_channel_ids(N - 1, [Ids | Acc]).--bulk_channel_data() ->- #{- <<"guild_id">> => <<"42">>,- <<"channels">> => [- bulk_channel(<<"100">>, <<"first">>),- bulk_channel(<<"200">>, <<"second">>)- ]- }.--bulk_channel(Id, Name) ->- #{<<"id">> => Id, <<"name">> => Name}.--bulk_session_pair(Sid, ViewableChannels) ->- Base = passive_session_data(),- {Sid, Base#{session_id => Sid, viewable_channels => ViewableChannels}}.--assert_no_further_dispatch() ->- receive- {'$gen_cast', {dispatch, Event, _Payload}} ->- ?assert(false, {unexpected_dispatch, Event})- after 0 ->- ok- end.--standard_dispatch_without_eligible_sessions_test() ->- flush_dispatches(),- Session = (passive_session_data())#{pid => undefined},- ?assertEqual(- 0,- dispatch_to_sessions(- [{<<"offline">>, Session}],- guild_update,- #{<<"guild_id">> => <<"42">>, <<"name">> => <<"Updated">>},- passive_dispatch_state()- )- ),- assert_no_dispatch().--standard_dispatch_ignores_ineligible_sessions_test() ->- flush_dispatches(),- Offline = (passive_session_data())#{pid => undefined},- ?assertEqual(- 1,- dispatch_to_sessions(- [{<<"offline">>, Offline}, passive_session_pair()],- guild_update,- #{<<"guild_id">> => <<"42">>, <<"name">> => <<"Updated">>},- passive_dispatch_state()- )- ),- _Payload = receive_pre_encoded_payload(guild_update),- assert_no_dispatch().--assert_no_dispatch() ->- receive- {'$gen_cast', {dispatch, Event, _Payload}} ->- ?assert(false, {unexpected_dispatch, Event})- after 100 ->- ok- end.--passive_session_pair() ->- {<<"passive">>, passive_session_data()}.--passive_session_data() ->- #{- session_id => <<"passive">>,- user_id => 10,- pid => self(),- active_guilds => sets:new(),- bot => false,- viewable_channels => #{100 => true}- }.--passive_dispatch_state() ->- #{- id => 42,- member_count => 300,- data => #{- <<"guild">> => #{<<"owner_id">> => <<"999">>},- <<"roles">> => [],- <<"members">> => [],- <<"channels">> => []- }- }.--receive_pre_encoded_payload(Event) ->- json:decode(receive_pre_encoded_binary(Event)).--receive_pre_encoded_binary(Event) ->- receive- {'$gen_cast', {dispatch, Event, {pre_encoded, Bin}}} ->- Bin- after 1000 ->- ?assert(false, {dispatch_not_received, Event})- end.--flush_dispatches() ->- receive- {'$gen_cast', {dispatch, _Event, _Payload}} ->- flush_dispatches()- after 0 ->- ok- end.---endif.diff --git a/fluxer_gateway/src/guild/guild_thread_dispatch.erl b/fluxer_gateway/src/guild/guild_thread_dispatch.erlindex 66707e226..28b328674 100644--- a/fluxer_gateway/src/guild/guild_thread_dispatch.erl+++ b/fluxer_gateway/src/guild/guild_thread_dispatch.erl@@ -14,6 +14,7 @@]).-define(RECENT_CREATE_CAP, 256).+-define(PRIVATE_THREAD, 12).-define(COUNTS_KEY, {?MODULE, variant_counts}).-define(EVENTS, [thread_create,@@ -51,7 +52,7 @@ handles(thread_member_list_update) -> true;handles(forum_unreads) -> true;handles(_) -> false.--spec handle(atom(), map(), guild_state()) -> {noreply, guild_state()}.+-spec handle(atom(), map(), map()) -> {noreply, map()}.handle(Event, EventData, #{id := GuildId} = State) when is_integer(GuildId) ->Data = EventData#{<<"guild_id">> => integer_to_binary(GuildId)},try@@ -170,8 +171,8 @@ shared_memo(Before, After, Memo) when is_map(Before), is_map(After) ->ParentId = guild_thread_permissions:parent_id(Before),caseguild_thread_permissions:parent_id(After) =:= ParentId andalso- maps:get(<<"type">>, Before, undefined) =/= 12 andalso- maps:get(<<"type">>, After, undefined) =/= 12+ maps:get(<<"type">>, Before, undefined) =/= ?PRIVATE_THREAD andalso+ maps:get(<<"type">>, After, undefined) =/= ?PRIVATE_THREADoftrue -> Memo;false -> #{}@@ -182,6 +183,7 @@ shared_memo(_Before, _After, _Memo) ->-spec unarchive_member_updates(integer(), map(), [session_pair()], guild_state(), map()) ->[delivery()].unarchive_member_updates(ThreadId, Thread, Viewers, #{id := GuildId} = State, Memo) ->+ Wants = fun(Session, _Passive) -> is_member(Session, ThreadId, State) end,case guild_thread_gate:store(State) ofundefined ->[];@@ -190,7 +192,7 @@ unarchive_member_updates(ThreadId, Thread, Viewers, #{id := GuildId} = State, MeThread,Viewers,State,- fun(Session, _Passive) -> is_member(Session, ThreadId, State) end,+ Wants,Memo),[@@ -228,7 +230,7 @@ thread_member_update(Data, State0) ->ThreadId = snowflake_id:parse_maybe(maps:get(<<"id">>, Data, undefined)),TargetId = snowflake_id:parse_maybe(maps:get(<<"user_id">>, Data, undefined)),Thread = member_update_thread(ThreadId, TargetId, Data, State),- Payload = guild_thread_gate:strip_internal(Data),+ Payload = guild_thread_payload:strip_internal(Data),Deliveries = [{thread_member_update, Pid, Payload}|| Thread =/= undefined,@@ -336,7 +338,7 @@ synthesized_creates(Thread, ThreadId, Users, Viewers, State) ->-spec members_update_payload(map(), guild_state()) -> map().members_update_payload(Data, State) ->- Base = guild_thread_gate:strip_internal(Data),+ Base = guild_thread_payload:strip_internal(Data),case maps:get(<<"added_members">>, Base, undefined) ofAdded when is_list(Added) ->Ctx = guild_member_list_connected:presence_context(State),@@ -389,17 +391,10 @@ recipients(Thread, Viewers, State, Wants, Memo0) ->Small = session_passive:is_small_guild(State),{Pairs, Memo} = lists:foldl(fun({_Sid, Session} = Pair, {Acc, Memo1}) ->- case- Wants(Session, (not Small) andalso session_passive:is_passive(GuildId, Session))- of- true ->- case guild_thread_gate:thread_view_access(Session, Thread, State, Memo1) of- {true, Memo2} -> {[Pair | Acc], Memo2};- {false, Memo2} -> {Acc, Memo2}- end;- false ->- {Acc, Memo1}- end+ Passive = (not Small) andalso session_passive:is_passive(GuildId, Session),+ Candidate = Wants(Session, Passive) andalso Session,+ {Ok, Memo2} = guild_thread_gate:thread_view_access(Candidate, Thread, State, Memo1),+ {[Pair || Ok] ++ Acc, Memo2}end,{[], Memo0},Viewers@@ -415,8 +410,9 @@ joined_or_interested(ThreadId, State) ->-spec interested(map(), integer(), guild_state()) -> boolean().interested(Session, ThreadId, State) ->- is_bot(Session) orelse is_member(Session, ThreadId, State) orelse- maps:get(thread_subscribed, Session, false) =:= true.+ type_conv:is_true(maps:get(bot, Session, false)) orelse+ is_member(Session, ThreadId, State) orelse+ type_conv:is_true(maps:get(thread_subscribed, Session, false)).-spec is_member(map(), integer(), guild_state()) -> boolean().is_member(#{user_id := UserId}, ThreadId, State) ->@@ -427,10 +423,6 @@ is_member(#{user_id := UserId}, ThreadId, State) ->is_member(_Session, _ThreadId, _State) ->false.--spec is_bot(map()) -> boolean().-is_bot(Session) ->- maps:get(bot, Session, false) =:= true.--spec can_view(map(), map(), guild_state()) -> boolean().can_view(#{user_id := UserId}, Thread, State) when is_integer(UserId) ->Member = guild_permissions_check:find_member_by_user_id(UserId, State),@@ -442,10 +434,10 @@ can_view(_Session, _Thread, _State) ->viewer_sessions(State) ->[{Sid, Session}- || {Sid, Session} <- maps:to_list(maps:get(sessions, State, #{})),+ || {Sid, Session} <- maps:to_list(maps:get(sessions, State)),is_map(Session),guild_thread_gate:session_viewer(Session),- maps:get(pending_connect, Session, false) =/= true,+ not type_conv:is_true(maps:get(pending_connect, Session, false)),is_pid(maps:get(pid, Session, undefined))].@@ -455,12 +447,11 @@ union(A, B) ->-spec thread_or_context(integer(), map(), guild_state()) -> map() | undefined.thread_or_context(ThreadId, Data, State) ->- case guild_thread_gate:thread(ThreadId, State) of- undefined ->- case guild_state_threads:thread_context(ThreadId, Data) of- undefined -> fallback_context(ThreadId, Data);- Context -> Context- end;+ maybe+ undefined ?= guild_thread_gate:thread(ThreadId, State),+ undefined ?= guild_state_threads:thread_context(ThreadId, Data),+ fallback_context(ThreadId, Data)+ elseThread ->Threadend.@@ -476,19 +467,19 @@ fallback_context(_ThreadId, _Data) ->-spec public_payload(map()) -> map().public_payload(Data) ->maps:without(- [<<"member">>, <<"member_ids_preview">>], guild_thread_gate:strip_internal(Data)+ [<<"member">>, <<"member_ids_preview">>], guild_thread_payload:strip_internal(Data)).-spec with_member(map(), integer(), term(), guild_state()) -> map().with_member(Base, ThreadId, UserId, State) when is_integer(UserId) ->- case guild_thread_gate:store(State) of- undefined ->- Base;- Tab ->- case guild_thread_store:get_member(Tab, ThreadId, UserId) of- undefined -> Base;- Member -> Base#{<<"member">> => Member}- end+ Member =+ case guild_thread_gate:store(State) of+ undefined -> undefined;+ Tab -> guild_thread_store:get_member(Tab, ThreadId, UserId)+ end,+ case Member of+ undefined -> Base;+ _ -> Base#{<<"member">> => Member}end;with_member(Base, _ThreadId, _UserId, _State) ->Base.diff --git a/fluxer_gateway/src/guild/guild_thread_payload.erl b/fluxer_gateway/src/guild/guild_thread_payload.erlnew file mode 100644index 000000000..3a04cab3e--- /dev/null+++ b/fluxer_gateway/src/guild/guild_thread_payload.erl@@ -0,0 +1,146 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_thread_payload).+-typing([eqwalizer]).++-export([+ mask_payload/2,+ strip_channel_surface/1,+ mask_role/1,+ mask_overwrites/1,+ strip_internal/1+]).++-define(THREAD_MESSAGE_FLAGS, 16#120).+-define(THREAD_CREATED_MESSAGE, 18).+-define(THREAD_PERMISSION_BITS,+ (16#400000000 bor 16#800000000 bor 16#1000000000 bor 16#4000000000)+).+-define(SURFACE_KEYS, [+ <<"thread_metadata">>,+ <<"applied_tags">>,+ <<"available_tags">>,+ <<"default_auto_archive_duration">>,+ <<"default_thread_rate_limit_per_user">>,+ <<"default_reaction_emoji">>,+ <<"default_sort_order">>,+ <<"default_forum_layout">>,+ <<"default_tag_setting">>,+ <<"message_count">>,+ <<"total_message_sent">>,+ <<"member_ids_preview">>,+ <<"member_count">>,+ <<"flags">>+]).++-spec mask_payload(atom(), map()) -> map().+mask_payload(Event, Data) when+ Event =:= message_create; Event =:= message_update+->+ mask_message(Data);+mask_payload(Event, Data) when+ Event =:= channel_create; Event =:= channel_update+->+ mask_overwrites(strip_channel_surface(Data));+mask_payload(channel_update_bulk, #{<<"channels">> := Channels} = Data) when+ is_list(Channels)+->+ Data#{+ <<"channels">> => [+ mask_overwrites(strip_channel_surface(Channel))+ || Channel <- Channels, is_map(Channel)+ ]+ };+mask_payload(Event, #{<<"role">> := Role} = Data) when+ is_map(Role), Event =:= guild_role_create; is_map(Role), Event =:= guild_role_update+->+ Data#{<<"role">> => mask_role(Role)};+mask_payload(guild_role_update_bulk, #{<<"roles">> := Roles} = Data) when is_list(Roles) ->+ Data#{<<"roles">> => [mask_role(Role) || Role <- Roles, is_map(Role)]};+mask_payload(_Event, Data) ->+ Data.++-spec mask_message(map()) -> map().+mask_message(Message) ->+ Message1 = maps:remove(<<"thread">>, Message),+ Message2 =+ case maps:get(<<"flags">>, Message1, undefined) of+ Flags when is_integer(Flags) ->+ Message1#{<<"flags">> => Flags band bnot ?THREAD_MESSAGE_FLAGS};+ _ ->+ Message1+ end,+ Message3 =+ case maps:get(<<"referenced_message">>, Message2, undefined) of+ #{<<"type">> := ?THREAD_CREATED_MESSAGE} ->+ Message2#{<<"referenced_message">> => null};+ Referenced when is_map(Referenced) ->+ Message2#{<<"referenced_message">> => mask_message(Referenced)};+ _ ->+ Message2+ end,+ case maps:get(<<"message_snapshots">>, Message3, undefined) of+ Snapshots when is_list(Snapshots) ->+ Message3#{<<"message_snapshots">> => [mask_snapshot(S) || S <- Snapshots]};+ _ ->+ Message3+ end.++-spec mask_snapshot(term()) -> term().+mask_snapshot(#{<<"message">> := Message} = Snapshot) when is_map(Message) ->+ Snapshot#{<<"message">> => mask_message(Message)};+mask_snapshot(Snapshot) when is_map(Snapshot) ->+ mask_message(Snapshot);+mask_snapshot(Snapshot) ->+ Snapshot.++-spec strip_channel_surface(map()) -> map().+strip_channel_surface(Channel) ->+ maps:without(?SURFACE_KEYS, Channel).++-spec mask_role(map()) -> map().+mask_role(#{<<"permissions">> := Permissions} = Role) ->+ Role#{<<"permissions">> => mask_bits(Permissions)};+mask_role(Role) ->+ Role.++-spec mask_overwrites(map()) -> map().+mask_overwrites(#{<<"permission_overwrites">> := Overwrites} = Channel) when+ is_list(Overwrites)+->+ Channel#{<<"permission_overwrites">> => [mask_overwrite(O) || O <- Overwrites]};+mask_overwrites(Channel) ->+ Channel.++-spec mask_overwrite(term()) -> term().+mask_overwrite(Overwrite) when is_map(Overwrite) ->+ maps:map(+ fun+ (<<"allow">>, Value) -> mask_bits(Value);+ (<<"deny">>, Value) -> mask_bits(Value);+ (_Key, Value) -> Value+ end,+ Overwrite+ );+mask_overwrite(Overwrite) ->+ Overwrite.++-spec mask_bits(term()) -> term().+mask_bits(Value) when is_integer(Value) ->+ Value band bnot ?THREAD_PERMISSION_BITS;+mask_bits(Value) when is_binary(Value) ->+ case bitset:parse_optional(Value) of+ Bits when is_integer(Bits) -> integer_to_binary(Bits band bnot ?THREAD_PERMISSION_BITS);+ _ -> Value+ end;+mask_bits(Value) ->+ Value.++-spec strip_internal(map()) -> map().+strip_internal(Data) ->+ maps:filter(fun(Key, _Value) -> not internal_key(Key) end, Data).++-spec internal_key(term()) -> boolean().+internal_key(<<"_fluxer_", _/binary>>) -> true;+internal_key(<<"__thread_", _/binary>>) -> true;+internal_key(_) -> false.diff --git a/fluxer_gateway/src/guild/guild_thread_view.erl b/fluxer_gateway/src/guild/guild_thread_view.erlindex 7bdb3011c..d7488b6d1 100644--- a/fluxer_gateway/src/guild/guild_thread_view.erl+++ b/fluxer_gateway/src/guild/guild_thread_view.erl@@ -11,43 +11,31 @@hide_for_non_viewer/4]).--type guild_state() :: map().---spec guild_threads(integer(), map(), map() | undefined, guild_state()) -> [map()].+-spec guild_threads(integer(), map(), map() | undefined, map()) -> [map()].guild_threads(UserId, Opts, Member, State) ->- case guild_thread_gate:store(State) of- undefined ->- [];- Tab ->- case maps:get(bot, Opts, false) of- true -> bot_threads(UserId, Member, Tab, State);- false -> joined_threads(UserId, Member, Tab, State)- end+ case {guild_thread_gate:store(State), maps:get(bot, Opts, false)} of+ {undefined, _Bot} -> [];+ {Tab, true} -> bot_threads(UserId, Member, Tab, State);+ {Tab, false} -> joined_threads(UserId, Member, Tab, State);+ {_Tab, Bot} -> error({case_clause, Bot})end.--spec bot_threads(integer(), map() | undefined, ets:table(), guild_state()) -> [map()].+-spec bot_threads(integer(), map() | undefined, ets:table(), map()) -> [map()].bot_threads(UserId, Member, Tab, State) ->[with_own_member(UserId, Thread, Tab)|| Thread <- guild_thread_store:threads(Tab), can_view(UserId, Thread, Member, State)].--spec joined_threads(integer(), map() | undefined, ets:table(), guild_state()) -> [map()].+-spec joined_threads(integer(), map() | undefined, ets:table(), map()) -> [map()].joined_threads(UserId, Member, Tab, State) ->- lists:filtermap(- fun(ThreadId) ->- case guild_thread_store:get_thread(Tab, ThreadId) of- undefined ->- false;- Thread ->- case can_view(UserId, Thread, Member, State) of- true -> {true, with_own_member(UserId, Thread, Tab)};- false -> false- end- end- end,- guild_thread_store:user_thread_ids(Tab, UserId)- ).+ [+ with_own_member(UserId, Thread, Tab)+ || ThreadId <- guild_thread_store:user_thread_ids(Tab, UserId),+ Thread <- [guild_thread_store:get_thread(Tab, ThreadId)],+ Thread =/= undefined,+ can_view(UserId, Thread, Member, State)+ ].-spec with_own_member(integer(), map(), ets:table()) -> map().with_own_member(UserId, Thread, Tab) ->@@ -69,13 +57,13 @@ thread_payload(Thread) ->thread_id(Thread) ->snowflake_id:parse(maps:get(<<"id">>, Thread)).--spec can_view(integer(), map(), map() | undefined, guild_state()) -> boolean().+-spec can_view(integer(), map(), map() | undefined, map()) -> boolean().can_view(UserId, Thread, Member, State) ->Perms = guild_thread_permissions:resolve(UserId, Thread, Member, State),bitset:has(Perms, constants:view_channel_permission()).-spec viewable_thread_ids(- integer(), [integer()] | all | joined, map() | undefined, guild_state()+ integer(), [integer()] | all | joined, map() | undefined, map()) ->[{integer(), map()}].viewable_thread_ids(UserId, Parents, Member, State) ->@@ -102,34 +90,27 @@ candidate_threads(Parents, _UserId, Tab) ->-spec stored_threads([integer()], ets:table()) -> [map()].stored_threads(ThreadIds, Tab) ->- lists:filtermap(- fun(ThreadId) ->- case guild_thread_store:get_thread(Tab, ThreadId) of- undefined -> false;- Thread -> {true, Thread}- end- end,- ThreadIds- ).+ [+ Thread+ || ThreadId <- ThreadIds,+ Thread <- [guild_thread_store:get_thread(Tab, ThreadId)],+ Thread =/= undefined+ ].-spec list_sync(- integer(), integer(), [integer()] | all | joined, map() | undefined, guild_state()+ integer(), integer(), [integer()] | all | joined, map() | undefined, map()) ->map().list_sync(GuildId, UserId, Parents, Member, State) ->Viewable = viewable_thread_ids(UserId, Parents, Member, State),- Members =- case guild_thread_gate:store(State) of- undefined ->- [];- Tab ->- [- M- || {ThreadId, _Thread} <- Viewable,- M <- [guild_thread_store:get_member(Tab, ThreadId, UserId)],- M =/= undefined- ]- end,+ Tab = guild_thread_gate:store(State),+ Members = [+ M+ || {ThreadId, _Thread} <- Viewable,+ Tab =/= undefined,+ M <- [guild_thread_store:get_member(Tab, ThreadId, UserId)],+ M =/= undefined+ ],Base = #{<<"guild_id">> => integer_to_binary(GuildId),<<"threads">> => [thread_payload(Thread) || {_Id, Thread} <- Viewable],@@ -141,43 +122,39 @@ list_sync(GuildId, UserId, Parents, Member, State) ->_ -> Base#{<<"channel_ids">> => [integer_to_binary(P) || P <- Parents]}end.--spec hide_for_non_viewer(integer(), map() | undefined, guild_state(), [map()]) -> [map()].+-spec hide_for_non_viewer(integer(), map() | undefined, map(), [map()]) -> [map()].hide_for_non_viewer(UserId, Member, State, Channels) ->- Kept = [C || C <- Channels, not guild_thread_gate:is_thread_only_type(channel_type(C))],+ Kept = [C || C <- Channels, not channel_types:is_thread_only(channel_type(C))],Visible =case length(Kept) =:= length(Channels) oftrue -> Kept;false -> drop_forum_only_categories(UserId, Member, State, Kept)end,[- guild_thread_gate:mask_overwrites(guild_thread_gate:strip_channel_surface(C))+ guild_thread_payload:mask_overwrites(guild_thread_payload:strip_channel_surface(C))|| C <- Visible].--spec drop_forum_only_categories(integer(), map() | undefined, guild_state(), [map()]) ->+-spec drop_forum_only_categories(integer(), map() | undefined, map(), [map()]) ->[map()].drop_forum_only_categories(UserId, Member, State, Channels) ->Parents = sets:from_list([P|| C <- Channels,- channel_type(C) =/= 4,+ not channel_types:is_category(channel_type(C)),P <- [snowflake_id:parse_maybe(maps:get(<<"parent_id">>, C, undefined))],is_integer(P)]),lists:filter(fun(C) ->- case- {channel_type(C), snowflake_id:parse_maybe(maps:get(<<"id">>, C, undefined))}- of- {4, Id} when is_integer(Id) ->- sets:is_element(Id, Parents) orelse- guild_permissions_check:can_view_channel_by_permissions(- UserId, Id, Member, State- ) orelse- guild_virtual_channel_access:has_virtual_access(UserId, Id, State);- _ ->- true- end+ Type = channel_type(C),+ Id = snowflake_id:parse_maybe(maps:get(<<"id">>, C, undefined)),+ not channel_types:is_category(Type) orelse not is_integer(Id) orelse+ sets:is_element(Id, Parents) orelse+ guild_permissions_check:can_view_channel_by_permissions(+ UserId, Id, Member, State+ ) orelse+ guild_virtual_channel_access:has_virtual_access(UserId, Id, State)end,Channels).diff --git a/fluxer_gateway/src/guild/guild_visibility_roles.erl b/fluxer_gateway/src/guild/guild_visibility_roles.erlindex 86c2a4c6e..41c7e18c6 100644--- a/fluxer_gateway/src/guild/guild_visibility_roles.erl+++ b/fluxer_gateway/src/guild/guild_visibility_roles.erl@@ -11,15 +11,11 @@can_send_member_list/3]).--export_type([guild_state/0, user_id/0, channel_id/0]).--type guild_state() :: map().-type user_id() :: integer().-type channel_id() :: integer().--spec maybe_ensure_parent_category_visible(- channel_id(), map(), guild_state(), map(), integer()-) -> map().+-spec maybe_ensure_parent_category_visible(integer(), map(), map(), map(), integer()) -> map().maybe_ensure_parent_category_visible(ChannelId, ViewableMap, State, SessionData, GuildId) ->case{snowflake_id(GuildId), guild_permissions_check:find_channel_by_id(ChannelId, State)}@@ -54,7 +50,7 @@ ensure_parent_category_visible(ensure_parent_category_visible(_ParentId, ViewableMap, _State, _SessionData, _GuildId) ->ViewableMap.--spec dispatch_channel_delete(channel_id(), pid(), guild_state(), integer()) -> ok.+-spec dispatch_channel_delete(integer(), pid(), map(), integer()) -> ok.dispatch_channel_delete(ChannelId, SessionPid, OldState, GuildId) ->case {is_pid(SessionPid), snowflake_id(ChannelId), snowflake_id(GuildId)} of{true, ResolvedChannelId, ResolvedGuildId} when@@ -67,7 +63,7 @@ dispatch_channel_delete(ChannelId, SessionPid, OldState, GuildId) ->okend.--spec dispatch_channel_create(channel_id(), map(), guild_state(), integer()) -> ok.+-spec dispatch_channel_create(integer(), map(), map(), integer()) -> ok.dispatch_channel_create(ChannelId, SessionData, NewState, GuildId) ->case{maps:get(pid, SessionData, undefined), snowflake_id(ChannelId), snowflake_id(GuildId)}@@ -82,7 +78,7 @@ dispatch_channel_create(ChannelId, SessionData, NewState, GuildId) ->okend.--spec send_member_list_sync(binary(), map(), channel_id(), integer(), guild_state()) -> ok.+-spec send_member_list_sync(binary(), map(), integer(), integer(), map()) -> ok.send_member_list_sync(SessionId, SessionData, ChannelId, GuildId, State) ->SessionPid = maps:get(pid, SessionData),case {is_pid(SessionPid), snowflake_id(ChannelId), snowflake_id(GuildId)} of@@ -144,7 +140,7 @@ maybe_dispatch_sync(SessionUserId, SessionPid, ChannelId, GuildId, ListId, Rangeokend.--spec can_send_member_list(user_id() | undefined, channel_id(), guild_state()) -> boolean().+-spec can_send_member_list(integer() | undefined, integer(), map()) -> boolean().can_send_member_list(UserId, ChannelId, State) ->case snowflake_id(ChannelId) ofResolvedChannelId when is_integer(UserId), is_integer(ResolvedChannelId) ->@@ -188,7 +184,9 @@ session_channel(Channel, SessionData, State) ->not guild_thread_gate:session_viewer(SessionData)oftrue ->- guild_thread_gate:mask_overwrites(guild_thread_gate:strip_channel_surface(Channel));+ guild_thread_payload:mask_overwrites(+ guild_thread_payload:strip_channel_surface(Channel)+ );false ->Channelend.