From e4049e3d69cd8279e2be6ff435dfb2f103561a91 Mon Sep 17 00:00:00 2001 From: "Timo K." Date: Wed, 16 Sep 2026 16:19:18 +0200 Subject: [PATCH] Move ElementCall Component to the rust based call view model --- .github/workflows/test.yaml | 13 +- .storybook/preview.tsx | 5 + component/index.tsx | 85 +- element-call-oxidation-plan.md | 168 ++- locales/en/app.json | 12 + playwright.config.ts | 27 + src/Avatar.tsx | 37 +- src/DisconnectedBanner.tsx | 10 +- src/analytics/PosthogEvents.test.ts | 15 +- src/analytics/PosthogEvents.ts | 42 +- src/button/ReactionToggleButton.test.tsx | 12 +- src/config/Config.test.ts | 24 +- src/config/Config.ts | 15 +- src/config/ConfigOptions.ts | 20 + src/driver/ElementCallMatrixClientDriver.ts | 3 +- src/driver/MatrixDriverContext.tsx | 41 + src/driver/MockRtcMatrixDriver.ts | 7 +- .../JsSdkElementCallMatrixClientDriver.ts | 15 +- src/driver/jsSdk/useJsSdkDrivers.ts | 37 + src/driver/useHomeserverConnected.test.tsx | 63 + src/driver/useHomeserverConnected.ts | 58 + src/e2ee/sharedKeyManagement.ts | 35 +- src/matrix-rtc-sdk/generated/VERSION | 4 +- .../generated/matrix_rtc-ffi.ts | 8 + src/matrix-rtc-sdk/generated/matrix_rtc.ts | 251 +++- .../generated/wasm-bindgen/index.js | 1298 +++++++++-------- .../generated/wasm-bindgen/index_bg.wasm | Bin 1597456 -> 1609348 bytes src/matrix-rtc-sdk/index.test.ts | 62 +- src/matrix-rtc-sdk/index.ts | 6 + src/matrix-rtc-sdk/logSink.ts | 55 + src/profile/useOwnProfile.ts | 33 + .../ParticipationReactionsReader.test.ts | 158 ++ src/reactions/ParticipationReactionsReader.ts | 250 ++++ src/reactions/useReactionsSender.tsx | 134 +- src/room/CallEndedView.tsx | 7 +- src/room/CallView.stories.tsx | 225 +++ src/room/CallView.test.tsx | 88 +- src/room/CallView.tsx | 249 +++- src/room/InCallView.test.tsx | 17 +- src/room/InCallView.tsx | 171 ++- src/room/InviteModal.test.tsx | 14 +- src/room/InviteModal.tsx | 20 +- src/room/LobbyView.tsx | 19 +- src/room/RoomPage.tsx | 33 +- src/room/useJoinRule.ts | 18 - src/room/useRoomAvatar.ts | 18 - src/room/useRoomInfo.test.tsx | 64 + src/room/useRoomInfo.ts | 36 + src/room/useRoomState.ts | 37 - src/settings/DeveloperSettingsTab.tsx | 162 +- src/settings/ProfileSettingsTab.tsx | 57 +- src/settings/SettingsModal.tsx | 5 +- .../DeveloperSettingsTab.test.tsx.snap | 146 +- src/settings/settings.ts | 17 +- src/settings/submit-rageshake.ts | 62 +- .../remoteMembers/ParticipationMembers.ts | 6 +- src/state/rtc/CallParticipation.test.ts | 5 + src/state/rtc/CallParticipation.ts | 37 + src/state/rtc/implementation.ts | 31 + src/state/rtc/mediaId.ts | 18 + src/state/rtc/useCallParticipation.test.tsx | 56 + src/state/rtc/useCallParticipation.ts | 86 ++ src/tile/GridTile.test.tsx | 46 +- src/useEvents.ts | 20 - src/useMatrixRTCSessionMemberships.ts | 29 +- 65 files changed, 3676 insertions(+), 1126 deletions(-) create mode 100644 src/driver/MatrixDriverContext.tsx create mode 100644 src/driver/jsSdk/useJsSdkDrivers.ts create mode 100644 src/driver/useHomeserverConnected.test.tsx create mode 100644 src/driver/useHomeserverConnected.ts create mode 100644 src/matrix-rtc-sdk/logSink.ts create mode 100644 src/profile/useOwnProfile.ts create mode 100644 src/reactions/ParticipationReactionsReader.test.ts create mode 100644 src/reactions/ParticipationReactionsReader.ts create mode 100644 src/room/CallView.stories.tsx delete mode 100644 src/room/useJoinRule.ts delete mode 100644 src/room/useRoomAvatar.ts create mode 100644 src/room/useRoomInfo.test.tsx create mode 100644 src/room/useRoomInfo.ts delete mode 100644 src/room/useRoomState.ts create mode 100644 src/state/rtc/implementation.ts create mode 100644 src/state/rtc/mediaId.ts create mode 100644 src/state/rtc/useCallParticipation.test.tsx create mode 100644 src/state/rtc/useCallParticipation.ts diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index 3f86f093d..7ba5f424a 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -44,9 +44,17 @@ jobs: flags: unittests fail_ci_if_error: true playwright: - name: Run end-to-end tests + name: Run end-to-end tests (${{ matrix.call_implementation }}) timeout-minutes: 60 runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + # Both MatrixRTC implementations, until matrix-rtc becomes the + # default and matrix-js-sdk goes (oxidation plan §5.15). The + # matrix-rtc run does not block until it has passed once. + call_implementation: [matrix-js-sdk, matrix-rtc] + continue-on-error: ${{ matrix.call_implementation == 'matrix-rtc' }} steps: - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 with: @@ -80,11 +88,12 @@ jobs: - name: Run Playwright tests env: USE_DOCKER: 1 + CALL_VIEW_MODEL_IMPLEMENTATION: ${{ matrix.call_implementation }} run: pnpm exec playwright test - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 if: ${{ !cancelled() }} with: - name: html-report + name: html-report-${{ matrix.call_implementation }} path: playwright-report if-no-files-found: error retention-days: 4 diff --git a/.storybook/preview.tsx b/.storybook/preview.tsx index 5b841b829..3f6139968 100644 --- a/.storybook/preview.tsx +++ b/.storybook/preview.tsx @@ -10,6 +10,7 @@ import { TooltipProvider } from "@vector-im/compound-web"; import { logger } from "matrix-js-sdk/lib/logger"; import EN from "../locales/en/app.json"; +import { Config } from "../src/config/Config"; import { initReactI18next } from "react-i18next"; import { i18n } from "../src/utils/i18n"; import "../src/index.css"; @@ -35,6 +36,10 @@ i18n }) .catch((e) => logger.warn("Failed to init i18n for stories", e)); +// Stories run without a config.json; the defaults stand in, as they do for +// a component host that passes none. +Config.initWith({}); + const preview: Preview = { parameters: { layout: "centered", diff --git a/component/index.tsx b/component/index.tsx index 60e6d4810..840a8a176 100644 --- a/component/index.tsx +++ b/component/index.tsx @@ -43,7 +43,7 @@ import { useRef, useState, } from "react"; -import { type MatrixClient } from "matrix-js-sdk"; +import { type MatrixClient, type Room } from "matrix-js-sdk"; import { logger } from "matrix-js-sdk/lib/logger"; import { I18nextProvider } from "react-i18next"; import { TooltipProvider } from "@vector-im/compound-web"; @@ -56,7 +56,6 @@ import LanguageDetector from "i18next-browser-languagedetector"; import EN from "../locales/en/app.json"; import { CallView } from "../src/room/CallView"; import { ErrorPage } from "../src/FullScreenView"; -import { ClientProvider } from "../src/ClientContext"; import { HostBridgeProvider } from "../src/HostBridge"; import { RootElementProvider, useRootElement } from "../src/RootElementContext"; import { @@ -80,8 +79,15 @@ import { useTheme } from "../src/useTheme"; import { useStableValue } from "../src/useStableValue"; import { type RtcMatrixDriver } from "../src/driver/RtcMatrixDriver"; import { type ElementCallMatrixClientDriver } from "../src/driver/ElementCallMatrixClientDriver"; -import { JsSdkRtcMatrixDriver } from "../src/driver/jsSdk/JsSdkRtcMatrixDriver"; -import { JsSdkElementCallMatrixClientDriver } from "../src/driver/jsSdk/JsSdkElementCallMatrixClientDriver"; +import { useJsSdkDrivers } from "../src/driver/jsSdk/useJsSdkDrivers"; +import { + initMatrixRtcSdk, + type MatrixRtcWasmSource, +} from "../src/matrix-rtc-sdk"; +import { + type MatrixDrivers, + MatrixDriverProvider, +} from "../src/driver/MatrixDriverContext"; import styles from "./ElementCall.module.css"; import { type ElementCallHandle, @@ -231,10 +237,24 @@ export type ElementCallClientBasedProps = Omit< * * Await this once, before rendering {@link ElementCall}. */ +export interface InitializeElementCallOptions { + /** + * Where to load the MatrixRTC SDK's wasm from, for a host that serves it + * from somewhere other than next to this bundle. Left out, the bundled + * copy is loaded when the first call needs it. + */ + matrixRtcWasm?: MatrixRtcWasmSource; +} + export async function initializeElementCall( config: ConfigOptions = {}, + { matrixRtcWasm }: InitializeElementCallOptions = {}, ): Promise { const polyfills: Promise[] = []; + // The call runs on the Rust MatrixRTC crate; its wasm is loaded up front + // when the host says where from, and lazily otherwise. + if (matrixRtcWasm !== undefined) + polyfills.push(initMatrixRtcSdk(matrixRtcWasm)); if (shouldPolyfillSegmenter()) polyfills.push(import("@formatjs/intl-segmenter/polyfill-force")); if (shouldPolyfillDurationFormat()) @@ -343,22 +363,11 @@ export const ElementCall: FC = ({ }; }, [controlledAudioDevices, callIntent]); - // Until the React tree below reads the drivers (plan slice S4), it runs on - // matrix-js-sdk directly, so for now the drivers have to be the matrix-js-sdk - // ones and the client is taken back out of them. `ElementCallClientBased` - // is the way to get here in the meantime; a host with drivers of its own - // cannot be served yet. - if (!(clientDriver instanceof JsSdkElementCallMatrixClientDriver)) - throw new Error( - "Element Call cannot yet run on drivers other than the matrix-js-sdk ones; use ElementCallClientBased", - ); - // `rtcDriver` is what the call will run on once the tree reads it; for now - // it is only checked to be there. - void rtcDriver; - const { client, room } = clientDriver; - const rtcSession = useMemo( - () => client.matrixRTC.getRoomSession(room), - [client, room], + // The call runs on the Rust MatrixRTC crate over these two drivers; no + // matrix-js-sdk client is involved. + const drivers = useMemo( + (): MatrixDrivers => ({ rtcDriver, clientDriver }), + [rtcDriver, clientDriver], ); // Everything the call needs is in hand once these exist, and the first @@ -366,8 +375,7 @@ export const ElementCall: FC = ({ // is told that Element Call has loaded, as the widget tells its client once // its own initialisation is over. Once per mount, however often the pieces // are later swapped out. - const ready = - container !== null && rtcSession !== null && mediaDevices !== null; + const ready = container !== null && mediaDevices !== null; const announcedLoaded = useRef(false); useEffect(() => { if (!ready || announcedLoaded.current) return; @@ -393,12 +401,10 @@ export const ElementCall: FC = ({ > - + = ({ /> - + @@ -425,28 +431,19 @@ export const ElementCallClientBased: FC = ({ ...props }): ReactNode => { const room = client.getRoom(roomId); - const drivers = useMemo( - () => - room === null - ? null - : { - rtcDriver: new JsSdkRtcMatrixDriver(client, room), - clientDriver: new JsSdkElementCallMatrixClientDriver(client, room), - }, - [client, room], - ); - // The RTC driver hooks client listeners for the crate's sinks; let go of - // them with the drivers. - useEffect(() => { - if (drivers === null) return; - return (): void => drivers.rtcDriver.detach(); - }, [drivers]); - - if (drivers === null) { + if (room === null) { logger.error( `Element Call was asked to call in ${roomId}, which its host's client does not know about`, ); return null; } + return ; +}; + +/** {@link ElementCallClientBased} once the room is known: builds the drivers. */ +const ClientBasedCall: FC< + Omit & { room: Room } +> = ({ client, room, ...props }): ReactNode => { + const drivers = useJsSdkDrivers(client, room); return ; }; diff --git a/element-call-oxidation-plan.md b/element-call-oxidation-plan.md index a1d51ac2c..df5aaf74f 100644 --- a/element-call-oxidation-plan.md +++ b/element-call-oxidation-plan.md @@ -175,6 +175,7 @@ membership, roster, encryption, impairments} | Leaving`. | C11 | No way to change `application["m.call.intent"]` while joined; Element Call flips it between `audio` and `video` when the camera is toggled (`updateCallIntent`). | `update_application(intent)` on the own-membership manager, facade and FFI: while connected the membership is re-published at once on the refresh path (a failure retries like a refresh); during a join the join event carries it; refused with `NotJoined` otherwise. | | C12 | Homeserver connectivity lived only in Element Call's driver; the crate could not tell a dead homeserver from a quiet one, and a participation's status said nothing about it. | **Done.** `ConnectivityDriver` (`is_homeserver_connected`, `subscribe_connectivity`) joins the `MatrixDriver` sum; the FFI adds `ConnectivitySink`, the two callback methods and `FfiParticipationManager.is_homeserver_connected()`; the facade pump consumes the stream and reports `Impairment::HomeserverUnreachable { since_ts }` (Critical, sorted first) in every non-disconnected status until the driver reports the homeserver back. The web-test-app mock and js-sdk driver implement it. A matrix-rust-sdk adapter implements the same two methods later. | | C13 | `session()` moved (seed done, slot opened by somebody else) without any listener firing, so a host's `session$` stayed stale until a membership or status change happened to refresh it. Found by the real-backend check. | **Done.** `SessionListener` / `set_session_listener` on the FFI manager (`on_session_change` on the facade), fired publish-on-change from `refresh_outputs`; `CallParticipation.session$` is fed from it. | +| C14 | The crate logs through the `log` facade (104 call sites) but installed no logger, so in wasm every line was dropped: seeding, joins, delegation fallbacks and key rotation left no trace in a rageshake. | **Done (2026-09-16).** `LogSink` foreign trait (`log(level, target, message)`), `FfiLogLevel`, and `set_log_sink(sink, max_level)`, which installs a `log::Log` forwarding to the sink (a host that already installed a Rust logger keeps it). Element Call installs `matrixRtcLogSink` under `[matrix-rtc]` on the js-sdk root logger from `initMatrixRtcSdk()` at debug; the web-test-app installs a console sink (warn in tests). | No crate work is deferred: `update_application` is C11. @@ -512,8 +513,11 @@ RateLimited`, 403 → `Rejected`, 404/`M_UNRECOGNIZED` → `Unsupported`. `assetsInlineLimit`; `?url&no-inline` emits a file. App builds use `?url`; the component build uses `?url&no-inline` plus an `exports` entry for `./dist/assets/*`, and `initializeElementCall(config, { matrixRtcWasm })` - lets a host point elsewhere. vitest reads the file from disk; wasm boot is - **lazy** (only suites that need it call `initMatrixRtcSdk()`), never in + lets a host point elsewhere. Wasm boot is **lazy** everywhere: in the app + `useCallParticipation` awaits `initMatrixRtcSdk()` before constructing + the participation (so the js-sdk path never fetches it, §5.15), not the + `Initializer`; vitest reads the file from disk and only suites that need + it call `initMatrixRtcSdk()`, never in `src/vitest.setup.ts`; Storybook boots it in `.storybook/preview.tsx` `beforeAll`. Suites using `vi.useFakeTimers` never share a file with real-wasm tests (pumps sleep on `setTimeout`). @@ -557,6 +561,24 @@ RateLimited`, 403 → `Rejected`, 404/`M_UNRECOGNIZED` → `Unsupported`. redactions), as they are with the js-sdk MatrixRTC code today. The driver decrypts them on the way in; the sticky marker (`msc4354_sticky`) stays in the clear. To cross-check against Element X before relying on it. +15. **The two view models stay switchable for one release.** A developer + setting, `callViewModelImplementation` (`"matrix-js-sdk"` | + `"matrix-rtc"`, `src/settings/settings.ts`, next to `matrixRTCMode`), + picks between `createJsClientCallViewModel$` and the driver-based + `createCallViewModel$` in the same build. Like `matrixRTCMode` it is + shown in the Developer Settings tab, sampled when the call is joined + (switching mid-call needs a rejoin), and a deployment can pin it through + `config.json` (`call_view_model_implementation`), which overrides the + user's choice and greys the control out. The default is + `"matrix-js-sdk"` when the setting lands (S4a) and flips to + `"matrix-rtc"` once the S5 gate is green; S6 removes the setting together + with the js-sdk path. The point is that a broken call can be compared + against the old path in the same session, and that Playwright can run + both paths from one build. Everything the js-sdk path needs (the client, + the `MatrixRTCSession`, `ReactionsReader` over the session) therefore + stays reachable from `CallView` until S6, and the `CallParticipation` is + created only when the crate path is selected, so neither path pays for + the other. --- @@ -663,19 +685,116 @@ participation, clientDriver, …)` sits next to it; both build a LiveKit: join → connection → own tile → peer → leave; transport-missing → `fatalError$`), plus one file per module. -### S4 — React tree, two slices ☐ +### S4 — React tree, two slices ☑ (2026-09-16) +- **S4a-0, the switch (§5.15) ☑:** `CallViewModelImplementation` enum, + `callViewModelImplementation` setting (`src/settings/settings.ts`), + `call_view_model_implementation` pin (`ConfigOptions.ts`, validated in + `Config.ts`), the radio group in `DeveloperSettingsTab.tsx`, the + implementation logged at join and sent as `call_view_model_implementation` + in rageshakes, `effectiveCallViewModelImplementation()` in + `src/state/rtc/implementation.ts`. `CallView` samples it once per mount; + with `matrix-rtc` and no drivers it warns and lets matrix-js-sdk carry the + call. Still open from this item: the Playwright helper and the second CI + run. +- **S4a done so far:** `MatrixDriverProvider` / `useMatrixDrivers()` + (`src/driver/MatrixDriverContext.tsx`), provided by the component from its + props and by `RoomPage` through `useJsSdkDrivers(client, room)`; + `useCallParticipation(drivers, config)` owned by `CallView`, created only + when the crate path is selected; `ActiveCall` takes `participation` and + builds either view model; the lobby's member count, the big-call auto-mute + and the error boundary's "were we joined" read from whichever side carries + the call; `window.matrixRtc = { participation }` next to `window.rtcSession`. +- (The original S4a-0 description follows for reference.) `callViewModelImplementation` setting and + `config.json` pin (`ConfigOptions.ts`, validated at load like + `matrix_rtc_mode`); a radio group in `DeveloperSettingsTab.tsx` beside the + MatrixRTC mode; `ActiveCall` reads the sampled value and calls either + factory — for `"matrix-rtc"` it takes the drivers from the + `MatrixDriverProvider` and the `CallParticipation` from `CallView`, for + `"matrix-js-sdk"` it keeps `rtcSession`/`matrixRoom` as today. The chosen + implementation is logged at join and added to the rageshake fields so a + report says which path it came from. Playwright gets a helper that sets + the setting (local storage) before the call so every call spec can run + under both values; CI runs the suite twice until the default flips. + Lands first in S4a, before anything else in the tree moves, so that every + later S4 change is verifiable against the old path. - **S4a** views/hooks/settings on the driver: `CallView.tsx` (owns - `CallParticipation`), `InCallView.tsx`, `LobbyView.tsx`, `CallEndedView.tsx`, + `CallParticipation` when the crate path is selected), `InCallView.tsx`, `LobbyView.tsx`, `CallEndedView.tsx`, `VideoPreview.tsx`, `useRoomInfo()` (replaces `useRoomName/Avatar/JoinRule/State`), `InviteModal.tsx`, `Avatar.tsx`, `useOwnProfile.ts`, `ProfileSettingsTab.tsx`, `SettingsModal.tsx`, `DeveloperSettingsTab.tsx`, `submit-rageshake.ts`, `DisconnectedBanner.tsx`, `analytics/PosthogEvents.ts`, `controls.ts`, and a first `CallView.stories.tsx` (lobby, in call, ended) driven by `MockMatrixDriver`. -- **S4b** reactions and notifications: `useReactionsSender.tsx`, - `ReactionsReader` keyed by `memberId`, `CallNotificationLifecycle` sending - through the driver; tests incl. a membership re-send mid-call. +- **S4b ☑ (2026-09-16):** `ReactionsSenderProvider` takes `ownIdentifier`, + `ownMembershipEventId` and a `ReactionsTimeline` (`jsSdkReactionsTimeline` + over a client, or the client driver); `ParticipationReactionsReader` + (`src/reactions/`) reads hands and reactions from the participation and + the timeline driver, keyed by the member's media id + (`memberMediaId`, `src/state/rtc/mediaId.ts`), and re-resolves a hand on a + re-sent membership instead of dropping it blindly. Notifications went + through the driver in S3d. Tests: `ParticipationReactionsReader.test.ts`, + `useCallParticipation.test.tsx`, three `CallView.test.tsx` cases for the + switch. +- **S4a views on the drivers (2026-09-16):** `CallView` now requires the + drivers (`useMatrixDrivers()`; both hosts provide them) and reads the + room through `useRoomInfo()` (`src/room/useRoomInfo.ts`; `useRoomAvatar`, + `useJoinRule`, `useRoomState` deleted, `useRoomName` stays for `RoomPage`), + our own profile through `useOwnProfile()` (`src/profile/useOwnProfile.ts`) + and the encryption system through `useEncryptionSystemFor(roomId, +roomInfo.encrypted)` (`useRoomEncryptionSystem` keeps the client for the + home page). `MatrixInfo` is built from those. `InviteModal` takes + `roomId`/`roomName`/`e2eeSystem`; `CallEndedView` lost its `client` prop; + `Avatar` resolves thumbnails through `clientDriver.thumbnailUrl` when + drivers are provided (host `downloadMedia` first, client fallback for the + shell); rageshakes carry the driver's `getDiagnostics()` as `driver_*` + fields and the crate's `matrix_rtc_snapshot`. +- **The component is client-free (2026-09-16):** `CallView`'s `client` and + `rtcSession` are optional; without them the crate carries the call + whatever the setting says (`useMatrixRtc = setting || no session`), and + every js-sdk-only piece (the `MembershipManagerError` listener, the room + sanity check, `ReactionsReader`, `mediaKeyStatisticsOf`) is skipped. + `ActiveCall`/`InCallView` take `roomId` instead of `matrixRoom`, and + `client`/`rtcSession` optionally. `ProfileSettingsTab` edits through the + client driver's optional `setDisplayName`/`setAvatar(file | null)` and + shows read-only fields without them; `DeveloperSettingsTab` reads the + sticky probe from `getCapabilities()`, the crypto version from + `getDiagnostics()` and validates a custom LiveKit URL through + `rtcDriver.getLivekitToken` when there is no client; the rageshake request + event goes through the client driver's timeline; reactions are supported + unless a client state forbids them. `ElementCall` renders no + `ClientProvider` and no shim — it hands its two drivers down and nothing + below asks for a client; `initializeElementCall(config, { matrixRtcWasm })` + can preload the wasm. `PosthogEvents.eventCallEnded.track` takes + `MediaKeyStatistics` (from the session on the js-sdk path, zero on the + crate path until the crate counts). `useTypedEventEmitter` and the js-sdk + client driver's public `client`/`room` are gone. **Consequence:** the + component and its dev harness (`ElementCallClientBased`) now run every + call on the crate. +- **Banner on the driver (2026-09-16):** `useHomeserverConnected(drivers, +graceMs)` (`src/driver/`) follows `rtcDriver.isHomeserverConnected()` / + `subscribeConnectivity` and reports a lapse only after + `sync_disconnect_grace_period_ms`, since the driver reports every sync + hiccup where the client state waited for a `ConnectionError`; + `DisconnectedBanner` uses it whenever drivers are provided and falls back + to the client state for the shell. The mock RTC driver keeps several + connectivity sinks (the crate's and the UI's). +- **S4 closed (2026-09-16):** `CallView.stories.tsx` (Lobby with a peer, + NoTransport as the error path, Ended) over the mock drivers, no client; + `.storybook/preview.tsx` initialises the config; the Storybook vitest + project passes. The Playwright switch is `CALL_VIEW_MODEL_IMPLEMENTATION` + read by `playwright.config.ts` into `use.storageState` (the developer + setting in local storage for every context), and the CI Playwright job is + a matrix over both implementations (`matrix-rtc` non-blocking until it + has passed once). `CallParticipation.mediaKeyStatistics()` counts sent + and received keys and their age from the crate's key changes for the + ended-call event. Found on the way: `CallView` rendered `ActiveCall` + before the participation existed (wasm loads on first use) — it now waits; + and `onLeft` had gained the member count as a dependency, which rebuilt + the view model on every roster change on both paths — read through + `useLatest` now. `create-call.spec.ts` passes in Chromium on both + implementations with two view model creations each (StrictMode): the + crate path's first full call in a browser. ### S5 — hosts ☐ (component props done 2026-09-15) @@ -708,6 +827,9 @@ participation, clientDriver, …)` sits next to it; both build a `src/IndexedDBWorker.ts`, `src/room/KnockLobbyView.tsx`, `src/settings/rageshake.ts`) banning `matrix-js-sdk` except `matrix-js-sdk/lib/logger`. - `ServiceInterruptionsViewModel` fed from `status$.impairments`. +- `callViewModelImplementation` setting, its `config.json` pin and the + Developer Settings control removed with `createJsClientCallViewModel$` + (§5.15); Playwright runs the suite once again. - `docs/agents/architecture.md`, `docs/matrix_rtc_modes.md` updated; `src/@types/matrix-js-sdk.d.ts` removed if nothing merges into js-sdk types. @@ -807,3 +929,35 @@ props moved to the two drivers with `ElementCallClientBased` on top. Gates: participation (S4b), the `?url&no-inline` wasm asset for the component build (the wasm is loaded lazily and inlined into the component bundle today), and the S6 deletions. + +**S4 (2026-09-16):** the implementation switch (§5.15) is in with its +config pin, developer control and rageshake field; `CallView` owns a +`CallParticipation` when the crate path is selected and `ActiveCall` builds +the matching view model; the reactions reader and sender have participation +and driver counterparts. Both paths run in the same build. Gates: `pnpm +lint`, `format:check`, `i18n:check`, `test:unit` (815), `build:component` +green. Not verified: a real call on the crate path through the UI (the +`pnpm backend` check covers the view model's Matrix side; the browser run is +the S5 gate). + +**Logging (2026-09-16):** C14 — the crate's log lines reach the host through +a `LogSink`; Element Call routes them to its rageshake logger under +`[matrix-rtc]`, the web-test-app to the console. Verified by a unit test that +sees the crate's "session created" line through the sink. + +**S4 views (2026-09-16):** room info, own profile, encryption system, +avatars, the invite and ended views and the rageshake fields read the +drivers; `CallView` requires drivers. Three room hooks deleted. Gates: +`pnpm lint`, `format:check`, `test:unit` (819), `build:component` green. + +**Client-free component (2026-09-16):** `CallView` and everything under it +run without a matrix-js-sdk client on the crate path; the component passes +only its drivers. Gates: `pnpm lint`, `format:check`, `test:unit` (819), +`build:component` green. Not yet done: a browser run of the component on +the crate path (the dev harness now is that run). + +**S4 done (2026-09-16):** stories, Playwright switch and CI matrix, key +statistics. `create-call.spec.ts` green on `matrix-js-sdk` and `matrix-rtc` +in Chromium against the dev server; the rest of the suite under +`matrix-rtc` is the S5 gate. Gates: `pnpm lint`, `format:check`, +`test:unit` (822), `test:storybook` (28), `build:component` green. diff --git a/locales/en/app.json b/locales/en/app.json index 7b1775be5..6b9909d40 100644 --- a/locales/en/app.json +++ b/locales/en/app.json @@ -58,6 +58,18 @@ }, "developer_mode": { "always_show_iphone_earpiece": "Show iPhone earpiece option on all platforms", + "callViewModelImplementation": { + "forced": "Your deployment pins the call implementation.", + "matrix_js_sdk": { + "description": "The MatrixRTC session of matrix-js-sdk carries the call, as before", + "label": "matrix-js-sdk" + }, + "matrix_rtc": { + "description": "The Rust matrix-rtc crate carries the call through the host's drivers", + "label": "matrix-rtc (Rust)" + }, + "title": "Call implementation" + }, "crypto_version": "Crypto version: {{version}}", "custom_livekit_url": { "current_url": "Currently set to: ", diff --git a/playwright.config.ts b/playwright.config.ts index e6dcc5249..7f557e083 100644 --- a/playwright.config.ts +++ b/playwright.config.ts @@ -19,6 +19,32 @@ const baseURL = process.env.USE_DOCKER const __dirname = path.dirname(fileURLToPath(import.meta.url)); +/** + * Which MatrixRTC implementation carries the calls under test, `matrix-js-sdk` + * or `matrix-rtc` (see `CallViewModelImplementation` in + * src/config/ConfigOptions.ts). Unset, Element Call's default applies. Set, + * every browser context starts with the developer setting in local storage, + * so the whole suite runs on that implementation. + */ +const callViewModelImplementation = process.env.CALL_VIEW_MODEL_IMPLEMENTATION; +const storageState = + callViewModelImplementation === undefined + ? undefined + : { + cookies: [], + origins: [ + { + origin: baseURL, + localStorage: [ + { + name: "matrix-setting-call-view-model-implementation", + value: JSON.stringify(callViewModelImplementation), + }, + ], + }, + ], + }; + // Needed by the synapse admin API called in fixtures process.env.NODE_EXTRA_CA_CERTS = join( __dirname, @@ -44,6 +70,7 @@ export default defineConfig({ use: { /* Base URL to use in actions like `await page.goto('/')`. */ baseURL, + storageState, /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */ trace: "on-first-retry", diff --git a/src/Avatar.tsx b/src/Avatar.tsx index 185ae97b4..a34948f70 100644 --- a/src/Avatar.tsx +++ b/src/Avatar.tsx @@ -16,6 +16,7 @@ import { Avatar as CompoundAvatar } from "@vector-im/compound-web"; import { type MatrixClient } from "matrix-js-sdk"; import { useClientState } from "./ClientContext"; +import { useOptionalMatrixDrivers } from "./driver/MatrixDriverContext"; import { useHostBridge } from "./HostBridge"; export enum Size { @@ -76,6 +77,9 @@ export const Avatar: FC = ({ }) => { const clientState = useClientState(); const hostBridge = useHostBridge(); + // Under a call the host's client driver resolves media; the shell outside + // a call still has only the client. + const drivers = useOptionalMatrixDrivers(); const sizePx = useMemo( () => @@ -95,16 +99,30 @@ export const Avatar: FC = ({ return; } - let blob: Promise; + let url: Promise; if (hostBridge.downloadMedia) { - blob = hostBridge.downloadMedia(src); + url = hostBridge + .downloadMedia(src) + .then((blob) => URL.createObjectURL(blob)); + } else if (drivers !== null) { + const px = Math.floor(sizePx * window.devicePixelRatio); + url = drivers.clientDriver.thumbnailUrl( + src, + px, + px, + sizePx <= 96 ? "crop" : "scale", + ); } else if ( clientState?.state === "valid" && clientState.authenticated?.client && sizePx ) { - blob = getAvatarFromServer(clientState.authenticated.client, src, sizePx); + url = getAvatarFromServer( + clientState.authenticated.client, + src, + sizePx, + ).then((blob) => URL.createObjectURL(blob)); } else { setAvatarUrl(undefined); return; @@ -112,13 +130,14 @@ export const Avatar: FC = ({ let objectUrl: string | undefined; let stale = false; - blob - .then((blob) => { - if (stale) { + url + .then((resolved) => { + if (stale || resolved === null) { return; } - objectUrl = URL.createObjectURL(blob); - setAvatarUrl(objectUrl); + // Only what we created (or the driver created for us) is ours to revoke. + if (resolved.startsWith("blob:")) objectUrl = resolved; + setAvatarUrl(resolved); }) .catch((ex) => { if (stale) { @@ -133,7 +152,7 @@ export const Avatar: FC = ({ URL.revokeObjectURL(objectUrl); } }; - }, [clientState, hostBridge, src, sizePx]); + }, [clientState, hostBridge, drivers, src, sizePx]); return ( { children?: ReactNode; @@ -23,10 +25,16 @@ export const DisconnectedBanner: FC = ({ ...rest }) => { const { t } = useTranslation(); + // Under a call the host's RTC driver says whether the homeserver is + // reachable; the shell outside a call only has the client's sync state. + const drivers = useOptionalMatrixDrivers(); + const homeserverConnected = useHomeserverConnected(drivers); const clientState = useClientState(); let shouldShowBanner = false; - if (clientState?.state === "valid") { + if (drivers !== null) { + shouldShowBanner = !homeserverConnected; + } else if (clientState?.state === "valid") { const validClientState = clientState as ValidClientState; shouldShowBanner = validClientState.disconnected; } diff --git a/src/analytics/PosthogEvents.test.ts b/src/analytics/PosthogEvents.test.ts index 83ef4d7c7..da5abf6e8 100644 --- a/src/analytics/PosthogEvents.test.ts +++ b/src/analytics/PosthogEvents.test.ts @@ -19,6 +19,7 @@ import { type MatrixRTCSession } from "matrix-js-sdk/lib/matrixrtc"; import { PosthogAnalytics } from "./PosthogAnalytics"; import { + mediaKeyStatisticsOf, CallEndedTracker, CallReconnectingTracker, type CallReconnectingReason, @@ -67,7 +68,7 @@ describe("CallEnded", () => { const tracker = new CallEndedTracker(); const mockSession = createMockRtcSession(); - tracker.track("test-call-id", 2, false, mockSession); + tracker.track("test-call-id", 2, false, mediaKeyStatisticsOf(mockSession)); expect(warnSpy).toHaveBeenCalledWith( "[PosthogEvents] Failed to send posthog callEnded event due to missing startTime", @@ -81,7 +82,7 @@ describe("CallEnded", () => { tracker.cacheStartCall(new Date(Date.now() - 60000)); tracker.cacheParticipantCountChanged(5); - tracker.track("test-call-id", 3, true, mockSession); + tracker.track("test-call-id", 3, true, mediaKeyStatisticsOf(mockSession)); expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith( { @@ -111,7 +112,7 @@ describe("CallEnded", () => { tracker.cacheParticipantCountChanged(3); tracker.cacheParticipantCountChanged(7); tracker.cacheParticipantCountChanged(2); - tracker.track("test-call-id", 1, false, mockSession); + tracker.track("test-call-id", 1, false, mediaKeyStatisticsOf(mockSession)); expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith( expect.objectContaining({ @@ -128,7 +129,7 @@ describe("CallEnded", () => { }); tracker.cacheStartCall(new Date()); - tracker.track("test-call-id", 1, false, mockSession); + tracker.track("test-call-id", 1, false, mediaKeyStatisticsOf(mockSession)); expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith( expect.objectContaining({ @@ -146,7 +147,7 @@ describe("CallEnded", () => { }); tracker.cacheStartCall(new Date()); - tracker.track("test-call-id", 1, false, mockSession); + tracker.track("test-call-id", 1, false, mediaKeyStatisticsOf(mockSession)); expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith( expect.objectContaining({ @@ -161,7 +162,7 @@ describe("CallEnded", () => { const mockSession = createMockRtcSession(); tracker.cacheStartCall(new Date()); - tracker.track("test-call-id", 1, false, mockSession); + tracker.track("test-call-id", 1, false, mediaKeyStatisticsOf(mockSession)); expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith( expect.anything(), @@ -178,7 +179,7 @@ describe("CallEnded", () => { tracker.cacheReconnecting("sync"); tracker.cacheReconnecting("livekit"); tracker.cacheReconnecting("membership"); - tracker.track("test-call-id", 1, false, mockSession); + tracker.track("test-call-id", 1, false, mediaKeyStatisticsOf(mockSession)); expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith( expect.objectContaining({ diff --git a/src/analytics/PosthogEvents.ts b/src/analytics/PosthogEvents.ts index 56ca08af4..9ea9b1825 100644 --- a/src/analytics/PosthogEvents.ts +++ b/src/analytics/PosthogEvents.ts @@ -15,6 +15,34 @@ import { RegistrationType, } from "./PosthogAnalytics"; +/** How many media keys went out and came in over a call, for the ended event. */ +export interface MediaKeyStatistics { + sent: number; + received: number; + /** Sum of the ages of the received keys, in ms; averaged on send. */ + receivedTotalAge: number; +} + +/** No key statistics (the Rust crate does not count them yet). */ +export const NO_MEDIA_KEY_STATISTICS: MediaKeyStatistics = { + sent: 0, + received: 0, + receivedTotalAge: 0, +}; + +/** {@link MediaKeyStatistics} from a matrix-js-sdk session. */ +export function mediaKeyStatisticsOf( + rtcSession: MatrixRTCSession, +): MediaKeyStatistics { + const { counters, totals } = rtcSession.statistics; + return { + sent: counters.roomEventEncryptionKeysSent, + received: counters.roomEventEncryptionKeysReceived, + // Only meaningful with received keys; a mocked session may not carry it. + receivedTotalAge: totals?.roomEventEncryptionKeysReceivedTotalAge ?? 0, + }; +} + interface CallEnded extends IPosthogEvent { eventName: "CallEnded"; // the callId posthog key is essentially a Matrix roomId @@ -80,7 +108,7 @@ export class CallEndedTracker { callId: string, callParticipantsNow: number, sendInstantly: boolean, - rtcSession: MatrixRTCSession, + keys: MediaKeyStatistics, ): void { if (this.cache.startTime) { PosthogAnalytics.instance.trackEvent( @@ -90,16 +118,10 @@ export class CallEndedTracker { callParticipantsMax: this.cache.maxParticipantsCount, callParticipantsOnLeave: callParticipantsNow, callDuration: (Date.now() - this.cache.startTime.getTime()) / 1000, - roomEventEncryptionKeysSent: - rtcSession.statistics.counters.roomEventEncryptionKeysSent, - roomEventEncryptionKeysReceived: - rtcSession.statistics.counters.roomEventEncryptionKeysReceived, + roomEventEncryptionKeysSent: keys.sent, + roomEventEncryptionKeysReceived: keys.received, roomEventEncryptionKeysReceivedAverageAge: - rtcSession.statistics.counters.roomEventEncryptionKeysReceived > 0 - ? rtcSession.statistics.totals - .roomEventEncryptionKeysReceivedTotalAge / - rtcSession.statistics.counters.roomEventEncryptionKeysReceived - : 0, + keys.received > 0 ? keys.receivedTotalAge / keys.received : 0, callReconnectingCount: this.cache.reconnectingCount, callReconnectingCountSync: this.cache.reconnectingCountByReason.sync, callReconnectingCountMembership: diff --git a/src/button/ReactionToggleButton.test.tsx b/src/button/ReactionToggleButton.test.tsx index 5c8d375cb..e8562f596 100644 --- a/src/button/ReactionToggleButton.test.tsx +++ b/src/button/ReactionToggleButton.test.tsx @@ -17,7 +17,10 @@ import { type CallViewModel } from "../state/CallViewModel/CallViewModel"; import { getBasicCallViewModelEnvironment } from "../utils/test-viewmodel"; import { alice, local, localRtcMember } from "../utils/test-fixtures"; import { type MockRTCSession } from "../utils/test"; -import { ReactionsSenderProvider } from "../reactions/useReactionsSender"; +import { + jsSdkReactionsTimeline, + ReactionsSenderProvider, +} from "../reactions/useReactionsSender"; import { initializeWidget } from "../widget"; initializeWidget(); vi.mock("livekit-client/e2ee-worker?worker"); @@ -35,7 +38,12 @@ function TestComponent({ { afterEach(() => { @@ -101,3 +105,21 @@ describe("Config.initWith", () => { expect(Config.get().ssla).toBe("https://second.invalid/ssla"); }); }); + +describe("validateConfig call_view_model_implementation", () => { + it.each(Object.values(CallViewModelImplementation))( + "keeps a valid call_view_model_implementation value (%s)", + (value) => { + const result = validateConfig({ call_view_model_implementation: value }); + expect(result.call_view_model_implementation).toBe(value); + }, + ); + + it("drops an unknown call_view_model_implementation value", () => { + const result = validateConfig({ + call_view_model_implementation: + "yes-please" as unknown as CallViewModelImplementation, + }); + expect(result.call_view_model_implementation).toBeUndefined(); + }); +}); diff --git a/src/config/Config.ts b/src/config/Config.ts index e2c5eb8fa..5a2cda8ca 100644 --- a/src/config/Config.ts +++ b/src/config/Config.ts @@ -15,11 +15,14 @@ import { type ResolvedConfigOptions, } from "./ConfigOptions"; import { isFailure } from "../utils/fetch"; -import { MatrixRTCMode } from "./ConfigOptions"; +import { CallViewModelImplementation, MatrixRTCMode } from "./ConfigOptions"; const VALID_MATRIX_RTC_MODES: ReadonlySet = new Set( Object.values(MatrixRTCMode), ); +const VALID_CALL_VIEW_MODEL_IMPLEMENTATIONS: ReadonlySet = new Set( + Object.values(CallViewModelImplementation), +); export class Config { private static internalInstance: Config | undefined; @@ -136,6 +139,16 @@ export function validateConfig(config: ConfigOptions): ConfigOptions { ); delete config.matrix_rtc_mode; } + const implementation = config.call_view_model_implementation; + if ( + implementation !== undefined && + !VALID_CALL_VIEW_MODEL_IMPLEMENTATIONS.has(implementation) + ) { + logger.warn( + `Ignoring invalid call_view_model_implementation in config.json: ${String(implementation)}`, + ); + delete config.call_view_model_implementation; + } return config; } diff --git a/src/config/ConfigOptions.ts b/src/config/ConfigOptions.ts index 872e35168..10a176f64 100644 --- a/src/config/ConfigOptions.ts +++ b/src/config/ConfigOptions.ts @@ -24,6 +24,18 @@ export enum MatrixRTCMode { Matrix_2_0 = "matrix_2_0", } +/** + * Which MatrixRTC implementation carries a call: matrix-js-sdk's + * `MatrixRTCSession`, or the Rust `matrix-rtc` crate through the host's + * drivers. Both are in the build while the crate path is being proven, so a + * broken call can be compared against the other path in the same session; + * the js-sdk path and this choice go away together. + */ +export enum CallViewModelImplementation { + MatrixJsSdk = "matrix-js-sdk", + MatrixRtc = "matrix-rtc", +} + export interface DelayedLeaveTimings { /** * The delay (in milliseconds) with which delayed leave events are sent. @@ -202,6 +214,14 @@ export interface ConfigOptions { */ matrix_rtc_mode?: MatrixRTCMode; + /** + * Pins the {@link CallViewModelImplementation} for all clients on this + * deployment, overriding any per-user choice from the Developer Settings. + * If unset, the user's Developer Settings choice (or its default) wins. + * Temporary: goes away with the matrix-js-sdk implementation. + */ + call_view_model_implementation?: CallViewModelImplementation; + /** * These are low level options that are used to configure the MatrixRTC session. * Take care when changing these options. diff --git a/src/driver/ElementCallMatrixClientDriver.ts b/src/driver/ElementCallMatrixClientDriver.ts index bc3a5c480..7448b9202 100644 --- a/src/driver/ElementCallMatrixClientDriver.ts +++ b/src/driver/ElementCallMatrixClientDriver.ts @@ -125,7 +125,8 @@ export interface ProfileDriver { getOwnProfile(): OwnProfile; subscribeOwnProfile(listener: (profile: OwnProfile) => void): Unsubscribe; setDisplayName?(name: string): Promise; - setAvatar?(file: Blob): Promise; + /** Sets the avatar to `file`, or removes it with `null`. */ + setAvatar?(file: Blob | null): Promise; } export interface MediaDriver { diff --git a/src/driver/MatrixDriverContext.tsx b/src/driver/MatrixDriverContext.tsx new file mode 100644 index 000000000..e1980626d --- /dev/null +++ b/src/driver/MatrixDriverContext.tsx @@ -0,0 +1,41 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { createContext, use } from "react"; + +import { type ElementCallMatrixClientDriver } from "./ElementCallMatrixClientDriver"; +import { type RtcMatrixDriver } from "./RtcMatrixDriver"; + +/** The host's two drivers for the room a call is in. */ +export interface MatrixDrivers { + rtcDriver: RtcMatrixDriver; + clientDriver: ElementCallMatrixClientDriver; +} + +const MatrixDriverContext = createContext(null); + +/** + * Makes the drivers available to the call tree. Every host that renders a + * `CallView` provides them: the component from its props, the standalone + * app and the widget from the matrix-js-sdk drivers over their client. + */ +export const MatrixDriverProvider = MatrixDriverContext.Provider; + +/** The drivers, or null where no host provided any (a test rendering a leaf). */ +export function useOptionalMatrixDrivers(): MatrixDrivers | null { + return use(MatrixDriverContext); +} + +/** The drivers; throws where none were provided. */ +export function useMatrixDrivers(): MatrixDrivers { + const drivers = useOptionalMatrixDrivers(); + if (drivers === null) + throw new Error( + "No Matrix drivers were provided; wrap the call in a MatrixDriverProvider", + ); + return drivers; +} diff --git a/src/driver/MockRtcMatrixDriver.ts b/src/driver/MockRtcMatrixDriver.ts index 58d68c256..aaded05ea 100644 --- a/src/driver/MockRtcMatrixDriver.ts +++ b/src/driver/MockRtcMatrixDriver.ts @@ -145,7 +145,7 @@ export class MockRtcMatrixDriver implements RtcMatrixDriver { private roomEventSink?: RoomEventSinkLike; private toDeviceSink?: ToDeviceSinkLike; private stateUpdateSink?: StateUpdateSinkLike; - private connectivitySink?: ConnectivitySinkLike; + private readonly connectivitySinks = new Set(); private homeserverConnected = true; private nextDelayId = 0; @@ -403,7 +403,7 @@ export class MockRtcMatrixDriver implements RtcMatrixDriver { } public subscribeConnectivity(sink: ConnectivitySinkLike): void { - this.connectivitySink = sink; + this.connectivitySinks.add(sink); } public isHomeserverConnected(): boolean { @@ -413,7 +413,8 @@ export class MockRtcMatrixDriver implements RtcMatrixDriver { /** The homeserver comes or goes, as a syncing client would report it. */ public setHomeserverConnected(connected: boolean): void { this.homeserverConnected = connected; - this.connectivitySink?.emit(connected); + for (const sink of this.connectivitySinks) + if (!sink.emit(connected)) this.connectivitySinks.delete(sink); } /** Emit any room event — sticky or state; the crate dispatches on type. */ diff --git a/src/driver/jsSdk/JsSdkElementCallMatrixClientDriver.ts b/src/driver/jsSdk/JsSdkElementCallMatrixClientDriver.ts index 27a00d43d..6cb615c1d 100644 --- a/src/driver/jsSdk/JsSdkElementCallMatrixClientDriver.ts +++ b/src/driver/jsSdk/JsSdkElementCallMatrixClientDriver.ts @@ -64,13 +64,8 @@ export class JsSdkElementCallMatrixClientDriver implements ElementCallMatrixClie private capabilities: Promise | null = null; public constructor( - /** - * The client and room this driver wraps. Public only for the React tree - * that still runs on matrix-js-sdk directly (`CallView` and below); once - * that tree reads the drivers (plan slice S4) these become private. - */ - public readonly client: MatrixClient, - public readonly room: Room, + private readonly client: MatrixClient, + private readonly room: Room, options: JsSdkElementCallMatrixClientDriverOptions = {}, ) { const userId = client.getUserId(); @@ -271,7 +266,11 @@ export class JsSdkElementCallMatrixClientDriver implements ElementCallMatrixClie await this.client.setDisplayName(name); } - public async setAvatar(file: Blob): Promise { + public async setAvatar(file: Blob | null): Promise { + if (file === null) { + await this.client.setAvatarUrl(""); + return; + } const { content_uri: uri } = await this.client.uploadContent(file); await this.client.setAvatarUrl(uri); } diff --git a/src/driver/jsSdk/useJsSdkDrivers.ts b/src/driver/jsSdk/useJsSdkDrivers.ts new file mode 100644 index 000000000..b26565c8f --- /dev/null +++ b/src/driver/jsSdk/useJsSdkDrivers.ts @@ -0,0 +1,37 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { type MatrixClient, type Room } from "matrix-js-sdk"; +import { useEffect, useMemo } from "react"; + +import { type MatrixDrivers } from "../MatrixDriverContext"; +import { JsSdkElementCallMatrixClientDriver } from "./JsSdkElementCallMatrixClientDriver"; +import { JsSdkRtcMatrixDriver } from "./JsSdkRtcMatrixDriver"; + +/** + * The two matrix-js-sdk drivers for a room, for as long as the client and + * room stay the same. The RTC driver hooks listeners on the client for the + * crate's sinks; they are let go of when the drivers are replaced or the + * caller unmounts. + */ +export function useJsSdkDrivers( + client: MatrixClient, + room: Room, +): MatrixDrivers { + const drivers = useMemo( + (): MatrixDrivers => ({ + rtcDriver: new JsSdkRtcMatrixDriver(client, room), + clientDriver: new JsSdkElementCallMatrixClientDriver(client, room), + }), + [client, room], + ); + useEffect( + () => (): void => (drivers.rtcDriver as JsSdkRtcMatrixDriver).detach(), + [drivers], + ); + return drivers; +} diff --git a/src/driver/useHomeserverConnected.test.tsx b/src/driver/useHomeserverConnected.test.tsx new file mode 100644 index 000000000..c641cfd61 --- /dev/null +++ b/src/driver/useHomeserverConnected.test.tsx @@ -0,0 +1,63 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { act, renderHook } from "@testing-library/react"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +import { type MatrixDrivers } from "./MatrixDriverContext"; +import { MockElementCallMatrixClientDriver } from "./MockElementCallMatrixClientDriver"; +import { MockRtcMatrixDriver } from "./MockRtcMatrixDriver"; +import { useHomeserverConnected } from "./useHomeserverConnected"; + +describe("useHomeserverConnected", () => { + beforeEach(() => vi.useFakeTimers()); + afterEach(() => vi.useRealTimers()); + + it("reports a lapse only after the grace period, and a return at once", () => { + const rtcDriver = new MockRtcMatrixDriver(); + const drivers: MatrixDrivers = { + rtcDriver, + clientDriver: new MockElementCallMatrixClientDriver(), + }; + const { result } = renderHook(() => useHomeserverConnected(drivers, 1000)); + expect(result.current).toBe(true); + + act(() => rtcDriver.setHomeserverConnected(false)); + expect(result.current).toBe(true); + act(() => vi.advanceTimersByTime(999)); + expect(result.current).toBe(true); + act(() => vi.advanceTimersByTime(1)); + expect(result.current).toBe(false); + + act(() => rtcDriver.setHomeserverConnected(true)); + expect(result.current).toBe(true); + + // A blip shorter than the grace period is never shown. + act(() => rtcDriver.setHomeserverConnected(false)); + act(() => vi.advanceTimersByTime(500)); + act(() => rtcDriver.setHomeserverConnected(true)); + act(() => vi.advanceTimersByTime(1000)); + expect(result.current).toBe(true); + }); + + it("starts from the driver's current answer", () => { + const rtcDriver = new MockRtcMatrixDriver(); + rtcDriver.setHomeserverConnected(false); + const drivers: MatrixDrivers = { + rtcDriver, + clientDriver: new MockElementCallMatrixClientDriver(), + }; + const { result } = renderHook(() => useHomeserverConnected(drivers, 1000)); + act(() => vi.advanceTimersByTime(1000)); + expect(result.current).toBe(false); + }); + + it("is connected without drivers", () => { + const { result } = renderHook(() => useHomeserverConnected(null, 1000)); + expect(result.current).toBe(true); + }); +}); diff --git a/src/driver/useHomeserverConnected.ts b/src/driver/useHomeserverConnected.ts new file mode 100644 index 000000000..e4747f898 --- /dev/null +++ b/src/driver/useHomeserverConnected.ts @@ -0,0 +1,58 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { useEffect, useState } from "react"; + +import { Config } from "../config/Config"; +import { type MatrixDrivers } from "./MatrixDriverContext"; + +/** + * Whether the homeserver is reachable, from the RTC driver's connectivity + * (the same signal the crate turns into `HomeserverUnreachable`). The driver + * reports every lapse of the sync loop; the UI should not, so a lapse counts + * only once it has lasted `graceMs` (the deployment's + * `sync_disconnect_grace_period_ms` by default). Coming back counts at once. + * + * `null` drivers (a host that provided none) read as connected: there is + * nothing to report on. + */ +export function useHomeserverConnected( + drivers: MatrixDrivers | null, + graceMs: number = Config.get().sync_disconnect_grace_period_ms, +): boolean { + const [connected, setConnected] = useState(true); + useEffect(() => { + if (drivers === null) { + setConnected(true); + return; + } + const { rtcDriver } = drivers; + let live = true; + let lapse: ReturnType | null = null; + const report = (isConnected: boolean): void => { + if (lapse !== null) { + clearTimeout(lapse); + lapse = null; + } + if (isConnected) setConnected(true); + else lapse = setTimeout(() => setConnected(false), graceMs); + }; + report(rtcDriver.isHomeserverConnected()); + rtcDriver.subscribeConnectivity({ + emit: (isConnected) => { + if (!live) return false; + report(isConnected); + return true; + }, + }); + return (): void => { + live = false; + if (lapse !== null) clearTimeout(lapse); + }; + }, [drivers, graceMs]); + return connected; +} diff --git a/src/e2ee/sharedKeyManagement.ts b/src/e2ee/sharedKeyManagement.ts index b29ede319..134743013 100644 --- a/src/e2ee/sharedKeyManagement.ts +++ b/src/e2ee/sharedKeyManagement.ts @@ -87,8 +87,16 @@ export type SharedSecret = { kind: E2eeType.SHARED_KEY; secret: string }; export type PerParticipantE2EE = { kind: E2eeType.PER_PARTICIPANT }; export type EncryptionSystem = Unencrypted | SharedSecret | PerParticipantE2EE; -export function useRoomEncryptionSystem(roomId: string): EncryptionSystem { - const { client } = useClient(); +/** + * The encryption system for a room whose `m.room.encryption` state the + * caller already knows: a shared secret from the URL or storage wins, else + * per-participant keys in an encrypted room, else nothing. The call tree + * reads `roomEncrypted` from the client driver's room info. + */ +export function useEncryptionSystemFor( + roomId: string, + roomEncrypted: boolean, +): EncryptionSystem { const { roomId: paramsRoomId, password } = useUrlParams(); const [storedPassword] = useRoomSharedKey( @@ -100,18 +108,29 @@ export function useRoomEncryptionSystem(roomId: string): EncryptionSystem { keyForRoom(roomId, paramsRoomId, password) ?? undefined, ); - const room = client?.getRoom(roomId); - const e2eeSystem = useMemo(() => { - if (!room) return { kind: E2eeType.NONE }; + return useMemo(() => { if (storedPassword) return { kind: E2eeType.SHARED_KEY, secret: storedPassword, }; - if (room.hasEncryptionStateEvent()) { + if (roomEncrypted) { return { kind: E2eeType.PER_PARTICIPANT }; } return { kind: E2eeType.NONE }; - }, [room, storedPassword]); - return e2eeSystem; + }, [roomEncrypted, storedPassword]); +} + +/** {@link useEncryptionSystemFor} over the client's room; nothing for a room it does not know. */ +export function useRoomEncryptionSystem(roomId: string): EncryptionSystem { + const { client } = useClient(); + const room = client?.getRoom(roomId); + const e2eeSystem = useEncryptionSystemFor( + roomId, + room?.hasEncryptionStateEvent() ?? false, + ); + return useMemo( + () => (room ? e2eeSystem : { kind: E2eeType.NONE }), + [room, e2eeSystem], + ); } diff --git a/src/matrix-rtc-sdk/generated/VERSION b/src/matrix-rtc-sdk/generated/VERSION index 8966fc8d9..2cb52ee9e 100644 --- a/src/matrix-rtc-sdk/generated/VERSION +++ b/src/matrix-rtc-sdk/generated/VERSION @@ -1,2 +1,2 @@ -matrix-rtc (MatrixSdkArchitectureDraft) 088a598-dirty -built 2026-09-15T18:22:09Z by scripts/sync-matrix-rtc-sdk.sh +matrix-rtc (MatrixSdkArchitectureDraft) 61140bc-dirty +built 2026-09-16T12:10:06Z by scripts/sync-matrix-rtc-sdk.sh diff --git a/src/matrix-rtc-sdk/generated/matrix_rtc-ffi.ts b/src/matrix-rtc-sdk/generated/matrix_rtc-ffi.ts index 67a59c954..fdd4103da 100644 --- a/src/matrix-rtc-sdk/generated/matrix_rtc-ffi.ts +++ b/src/matrix-rtc-sdk/generated/matrix_rtc-ffi.ts @@ -36,6 +36,14 @@ export type UniffiVTableCallbackInterfaceMatrixRtcKeyRejectedListener = { uniffi_clone: UniffiCallbackInterfaceCloneMatrixRtcKeyRejectedListener; on_key_rejected: UniffiCallbackInterfaceMatrixRtcKeyRejectedListenerMethod0; }; +type UniffiCallbackInterfaceMatrixRtcLogSinkMethod0 = (uniffiHandle: bigint, level: Uint8Array, target: Uint8Array, message: Uint8Array) => UniffiResult; +type UniffiCallbackInterfaceCloneMatrixRtcLogSink = (handle: bigint) => UniffiResult; +type UniffiCallbackInterfaceFreeMatrixRtcLogSink = (handle: bigint) => void; +export type UniffiVTableCallbackInterfaceMatrixRtcLogSink = { + uniffi_free: UniffiCallbackInterfaceFreeMatrixRtcLogSink; + uniffi_clone: UniffiCallbackInterfaceCloneMatrixRtcLogSink; + log: UniffiCallbackInterfaceMatrixRtcLogSinkMethod0; +}; export type UniffiForeignFutureResultRustBuffer = { return_value: Uint8Array; call_status: UniffiRustCallStatus; diff --git a/src/matrix-rtc-sdk/generated/matrix_rtc.ts b/src/matrix-rtc-sdk/generated/matrix_rtc.ts index 9f2ef3691..d34986c1f 100644 --- a/src/matrix-rtc-sdk/generated/matrix_rtc.ts +++ b/src/matrix-rtc-sdk/generated/matrix_rtc.ts @@ -4,7 +4,7 @@ /* eslint-disable */ // @ts-nocheck import * as wasmBundle from "./wasm-bindgen/index.js"; -import { type UniffiRustFutureContinuationCallback, type UniffiForeignFutureDroppedCallback, type UniffiForeignFutureDroppedCallbackStruct, type UniffiVTableCallbackInterfaceMatrixRtcConnectionsListener, type UniffiVTableCallbackInterfaceMatrixRtcKeyMapListener, type UniffiVTableCallbackInterfaceMatrixRtcKeyRejectedListener, type UniffiForeignFutureResultRustBuffer, type UniffiForeignFutureCompleterustBuffer, type UniffiForeignFutureResultVoid, type UniffiForeignFutureCompletevoid, type UniffiVTableCallbackInterfaceMatrixRtcMatrixDriverCallback, type UniffiVTableCallbackInterfaceMatrixRtcMembershipsListener, type UniffiVTableCallbackInterfaceMatrixRtcSessionListener, type UniffiVTableCallbackInterfaceMatrixRtcStatusListener, +import { type UniffiRustFutureContinuationCallback, type UniffiForeignFutureDroppedCallback, type UniffiForeignFutureDroppedCallbackStruct, type UniffiVTableCallbackInterfaceMatrixRtcConnectionsListener, type UniffiVTableCallbackInterfaceMatrixRtcKeyMapListener, type UniffiVTableCallbackInterfaceMatrixRtcKeyRejectedListener, type UniffiVTableCallbackInterfaceMatrixRtcLogSink, type UniffiForeignFutureResultRustBuffer, type UniffiForeignFutureCompleterustBuffer, type UniffiForeignFutureResultVoid, type UniffiForeignFutureCompletevoid, type UniffiVTableCallbackInterfaceMatrixRtcMatrixDriverCallback, type UniffiVTableCallbackInterfaceMatrixRtcMembershipsListener, type UniffiVTableCallbackInterfaceMatrixRtcSessionListener, type UniffiVTableCallbackInterfaceMatrixRtcStatusListener, } from "./matrix_rtc-ffi"; import { type FfiConverter, type UniffiByteArray, type UniffiGcObject, type UniffiHandle, type UniffiObjectFactory, type UniffiReferenceHolder, type UniffiRustCallStatus, AbstractFfiConverterByteArray, Cursor, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, FfiConverterUInt8, RustBuffer, UniffiAbstractObject, UniffiEnum, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTraitInterfaceCall, uniffiTraitInterfaceCallAsyncWithError, uniffiTypeNameSymbol, variantOrdinalSymbol, } from "@ubjs/core"; @@ -75,6 +75,23 @@ export function impairmentSeverity(impairment: FfiImpairment): FfiSeverity { } } +/** + * Routes the crate's log lines to `sink`, at `max_level` and above. Call + * once after the bindings are initialised; calling again replaces the sink + * and the level. The `log` facade accepts one logger per process, so if the + * host already installed a Rust logger of its own (a native host with + * `tracing`), that one keeps the lines and the sink stays silent. + */ +export function setLogSink(sink: LogSink, maxLevel: FfiLogLevel): void {uniffiCaller.rustCall( + /*caller:*/ (callStatus) => { nativeModule().ubrn_uniffi_matrix_rtc_fn_func_set_log_sink( + FfiConverterTypeLogSink.lower(sink, nativeModule().rustbuffer_alloc), + FfiConverterTypeFfiLogLevel.lower(maxLevel, nativeModule().rustbuffer_alloc), + callStatus); + }, + /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), + ); + } + const stringConverter = (() => { const encoder = new TextEncoder(); const decoder = new TextDecoder(); @@ -3788,6 +3805,46 @@ const FfiConverterTypeFfiKeepAlive = (() => { return new FFIConverter(); })(); +/** + * The `log` crate's levels, for a [`LogSink`]. + */ +export enum FfiLogLevel { + Error, + Warn, + Info, + Debug, + Trace +} + +const FfiConverterTypeFfiLogLevel = (() => { + type TypeName = FfiLogLevel; + class FFIConverter extends AbstractFfiConverterByteArray { + readFromCursor(c: Cursor): TypeName { + switch (c.readI32()) { + case 1: return FfiLogLevel.Error; + case 2: return FfiLogLevel.Warn; + case 3: return FfiLogLevel.Info; + case 4: return FfiLogLevel.Debug; + case 5: return FfiLogLevel.Trace; + default: throw new UniffiInternalError.UnexpectedEnumCase(); + } + } + writeIntoCursor(value: TypeName, c: Cursor): void { + switch (value) { + case FfiLogLevel.Error: return c.writeI32(1); + case FfiLogLevel.Warn: return c.writeI32(2); + case FfiLogLevel.Info: return c.writeI32(3); + case FfiLogLevel.Debug: return c.writeI32(4); + case FfiLogLevel.Trace: return c.writeI32(5); + } + } + allocationSize(value: TypeName): number { + return 4; + } + } + return new FFIConverter(); +})(); + // Enum: FfiRosterPresence export enum FfiRosterPresence_Tags { @@ -7027,6 +7084,189 @@ const uniffiTypeFfiParticipationManagerObjectFactory: UniffiObjectFactory { nativeModule().ubrn_uniffi_matrix_rtc_fn_method_logsink_log( + uniffiTypeLogSinkImplObjectFactory.clonePointer(this), + FfiConverterTypeFfiLogLevel.lower(level, nativeModule().rustbuffer_alloc), + FfiConverterString.lower(target, nativeModule().rustbuffer_alloc), + FfiConverterString.lower(message, nativeModule().rustbuffer_alloc), + callStatus); + }, + /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), + ); + } + + + uniffiDestroy(): void { + const ptr = (this as any)[destructorGuardSymbol]; + if (ptr !== undefined) { + const pointer = uniffiTypeLogSinkImplObjectFactory.pointer(this); + uniffiTypeLogSinkImplObjectFactory.freePointer(pointer); + uniffiTypeLogSinkImplObjectFactory.unbless(ptr); + delete (this as any)[destructorGuardSymbol]; + } + } + + static instanceOf(obj_: any): obj_ is LogSinkImpl { + return uniffiTypeLogSinkImplObjectFactory.isConcreteType(obj_); + } + + +} + +const uniffiTypeLogSinkImplObjectFactory: UniffiObjectFactory = (() => { + + /// + const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue: UniffiHandle) => { + uniffiTypeLogSinkImplObjectFactory.freePointer(heldValue); + }) : null; + + return { + create(pointer: UniffiHandle): LogSink { + const instance = Object.create(LogSinkImpl.prototype); + instance[pointerLiteralSymbol] = pointer; + instance[destructorGuardSymbol] = this.bless(pointer); + instance[uniffiTypeNameSymbol] = "LogSinkImpl"; + return instance; + }, + + + bless(p: UniffiHandle): UniffiGcObject { + const ptr = { + p, // make sure this object doesn't get optimized away. + markDestroyed: () => undefined, + }; + if (registry) { + registry.register(ptr, p, ptr); + } + return ptr; + }, + + unbless(ptr_: UniffiGcObject) { + if (registry) { + registry.unregister(ptr_); + } + }, + + pointer(obj_: LogSink): UniffiHandle { + if ((obj_ as any)[destructorGuardSymbol] === undefined) { + throw new UniffiInternalError.UnexpectedNullPointer(); + } + return (obj_ as any)[pointerLiteralSymbol]; + }, + + clonePointer(obj_: LogSink): UniffiHandle { + const pointer = this.pointer(obj_); + return uniffiCaller.rustCall( + /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_matrix_rtc_fn_clone_logsink(pointer, callStatus), + /*liftString:*/ FfiConverterString.lift + ); + }, + + freePointer(pointer: UniffiHandle): void { + uniffiCaller.rustCall( + /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_matrix_rtc_fn_free_logsink(pointer, callStatus), + /*liftString:*/ FfiConverterString.lift + ); + }, + + isConcreteType(obj_: any): obj_ is LogSink { + return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "LogSinkImpl"; + }, +}})(); +const FfiConverterTypeLogSink = new FfiConverterObjectWithCallbacks(uniffiTypeLogSinkImplObjectFactory); + +// Add a vtable for the callbacks that go in LogSink. + +// Put the implementation in a struct so we don't pollute the top-level namespace +const uniffiCallbackInterfaceLogSink: { vtable: any; register: () => void; } = { + // Create the VTable using a series of closures. + // ts automatically converts these into C callback functions. + vtable: { + log: ( + uniffiHandle: bigint, + level: Uint8Array, + target: Uint8Array, + message: Uint8Array,) => { + const uniffiMakeCall = + () + : void => { + const jsCallback = FfiConverterTypeLogSink.lift(uniffiHandle); + return jsCallback.log( + FfiConverterTypeFfiLogLevel.lift(level), + FfiConverterString.lift(target), + FfiConverterString.lift(message) + ) + }; + const uniffiResult = UniffiResult.ready(); + const uniffiHandleSuccess = (obj: any) => {}; + const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => { + UniffiResult.writeError(uniffiResult, code, errBuf); + }; + uniffiTraitInterfaceCall( + /*makeCall:*/ uniffiMakeCall, + /*handleSuccess:*/ uniffiHandleSuccess, + /*handleError:*/ uniffiHandleError, + /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString), + /*alloc:*/ nativeModule().rustbuffer_alloc, + ) + return uniffiResult; + }, + uniffi_free: (uniffiHandle: UniffiHandle): void => { + // this will throw a stale handle error if the handle isn't found. + FfiConverterTypeLogSink.drop(uniffiHandle); + }, + uniffi_clone: (uniffiHandle: UniffiHandle): UniffiHandle => { + return FfiConverterTypeLogSink.clone(uniffiHandle); + } + }, + register: () => {nativeModule().ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_logsink( + uniffiCallbackInterfaceLogSink.vtable + ); + }, +}; + /** * One end of a driver event stream: Rust-exported objects handed to the * foreign driver through the `subscribe_*` methods. The host calls `emit` @@ -8963,6 +9203,9 @@ function uniffiEnsureInitialized() { if (nativeModule().ubrn_uniffi_matrix_rtc_checksum_func_impairment_severity() !== 9139) { throw new UniffiInternalError.ApiChecksumMismatch("uniffi_matrix_rtc_checksum_func_impairment_severity"); } + if (nativeModule().ubrn_uniffi_matrix_rtc_checksum_func_set_log_sink() !== 7798) { + throw new UniffiInternalError.ApiChecksumMismatch("uniffi_matrix_rtc_checksum_func_set_log_sink"); + } if (nativeModule().ubrn_uniffi_matrix_rtc_checksum_method_connectionslistener_on_connections_change() !== 24219) { throw new UniffiInternalError.ApiChecksumMismatch("uniffi_matrix_rtc_checksum_method_connectionslistener_on_connections_change"); } @@ -9047,6 +9290,9 @@ function uniffiEnsureInitialized() { if (nativeModule().ubrn_uniffi_matrix_rtc_checksum_method_keyrejectedlistener_on_key_rejected() !== 53044) { throw new UniffiInternalError.ApiChecksumMismatch("uniffi_matrix_rtc_checksum_method_keyrejectedlistener_on_key_rejected"); } + if (nativeModule().ubrn_uniffi_matrix_rtc_checksum_method_logsink_log() !== 15220) { + throw new UniffiInternalError.ApiChecksumMismatch("uniffi_matrix_rtc_checksum_method_logsink_log"); + } if (nativeModule().ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_sticky_event() !== 39725) { throw new UniffiInternalError.ApiChecksumMismatch("uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_sticky_event"); } @@ -9126,6 +9372,7 @@ function uniffiEnsureInitialized() { uniffiCallbackInterfaceMembershipsListener.register(); uniffiCallbackInterfaceSessionListener.register(); uniffiCallbackInterfaceStatusListener.register(); + uniffiCallbackInterfaceLogSink.register(); uniffiCallbackInterfaceMatrixDriverCallback.register(); } @@ -9157,6 +9404,7 @@ export default Object.freeze({ FfiConverterTypeFfiKeyRejection, FfiConverterTypeFfiLivekitToken, FfiConverterTypeFfiLivekitTokenRequest, + FfiConverterTypeFfiLogLevel, FfiConverterTypeFfiMatrixDriver, FfiConverterTypeFfiMediaKey, FfiConverterTypeFfiMediaKeyState, @@ -9179,6 +9427,7 @@ export default Object.freeze({ FfiConverterTypeFfiTransportIntent, FfiConverterTypeKeyMapListener, FfiConverterTypeKeyRejectedListener, + FfiConverterTypeLogSink, FfiConverterTypeMatrixDriverCallback, FfiConverterTypeMembershipsListener, FfiConverterTypeRoomEventSink, diff --git a/src/matrix-rtc-sdk/generated/wasm-bindgen/index.js b/src/matrix-rtc-sdk/generated/wasm-bindgen/index.js index b221ba0b5..fd45f635d 100644 --- a/src/matrix-rtc-sdk/generated/wasm-bindgen/index.js +++ b/src/matrix-rtc-sdk/generated/wasm-bindgen/index.js @@ -359,9 +359,9 @@ export function ubrn_uniffi_matrix_rtc_fn_method_keyrejectedlistener_on_key_reje * @param {RustCallStatus} f_status_ * @returns {bigint} */ -export function ubrn_uniffi_matrix_rtc_fn_clone_matrixdrivercallback(handle, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_clone_logsink(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_matrixdrivercallback(handle, f_status_.__wbg_ptr); + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_logsink(handle, f_status_.__wbg_ptr); return BigInt.asUintN(64, ret); } @@ -369,9 +369,63 @@ export function ubrn_uniffi_matrix_rtc_fn_clone_matrixdrivercallback(handle, f_s * @param {bigint} handle * @param {RustCallStatus} f_status_ */ -export function ubrn_uniffi_matrix_rtc_fn_free_matrixdrivercallback(handle, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_free_logsink(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_free_matrixdrivercallback(handle, f_status_.__wbg_ptr); + wasm.ubrn_uniffi_matrix_rtc_fn_free_logsink(handle, f_status_.__wbg_ptr); +} + +/** + * @param {bigint} ptr + * @param {Uint8Array} room_id + * @param {Uint8Array} delay_id + * @returns {bigint} + */ +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_restart_delayed_event(ptr, room_id, delay_id) { + const ptr0 = passArray8ToWasm0(room_id, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArray8ToWasm0(delay_id, wasm.__wbindgen_malloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_restart_delayed_event(ptr, ptr0, len0, ptr1, len1); + return BigInt.asUintN(64, ret); +} + +/** + * @param {bigint} ptr + * @param {Uint8Array} room_id + * @param {Uint8Array} delay_id + * @returns {bigint} + */ +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_cancel_delayed_event(ptr, room_id, delay_id) { + const ptr0 = passArray8ToWasm0(room_id, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArray8ToWasm0(delay_id, wasm.__wbindgen_malloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_cancel_delayed_event(ptr, ptr0, len0, ptr1, len1); + return BigInt.asUintN(64, ret); +} + +/** + * @param {bigint} ptr + * @param {Uint8Array} request + * @returns {bigint} + */ +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_delegate_delayed_leave_via_homeserver(ptr, request) { + const ptr0 = passArray8ToWasm0(request, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_delegate_delayed_leave_via_homeserver(ptr, ptr0, len0); + return BigInt.asUintN(64, ret); +} + +/** + * @param {bigint} ptr + * @param {Uint8Array} request + * @returns {bigint} + */ +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_delegate_delayed_leave_via_transport(ptr, request) { + const ptr0 = passArray8ToWasm0(request, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_delegate_delayed_leave_via_transport(ptr, ptr0, len0); + return BigInt.asUintN(64, ret); } /** @@ -429,49 +483,49 @@ export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_read_event return BigInt.asUintN(64, ret); } +/** + * @param {any} vtable + */ +export function ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_logsink(vtable) { + wasm.ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_logsink(vtable); +} + /** * @param {bigint} ptr - * @param {Uint8Array} event_type - * @param {Uint8Array} state_key + * @param {Uint8Array} level + * @param {Uint8Array} target + * @param {Uint8Array} message + * @param {RustCallStatus} f_status_ + */ +export function ubrn_uniffi_matrix_rtc_fn_method_logsink_log(ptr, level, target, message, f_status_) { + const ptr0 = passArray8ToWasm0(level, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArray8ToWasm0(target, wasm.__wbindgen_malloc); + const len1 = WASM_VECTOR_LEN; + const ptr2 = passArray8ToWasm0(message, wasm.__wbindgen_malloc); + const len2 = WASM_VECTOR_LEN; + _assertClass(f_status_, RustCallStatus); + wasm.ubrn_uniffi_matrix_rtc_fn_method_logsink_log(ptr, ptr0, len0, ptr1, len1, ptr2, len2, f_status_.__wbg_ptr); +} + +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ * @returns {bigint} */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_read_state(ptr, event_type, state_key) { - const ptr0 = passArray8ToWasm0(event_type, wasm.__wbindgen_malloc); - const len0 = WASM_VECTOR_LEN; - const ptr1 = passArray8ToWasm0(state_key, wasm.__wbindgen_malloc); - const len1 = WASM_VECTOR_LEN; - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_read_state(ptr, ptr0, len0, ptr1, len1); +export function ubrn_uniffi_matrix_rtc_fn_clone_matrixdrivercallback(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_matrixdrivercallback(handle, f_status_.__wbg_ptr); return BigInt.asUintN(64, ret); } /** - * @param {bigint} ptr - * @param {bigint} sink + * @param {bigint} handle * @param {RustCallStatus} f_status_ */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_room_events(ptr, sink, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_free_matrixdrivercallback(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_room_events(ptr, sink, f_status_.__wbg_ptr); -} - -/** - * @param {bigint} ptr - * @param {bigint} sink - * @param {RustCallStatus} f_status_ - */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_to_device_events(ptr, sink, f_status_) { - _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_to_device_events(ptr, sink, f_status_.__wbg_ptr); -} - -/** - * @param {bigint} ptr - * @param {bigint} sink - * @param {RustCallStatus} f_status_ - */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_state_updates(ptr, sink, f_status_) { - _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_state_updates(ptr, sink, f_status_.__wbg_ptr); + wasm.ubrn_uniffi_matrix_rtc_fn_free_matrixdrivercallback(handle, f_status_.__wbg_ptr); } /** @@ -567,77 +621,64 @@ export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_send_delay /** * @param {bigint} ptr - * @param {Uint8Array} room_id - * @param {Uint8Array} delay_id + * @param {Uint8Array} event_type + * @param {Uint8Array} state_key * @returns {bigint} */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_restart_delayed_event(ptr, room_id, delay_id) { - const ptr0 = passArray8ToWasm0(room_id, wasm.__wbindgen_malloc); +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_read_state(ptr, event_type, state_key) { + const ptr0 = passArray8ToWasm0(event_type, wasm.__wbindgen_malloc); const len0 = WASM_VECTOR_LEN; - const ptr1 = passArray8ToWasm0(delay_id, wasm.__wbindgen_malloc); + const ptr1 = passArray8ToWasm0(state_key, wasm.__wbindgen_malloc); const len1 = WASM_VECTOR_LEN; - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_restart_delayed_event(ptr, ptr0, len0, ptr1, len1); + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_read_state(ptr, ptr0, len0, ptr1, len1); return BigInt.asUintN(64, ret); } -/** - * @param {bigint} ptr - * @param {Uint8Array} room_id - * @param {Uint8Array} delay_id - * @returns {bigint} - */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_cancel_delayed_event(ptr, room_id, delay_id) { - const ptr0 = passArray8ToWasm0(room_id, wasm.__wbindgen_malloc); - const len0 = WASM_VECTOR_LEN; - const ptr1 = passArray8ToWasm0(delay_id, wasm.__wbindgen_malloc); - const len1 = WASM_VECTOR_LEN; - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_cancel_delayed_event(ptr, ptr0, len0, ptr1, len1); - return BigInt.asUintN(64, ret); -} - -/** - * @param {bigint} ptr - * @param {Uint8Array} request - * @returns {bigint} - */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_delegate_delayed_leave_via_homeserver(ptr, request) { - const ptr0 = passArray8ToWasm0(request, wasm.__wbindgen_malloc); - const len0 = WASM_VECTOR_LEN; - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_delegate_delayed_leave_via_homeserver(ptr, ptr0, len0); - return BigInt.asUintN(64, ret); -} - -/** - * @param {bigint} ptr - * @param {Uint8Array} request - * @returns {bigint} - */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_delegate_delayed_leave_via_transport(ptr, request) { - const ptr0 = passArray8ToWasm0(request, wasm.__wbindgen_malloc); - const len0 = WASM_VECTOR_LEN; - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_delegate_delayed_leave_via_transport(ptr, ptr0, len0); - return BigInt.asUintN(64, ret); -} - -/** - * @param {bigint} ptr - * @param {RustCallStatus} f_status_ - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_is_homeserver_connected(ptr, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_is_homeserver_connected(ptr, f_status_.__wbg_ptr); - return ret; -} - /** * @param {bigint} ptr * @param {bigint} sink * @param {RustCallStatus} f_status_ */ -export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_connectivity(ptr, sink, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_room_events(ptr, sink, f_status_) { _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_connectivity(ptr, sink, f_status_.__wbg_ptr); + wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_room_events(ptr, sink, f_status_.__wbg_ptr); +} + +/** + * @param {bigint} ptr + * @param {bigint} sink + * @param {RustCallStatus} f_status_ + */ +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_to_device_events(ptr, sink, f_status_) { + _assertClass(f_status_, RustCallStatus); + wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_to_device_events(ptr, sink, f_status_.__wbg_ptr); +} + +/** + * @param {bigint} ptr + * @param {bigint} sink + * @param {RustCallStatus} f_status_ + */ +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_state_updates(ptr, sink, f_status_) { + _assertClass(f_status_, RustCallStatus); + wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_state_updates(ptr, sink, f_status_.__wbg_ptr); +} + +/** + * @param {bigint} ptr + * @param {Uint8Array} event_json + * @param {Uint8Array} origin + * @param {RustCallStatus} f_status_ + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_fn_method_roomeventsink_emit(ptr, event_json, origin, f_status_) { + const ptr0 = passArray8ToWasm0(event_json, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArray8ToWasm0(origin, wasm.__wbindgen_malloc); + const len1 = WASM_VECTOR_LEN; + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_roomeventsink_emit(ptr, ptr0, len0, ptr1, len1, f_status_.__wbg_ptr); + return ret; } /** @@ -645,9 +686,9 @@ export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_ * @param {RustCallStatus} f_status_ * @returns {bigint} */ -export function ubrn_uniffi_matrix_rtc_fn_clone_membershipslistener(handle, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_clone_sessionlistener(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_membershipslistener(handle, f_status_.__wbg_ptr); + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_sessionlistener(handle, f_status_.__wbg_ptr); return BigInt.asUintN(64, ret); } @@ -655,9 +696,16 @@ export function ubrn_uniffi_matrix_rtc_fn_clone_membershipslistener(handle, f_st * @param {bigint} handle * @param {RustCallStatus} f_status_ */ -export function ubrn_uniffi_matrix_rtc_fn_free_membershipslistener(handle, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_free_sessionlistener(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_free_membershipslistener(handle, f_status_.__wbg_ptr); + wasm.ubrn_uniffi_matrix_rtc_fn_free_sessionlistener(handle, f_status_.__wbg_ptr); +} + +/** + * @param {any} vtable + */ +export function ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_sessionlistener(vtable) { + wasm.ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_sessionlistener(vtable); } /** @@ -721,28 +769,30 @@ export function ubrn_uniffi_matrix_rtc_fn_clone_statuslistener(handle, f_status_ * @param {bigint} handle * @param {RustCallStatus} f_status_ */ -export function ubrn_uniffi_matrix_rtc_fn_free_statuslistener(handle, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_free_connectionslistener(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_free_statuslistener(handle, f_status_.__wbg_ptr); -} - -/** - * @param {any} vtable - */ -export function ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_statuslistener(vtable) { - wasm.ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_statuslistener(vtable); + wasm.ubrn_uniffi_matrix_rtc_fn_free_connectionslistener(handle, f_status_.__wbg_ptr); } /** * @param {bigint} ptr - * @param {Uint8Array} status + * @param {RustCallStatus} f_status_ + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_is_homeserver_connected(ptr, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_is_homeserver_connected(ptr, f_status_.__wbg_ptr); + return ret; +} + +/** + * @param {bigint} ptr + * @param {bigint} sink * @param {RustCallStatus} f_status_ */ -export function ubrn_uniffi_matrix_rtc_fn_method_statuslistener_on_status_change(ptr, status, f_status_) { - const ptr0 = passArray8ToWasm0(status, wasm.__wbindgen_malloc); - const len0 = WASM_VECTOR_LEN; +export function ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_connectivity(ptr, sink, f_status_) { _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_method_statuslistener_on_status_change(ptr, ptr0, len0, f_status_.__wbg_ptr); + wasm.ubrn_uniffi_matrix_rtc_fn_method_matrixdrivercallback_subscribe_connectivity(ptr, sink, f_status_.__wbg_ptr); } /** @@ -750,9 +800,9 @@ export function ubrn_uniffi_matrix_rtc_fn_method_statuslistener_on_status_change * @param {RustCallStatus} f_status_ * @returns {bigint} */ -export function ubrn_uniffi_matrix_rtc_fn_clone_todevicesink(handle, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_clone_membershipslistener(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_todevicesink(handle, f_status_.__wbg_ptr); + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_membershipslistener(handle, f_status_.__wbg_ptr); return BigInt.asUintN(64, ret); } @@ -760,9 +810,9 @@ export function ubrn_uniffi_matrix_rtc_fn_clone_todevicesink(handle, f_status_) * @param {bigint} handle * @param {RustCallStatus} f_status_ */ -export function ubrn_uniffi_matrix_rtc_fn_free_connectionslistener(handle, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_free_membershipslistener(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_free_connectionslistener(handle, f_status_.__wbg_ptr); + wasm.ubrn_uniffi_matrix_rtc_fn_free_membershipslistener(handle, f_status_.__wbg_ptr); } /** @@ -804,20 +854,110 @@ export function ubrn_uniffi_matrix_rtc_fn_free_roomeventsink(handle, f_status_) wasm.ubrn_uniffi_matrix_rtc_fn_free_roomeventsink(handle, f_status_.__wbg_ptr); } +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ + */ +export function ubrn_uniffi_matrix_rtc_fn_free_statuslistener(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + wasm.ubrn_uniffi_matrix_rtc_fn_free_statuslistener(handle, f_status_.__wbg_ptr); +} + +/** + * @param {any} vtable + */ +export function ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_statuslistener(vtable) { + wasm.ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_statuslistener(vtable); +} + /** * @param {bigint} ptr - * @param {Uint8Array} event_json - * @param {Uint8Array} origin + * @param {Uint8Array} status + * @param {RustCallStatus} f_status_ + */ +export function ubrn_uniffi_matrix_rtc_fn_method_statuslistener_on_status_change(ptr, status, f_status_) { + const ptr0 = passArray8ToWasm0(status, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + _assertClass(f_status_, RustCallStatus); + wasm.ubrn_uniffi_matrix_rtc_fn_method_statuslistener_on_status_change(ptr, ptr0, len0, f_status_.__wbg_ptr); +} + +/** + * @param {bigint} handle * @param {RustCallStatus} f_status_ * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_fn_method_roomeventsink_emit(ptr, event_json, origin, f_status_) { - const ptr0 = passArray8ToWasm0(event_json, wasm.__wbindgen_malloc); - const len0 = WASM_VECTOR_LEN; - const ptr1 = passArray8ToWasm0(origin, wasm.__wbindgen_malloc); - const len1 = WASM_VECTOR_LEN; +export function ubrn_ffi_matrix_rtc_rust_future_complete_u8(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_method_roomeventsink_emit(ptr, ptr0, len0, ptr1, len1, f_status_.__wbg_ptr); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_u8(handle, f_status_.__wbg_ptr); + return ret; +} + +/** + * @param {bigint} handle + * @param {any} callback + * @param {bigint} callback_data + */ +export function ubrn_ffi_matrix_rtc_rust_future_poll_i8(handle, callback, callback_data) { + wasm.ubrn_ffi_matrix_rtc_rust_future_poll_i8(handle, callback, callback_data); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_cancel_i8(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_i8(handle); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_free_i8(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_i8(handle); +} + +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ + * @returns {number} + */ +export function ubrn_ffi_matrix_rtc_rust_future_complete_i8(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_i8(handle, f_status_.__wbg_ptr); + return ret; +} + +/** + * @param {bigint} handle + * @param {any} callback + * @param {bigint} callback_data + */ +export function ubrn_ffi_matrix_rtc_rust_future_poll_u16(handle, callback, callback_data) { + wasm.ubrn_ffi_matrix_rtc_rust_future_poll_u16(handle, callback, callback_data); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_cancel_u16(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_u16(handle); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_free_u16(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_u16(handle); +} + +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ + * @returns {number} + */ +export function ubrn_ffi_matrix_rtc_rust_future_complete_u16(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_u16(handle, f_status_.__wbg_ptr); return ret; } @@ -826,28 +966,12 @@ export function ubrn_uniffi_matrix_rtc_fn_method_roomeventsink_emit(ptr, event_j * @param {RustCallStatus} f_status_ * @returns {bigint} */ -export function ubrn_uniffi_matrix_rtc_fn_clone_sessionlistener(handle, f_status_) { +export function ubrn_uniffi_matrix_rtc_fn_clone_todevicesink(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_sessionlistener(handle, f_status_.__wbg_ptr); + const ret = wasm.ubrn_uniffi_matrix_rtc_fn_clone_todevicesink(handle, f_status_.__wbg_ptr); return BigInt.asUintN(64, ret); } -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - */ -export function ubrn_uniffi_matrix_rtc_fn_free_sessionlistener(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_free_sessionlistener(handle, f_status_.__wbg_ptr); -} - -/** - * @param {any} vtable - */ -export function ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_sessionlistener(vtable) { - wasm.ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_sessionlistener(vtable); -} - /** * @param {bigint} handle * @param {RustCallStatus} f_status_ @@ -901,83 +1025,6 @@ export function ubrn_uniffi_matrix_rtc_fn_func_compute_sessions_from_events(even return v3; } -/** - * @param {bigint} handle - * @param {any} callback - * @param {bigint} callback_data - */ -export function ubrn_ffi_matrix_rtc_rust_future_poll_u16(handle, callback, callback_data) { - wasm.ubrn_ffi_matrix_rtc_rust_future_poll_u16(handle, callback, callback_data); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_u16(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_u16(handle); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_free_u16(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_u16(handle); -} - -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - * @returns {number} - */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_u16(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_u16(handle, f_status_.__wbg_ptr); - return ret; -} - -/** - * @param {bigint} handle - * @param {any} callback - * @param {bigint} callback_data - */ -export function ubrn_ffi_matrix_rtc_rust_future_poll_i16(handle, callback, callback_data) { - wasm.ubrn_ffi_matrix_rtc_rust_future_poll_i16(handle, callback, callback_data); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_i16(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_i16(handle); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_free_i16(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_i16(handle); -} - -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - * @returns {number} - */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_i16(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_i16(handle, f_status_.__wbg_ptr); - return ret; -} - -/** - * @param {bigint} handle - * @param {any} callback - * @param {bigint} callback_data - */ -export function ubrn_ffi_matrix_rtc_rust_future_poll_u32(handle, callback, callback_data) { - wasm.ubrn_ffi_matrix_rtc_rust_future_poll_u32(handle, callback, callback_data); -} - /** * @param {Uint8Array} impairment * @param {RustCallStatus} f_status_ @@ -993,6 +1040,18 @@ export function ubrn_uniffi_matrix_rtc_fn_func_impairment_severity(impairment, f return v2; } +/** + * @param {bigint} sink + * @param {Uint8Array} max_level + * @param {RustCallStatus} f_status_ + */ +export function ubrn_uniffi_matrix_rtc_fn_func_set_log_sink(sink, max_level, f_status_) { + const ptr0 = passArray8ToWasm0(max_level, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + _assertClass(f_status_, RustCallStatus); + wasm.ubrn_uniffi_matrix_rtc_fn_func_set_log_sink(sink, ptr0, len0, f_status_.__wbg_ptr); +} + /** * @param {bigint} handle * @param {any} callback @@ -1016,176 +1075,27 @@ export function ubrn_ffi_matrix_rtc_rust_future_free_u8(handle) { wasm.ubrn_ffi_matrix_rtc_rust_future_free_u8(handle); } -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - * @returns {number} - */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_u8(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_u8(handle, f_status_.__wbg_ptr); - return ret; -} - /** * @param {bigint} handle * @param {any} callback * @param {bigint} callback_data */ -export function ubrn_ffi_matrix_rtc_rust_future_poll_i8(handle, callback, callback_data) { - wasm.ubrn_ffi_matrix_rtc_rust_future_poll_i8(handle, callback, callback_data); +export function ubrn_ffi_matrix_rtc_rust_future_poll_i16(handle, callback, callback_data) { + wasm.ubrn_ffi_matrix_rtc_rust_future_poll_i16(handle, callback, callback_data); } /** * @param {bigint} handle */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_i8(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_i8(handle); +export function ubrn_ffi_matrix_rtc_rust_future_cancel_i16(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_i16(handle); } /** * @param {bigint} handle */ -export function ubrn_ffi_matrix_rtc_rust_future_free_i8(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_i8(handle); -} - -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - * @returns {number} - */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_i8(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_i8(handle, f_status_.__wbg_ptr); - return ret; -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_u32(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_u32(handle); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_free_u32(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_u32(handle); -} - -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - * @returns {number} - */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_u32(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_u32(handle, f_status_.__wbg_ptr); - return ret >>> 0; -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_i64(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_i64(handle); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_free_i64(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_i64(handle); -} - -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - * @returns {bigint} - */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_i64(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_i64(handle, f_status_.__wbg_ptr); - return ret; -} - -/** - * @param {bigint} handle - * @param {any} callback - * @param {bigint} callback_data - */ -export function ubrn_ffi_matrix_rtc_rust_future_poll_f32(handle, callback, callback_data) { - wasm.ubrn_ffi_matrix_rtc_rust_future_poll_f32(handle, callback, callback_data); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_f32(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_f32(handle); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_free_f32(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_f32(handle); -} - -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - * @returns {number} - */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_f32(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_f32(handle, f_status_.__wbg_ptr); - return ret; -} - -/** - * @param {bigint} handle - * @param {any} callback - * @param {bigint} callback_data - */ -export function ubrn_ffi_matrix_rtc_rust_future_poll_f64(handle, callback, callback_data) { - wasm.ubrn_ffi_matrix_rtc_rust_future_poll_f64(handle, callback, callback_data); -} - -/** - * @param {bigint} handle - * @param {any} callback - * @param {bigint} callback_data - */ -export function ubrn_ffi_matrix_rtc_rust_future_poll_i32(handle, callback, callback_data) { - wasm.ubrn_ffi_matrix_rtc_rust_future_poll_i32(handle, callback, callback_data); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_i32(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_i32(handle); -} - -/** - * @param {bigint} handle - */ -export function ubrn_ffi_matrix_rtc_rust_future_free_i32(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_i32(handle); -} - -/** - * @param {bigint} handle - * @param {RustCallStatus} f_status_ - * @returns {number} - */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_i32(handle, f_status_) { - _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_i32(handle, f_status_.__wbg_ptr); - return ret; +export function ubrn_ffi_matrix_rtc_rust_future_free_i16(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_i16(handle); } /** @@ -1234,15 +1144,26 @@ export function ubrn_ffi_matrix_rtc_rust_future_poll_i64(handle, callback, callb /** * @param {bigint} handle */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_f64(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_f64(handle); +export function ubrn_ffi_matrix_rtc_rust_future_cancel_i64(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_i64(handle); } /** * @param {bigint} handle */ -export function ubrn_ffi_matrix_rtc_rust_future_free_f64(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_f64(handle); +export function ubrn_ffi_matrix_rtc_rust_future_free_i64(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_i64(handle); +} + +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ + * @returns {bigint} + */ +export function ubrn_ffi_matrix_rtc_rust_future_complete_i64(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_i64(handle, f_status_.__wbg_ptr); + return ret; } /** @@ -1250,9 +1171,9 @@ export function ubrn_ffi_matrix_rtc_rust_future_free_f64(handle) { * @param {RustCallStatus} f_status_ * @returns {number} */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_f64(handle, f_status_) { +export function ubrn_ffi_matrix_rtc_rust_future_complete_i16(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_f64(handle, f_status_.__wbg_ptr); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_i16(handle, f_status_.__wbg_ptr); return ret; } @@ -1261,114 +1182,101 @@ export function ubrn_ffi_matrix_rtc_rust_future_complete_f64(handle, f_status_) * @param {any} callback * @param {bigint} callback_data */ -export function ubrn_ffi_matrix_rtc_rust_future_poll_rust_buffer(handle, callback, callback_data) { - wasm.ubrn_ffi_matrix_rtc_rust_future_poll_rust_buffer(handle, callback, callback_data); -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_func_impairment_severity() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_func_impairment_severity(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_connectionslistener_on_connections_change() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_connectionslistener_on_connections_change(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_connectivitysink_emit() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_connectivitysink_emit(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_close_slot() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_close_slot(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_connection_problems() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_connection_problems(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_connections() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_connections(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_debug_snapshot() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_debug_snapshot(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_is_homeserver_connected() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_is_homeserver_connected(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_join() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_join(); - return ret; -} - -/** - * @param {any} vtable - */ -export function ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_connectionslistener(vtable) { - wasm.ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_connectionslistener(vtable); +export function ubrn_ffi_matrix_rtc_rust_future_poll_u32(handle, callback, callback_data) { + wasm.ubrn_ffi_matrix_rtc_rust_future_poll_u32(handle, callback, callback_data); } /** * @param {bigint} handle */ -export function ubrn_ffi_matrix_rtc_rust_future_cancel_rust_buffer(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_rust_buffer(handle); +export function ubrn_ffi_matrix_rtc_rust_future_cancel_u32(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_u32(handle); } /** * @param {bigint} handle */ -export function ubrn_ffi_matrix_rtc_rust_future_free_rust_buffer(handle) { - wasm.ubrn_ffi_matrix_rtc_rust_future_free_rust_buffer(handle); +export function ubrn_ffi_matrix_rtc_rust_future_free_u32(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_u32(handle); } /** * @param {bigint} handle * @param {RustCallStatus} f_status_ - * @returns {Uint8Array} + * @returns {number} */ -export function ubrn_ffi_matrix_rtc_rust_future_complete_rust_buffer(handle, f_status_) { +export function ubrn_ffi_matrix_rtc_rust_future_complete_u32(handle, f_status_) { _assertClass(f_status_, RustCallStatus); - const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_rust_buffer(handle, f_status_.__wbg_ptr); - var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice(); - wasm.__wbindgen_free(ret[0], ret[1] * 1, 1); - return v1; + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_u32(handle, f_status_.__wbg_ptr); + return ret >>> 0; +} + +/** + * @param {bigint} handle + * @param {any} callback + * @param {bigint} callback_data + */ +export function ubrn_ffi_matrix_rtc_rust_future_poll_i32(handle, callback, callback_data) { + wasm.ubrn_ffi_matrix_rtc_rust_future_poll_i32(handle, callback, callback_data); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_cancel_i32(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_i32(handle); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_free_i32(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_i32(handle); +} + +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ + * @returns {number} + */ +export function ubrn_ffi_matrix_rtc_rust_future_complete_i32(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_i32(handle, f_status_.__wbg_ptr); + return ret; +} + +/** + * @param {bigint} handle + * @param {any} callback + * @param {bigint} callback_data + */ +export function ubrn_ffi_matrix_rtc_rust_future_poll_f32(handle, callback, callback_data) { + wasm.ubrn_ffi_matrix_rtc_rust_future_poll_f32(handle, callback, callback_data); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_cancel_f32(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_f32(handle); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_free_f32(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_f32(handle); +} + +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ + * @returns {number} + */ +export function ubrn_ffi_matrix_rtc_rust_future_complete_f32(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_f32(handle, f_status_.__wbg_ptr); + return ret; } /** @@ -1414,120 +1322,133 @@ export function ubrn_uniffi_matrix_rtc_checksum_func_compute_sessions_from_event /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_key_map() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_key_map(); +export function ubrn_uniffi_matrix_rtc_checksum_func_impairment_severity() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_func_impairment_severity(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_leave() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_leave(); +export function ubrn_uniffi_matrix_rtc_checksum_func_set_log_sink() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_func_set_log_sink(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_memberships() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_memberships(); +export function ubrn_uniffi_matrix_rtc_checksum_method_connectionslistener_on_connections_change() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_connectionslistener_on_connections_change(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_set_session_listener() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_set_session_listener(); +export function ubrn_uniffi_matrix_rtc_checksum_method_connectivitysink_emit() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_connectivitysink_emit(); + return ret; +} + +/** + * @param {any} vtable + */ +export function ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_connectionslistener(vtable) { + wasm.ubrn_uniffi_matrix_rtc_fn_init_callback_vtable_connectionslistener(vtable); +} + +/** + * @param {bigint} handle + * @param {any} callback + * @param {bigint} callback_data + */ +export function ubrn_ffi_matrix_rtc_rust_future_poll_f64(handle, callback, callback_data) { + wasm.ubrn_ffi_matrix_rtc_rust_future_poll_f64(handle, callback, callback_data); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_cancel_f64(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_f64(handle); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_free_f64(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_f64(handle); +} + +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ + * @returns {number} + */ +export function ubrn_ffi_matrix_rtc_rust_future_complete_f64(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_f64(handle, f_status_.__wbg_ptr); + return ret; +} + +/** + * @param {bigint} handle + * @param {any} callback + * @param {bigint} callback_data + */ +export function ubrn_ffi_matrix_rtc_rust_future_poll_rust_buffer(handle, callback, callback_data) { + wasm.ubrn_ffi_matrix_rtc_rust_future_poll_rust_buffer(handle, callback, callback_data); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_cancel_rust_buffer(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_cancel_rust_buffer(handle); +} + +/** + * @param {bigint} handle + */ +export function ubrn_ffi_matrix_rtc_rust_future_free_rust_buffer(handle) { + wasm.ubrn_ffi_matrix_rtc_rust_future_free_rust_buffer(handle); +} + +/** + * @param {bigint} handle + * @param {RustCallStatus} f_status_ + * @returns {Uint8Array} + */ +export function ubrn_ffi_matrix_rtc_rust_future_complete_rust_buffer(handle, f_status_) { + _assertClass(f_status_, RustCallStatus); + const ret = wasm.ubrn_ffi_matrix_rtc_rust_future_complete_rust_buffer(handle, f_status_.__wbg_ptr); + var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice(); + wasm.__wbindgen_free(ret[0], ret[1] * 1, 1); + return v1; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_close_slot() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_close_slot(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_set_status_listener() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_set_status_listener(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_connection_problems() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_connection_problems(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_status() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_status(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_update_application() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_update_application(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_keymaplistener_on_key_map_change() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_keymaplistener_on_key_map_change(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_keyrejectedlistener_on_key_rejected() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_keyrejectedlistener_on_key_rejected(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_sticky_event() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_sticky_event(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_state_event() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_state_event(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_delayed_event() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_delayed_event(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_open_slot() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_open_slot(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_own_member_id() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_own_member_id(); - return ret; -} - -/** - * @returns {number} - */ -export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_own_membership() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_own_membership(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_connections() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_connections(); return ret; } @@ -1582,104 +1503,120 @@ export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_s /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_delayed_state_event() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_delayed_state_event(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_set_session_listener() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_set_session_listener(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_restart_delayed_event() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_restart_delayed_event(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_set_status_listener() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_set_status_listener(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_cancel_delayed_event() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_cancel_delayed_event(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_status() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_status(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subscribe_state_updates() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subscribe_state_updates(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_debug_snapshot() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_debug_snapshot(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_is_homeserver_connected() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_is_homeserver_connected(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_is_homeserver_connected() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_is_homeserver_connected(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subscribe_connectivity() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subscribe_connectivity(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_join() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_join(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_membershipslistener_on_memberships_change() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_membershipslistener_on_memberships_change(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_key_map() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_key_map(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_roomeventsink_emit() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_roomeventsink_emit(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_leave() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_leave(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_sessionlistener_on_session_change() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_sessionlistener_on_session_change(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_memberships() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_memberships(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_stateupdatesink_emit() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_stateupdatesink_emit(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_open_slot() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_open_slot(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_statuslistener_on_status_change() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_statuslistener_on_status_change(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_own_member_id() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_own_member_id(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_delegate_delayed_leave_via_homeserver() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_delegate_delayed_leave_via_homeserver(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_own_membership() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_own_membership(); return ret; } /** * @returns {number} */ -export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_delegate_delayed_leave_via_transport() { - const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_delegate_delayed_leave_via_transport(); +export function ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_update_application() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_ffiparticipationmanager_update_application(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_keymaplistener_on_key_map_change() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_keymaplistener_on_key_map_change(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_keyrejectedlistener_on_key_rejected() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_keyrejectedlistener_on_key_rejected(); return ret; } @@ -1739,6 +1676,154 @@ export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subs return ret; } +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subscribe_state_updates() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subscribe_state_updates(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_logsink_log() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_logsink_log(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_sticky_event() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_sticky_event(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_state_event() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_state_event(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_delayed_event() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_delayed_event(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_delayed_state_event() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_send_delayed_state_event(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_restart_delayed_event() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_restart_delayed_event(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_cancel_delayed_event() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_cancel_delayed_event(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_delegate_delayed_leave_via_homeserver() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_delegate_delayed_leave_via_homeserver(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_delegate_delayed_leave_via_transport() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_delegate_delayed_leave_via_transport(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_is_homeserver_connected() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_is_homeserver_connected(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subscribe_connectivity() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_matrixdrivercallback_subscribe_connectivity(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_membershipslistener_on_memberships_change() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_membershipslistener_on_memberships_change(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_roomeventsink_emit() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_roomeventsink_emit(); + return ret; +} + +/** + * @param {bigint} ptr + * @param {Uint8Array} connections + * @param {RustCallStatus} f_status_ + */ +export function ubrn_uniffi_matrix_rtc_fn_method_connectionslistener_on_connections_change(ptr, connections, f_status_) { + const ptr0 = passArray8ToWasm0(connections, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + _assertClass(f_status_, RustCallStatus); + wasm.ubrn_uniffi_matrix_rtc_fn_method_connectionslistener_on_connections_change(ptr, ptr0, len0, f_status_.__wbg_ptr); +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_sessionlistener_on_session_change() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_sessionlistener_on_session_change(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_stateupdatesink_emit() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_stateupdatesink_emit(); + return ret; +} + +/** + * @returns {number} + */ +export function ubrn_uniffi_matrix_rtc_checksum_method_statuslistener_on_status_change() { + const ret = wasm.ubrn_uniffi_matrix_rtc_checksum_method_statuslistener_on_status_change(); + return ret; +} + /** * @returns {number} */ @@ -1771,18 +1856,6 @@ export function ubrn_ffi_matrix_rtc_uniffi_contract_version() { return ret >>> 0; } -/** - * @param {bigint} ptr - * @param {Uint8Array} connections - * @param {RustCallStatus} f_status_ - */ -export function ubrn_uniffi_matrix_rtc_fn_method_connectionslistener_on_connections_change(ptr, connections, f_status_) { - const ptr0 = passArray8ToWasm0(connections, wasm.__wbindgen_malloc); - const len0 = WASM_VECTOR_LEN; - _assertClass(f_status_, RustCallStatus); - wasm.ubrn_uniffi_matrix_rtc_fn_method_connectionslistener_on_connections_change(ptr, ptr0, len0, f_status_.__wbg_ptr); -} - /** * @param {Uint8Array} room_id * @param {Uint8Array} slot_id @@ -1999,7 +2072,7 @@ function __wbg_adapter_24(arg0, arg1) { } function __wbg_adapter_27(arg0, arg1, arg2) { - wasm.closure562_externref_shim(arg0, arg1, arg2); + wasm.closure572_externref_shim(arg0, arg1, arg2); } const ForeignFutureCompleteF32Finalization = (typeof FinalizationRegistry === 'undefined') @@ -2484,6 +2557,9 @@ function __wbg_get_imports() { const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0, v1, v2, v3, ForeignFutureCompleteRustBuffer.__wrap(arg11), BigInt.asUintN(64, arg12)); return ret; }; + imports.wbg.__wbg_call_2317578a4ec85f27 = function(arg0, arg1, arg2) { + arg0.call(arg1, BigInt.asUintN(64, arg2)); + }; imports.wbg.__wbg_call_2798409ff618ef7d = function(arg0, arg1, arg2) { arg0.call(arg1, BigInt.asUintN(64, arg2)); }; @@ -2523,6 +2599,16 @@ function __wbg_get_imports() { const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0, v1, v2, ForeignFutureCompleteRustBuffer.__wrap(arg9), BigInt.asUintN(64, arg10)); return ret; }; + imports.wbg.__wbg_call_63c160b52f6d962d = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) { + var v0 = getArrayU8FromWasm0(arg3, arg4).slice(); + wasm.__wbindgen_free(arg3, arg4 * 1, 1); + var v1 = getArrayU8FromWasm0(arg5, arg6).slice(); + wasm.__wbindgen_free(arg5, arg6 * 1, 1); + var v2 = getArrayU8FromWasm0(arg7, arg8).slice(); + wasm.__wbindgen_free(arg7, arg8 * 1, 1); + const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0, v1, v2); + return ret; + }; imports.wbg.__wbg_call_65360e4d1b0f41fa = function(arg0, arg1, arg2) { arg0.call(arg1, BigInt.asUintN(64, arg2)); }; @@ -2563,6 +2649,10 @@ function __wbg_get_imports() { const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0, v1, arg7 >>> 0, ForeignFutureCompleteRustBuffer.__wrap(arg8), BigInt.asUintN(64, arg9)); return ret; }; + imports.wbg.__wbg_call_94b3adcf4a0499cf = function(arg0, arg1, arg2) { + const ret = arg0.call(arg1, BigInt.asUintN(64, arg2)); + return ret; + }; imports.wbg.__wbg_call_98882f14cac8324a = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) { var v0 = getArrayU8FromWasm0(arg3, arg4).slice(); wasm.__wbindgen_free(arg3, arg4 * 1, 1); @@ -2755,6 +2845,10 @@ function __wbg_get_imports() { const ret = arg0.is_homeserver_connected; return ret; }; + imports.wbg.__wbg_log_f27a8f2ebe07bb7c = function(arg0) { + const ret = arg0.log; + return ret; + }; imports.wbg.__wbg_msCrypto_d562bbe83e0d4b91 = function(arg0) { const ret = arg0.msCrypto; return ret; @@ -2983,6 +3077,10 @@ function __wbg_get_imports() { const ret = arg0.uniffi_clone; return ret; }; + imports.wbg.__wbg_unifficlone_f8d7fe966d3a99d9 = function(arg0) { + const ret = arg0.uniffi_clone; + return ret; + }; imports.wbg.__wbg_unifficlone_fe0240768db0e3d6 = function(arg0) { const ret = arg0.uniffi_clone; return ret; @@ -3011,6 +3109,10 @@ function __wbg_get_imports() { const ret = arg0.uniffi_free; return ret; }; + imports.wbg.__wbg_uniffifree_b48fc51f60f5be76 = function(arg0) { + const ret = arg0.uniffi_free; + return ret; + }; imports.wbg.__wbg_uniffifree_c315e1fbfd7f9e6a = function(arg0) { const ret = arg0.uniffi_free; return ret; @@ -3028,12 +3130,12 @@ function __wbg_get_imports() { const ret = false; return ret; }; - imports.wbg.__wbindgen_closure_wrapper2259 = function(arg0, arg1, arg2) { - const ret = makeMutClosure(arg0, arg1, 551, __wbg_adapter_24); + imports.wbg.__wbindgen_closure_wrapper2297 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 561, __wbg_adapter_24); return ret; }; - imports.wbg.__wbindgen_closure_wrapper2283 = function(arg0, arg1, arg2) { - const ret = makeMutClosure(arg0, arg1, 563, __wbg_adapter_27); + imports.wbg.__wbindgen_closure_wrapper2321 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 573, __wbg_adapter_27); return ret; }; imports.wbg.__wbindgen_init_externref_table = function() { diff --git a/src/matrix-rtc-sdk/generated/wasm-bindgen/index_bg.wasm b/src/matrix-rtc-sdk/generated/wasm-bindgen/index_bg.wasm index 972914482f2ce5993883dcd13220ceedd86cfcb4..24fdf7b662213247fad432f1d3123f622235f70b 100644 GIT binary patch delta 314022 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%0A(U6A0c-Q4;XDb-`H#~F}Iv~6=0t}x6 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 g5DkE#Z`D(DaGpXQeGv@+1 z%da+TL05GD1#<@5UW0=~*A?0^xwH<&DrqeCIxnEgTJ#LnT}f)tHbl3^YT0(2J?fd) znN5_MEv}_;I>DSP2CCzAzz$Hd+paSMv5X6tjOnrT_S3PoJ$O3`v&ge>ZJ z(9Y{IymcgQFb}X016(%i;N{(DrcvCD=AGfVAmZvNsYr>=^Xg4zmFjN6*uR-wl~hD$ z4qkDy`K72zVQ*3uQW0n{*(rY_6$xizT3gxW0~CiNT|QKniY)$zd0ot2*e-+N-b*RB znR_9NIDVViAI3Mqi*Gmg@Hgwa)-GPUy2)I7UQ#O2p0H68adS5n*mz|^=2oW zjA16C_}~n?1{?)uQQn<6&1|4sOU;_}#+~NpF$c`~fuvyplLoCY>jf9wg~l*j!NSwn zV`z7WsEerEy+EP^bY_)#FlY@k?-MBh=31^Mxbc2-04(T(bsjW(b6;+K$SlN9@vymA zz_32}i1`+N{`*n$Cc`~`7A&>K()!1+oQmo2Vvy6p*d@a2xyJWq9WbDo*X3+c-zpq^GiC!a9cKgFMBXP9E=Rl7UG z6t63Uo>d6alsq#hMYnXGA;AlJmB5Ov3@ji21{aS_tu{ZiQ0+GUY(maygUa*G+G3`M zrskO~tM2t*sqyiVW^FumOC!y8|6PS?mBB!{qp&L0QvXqAmhy%?DBsMix@IP+aoZTPF%#_$2TtZRjyC&(`o;t~F$YyLj!;8aJ7dshMLMii5 zkgDxK<`_HkJZja}lS*|bo6-DC3wjBKfHfw!*TS_{-O@l120PmKspn*~LsQ^){Pr4# z%mW?-Yw(*(>@;)rnLezc?6Qi_K)uT4eLg-To?88GWaZ%yDvHl=5(1@X`uL@VtsA;; zD1n#~#0b7p#S^_}`k+--2?S51QB5+cp`qd$e)I_SZcAp9D`Ye6946WwpviMV9@*Df?};%DN-VE_cdSRI6-sWZ4g$vfHawHb#}r({L^g zA=2K{HX?039YQ3=ldY%wB*b!H_vsJ{A;>X15M!edf>oi=3a5KpBfFQu1ns;y6c;(R zl}_RBA`4epHa@cKDyQtGYL)dwmR;?X-B+!$36W*jIAsr3t8AhwYtP5p(0mj)3;S5* z`8bC8NMh*chnF;h9CIo>9|%@8A0LI9nC>(&{>)lDG0sw4m%c`UF->tgrqgojRG{grFsr&HpDOG37uhihJfKr3E8YsfY(L7L21mdL%XadxFAIjLmWgNQ*F@gLl8Q9KLGvw|2Z_^f7viq%rx7il(U0z z)^7k)h=C%6lTke~r{dPVh!iJKMv!-5PyYe_7n2nbTjjh(AdItw(>Gx z!tU3QT7uz?r~BrZ`AR4YZE)zh?KZ4MFz~h-*^rpSKephHzE?3Y7+Zpi0A)XK<`|#Q z_0OCA85plVZ+39p)+(p@bl`cjhcQ0b^aZe`;G-UVQA2O$i)K@wRwINj53QO78}A|B z9m<`P4$|%yar#|OH4DKr{zexSn(ZO?xUbNh2uPnUgrKZ~9-eF7fzR%_=5l;qe91h4 zqyKX+n?sFyYj9=n=WBatIPi^rWz7U?@QV2r^2%4uM~xcG4L*WKstnQ7^UYK={>psw z?xJbCMaO!q7vYLCuU*TCvFNq%;}E(%D7kyLK@6hB>gN(r-uvTYX-{E{VH~TokKZ&cc_L|s{p$}@Y(&X_qN%qy5)GB(C1U* zoQ87h7`ds)%={}A;FPZ_X#9>{0nVYRRQ|T<{;#S_wX3T@b;e<;zZy^c)L(2@_J6CI zl}>p|Uwzl^>DhNMiT~R+@OmZM_?f0HHhb|J_AW8&C^%HJt-yt+oSu3QXXuUe)_Z2l zw2A~^R9&WSb$oUC21!Z4>HWnJ#Q(o(KDc&?nQVY`Yz=~td^fWg*PbU0YFZ4nidl3^ zF@)ZP_YchI*@N%$^gmy6PZt}4F~!0r>JG461_kge?-N6~ zJPP*AA33UE{FK7d{JhbD8uqU|{yB*KU^+1zF~$#r;3yn@lOLUL$%lpldxxOP5kvSI zojIl9D#Vgmbvbnh+rDy7d@(pW8-TCD<{V103gvwDGIWe3hxz$lj7{y7?-7`bS$R8L zL;NoM9x=?Hz=`NRbW?^v!vx3kJoeqy*#)62_y|M{4F86WtjoG1{9EF;of$$HRcQjY zMEH64fC<3f1jw)spNE@^MGA%lNay(z(IOfMH3Wx2+_u5_;@M9Mbf4HmD4R^eeK%Xa zF}1?46c)630|{32FzCO+lsFw={pI6LpUj`M?VY2pF_3_=eQ_YA=hu5@{PM-2Z6${g znF>h%uxsisGs|`a_qqV;8ordCzka-7bj70W!C#Oeg~7m8d;EYYyq^vq#(h96>&Wp3 zJw_LYWV>8}G+)gzfttS55rI_b3)UDBz@MH86UGD(tc76m1a2VJSF@)Vku`g!PVm)4 zd%g+C$sNqAg)sV*;!8uz7`4YN zM4#HZ5M`NubzO`5{rh}zSJ+7aeH#}P`z-mu8)JQG1^zUI^Td5BuRxR86F!|6_PgkORfi zQ7~-`vZ)z#@?et31k$($49uBlUy80k6;9*AIuSD;z|1>|;gXCWj5WZ!5rI5zn~QQm zZcL?c4lavKj6nz^YmJ`1@dyH+Fy;I{1^|p5)xs4Y7_V)Zgj&Aj(M+CL{2c46F(2z4 zb=Dq_6>!!yx~D^aj3;d*sB(pb>PM@@vXg^RswyD$o00%u|0CAdbweYeL#W{4H3-a&WTP23YZ zx3I6Q5*1<9>0haxc+w^zduE|NjjXz8cw5^ndW z;1o_96t~fA*Yvx1zlWC;Qz6WScS#H;6N5*9felT6&`*$3?-KgYMkxI)p|>_dPjCDN zy8AO+JG@U>Rh1OHa+7(N0hO83&E^e%Y`^Xl^o4Lba%wX<}Z7jpsWq;e1 z&@NO`N~mc2w8;?CB*yx(8>Nz^C|o{SMj@3LrL09|jcOE;ivRO<&imdOgO>02|9w1u zJRbAD@3WutKIe5_`)ll1z9tq({!L%|2Egxr<^iCM>#4^9U*!(#HO6GKnlax*|5J?V z{R6)K#WAKP2YowAj`A9eX=Dgv`Z$>Ujqg9++6H492O*NP+NwHrSO!u5bLEQ-A<&;QEfk{5g2s5(lirSG77ZAv)Z$y0&Q7TJzB0 zL06j)=`YNxS!;C5>{)@oIh!)f3a2ptg|EZKWA(T&$!jdw1pO2#24KVVj1twX516W} z*cr~mKG0z5e@)mOj}n)Gsk@@ZrzNMmVCpoCyfk6AKiD!x^zJ%3BMlRH8^jM2AL+7|e8g@>6aABsYk1lL?zGsEcz-*w71@;O39*W!u!x9<&kx791kLx7ypD*VJts?-=-~c-K3F) zNm(9e3Hi&5GM(8Tl<8jo&+OF!+O3C6FkJ>(-7t(pKiL1{G>f^F&gqb~^Eu;%7*26K z&IWoI%~@w?ba~MU-T}9l7wK5AbLB;5tQp3B(>*n;fSkQ_X9ZE7_uaD-Qy zVMEuT$pOI}r_W3hHuPA$jZ4)V7JIp3@S9Z8jkU(Gp@-vvy`0Fj)&?t7lX*XeQ}j@J(u*8Q(i2&g zF2IG_ZBAy58bwZK5EFUIDtY{}IcWBKDWqRE=pnVlfq!vjq|o^WVp`~8%BUlrb8kMQ zzIP)orV@3O^G4U$)g1e0 z0mZbyHd#QmTZsM$oIou^O2seQr^Rp)?v2G;=q@1K%IIom3(?qG5R7Rl)_bfC!L6gJ5 zW!?W_m#l!rl0(VWbf_t|9YA+(Tx9&#agj&eAktYrXlAtH2GIa-ZfB=%_=lbKbvtw2 zyI_92MCi~>K*io`> z5{>`SVlzaady}aDj|zvD3G6nvcV^6DY0hw@WIdAV5kDNIJ8s4&o+;LW%= z@ZrxPwXF$w3!0=i%VTvE?mlRP$sn^8cDq|a2hi1pG_k~mLbfq?+=8R{S38I&wc!>~ za~R`<&{~^{NcOyC;ZEN}TW%H2^lLec0w$-oiQ4)V zj!N;`_BL^EEiTLs;P!x(;frB!ns|YyFQmckkG6$@jYx#^ON4(SMfMa`lexw$`~l)* z4M`KpPB}Cnl7UF?p@bfyPGY$K1aO5A3e3Z1FA+FCV|$89e_4Hc4}iwGw5^Az)(ij^ zUlGx^*cUtV>cO%0Ux>jg|8fq8@;O)-@BxcO4k!twLWJSHUEEe=qB*yVwA(NzCYezg zCfm9VRt$`Gj&MUPU)z%q3$~HY26#Yg%p!+HcZ{>?k{SKmHMthEPPwcF7&vMD@PE2A zANLe(B6+CnZ)*>g?j~%i*?wW#XfV`_J;vo!VO@!WnhB-lFnfe##!bMa8z< zmRVX3xS?HfT7W7n$dB-!Ws|P(hd`&PK8FL&g?fir3V124?k$psg~yl>E8TAm1txq_ zF2qy87#T_QIUJhKZ2?K_a0Xd`2go{Gm<6<-tEGY>2t=~!5f{Q7@ii>}Oyy>CtGa5m zvy7ef>1Cli?-11*6ln?=wBCIFC4lxrKx%{rWTsR&py28|aDiWQxC7tvaEDN0w7Klr z*=K;0{O-Gcfm{rjKpP9#Er^La)|kUo{VtISuCOQ@X?~JWPqxKO>=$v-p=#!eUNn>>R?wl(?`J2^r4faFsROMuu}ToWRsATUh&Q zzyJ>;vz*=AQTr6jAj5gZvgoruqPpO51y|mU2?%a&Ot4{Jpf9Dk?;vYnfDm_P>9^q2 zd&C4F3(P_6VNuq7AvB@^fsGgpK7T(5Pv8>ZC3gHO4$#H zhk=!Vwb+;jpMl7B(SC?*UmqY|xFVyG`VJIp`G#iWuW?jukZ2=K5LJ43kSH6@362{i zUi83FDe+-|ut~w|9~SReHFa2{5DP&sS5Z@%OMH<~jUl2U8wP=6%st&OM0CEY-|J;V zME6VlUdKEl=2^$zcF>L8N266V!PeSK=zV;c>y<3AR5DR0MZm(i4Kc6SR6lREs?af4q*>%<2NR z*X#7?6CxwQby(03+)hB`oL6+u%byVJuK*4X0+jI|p$(~e{6|z{rv(7N`LF6yFa1Z< zln3YQ-)sIO1_Dwi@`~P*E;Wjv?%C}O?Vn)TQ-$?2IvJLR1hfiDfH|!VtfKB zLIkUs(`-l0LW68dc~+FEpj{vdt5#|POl;5kF{Th1||b&qy);)fKQg`v%$^ej;~_T+wMHmt#2 zHFyEqM69qOQX)!E?qA7j@kG9``tH94_AM!8dL>bB`gk24FE?JYYS9 zpmV%NVqDxOwzNil+?%8n0J;|*ywHLM`9O_Iaaar(Rl`1F(+E)&Ucyd}5P@>xTLDE% zm~a&7jO!dB|430q@)%~VpzhC$1jLZ(_dH0isg(1)sMnQq4B8bNk7E!XRh%=8y9LDO ztJ;rq6wWH)%;qep>2OvYU+}!2uGU-kk-E2MMvA88clb>C(A=Yn%$;_O6y-C`Ts3~+ z4`0g~Kj5X{xUpCYHyb^UrwXG)y*@>f3or9(5kEc z@m|DJWz>KdA1)WYPL`P_w$Z!VD8!Zwd%|~a1X&qW^8qQ6Kg_joH zKM+^oCbmIu5ZobzZ~~jOi(r#f`UPNb;jKW<3!+hx*Q^&r;;1~4Ig0{QMQ?=q7&=v?*O~QldlT8g zdaRB$YeM@+HaPZUoZ@k;$50q4{N^=pFVoJcXks#X2}`_>o+i-@ILk^B_u!E<4L9{< zdUTqoqT5x_CqTU-?INW}yLbz?`{6X*?yu9pe|m>HO&2fY@#S<#dETKeGw|3)@6Q15 z^&R?g2JY?o)N-asLE@b=bz=5RaKZM`FEhnMu#oRNOH?Z}i^C#vRC&>db=&!QnqTS3HQMrLT(w zdLS3~*{cpIWquR?%W=5s_+E+kZQ z4&edW*Ds6lS$5IzB|_`Rzp_N!%owL@dVX<<=*_RLwfenpiL@fQc+={_qi71|5P+NIdX@6n#6rtkAh4S&DJGSMUyEm8BJ z=%Hnz7L?>?E)%V=*Y_*MIcyP`)cvEB9+{1RtxRcv|wrG{pl+Hp{cR12fC%;;FArAMa?N3GE4TvPKZ zLA_~c*qP`ubazm^ZM{wLs~95Frd5J1_7|>(=u)tJ%tz(dKv)<39zOR_4Flwl~xbaJccS6oNvu203Lk}vs;j?kfy@O??J(KZqE@c4hq7ZooRz6XVb(TI>h zl)Za;0FS@ZrFs5NwOWiBJ-?fci{u11Qz4XqP2KMzyjME14a+lbNPqJ^9Nb(mST~O>6UQ6s?E)d1; z5i{JMi}#2@SdVgh#WUXPKSQoY1XzI&?&`CCFz^5aE*U% zuJO;Q@z?qqU;VYd#tY2bBM0;iKJS1~{59S@7(yUM;;r8|8Y!6kjYec&{8qoM`WBM5 zUF82xzqR^KBMcY51FU+1svi>b`HIsTX&N-`IfM=Q2~|A|p3HLUc^Jj&(x}5?DVk_> zM7#p#)}A9kkKUo*j))*ok7Y+i{l>0aKJX-&c?jmac1z^ds%6Z-1ou1LbDF=H$%z3Z zh(#pA@{zhLVzb5S10v$?rPP=A^SJHYB>8k-ev3>y%c>>nYV zxgeBDt&f|Q?!Z$^_apu5Y1nZi@}GTNG~{lrnNbOJ?6^qK!A=1Vv75o2HG+JI^{*Bt z04LO7$e13B|F2Tc;cNixt7HR*6a#T5K9p+FGvC92Z3K<^-duujeGe6dUuf6&VgRdY zv^@cYv@Sh-LX;im`sxG26LByc7g`KTRagxe;-z~Ar`fDMj<%s=&Tjn7NyRN6fgeTb z6jn*`8b4Q%L}HC`O+sn}LRv2u-Tb3yt=U%A^{m9>d`Y=Kia@Om-0VN;XGhisO8rqJ zq{I0Y|WJ#b1q4fK?87bJl;{qdA|EQF{H|5+32gMWca0YKJi&>p*j ziD$s#L(D+<%PdE?{3;gVw{=$3jNgQHDhsoLkdovN)Z(njM(&ogq7Dn^ah@>GKYU?N z9a-Ri87OA5GQ&9y+ziS%2ktu`E!6BpJ1WK|*Whysya3qe81Q1h7pCqN9iL1%XMo`1 zbE0aA4_F)pLvQU|^)wws8Z>OwZ=!D01a?MZIO1)7!(y(CntEQq5OJIp<+TtqBj-0! zt=yj>uGAXirUm{t+@|t>!+r1~UHlF6nM{H6q6LG(yUvT|{G9DR_qoqi@YIw6 zyrp^v_-E6c-$fNy;}>Q*aGt~LU#L(qC(Zc-MOM?n-!(!-7k?KG(x++RWr3xoVm!6e z7N(JDJVEjoMZ+*G9!tIc5OqP6-TkL1OY{E_<&0+&XADp;)5aJ;e3q)C4Jes~+n_^# zh^jn=m_H2=t@kG;svF7-jhx${S$~QoF1PAW(Nud*LqiL|7=m*Zin}0GC~djWpU}S? zA8s;4#t}{qh@`PmGPZj_E331w79D^sJLy)@|}uKUwdN=sJBo6=M^wKhz7T;6Q$o$|44j!&d4 z*|JIaGF<94t~7D=Ee91D-jR4;Q<#+(%A%o`)K}{?OQs;w#41ZZ?m6eBIv&}eih;*z zkT5&BtV)L=zrQUsg*;3l%9+2B#&~3JxFbL8k!gGxMS5k`()(ZFYhfhoV!(Ak7C%w4 zotKAA)4j4h#=X)jwJzORuhd(tkxy#3%)Nc`DY)tX(kHLQX9%VV*^@Dvp%N^^U9?`B z>dzAbNKe!w9kpURAsJ($>PprutgkutSN=6@q)uZov33mSxY1&6@hr}|Oy zSTSBfdbI3lFeS$2n238OT7HJ>r)!K{g2x{*aycY^5cNQz)ktSbU~|T@d_@Ehb%fViR}P|~e{mftNQZ;D1e1WaYBHJjq&B)cYS9w!?X zYoL^F0Dwn8Dc|(S4aCU?cpQt99ZI4d9Mb@7)56WQ_RALBj+F{k3G5@N+9aSIk(vPG zmOuj9neLYbpz5>Z20vKJoDmXfKITuSxqTm+ZM^PVhN*u zgT2C%w#oDj>;bswg+!^nXyw+4)V>*Z)QQyZ7wbfprrdHefqh2d<2M-K{|P?M|6dzn zI+lZ{(XzZbU-yA0MOy%@N?)&!gW{r=Pmv@FfXTJ*aF?cH7TR~Q_R!prZTUslE zttv|JxVO@+De`MP8V0cIwo;#fydPe)w*=&acr;3tCt|m1wYGd#e~n&3&W+Nw8L39E zrb%{f-Jp_mU0Yv6-73q9NP4I;`f&YQCsdZ~-`Y)L|JJmrvb+e5Ph8i7DD75RnQp0y zJ-nN;tIC@3yU`yE`NDVh>)O#Za&M?6tHoi5dmJqT#dpdsLESTA%h1wUk+HO}nvB9Z zSW!*3#pAbXl0~tN(`5!8{nGW@tLAM-x=e=ax*yV|_D2E3OVF__`Od5^(^2~N>T)$6 zrE17pc(kse&*Q)vvKrnd)sQTL`)>`I$r4y#{$SWx&LLcC5TVwPb5Le_O$lV5-m57) zSW|+YTJo4BjjSAD(m13%w@AcN}SDwswu)|Cy? zG@-%j<6h^B5N5dDjP4+hWRi~#p!o_Xr)jDHm>CZ#ho4Lp@Dqay)RUPd%%E`ln^E0a z4_{y}jjkvAGWgfhbt)t8Ai4fYxq@BY=$X<~g@iJk8O)PTWS**IgxuXI2F z&C;$ypgwD;mGbhuR$3 zK;GnrFxlTg{^HTUgTbARrPpH}rMJt*B;oPPHL^2qPN$VDUmBugke9%?jv~G(It9bY zil)KyqRXSiOHE~aJa#mdH{nsG8BXR*dbFAR5D%^$Ral$uZjL>#lT)X*ls3KIT(-VK zu|O-hlPgl}wif@OSf_u`(CU_d(@^#12ca1S=!?l_u@5u)d?m+sY=OG2Ut`lgrIO$I$o$@JN$jiZC(Z62ITJm6f6I zs@lm$U>CJ)CzAlsZf_?uV|l`jJb$qM1$vy?4iIxMt#1c>;WN6Yy==yJQEq$r-hJ7d zH%6qgL{ha;sU;kKH49<0tX&1X84(Z*cjRAeEQtUcyuTxz?>2EgjD&w^odZM!hD*RU zzSI&i+Eu5n$#My2&1TxrLDq;`%0*!#g;hS&K{odnzT0V0&VmARI?DQiMPRVA>K#bj z_x0e~L}6fsWodFp*`oATlVv08C^yTJ>yPM2M_Da$C(j|uf8Ikw)JewQJ=9 z+%H|PMEz;v9zmv!dyjQRO+j!UN?+# zKi$?%j;5Z(Y+D)0cV-+(flfn`GoTj+t`&)f<`;frF3!W#xr_=4KphVUCZ zXvA&u>3SoMhR$nFG|s29e0}J=7Jyib58Y7$92q8!N`lQ(yNCP)y`S$PYvb5dzg;iO z`rGBRF#2uY6XSfBdi6x!7|QM`duE0&JfQVZJpyVSDAm}Dn^-un>N{=?|Ab$)Rs3AO zo)UV=o6GG5sR`*$ZzJQwuRb9$&G25puqRR1-f|B@=A_>t@4sBK^v)e1*2YrYo%n#O zsP3J>Nj6iDJ8`l%(}X(_SObUfqdRf#H`C!eq2Z0!kPxZ%T{`*NyJR}z%<}zriO{FG zV5XQ5DZuYWUNsod&f^@@@~YDyxi?cD+WdEtrJ8;8U^@1Z>CBwPVE&~vr}%Iaipi1q zJv3aPlq{*mUmotHNQUejo8HkL&*;ZKvUCSCi2tp0i#p$JBxn8a#$nk&-TF$`!MA4)`g4vq|R2xOc_a4&Qg;ZD(5w+sKTm&Ui@L5M9xhdfIpQ7fJpx39(jGaU(gN**@h+r z1I`$}uKXHRzWrWVzs_H@J)ez;Oq+mNZkzAjE35Km_UR^$-zyvXx1NWr{wuAom#9-~ z_mf={-7DVAN)O+?<|p@)ojpIq(t&g$T~Q&fdN4OaVT34G;Et*cxr|ew!&Bs zyZ29ua>nBGzg!~PSxajN$Z{~?+%-UUahY*?;~Lf^el9nx(|_9FLYg;Fj)&52-9ggw z{N|zh4`Ng=(>)K$56WWM5NOJQ^B`sw2-ZSJ=+Rl!;vs-MY_Er8O2&@44hNWqV4`}& zC;S`HNmC^=rGca3sxw#(1Qpx}t$Ijya!!p~GlNC%H49FFSF7vhK zs18XiruJ1e1$#BVhK3H2&jY!%9+CIrao;0yb!1a;E#QhMerT}zqri45tN{nc>mY0} z{vxU*7JUTt6j_e${}ud#$7Fk%2Wc%7k@q}?3u-!Dcucl*zI`1xc_U}q8`ui9XW~oUY@FA~4@;F-;>ehxnF1tp<&w&qngnb;)myZJ`@1puo$Z9TO0S(*+<{RNx z6AX&4>8#}b?n z8{lt)hBiG74qMY19Crj|fRusH%@2J_fl=`HV`>G+2S?$ARo2p#h4I)IucRlRm7Ppn zbEsi0h##!xwAF zqH5W5vK*9Xcr#vgM54%uco)}+7-2@Ecl7y{6gdnGE6n|-VKS|{A^y-$J8i7bJ$6DZ z{syL(JlD>P<_wb@6-nFQaojRKKpGu$;AZR9Ak5l0E)ovS%pmO_CX>>z^C5L|%P}(- z257+`4A9))%Y&4dh3gzc>7FH1+k}TwK0K7bB|}Lx-v=^wkeyrx)ML7b%Y@eF-7I;X z#>wza6h5;(Ts~Jfq~@fRkyxgWk@N1u)`7oA9@Q%=+HvqK{Kn{4w4>l~*~zdKxqz;~ z3{ej=M6pBBaPkOw-LQ)gqGm)auu3QnvuSyKz`ZTUM0J9j91}irFQL>u&jUS~OlzK(I=97wqXdcc8uJ?w1NdZLfc!?j2Go8WQ@(0V@vCC;RFw0J9}Ffz-5u~ zlALCp32uG~E#dk5SP9v9zN>x#-cP!d%WrJJ1Aq;4MDxyrE0P<$Z5+7P!+vGWV*hAw z5-$#%)asC%(2wVIZ(({~gqyK|GeluVmI=}cdXqDviez})8izQel+Fl50P7m#OA172 zUjY!6mcHWH=(-$vqx}guXdo~@q1SS7n=PXsb7WaOysQa|Shf-rlhL z@DHbCl9ga0--^H`u!hqU(`25(ALQlu!}ZfO{_yPdtKkpK*I{%bp4{a$WEO7r_h{-Y`LfJktgq+lvtX;j59?W{TGa3{}!7;Xjim?P7e-3Q7WxQq^H2XunjeJ;cY-_>RJ z&2?+8o+Gv6h?8>+(jPrn)=1HPI9ry3`_mYQ>>>`?Dt^gYf#Knh-8>hjH5lI$b7iGM z_F`oN*3n;js6Q-<#TfZyS~piFYTv85pG8)rvvcL#G8#_?1BG?az2KO+Sn}dr*|0j4 zH*l%*m7}vQ{|4sSz%wNCxu!|35E$S;WhGG-D`N)cVdJf%Ci8$9zDZl=$p?9OjbD+Y z`MLfTgQ)I(1@!Nm^xG?j#;p6QtOifbe5`QIxUzEm3dzcK200(71RDFQj6{4gY#szC zv9x?xA4bHg+e>#3QOQ*Bn^LsxRaqJY{vkBX{l?Ch0UZsEZ!xX}%>=ARCRYko*W@DsP)uIO+cYAPFE=)AwY3XAg!|^FpXlz_aa5`QORNghZ*Qs;USsKEkxN4W9U+;|)e>P+L2;l`IOkR8$ZZwnyUm_k+GG?G(y znBCu$+lLjJM7g@utDsVC6uMy=1rmpquM4Ah6&6P@b2oPjD`96k=fV{)(aOf{2wdAO zi*pRueuE%%=SvLN63tmC<76J|Z@)nAE(Cu2Ib|%8&C8u-NF9ib_eaFq{N14Bi&Yrl z|C~lFl8sU7zl-E`poisR`7z#hECyTh^Wgc#GR{gk7gE|QTCKucGE?Xry74WDFh8e1 z-;zz;exkV_C@U1H5bXXo2pns})a9})J+@SqwAuSD4k@S93ct|%O95Q>2Tv}QmeqZy z(Bc_^55UADpXo0`NeMcMF*8>ORdA6+XUc>PxI~!{_v!72wSj8^T(>^>n`-fn>}%cq z@0taeGc6x2-m*`JD0DjjaPUuM=Th#J!12pij{9a#aN%<36u<|<$1CIp!}5!Q44j2j zv{Ft$M)jcl6pyn(h|OlwvQ_d?Yu2O*UzDNNRib>r;ZbVwUyy(^>0a|T!Mv@)8yAiY6^?mN7ry2_EuQH49vIv+Y1(_TD;`JRlhE;_ zVQX-^&7^nM$ohC3F^{CR*zq%|?^-ZEk5bNB-B%EA+`1KReVxv3x(>4bPw3b>Im#aU zGSC_6e}f)hFZ;nU-oEuR)6RVjiGKegDwQYG?1@|?8bw;<$%=(}_vAs+v4iI4$@cba zE)sbF1f0hQc ziwp?dN-CQA+!T|*NGQz98G2}POr!fT3?2o8S6KIjutC1ZJUSF47Y3Sf`hD4sA!O4J zWKtyqxur7_{N^WF^HQtxbL?J5vQ5`1?ZK;_N3GjOCc5#O!rjvP56s=U=L0z`L-RUD zYW^Bvx_-;iZ$L23EAvDQ18fzI+K5#;OB>qDQZ)FRNFRN*QD%C6w<&IuELW%p10x79 zv^5bkndN|bT(|=G5-H5mQbW$7KB&!%6rd}@$qJ6x1jL}~w6{M%3))KKMNKfqr0NzS zO#`L@NrPc&ZQYCww39Aw2JARa=^x7cV$2X3W`@LV(a228ErrMoBppSVA=-HyqfsGd z2FosuB$J-4T07Zuau7RW}0E7sgd`_jd z%9^)xC!h^=&BA75buHH{QD+)cSO0nmV_EHIS&slyig3nr8=w!l4Y1qH999r*mCd8Z z0N!Lo_+dOrKYlFB4g1TLW$m#5E_WY0FNyFkiG+U;Z8@nI#SzcUgEL^4dTAoV(!&C}Zn%?kaR1?b^*!mkWlioC8WEKHO0HJE=d9}Kpc)N640bP!-7k8 z$dXp_TFo_tIvmISQkwwT*gz0VveIQJTqi9vr9VY!H%g{v5k=wB*WlCs z(vUFKzJ$E+Tk7_uY|yeWe&>}1G+KPbRt_Q9d})&#+$IlxDc3<1GIy6u>J0wdDKcVJsU{~jse?cz?coEcn3`wp@gk|0TQQ@IXujlD9; z!wo#<4@FaVknn^{t-g{XW~Ga(z7>hX68C0wB4v&j3Do+cilX~#Es-<%MRLl2*n z+JocCnNgZgmwQsyuV2C38)`qB9rJQptU(YQvbp^HNTj1fZ`Z)6tfOYe>CI=S%$~O;}jbAq8(|m zNto@1A7qFv!74By_DfWX)pNOFc63<|-OB?j&u!|Gz+ZgqTgKzsRIk*fHgyLsK4~ z0}N-JC}_VhxAd3g;G8D%@9GgJmbYsh;Wxj(EFtdiod0=5@PE7@Pr?=SAR1 zu}?0iJno(R)AC8ghU$Dq_ThD3bjCopkI%>&Sbyv-+PA^3N-4j}l1#7XYLk6x`l}q0 z`h8f>hn2jeo&Avd7$xt6(DR9Ln$y-_<$cyEs()6tW=+1w&&nRSZML126FvJEQr~m3 zp?B#yi)NgY6~KyEbNwJ|DW$c=G(LA z^aO-l5|q&2kt2E^c$_>pZZFt&Sj6lLvQO+E$3R@AJM)j@7I=-$UXU{`O$yGrC?l-| z&E`3M5@o^WnfwC^{}8w0J=Mwzm7e^)Za{g|_5PD+%wcl9fLkqyqkBE7vgcF`WqVYg z+F2;6b4PNO0v0ne9g^bW3B@|0M6a67Xi?CszWWQA=pLVX8XN6qp_rr{AruqSuM2fO zM5Bxvi})vle+bpmDrZEaKyPp`u!dNQEbuZJ#konTHX#&eroxcV#n1+&D*mlp6p93Y zgX9Ek?5i)xu~k?2=gqOzXVxopPozSGAsEm`DlIlV5vguNa@#1?0*~QQD$T5WG4>h- zqtvU=SLzk5?gY&EZ?xhI?%Qbf2{-0kVuJcfj4E&JKuXc?F)BVyA8@_kSJPjm+OaB^ z#nAb&s-ndZz=)vi+?Kkd7Qd7Bz!iwC$F>5 z2%mYwVwIc5tFZ7Hh-8{i`8P&Wm(OJ;?Tc5j?XQ4PULu5s9r9lQ)Ug|4^y^Ehwp}#(d{A$LjUjB>AlKnngItGS4RRfRHPUtcN?j9FZEU!q z32G{^YGz_GR$ZaAiVI=YIl3pv;tf`f%DfmI%cw9`J*kXp-T4Z$FN#j1+TTw8LZn9y zQ#5{?tVV6is$2Q=%q*)`6n;u9Ls=S}sK4a+MAZ!^=0KvVf`=%ls^U@0JZ>tdYGPKy z%BfB`Mp6104GZolr#gm?(QZAfT>X)M#kI+Es++8?4;`bC$*OkWFBs`#2|>WuGy-C2 zSZFdN^EzOCXsCXLNni5G&;8x3DWSZ&oi%>q7<~ltnNLrZR}-q~l#OBl(s2i};*BZb z#bm$?b~q~%oU6JORBc|KW7^6k*uR3hwTR-(=8Eb~K3YRkR2rP3OiodOieuX$hv^_;>gN|bu{Q;lFw_hmKJ z(qu%s8G&@wnOAIJy6VQ3Cz3_d_~2S_m9B2kUU#6dVx-bq*2h?}=2^_5hSgPj`|}x_ z*sy5@#g?^GJio?KZ9L0=%&Ee^LTSN;VR&y3mHfIo=%-)frq)p9tT!mBhD!1O8kfrU z`q+AG`Qm?`I@eH{_6J6uUDI{J z(>2s;EB+V6D1|Nw6mXsWs15e~x>~BEofm2;Hbd2g_^efis#Dnf6B(*HcRDXavHY@s zZ8ZRo&ugoxcnqkcQt-&Gqu6!Lhjnlx?4p!Ro!BZ<&BohTnToyor`FYvesxt7yv?br zc2>d;*1k3pcvOs>!uA+EgEqr~Jous3?Mz!qQ|hVSbq!(dgQt3+A536FEaqXEH~#t! zWzFhZfK~wRfdSYeY4ug6wk3z+FAX1vn_zH#<%?uRJRncb3>sQrT@MD~C-v0??D;zy zsMUr~=(}9#nb8oyGMjQfQGca01=&ZKPbf7ZJ&qPMR9b23R73Slx)FLJOVdxwlodG) zpvB{d@ED>N!z4(H0C#tCBUKMe^kE})4<0oetATh>W5u%Ms3!XDi6;8(xOuzf8vVBA z8pY^(^``1UhN07%s@MMl0~y*(4F|Bi*i2&}8O=2Yazk@<9qvii9uo1-fZ7dU(KD&; zqq21H{pL7c$p#(amG;6PZ-b!^A?=ZDZ|7oQv;1o@1rK-d4!TMI}S;QA;-dg>~+D6M; zs~XlqI?x($=L~IkR5RUBX*3kyMrm1NlQycGjxH0S{Wby?OlqSv{h4=JPI6lyJbUQ& zw(4HsD(l*+efTg#+N)Z$xt&^Qet*i~q;&_C1a3*M4yuEB)S_)201DoteH|d$f5po} z+tR`4j%twwx5dFu>N>f2J+REtWOv4AnHy}>8C7AhH}qPZ!BCOBpRQEo!LF*G4?K75 zsYo5ona>Ghs%{*+SqSau)Nru|BR*A-lUx{Qk#f2XOt~-ANt-nQ8yAx(ipol;{^O&^tJ>0ChqapW1CKMVr#TXqh5c$UX6I-j+ttz#&iyXuBHzJi4 zp>baQQ>gE)sz3bQ0f#XhK@jEOIDozZ=Z^a&ai<;f0s_B@* zUSl5)mK%)V>CxNN8w^d#_fQ2_#>lR_T}|>g#Z7H+YXAjb{1d?+Z-+`%c>^sBE(vWD zz`k#QbpdcNxVWxYA>uWs7hvoM^l2{@_*+=eOARb2eUBC(H z&NPHS1@UA?e-N5IKCh^etEtkM2q$q4^q`rBpfhPJbZt^3$lD_wJ+>JGoG z+4rfiUsia`W529h?gK)&mrmWMYFTdwE8Y)0g_RwF_qeKsd<%oqvv~uQ9bL7;^&9B+ z{y?*KP)>hCCNA!;k^z0U^jA$7D0&`H>8`d3kWg3K1iy-EoA`{j$(;`ANm||}gDYlTB4pi5$&Su5dzDgazC;>W!JARgBj0f>ESL^05s|07s%j_9fjvFop zqQNZ|QrtW+P<1IeLA#CW1O|}ZAvP9=b}O|Qq%!3}@3=hU)%fW_Ah!G22EwvZYqn{ZzLkkSe_&Pyg{+JuK#gRB%ScApJM4#e~0!@%&~q!NQw z18!eC=jk!nkP$-$n@-0LR+SSqgOr2t9Qgi_oDkAt8|NlWNN4$@Jz^ zY9p@Ghn~i|@1}WA13g$xU7k^zMQ^3DE*H+y)G;)Gle-qdCv2!P4|X6JAu4 z=#8POzR`CzW?_KpF@WdZREQ2m0D&Or*P%-Lo-i0PJLHPdoHvaJ@Va256(}Q#hxFG3 z_5_Xq-FLV#9rPRyJ+`ustd~@yvcJUYP3N<(-*55nyfe)AoBx~sjqjId z=uP+2(H+^!;mw|#t&+=`Z(?DeU;0hv(avlYfIAeH>#|woEV`Jjnq1}60N$2ilB=$mgvAN1C&9RK-dYXMk4dHLKqEb7I1^2okw5isF0LIr%a}MAt zFhO--z`SgNDx%ll+rVXTr~BwrWx%play8Zt+b629UO!X|_zFW8U^{TL3uZtl!Cph~ z`_&oLbfVIx1OJ0Ac=%TPdv@pd42W>b^-xr`UH5#TDENRN>v0(-;SGebVtRB`U-g;cSZS1)WzbOr4h!-hHexuJ^VbJat1-7FR3>H~uzh1v9- zb=ho|zZ;rOo!MX_Y@kPH7oQC{bUd3$P;)l3$ts-9&e?i4kIebMo=r%x*-T_=uKIxW zno|#}vhhIoVBu{6|2C=$@6q$~)T=Uo5g^2iRO=Nri1*EmS5%A0joRd@k*CSut2;M) zRSjajV*m&c2Y;*Q4C;`@Jt*2dtfJf+at|%;fv7vI=nPj6mnu4!pAYm718g~8Y1hAZ z%~zGUW8g$+?Qa#HQ8l<>zMAv5IQh^8s(Uef9s z6KoFo%=(%Ls{+&P_ZETKypZ-T0(trtomm8gHlJ!OR>N<+%8_J38?5!K-9emJ=`CkaWwL~dzwJV9QfEDi7Wf(s^X-e;3s($e@%wG-;0)L;OD^=xaeau;D zJPUCt>)463aV7Y}(Zc^!*$>cPN#>~sk`xE^Vg~62KLw?jvPBdG-ix5*MrfYO&_i=ggqK^hhdL4V=St< zXB1J!LFd!Jp5A%tK4|WJkf*joZ*$THu*@)B&--e0GuA2K{gdu_(h$!0^{k5%Gd2pg zW2%>@%SHN|slr_aF6h_kgZGv8WOVj@Rl}vr&a?f&wv2l%{nwX5YRFH^#X6QtN)_In^iL~)>1!Izjk>!o?)*Q z(tx(mvEc@BgcFT7K+{4e1-O)(#6=RF;eY0VX@PU+7Fg>ZJ5@U`UoWFDr)_a zYNWZipxrbVHx{e}|2XLPF%x$!&HD%}xZ@;02HW{Ny7Ob)NaN_`kJZ|%@^bI~MBiF} z!^;IsyNs8+{}Z!wU;tZz+H6%1VEZiI3WWAs`eLif!sFIYRRcSuXhjo01t;=bTJx!D zQkeJ$Cw@p(w*jDhOLuH5T4DM&$g;A@*^bk>dz*@Z#RU7Yv{Kn!20nQd+XDE%rSscV z0KCuS?LhBzaZNYfzg^|P_5Hc+DkX9aTl2*X@V`%id{rxjy*)cdZ|X|FXkfk?U#QWh zt&aAu2;I0(?NDvtGGWaQ)vTJqAK(qWIoglL4TVRpzHuAi7Ziy+toCx8Dt@M(^$d@p zZR_l03Vx`vT?pG%m`6%%fK_U@i`!lx2(GP#E20_&+a8%>cT2!SA#4sM9`IO*g z89rr*<&kqhl`U>bwZ1rlvH5^OFpeF-eLjz34i*^zD~?enQW!*Edr&QjIuQhFT?+K< zM`V2i-u@b@^$i42v*>|uQ2oF3@;9nmq(&AX5<5(XztNJb#owwM(Ztm6)JtX7TCB%X zIn@H0%Z6%h(1Lm28AL4ZkZKUcW-{|_k8hYob-Z>8<*kM{`@x6Q+b&jD0}I>bu$m%s zjkVg*!>T6_vF#Bknrx&EQ*G9PyZTxlI08oDzhBFAP1zJ8YjcaOWdz?|(03j{+p+RI zpp{2eisqOgwLkrM0FsiwTH#UVTHI-$DYvG|0#F)p746l{hvS9#)wc`2S%AiMWgk-^$0)gPX}W6XB?Np-Jx z31b%Y_;TBlY@(HK4NQxM!eunW8|@eaUf%$D*ek?Os%rTevDzBIpd+EbkWgq@c1(d< zr1r5L7Nmj)+u5aohp_(YyD@qbXok=@I#Qr!GXp)RBv;bHNtACB(bzktq={jF0g_3nOCMj8V~r^9qrhG^Pg7 z!kDb)!GC7Uy6jerou;q#b7|xp!=p;l?`HSkFznI7^|L2qF z{lA|?^af=KhLr`LfoUGVN{yRY{y#m`RoUa270I%BuLg<7k>Wwl)3!Yfe4_KV-JD;W zMB1%9X9eATgG`{8BW&9P()4(gU5Y(9XPjILpvqj;5FC8+pP;Z zDY^=@7uey8%N}8+98+ZusuXfkx`$i8IaIVLCuMxG%b9+R2WK8b^_R3OwF+}k62h${ z7Pf*8jbb~-p$kOth`2xqwR)ta-JwiTw;z1rK|_oEC2cEdcV?Hw5~J4FV_GRYD@I?B zPM*0A-zsGjYoSSJF>}jsh2D^0C-go6TG~k3J=Y-+9JGn}D$_>8Hmc$m^L=E9D=eKj zP2EAJE}eHYr#KC4PbTmnUYBr)WAX1XoDCsIf?XD_Q}-m;wPNxovA@#hNY9@{@ulr5 ziI9i$%{onwPb-sKkh!m!L0wDREBRJEr(F!eQ?Xq|=9^o!Ng4YF=n!O=u>%39xuG>} zk`c#VfMBG|Yi6`_UR4XOqR&8u(+^b9(s)8)|HB(;grEV4M()N}JcPcz{f3cab zrl(TPy8O>4dM4GbbNQk704EOdD&hd1OtTYjFrpC-8|@0L zA%53ruGR}p#FShBqYooTgECmK2OEo-)8O)daIkG-i2U{MH3#XIN_Lx&6DoXbE-#GZ zCx-5CSF+nTh7%#kgPN33Qc9m!NCDOc{JCiBA}!t03YAWrN%8SF)=sJ(tYRnLj}Zgp zV3^Id0we!wjm}-hHMX%Sog4Bc6z`5197xNFcQ=k1dq%{*gYe-5%SfKb=R6O#Q)J1- zL0VY(vU#}9w0IuADt3DoJY81>YdM*CWK4|xqmc!dRIzL6`|D3&YTV-*u(IBx^eLb$ z)2i7^WY!Wb3;3d%{QzGOAkUlNE_*5+C+uo2PZD?of~Xq{=AeaB#478X=*M)s-&Lz< z&SHhULtetF!!1R=1ysJ=~#<4hW_rjnl(5?4(kMI}8|@rk13|jd>##Mp1RF z?87vxhMf-0x=l6glz?&X0OeDF3PD;~)BbNI z{y7FfJAkv!p9VyyFHoXQR8~MP36vZS?@k}lq+0ef{*MI16cA@luBl!z!%pQ?mP;UY zsY&gYVNV2?{M!us1Wj3^*h4E;7BdEh~ zY-lHie*YT&T{o1}vr%F8SpNMjz0t^S6v{qRB)eMU!lJh~#>(W;u*SB_MFf)cKE2V{ zcFMXAE||r~*LeV77+RlS(Z$AgwIrMZwj*LygUSr!8+qLPE!4V+oq_!ve7K42_0~DZ z5hm+9i*-OrKJk}CnB;^@)e`45v%^YSv$P`D)aLf;l3*66dRRlj*m5ux{z-GYN^;n; z+ru{VUSl)w)i(1K-NJ6}n&ors-R>>yj2dXif!+ffLG$==id@#ej*E+3$(Ep?qS!RQ zg?$^i%NJW<)9;}`OMrlJ)TX6fvq(JOCtBKpa%hXi4}g^#XJj-$AIx#|c1t_41zI#7 zJ6Ji(nZ_N!?utiHtnZne#ST4m7WOln%llfvyE110cfg=(x3X`E=T{&cZaFs9p4`gb z4}sN?*5E*$q4BNlTBVk=&l=EOP)Gvs0gi$g)7x6x^-H}U7tR1o#6^G%1nHX%SJAyc zk4m8(j$Nf_AzTkIVnm_HHuf#(~>s)^gI+1r=loF<*qffTJ39X?E~xXYeBOibHcTD8tb2EXv*Fs*IjGh3I0-r>+IyHrC>y` z&L?=YZLYH`HCSK-JFq#{@Bv&xAiw+v!RZUjLWal3mh+sQOKJLbcHOFP>YC0hlw!zI zwC4Q6npAL|T^cf3*~Pv)W$vsz?j16)$*jY{z$cP%ZAQ4Ay-R6y7yJJ5rmil-xCj?; z)*unM!AOd{-frFavYxpetNY6mji#ES_DP>)6_r^MWb-i5`cz~~~-6~a&11Js9 zT=tHL2Ubmw$?cc!?P}jwDj&-JAmHFT&uBW0b!)eV}f{rYzXbC0se(_Z#SF$&3)O;?vF>S?luQz{iVD8 zC?5CUV7J2}F22G3N*+7{gyRJof1`a5f9=yZ+UfAR;^cjylXoAt)8O6P-oSY}enM_Y z-v77p6S&H<@9iG6?q*vHRx@s~E7iu6qwOm|?Hmd6V{ zcZ+?E;Z?9+4qM6gn-ZH63H@RO%o_k%;fY)9Ohf=Ff2&>Jl!H#VF4yZ;+@Jd?>sGrb z&fLCRai?XIb(_sr9GSP-RgE`u4k$j0`rKx7h>4Cn%r(zfdYE)uG{SrmgiSR5BIb)d8+ez8kW?Wp12gC;ndSktbt>LT_f4Yo{MC| zbl7zij$eH+)DRUP=w&y%(cGZYX`v;i(rKD(O!17I(z*AjHG!g zd??|zLPj3OdS(3vXobB=EqdE6T!l_t0U&Idfy*?2)}xr%8>@rGSl!zYIA8X*C;0O$ z7L1#H3Q^2T`p+G9>J2Ng@o^2YOEkvPIQWWAiE(luIdJOu_i5+%>7E|23PZ`>&O}bX z5P=K;UZmX2s#}a5vi>BHi{p3L>)7UN!Cm&fJctr~>`_-lzJhP`u}i}F{tu8)Xt$HQ z`PU2d(cSh#cNi4MnU5r1;2e)LamofBKP)MoRa{WJ3j@6lD{}rO;i8B*3quH$gtE7( zISOCKt+_?l3{LKA-){kR_~RbCVvGi0#slMIs(PhF#}BT6?j4%_{{+O7SEp+H5q8PyVO0d>)2Q0U=g^iv5*-NV^+3f$BMkD5m_tS z(UO67N27Dg1vFI~!Au)={K4qhEbiUF{TJxT;6Du0T zQ97|_)14*Akt&N~&(e`6?D*n!-iGTS2#p>AEVYOyfx|`}hHR9{!V!y~n-0?*PuUsq zpKXC@3~N-eFg<~(@X-4l%`R)wZG&OllN1_-gshvsVDYY!6#noZ9f8o>Cb!H z*Cl>}IyFN=o=(L+7;wR;g(uE2Zh1JR^|6~H1Z|H#sCP72k3*@To}OS%y}Um5<=E9o zHv@tJI27;!a>E!lcGc5%tPn6!+bz60bon8N*T!de*L6`WD0r!-j8t)_w&>A#I<7*nXTA zKL@F_kfNTq6K>c$p^#TKrx4IK9c=yb4yQgrdJz}ry#a~gP)#o1NS1lQc4&x={cSAY zE_(QRyJkG@@CQL^UJLf-F3uB!o5)K1yxoacR_X=d_urm9Rvi zU43nBp|I{n8;bOKU%vwSzZpb*u9cRAtv&P(b2?dBCmoZlRR z!A9UOfS)>b5T=|J$U!j{)hqq&C$-07XwYNvr~VK%mXbfqZc^;h+cOKxbu~@Sva1yL zbz7EQH5p*B2`p08ZKnb^cj;V7!CzP48({zBYN-7Q5#E#8R&W*^)8yZp&hJAc$2sBU z$+uL67Th-&Ajh8;`|Ay}i|jy+*k3Sqm_5#l-i>9iy~ZKRIKiU}>W{D!tolWFMA01+ zRys6zt;0&Q)06Y$FzP?jo(W*cpKa%9V2I5p0StZps(n9zp+47%7p(!bag^OfouBQv z<_ry|nIr8QbjxVF3rx?_FWXNRlo?|W(a+OZ4J@r6YiHp3-^SY0gMiYk9J>+%K5Ekp zWd96J(}t*!GzyvTXCB76wL8?%Tin_nni}HHz&^8f;yAmGlQRP4EUWry>Nw7> zk;TGah%XP}?gGakT3qI!MR@?+Ut{k;JegPg9T zQu7Ooo_X&zBYXaUXP5?5c->Ac(d50ao7>s1+wiK4rgvWlr-P$4-qs0ns*ksKvyu=X zE1Ty4UH#sZZ>UP@L_<{uPWsEP(wr&YD9(t5HZn*1)X8lsMb zTW(g*=DQzHbEk*6GF%xYGmN<>**C@^8#tuSpdJohxXdW8pzf3G2A&=4MpBn1O+tWy zO<+(Px@I#3ij>)Td<6IgRh&C8gg%~R*NHGnHaMsvNc`*Mn`~FE3&tNjw3ojlnq_M( z^BFCfA0P)fnd&;xEqY7_*Y^%aL!zFyGc)MhQgX_ApJJ&$`uw|DD`I8m5e0F9zyIGk1Hw@ z9~MJr;_Pr5&=foM$QgE54wUTTD9koX+N?-}oW-5D`HvS-m|b}YJ~x5dB3L@x&T~%hm}9qgPIKqjeG(Y0#P9*Q1DMGm3tKXU zfYV5yYghFcERzOy@WwzWcxvs&781;l*JWi!xN($zrCaCQ zo`}mX%#4!di}2Ej1$J6-T+@Qa3+(omVLgpW7?eKjk|xBy>f#kO-oRx30kKTuZ%H7%6P> z3R~MIZ(Ly@%P&?y4n>omm3A8MRpy`?9<@3GxgB1{>-toAEfpQ0c?7Gq=Iw9 zT^FA}c9mVHG^o^hmE9J+!K76%G0CRAs|-{czS`_ZjaHkVdjD!$d*BXRZCABkrTo>9 zVmDEzHz5ljiKK6*%NSbvt?j9}M;L_(W_%5F1T>o^uqv58W|6Ua7@Au2h^VSR{hM}2 z>l~#N*w29*o={*{DxWKvZr4cD;y;VG;Jz6IkObm668LfR+>9M!Wj9!i-MDCy8vil{h(GDSI zLSgl>cA2#RdWdhq=pKCAuFazxn#zzJ!{o7R?bg=!)OD@ho+le-1{)qT%49-xVh%7g zTNF*yZ_${(DxQw41^LI6I=vRkHyjhz*{z_Lxo@4l3ghluZ^s44y()$Xd(Q@0H1KTP zfPv@n$BohhpA_XaxH-(3&7P36-hLb-bZNcatnyeL=oQbl!Lu-g$Jzi zVDD7ARH!Yb(l^Taa`l`CYxRo4;$100DpRUFcKwgR!>3un@|m?pshnjNELO!HaV@+bI~U zwVUmm0m_BHXFr{Ff^#=upny06Q3&{pgQ-)}~2?-ZH!T2K{ zc%3o^g#<&$V*~c2p{qB}ke0C*4xAOTq3bbI@VBCZ2Le-mE{tV-6Z1_~T<~w25xs5vPwtFLvE62vhByP?C zu2w{5fLimxOcN@;7s!EgHC^%>Ei;^$IbtP zKJGSs-27kZ?MB+Ht+zw{HYzxv4_d7bxK$p%)grnLF+%YNBV*f zx{;qR&BoJR4%*#3$g~Hvod$er$I$kJcBG?I)$M3*Ubo|L^FJK40T3Ut%W=qLc8mf^ z*BYj8j@T6=b)dH#s~09b)4lRXA#Wa{hDV|8&!#a)?OS=H;*iK1GNzM9?F0NwB;tJp zpV@H?)bS9VI%fYPUUMU;Y;2B@m|35^O@$T2qcrwQ`&FI-$Bvg$wUzn8-pR$RWrK~@ z!6I&5PNhVxEXPoi`j%zw`D@NFlN1yuG%Z(Nm$7B)x5R z!WsNVe5E+ip&HQEVFCUnC(1E<@cempwNq0(mgJvV$N7~&l#vhhyJ9x__U|+sJ>zCmW8E&=XEg+P%P;m9{?o+46-z#j^d0)~ z@e_5}#oK;0dqJOH?TW@dB)}r6TI_L!XSrBCevEeKV#a>-8;qO3DFDnki<_UYRis)2 zC;US=_~N}Z)Dmri*vT$SREITg?T+#$Z;U?#3rcSj6R49*G>3E6XqUJLUb|np#0@x9 za*G-jC&K!Nr<2CHa25)+2{PAXGY7riJ_?;3MjPE&O(WeR8crb7+#<}1WRqqoX9`g^E|_D_h?E@Nn59anUMd~$=Q&4W`z#bDR$A(R>>;@Rb>X_#Qoq@H0S z{bud9r1dJ;1=)oOLywQpw+}o*P9ZcAvqPC_;E0}PP};(UUkmdPX7vL|Z3o^CMQC?- zn5dogDdZTww+_xnS+GrR$Y*{F`87~DWKcWK7ZA9d0xX=vW^!~4biq6VepRd}_D6SR@a^$<6uTN;;C>$IC;KoH&Etb^;TDQ7T73ee z2EETi1SS=1i7vu;=|U)g5Dt3~y&NuT0u$D8C8v z27FD+;=Sb+f)B$>oE1ll2=+*oLGt?8;x2PQvJG1_zy2p zrAg5;Tf{rX zpAc9s3bdxfyWlNOYrDC%EMKs>D_#w*o?jiTe2go{1jY@+0iPoPUUtM~y!rx{vsx?I z?G*7JE~dCSK)d=^ui^4CrZ1ED zSL?n&Zs3PGzzUDyVXhP#c#X#mLS+_rd^^g_fJ1sH+3_LS`c0Gg;0))5qPm=%3k?T9 z&MdAJ9k_N~L}1~%ey0)GV5Y~$Z zd@p}m*6X5~Do*=3ucBsbU=AO6UId$WI;X$D0KWM{mYFFbU;)ev^UX6?w9nSBXeamu z)^eq|tJ~kh<@`PU|8gQSAg_DX&~+1klk@yo*}$MtI5dj%0g>X$!HGDWEBUS- zhUL_|j96LzG@>f`BbX=f^1kJTf&%~Fln9M>i?ZS_*k{rBvZ8g|1g#X%EEJ{>KLu{? z1f3}>(jd3_qD2BQP$rPfXE{VX0;N~0@yE;dUBqIh$4MB~e7o)|K4Of}4 zSl}--d&R4J#$*l$dMC~*AwMq;U_IL7u=-qKF!KcU*dJCtrm%b?4f&l%&lLp4M5)HNO3CDgxofst8^4uh7&gQg#*iElws z?oALs`f|Q!yFm7(8vg^IQQ2~0y}|!kZK%y-B&!WlK^=r2*J?qRWdfti)qh z(9={H|JBs+B2UvYNupJ;f2(sJcj=KN(Hd^13zI}e0BAdtL~VGR{+1*vpfIU|U>DR5 z6-0d;`d1M3tf2+VD+o(7VyluxNpnWXSZRdV7>gZI5u!#yks>n*^G`FFJ5#`sfYB@# zwCekX7PRL2g$8za`9<}_pW6b@ba8we?8!rZX^UVaIE5h|%>QFkMf!s!Dlo1!fUW!4 zRO8amZT)UzBID);TzY5c(c=`vfdRj43DI|58G5&e2SV|CrWU^kr<9BLB$lYa@0k>Q z&v;Zgm?{#hm2U8SiGD$o`*TspaY`v^Xs|>DZt%j-PRH>ibx%WsKbPv^h!Pz@3isk3 z;*{P<6RB7Ba8$5|c#@8$iG(cOLntG#nth){r&+#95VzY!@RS;2-2{xt^8F)bBm{D0wwp`yuQPZlTBOgar z6|eF!uA1nHI4^yxiT&0G1-DhlZ09#ri1+9PF|MXr7z=BPCS2afDgUje(AMZn<2^xZ zber;%;56K$mJnRCe|eKwXiP0r^M(WuOH6dCyhn#hvL1=#a1<>PJ;@w;9~7Clvox5f z(dP*s?L+umf~N*Ql2;pSD~@|=3w?dLwy0`C7Gw8EBx)W+rRcHxVp%k-u)-h-a`amS zO*S@I)^D;V-Q7UkRe7>x05>cER5Kli1Wv0^;tBZJ8so5qzsZNF;q~H4w(gpHz0lTO zY>jPNM%oNkHGf4%t{0Wrx~upW&e($TtAg?k#b=rz{oF|Wqm*E|&VuV83znSSJ!p3A zZUTF8{KlG1%y4yX0z$uudN&ax5D)z4CZPWJjDYPXL^~MNYOC`AC@w2@kph%$J3~2@ zndbck(|iw7mqPXH!Zgz&wI}d8*9tGHRs0y8X(p23oGY7)&g=w#e{<2jWCVFU@1hY*nOPt zDJs&)3~@aVYhi|fN!i2z1nAim2#6M3I3OTe@v*~0X3U>_$V_&tmH8IS9}?B*u2y0+ z_MR_Vi5~Wd(R!TcQHRzdtvG4yv#mvAYdtM#4f%R5oyMV5GT7_eh+5jn?mv(Wmg6O` z{?a#;4!04_i<eS4$O1~zR4Yk?ZK6>S*&Dl`r@L)(hw zsM@F9>~#@2p{2Yxh) zm^tHXZSbgw1UOkZrYf8r+sKg)duu zYKAP?O#N;ZcNZH%A$e@jjA{h4ka`P0f2%0Rdpu?rVx#ZTnu2rr3^=47Uo} z1Aj%E)^!re34^3_`vlw2;Pwf9`!ucXBvLSVhdPNy;oI4Q(;q^gPj$yqt761KPGo^LMSX9zo0&M zi%RUh!JyEMPve7_yeUCyJ&-> zIO86{LDaUEsu|i9Fu-xD+O_2451Yd5QiWSg;i;~oPI|Eo2;@AVh5&0o=RqG?Ji}@M zFENo?-YXt!{QKe1t`#D!xQve8D>%w-&-<{{c}%DEKt~5sVK;FLc3wo~UK`wTcRwKF z=*0b^KXz?YpGZG<7qkB5BL)13BOUupckj!r`g)p3;+2;`@PKcwE#%=nh_?P!OH842*-*(?M0BbL(*Ntz*Gk^x5OWACHw8ScF{$ z99&sgZ2>dXxk)Lem)Hd(?i0PlBi44h`3Y!>Dlvdcls6xkIfiYmGnh|l7KNTsJlemz{dp7myD_UV!S=ARvcQ$?7SJc2E z`9*zo-;1I~1#YFP%byz00A3P;D(Z=>#~ohGzf2R?8;caLAMs8gXg8ZKQUrVjkSZ1J z7eu@Sxf1H&sF%e(5uAktfGO`xNTBfS%c5@5Ic#6&tz=`3QM$4Iifg5hap>=t3P$#7a4cGSxOLT@-5RSOE(r8 z<(-%rc^~h2Ikx3*1{iT**I=*^2k4iYR39|Bn50QDFGSl|G?HUvD&0s3tSSf2w_ zb0~0x19bmTeKl&R=!~l)<|<+sIPC*8ahPu9{b9P5Ux(>dY7N(|Oc}19+csRc^0T=@ zE7j<1HUN(U^wJ1j0Zk>)qmgz5?HnOEms7owy3vP5>PBg#ZuEnZf4b3v`(G7J_4YG) z)YUw|=}|&&_r)N_q0yo@4`jzNW&ocXBii%zMqG>WobkMhYlNFNJ*8rkSh+9)Cg9_J z3Iut?U#=ryN7;VfEm0aU}WQoXFI+h&aWfS4?q{iv5TF_*isOfI` zsXG<)i5CH{gm6d^>=+Ly1=t~+jlc|-C}hzNcC;`Z2*V7-roWEnj2CQk;F=&R*Dw=} z#WUkYh_j&0LForwc<`VhQ`1#&+wpw*Ma7|$iGIis56d9y+2ixJvmJix^~kv*&8=S zUoAIRzfJ*v^)0361}U6m#1y3B;ap7CY#N;_j)SoEo+=W}tF(axY&}bm+CTWJBh$bq z{|+&AUX?~er;ELK-@P-$&Co*5odLjMXTd9ZqNWRc)uLGx^_YiBd6YFzl*gJe$i@)3a*d}AC%pPK2Typ@**sny3Uh@M95-U= zY!^#X-o0)QMb8&q4eJ<3gXfD2CW0rNV$G;P0>r4ySfEFxB;ScqVb0I@t4KE?d5mZT z>uf8+s1bn7-tsGE%DD;4VUOBxk!X))_}(J%C}g~rAB&3K9q=%KoX$Hdl1*L`F=e!; zCp-usgfGrv{EY@K7S(x0=$a5j7e%ohq&qMxm@5KLv#p-rc(1wxP#HLne!du=;_w*i z^#x|;2FlnglCvft31skHwO2R9T+5KLkXRa__EB{00z0LxLy0!|oe}1e zS)r^pPNt!2GZ*2M-dP1piG%dbDlDAQRCYCF&w12nwP;c6jD{PueGk-y zm<+mi_{$g(gMY}u6w=Dm8S_2Fca~{8H?(B}hDKzpRxy)+@aw z=36@ocD@B9OJ;AuybK2mu#GCL!_Jhwg_^DtHRRy!CqXUQZHDM#?#Bbw6f@-OXyoJEel5d0P1iHb_PcCR1-I|I}?+v1hD|b6> z-5}%Pg5p}w0$Q;o^F7=r^PF7}n;Xzg&|4wHIA{I71}J>C^9nPTO=Ybe&(iV+$PTYfZB za}3?WWsP{l%IU=fruZZ;JPj+(2$v~PQ)~>EY^Z1}d4986% z^IHFdtdLqC6y{uq@ih>3))v9>2Ulz$*DfNI>HL+IxCv8MZ`Rx5?!p7(pE{V zl>#X?TB&wemypE*7ALj{MN-K{?}@bf(8Hk#6tGQZNMOiEn2#Rc$M^vaU93WdV9F*c z_=6}eY;oW#oVZ0a30%AP+%fh&LaW*{03nx3j14BF>A6;Zy|e{GcePTCshqBb76JoY zzKyY(0EaFa0+UK}i)ot~KK@A@{9NUexbdy+1r-#9f zF|Y!IDf)d8a|=4bcc-Fm=@;-abDHwojregODo~-KRg8t-fIF-9V95Rns~Q}^Lp}4p zxFyTPZ-oL=YtXT;GsG5BHDu`52u&Dk&Ij;0_CPMb_>~S>sL#*yIp&e>C&IF`7MUH+ zl1*b!$7Ag$YrVdy6#VOV*F;&$`A873q6P)4n2^@TrmfA)bg~5z<^8d>R2jOa4Q1kW@Gf@tPT}! z6ZI0oYVznXWd*DZ!&*N_jK%B*lN#}XNK0ZC6Sd9wS%C_rj1+GEKwJd3*5*U;PaIlp z7i+D(^xJlb6nhKy?SQUK%>(y~al!hbEnWpOKW(?D zmCkQtix3|?tHGgFVGd27)xZ=81}QzaTWA$#%pN0BG~NTzS2qw({r8A+l}#&%wBR%Y z{RrC8o)zP*5)EzGBed7jKlT7D|HCYMEqeDONNyA8)JNiuKg+VW~ngd-vXNMt$mjpo^nv!+!CC)ONvW z5wou40m1$-RO=IfBgKl@BL_ut!ONeZTYPiYr-u98_Nh3**UJu;tXzP~t#!SMheah0 zQK5#1A@G&EKR!P8WS4IWbvrEfV9wV144pVYo%EsL>CZ$9izlHATLV)9U~UI!su4W10>S$9`PX7@aVX6yT0(Y$ zhI~fTPnt}eaG(^%+zlZZk>sXEE%|D(MkNlB_`=1jx2mQviQ%y`7!Z!N_4?=DJBt;t{v3ip%djMWeqH<$||$qW~F-8>NkSCpWp_(};?6?vscxzHognhGPY1 ze~&HY8+z+|F%egtE{N}NX#Im|m3SyLh-&yAPYVm88nASQziH|T%+wv!{DfG6>gP^~ zQI$RZ$V|V_xXVN^hJgZhmkBrSGP($Y2`%_iRF6k_D2ElY0==;#b8Rc|004{SXWa1= z@s+qin`QBc@Sg0W`@RwtXy^~(7WXCC-E=%2m8wZE_#+=ZFf=r#OmF}-zwFHfBboN2 zfy}!7D6}_R{~v*K;CHWeu0Q(`WPAXLpTyl<{NPU_Ey~Cg2$%s?x(h~}um2<}$A1X} zW=!3tA*;dS;f=`PWBD#d5b(Wp9gCy$YHa0bqWncsJq7(!2SQ!S;6WIWexu?aXs$o}-912P}8kvz}^B3AMNL1_@`8ZT5z<{`l+YBPG9*ZF%u!ESQ zL2!uWqmWjX3E#x7OKBEFbGD)Z0>h;m8Pa?pV;yF+;RH|T&S11}x+oqs>9Y+h=MSqH zQl&V_Y8bmR&!pWKMFMtuew8j6@8y|S!{ALgtAh_4RQ&KAJv;SU3Vt!HC0-LefEhnS z2wY6veiqtbE9YlX4Pp{o95KA^nkHP3TEqv_!3bEF z6(x1CYn1 zzy5jF=|6{d{^uE{36ZkNpBaHy|DPX$HUG;a@ZUhZ^TUuNOEUvOIWKq&Br$UkV+ zvYcb~f#Q2gRO#kaVOoP*e=Bk8G3VAqkJQXWqDPkhBdVgc9vR?%U5PRUfE;o8{~Tq) z(-Uo317@H#ZTX26HzPFF^26o|y9?7>4_Go6{MQqu9F)u!3fh)9H1Ly2cHw4a%vKJ7 z2$O}iQdY7C(dSZ@NAS!`QU=WvE^!5zCp1;E3iiW?lpGD~({Gi0z_rZtdYK)u6DO%~ z@<+%p7`r^@m6`mLKKDun{+I=3nfL07*G0%zVLQ1ZLf%?zJ84Iv4?Cz9ALi1Xk+N|q zYe|ZfsYPau8zUv}6`w^)y;rcmkURRPavxU826x9`&L=0#acU+gL|)Ll>IVV&eSpkfEMJc;5Tb4tn?7N5GN0y#`bvW#3pBco+an_1i2VD zHYdnB;I@BAko~Nw1y7fg+pIqwurD)FwkzW}-kE@X=)qo^7J~`qczo|M9^X&I%4Eo< zqhe(u;#s~|bjR;3CuP;Q1R zBAh9L^Nx9M;~lzJlvP3ApuV)6UO+0@T0zzlrhA+x;Bp0dhxIYtku2+h_GtzVIcbw+ zBiDC|wj|3t_?Va?6QkZ~o91a6!g{Tc+94O-p&L_VWjy&rifqhv=B3En`S@#!Y>47| z2%3)1bDv*&T&{~-=%FplVf4;so)N@!X*vgzkhz^zM z2((|WZ_NU3Xl88|aBGKrgX^a`rXE8oSlXx8;~g%5g0EJU?XTS$7~If5+gf5ZStFVR z&rl$mpeI_%j9_&4R+9sv>pomfRuxlO-2w~gwqV8XxGk!|d?1$a6Fp;1@Yk+&OPHl{QX>nXafydiX%U0zYGm%Pb|MTDa$o*g@~ zYpOzH>dLlge_vghQ8_zOdnJPJ2PwvgLcBu})~u^k5#`m#kIAM->d9_@_L=DV@{vFL z%m?+c)DDFf`QrN67dMQ0H3ZqYfo5*@mP=WdUFcxKO@2JYtI*NqG(KfO@IhU01RW^ZK5Po>8M z{6wkxdf=#2PT(5Mlk2aA8IKe|cw(-ZBW%!Qz_$oP89pak24-l@1fUaYuuVx!`$sGnz=%0_?#Dm8=d?*QG{OmeWOk= zFZzmFw3d}i-@@}40NmPeqx6@)<>y=JxV5yk^kx>dTzrEZn(aj9GXy2quemh5r)#APK>H#aMH z0ez%_x&w7fY5*qZb86H;GV1n^267a37#Pt-8r02Z9F4t{0Stv1)Xk>Z*URb={qV*3 zW(eT6Gz!Go(e%yr(q9&!37i+Of(`cL2KJNO5UF^cXe-B9y9+M0l@D3Syz@YNc|C3F zAggu_W~y@XRHcQpHaNru{DeJc(3s2j1LywhJuDaUCU4N%q_4{5 zd8T)lJ{I?MxQi&3Vyr%zeb-leG2xe@UPJ)O`n2&+Wjy4l=XjUZwXPeO7f(x zAWs^`7NXx!etR&bpV5cy2HD4gEZ0&hHJC-C(1aHcXCW)sRo4l$Vt%$F99Qhspck+FNb7 zYy*|RQ^RG0>QfdOPXMHCV06>i|3kWA!zj+6Jdh(jIzG5Nhs&x_aQX!=$pI+N!+m89 zc}B>W!FUcD0X7*XIU{5?ti)Q5lx!@9Lp%){3E0;;Us~e)pgBJ`QZv^6Y?&l<5++3C z1Xi03S$u230t-dGGk@8vUmWI8u1RT)PqHi zo60nfObBPGkz1WUR^ID^|CaAdZ!%TeExmMOj!dGA99g$0Z$@L5rgScKhVK~lz#q<= zF)l~8giy98M~+bp5(l$dWR8>5T%P&!AR7&*i1C0Sz+BfEFYAULj7oD+&xxuW^&by8 zXdit$9%FitdiDuVr1L+AhtrHS7>G1aQ`O`4nE=q**4=VtU>tyiUQsnRTGw)9xxgCp z$_*3bWDN2>6J>idb$C9_pQz=q4g|p?mqwDj6(IR1gtg)NR#J<}@@XBo6vmrO#~?Xm zf|QN_3X&>92^Hc9Gu&O1Wp&>nU*N)*D6S9~VoK!{*&dUgO;;Ek(#A$O3o4E%@KK~r zZUN`7B-$_qaUU=oB?|S*Ih`vLvfG~QnL z!g}Eq85rSlKkjH8jUU&*SFm-fWb09i&gV*PC~^H%**4+ylpC7?sAsf%YE~~lavECC z*0xShq1UI%y5=r|wOw`h@Ko8t+{I77>Tca>2$QB;hFpBr-Rx;H!`x*F_R9AjpC+5S z@c!iKGT>P?m4#+{cskHxts{E?MDP4`*~%;^51!@)b;AtV%=MFpUY>zTiV*WNjF9-v z3_LcLqVwdFL0eAF*#2sstXHbFL~1%yR=!4)?_0V_Pc|Gc0y$JTL#C2%7IZE6ItjC6 zRqr^C)yQaFC~ha`$#V3_EZL#t%if+PTgPuj(kA>=7`&T%TFwn=9i|{xN0~V`Cu8fQ&=DW$;$^-LbW0P@tBn zbhvaSc<`32G>xL>%J`HkDq$j{Qgyf8gl&uh(@muXrCZX84KSNv;?I?4=t^{cj$~Z7 z?pzrShemFky3Lg`OZQNRDk+==1(^n)Lm02H0w0tp05)y~_Huznv_lvNN8A)H&;WJ_ z)VC-&%LO*$)gcD+{*epZra)ufKXU=cH$n|y-kq($Ke@zdRfFCm-#|f>sRGd33QXdH z2vY!pX9ebPf%9I#IhJ1D{0Fb5hV$eye38!^s|;HAt;eQX^W`l(2X>TIwP@jdIS)YY z?F)b;9H0pcWCI*NSRkLpq2)pi1@~Jh+vDoJg>r%G;pmpIlGU zoTbnc=F*O(=tVC1mdOBAN4GDNw#D;06rsuuQ$MmxClvrMb(2xRqR3iFDHn zvlRFdY;ZEWDmGTr>()Zy`64dBU4xfy8A5|6J7uZCPWIN8f&EA_4dV5H+=c2FiN)LL-nXEHbDFaXXw+L6sEb#Ye)*PsB6@Gz zK>y50H@qf544@VTVnh$WjbWKi!{3Hw#&lZsww#5--D~mHrqgq4@ujBIw6$`wj;Fu@ zJX2lh4`y3Nk@YS(vqg00I-?Q^x)R$yy;HE;fwKwF%5@-@_z>sTnXhy6dYSClile>0 z#<&k>{qT%Ij2t0_R-k7Fsk~J~e zKHMbzAbO{-UCIBBJc-#M-i3bq0A;)@Kfpn4W^}Tk>1OC!9A!x&D@!=fsJCgzZJIRV z&o20-T0X55X>PeMUT#b0w#W`hf7tYWdAkqsighY!H~X9Uez9rl`+Ci6ejgf9co}X5 z(~wC^x5_%@7jW8Mu!@?UEfs`}E^d__5zCT7S(tDCQbrtl+IWpU=`8QmSbBfTnTkR=XE?U4`($fg7ZLmAZTPMC@0aP?c_;)uXRjZuLqD%by^7PZB7^oibM{N^ZCGXn zm}WF^WPo{m*CiEcSyTp}MkAXC9XMkzHS)CyTURjafPBkp zx*Y-MG2;>HcpZnHpCigcTxW(05zpbi#u{wj=}43?Va2l+nBc=YNIgyX)EH%~`&8<< zX@*+bMUmCKjvAHDe=4;(usDb*Fpz2;lt~t6rYuhnACz(YQ(ieJDe8OVdX4-!c6MH*F90E0+LA4J-@v5&Xcs7HCO^@UZj}^mr zvsDY;wCa!?ijUFsFr=$@CF>p`PW6KCN|jU#0&fWZ;i>U7>ac9c^OW;=>p0~c`6Mqhy;Kj3UQtvM>2#Se>Y#X1S?_@kp0wSqy4Z!XDWP>X#^za5jw^x!es z1xlQ^j$uqs(*9#0R{BmR*3aKRmq|Uoag|34yB#uxUx)Ab`|65+ad&d4%WEipr@E_Tj-ACvPw;q%7@KcGg$w&C_inhFdRkfiFuQT} z39jr^HZTh89`HWTr0HHP_L3FT!W;2JPVH30f36vFYyho$Se37Jt!Ki~c$zHr4A4IP z%+%Ae{N2}j2CQelG;gVAY_K%?Dbsboof>gvFLn1*BTQ#0;*7kz96AaDgC90&W9u{s zIev4Mw~<~sBNrzkF#^Zb!5oCMQlEeuHeUhEex2T-%~>pyQ`GCMOse3djc^4(ckv9T zjo>5_NE_kyouWBsr9V0@L(&F3-Zj)O9jX1d#tP;5u zSP!dd4$>{aWZ2|Zz-;H-3SG|0n%zpJkbu_;I;@jPpo&RcfuCHQuHwoB5)8I-3Jdg@ zzpTj$VOl|c2s(Bau3X=rlR4$U7`dV0XST@Ad#AgIEt+~>9&&ZKYSPCCCg!~kiKp8KfJ+OFeQh*iL zCk-hvdH6U-c;m>>5O1V~sg92ok_LZ`5D;B_kftFq_!jK?tHC>HC8Vk-o)cJ@^ryDLHHOpr-_JVw#_vi2*WQ_)} z%fi$R3BsxPUK$?O?C75_sdQOw&fkk+)G$Zhi{!u2tY-R3`kmU}O=O@{*`tK;*?O<9@H;*~{ zz2{kU-_LSkbS{&6L>J)cr9F(m)gi2NJk|aM?Ac_>{Y929SqV0(+C+&E$@vNEO=|e7 zysb3jI__8CyNBtWUu8?)EJ88iwVy*wS_Ed4Hx*nPzWynJIOj8Lg{*6{rZ)5gjYbr9%$`BfsSAn(l( zmts+II}WhHr5mb7RHCMCCF}jpoMo-Z@0gI#z%Vs~Vnfv}o&hGd>!YDc11vjXe1+i0 zzHk#}tWKC>5A}lEaI`!*f21ywLLXM015wDAf*#Q~~-4V>h@!Gtm##KW8BMBGe;sh1_GE>>Kh9$D1)d9u=V; zy}C1Fr+Z_mdZcPsn}-X;tfA{~ygxN`J%G>3$>QA1aGSAn2e_+lmT5krnUSgvyB`I+ z3crpLT@6E5>1?EmgTMq5{e0X;?v*<*;EHh^7p1Dz+krs&ycbp5A&%S-kkSXrf-8Kmh&F9@Tv5agTRGZ6!2*ggk>#A)m-36 zAOn1Ac-qk`8s>G5pL!Z>u6_Xar&Y_SMhKM9vy9q@53I4#7s@Ja_Xb#WvbBsJjaJt^ z0xLu)r3^b&GXyLKtOl9Mz&8rL$_|mu@5-CBaYok+; z>1I>pd#W0Qq~sV?HR25hZ-5>`yn<=_ohZU;>K~(qT5nKjta<^5ez90fvuR4Kn&~`{(6uXFqmNS=)%Bgy&n^{gllU{)7 zT~12`%@Wn4qR91x7A30k<%)ewu-h{OW8v3*AL4tBjwGt~?+Mj@Y5S5@O8oCI0Cd)`dhk-dEmc)E+P>7y;pHel1q+QGv9E^0>PjmGlde-0v_BinDQVAY1VKrzp?qAUP7PB7VJe|| zMWOzpGpnhj|BaU;Sc+07-ImCrsI2 zfWd5Yjt-B-up2HWWwHMY3m)Dg;ETB#gGD6ORQ&+HPOhnHfwXL`slYqaxtbtUQ|Y-{ zYA-Oa4z<;-AV!mGs|H~kflUshk7}#81KN}GW?lJAlnq?^7%~0l{@)w{`ZZGWFEm z*JC?zb1Zt^7tQVh>CNmeECaJh%JM6ogOxjr47|J0*oG=T8iwsfrNLdKuz_mqDV)P% z82#2jRq*7S^VI8A^_YKnSz7k8>D-YN|S7Y24OSeTze& znOb0&PPV`g@|&l1n57Th2*QUjOYEM3`S1;`ZK0N8+s?c}A@(Gi?bA|KXVY}dF*Z$S zMeKr>ic_k!&A{3udM-n;OTq^k>e(oh3XL}(P$-a|jsex)Mko&%mgVXsY$MyKPcaG)-KZQTnxEdjQ4K*+%eMGE2k6PRimYwqX{Q?T z?}o|Hv(E4C&`u2m@3y_2Y6JeJOndXb7VTB4^&0hPuX<_ub|VEEtCkdXlj@1q`rK6F z>s;SKwTb<~E)RU0U3E?L5_Szqr;fL%wWuySs@rhr+EG>a?uL2=!_FS!*_6`}6mU2d zbW|5git9x({f1jr{W5QcGquCIW-QOIeBUG3v#L#XZ&NK}a1R`R@E(HdXZm*2klR${ zlFb##)f;Y8b5l0KL!LQr-={2~15bl5HMSi9N$}D}?)t%<)QhsX5_vkSfP9VpaP&je zxii3Ed*{9CwSXyVZMFOJ?8Pt?qBh zLK(6o=)@jy&oN?{Coo$VRM8@Ru>c z^6poi`0~k9-t=P1P*)FOjG+wGyPK7IcX!OgKa*nTt{$ohIx@D0Drc{QzcnI5E~5M% zV9p9?R}Xb}`76VX!2>GDlw~}i?smu*RGMJLEZ;Qh{h+#`tN|1e@fw98zG=~E5j3#1 zH-(NqsFIu~w5Kt2veRIfr*23wPq2O#W>WkF7^+Y`+&*oEGOZ^djogQnsyz}(2=u$O zc81$`P7ofFEfe{9eS-K%h#NwI2UM5;Krb_TUaOZ-MqSa%mbJ3~R0nDAL+Tk!nf8BE zci}MoZ)ycLp3V=eg#R}*KF>V@d1dziT8N{M6+Rvv1&h@`Q23mAMD4ihs{<)7>{qL$g;E=X|S9cgF znGLR(k(l#$)fYFCGZovS-k+&%#?^vM;D}S{+e~oxxs>s^dK2K{Pmim6c$IhVW%3O? z(MzS{y5RL*pb30K>l^nxp@s$bm;0YoO~G$YdJ;0xyY%6cDlyK)!v$$YL>mT)aQ1+2 z6kU4K;1;!?Qj4t9bm%En$H}%4OTNxt;qo1$n!QzZYd&@Dt=b1Qs2CyqgeASP%}=JN zK43N`Q=>krg0^RY%B7(T!E)IA`yL!10^EsxaRv46qppVar z71(R)mU%(NdN%XzN&82JlKix#*!YQ-gR4UTK{rn z3ckf>FGr^1@Y_UhDpl+knbhK4pV>?6IA5aybb}n8m?e{AZ;(iD)!DRU5ygx@XShT+Bfm2Iej5{GOx+@U)61 zwCmii&@78{Dinq|W+*KFB8DcQ*x*0jN5N00ZxAZit36($Nn0le7wKf z;K^A6_1Z|PonNu8-Srt!6ivW;al!VZmmj z>HKj0DB6yr@od?BfaVXo;sq>x1=~)cr-!S!xQ*9(!AA3fjsMdZG*2ClfE6H+Gu$90 zX6Z2j;?;-2)ApDZMyhxxq#}yzm=%Mw8rodS@~x##BUP;o)?;uW37_`R#(hvQr>Vwh z%5e*F)?NFeR@xM`vH`6y{XIKU?`IT~t{>Wh=?|??X8sv$737Iw>10 z@+A5!Tdl&D_1dfIc^t$jm5VPvXOyY|h~=YEs*zWNVVro4vzf$>22O}}{=0R?udD)jYO)sl@Tb3k%IUTf#5?eKEC zl%qEDdkb@rsAD{RJq`=bB)*EJ{NxBx&UY+I0|#({Ijg%80`tpE-Ly6;|u-Hk>$3u^|kXw0}Z#VLe zjSP(uds#naCTo3@WGQ1JUUG$JPy~&gsB93tNfXuG)-XChQPqR38rmuWWU_`02Ct1t zRdW3_gL)8DHdE+DQo$&9hgn*Ir)OrfgKlH6yz1W9;+zd)cJa{8URA@*c8Q<@N1{wtInWfQ&e0Gq(p5F z2<8zxC@g52`=*o31%J1MTI8zuN6ipn6*@Z{&V0d5&a8ANgS`lrLcDdhdT?rN5W`Ct zg*>dr>SIvQi4Flq*lvVDsI|EUy0E5V7n(_RPkRzt1nVQ3EMmukBXMHK;;at3T@*VO z*G}wMoE4E9_Dcfm&0_-X<65ETIL;=SGsy3g1oak?JXaZF=vAfTE^Fr3ADln~r>Suu9MRL&lU7|CG#!L_2Q8lt zAHx+;{Z&)3H*?k#7%gHJ=%Ha49G@)ociEqRakrqx4180=MTa{psau}%*M4^k?@=zD zqZ=O@mx28}Gm+dgpD!kD#w6ktMR3~VwY4Y@pMDS>$pe6tOE1m!))OI&mVs>;K&@sf zPLES4MIvQLAq6bl!Cu2_kWyQEQe3%`HoW95M_pTb)WliXNpmTEmTHW7eE%$^O|_8( z7eA5LdCQZoINCZ(rD~-Tej1h8236!+U#Kz^_l9a~eha#;Yd`h|X2<1FTKWcXf;`&s zh6;WZK#82>~x|ylh z@VN$wneQC8%~dyYxo@6f{%g;}{&R-r&QnvcW&`t859^Fsod`Si`0t|#%>fl#%#A`(VjRv!2~ADTnxVE z20FJ`l}q|{bRjQE?N$ZklNGsaHHT0{h)Skw2B}?!##?!7PW~)BA zL}ftgsk&4->E$rXd7{L?7!WG@H$wiI9cLaE>qQY&@R?(^E0e;a&p3PJN#Ti@Hyz1%wtgn6_=}# zRxD4*D8F}bsuxQxXa!HxmZ@HB9)*DYnkwH1YaO>zQyEAq{Lhz5-BzlHcwMgqTlzJfUJ0=wm*Q9bANJk@yozG|1I{_=*_q9O z6hac|E&^gfta!a%D+v-25h)sY5rPH*L26K>3qb+`Qi6hjbZmft zpr{}S-|wB-Jvj*p;MIG-=l^{do+rCIJ2SgycIKV8{$At8;13{aW>98x_}Awj3JIp> z3*l26(paW;kWhYb0Wk7eDHZ^kFMv&AraRCLr^9T#s`Wi~Uw&nk zsSM-16muiNGt1KyRNKuvm)GldGO+P{Lxzvd3yo^mt^f=te>iw&HPu~C49y42$=R9pNrk3Wk52g z*2!SMS#`-O0rr#+)Sis&D4}j)#F2DV^^BL|j+A#NK3w7eu8yTI+Y;OiHWp0A6wc8ie063Zf#e=uVX4LTV-%+xkcw!8DB9T#E#WUomr#6=o0u6 z@(`V0DB@{!fsy#<^h}PE933n$;(dCiOPt~6QHwQ3J=5PAZeB38U4yin`C~Ymw{$mxGxQ+qv}fRjby#jWRCm46Bxrnbt?7SOT^g!p6;!24F?;WNqX(8SQ_X;6 zfSXgF<}#+%OAOb_yWRm8<{dV-Z?vAn`UYmH{{bT(BgtP`Ehid1!z5ydDHyaH3**Ci__RGf9e`!F%49-E-;noN&w zGAclBSHc{uoY^#L6LgEX|NbVUl@kB0o{=oL9r)O+0K>Ja2;H3)AcK7UGVfpukkodw zF+k}}v;}4UW~Db7v;_v%@gxh4IOlE>i>h0V6dQ`)3sI6rqaITH0Po_* z`G}st8#%$1KNW(a>jpKLU@8h@hi49R`3Tks7lzIW(0pvG@svD&7;HzXHT4L##A)>7 zR^v&%Do!6m`Kkab`#5eKkEDNoZuAy25nRaA1q0`z!L7`S9=BmFKvS!lwMX|5{)JYI zIZkWv?TZfrtGtZ*{t+BS`#u7yKD_!255gs&LDKKaia6S{Pn(EVeF5ow8I{|iJqz3J z(CUd|>8xMhZzS>0cXD2D*Teh!ed#{r7*OntL~X zS={UKzc<22?rj)Lq0P>KQW3&*o1prOR_=oC672e;^F(|gM?pTb8`AwDnzb9m$Y*VP-L*Rd6d1^XzU)gi8ky7NBAY3+-qE4F>ezVB4-Fkw0$n0AI2Xgot@Z^T8blV zNF5It<*{Aeall~Nmef7ZyK0STNF-iuj#C*$d~I~syDSUK%sfbnjOo*C%C-Wp{~VX9^f4c z>Fglq=aF$3o;+ZtbG5fj7D1G}dOji?W*I{Ek#_h=?2zi+rOi3>UMbYki!@UN6 zXd=rbyv2y4P^6ru4o3}drC&L!gGa$ogEArIM-0?t>iQ$*C!&e6endzj>i);X zs}M!?{|mpk3qL5&HmD+`JTL`%a1~VgC+w*#D+jYZb=+w`dn%VgCCm0y`t&q3Bf0d` zX~&=n!yp?}b1C%~jBEkj^b5qgDU|bzVsv-@VpNKl3hbmn6-PjAPvI-EPcdk7laB&!ey9pQg~ z3#wR|UpobRHliTe8m$UwcAe)f>5j$glxvs5rm@Y+&Sap4zI+pxOJtcL6Z1ep7!eB{WM$1EAiV1 z*agcw4EwtWvW$nF3l=LnjJ&#E*5aziv5bfDFH0VE#a~7j14T?J^06}~F4KF5;aBWk zO+YBGuW|xbDSZM47{}f2;0)J`H1H2&L5C4nH-gQt`mvY!jmfWF@i+dJ5gdKR-v8tX zmhn@rjSvq)e=$2ktTZ`51vC|Zpw?MR&l;k2;L@OYWfY@LhPWSM6f&jG6QVBEz6|Ju zeOMu`3=~3vPt6fRsR54S+QzFvo_FAq)|0|#le3{jAwvp0N^S7HrKk)e>>w!^DDyf~ za7K;(`T!SxM2ni@?ogFR$+L1{Brq_8aRCgK@*YvW`keBdiyaQjh2@gn%4MpUXO*>a z;;I1ro_jnZy$^?d!K56UfOq}a1J1CtGZ+!rku@(`a9qjRXfZw-cu2}n!rua2 z=tLb=qD5V1D56DNO>L}I3U{{1Va$E@TAcaWYpKVDFcptBBU*HKP1D`OZ1#6{Z;OOX zY-w#dag96+ZBr66!B7Q!OR?oeJE{8`y?usk)56{)VTsdp@<)Ymj9R#fcxbw|s1%Iof&zB}PItwNCz(qIh!JD$eHky{BQkwTf>1`nX^BF)hp)Ad z-zN%{EX%AUD!8(!dL_|<8Hc`=L_Qy@Ru&3>s()pnf&?d37EO5QjWcdHl)=<@eMklR zxw2@{XaTr(OdNOvU_GjsQMWalz3|x;pJCPD{Q;Pi1gj$A0|FCZY}-Y>tKg0I)2mfP zdrY#8RYa%S`(3~@(~cynAGVlSXLQ~(1Q|p#yam=emfjp{>lLpy;}w-%*9OTZ_-*Yr(aiw*4Z9(OthtqiZzG!owH~iDL|! za`I!Ygexe-ehGmJ^Ys|E5qa_)qPD#p?6U#bi%TV(O>Yt{8)>3eoLLOB1XD5C)7euy zoLOZRmTQwP>Qz^Ki-EkRp16fwPqE6CFvjMjvSNu>)Dw@`fzzBXuTg!`HewhwXlVhQ zxru&AFe;Xal%7{#G)wpv8d|rCTk+%|09q-py~vy#=J}dj4a9!W=&7KqY`(Jcrtle^ zY#=(6JK<(aC=3<=n89$vm7-%qQ9J3_J5b`KTG_d%$!Qv`Jt)wvb9L)C8jAa{1oqp` zNR@E3-Bao`7D~(ZP$N+d{z(XQZWHybpf_@`uq@|$LaI0 z_}rt_?%P3TT*wcP_!cW)_J}a3_LBI|AuoK*i^Kvy3d6Yt_uvXaP=-Y z(E)WVJYW!y(dMS29v1DG=EBJ{t-V3OvM^Y(dUH08q643=5SwPyre-afF#{MLXXvA#W5MAR#zZ!l%DO@8<)u_MTuLe9oT-JPk zQV1Y-^_~OZTmE5e_+&)5&*`pK!W*K13U@wDgpjzk5 zvbsD6X=N+X39*T#fGJ$pS~O5Z1!`&#mBJfDvQ1++0B%le5$}i9P}o`|)%%*~s18o^ zydH$D4NhQol2F98MWX;pd>iO10JaBj8^kotX)9LNb;NCeX*jZWsWJ}k`wWiYk(HcX zBOZ)*8IlgQZ6j{}GXXF)sbX8<#JF%`FIIvgoC-bx3TPPU`pjtD&{njnv+@ctE;@iJ zz}V?_h0@?hkR_3UBl&{?fQg9*FsihZ54aaA8VQ)&r;E>^(Kapd5;PfOEK%Li&P8lI z$VM2f7*csxkg_p^Wihl{bI^`p>yL@~%nYhJ{o0EjhJV4z_M+b7(J zcSEOI=wWFFb0)|P4hjkiP)K8t$k?AQS1kmV&$M^lV}~HhqV@QWqP4MYDptoH`~kkk z{*EFEAm%xYy|^wc7unA6aX+GY*Na-AyWtAO6%Sl5Dkc0H$x2^)Q)j=v0L+8gr|<%c=)LPi zhriHwmCN)Ez{KOUxs_=CH!b%1{)_z-u;4Dg*iX4BsSOPFuXYCOy_+U?7QV#E*yXUI zj&+6rGMr+%h@LnM=prbDJ+HR8DSwnvoziX;ZP;nVt13Tvqga9cy+K#-#4~ASSD|v@ z*6k*S@^@X>4Z_1<3hFNEb3zVG3eKd;)3gpcZoI-PUYQ@ zhjvi2y9L9V54u~lc1@>ccZ(bB)Z!4Zf|3y*>S9p~IZ@PS;H?Y9QW?OV3IR?9#{izU zT~?ufy~GS23VDy{&Bw>?5l*-U;Opvhe5{I$cfvJ>)8u=E3bfdIk4Uy{_o!)yYv7Ds z4b+S=dy9&gqp7`h{S~`p)qcnnqixJaR-h}S2vXRc&Z_%dpn)*3iRTB#NObP%8#R6=_%Ri0=w@w{ zqY;~YuV}0ETQ1KGr^S)Ww#azU)`+=0?>j9HUAD#J{Y3K~cqRr1m@|k)VqX^y+k;Tc zFIG(AypjU!cQ<_5!0gSZlMjf5h|+(`2hNLayX=ek{ge-#76&ief`3Ye{wY8t=bvKg zp91&efBUC=<~;lG<(>_Npk8Y<^Ip-!{$?AUrh6{el>C0^Ca1-L%eLSj>c(=I{D7$H z#SgyhXQ4j*MK`U}`qF(NgoZsNYPg0i%6mw(bhXeve8Asf{9D%4p{rjvgQH0FtYTsO z4Mf;lUTXmkTGIYw6ABu5RxPUfu!wWT6?6ouD^NJ#;U9watMFjc0_GIZ&5wv)uJ366 zBcht459mH5I2yd>sYgUJ*Ep*AsHmMW5%Iw+I)Jw5Owra%hM~ZI$T}%(oM1Zn6kDX0 zCrYsS3cnguFT%>ynR2nRG5zwGa6khXrnh0G2N$X%P3UIhA*|G)FCG=MO5fjpe_TB6 zx4*S}Tui^JiqoG!_|sy<$IKHIlsgCfIOl=Y-Yi-7Z(HwfUz za2s3pr1;EzR?@J4h(}yY=$C(p#-5WBeg{A~)sP$eqN&AGq82vL`<@alkT!`oKURX< zVfQX53;8sM7Cj|CEPWgX{ZstQZ@}t2UDkko|Fjt7S25>bWw96~dJKG4RE<>_Q!1Mf zqjseZura1uKPw)^oSONpsE(lhtNIk%Vwjuy$_FDktt7)i713!)LLoV+2lIoXV( zw_gzb;(Xphb=24P#Yt12PeLjrz^`?_a%#ua4bbirki9i0(D_B7;7$9B>a^}fF%#O@ ze+{oD=;9Sk)t9a*XJzrIHt`6}PX9rU4PViNfb2WIF|5Y|$aZ;ej41VCdzDvH!<11e` z%ZuIHQ0!_aU-=&K17G=G?d4Z-)z*3ZYQBngu6FQMV|CR74}5JnF6%fq7x7h!bG4hV z)SL3F9pNkA1JCnSqEmDHYq-LwQOpo=H|EomLxd7Y-y0%s$K}N#qOr;W$Z;!4?B0hk z85q|Xu19@nBiHQ$kn}M#fj)a##DEqn=J-3CIsT4}p`sBwYByA*;84UIS4AQ}(K&S6 z>md1CJ#^~rh!|?}im0jWJ~~;zNE+~p=y6F&owhpCi@9hpL&CF{q3-cQ%o*{YFqAO! zq<0!7?>f%RKA~<|Vsr{30~o#b5de@P8aG;V=ArnF!AW6YFR>&578Uq1Hnkme^UGNA z%jmh6MZ7XMDR&Uqn;5t|O!-9B8z$-)pG?4Dx;!6+B0h0dtd!@2Qac-r?7GuUAF9R8?6Yrs~vvRV0V` zy1e~W*ol6Pq-S3hohszPmT1+o_OMBDFNehqVaT zn?Dc<^wDsLx9`(MoM)W1*{+#3`;Zo}?VN3WSa(iaAB=dLLE%ke-8o1Id{TI>BlG+W zS&LIH*@zN1bP@p1#VH0x`4bm6E4Vzf%5&fa_}9;wPf2FxD#&JFgZvm+a7D@$8;-S= z7l^txTQu8gyx(DRN^48e3qoO}y1ky6#QUraA!jG$e2mB!^k610dx=KZ~^+qL>N}uYNUd%y(fZ!z_vgJ4f0H< zAI`~2@lF+e4?DiK*6v;1XELI?VAsyMG-SMZ+4VWK+k|QPIn{Uz)bDfp*ITe=d`{Ef zf~dNP*1q*`(3Hn*+5(!ALavD-8jfmAQ>ej2DDY0vfQh06aKoI5BFzophCLHSN^IU4 z05|l<@6*5yaK-0Sip_zH@fEer5em6sS`J3?Q`(Rt`hr8LGYO(WK1Dtq7FT=!oB2$4 z8DCPRXXQZtPhd~*<61D^z?#4!xM`9|Kt8e~lf;lqgSvnLetRVj>SEUcAh|=r2Qqpf z^SFWR`Ud{2SFX4=cAZFKecVZQfc1;uy5}8HI%>j}Hyw#o;^v`!i)0*dTp-cY2dQ^55R!^~X#;I?(6;^#H zP^q`QE0TnNb#hG+cZTGkOV3v7J4M_IyBsvW${GplEDQAksR4!aJ2r)-5$81n*3Iw8 zmPU1+&*%IxqLl@SQ<$hYQN7&rZG;~cw~I=%9Q}&Mumv_DD>`|fw=U2s?grcI102q* zd|p_~3Bsrt14Xd-he6Cs3xI9+sbt=GKIo_($g<$+4{^>s&HH6P#kN-9DcO`W6|(3q z`e-W1P!4@JRSdwY=rK(#mB*)nb^n~!OoI;abNX=_26YjYdrveihaf#LaVkPTl;5Nd zbqfnm!Use2{tXA=GaZ2O4cg_m zrh`8lOFvDArXFGZGvFRGmL8u0ArQ%_W(bB6Q*nZ|-xoK-871R=p`zE2_jg1X6<`2*MRiL-Dg=JO6<)W@EK(=025+3U}9F zX36emm*}oBE6ttW8l$sE=ZM~}v)ow~IyOhN3)uvIVescaL~nWtzoLNXFTLx#^2*MNp>o+oT9Dr`reP|~L& zio)|mS_Pk=Wk)LG$D_txYPVMV8f%1SA?6-0f*@-Z z-7#NyliwZ+G6f?W`|H~Ez#x^ZR|g+%=zOSE_Ry;NqRpS?@BCLkZNf%>LmN zQ(Ol*+q|6$x`tr4(D#Te=MiVlugw4%@k|1v$sL_J504E#$t-#XPPyd#dEYZ|TKY4P zs)olmz$&kKzNo9<`JnXnbIhYL3owm$(60-`KpgsiBtC`Ny#7Mbi4#8HsUh$X3)E0| zIGw5m8!$833xz@`U%n8GJM(Mdo(l$jw@}<`ZrlUfd=_D7dqHCN(5;KaUCjP`xCs0@ zjz26CDlRW#G5B^|H(3n34SJxtOGG?tU^Xm)^gd~^cn6B*HcQw$0A)*+;^kf3va77Y z{2slu*xg^2iU<9i&+cEQoK6}p7cVGR6diuIXt^rQ`q(bjSQp_dROy#1>{9Kva@R^# znwl@3EwXjJpRa6P{a0ZXYF`!*2>fC;n$1`x&Q@30Nx+`5fakvpjMPxzDOg!wg0D)o zX5*k#gzISQ9+^ya3WS;X&1^Kcv-Ls~0fGvtXH7Qm^{LCD~~irtE*?#&}2^nHk-{?A&^P2;J~8WEAI+OtrqHd4>_ zU~MC1iPRflta7^qn^cgo=v0oZNJl;qLos`vSPjp?9rW62aeLd6p$EW@#oOh&&PN0& zYb%1r0X6u6+lNx;M$byLWSl)#3|7PkUbKh<)7k(GA)Q()dg-p+=waERLc_KNAZ8?UuYz z+)~U6-ush~SQ@`kFx-&lmIrHuBYX-kOMCp1;N<4fmW|?ZY~MEf+iR0zf9Gsc?C;)9 z;0qVg*-fGVK}ah$W843Y_G}j3uDp7Kzzwom8z&9eoxwW1Wwna)^=R}Frs~$=LQGyJ z>=u)GK;)IGAKX+Znq{2J!VC?zGGE4l2^5&PsTZ&UhH(K0>Z3bVKwQ8-0JtJ~nIITv z!iy%gOS$Q|tOZ;t-1^vQ?DV#g3z$iBdfUSV;Gi+t0O3>o_0y z<($^`yFj62zuYfegMl&8+ps_I+XB-^73Haa09+xWFFA zLXd}2$MFnT3bzK&w;N*|RpZfIV2`6J$mIfO91o*aspB|>Ynj%3KG@^v|1N4ARlyRj zVUOdw=}vDY#&I=Q3Uzu@<5<|9e@SWMxPdDh)^<;hqzQ|z{apOu z!j!MSO-=c(+w3VH=uG**(x*I2oW-VmV3|{X`8M&7h#e;TbAk1FiCSzIO?X8=v0eLn z=WN$rk@?%jKe*g_IY{}kUCfPCM-D!3GdU2;4;z1q&(|RpbJgeTkfLnt&V3ixEI$3>m!>a}oz3%&++ihBpkpQ>DV zT*`|V@zWl>DfJj4W1P5k22i8)B&quM?9{;%-ItpjP=D(8qW6HiMmGGe%s3UV{Uy!V z3GRP9eYI00*3yC6LDohMmc*Jetip>NsjVH*5ULGl%PyYxDQTA;#c{jDhwj0G7%5GS zHWJY&M#4epb0QDteIX9%kn2>nPOCbX6j0_K(I9NSqY3$aueiQS-uMozx>Z>c z!<0_~h&t;)!l0^#i&D~FQ71WXLWh<}EQiEmZa?g6Wyqb02h<+b`~ad14%3lP|JP~97J4)EgtSZ2m$aVYH&z23?0Fq3!`0Rt}x=m9EbrLaY#Iey*Ko0 z(Vsb#uSI+J;1J4rFI-L5&0p(2_q-Qg1#05xZ}d*gSdaY3-qTS$nKGt_$0Gn<@4Z=2 z!erBmZ@{af##i5{4iMW|je z6|qRCGDTEWX_4z&5#)5(^55@}e)?XyX<-VuAS5zVKa(`m16zDp&vviC-1RB_Jk)nEbBo@Fr2_48;|I43_hDVwCnBqQjigx}e>c=3@CyVgVt-zVdhvrx5 zq-b3HmU4>ec~T65_Oa_v!r~De^AmQpMKtdx;XoEDy*kl7tHQa2AD+V6 zn;Eq16v96Kt(L$2gdm{BbnAVR$|D^3 zYB*=|pgCq*p5-S4=-ppL2G(TquZmah@~dc7&fY_Lfq>fahaUf{=o&F>0*0BPMAp;E zUqz>mmE+zge$>rmlu zfvdzGN;(S-+a_vxR&+^LVThO{NSJ|4oj`Zy5Hy}Ne4WbI)FaxArsZcvWzHhYHn~Tj zz~mo&_$<^nyD9j0G1`q-u$AZFG6(d_Q|07(I_8$Wu6!{zOUB}hInW$q7fT>>jQv4+ z!yHsRigL-CMQ#>Q3dK~%@WIl}V0peTTN+?ThD%mc`5-m1f)UYYD|etfR=H#!-&>Zu zAZ}51M_3j#DSQD`u|E55JbwXhh6`x%1#kji(or1R7VtCy0z)be*p|O#g)Gvdcut37 z;Iv5;@&^;l(&P^+_GBI`*9Ua6oZO%WuGsm9x_m^atdKYsHc!RwxN8P_6qGOfgJ)`$ z!OBqC1?ou=CL4psTVb*_t_Fq4>zlDh?8j_YgfM)-?SRE&^13`ruh3%})ee_cTuX~} zyY!0PW`$hgMcr8;B*SDQ`%U>WBTQab>{auNzv}T)`^*Q8!(4p9z>hyp>kakeFBtgo z$ElT&3^4bykgf2XRYJZ8OCIw;j9m zR<*^r$Nq>2F3?hKOr)y(mXZ(uMG13p8^7|OM!gZA1 ziQ|DP_9m8G5t~0JgDzzwJ6=iFiYa!>e@Z$ugm}BkBQU&~|H&13~kNdaysk zi~)W~-FNXB-`AoZ{p&}m{M`%DQ&p!YhQMwI=QRE6$a+0s(SIv-*2k;y}LsrD$$v$GSWsk$9rN4Ln-dEUzFYn1#abJS{WKq z5p0HfS^=nZHjOF>SFCYH3J|X6(u5S*!?S7ybQ}@ZF#xi|T5&Ff&ZWqD#zYRV0Qep01J$wg5q(fYJ_0Sk zz#5n-uhN(rvZ`rEqs?F;%2Pm})Q~MYl-y;^Qg<1x19LIXb!i+UrKido$U@aWRdRl9 zJKOfIROAMqNWZ7b_Kc5%Y}?g)&fv|1=Vn@f*FmGi%Q$G1MToB8F-m4xQK01Ns}x6c zEe1xJsKF=`>4ksFn^kTc1&vDmYJwaLrQDh_#`PX8tSOtpGd;-LwcP$xTx_0#S zTJn&>EEq>m)s|gFk#X?%Fxp%j13i%jhJ`~e3JW*LQwM}{A~mfezlE)Q)y zAV9`?ge23F+G@NLCJy25X)>aY;tzEhg}Z#ppe^3M2_iufRqv{uxcniP6|IS!7=?7eSG*9M6PUaETbV}9c?TNZOwVt->|>_ zjVkl%O=UOynx~t}syr(vHkHjnF2cZ=6hPh%;Z;%*FvnXntl7LUTztj=sk|^)(s8p~ zp>XP}G?Q^QXMVuPb&cKwl3LqZjsp}|J)248AvvrWmcx5A-M(~9jEJTmo5|Q>8Z>Wn z>BZKes5=rwBIbTOb!`sXww<1CE?3%GRW%%ef1f&aatj#;{%L6onTEsR7J6&)w3M~5 z$G2)JTb5(FR)r#Qx=W?C9NJQ5xaL#kHc+|Dq4YMg4zBvPmNg?rG7P%TZkgK#6nGiE z-%9oeB~W$e>bggC-BBg#zC^3q$QE>>wXDZU&$#n>x&czfbLXQ=G}y%rhSYqeJWIUT zkCk^sa!7mE3ve!m#TcaPBxm^rdu!KeU>gApY#xxjIpb7n59WD!(U)rs^-h;c6ZDr~Yq|K_Ud#RI-}n=eD)w*siLN*QzOJ(WzOKgp zeO-W5|o5NER_W^pt%Q(TZbDVUaX?YH-bDJr!6MHMaPjZuIhrFFW2A&ON z?2t*ce1nLjSG!B)@i3#i5SbK9w`>-B?%e)! z9ay6)DCdHCEbb`(EqA)*RsI=|-V7-$tB{7?EUQPIh3;-0{&+Tr#xr4FceW#~ycwI@ z0{Z@Dd4HR;?EbxzYi;COXQ9AWOgKa!cyB|Ufi~ODcJyS&aA+CW0hKJvI?YjFAJeNn zW!b(>m*F>RLnQ=OBcb!#wr>OgC*3L7IW*v8;8o{`XDcWJo|m%%DYu~!?Mo5QH>8a@ zdE0F=t;RMLkd_=^4H{s&-3WcfT*ro~Gzgw4;rJ4WDu9>TtlMO*lmeh2F*gEuR4j)n zz@K!pEDpXsNjV}I3}t!tHhCk@^y_ZdGyg&RIP`X@5S>25wX(Fi0Rv8_9yF7~3!Q*n zxM|4NhH_n2UeJYf<`&sh+G)|)E%nVHYIQ5N;>pzOR#^cX`af@#b>wdgG~9Tgg)^Fa ztE?Kuc;h;*hu=4!X9XqPA)g4|itm|4qwkP6S1QE!1!xZB1+Z7;JXrlodCba_>@DN& zl=VWm^2tbQa;LQIPK{{Eo$?-d{l(oStK%)&-6c~&3Hsk9b3h4#@0Rc4Fyn671Bc)5 zmK|_N?2>8D<@Ij(BoBkLwWfs8#HGs=DqWx3;*7`ug@x<|Gu z^5tFCTUKOH=%k0FcPS&CKpd@T+jc23&Ui#)MRT0JViC-`c}PBe{SRx}xzhZajg#KeRH> zy3c7nm1}W^c+|?qxqc7k?fo7xr_@T!=lfM!cu6H{@Bn7qE^6?oRQ`4YACZkavIkQ! zt@*#F&zL^|v-p2q!{r=qQH+WIzX8EOaFT%k4M-U(!2g>w~@h)%iEhP3oIBo2;V9z8b}zfoZMV|Bj7s7zpUP7LmDUMQ+4T`r=b(fp*2s- zJKQq^$@8?l?Jsw>{a^Ar?7x+tQJnbVXXFId82bZ;DW%5SJtJe8De-q*g7so7Si|h%+b%w z1o%+QeqL6I{#=J|gu&s7<3>{9`tt?te_kebP)_t=)>c&^IUF~%^{77kIC#T+wVe)h ziaW3M{)l{li9#U*tJNM#e*v#?obG!;4bO!aWLHR`%Et4a&&D%8P#OEqX2`+H#?$#l zDDRKZ124)Mm=2MH3~)m!HX_t$!d)7GddF)q1(JH1$e+JSu)Ko zs~DTaz{w*Ypj@rkn5UFRY!t%#uw#N9AGrTz8P~{%5d;s{;ut|z zS+{7(OR_W18S7zw+WYqZWbcVzUZ!_?d^ltZ zK-Eo>4Qb13vQeW^0^QWjCk2icYS9h!VIa@DF=gD+JavQyy_;y zMTbf2d6&;A^)$cT@D;Er+gj0*v-YQ=g3uTOY58T$$ZRjlCPhm%7TG;%QOZ1@_n z@bG6ry3I#``vDzDpyxBDFG#%t4SZ|!3hK`kcSJoc>5pZg%vjd``<=2Vuab^TZw` zq^&$shH#2S_e4Y-+E+k-@c%!>tq7t=A~_m9Pshtun0<;@%xITjwq?9g<9T5o`3%tRWrLH3}x z#=$@_kvKgl6-55Uy@LXNaUBNZi_#MJXk zWR?dR+c(J}sHIm-FIMMv>ixDf%OJWJOQD!}RJsaHI*pGibD;>yp-*z*vo%RoV_v&Q zu53_hz0W7hH)~E%38>x7G`cZ$*q*pj0Wa_sis}upGTDMyNF(3XE-m@*$`v)2hbYse zf3sH<_D4~(0}2n6rccq$c1@AbIbQZb3J5rq0~DaDV{f2j%=Fx;Ft-(h0*)Jy>;ky# zg{e@V?IQ0qd4p>`Jv>b|t;tZHSg8*uX=FXs$1`s27#WLDQ`!hjKr=A zh=(2Y)lB&qvn9LXo|uhU zP)MFRvOTVDo+F&Qj4AsfIYp7ukbom2>1$> zh25?R5fED=G6Zu{Qm1+I3{{FapQi4{zEVJrp(~3Tj8{lk53)!P%g&F)FftS(iZoncBk`y_8aSA1_uTO1-PK7h7&U4m5v0{2R|5XnbFj| z^L;*+wNH{O5ZoaoV{yz-8*$n(owT#pF{2`g9rqE?G~h-YcEY@~F3hk1Xzq5|Q1@WLYH23N2Mye%@n zFNWg@yuudCcD%O#wOA%MXX8%bjbMab)|V~?ryXGBx|BME%f5b{6U{cpS$tEK>jloS z9Q^hPZCxzuh^YlU#&u9IwSdBxNN*|e%(X~Yh?doIlf1( zfu0T!A!}u#1mrr;ZEzbd&-dfjD$hvV80q@Zr;|FYgCV|JD<4c|(Q&9v61@u0=X7URe+o`5eIvUIbn7`h@g*j4QMKGZAJRoO`lDf<;RTF3PHW~J)Du)4Fi8uz64o|Xnu>FN1osR6aur4i zXB=tmbs4WFEJv?eYYfSDO$`+$ZN z2M@y?_Vwn~1II{gpO9zSc^p?9;{=uvL1)~YXLYFEM=1A!Lf~Z7E`rpBV4!lLKt^OR z#9$U_m89XMaiT8kz&@X*r`ADFJdtwOK~UICht_GA*6Qo!{hByHEVhZmTkAm_KBgt> zhNjBmh9k;nKI=M+khHF7Rns$fLqdwaaW6Yj!1$~fu0B4he;>XwYZvSrkN9pp;oRW*&v3C?I4{`6 z%I%LMV8_zPFSMAq=?i?#!F2o!`B=Y=jMxR!zXxleY-+3N=E>hdLqSuS(4OIQo1TK` zBBP=%XNrszJRXbLc6OL6%%m0DWJ1{>rS38vu#N4=FESnJv1rBJqSN1jVBU#848Y4P zkmpOe+WuOx^uw33in1<5ekt#!hjz&RzFS9j$STUs=P2d75a~7kWOxj9y9c@FTJ6-@ z;hsA&%h7FvQvlI;d#7|#ltU2q>bZxr6ldzONK8NOl)*|4Kjm_T(2ZxpYv?Xhcj@qJ zhE;E(KQ-E>`g-Br(U}9dk?zA=Z*8*#3U580X6%yD{7QIO%{cU9{Nd8!P4#W63wo_U zT;s!)q=;p-g_6IL|11fs=fx!QA|}*iY)l7MZ?EJzs5J3vkA+H4FRO!J$wWA70UWld z-&2&d`%3**#Zy2KCa6h&X}?T(>(j z1^g6bb>|nD%8&=DE48x}b+wu+*&YVIp7{AnPvt^Hx=cngCu5JSZH!u2fPI)XK%2-y z0VwOEdt^tYd&G!CO$ka5wI&=Zl%&F25^dZkzj7_7{C)B}_>)fGkH8B|ge{#-<-B&H zvssZEACOT+(KLxZLc$+g%`PS+sa)*hvpRM$6OvSSYwB?}xMEa*)fzB%kgozfzhZs? zn<0o!EsBVul?P;MNIv_(eoV&?K(#TKZapaf$uF_#pw=oKvya9h?MKx8kS>4x5TY3l z(dA_)+L6_S1Jq?62l|C8$bZd`%Nw-fQ3J7#q>;zrKbJ$tkISwOpXR6p5rpw_5L7KEWQc<= zqFA-TCo~7*3OAF(z~mUvn+8(hK{KA(ZImW`(+#Lfemq~7AEkyC05w(}IB|1qaSi4U z>}`239O~U8g6ZN(t)IkZtkRD3J*B6S+ICl*lp+3mIX43E#D$YuK~-iO%*RC^oPq`& zMx96dM^*^l9B6%&N3ZsetOg`@`LhmfX!5h{tYY=?s+xlxfjgkZAO0+FgsRJRTDFX1 zq`$qedm!Xoqw8TCS8~?Pr{&}27F_J8yp^pP7g5hnq}ZQY{UY0VxCqc8*o}{dK!2P` zul_1KWt?6LT?2nEY&zfIyqHg%vooFHO1ys+t7PwlPNl46w$`FpCENGS*$H!1C2JNR zI267eDv!p6hWBB!khO&Gabh&BlJ(!B^Z6FrE& z0n!vCTmT`!1?GUykv0KRKNF1QwB?M9i&Eq>dkl8e?_vGH5q=WCpOGD|J)c8Q z!L8ZHBFvh`;23OCv39Dui2wTq{FiNWaiwtTLDt7uEP#xpA!lW3#uqT`dp4I(4)Tme zo=TAVV))HW`fX9n#tVeYt!76sTQ5Ybg#>s-mDEs~Yn1VdEuCD7#<^SZ)=Q%y;Xzk| zbA<$`afbo<(v)ibE>j~E79BU=MtA=%TbX`&vM|gPdA*2J(T{8Bliy|2Yn`EIF%??> zfZA%G1RJ5$>|p~QRv(AA!1^r27SEQ2j8;c@O?CscFWqrYCWJYl-}C~mN=5tS-@|CX zGfF}G7eB>8n7SQFSG^}b6z&{r)Hea&dcO*0rfpE6Dwbm05(V`fDKB(hPsO; zo|m_R2>o;(!mCZ$+!rK`0WI?*ZRh_08E|f2yyW)b3-a1B!^)COQ$dl>t81#TvcaZV z#k84=)^Kk3d=N%SGh`ecz9`$;piJ=pP2}u$U<)7xKm_MaZmeZG$&yfNGw(QSofI6H z4&UtIW1ljaXpNm}R#(!<3YXcq(#i=eaBky058;S)`W84JGWWAavq2h zmZM5iqF8J2V_?CsO1Y3~1)8mbQ3s$Y0|L!E(y~Iq1+kA4Snp7;;T2xQq48;?*W)ec z1@vL4H_99Bjq%39OmH&LYy&D;HwcJRTc|-gY?Hl$VEN3VK|v<##P$c7&FZdJP&@ql zlaLcbNj>UK!8*W>!vg~&Qzyj`yFIydZLpaPmhzFX$T-Rf#sdz~$H8X99u9tnM@5D3 zjt5TG8`LrY6OW}~#yKcTETL~Q=nu$`zIh2&MtX?Z-Fx~g(4xGAL) zyfHQ_(wK0Kdp0ZFRC!1bhMP5%0R6IC=MRmg>Jetuu;W18gU&sRdPJB}8N(Q?Fv5C+ z4=i&*AAg2n`G7^I(Wb5Os)m*fwK%7AZdQSAxtR})NClK_1$6iY7qHd?9^*6kS-W)& zHJA%<&JcSptxgO`_Q|Fvxt3{N;DhZret;{_r(nbUM~Kd~NP`SBuDTs1s=f@iY!v}* zM~iY8wSyG5+%P|4Zj3dB8sg(cVWu@*0#b~pdd|Brv>Xnhi3T(GSQ`$WR*_i?3zVVZ z4+yjMpP_$M-HUCSS18Svf3D@Cf4k)pyXEXiQ|V`7J!bvuwP{zm-mrj$@E!!6;|Hp2 zFswqwqGjzbRHBF{;QDY#+x?Lv~s6`2zxxUgsyue-mHE7qK+*Cu&A-V zf}XY_2c`vNatXu{l!W<}U^Sye_?3X-qQv8rP_G2@{_@;d;q2CPnXLlCjFT=(=^;|f z6*y^57Tak~s8XTW??4YR@doQuoacd>Brq~mx)Fqq{ zVK{|UHoJnMyQMNVtlc!Cvf1w%9olBObQGkEqadMk^w`C274yjSuBhyis?@NG*)#dd z90|>+atRv}<27p|gx&I*6>+%BYd*ohZIf3qS@fINT&<@rn0hsJ*Cv?_@e9r-nT^43 z)J-;fq1lLJvqce5*QR7MKFY^KpdG9KjNLBUS}0=4Q`L-jH6YJ>5wZ2(9i^04;NBfz zA(!>zM$AIa9i^P8Fp0Dll)1aMs#TSVI(M|UC}4SrcP?zO>#Lg2@~(`} z0(ZL1XP(rDj>u%-^Q-QYVx~oHFhP8ZQ&P%JF)y?LR`sP$O+u?wWW3d!i0~B;3rPeU3QEoM}Rpgj3c)BqNtry~q=P(_u zW>!v|300Na6u~@LaZjlf*gQ>9V=kpsH(S>$Ez~x^*iobgM`#+hN;W>C(Prvb!)y?m zy9RvNAA%;|KUR5$n+D@DnQEmFW6OAX zo6+r(=w!U0XHxm3U<(Wr=LB_G0Xn^CCoC`oDP#U}lV}`Z8i#MCmA9F;rl;5K2 zT#16dT|w3~ll}Z6mFWkwK`BOy`9;Ir8RQ#g;ft9Y z%-dgUo3}Sm+X3rbps|9H6$2$y6fb{Us0|cL=LIHQSTi&PyZr%W)G^z7IsGDY0Gxi& zo$htD4?qO71-Np%nD*8&Q`3Bx(HIfXYprz#s~zZ>7^-|>tsIt7f#m@is9~B}$9*Q0 z`lOlt;5b~6X12iLLYm20Ybw<>J6;vDRAC<`0TyO5MxWJh7#3!w!?m0lTJI`(uF|_1 zXLs{$J+ooCZ5M2f)4B`z4XklWt#1zX@D;X=)B&CoY7e0m_04Kb_2eTuG-C44`dH}I zMzHz~%u0|ix;8K!1WTo`(@4Rb3JL>^$xsS(m$9FhR8R#rNSf+ZOW8wzbY|U=b=w?tlVcjijW?su%Qjy=c(cEOe??%ndZsEK$ea-3s z8ugv1Oz$^0d*If&=3pa;Vq2K)qQ*jEfGDe#7bA{9_I!o8>1kW5jq%1oXp*i~`smav1 zojIaH85|<*Xjg(QypJJ?0cyMQ>w-RjY)tcRGJ%jN>EKN!;~1rMFq@b3AsW!ZWFMm8 z9k4Uz(1{L?9CyIx85tiS48D)x8Jl)AUv(dtPpdkbJ$O8$J83Ovua*%N>7Gue<6^X+V2%e4Fe}jA z*P9AmnDs0wM<+dWgIUM(2lEY>WGb~8KXd=}W=w@YFoW?0ZFv<9lybrDDfx!ddTOzS zdm0b@h3ej31=#fi0kMj?yei;&@TXf!>6jkB&YYF{@l~pKY4Z){MIK5&Pk=fP`u649 zeNF&(V|V3I#3D&`E1y#rpY^wk*-+~l9d2OPc7PrVwR5kYUL)ZC18aB*pohU-%eR(x&B5%sn_!fSJ;gLF-%1 z2C;gkD0Kj413U4mrRI7-ZEKTn^<(>#!q!PtvHw=H6^}~dZDx%ib}LrlA%SoPq`AL@ zS9PBY*WQ6={k;Q&;S2<4z`eJb_4OXIvlxlk$s{7>cJrmU!Ves=5{w~aOYP}sd`S!1 zm~|qQSP-rF$fIq{+VCUmL`iMU=(xkvv6UgW)zlf-%~W`{A`G8W{(WX#8qa-~RUhrx znZw$1%6SH|GqSv_mp3@gXmFae>~`~c*DrMZ4zrf$t59AZSiC&oK?t%Lcn5C&tZqgv zEPnItU}GZAm#vQ@CGvqq_y5> zW=*PeH$;v#^w?)+9Ey%_FunB8yUlA;mCl$WVU%Kw;rFb7B#ih>%k0o#(F&-zSC^@fDH)N0xqZJMg{1pUhHjFPMa5L zU33jJ1A|-uNaF4A80bcbmC;28TCA4fC;$}kos*fguD99LJek=EopA^Xf<-e)^f8lD zUn`Hsc5{V2rrNMnvJSPe;vi;X3^M7~KIWjx8==u-aU=sFtC&zhPbb68m**ICbqIPZ zToMrt;V`tX*{*hRpZsX{@55|j?ORePzEc2yBYYrubLP{)zECXX(3ZaDXV92Tyw_|5 zWausTg2JAeNv?k2pCE}>?q{ZZ){7(_d?25(x!3r_H}CGg4DvJPUJH8r0doKYS2AA( zGav5~il0I#gdzZ%eR2#*^&d3jG$ZFzl+vvanksbm@n_6R5t@pyE0+Gq`yPZg2_JdR zGn#LT?+*>rd0QeKe_l(ZfDNUKea-fi)8A}T0flgXhA-D^oX!Et%}|x#lyV<3uf20| z78W-2tn6Sg1LxWsqJ$5_0Z!GV;>Ck>|wBRzQ&KcIKYgF-c#BRez?Dx6al|`wlQ%aaMVL)lBei8 zEIHVkagwfm$h?PYJ*-T_R1%VaGfZY(2=GQ1X z@v!y;EGfueR)FVkgQF!CW;jIh*`uNjxi0^dBofEu;3GWKBe@5WlK5Fh6VuF3)~?`yX0q z&zvz&fS9MuCm1?J8&zoJQ)bIRHlcj>lv$}F>s$(5MNob2bgK}O7=DxMpJoMY#a1S( z_He!SY4h1~LAa~+H2DFzgZ+Ha(`Hw2uze+x?9BNVKgKz^BCMbDm%zztUaLnpI*Be}iw_P#Y|rSuuyT z3o2B5XGEmx^t)%ZIl}XtRv5H;&QyUuHiuT0jLpdK-b-ccPw26JX0qm>lwy@8^h0L! ztK*=exKDUuDDsESzd5-Y@PI=@qr)A=?BCk`_@C_V?{K>Rv;;8$J|SqnrXrlEPf-z- zvX3Ls-1ZqLhJ6M)VW06nhZbZ#Z}zOVlMVh6R`!r$G$Blpsr&%Fx6agJ zIH$J-hBv1lUx37Tu9R&dz?h{wY51bq`qI6n@rk0nMX5}{4?tLCOQIGQPn6Opj^%rJNR^+#0hrj?&wxah`M`gs!aE2#yX+(WdWCPU^oYM+VaB8@ z{EDlukTV=R+UNAiaFe4R-mJ1MHjGudiWO?|nyGNv?|jW{E^X)(EM1r9O?u}wQ)P;C zcDf29%-iiWt*}g6E>wbJ3DP*Yia@Vu+Km)WrW%N>YAVaOU2wGlh%QHit1;XFC>ysdlIHJ!k|kcBCgpn$a0J;p>eTJ1VI#)m;e92-`pa zu3IiC$ikviwUxw!%1k%d*;ScQ-JT7s{9=Qu=f`p&F~uBZamO~$l;LlJRZoGV%<|z( zP9c(dmeAHw=Cz2QePN8*CaM&3?zmBqo$HPe0~#4X|Eu_aet62|n0N7x$NA97>hS`VKQhePp1q2NE=;=_D1*c5os-N5uiRZ%-dpphz)j{S z%6|v$(%4#)rmC%V>D!PZoV!1lyz9-?T2R$?!Da8BE_wID)S|ZTU!tkUG`*+W5ANc3 z8|gAjyq5oi-9Jass&|St_P_1=wPfRBPyX$)Pj;Waq;LP$@O17zt=M?wO)L6U|GWF& z84dUT%YVZi#%1Tn+a>2mVV>EF0|8iE|9{x~@;IBTH~xF??C#7xpU;>DW6X@P??a3& zTtXyNzU>P|$Qmm3t?powqD&=^q8g=AsYa$o5o4){ipUZ&X+l{dz9mb3@8_J)`ON3u z8AHEcfBt4(&ppp`&U2Q}S)cQq?MhoI(}!hWNdCf0S7r$*a9oq6RH!TSV(NO8ng&V& zXlZ6IR`UnGa@8YM1A7+xZpCE1{Rh78Uh9=LtYtk>xsFm20 zGg~B4@E+~BQjkycp?7`>R$ojo{wk{z7P#38$$isbxc! z!{gL-J@R4!?|amD5_Yj`);X8X`og8NzIf@Zb1$8B-lem?a_Ox3m(Du>(pg^(X2r^F z%Vk)4{Z-JX%Y3zcXL(ETIqaC??ZUh1$TD9h-sLfu`!44R4L=TUp9Yn>VX1u7x?y>y z6LoPGJ-u9Qf>^j5r!fxFhW}gtcYX^0pV4EV`YxApjemfsf&Bv|pZbz%@vKpHLtdY-i+E=ObnaZ8dR_=VRa_7G*cRpXabB?Gq z<&!FRo?N-}lnXkSyobB=F6b(={ISZNrR1FJIzv`I}$sM z6Hz{~u;#?f_**A7&ymh*sf9JCc9EUh0!M1!vQx`!oLZO{PHn?WO|78* z8+}d8Qk~o#R&r$>Phv{d@s+ZU$ATzvQQwWeX69P0<5;Q>Ps?V(l=8AlHH$Yk`EJ3h z^Q`_z$EGx-ISiV8>>)=pW_%{4ZuY$x^ASriScKV0#hZNzxZCx+%~GpGT4?istInd~ z_Mn<{^-^43f-y1wTVI1RP2#3+eK$1a@dP`QSg69>iuVwxjjDVdEtH!J4`DRI7<&*V z#@GQ{d_ADTn!Clbehpua0m0c*jk7`JyIWIl^b~hdUQ0)rLLX9AeA9E%+l?_9Z;znn)$J;$kUhn=d?8 zULnHUHdyM-+ol#s@{vI6AT3hXffLA~pw!**Z&^tF5#3jKCX+!4%M z5R7ar`-P$B#t$}_d`pwJtIYYbrbwq9+kK5PK8mT-%X<+tWjkhT$WZnZhJ`t5veQ>9 zVHWyAer3!*t*n=&`F*heGqBUwpb^`mL&T!>&$t?lS05wzNPD>IDY3?B-`z!;E*TFrQUf6@ZhTlhI@Z3XA9@1Sj z{RdwbX3wAg0F}gM`sD{-hf7KoHZOR+pYZAtbe@wde_+|V>R~B1fd1{Jy?cFp0b1n# z*w#(AEM{Jx4213z&IQQkpQQ4A20EZFzwDJA&wP>*sc=xqwgkD z>1WdAtc@3?)MMj`#gmJ;M=8K7Y{9jwhsXr#Q>irqop^hor`yt#?< zj)xZ%vRdZ)Tax~KkF`_!uTtNw|0sYzLITM9*>~&Z|0D%du~{7LaG{j~?{oCj55DFY zDIyM_+D)dc1HQIZ-{#r`-J8_5ufy&iDBwEm_qE|2dYi0mZMa2?s|ot5E^M@SwS_V3 zw>5M=Q?$s&ZZ{q$qQNe)*Lmk<*rU+!^U3eXIxhI)GYkH;Yf$fAz%k#oawN$+;JeTL zJw+ZwVz5oOHI{Hnvg?BxCOyb?-3f)8s&qWebAx!+6XRBzRKaP+Xa$+GE( z(fqmq8r6r8=+ab`cM=)E-rzej1QtJE>t5Bb#m=%0OXOBWf{|#mS=9}O2G!!zp@TJ6BS$>0ebaRmDc+LPu z&5STvtxz$zPR-rnOSy#g`J+4J0b&*^_~e@0;h1mlaO7Q-_8}VD{F|>iWEnYhKTXlc zd~Iue#jma5D~v5}^lVm}cf*St`9F_tKjs_8bp_S8?L8Up=dL-OD7&Dszxw2TbblZ7 zb;WLd|8d`VRV7<^=EON_V>+e%?rRzxXIkZP#?v#$p_PyoyoLMK*(cCH-<+lg>|L1EL(b1gZc2U-RUm9;_7TCx9-v6*+ zqY@u|{-KW!VgEFSF6CnA_Xqmf^)%)WUsJVV61!8SN^#*IKAvs<`iE~1XG=xdlxaza z<+qkeZ3|0UP}Ol7yy&8O4?Yv7dcYI*74Q=FYFx4CNLCl>9j6r#$Qm5 z%razaugR|nasFS>gJ&O3di>?f&_1FpA2jo{ui0hriWaAZL@jE(BKnd~T)RFg(3B~{ZizME6jc&u(Zf$Yu|9Q7TT@iV=8##g@uu6M$n?41;pDnCJ6a%j?5yzM_%Ks-DoCxXjIreEKq698MiD><|uLBPCd%F0WaF3^? z#c+QUNF$H^%@XAYRQ$K^8g;h_s`$ga1JOEH#rkgRbtrwJ>gMw}QFRuNz9Mp-e>_ib zpU3XzOC3Xsrw0Nf3)c6SsF!wC{e=>pF+YP z93#3q2a#1VBGI}?S?dr)hz@~bstBAJgU$r9q29wRC;RAW9h3bLRYW~YPrxByX7W-M zAt#W$_fhUA#=SUne1u4g#^=hRgm%ZOutimI6(3$fx5xV!8AER=v44wawohEqWIb-f z!vS+_orU4TQ;TZkF|cD2l6mRN=+~g*S?~&Sem9NviQ2R$R>+&XDoNobgdCzhLdZS6 zrIC6iZxyXZRPLGdvk!;#W>J(7eqPPz8;X!X7HcrB*_#7+3-S;l#;RVH_ix(0Yy;k+ zYlxPfoDZm$A+D;7CGX-aB_B`^QxK*nKbWF3c2~(Hm2FXI8ZSz?YE+UrG`6Z}i`%o` zs*2h_iAt-A)=IqLTfq2B>L!S+#1J`^Cj^jFM( zL5}?1EZpV`vuC2JZj%#LohnRJ_S;~efg0s~!Jgy!=U7waC}eFkC}dlUBr(R5znJDH ziL0O@IFcm%p7UYUB3U#SipTat-rO(65zAX&d)IV-$zYgL!EC#PVCot=l!ZZ|Fr`A-ehHz}G1ux~mO6rI($EfN$HhW9nj*U3ZMo(( zMK&7A(3+yT`(vV-BFj=@HtubyCYD-nt4T4MMcp~kXREllDnK7mXrO6UuC7=Mbw%e? z(en0SWyRBW)9`fhFO~a`cA1lMps!J^V}DW zqwwe&x}#R*-%$`6$5uxii!L6=TEy|&MdH}OEg0ReT^NUQui zwA$56JNi}L7KyYlZ?7aB*tBaXEf zk7EJi*n5#U{$JZ*?y-xvL3~GWng7G@n1wi?Uahph`hWe71()z0>NJ(3UgbH;W5LDC zqY&khR=4u+I2c;y1&%mMFCh+m$NLwFW16M3xBHS}M;y5q@7vcRj?VQ&%ebKNgL3MN z;i2cM|3`n;6D`u-jNg0B~*I!%?td8K78UZv=~ zrlLvUo0XXIRKqqK6o}h@fT_lsdbSu;wx-qxQ8}yN)>ON_%arYJ2UEB!ScQ3%sWeSJ zg-r0*2jzW|MPBOAOthQ@T3nwqnKtjjV;~|?NY%XF)u1Okn_7xSQoCSnvb*3~`+!zL zKK3-Pm5|RKZD}Ryb=wjy*G^ausn$+B{;k?7Tw3w*#?tV(bOC6{c5wLsFM)F*a&Bf6O64AR5t+*`kNCIV`AITTz1-LX@h$e_N5v z+e*|~%rR|6?dmzl;dQ-`YcFbv)VlYMj<*xdDtJ{lwjF9;xwm#<+m5@zkSBOAV0~SC zF_MpWhF+#i-?mp(HN1mJxAi`k$yH_Zva&^GuXhq!3f+<&mqL;Ag;BQ4W1zjuW3W|O z>6H#58Rw{Ehd$A+%nv*2vayD~>mXWQXHO@G*`bWI*sL*Pg6%L-J8-9v=ibv6>? zJG!}}sHbP#g{uGK8F$<=0~2(vv31b5(ASrXRxO@Uo2z+m3D@=pD70s_l_9Ot{hOwt zqKENP=W#D(brPK}$=711uU9&Wb|}D|ox}xRNA-3_37?V-oho`hHO!H6FEj(z!nCcl zV11CKw0O0%xGk=@z;X2nP46OV<5bamT|{c_b^PYT2@EXUR`G+E_;xt0j9=+U7fj7B z%ziM0{bs+ovcvq-Nvu2z%=$hFst{#J9&Unz&z} zDqY3c>sKCTXGb`nvxT+kQ-*_H0;?f>*~2k*^7_xP!K)a&{=xXPBkV@IvkUat+S7UXe2kgE))b$P3n;p<#M-mLhrog*~yMv#rghusHGKFc=W6J*O@l^$ec z@!{@er*Gzq4zfw7S9^=pU`-&jctzjz7WcWaL$)k?)9KMZ;x=P9_N1#_Q0rr`As~k) z^%se0h5DA{h1M;}jxD4M&-9?h{X{|lh#!rA(HXsIwBSq+dDW)N*o&%%@dB>QB)2u5 z=^;1lUHIVQbZ$wWEgacrkA4S7!aG>0sGsl!Kyoy@?L?H=i72%b!AzV8n3tZ2 zLcKqDp`{3O=E2#ZL@Wd==fqh%C)k~JGsXcs5zHiW;_N?2M5#{1j`E4v5tN8NAZ1S2 zi72rXvCmEfGs&E&JP~B}7Xyt2Q0J<;vCgg=Nwu^t?VzPgb7afGbE<0e0m5lHY;S%( zhE38cL-yEdVJ1!s%*slIjDDhtp*OM~)Eim*^b?s~c^_-Izs^0zhAPGq{fEOLg=+%16J0 zBeARU)gWa7+KDK!6Y+zc2xgK6c#%X<`T(UUwr;MdQ1FyO_vEq>tOB8Xz;)tA&!z%; z?>f(^qv|94@$`!9s?-oFsW`~N~11^+@Ai~of%KKK{H zSn@A~QTQ)}@!`J^#z+6RVRS94>qS9fJW)25=jsvcRQa*|6hw)FTSY=|Al&txwMX$B zj9q+BICnNLR8^t`GjZ1k6Yc5(f&}?)6L=+=A7$s&%l5a4%c^`8A*XkIeceRMRjq9< zxJ|UzuDqbhuGRHcJ$XwJ_6YJ8M2~;woK^JUZKAdbgcD_j$-Zv9UDWjb?hfmMv2v~J z9-JpxM3ZmF;^(V)-=dq~EuvD$ZGDHhJav;g4*_io)N7{UQU@k*zdE+6enT_w5RKDv z@ttxT{HfFB4;!7fMyyk(RgRt3B1eub_k6GO3oJ6fPFIp&7_HwCt?Dy5}_o(!?px?%$5Lu(uuI-Klr}XM6A`K*HTOLatM4&ag<3)Fgg)l zK759ZSZ<$oDrOcb3h%el08cU_U|wn(W@#yET6rmInwFyE`8#Sd7{#F^sTsB;m1j#* zB~~KfOI6JCmz;=`IuQrUC*ojmBDi8+2|HOQ>{J}HQ}LrN4l5O4y>M30BZEaFm^SY@}*e3e-u)$h8+F17Jsn?&&>5BTvH#1 z1wS{wkX>G8DjppjwmdF{1$KMy8X`JfR+0yMzS0)!~?`9JjIJzVhQkMM8IQ@?Euj5*Mr(SfTKR z9cHT1*V3O6$9LFj1ykJ-#*^5&@%|UtA=ST7+EedgP-0c|itGEs#CUbu<&>`ZyjtLE>f+V^Qwj1O8)?LdRt^%TDkLaBV?lz;Zb8Q-KVuq zpe`w<2ksH|67tn?g)mDASq;j@RkZjXtmPb`jrWKy6>Fi>N8n1fjpQF8y7JS%(O8;7 zd*H=%dHMzvY2X)yR+r07Ax^k*UH`mkW9uh>M{zurLw5+ zXwks^6+JLoG%Gv75=;G?ii8*g-sJuyx_Y0;kPRv@TGYD;A1?r;j>giP3Oojj77^%| zaIE{-Xvj#nV*@wx4@oj5>cW;luCfrC%-gB=7;$YCNJikm0>@AE#u&BmQ|{1=J}lF4 ztVmaNvN-4jRxvLs4IC@#cnUtCsbfVe#e}UEvgFh$I=*0&HZfE22lU5SF&ejw54l&g z3+fm{ySMUvTkbQmRKC4e+{+)|eVjeapXi*BiTw*H)7z4DHcYC^eB z?&23|@fhJFB+)Fx^Wx|sh!Ck7DhKd95s*5-!BF> zJ;OH_$bOi6RiJv)ddNit3ZAUZ^?PVnLm#x?Zg10t*J>7ELfR=8rz zg%xzQ4Lo{bh4a^#L%k=8TAmYLx@RJ`C7+P{>>GHN;)SzXaVZ9$npF4QEChy?%ugm_ zA?+tRJW-@!pIYpLSl66eg;oVbD;oEpxCv)iH$EutLeJgeA=~L@i{(OQE4u$t>{vY) zLvKGSYWff2_Ib7L=N;&Q!j@0aVOyk|56~G)lFmlf_H+&W2c7<`Qj8eYz>ECKWqc8S z_|=n90dXyM8x{w|E!tSZ)Md0NN7OExyKT!6`~Y0cB+=J%Hk@vnge?Vl)SOoiWAs^< z8!2l;Tw}if9@h0`uWDJHE^qZ$c`MwH&mOt{r%w^BQ!BjCjYk)p*Zz{mO+lZf_LJ-P z*!iXu(g&tXrr7(Z$7erE2{Jb3aJ)8@xTDyrOXk1MSs7ZSCYCL(y(xc3&Mk?Xb#Pmj+)P5n5Gjy*1t zqSv{sQ>Qk&96_$0Dq3ONz`AMZbx|-!r-|m72QjSSPG2d9&d`D)Z_;=BH%lkHR@>zX z(cwBLMAIsHA=W#UH6GG&az~uOwurlE(o9^M z_0`iNx}A05@9fi93B;3}P}i$Re;2St6<91i2V@`raIru%SqB`)oya#+G-B8cwV&0{D^bSiclVDlb7cku^)SX|TEy4!d2sy*INcn?i5T6273;y93SDkxaYw?wTb! z1~DGKR7NH8Mys0c=nweATb8_3_Tig=JEC4MozQ-Q`h(jqVah27noD7n{aM~~qG4vq zB1bxaJJTVZPykoW7MYjHB@3yaR9z9Hyqgcj!ei;X**ZxN-j$%dv&%t2J>z! zY#dRNj@NrFb$-ZK4T272`D!H6xE8e|QQy6d29anc_^vtxq4r>SZ@+|zlQq>+XP*Cw z4=YI*i(}Nof}g(N0as1RE*gi!hcyBG2XXv^R9RC+_2o1Vrx|p|G$R)Ut2>t6Q$Wnt zHiwzYXUghW&ccE_mg6L@cE3)Y=ZMysGmgUDYMFV!9Tj7mbW%+?gYK9k5`(z&FTj0l zju>5Sb0jwDd+fz8Y?4%qU*w%DYGjurpfYj6d;4Sf%hVzqEHOQF8Q)aud0*w8H&yDn zv~tgfD)szx<({WSRr1ZA{RvcmuBcsqC2Q~@{NHc9W9U8ud+3xkZ=jQhcvjQcxuU@( zGq0R0vNNCfw5(Sz{UoS2eoQ){C?9!A)TK`IM10T~u<-(8faIPN%Dwag++WQTt%8Ex zeE~)U+qSkGXVieJHviZ?s67OMFFSM2p|Y=<2Ha6WbET8&xl-x*S44}%fQ$D zuCOqviaGRX9e0u*f8on4uXRq9wZCGPT*=Zt>_RDPqEn_s*GgmC!LfCs?0lU6{DyAJ z7q#QQ!PI<@%fAjL1cDj)YER#ae36bTM&-P&l=fS;)#lqf{ftwwCyIsh#W1hh)rzgDm6JTsQ;^?zRC;kyCB}GW$-#` zObPREe3@pwD#o|WD?vBZ!k+^}Y8VD+nLPs&JKmIY6w65-+|I-lHr!w#s@-c4P@bV1 zVbmywGEpvCEzkLaCp0UuO2B-}b0`n)p5g;k@S12@YcH>-`FHSBzn7zuU~agM@j0xF z`Ymqu0_bwEi@fauF;)(pS+8TW-V8eay6Ec8lZNL^H2L4e;XfQLXH&acOu@#}%BN*H zGl+VM`YgneT#Sjw<706ecA-eGU(Bu4^lxT^kKW}ovQtq~GA#g(Eo{x-5q0Rjw?uUP zMf?<(*Ka-8@y@e254LwU4N6~?TrheT%8n{TL_byDrLonOoYlj)z<1@lN(1u!5xG;ItLGEnl zF6UrXxCLFg4?5^B3L5yX$Ta4nb@JQUxEoCh$#ia!=uqDF%6CPF>Y=r`;!0(-qC<<-Y}@=m z9Y1LOfk>~WZtC%{`Y_r*VlRKXoa={1Oz* zl^hJcvqTsnAKkVP2Rh%Rv4x^q$5XhW2J$qjDll2>E}W?KyECv{(v)AM1A#Qj$LZ9D zgtgq~fq!idtwlgpR`tlhwjVtBP)rdYLRp2bg%5Mc$wGIku~M{g&!(3?gjBKif82Ea zo7vzE`wJM^rYPBK6aq&>IQ*fgU*BrWOSnmMyObA=tYOM(mviJrBg~vepMHpzT*B=z z&VPgr4!)R?-xVc;-vnF*UyHhYj$WyNr@*oPhN<;P6qWNOZ>)i}w_XPS-DiHanfK3=8wSdZxRZyM0E9$14knr{=Pt z;qEfl@PR{57e2}=hb<+*T9i&@u!)kG}s{G_{om4L?EC(i((OpNOh>s1RQm ztv=9=`la7pM-HHaz-798nHDOYf9qm;=M#|=wTHM0AoQRwvO*fNViMmSLUh zHy!sQ%b=25MRS*lI+-VbKuPc$on36{$=Vgi?*+?UakOul7#M}gFs{xEoBb&?oeSup zEQ7Q(S~GD~!yQqOYHv?F1w5aFgrjn@ zrjl^n{&_Fc!z;zDtik?%rTB?^T-i*uhJ(H;#)iMIC}EYzNU>H-!c>)c!kr=LXtm@2%V(s?`dS$Yx-K!W?NM0qt1%Td#FEx`R z8+uTdG`J%bUghAjF5Si$!?yt#&wH@)pk5nKa1pH*%@T^`N&rfJb1Vy#K)#JtE^k>6 zq#FOzE+;IPx!UEtcKJJ&cCHqg&9UW)gW#;=*Ll)$Qxle$>}-{fziPn|&$UwHHR3-B z=OV3`|IopmR1sCJAaV5F8Yse6lV>gVWAWmhe7p1~>atceO`36VE#EB*8AW1Pd%+&6 zcWLEXQ7>tp?ItmYTm3}5W2L+uW6a@HFDZx5tjQoHrrokX!@6}Y-TWD@o|qL*tJaD- zNy|5CR*7j=8T&@tO=8;Z_s_(D>W8_zPW3;*^Brq?zngpQ#dOE#*hcmzceklQ@5-!u z6OC{&&HG$jt1kYqGFEkMoUvhFh*s5BLLQFuPb!9CO#(_`1&@88 zldJo8(L-WnjO7}uI;^}UG-Vx`434-OsKr>-ryyxO$3yqq z-j$95_hhp!%wLGBNY-B{F3y^S3LC|d_2M!)B-n`Lt*~BSIFzz)No&&%Lylp~nzBtj z8=v9!gvgMfo$@DLzCkpOXptfC8tteJA}itsiN3Z$v}X}w?*_G`!lx(sk~Xg&%Wm#R zF>s)p;Y;#(y&~vJS9J5~Zrq>4vPigj8}bZMOY zj`*c%YlfD*yS;+G@K|^|C4HbVaT80&9q*x=HG*Y6GV;adhDSfr_D6?f)zD5c( zQfwiSn@;jrNB+&CdVD_j4CrXMW6NV@$aAwdi#qX}c+z887xR2aSufmEW<3YEWnGGa zTXS#aL0oZfEG@HM4jel^c5D{yV~P(*k=)yo-rFD=HPy?cS!lbNkRC_W_CT&?X$Bo| z!3XGJyv7!uIYIJXMdQ8|H~BI$d`59%?YMMYp_v{>S>K6->WAxBe~_Z^6RXB4sRA#{0^^Yeek!jxyd>1{QzWvOpTtYpZC6^(waVED5LEzY|ka zR;q0{QsIrshs(caW-%v$6)NYy!`jO?l)ep`?5%X=Hqj|%o7(44#x4hL#Xf(VsG739 z5{7TKiFy$OGUCwuPHz)!aPHFU?chQqrTI5SSEFmTiJBk5qH#tn(lL35sDoRb-rNC!V|o^6QS+9Z|eX zG;Vr34)9-wkhn)H{i}z6!B0p(@P(LQdC(oCAdf*Fgwu?lsM>Ck#d|uu^@D3Q7lrY6 z6iweP>Uqv9(>;Zr+>LsYql`()m@Ey?Ul#9a%RFP5XD#zw6rI>3>P4>Mq^_p4A8_r@ zB$o zh_Y@arj>9iqvS^qWt9;<)m~N>o(^eY?h z5XQ;6?m}tgT+bQ%08;fWo8>{Je<~bKe)em8OETK+^MBT8dv0i%U z7u-JcNeoT;74~ze0QT-5X&a0-ucHyk#D6gl1-=$P6@Hzki)@gE7^?Y|aLPI?s`u2C zZWglLU}~I-FnG+vxL9C?u+Gzv6wN3{x~dZb>MCwO$EbYh0E~` zJrXveK$VtadhujQhHgIob*oXe+WAXiKmh7@1l_+cxUMiS>nVc{522spmx}y+kVuBc z96@J%G{-cYaP8w>b*W1gtYk3mq(s+bnB!AWIz_jN2Tgnq!B9gK?W9 z=n#%h$U(^w(BG?%$eeNn!nhqs&^u2$5Ps#!=2)P^m;+nQ!MM#4bQWB41dy$KFx+NY zs{>i;2!wH)W2@#^=ip%6<_J3NtrN1t$#GJL5jf}wgmF8NpjT9MAk%PI+vW(mn^AM{ z&5Sljp+4j-Z(6i!5#u&TAm~m-9SGmAXtM;pzoI$TIXOyoG&^9cIT$YsLmxg`$49-b zgfJekS%Tg;(k%SKkZ2f~NPH3#E1N3K5FbIQTNxXlrC0tsORWW(a)NH$B*Npl^| z94AMij%FcjH3#E%7;81hQU?d)Hpf=QF&Kk_gN1RMCFsn#j%J6G%y)}8v zLE6y08PAaSchQIi*sK#u2f=1t?z(h$Q=*rBH(}WqQN0|CcELFHKOqw0Hh$ZUgIfM= zH;m2FD)z9l+Raup))8)KJWTgHArfO3&A5UCnKR>xOYq@LsSeT4DXyh^<+Wd{E?#x& zvP%zlUBsF0J)usqJAkNda-PQyj+E2t1#x! z`~MS3-qpBtpn)fUbq^~O0`j9+6*MN@RhRjH6~IrhiOmAZFfD+>O;ZVQvcFYLNc$7U;;15wFP`p%@dErtna~>*@Hb^dh>~Y5j z>{hNDD|Vgrwe&mf>k9qOJ1Sjsk5=e<@`!W|lpd+jxm4AnVy;D1y~!>fqj_!F?VsYl znoZ=N*PCS9vkhw-ja>YsI5N_>GdL@1T5kAGkMWp05S)!cu2bE?j>&2+5#S4TA+mAH z>&dFtYRW#xeF29_7jl^Fu1(EP;ndD<8gWY0s5&d$Tis5&QHyKG?7u`}M4FAI+gN=Y zYhYsyEv&j*`D1+m$xf%f@=!*i|;xhcOy^#ty8n?bOf4`rFtwHg>IzU1wuA+1SmDQJ1rJ zutRL8p*A+$#_rMBs1b~nwOw6qsD`71E1Y&giym`9KNBwK=K&pK#Dg~WU&iRib0RT- zBw%qC9YnbCM5I*{Wz}{#Jb599k1pge{X!1=B7)-x*s;&Jke8<}29y)7fCB zS<0!G3}OZoW!@Gzyv+-CDs(t4Qcj#a|JqlccNw=1{ z7guckfzvur7WfjUeVKJ(#nvBIZ2eKi)@T?239&(o4zWScWTK{3?oBcU@mwIFARhRV?V^EfEB>`ub6IrFPnt zFElA$3gJ4=(tY{z54DN0YA*IwMMoPo1GXpq!Q91$cq*U3lDN=nZS#bL<4oXzFt5qV zQuH6NuFD+)y%ufMa!1nUXd~4fLnSZ_!^>^IuIeP9ucx>eV`|_bZ+w|w_;edPeC4e6 zB$Tt-S)S_?QI6~T@?5)utO7F1-9B$D(#HLgaWqaap{{CrCal{#tcMt zVaEDMTy+)R4nGJj4 zvd2U|+ITKr#wKZwJYI$fQrZ~vtEdp?%=yd?QKn9Aw2C!jtr!o#2K9^;V^x_>#q3N$bJ8ZQ46`#?)I3|k=K z3rb;ur%aE*EKArX+(D&-<-$M}lgfiZvQSlpGw$_PQQ!DfywK<|p9paNy8YWe#6kd{ zJoU<)K=v8Wg_q$uk!ARw4*OHlW%fToFV8Ws-_geLK@Sk_E&vM|i9XLhHtWcHay9o8oIeZKtAU|5>0j&oe&v_up zx0tMHlbd<_qWItsm9~@upK`-!%!dcu`_eddQ{4H zl?HSmR$6o2E_5jVP5WV=VyuFy#^>@MV(J?x&_FUDLiBrjIdUQ>=iiA@fiIZxSw-1t zr}k;?$y(y0mY{d=%W*~)d=Zn;R{n8y``vIk;+jtn3!{1f1yfc^@Ay=d%U8l{Srz)4 z$+Gg@@(D=1kj-47kcb=n(3Z zp|_Wz10`xur14{dH%6Aau{4G;{={diAS^Y)V_o0IPo2jSsb!D#dmGQoX;(&Io!)l9 zRx=yN4g?vI+zP9sJnNZl8Z~iLa*~OWQ5l?EXKY&2b7iTr>8gukCJRa%7$^2_|OGx9n` z@&T!-kyMS;)<~vC>T0B(Mw)1(rG*5H%d}N%jkM9ots1#aBX?+Iutx6I$S{qJ)W|q* z6o1^$Rg}5kG7nhhK{k0O#4nb`ua$N!ev~jG2Td*@lle?8-bm?N&I^zk$=z1-*fW! zZ~1#({^m%YN%D8H{GB3ybLH=2@^@-dfP;8k64T`G6Y}>-`8!?y&XB)P$=|2t?@ald zCx4%jzt76w=j87!`TM;5oh^S!{?3uVFUa2)PZBT5-K%!8<}<-_ghQ}wDNA_ z4)=0O8){@@QUV!>qfZ!2)D~&YI+T5tcAE% z&~rnL4q2B04Y!~*%r+J{?XzLm)`AsueyGuEhz{)=gq98`P5%t~O3<%0Gh8>p+>5W{ z*fjkm=yV7D3+U@XYyba67BvJtttx(KW;3%xKs!x=6K9zI=nvqvm4lv%s8d1T)5385 z2j+v(E>}kf-4^t%4mt~TnuGR-(Dx}i#TAyVa`Jja&;%Zaj~Y8@__$F+Mo*yQ$%$3z znc+r8N?E*B;jfM(+|;5C!;N376?K?mj5q1Je4{%3{hpCP6JIr|7j2qtd=*Z|)*6XL zYhE&rBrCMVM@F9x?rIb`Zj2A;?@5hRbw$&EfsSy*b0~z4iVAjbA3`?|p;JQW8x$R| zGqigM!>AB?K?qGD^p_#@a*OVYk3gQuYS<0t6&7@t_O#=7!=5Ww94PDqRGhOE3@V3vy% zb~>`Lz;z_Kz=y&wCy+mS7+|<%GJOw#dya_!rbhxsaep$+vKS3>3}B8$kA=y-kaiyj zd_155fCHESxDT+5PBNuCjgrNN#KF$_$dZ(05bqj0XA9m(=cZO z^cUp;e+Hlwq@^Zvqwq-U7T0cn7cu@Gjsz!25s#z+%7$fF*!f04J!BtNVvQ zJ_6`J^nR`)>~S#7_U>d#{-1Hn)w+Z@(H{do0W1UP4_OZUQ@{#`-AdrafK?8=)xg&j zJ^rVW>~6hlm*M&e@GGDS>}vo70BzTG8g}8k4OcBdQ^1;Z)Mby$l|frh8B5|1VSMCv z#kDa8aHuWK`O9eI#!11yjK=OS>C9h7_MIEx!higs3>%ripQgV8K4I99^ihLG4;ngT zT>7v<GJ4^A;L&*2v7zB-fWj zhcnkhNz;Qpe!%xEG{^CWLoWobk5(R=k9q;<*17@r4zrg0YF{5N%&@R79zB0~3A@t!8`pENt zn)OqU!dB7u)8LKj8?GFfNr~q7^7iw?sfabE$^cSExn>9TcMJ$7{Qab^(ihZchY#z{T>yU9ihqoxOIX|L$ zNHEPUdi;dpBS)qW!aQQI9i6;2wyoWoE*-$}sE07_W@E zhS?c)c$Z=Js~d${rhBw#;4y%YWTMm$NLLl=XPO-#;!HQq%wAr$!XKiR5F0|rf$lqI z^bjY{dJv&Ku#f&kaBe{<@n(u?goI*J&v>Lcp2ozZC#f3ZdWe?An~(d}oitn<0b2mu zPg4J?W{toze;BS80r`M80UrUr0wf@ad@IR`z>@$h?eS+M1Fr^P;f3kyz-s__d}BHV zW=#MmlIc{KwE&!9+}EeUOb1-aVk$FafT+zD0A|R9SqIR-qU*w}2jB@YyVtkemcnHJ z4PiC{+z4Rz#xR=z76NCwDez{1eBjLA9C!=Bm2ON0*di;0p(W^6fMEa*;4+x40n;qH z4a{tSt_p2K=ysslZonzS)gERCKu5skfKCAZ<8Z?fzpJy;0(2M9Y?o(w_5)|nT>>n-{Q zm|V6uS@g{?ZvotD(YL|89dL(54}>`gaHmDz1#>W9h(+HGb0}aKmp?~19B>a{1c2$0 zfKh$Sirp&Jr3r0zyyoF59VEi#tyn`_=E>-(F0#uH%n>Os-vvhg5HV8YbL?G z8$DGc&V?q{U^X8_9e}eq?nj{f$K}lM0F9_+)(_{-fi_=mX41#C%(%J}!8KsqgFVKL z8P#j_gzn?UjTt9}n>;A>9tCSBKn(phz-&yOG_${%RYw)XBKYIMVFg{6X5QgB-;|8z zX1%!o!ny%~Yv;psAkA!Lo^Ps@2H(TF1FVS}r<*BpkAT!klLKxunv`z(yKC*&E!ODt zsDm#6JjVirWJ_Vg&ar4(_P2tfGB6qwwaPFzxTn(j3^T>gAI^U|(k~S$#YTkbnuMRp z0G{4(@~5yR{xp9s-BKHJz+*JMHUxmFA+C?p7qCV@f1LnPwpFDOit16maGNd+O6aXjS525b zVe({kkY)ccOddP=5A{VhyO{_!50DO;gMJ41vjDDKOg{&l|MWM{0zG2Lkg<0R8c8qI zH8b4L)3Ul|O2+IEJ_@1d(4TcN>b*eO^~@;=4~Dq1&`$0rjYK-{H?J#dQ{Qah_MCIk zzy@YLT*Li%12a4IMflNqG}rRa2E#ns)xd0QyyRec891$)h#(s`G<)I-zVQvs&hZZ; ztEK?*0CNGayJ&4gvtDLFnCbc$@Ht>BU?1QQKzO+6iUTBun>4(U*}5wvXgd!%e>h)C z0Q!$p{%|LKAZt^DtVxE}^@ClXD} zlwRDj`;CykZSU{G4t;~P)Iq)%62$u<^h6rp#LNynQr(d1J8thW2td9|KMSXZjQ1%K)hANZb)rv*ASZfFy`0&+7(Cyw=+%m2F)L!Ix^bS)a+~O2`Kj| zGA?S~%)AayaZG7u_B3@&P2sCPU>ogfX13COY9}2qk0Q*n8@iKWFy93545p~AS`=xC z9 zcx}zC^J-Y1_ELiuX0s}FVof<=Z5B%dTbM~Pw}R&So=briW``=dAh}NG#nRdqX1(gg zpm`M6!JR{JEJ)9wuq?A*L@~%!bVHUo!u&8>sno88D`)D5v?U8;ini`-TPL?P>vvxb zj}2hObzlwfes|w}9ae~jbiW@;qwy}+TG;8f^%?Nb0ikW{3uoI3aJ%5P1xESzC6En( zjexHJUjsN#Hvu*Sz6ERnYz2G=*ap}R*a6rH;6ZQ~fcbX=_5gkW>;*7?3E)S-KEO|I zj7_CLes1Y!gL*gc@Xdm;BvsP0RH1_;?~U4BL8W+ z3uv}GX8An?9DV~*gk;Z$0ZtLpNgsjR6@Vs&iufpSj+jMA_UlX}ON&nWH_&W1%<_8- zIQwl6_?3k%{Rg_72zeZqR{<8l^Y1WE08Rp~2K*232Y@RFfAOCo^eND6R|3C(!8{E( z12_xd%K0~-4#%%OOACwEo@<)Q^La2kJ@e?>!r|9RYri*Ie%;`8`gJBcaG_MsvOIf2 zJcog1$v`LCN$ZF=S$@Mq{N{fA#kQx{>>u#MBcrpwTzki&J$)O|6CKRf)jGzTu4Dwt zf4ahy04Mi(qh>ob3TCAb899X43tc0@-59R-4;p#jko4i>(?<;-&m*Mnv%W{?lL_}Q zYTVJBPoLK`+hn{8jrADVr32yt8PyEeAedv2MD89lXm3Z%Vb=rYKmIy~FX?=$**Q+s zQfjdFu!<)y1l`mKc;u4j8i`kR_^yHaJiY1>a2|SqZs*5b4vNS28+(^ z+!^HUWTv<$QvFV5ni&-mW;ET<$!u=Mgjh=>guEIs*}gSQ9(;O_89ti3y8F<}IX}W1k_M?* zZ5j*Pbok;7i39EfXc16^_?Sh%bul}H8?YvKJ+n!S&JQKrg`3jB66R*I7?;=8d^I_; z%BVpT#tol%$G8c1IZ&Eh)x6Q?N`xmJj-_o|LCFc`+*-r1ivJ%Zi$`eg@cB=3CV6O6 zg4xJDtmsUFxxvE&Y!!*8{d51f^XiGKoan-ZvSgMDF zRwIN?388C-(4qBmgZc>jD^f%FYhhvgu)?I3=%8=Aj@w@S{EM=r2Cf!Z5sMKpTn&I%l>Hitfqiqt2%TR+oMU5{r zr-!9xz**ySSSAZ_CZXq;Fq-@uxiRtR@ zfe_mRL{9(+7i&Fx0XWV?ltrRKdb zyG^B`y;y8bqj|l|Hf(O~WwvB9y0ntysEpUruHNPd z_kXD8RVti^uQF>SUW-UWH59kfJ79_74JtPPZlnWOnQ0DE^f8mojTkp>MkH+j+*~$N zb|3SGHoGxE+{z@1l=axRAOM|{w*tQna63T%@rT}_sx*|c=lht`ubz^ilpw4C=DCTc zqmZH5pa(jF90dH%3WB@~c7p*!X#3S>nx~`@ow^#i1hYwBvqn2s@!XBYsKM!@hYTGw zVfg(+(kBcbHDvsRL8Hb_gm#>3c@iKUz<;_@4y8a}bZl?X-o8*Gzdsl^%(5!dpg*NApHXGuyvR(bn>~@-WxfK>izc^m?aL*x8+{XD& z+r14t?gtjrRo9r;WohdhP)0mLYI-o}&JKDA=q}RRH`icA3ftALMO|J@H(ZO=ti?3< zTC@4xp(}-$v!?w4jU-oNFOtrms_AP$b92`8jUhD4!90b$0a3S08bifS2 zQ-G%dwTpflV4jG{(#hx;8JuXQWumQ*XrbLH>JIa&Yucgv7>FdWFwAV4W~rHzq-hq0 zo$f3Nab9V6mUEggUG&-=W=~JOS)lbN@%F;m00QVg1n-)ox`9B2BOBcHCw+>lSO@en z3`uuz00^h5gJyx0`wi_L1Db~^O>^2wd-hb^VsxH7JO^d zsG(+}y-aH_@LCGyd_>4&Y(Bj<)a)G4tG6E^Ca$aehfkF70_^xt(>#2ZTVu7<)SrWo zCHUc^?`{g{JE(72p6S~7BK+%em@#vlZnJGpiN7 ze2>|`oBIL!?Om*pE`W#E0dD}BVb0~pe$j^z;Q#<9+)vr>nQ4KCplgDlEW0X}do?`> zICo>3z8yGcgQmI5;`D2p{nm5PPXXtWcpZBCu`p)?I6O_0q64*KIB@Ox`XZloTmv#@xgsy?gQXD>jCeZJ(3n7kN8g)+`FKUHlc#|&FsO? znNmLBI?R8}xej*k0nugiKJWs-Vs^wI&m}mh4?r&g6aqd3aGl|PirtEUF9m!I_=K)1 zfQooAO=ly8Hb|q$yVy(%a}S`#g;;torkRCs45x1jQTog1e4*L+@(x%};BR>nb(9y= zmpdZ(6!;2&|E{}+j32L7Gn|QDNkcz07X@ZP9re8FN(D3rbO!VT+zFTfm;{&!SO6#h zECXx;{0uk=!1)MQBA^3cJYWXkHNg9TrGV9dZvnpm{scsj2}#Fv)dMtRvlo7D01O2@ z0(chi5?~1c_jtNC0Jae={Rms#*3gNMFcS5q>>@L>^;&#f?{nvm^3lzO6YAHm9-c*07*}U095Q@3N-3j1| zr0LAw(kJ!swR06&C@Vq?yYgX+A_7mSM}5u6w#SM<{j&vw_5N?DEkp!_gzuf%9i{$8vLG;3d;_C7=%= z2hbnz2!Q{F!yF8lXwf&r91R!hwAUzM7usUZ*fm4%3fhM50BqrIdd`?c0$64G81UVYIC%^5uI6W_VXO6PJPyx z*R#1`joH;af)y2xb}>9~L#|JMu7L#eLndzaH`~X4k05seb_3{{wPtI|Uu${?fzj@x zH^XTOy3wm(7glagtdzs;Ib6JS=NZ&|H|C!eynKb*Jg(Z&&dSZxW#OF=Sj$$cfxru zvW(d@T@pg0amd7Kcb=YeUC?w}&^+#Innfi=)4;7}GmbBBtJx@CyT1!w6(4QfYIbU= z?HAkjDqXQihcg}l+6uShcV-U`Hy36=`+v{!pJXk=#97~=X+{j*KevF&CL^LiY+VPW6^pdsLT>bV0` z99_8sXyWW04{Kc4E`0dj;M5 zhuNPxy^w6ss8)#`Y35$D>T@$94Nq9Ha@y27u?D3tNxn=vQS1+<;R#Q(D zUeYsQbHM_x~g=1;iY zQ*|?kbd$=IxL0A_my$cEEI9Tnl9@p6L*{p$#BWuMEe@Oioqfo>nT+d_5-IiN9Xx z^l;VqREWDRPMgnpYR;sr)8?Ht@&x*#)MuHvj!MGfyLf87X-AVtcl^(cqvDfh6pgMP zpG^G@CL5l#w<=(0;ZCRHC(Qy+hAi39)GI8(Pp5u__dEXhKXiR}d=y?@=iv$MOiGiOeDPFcKdb^h3%bl~rhII)KDxSsUNKRBql*nIY_e?ndo zpZA@4=l75xn)@WA8h!F+Xs}qzH@@6ZIbNtu#i1Z5kS73>)vAjQ{1M_Xhxdji2a9!9 z^A#GwM_p~c5-ilEU|rrS*7H%^V~?CD*7qF@uz>QrKLDLJ@I9h4rT__nc*JV4(Q5NW zdk5*k^t6K9S`6P*z9oRRKPR^kBYd}ezcTI}={vYL6Zd{_9lPo|XRy$i;va@&i%l}9 z&BKs1dg?-avH55Gp#~*Y#AkiwCV+awB>7EF zS`{h$X^5MyJq@WqSF7UfTYg@qGtOCPKsC9I7=4g>4A6Qap-}5iPp@KCo)gi#)k)sG z*=)JVTVi~pUvWcgOYSEjmBrR8{X002PCbQ&V35M5UqA}6tID5iEyisq)ACj|IhY>q z&;l0Dm1_&}eAFAnHXBF?l1J0oM_Ar*cW{@s+j+|v>TQ!H`qv^i72D;NY00(9jl~ys z`dgyK7xVoGZpwKm2he`2?4+?a*_Jg3AL44C&2M+fju-FnIqy1}K5<}LU%F@>M7ZRN zl;2Hr(`YA_ujBXr=6A$SoBj8eD99~05<44@9!-1Pax1ZmG1k#EG(c`Cbmea}hUx^O zSGUj1n|u=}HxRmG0Q<#+qr7Pf)xQl=?HMdbh&>LPEv^vU>Sg0#G#v?%UldhZZ(!A>xw&AeATxqkE&u-J}(NXEWBoJ?u1jG*7RW&xrXpM}T0JFI+*jkZ^ppUe6|3lMt|3kn~BLoC@s!Y z*KA3wDYp^&(aM@~bFqI93a%yBp#N&hjf4TzyOtboPkrzGZh2DS7 zY`OeAw$ld`R7*|}2JuUpiGzKo_SBM_h$+pC!P0ZJWv7_xJA(%}=;hjSJu$7nd7G8B z5_P4YUN0dF?rLJ6E_>fZT z;*~~HUS0V$@uN{@=jHXVk($(#yNjdR`&$}_AD12k&>!{Ws^aL*=IMy~a-=xsMgM`5 z(&~juG`qfBSseSe{}#dYU43k>aS8sG09sxz)K1Y2ux#T;QSnX4|6VseA+)N2+>}kg zTp3M)4dv!6T}U;L#x#^$v5DqUJpJ2H4rh}PVPq^b@~={dj+!h)7>Cy31BRxKoI;t6 z=tqbZ(*J$3Q}yQ(29mMRO-`;W_a9u;YG?^f!&!U zQ05I4lBAie*bqYiXUGD|Z6?3W77FjtxsLLS)G11?%(8`!Bs7s+Q<^YL-be*+$yKr&D*@hPG4f| z*g9mkh0K)Oit7am2~?|5QM?*J2UlWi6&;cT*#_Wq#(X5UmnX4}poPpWazh&NffCF% z36JUAuS!L4d=Xu1ou z3RKWl&J}i2dN+B3xJ#h)8FF1tr2*EyLz4!kc)fAm<%S~LEqq1i{*$9Ae3~3aU-pn6 zu+Q;HP&C!1f)<`2>P>i~@yliW+o-HzdxR}MQttYy{E+PxdQoH(C7i-U5-6A;2>QGw|H$$|o;}7u>(AXTTc~@1+?95`jg5Fn*kvxo)B2i?_C_gg z3Vu-;OgXI;J3A~aqs&)4Z&1N-rBYUIYAD}_A(q%9!af)yRw!b>3{#g-LZaM&9Tj?* z`!eBswU%(qdoB^&7lXt+eoW(&WGg#?uS;RoBj~K6SZIHeJc@mRooh^4@Au?iq?5vQ zM#31(8y|djPq2YX{ge>8(MK*~Ukd+~t{HJMB#_~F+B{sI&JXL;weyODD)*OLN~eTO z7xh@B)bO6%C#P80S9nSO81IDsAPM2LH*)~rp=X4LCaFcdFTW$Qv%;U{*RN(-?ol8- zC^N6%AVewh4e6XPv2@JulP697Rr*@Ukc{{6HW?!SB(QIUa4K%A<6H5=WGDL;Q9*v< zBM{$2{tjo@d3+ngU|t}=2HqnhU?oRSVb{`Q2Nw4dX6g<^aQz{bnKl{Rb8^`js zPNcXzWfv<33n{m_%h>~{|4CoUjUBPk(J9Fze+M5bdC$1g6&C+6c{*LnmR;;mur@H; zx|F{HOtuQf!~VjDkPXTx;Y1I_hqz>dUWw8^kzW%3E+g`s$seT+9Gd)(@JX48AWVeK zJ8qHu9Ap0qv#3oyr7h)d!~3p?!A+L$RaEu}84zV2vJ5ihF}~n#bTx={-g3Dy`wyGG zOfQnH*(<;+pFBIl>jt^9r$QR793sb4@0D_dFo7~x%I#RX*p22KQyY`xQ!LL!(a;lo zY~-C!cs3Y#jf zGPaw46}`c$vE{^RBIPxftHB0^mRwk%d1(I{?Aqz#YsTtkMT~o1m_cEm$(`6t5$0%) zGLectlWVY9;%>@3r7x!3wQ^NqwzpudoGD0i#5)odZEY|k}|*0g^s7B5r0VhW-XC8j#n%msbT7vaaj)3OeZu11~nWSM1&3n=n= zPk&1Es8))NQ0uS-Vm#k9kSi_K06SN>7K#%^DsHaC&_~*3ab_whUJoQ&OmVV9jbC2X*g?nn)32my2!9 z&63|-m9jF%2Y{D7-6Oxna>P&lszD&d?34SkmEt%`->!AZjt0}^??tN)%NqMs+(lhG zsIBO)!}1umN(3|f727^zlUj=+j><0Ymq+AN0$VLk;G;fDZy%Rivo&G|Y7^jzps$Y0 z9`>1-$H%vV#(l0^soMlSKwOLE->rsI;V9MaKv)byAJ>To{0kevP0~=dUOeT0vFB;- zK0SbK5WQy87>{0sZ4_H@7Sg~_dL(S+O_cbhJeY09^9|O*DGTe9Iy8BUc$g2+P`nyZ zTC#eOax|rx6uVX2%cr6mmqIkRy;6yC7wav}ZD>0UH6|A`V9;OAX}KB86Hk_*n~*bd zCfg?F@-gA#&mUrh+r>Aj#|HgPwnJ=AVN=zn*1jW>cZ#tTS%9rmp+MHeT_UC5R!WtG zo|0EQXQ4=s@**WRQtBFl)*F8g)(_h)!pArh+w58^rK@8^+OXuI!#~G}%mt6tZ8T>% zaI|?nRleYR#7+3Zq!OMzNw!kqMeuGzW_Ld?D{Qa0!@LSR$3k6pXu1gfBCoH~juOAa z?%gkL_32K9{X?C!^?UiActE7qdIwhK~u>h6nU?C>-aLI}m#$rW}U|SkuyWm^7C%xN4vw7eD zLB1uhqyL}FkBL8cbHbFt0wuhv*|LIPGv=a@OSkrvQH1Sr9Qz*3u8wI0<=;@9L8b{X zEF~#z*nrgGC+N`6@=o>z=Eqp)GrOS*RJtk4sQnRsQ(nxz6xWxV)nw{-3%1QEaUrD# zDeqADCfEY?)L_~grdI_W1smpyH~O~xstD&>|jh=di0H#lFIkX1OK5;Y7`0_cYrwKY2@ zuH+=zh|ZkH(zzbU-PzaTSyL|sd$iKn2XZd^MqFbuy3NyNs#`~q*|*|WlPQcn1+*^o z4|xbXFYYtvB<-4Jr__%^!>IY6;ECUrw4eD?ZY6y$M#NA;rOi#3Au|n}B3OTD*rZF9rs&wHWC_UH3J?6gH`@0s#egr$f-dak}|EN@BKZ(DX z{I2&-pHk>O_(%>C#h*oQW`CuoKyiJQ5OzacKa}C1fDft@b19SALvU#DuBNm#PI)K$RYgMS z2Bi`ETkKDHk!o|A=2jxuKb(=am+RBw<9dK2Iy!mqz~TRj&8W=v;z~hCxazK2_R@Pekv8AY~Y1Pa#mC zBZN|1N7X?dMe#s83RjfDES&+f_nB26vxy8a_Dz7I_aAAErAb&q%IT+Gp!1rN$tE+% zyOywfb6!+F_15wzBSbcZtt&UD$<*RGC5TOB@my`GK)oxdP8$3iR%RNz!IyEUKskdv z56Udybau9s4_LC|Cn@wpnkOoIpg#54wVuKHQ~I}1CQA?jD=n|4$ihs@tEOy$rrA48 zX$|FRd6;rbl;%LhQF;nk^GZiCgHiB8C5&Si zHVR&pH_D%X&c z8dp#Gjb*d7CO29!Lp8XOMC?A}qiVxZ7D_v)>E5^o$}E9>!aDke`*XHr1lKNNlgmwR zDW?b$7JFATQsSAggbE{-XttEi^@d~k0(HBl+l6J`hD{Vj5SDw}G*w0kYz2d-fEzg_ zcKQ&O!wfqFFk`XO*$}5v>`G>k>Sll+iq1Y|-}?!-F&BSvw11+~gsoy=KhXeYQ&%Zb z95Cunz56K+VYPQ&OQkboYuIITcJ5!+9MrtEGLe18e&$WRNQ+fwv$gCS|Bd}SB9t=n z)Y@zvTjoFaK3mUDmZ1&GsR0I&+DG5_3}FEK6JAgTu#GH{oM>+EOIjo1$M1s_L0 zKj22Oos<@ACxbY>>1oV%u@bHaAsQ@{?ibO^sQ9#6m2ws+@OO4q?9y&FtJGTD$k)<9 zH`-9|IZ$Ndx+_rv`O1BzB6mqx1oK zEakRU0OPQ(l(Ycbf8)n`WlDHYaj?^Drl~&Uyr;M*{XL~0JHvdYjja#Nyt8Z@w?A9b z@&e@-LnZ>}?9o?wS2#zxeX-hKXD2IJ>>Kte@0MDM*a_cyGy3y+KhL(70hQmKq6C$I zGi(Xv-BRACo9`=)#qY7G71SiM9}zn_7^Avk3{JYrrj#WJLvt;dEw_gH97qw}l?$dan|1|I%Xeu?OW_A^ z@DMOU@fxF$1xgn#q$^PVFicS)J7F#dWpvYi;AGfIx(?HfLTw^&1p%+~5z(vte#W|Y@Vet|+qDFM?FcY zI%z6vRc-?zP8qMX1T*hUZC=saQ_*B@NaH~Yhj_oyp)gJvpS1ojV`$B(NC)crfP z4n_(=__;PFa<$WFj|e`D<{pAWIW5AkgPX>D1-}tvUU$Sm`Xzm1t$CR*zm?qJ)U^B+9HCT9ty&K)1U3hu+c(vm!$( zGBtW27)|Nd$4Uep{6=j^`Ejb|UA$CTE3i!IEz==2V>!6)d~eQjB}EXjC@4oMhT0;m zRBB2KrO&~MIN+2U4MQULvRaSkM5~=)BsZdfC5Wkr|5W*uWlIB06D9RM?RgW>BPogR z^d^LDUCHoCuur5p{<&+-7UA*N>w*=G@2ga%h)mfERUf z88nxrl<*lex@GkAGbNWTm-hK*YB{i;+_hkTIhZ~J0Bx{Oab(|AXP6eiN~tfU_fQ&8 z{6#$?C~4@hWXScQpGuv%HAayyDAlR=H##)_x>}$!b!g(i6b?PCqTmh6hio-oq6Gf6 z()JBXbGAmphnu)x#^4VXH!647XVNn)j`ZN${<3YJ!!0tUKO))uG%1H%Cjr0x){~);L@=2ww_zfn=j}*p! zsq|#uf>#_0*1H-@72H@?NIa#4iRUGbr$-Q=5RVT~{Z2CAoCqqq48&>EDP8sd{4h!4z-@WhertP;X5Nrp$% z(Dba{H_s||fnAnLwZDJa73oz|ZMb?44C*QspHrr@AEZGPsVK=#Zl9wt?lmcuyI>HR za7lTI6@s0#sinPTGmzle>tM;sLE%Rl|E-6{9rUm?x7_Gkr6a~Hgt8%1QhtOT&% zq#=}aQ5g(HeQ4}GsSiJ>MR}L;$orTA!^sOI#ZFa{lr^Y(bpNt)R4SH!5J@ zRcZ+01BoL+WgPRsqB++6yF@*DC@Jg@unA+|adkE)ACR5l^Z65FY~xV+bEgri1EviB z3#;pZ*1@6q|E>X|c?c;6ta34JErbs8H&zeo;%EvQrH8S9Btv-|O>rF%26^^(Er9(i zwc!eWRMxdgF7`;eScW&jEcL6Q9jI`!;xOL$u@u8S2MA*t6?-BzryiR6 zJUva)WcE~AWG+bXbDD!qu&m`gpc@rFQav>KJYx598v+DKx1{mO8)O^Nq;c#-O9x}Z zgLuKE#I&KQ{RR$7o@Dv=nGyK~d{bjcH0z2|N0>}ux0E^1OSaxpa-f$a+*Vcy)2Qe+ zz=!FUfs{7@?5N5`02C1BI(P1+rKZiW7^H7uJ z*`vDyu`{rS#g>)+aWyNo-J~TJuRuvh)z(ya6awOG6Byc|e=9GDOCh(%frlB82|)Y+ zC@2MXXj$CV>+YL82%yc-?MGN;^Tho$;ud;OHwB8XgOXg$cu)x+>J~usBF<0O? ztC9wnd(|M1g<2nxn<2S6|K{7?PgNT?C=`CdHT9IwB_~cm$ z?h{Q_7i-PfR?E;bG;ElbsSQ<&!_+m>a&hy!dLznt6?}p_&Zv=Htsv%EsJIV&MhKo! z*)|LG1fK$B4IG+0EOpR_$%*|^`-~X2ov*;FY=`9qfAF6i0MLCz3hKiR+G#lgk^K{3 z@`FFB4sVV_%@Wuy5Hjeof;Zu!)>dF%OML0P(+4hKzq>8lOfk65rA}s_Th^EyfGg8f zjg@eKJ)mm<*HftQ6>!$QpeAsuaDuKf4DmR@f$EEFzhzmeF!u*pumhH7Wjv27Un5x^FhgDwDz=I2H!bk>BIT?+jc}S4I0=#X*(kn(YGEfWZ*ye1nSs^Qf(mLd`_kfzvEyD!TT-7s$!Wt+ zQBehTF#F2lGeOoor|Rsqr7=aua3>o+5fc<0-7j@0>a##2Pe~qnhKiq4H?Xsy$#P&C zV)~=hZgjMPW<-f#n-^Fp-k}UA*=*-5hvEG@qxGdumDL}FuQ>&WQN&ESl4}@>wZj-d z?X7S4Yb3C5Ezu@r7FAILh4b{ZiuxY=&T`!pg9*Eo$m|cW;)V(Tz2zT2GcxSf0rX~= z+K*kZe9XfO!sz{KYA@j;9STzqNS7?r1UeG~=qVymi=wnlMG-H9&Kv9PfYD5-uJ&hF zEvHTG50I>j3NK*iR;r^J)+PJFg7{!xG@St<4yQBwl)6&vHA`Dl;Jy2r8__d8o>$MZ z>y`peG>xd&Y>cA!Bj}PD4^@@YXM^hfyUosb+tB1bA5z#{^&QR$E70kS*z8$N<*Ft# zZwdF&lS+z9j2uhnzJ;%F!X-_Hwh~rLt;K$_Adi77t59FlrJpTV3^TE=w_|N}yTEQ( zrcnAd^<{Vq1HFlL)z28a2@(f`TW1Q(Tb7C3rHAc25-ybF@p=s^yaylpZLmS(O?x*2 zdHiBI=6{umwBRckpFB>Jp2X@wNiOcQk~`>Sjh z_ORU1-VWK;9TEXr&Lv9Q28$RrLUfVs&Fsw^$E zo-ONf==Gu+$Fi+$xcsk0`yR+1`v}+=WG#drwKCo{!=p;{2+(jx1O(i8oGz;y1Q9%4(Zo&8S2CTywI zCjw!BbT_|8>L=&R{F8-3-0PhytYJT~$^3)C!JLp4hVDUvbizZt7iWmG$cXanfRV5~bDF zXUVir*3-!jy5 z^M>_Oj|$Ry>xpMNd_YB2lyBjD%6nUl5;s~Ahpi8yG4nxxo2>V_31J|+!)eJoSj^4V zNq$7HO<@0I2)TiM5|f7ZkKJOW%sYq!p8T#_Q`~B$_*$9|f)7fBkj}LZ^RuEVr5xR9 z=uepEJpN$i1^3Xwi3lwpn3}T9`kHB}79^^Y0=1ME>q+kGJGQ>%$ytEmXyOF~BCZajBAU=wJ=)j5KVFQD|2 z9m3}n)JJVD?(uakNu;u}z2$cGKI<{c=miJZ{=RB&w%?jzhB3t_tHtbq^{D^ozAv8X zV3{HHWck)ow{-w@8G!UagR}N70s;w(Q?^6g^+WyWL$q}OVn+^R!};|YSN9Ra`=EYi z>=El~zts>)2rsB8#U8b0b2Y9SRjUf_Uvg6mT^OlUfi_Ty9m6&`Bx^BQ4V&1V2zqB6rtKo(cNVf+;2|Z=q>sk-{#AyiQ0d zG&1aG@Va8)yb}T(k~0k&Tfbsj_&7)A^2~kv;l5YP z^s@1ZZxQtvqSle~$ zm!_Un;xG7s{b*h0m*U7!0%|G!WW8M$G_;Kc`~BJa4)y4-)u+G4V#aP*_wf4|KwDk< zXq=kDZemxI*k>kT@W@W-mi4}2twvGY1od-v+uGCTrP&J{K4QEI51DnR5y!ELR-~)* zr90OD7y^<#cf3_6sS2W)t%#F2^aN?P!K;CA7|UIfL+KIjQvOu+FX=by4O8rL564`8 zR2Ywe8qe-okC^i?e!9Al-M5zJXN>17C9xui*Ra?0maN$73$!e34Wzcj8)l)iN8lCY zT7J{;{^_uuv0<9~!E#f2{?4C6@9fkFeqMJBY)vdV6H6odxz7n+zCGD2-E)E!};o z)`9`J+-K}uDjV2>lSlnAVr;Y?QI~IgFjJI*;7ysTyZt2#D+$Ot$LdBqXENX2j<^)?QT^InY&&W=<9WSrM

kKc}vyxf;7oig!P>($9NYnSDOmJo6fEP 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 { expect(manager.ownTransportIdentity()).toBeUndefined(); manager.uniffiDestroy(); }); + + it("routes the crate's log lines to the installed sink", () => { + const lines: { level: FfiLogLevel; target: string; message: string }[] = []; + setLogSink( + { + log: (level, target, message) => { + lines.push({ level, target, message }); + }, + }, + FfiLogLevel.Debug, + ); + // Put the default sink back for the other suites. + onTestFinished(() => installMatrixRtcLogSink()); + + const driver = new FfiMatrixDriver(new InertDriver()); + const manager = new FfiParticipationManager( + ROOM_ID, + "m.call#ROOM", + "@me:example.org", + "MYDEV", + driver, + { + compat: FfiElementCallCompat.Off, + manageMediaKeys: false, + requireCrossSignedSender: false, + useKeyDelayMs: 1000n, + }, + ); + manager.uniffiDestroy(); + + const created = lines.find((l) => l.message.includes("session created")); + expect(created).toBeDefined(); + expect(created?.level).toBe(FfiLogLevel.Info); + expect(created?.target).toMatch(/^matrix_rtc::/); + }); + + it("maps the crate's levels onto a matrix-js-sdk logger", () => { + const target = { + error: vi.fn(), + warn: vi.fn(), + info: vi.fn(), + debug: vi.fn(), + trace: vi.fn(), + }; + const sink = matrixRtcLogSink(target as unknown as Logger); + sink.log(FfiLogLevel.Error, "matrix_rtc::a", "boom"); + sink.log(FfiLogLevel.Warn, "matrix_rtc::a", "hm"); + sink.log(FfiLogLevel.Info, "matrix_rtc::a", "fyi"); + sink.log(FfiLogLevel.Debug, "matrix_rtc::a", "dbg"); + sink.log(FfiLogLevel.Trace, "matrix_rtc::a", "trc"); + expect(target.error).toHaveBeenCalledWith("[matrix_rtc::a] boom"); + expect(target.warn).toHaveBeenCalledWith("[matrix_rtc::a] hm"); + expect(target.info).toHaveBeenCalledWith("[matrix_rtc::a] fyi"); + expect(target.debug).toHaveBeenCalledWith("[matrix_rtc::a] dbg"); + expect(target.trace).toHaveBeenCalledWith("[matrix_rtc::a] trc"); + }); }); /** A driver that answers every read with nothing and never sends. */ diff --git a/src/matrix-rtc-sdk/index.ts b/src/matrix-rtc-sdk/index.ts index 62278771c..f14e4255a 100644 --- a/src/matrix-rtc-sdk/index.ts +++ b/src/matrix-rtc-sdk/index.ts @@ -18,6 +18,7 @@ Please see LICENSE in the repository root for full details. import initAsync, { type InitInput } from "./generated/wasm-bindgen/index.js"; import bindings from "./generated/matrix_rtc"; +import { installMatrixRtcLogSink } from "./logSink"; export { FfiMatrixDriver, @@ -31,6 +32,8 @@ export { FfiImpairment, FfiJoinError, FfiKeepAlive, + FfiLogLevel, + setLogSink, FfiMembershipState, FfiTransportIntent, RtcError, @@ -54,6 +57,7 @@ export type { FfiToDeviceRecipient, FfiTransportDelegationRequest, ConnectivitySinkLike, + LogSink, MatrixDriverCallback, RoomEventSinkLike, StateUpdateSinkLike, @@ -83,6 +87,8 @@ export async function initMatrixRtcSdk( loading ??= (async (): Promise => { await initAsync({ module_or_path: source ?? (await bundledWasm()) }); bindings.initialize(); + // The crate is silent until told where to log. + installMatrixRtcLogSink(); })(); await loading; } diff --git a/src/matrix-rtc-sdk/logSink.ts b/src/matrix-rtc-sdk/logSink.ts new file mode 100644 index 000000000..c93fcf83a --- /dev/null +++ b/src/matrix-rtc-sdk/logSink.ts @@ -0,0 +1,55 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { type Logger, logger as rootLogger } from "matrix-js-sdk/lib/logger"; + +import { FfiLogLevel, type LogSink, setLogSink } from "./generated/matrix_rtc"; + +/** + * A {@link LogSink} that writes the crate's lines to a matrix-js-sdk logger, + * so they land in the same console and rageshake as everything else, under + * the logger's own level filtering. Each line names the Rust module it came + * from. + */ +export function matrixRtcLogSink(target: Logger): LogSink { + return { + log(level, module, message): void { + const line = `[${module}] ${message}`; + switch (level) { + case FfiLogLevel.Error: + target.error(line); + break; + case FfiLogLevel.Warn: + target.warn(line); + break; + case FfiLogLevel.Info: + target.info(line); + break; + case FfiLogLevel.Debug: + target.debug(line); + break; + case FfiLogLevel.Trace: + target.trace(line); + break; + } + }, + }; +} + +/** + * Routes the crate's log lines to `[matrix-rtc]` under Element Call's root + * logger. `maxLevel` is the crate-side cut-off: what it does not format it + * does not send, so trace stays off unless asked for. + */ +export function installMatrixRtcLogSink( + maxLevel: FfiLogLevel = FfiLogLevel.Debug, +): void { + setLogSink( + matrixRtcLogSink(rootLogger.getChild("[matrix-rust-rtc]")), + maxLevel, + ); +} diff --git a/src/profile/useOwnProfile.ts b/src/profile/useOwnProfile.ts new file mode 100644 index 000000000..051462f3e --- /dev/null +++ b/src/profile/useOwnProfile.ts @@ -0,0 +1,33 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { useEffect, useState } from "react"; + +import { + type OwnProfile, + type ProfileDriver, +} from "../driver/ElementCallMatrixClientDriver"; +import { useMatrixDrivers } from "../driver/MatrixDriverContext"; + +/** The user's own display name and avatar from a profile driver, kept current. */ +export function useOwnProfileFrom(profile: ProfileDriver): OwnProfile { + const [own, setOwn] = useState(() => profile.getOwnProfile()); + useEffect(() => { + setOwn(profile.getOwnProfile()); + return profile.subscribeOwnProfile(setOwn); + }, [profile]); + return own; +} + +/** + * {@link useOwnProfileFrom} over the client driver the host provided. The + * read-only counterpart of `useProfile(client)`, for the call tree; editing + * stays with the profile settings, which a host may not offer. + */ +export function useOwnProfile(): OwnProfile { + return useOwnProfileFrom(useMatrixDrivers().clientDriver); +} diff --git a/src/reactions/ParticipationReactionsReader.test.ts b/src/reactions/ParticipationReactionsReader.test.ts new file mode 100644 index 000000000..ba145c4a3 --- /dev/null +++ b/src/reactions/ParticipationReactionsReader.test.ts @@ -0,0 +1,158 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { describe, expect, it } from "vitest"; + +import { MockElementCallMatrixClientDriver } from "../driver/MockElementCallMatrixClientDriver"; +import { testScope } from "../utils/test"; +import { FakeParticipation, fakeMembership } from "../utils/test-participation"; +import { ElementCallReactionEventType, type RaisedHandInfo } from "."; +import { ParticipationReactionsReader } from "./ParticipationReactionsReader"; + +const alice = fakeMembership({ + member: { + memberId: "m-alice", + userId: "@alice:example.org", + deviceId: "ALICE", + eventId: "$alice-join", + }, +}); +const aliceId = "@alice:example.org:ALICE"; + +function raisedHand( + timeline: MockElementCallMatrixClientDriver, + member = alice, + eventId = "$hand", +): void { + timeline.emitTimelineEvent({ + eventId, + type: "m.reaction", + sender: member.member.userId, + content: { + "m.relates_to": { + rel_type: "m.annotation", + event_id: member.member.eventId, + key: "🖐️", + }, + }, + originServerTs: 1000, + }); +} + +function setUp(): { + participation: FakeParticipation; + timeline: MockElementCallMatrixClientDriver; + hands: () => Record; + reactions: () => string[]; +} { + const participation = new FakeParticipation(); + const timeline = new MockElementCallMatrixClientDriver(); + const reader = new ParticipationReactionsReader( + testScope(), + participation, + timeline, + ); + let hands: Record = {}; + reader.raisedHands$.subscribe((h) => (hands = h)); + let reactions: string[] = []; + reader.reactions$.subscribe( + (r) => (reactions = Object.values(r).map((v) => v.reactionOption.emoji)), + ); + return { + participation, + timeline, + hands: () => hands, + reactions: () => reactions, + }; +} + +describe("ParticipationReactionsReader", () => { + it("raises and lowers a hand with the member's reaction and its redaction", () => { + const { participation, timeline, hands } = setUp(); + participation.setMemberships([alice]); + raisedHand(timeline); + expect(hands()).toEqual({ + [aliceId]: { + membershipEventId: "$alice-join", + reactionEventId: "$hand", + time: new Date(1000), + }, + }); + timeline.emitTimelineEvent({ + eventId: "$redaction", + type: "m.room.redaction", + sender: alice.member.userId, + content: {}, + originServerTs: 2000, + redacts: "$hand", + }); + expect(hands()).toEqual({}); + }); + + it("ignores a reaction that does not relate to the sender's own membership", () => { + const { participation, timeline, hands } = setUp(); + participation.setMemberships([alice]); + timeline.emitTimelineEvent({ + eventId: "$forged", + type: "m.reaction", + sender: "@mallory:example.org", + content: { + "m.relates_to": { + rel_type: "m.annotation", + event_id: "$alice-join", + key: "🖐️", + }, + }, + originServerTs: 1000, + }); + expect(hands()).toEqual({}); + }); + + it("picks up a hand raised before we looked, and drops it when the member leaves", () => { + const { participation, timeline, hands } = setUp(); + // The reaction is already in the room when the roster arrives. + raisedHand(timeline); + expect(hands()).toEqual({}); + participation.setMemberships([alice]); + expect(Object.keys(hands())).toEqual([aliceId]); + participation.setMemberships([]); + expect(hands()).toEqual({}); + }); + + it("re-resolves a hand when the member re-sends their membership", () => { + const { participation, timeline, hands } = setUp(); + participation.setMemberships([alice]); + raisedHand(timeline); + expect(Object.keys(hands())).toEqual([aliceId]); + // A new membership event without a hand on it: the hand goes. + const resent = fakeMembership({ + member: { ...alice.member, eventId: "$alice-join-2" }, + }); + participation.setMemberships([resent]); + expect(hands()).toEqual({}); + // Raised again on the new event: back. + raisedHand(timeline, resent, "$hand-2"); + expect(hands()[aliceId]?.membershipEventId).toBe("$alice-join-2"); + }); + + it("shows a reaction keyed by the member's media id", () => { + const { participation, timeline, reactions } = setUp(); + participation.setMemberships([alice]); + timeline.emitTimelineEvent({ + eventId: "$reaction", + type: ElementCallReactionEventType, + sender: alice.member.userId, + content: { + "m.relates_to": { rel_type: "m.reference", event_id: "$alice-join" }, + emoji: "🎉", + name: "party", + }, + originServerTs: 1000, + }); + expect(reactions()).toEqual(["🎉"]); + }); +}); diff --git a/src/reactions/ParticipationReactionsReader.ts b/src/reactions/ParticipationReactionsReader.ts new file mode 100644 index 000000000..3400ddbb4 --- /dev/null +++ b/src/reactions/ParticipationReactionsReader.ts @@ -0,0 +1,250 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { BehaviorSubject, delay } from "rxjs"; +import { logger } from "matrix-js-sdk/lib/logger"; + +import { + ElementCallReactionEventType, + GenericReaction, + type RaisedHandInfo, + type ReactionInfo, + ReactionSet, +} from "."; +import { REACTION_ACTIVE_TIME_MS } from "./ReactionsReader"; +import { type Behavior } from "../state/Behavior"; +import { type Epoch, type ObservableScope } from "../state/ObservableScope"; +import { type FfiMembership } from "../matrix-rtc-sdk"; +import { + type TimelineDriver, + type TimelineEvent, +} from "../driver/ElementCallMatrixClientDriver"; +import { memberMediaId } from "../state/rtc/mediaId"; + +const RAISED_HAND_KEY = "🖐️"; +const REACTION_EVENT_TYPE = "m.reaction"; +const REDACTION_EVENT_TYPE = "m.room.redaction"; + +/** What the reader needs from a {@link CallParticipation}. */ +export interface ParticipationReactionsSource { + memberships$: Behavior>; +} + +interface Relation { + rel_type?: string; + event_id?: string; + key?: string; +} + +function relationOf(content: Record): Relation | undefined { + return content["m.relates_to"] as Relation | undefined; +} + +/** + * Raised hands and reactions over a {@link CallParticipation} and the client + * driver's timeline: the counterpart of {@link ReactionsReader}, which reads + * the same from a matrix-js-sdk session. + * + * Hands and reactions relate to the sender's current membership event, as + * they always have. Both outputs are keyed by the member's media id + * (`${userId}:${deviceId}`), which is what the tiles are keyed by. + */ +export class ParticipationReactionsReader { + private readonly raisedHandsSubject$ = new BehaviorSubject< + Record + >({}); + public readonly raisedHands$ = this.raisedHandsSubject$.asObservable(); + + private readonly reactionsSubject$ = new BehaviorSubject< + Record + >({}); + public readonly reactions$ = this.reactionsSubject$.asObservable(); + + private memberships: FfiMembership[] = []; + + public constructor( + scope: ObservableScope, + participation: ParticipationReactionsSource, + private readonly timeline: Pick< + TimelineDriver, + "subscribeTimeline" | "getRelatedEvents" + >, + ) { + // Hide reactions after a given time. + this.reactionsSubject$ + .pipe(delay(REACTION_ACTIVE_TIME_MS), scope.bind()) + .subscribe((reactions) => { + const date = new Date(); + const nextEntries = Object.fromEntries( + Object.entries(reactions).filter(([_, hr]) => hr.expireAfter > date), + ); + if (Object.keys(reactions).length === Object.keys(nextEntries).length) + return; + this.reactionsSubject$.next(nextEntries); + }); + + scope.onEnd(timeline.subscribeTimeline(this.handleEvent)); + participation.memberships$ + .pipe(scope.bind()) + .subscribe((memberships) => this.onMembershipsChanged(memberships.value)); + } + + /** The member whose current membership event is `eventId`, sent by `sender`. */ + private memberFor( + eventId: string | undefined, + sender: string, + ): FfiMembership | undefined { + if (eventId === undefined) return undefined; + return this.memberships.find( + (m) => m.member.eventId === eventId && m.member.userId === sender, + ); + } + + /** The hand `member` has raised on their current membership event, if any. */ + private findRaisedHand(member: FfiMembership): RaisedHandInfo | undefined { + const eventId = member.member.eventId; + if (eventId === undefined) return undefined; + const reaction = this.timeline + .getRelatedEvents(eventId, "m.annotation", REACTION_EVENT_TYPE) + .find( + (e) => + e.sender === member.member.userId && + relationOf(e.content)?.key === RAISED_HAND_KEY, + ); + if (reaction === undefined) return undefined; + return { + membershipEventId: eventId, + reactionEventId: reaction.eventId, + time: new Date(reaction.originServerTs), + }; + } + + /** + * Drops the hands of members who left, keeps a hand across a re-sent + * membership when it was raised again on the new event, and picks up hands + * that were raised before we looked. + */ + private onMembershipsChanged(memberships: FfiMembership[]): void { + this.memberships = memberships; + const present = new Map( + memberships.map((m) => [memberMediaId(m.member), m]), + ); + const hands = { ...this.raisedHandsSubject$.value }; + let changed = false; + + for (const id of Object.keys(hands)) { + const member = present.get(id); + if (member === undefined) { + delete hands[id]; + changed = true; + } else if (hands[id].membershipEventId !== member.member.eventId) { + // The member re-sent their membership: the hand stands only if it + // was raised on the new event too. + const hand = this.findRaisedHand(member); + if (hand) hands[id] = hand; + else delete hands[id]; + changed = true; + } + } + for (const [id, member] of present) { + if (id in hands) continue; + const hand = this.findRaisedHand(member); + if (hand) { + hands[id] = hand; + changed = true; + } + } + if (changed) this.raisedHandsSubject$.next(hands); + } + + private addRaisedHand(identifier: string, info: RaisedHandInfo): void { + this.raisedHandsSubject$.next({ + ...this.raisedHandsSubject$.value, + [identifier]: info, + }); + } + + private removeRaisedHand(identifier: string): void { + this.raisedHandsSubject$.next( + Object.fromEntries( + Object.entries(this.raisedHandsSubject$.value).filter( + ([id]) => id !== identifier, + ), + ), + ); + } + + private handleEvent = (event: TimelineEvent): void => { + if (event.type === ElementCallReactionEventType) { + const relation = relationOf(event.content); + const member = this.memberFor(relation?.event_id, event.sender); + if (member === undefined) { + logger.warn( + `Reaction target was not a membership event for ${event.sender}, ignoring`, + ); + return; + } + const identifier = memberMediaId(member.member); + const rawEmoji = event.content.emoji; + if (typeof rawEmoji !== "string" || rawEmoji === "") { + logger.warn(`Reaction had no emoji from ${event.eventId}`); + return; + } + const emoji = new Intl.Segmenter(undefined, { granularity: "grapheme" }) + .segment(rawEmoji) + [Symbol.iterator]() + .next().value?.segment; + if (!emoji?.trim()) { + logger.warn( + `Reaction had no emoji from ${event.eventId} after splitting`, + ); + return; + } + const reaction = { + ...GenericReaction, + emoji, + // If we don't find a reaction, we can fallback to the generic sound. + ...ReactionSet.find((r) => r.name === event.content.name), + }; + const current = this.reactionsSubject$.value; + if (current[identifier]) { + // We've still got a reaction from this user, ignore it to prevent spamming + logger.warn(`Got reaction from ${identifier} but one is still playing`); + return; + } + this.reactionsSubject$.next({ + ...current, + [identifier]: { + reactionOption: reaction, + expireAfter: new Date(Date.now() + REACTION_ACTIVE_TIME_MS), + }, + }); + } else if (event.type === REACTION_EVENT_TYPE) { + const relation = relationOf(event.content); + const member = this.memberFor(relation?.event_id, event.sender); + if (member === undefined) { + logger.warn( + `Reaction target was not a membership event for ${event.sender}, ignoring`, + ); + return; + } + if (relation?.key === RAISED_HAND_KEY) + this.addRaisedHand(memberMediaId(member.member), { + reactionEventId: event.eventId, + membershipEventId: relation.event_id!, + time: new Date(event.originServerTs), + }); + } else if (event.type === REDACTION_EVENT_TYPE) { + const redacts = + event.redacts ?? (event.content.redacts as string | undefined); + const target = Object.entries(this.raisedHandsSubject$.value).find( + ([, hand]) => hand.reactionEventId === redacts, + )?.[0]; + if (target !== undefined) this.removeRaisedHand(target); + } + }; +} diff --git a/src/reactions/useReactionsSender.tsx b/src/reactions/useReactionsSender.tsx index 1b7e099a2..19359a75e 100644 --- a/src/reactions/useReactionsSender.tsx +++ b/src/reactions/useReactionsSender.tsx @@ -5,20 +5,18 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial Please see LICENSE in the repository root for full details. */ -import { EventType, RelationType } from "matrix-js-sdk"; +import { EventType, type MatrixClient, RelationType } from "matrix-js-sdk"; import { createContext, use, type ReactNode, useCallback, - useMemo, type JSX, } from "react"; -import { type MatrixRTCSession } from "matrix-js-sdk/lib/matrixrtc"; import { logger } from "matrix-js-sdk/lib/logger"; -import { useMatrixRTCSessionMemberships } from "../useMatrixRTCSessionMemberships"; import { useClientState } from "../ClientContext"; +import { type TimelineDriver } from "../driver/ElementCallMatrixClientDriver"; import { ElementCallReactionEventType, type ReactionOption } from "."; import { type CallViewModel } from "../state/CallViewModel/CallViewModel"; import { useBehavior } from "../useBehavior"; @@ -44,116 +42,108 @@ export const useReactionsSender = (): ReactionsSenderContextType => { /** * Provider that handles sending a reaction or hand raised event to a call. */ +/** How to send and take back a reaction: a room event, and a redaction. */ +export type ReactionsTimeline = Pick< + TimelineDriver, + "sendRoomEvent" | "redactEvent" +>; + +/** {@link ReactionsTimeline} over a matrix-js-sdk client. */ +export function jsSdkReactionsTimeline( + client: Pick, + roomId: string, +): ReactionsTimeline { + return { + sendRoomEvent: async (eventType, content) => { + const { event_id: eventId } = await client.sendEvent( + roomId, + eventType as never, + content as never, + ); + return { eventId }; + }, + redactEvent: async (eventId) => { + await client.redactEvent(roomId, eventId); + }, + }; +} + export const ReactionsSenderProvider = ({ children, - rtcSession, vm, + ownIdentifier, + ownMembershipEventId, + timeline, }: { children: ReactNode; - rtcSession: MatrixRTCSession; vm: CallViewModel; + /** Our key in `vm.reactions$` / `vm.handsRaised$` (`${userId}:${deviceId}`). */ + ownIdentifier: string; + /** The event id of our current membership, which reactions relate to. */ + ownMembershipEventId: string | undefined; + timeline: ReactionsTimeline; }): JSX.Element => { - const memberships = useMatrixRTCSessionMemberships(rtcSession); + // A widget host may forbid reactions; without a client state (the + // component, the crate path) there is nobody to forbid them. const clientState = useClientState(); const supportsReactions = - clientState?.state === "valid" && clientState.supportedFeatures.reactions; - const room = rtcSession.room; - const myUserId = room.client.getUserId(); - const myDeviceId = room.client.getDeviceId(); - const myMembershipIdentifier = `${myUserId}:${myDeviceId}`; - - const myMembershipEvent = useMemo( - () => - memberships.find( - (m) => m.userId === myUserId && m.deviceId === myDeviceId, - )?.eventId, - [memberships, myUserId, myDeviceId], - ); + clientState === undefined || + (clientState.state === "valid" && clientState.supportedFeatures.reactions); const reactions = useBehavior(vm.reactions$); - const myReaction = useMemo( - () => - myMembershipIdentifier !== undefined - ? reactions[myMembershipIdentifier] - : undefined, - [myMembershipIdentifier, reactions], - ); + const myReaction = reactions[ownIdentifier]; const handsRaised = useBehavior(vm.handsRaised$); - const myRaisedHand = useMemo( - () => - myMembershipIdentifier !== undefined - ? handsRaised[myMembershipIdentifier] - : undefined, - [myMembershipIdentifier, handsRaised], - ); + const myRaisedHand = handsRaised[ownIdentifier]; const toggleRaisedHand = useCallback(async () => { - if (!myMembershipIdentifier) { - return; - } const myReactionId = myRaisedHand?.reactionEventId; if (!myReactionId) { try { - if (!myMembershipEvent) { + if (!ownMembershipEventId) { throw new Error("Cannot find own membership event"); } - const reaction = await room.client.sendEvent( - rtcSession.room.roomId, - EventType.Reaction, - { - "m.relates_to": { - rel_type: RelationType.Annotation, - event_id: myMembershipEvent, - key: "🖐️", - }, + const { eventId } = await timeline.sendRoomEvent(EventType.Reaction, { + "m.relates_to": { + rel_type: RelationType.Annotation, + event_id: ownMembershipEventId, + key: "🖐️", }, - ); - logger.debug("Sent raise hand event", reaction.event_id); + }); + logger.debug("Sent raise hand event", eventId); } catch (ex) { logger.error("Failed to send raised hand", ex); } } else { try { - await room.client.redactEvent(rtcSession.room.roomId, myReactionId); + await timeline.redactEvent(myReactionId); logger.debug("Redacted raise hand event"); } catch (ex) { logger.error("Failed to redact reaction event", myReactionId, ex); throw ex; } } - }, [ - myMembershipEvent, - myMembershipIdentifier, - myRaisedHand, - rtcSession, - room, - ]); + }, [ownMembershipEventId, myRaisedHand, timeline]); const sendReaction = useCallback( async (reaction: ReactionOption) => { - if (!myMembershipIdentifier || myReaction) { - // We're still reacting + if (myReaction) { return; } - if (!myMembershipEvent) { + if (!ownMembershipEventId) { throw new Error("Cannot find own membership event"); } - await room.client.sendEvent( - rtcSession.room.roomId, - ElementCallReactionEventType, - { - "m.relates_to": { - rel_type: RelationType.Reference, - event_id: myMembershipEvent, - }, - emoji: reaction.emoji, - name: reaction.name, + await timeline.sendRoomEvent(ElementCallReactionEventType, { + "m.relates_to": { + rel_type: RelationType.Reference, + event_id: ownMembershipEventId, }, - ); + emoji: reaction.emoji, + name: reaction.name, + }); }, - [myMembershipEvent, myReaction, room, myMembershipIdentifier, rtcSession], + [ownMembershipEventId, myReaction, timeline], ); return ( diff --git a/src/room/CallEndedView.tsx b/src/room/CallEndedView.tsx index 58417c38a..f68399350 100644 --- a/src/room/CallEndedView.tsx +++ b/src/room/CallEndedView.tsx @@ -6,13 +6,12 @@ Please see LICENSE in the repository root for full details. */ import { type FC, type FormEventHandler, useCallback, useState } from "react"; -import { type MatrixClient } from "matrix-js-sdk"; import { Trans, useTranslation } from "react-i18next"; import { Button, Heading, Text } from "@vector-im/compound-web"; import styles from "./CallEndedView.module.css"; import feedbackStyle from "../input/FeedbackInput.module.css"; -import { useProfile } from "../profile/useProfile"; +import { useOwnProfile } from "../profile/useOwnProfile"; import { Header, HeaderLogo, LeftNav, RightNav } from "../Header"; import { PosthogAnalytics } from "../analytics/PosthogAnalytics"; import { FieldRow, InputField } from "../input/Input"; @@ -22,7 +21,6 @@ import { LeaveToHomeLink } from "../button/LeaveToHomeLink"; import { useLeaveToHome } from "../LeaveToHomeContext"; interface Props { - client: MatrixClient; isPasswordlessUser: boolean; hideHeader: boolean; confineToRoom: boolean; @@ -30,7 +28,6 @@ interface Props { } export const CallEndedView: FC = ({ - client, isPasswordlessUser, hideHeader, confineToRoom, @@ -39,7 +36,7 @@ export const CallEndedView: FC = ({ const { t } = useTranslation(); const leaveToHome = useLeaveToHome(); - const { displayName } = useProfile(client); + const { displayName } = useOwnProfile(); const [surveySubmitted, setSurveySubmitted] = useState(false); const [starRating, setStarRating] = useState(0); const [submitting, setSubmitting] = useState(false); diff --git a/src/room/CallView.stories.tsx b/src/room/CallView.stories.tsx new file mode 100644 index 000000000..9b46a88c1 --- /dev/null +++ b/src/room/CallView.stories.tsx @@ -0,0 +1,225 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +/** + * `CallView` over the mock drivers: no matrix-js-sdk client, the Rust crate + * carrying the call. The lobby and the ended screen render as they would for + * a host; the in-call screen needs a LiveKit SFU, which no mock provides yet, + * so its story shows the path a call takes when the homeserver advertises no + * transport instead. + */ + +import type { Meta, StoryObj } from "@storybook/react-vite"; +import { type FC, type ReactNode, useEffect, useMemo, useState } from "react"; +import { BrowserRouter } from "react-router-dom"; + +import { CallView } from "./CallView"; +import { CallEndedView } from "./CallEndedView"; +import { + type MatrixDrivers, + MatrixDriverProvider, +} from "../driver/MatrixDriverContext"; +import { MockElementCallMatrixClientDriver } from "../driver/MockElementCallMatrixClientDriver"; +import { + MockRtcMatrixDriver, + type MockRtcMatrixDriverOptions, + slotEvent, +} from "../driver/MockRtcMatrixDriver"; +import { HostBridgeProvider, nullHostBridge } from "../HostBridge"; +import { RootElementProvider } from "../RootElementContext"; +import { + componentProperties, + configurationForIntent, + type UrlParams, + UrlParamsProvider, + UserIntent, +} from "../UrlParams"; +import { MediaDevicesContext } from "../MediaDevicesContext"; +import { MediaDevices } from "../state/MediaDevices"; +import { ObservableScope } from "../state/ObservableScope"; +import { ProcessorProvider } from "../livekit/TrackProcessorContext"; + +const ROOM_ID = "!story:example.org"; +const USER_ID = "@me:example.org"; +const DEVICE_ID = "STORYDEV"; + +const alice = { + userId: "@alice:example.org", + deviceId: "ALICEDEV", + memberId: "m-alice", +}; + +interface HostProps { + intent: UserIntent; + /** Members already in the call when the view mounts. */ + peers?: (typeof alice)[]; + /** The RTC driver's options, e.g. no transports for the error path. */ + rtc?: MockRtcMatrixDriverOptions; + children: ReactNode; +} + +/** + * What a host provides around a call: the drivers, the host bridge, the + * call's parameters, the media devices and the root element. + */ +const Host: FC = ({ intent, peers = [], rtc, children }) => { + const drivers = useMemo((): MatrixDrivers => { + const rtcDriver = new MockRtcMatrixDriver({ + userId: USER_ID, + deviceId: DEVICE_ID, + roomId: ROOM_ID, + roomState: [slotEvent({ roomId: ROOM_ID, status: "open" })], + ...rtc, + }); + for (const peer of peers) rtcDriver.addPeer(peer); + return { + rtcDriver, + clientDriver: new MockElementCallMatrixClientDriver({ + userId: USER_ID, + deviceId: DEVICE_ID, + roomId: ROOM_ID, + roomInfo: { name: "Weekly sync", joinRule: "public" }, + ownProfile: { displayName: "Me", avatarUrl: null }, + members: [ + { + userId: USER_ID, + displayName: "Me", + avatarUrl: null, + membership: "join", + }, + ...peers.map((p) => ({ + userId: p.userId, + displayName: p.userId.slice(1).split(":")[0], + avatarUrl: null, + membership: "join" as const, + })), + ], + }), + }; + }, [peers, rtc]); + const params = useMemo( + (): UrlParams => ({ + ...componentProperties, + roomId: ROOM_ID, + ...configurationForIntent(intent), + }), + [intent], + ); + // The peers join once the crate listens to the room: the participation is + // created after the wasm has loaded, so poll for its sink. + useEffect(() => { + if (peers.length === 0) return; + const rtcDriver = drivers.rtcDriver as MockRtcMatrixDriver; + let tries = 0; + const timer = setInterval(() => { + tries++; + try { + for (const peer of peers) rtcDriver.peerJoins(peer); + clearInterval(timer); + } catch { + if (tries > 200) clearInterval(timer); + } + }, 50); + return (): void => clearInterval(timer); + }, [drivers, peers]); + const [mediaDevices, setMediaDevices] = useState(null); + useEffect(() => { + const scope = new ObservableScope(); + setMediaDevices(new MediaDevices(scope, { controlledAudioDevices: false })); + return (): void => { + setMediaDevices(null); + scope.end(); + }; + }, []); + const [root, setRoot] = useState(null); + return ( + + + + +

+ + + + + ); +}; + +const meta: Meta = { + title: "Room/CallView", + component: CallView, + parameters: { layout: "fullscreen" }, +}; +export default meta; + +type Story = StoryObj; + +/** The lobby of a call that Alice is already in. */ +export const Lobby: Story = { + args: { + isPasswordlessUser: false, + confineToRoom: true, + preload: false, + skipLobby: false, + }, + render: (args) => ( + + + + ), +}; + +/** + * Straight into the call, with a homeserver that advertises no transport: + * the crate fails the join and the view shows the error it turns into. + */ +export const NoTransport: Story = { + args: { + isPasswordlessUser: false, + confineToRoom: true, + preload: false, + skipLobby: true, + }, + render: (args) => ( + + + + ), +}; + +/** The screen after leaving, as a passwordless user sees it. */ +export const Ended: Story = { + args: { + isPasswordlessUser: true, + confineToRoom: false, + preload: false, + skipLobby: false, + }, + render: (args) => ( + + + + ), +}; diff --git a/src/room/CallView.test.tsx b/src/room/CallView.test.tsx index 8ac920b84..b0ae57d3a 100644 --- a/src/room/CallView.test.tsx +++ b/src/room/CallView.test.tsx @@ -11,6 +11,7 @@ Please see LICENSE in the repository root for full details. import { beforeEach, + describe, expect, type MockedFunction, onTestFinished, @@ -64,6 +65,15 @@ import { MatrixRTCTransportMissingError } from "../utils/errors"; import { ProcessorProvider } from "../livekit/TrackProcessorContext"; import { MediaDevicesContext } from "../MediaDevicesContext"; import { constant } from "../state/Behavior"; +import { + type MatrixDrivers, + MatrixDriverProvider, +} from "../driver/MatrixDriverContext"; +import { MockRtcMatrixDriver } from "../driver/MockRtcMatrixDriver"; +import { MockElementCallMatrixClientDriver } from "../driver/MockElementCallMatrixClientDriver"; +import { initMatrixRtcSdkForTests } from "../utils/test-matrix-rtc"; +import { callViewModelImplementation } from "../settings/settings"; +import { CallViewModelImplementation } from "../config/ConfigOptions"; vi.mock("../soundUtils"); vi.mock("../useAudioContext"); @@ -138,6 +148,23 @@ beforeEach(() => { ); }); +/** Mock drivers over the same room and identity as the mocked session. */ +function defaultDrivers(): MatrixDrivers { + return { + rtcDriver: new MockRtcMatrixDriver({ + userId: localRtcMember.userId, + deviceId: localRtcMember.deviceId, + roomId, + }), + clientDriver: new MockElementCallMatrixClientDriver({ + userId: localRtcMember.userId, + deviceId: localRtcMember.deviceId, + roomId, + roomInfo: { joinRule: "invite" }, + }), + }; +} + function createCallView( hostBridge: HostBridge, joined = true, @@ -145,6 +172,8 @@ function createCallView( withErrorBoundary?: boolean; /** Wait for the host to say when to join, rather than joining at once. */ preload?: boolean; + /** The host's drivers, for the matrix-rtc implementation. */ + drivers?: MatrixDrivers; } = {}, ): { rtcSession: MatrixRTCSession; @@ -194,13 +223,15 @@ function createCallView( - {options.withErrorBoundary ? ( - - {callView} - - ) : ( - callView - )} + + {options.withErrorBoundary ? ( + + {callView} + + ) : ( + callView + )} + @@ -424,3 +455,46 @@ test("user can reconnect after a membership manager error", async () => { // In-call controls should be visible again await waitFor(() => screen.getByRole("button", { name: "Leave" })); }); + +describe("the call implementation switch", () => { + test("matrix-js-sdk carries the call by default: no participation", async () => { + createCallView(nullHostBridge); + await waitFor(() => expect(ActiveCall).toHaveBeenCalled()); + expect( + vi.mocked(ActiveCall).mock.calls.at(-1)?.[0].participation, + ).toBeNull(); + expect(window.matrixRtc).toBeUndefined(); + }); + + test("with matrix-rtc selected and drivers provided, the crate carries the call", async () => { + await initMatrixRtcSdkForTests(); + callViewModelImplementation.setValue(CallViewModelImplementation.MatrixRtc); + onTestFinished(() => + callViewModelImplementation.setValue( + CallViewModelImplementation.MatrixJsSdk, + ), + ); + const drivers: MatrixDrivers = { + rtcDriver: new MockRtcMatrixDriver({ + userId: localRtcMember.userId, + deviceId: localRtcMember.deviceId, + roomId, + }), + clientDriver: new MockElementCallMatrixClientDriver({ + userId: localRtcMember.userId, + deviceId: localRtcMember.deviceId, + roomId, + }), + }; + createCallView(nullHostBridge, true, { drivers }); + await waitFor(() => + expect( + vi.mocked(ActiveCall).mock.calls.at(-1)?.[0].participation, + ).not.toBeNull(), + ); + const { participation } = vi.mocked(ActiveCall).mock.calls.at(-1)![0]; + expect(window.matrixRtc?.participation).toBe(participation); + // The participation is bound to the drivers' room and identity. + expect(participation?.session$.value.roomId).toBe(roomId); + }); +}); diff --git a/src/room/CallView.tsx b/src/room/CallView.tsx index 3c34dc845..3860a9b40 100644 --- a/src/room/CallView.tsx +++ b/src/room/CallView.tsx @@ -12,11 +12,11 @@ import { useEffect, useMemo, useState, + useRef, } from "react"; import { type MatrixClient, JoinRule, - type Room, UnsupportedStickyEventsEndpointError, } from "matrix-js-sdk"; import { @@ -34,7 +34,11 @@ import { LobbyView } from "./LobbyView"; import { type MatrixInfo } from "./VideoPreview"; import { CallEndedView } from "./CallEndedView"; import { PosthogAnalytics } from "../analytics/PosthogAnalytics"; -import { useProfile } from "../profile/useProfile"; +import { + mediaKeyStatisticsOf, + NO_MEDIA_KEY_STATISTICS, +} from "../analytics/PosthogEvents"; +import { useOwnProfile } from "../profile/useOwnProfile"; import { findDeviceByName } from "../utils/media"; import { ActiveCall } from "./InCallView"; import { type MuteStates } from "../state/MuteStates"; @@ -42,11 +46,9 @@ import { useMediaDevices } from "../MediaDevicesContext"; import { useMatrixRTCSessionMemberships } from "../useMatrixRTCSessionMemberships"; import { saveKeyForRoom, - useRoomEncryptionSystem, + useEncryptionSystemFor, } from "../e2ee/sharedKeyManagement"; -import { useRoomAvatar } from "./useRoomAvatar"; -import { useRoomName } from "./useRoomName"; -import { useJoinRule } from "./useJoinRule"; +import { useRoomInfo } from "./useRoomInfo"; import { InviteModal } from "./InviteModal"; import { HeaderStyle, type UrlParams, useUrlParams } from "../UrlParams"; import { E2eeType } from "../e2ee/e2eeType"; @@ -64,7 +66,6 @@ import { UnknownCallError, } from "../utils/errors.ts"; import { GroupCallErrorBoundary } from "./GroupCallErrorBoundary.tsx"; -import { useTypedEventEmitter } from "../useEvents"; import { muteAllAudio$ } from "../state/MuteAllAudioModel.ts"; import { useAppBarTitle } from "../AppBar.tsx"; import { useBehavior } from "../useBehavior.ts"; @@ -72,6 +73,20 @@ import { useRootElement } from "../RootElementContext.ts"; import { useHostBridge } from "../HostBridge.ts"; import { useMuteStates } from "../state/useMuteStates.ts"; import { useLeaveToHome } from "../LeaveToHomeContext.ts"; +import { useMatrixDrivers } from "../driver/MatrixDriverContext.tsx"; +import { useCallParticipation } from "../state/rtc/useCallParticipation.ts"; +import { type CallParticipation } from "../state/rtc/CallParticipation.ts"; +import { participationConfig } from "../state/rtc/joinParams.ts"; +import { effectiveCallViewModelImplementation } from "../state/rtc/implementation.ts"; +import { + CallViewModelImplementation, + type MatrixRTCMode, +} from "../config/ConfigOptions.ts"; +import { Config } from "../config/Config.ts"; +import { matrixRTCMode as matrixRTCModeSetting } from "../settings/settings.ts"; +import { constant } from "../state/Behavior.ts"; +import { Epoch } from "../state/ObservableScope.ts"; +import { FfiStatus, type FfiMembership } from "../matrix-rtc-sdk"; /** * If there already are this many participants in the call, we automatically mute @@ -82,14 +97,26 @@ export const MUTE_PARTICIPANT_COUNT = 8; declare global { interface Window { rtcSession?: MatrixRTCSession; + /** The crate's participation, when the Rust implementation carries the call. */ + matrixRtc?: { participation: CallParticipation }; } } +/** What the crate's roster reads as while matrix-js-sdk carries the call. */ +const NO_PARTICIPATION_MEMBERSHIPS = constant( + new Epoch([], 0), +); + interface Props { - /** The client to place the call with. */ - client: MatrixClient; + /** + * The matrix-js-sdk client and session, for the matrix-js-sdk + * implementation of the call. Without them the Rust crate carries the call + * through the drivers whatever the developer setting says (the component + * has no client to offer). + */ + client?: MatrixClient; /** The call to join. */ - rtcSession: MatrixRTCSession; + rtcSession?: MatrixRTCSession; /** * Whether the user is signed in as a guest, and so should be offered the * chance to create an account when the call ends. @@ -161,7 +188,52 @@ const LoadedCallView: FC = ({ const [externalError, setExternalError] = useState( null, ); - const memberships = useMatrixRTCSessionMemberships(rtcSession); + const jsSdkMemberships = useMatrixRTCSessionMemberships(rtcSession); + // The host's drivers: what the room is called and looks like, who we are, + // and (on the crate path) the session itself come from them. + const drivers = useMatrixDrivers(); + const { roomId } = drivers.clientDriver; + const roomInfo = useRoomInfo(); + const e2eeSystem = useEncryptionSystemFor(roomId, roomInfo.encrypted); + + // Which implementation carries this call, sampled once for the view's + // lifetime (§5.15 of the oxidation plan): the Rust crate through the + // host's drivers, or matrix-js-sdk's session — which needs a session. + const [implementation] = useState(() => + effectiveCallViewModelImplementation(), + ); + const useMatrixRtc = + implementation === CallViewModelImplementation.MatrixRtc || + rtcSession === undefined; + // Sampled once, like the implementation: the participation is the call, + // and rebuilding it for a later change of these would leave and rejoin. + const [participationConfigValue] = useState(() => + useMatrixRtc + ? participationConfig({ + // matrix_rtc_mode in config.json overrides the user's choice. + mode: + (Config.get().matrix_rtc_mode as MatrixRTCMode | undefined) ?? + matrixRTCModeSetting.value$.value, + manageMediaKeys: e2eeSystem.kind === E2eeType.PER_PARTICIPANT, + session: Config.get().matrix_rtc_session, + }) + : null, + ); + const participation = useCallParticipation( + useMatrixRtc ? drivers : null, + participationConfigValue, + ); + const participationMemberships = useBehavior( + participation?.memberships$ ?? NO_PARTICIPATION_MEMBERSHIPS, + ); + // The call's members, whichever side lists them; only who they are matters here. + const memberUserIds = useMemo( + () => + useMatrixRtc + ? participationMemberships.value.map((m) => m.member.userId) + : jsSdkMemberships.map((m) => m.userId!), + [useMatrixRtc, participationMemberships, jsSdkMemberships], + ); const rootElement = useRootElement(); const hostBridge = useHostBridge(); // A host that can close us is a host that decides when we stop existing, so @@ -178,12 +250,16 @@ const LoadedCallView: FC = ({ muted: muteAllAudio, }), ); - // This should use `useEffectEvent` (only available in experimental versions) + // Joining a big call starts muted. Decided once, the first time the roster + // is known: at mount for matrix-js-sdk, after the seed for the crate. + const mutedForCallSize = useRef(false); useEffect(() => { - if (memberships.length >= MUTE_PARTICIPANT_COUNT) + if (mutedForCallSize.current) return; + if (useMatrixRtc && !participationMemberships.value.length) return; + mutedForCallSize.current = true; + if (memberUserIds.length >= MUTE_PARTICIPANT_COUNT) muteStates.audio.setEnabled$.value?.(false); - // eslint-disable-next-line react-hooks/exhaustive-deps - }, []); + }, [useMatrixRtc, participationMemberships, memberUserIds, muteStates]); useEffect(() => { logger.info("[Lifecycle] CallView Component mounted"); @@ -203,18 +279,20 @@ const LoadedCallView: FC = ({ }, [rootElement]); useEffect(() => { - window.rtcSession = rtcSession; + if (rtcSession !== undefined) window.rtcSession = rtcSession; + if (participation !== null) window.matrixRtc = { participation }; return (): void => { delete window.rtcSession; + delete window.matrixRtc; }; - }, [rtcSession]); + }, [rtcSession, participation]); // TODO move this into the callViewModel LocalMembership.ts // We might actually not need this at all. Since we get into fatalError on those errors already? - useTypedEventEmitter( - rtcSession, - MatrixRTCSessionEvent.MembershipManagerError, - (error) => { + // matrix-js-sdk only; the crate reports these through `fatalError$`. + useEffect(() => { + if (rtcSession === undefined) return; + const onError = (error: unknown): void => { // When matrix_rtc_mode=matrix_2_0 is in effect but the homeserver does // not advertise MSC4354 (sticky events), the SDK throws an // `UnsupportedStickyEventsEndpointError`. The MembershipManager @@ -227,79 +305,93 @@ const LoadedCallView: FC = ({ } else { setExternalError(new ConnectionLostError()); } - }, - ); + }; + rtcSession.on(MatrixRTCSessionEvent.MembershipManagerError, onError); + return (): void => { + rtcSession.off(MatrixRTCSessionEvent.MembershipManagerError, onError); + }; + }, [rtcSession]); useEffect(() => { + if (client === undefined || rtcSession === undefined) return; // Sanity check the room object if (client.getRoom(rtcSession.room.roomId) !== rtcSession.room) logger.warn( `We've ended up with multiple rooms for the same ID (${rtcSession.room.roomId}). This indicates a bug in the group call loading code, and may lead to incomplete room state.`, ); - }, [client, rtcSession.room]); + }, [client, rtcSession]); - const room = rtcSession.room as Room; - const { displayName, avatarUrl } = useProfile(client); - const roomName = useRoomName(room); - const roomAvatar = useRoomAvatar(room); + const { displayName, avatarUrl } = useOwnProfile(); + const roomName = roomInfo.name; + const roomAvatar = roomInfo.avatarUrl; const { perParticipantE2EE, returnToLobby, password: passwordFromUrl, header, } = useUrlParams(); - const e2eeSystem = useRoomEncryptionSystem(room.roomId); // Save the password once we start the groupCallView useEffect(() => { - if (passwordFromUrl) saveKeyForRoom(room.roomId, passwordFromUrl); - }, [passwordFromUrl, room.roomId]); + if (passwordFromUrl) saveKeyForRoom(roomId, passwordFromUrl); + }, [passwordFromUrl, roomId]); useAppBarTitle(roomName); + const { userId: ownUserId } = drivers.clientDriver; + const roomAlias = roomInfo.canonicalAlias; const matrixInfo = useMemo((): MatrixInfo => { return { - userId: client.getUserId()!, - displayName: displayName!, - avatarUrl: avatarUrl!, - roomId: room.roomId, + userId: ownUserId, + displayName: displayName ?? ownUserId, + avatarUrl: avatarUrl ?? "", + roomId, roomName, - roomAlias: room.getCanonicalAlias(), + roomAlias, roomAvatar, e2eeSystem, }; - }, [client, displayName, avatarUrl, roomName, room, roomAvatar, e2eeSystem]); + }, [ + ownUserId, + displayName, + avatarUrl, + roomName, + roomId, + roomAlias, + roomAvatar, + e2eeSystem, + ]); // Count each member only once, regardless of how many devices they use const participantCount = useMemo( - () => new Set(memberships.map((m) => m.userId!)).size, - [memberships], + () => new Set(memberUserIds).size, + [memberUserIds], ); const mediaDevices = useMediaDevices(); const latestMuteStates = useLatest(muteStates); + // Read at leave time, not a dependency: `onLeft` feeds the in-call view's + // effect, and a roster change must not rebuild the call. + const latestMemberUserIds = useLatest(memberUserIds); - const enterRTCSessionOrError = useCallback( - async (rtcSession: MatrixRTCSession): Promise => { - try { - setJoined(true); - // TODO-MULTI-SFU what to do with error handling now that we don't use this function? - // @BillCarsonFr - } catch (e) { - if (e instanceof ElementCallError) { - setExternalError(e); - } else { - logger.error(`Unknown Error while entering RTC session`, e); - const error = new UnknownCallError( - e instanceof Error ? e : new Error("Unknown error", { cause: e }), - ); - setExternalError(error); - } + const enterRTCSessionOrError = useCallback(async (): Promise => { + try { + setJoined(true); + // TODO-MULTI-SFU what to do with error handling now that we don't use this function? + // @BillCarsonFr + } catch (e) { + if (e instanceof ElementCallError) { + setExternalError(e); + } else { + logger.error(`Unknown Error while entering RTC session`, e); + const error = new UnknownCallError( + e instanceof Error ? e : new Error("Unknown error", { cause: e }), + ); + setExternalError(error); } - return Promise.resolve(); - }, - [setJoined], - ); + } + return Promise.resolve(); + }, [setJoined]); useEffect(() => { const defaultDeviceSetup = async ({ @@ -409,10 +501,14 @@ const LoadedCallView: FC = ({ // queuing/batching of requests. const sendInstantly = hostControlsLifetime; PosthogAnalytics.instance.eventCallEnded.track( - room.roomId, - rtcSession.memberships.length, + roomId, + latestMemberUserIds.current.length, sendInstantly, - rtcSession, + participation !== null + ? participation.mediaKeyStatistics() + : rtcSession === undefined + ? NO_MEDIA_KEY_STATISTICS + : mediaKeyStatisticsOf(rtcSession), ); // Unfortunately the PostHog library provides no way to await the // tracking of an event, but we don't really want it to hold up our @@ -457,8 +553,10 @@ const LoadedCallView: FC = ({ leaveSoundContext, hostBridge, hostControlsLifetime, - room.roomId, + roomId, + latestMemberUserIds, rtcSession, + participation, isPasswordlessUser, confineToRoom, returnToLobby, @@ -474,7 +572,7 @@ const LoadedCallView: FC = ({ }); }, [hostBridge, joined, rtcSession]); - const joinRule = useJoinRule(room); + const joinRule = roomInfo.joinRule; const [shareModalOpen, setInviteModalOpen] = useState(false); const onDismissInviteModal = useCallback( @@ -495,7 +593,9 @@ const LoadedCallView: FC = ({ const shareModal = ( @@ -525,6 +625,10 @@ const LoadedCallView: FC = ({ throw externalError; }; body = ; + } else if (joined && useMatrixRtc && participation === null) { + // Joined before the crate is ready (its wasm loads on first use): the + // call appears with the participation, a render later. + body = null; } else if (joined) { body = ( <> @@ -532,8 +636,9 @@ const LoadedCallView: FC = ({ = ({ if (isPasswordlessUser || PosthogAnalytics.instance.isEnabled()) { body = ( = ({ setExternalError(null); if (action == "reconnect") { setLeft(false); - await enterRTCSessionOrError(rtcSession).catch((e) => { + await enterRTCSessionOrError().catch((e) => { logger.error("Error re-entering RTC session", e); }); } }} onError={(_error) => { - if (rtcSession.isJoined()) onLeft("error"); + const joinedViaCrate = + participation !== null && + FfiStatus.Connected.instanceOf(participation.status$.value); + if (rtcSession?.isJoined() === true || joinedViaCrate) onLeft("error"); // If there is an error we need to be dismissible again. This is done in // `onLeft` as well; we need it here explicitly in case // rtcSession.isJoined is false. diff --git a/src/room/InCallView.test.tsx b/src/room/InCallView.test.tsx index 357bc186e..2bfc5ecb5 100644 --- a/src/room/InCallView.test.tsx +++ b/src/room/InCallView.test.tsx @@ -42,7 +42,10 @@ import { type CallViewModelOptions, } from "../state/CallViewModel/CallViewModel"; import { alice, local } from "../utils/test-fixtures"; -import { ReactionsSenderProvider } from "../reactions/useReactionsSender"; +import { + jsSdkReactionsTimeline, + ReactionsSenderProvider, +} from "../reactions/useReactionsSender"; import { useRoomEncryptionSystem } from "../e2ee/sharedKeyManagement"; import { LivekitRoomAudioRenderer } from "../livekit/MatrixAudioRenderer"; import { MediaDevicesContext } from "../MediaDevicesContext"; @@ -160,7 +163,7 @@ function createInCallView(args: CreateInCallViewArgs = {}): RenderResult & { footerVm={footerVm} developerSettingsVm={developerSettingsVm} matrixInfo={matrixInfo} - matrixRoom={room} + roomId={room.roomId} onShareClick={null} /> ); @@ -172,7 +175,9 @@ function createInCallView(args: CreateInCallViewArgs = {}): RenderResult & { {content} @@ -248,7 +253,8 @@ describe("ActiveCall", () => { { { e2eeSystem: EncryptionSystem; + /** + * The crate's participation in the session when the Rust implementation + * carries this call (see `CallViewModelImplementation`); null when + * matrix-js-sdk's `rtcSession` does. + */ + participation: CallParticipation | null; // TODO refactor those reasons into an enum onLeft: ( reason: "user" | "timeout" | "decline" | "allOthersLeft" | "error", @@ -125,34 +141,77 @@ export const ActiveCall: FC = (props) => { // The element we have to draw the call in: the page, or the container a host // gave us. Its size, not the window's, decides how the call is laid out. const rootElement = useRootElement(); + // The drivers, where a host provided them; required with a participation. + const drivers = useOptionalMatrixDrivers(); + const { participation, rtcSession, client, roomId } = props; + if (participation !== null && drivers === null) + throw new Error( + "A call over the matrix-rtc crate needs the Matrix drivers to be provided", + ); + if ( + participation === null && + (rtcSession === undefined || client === undefined) + ) + throw new Error( + "A call needs either a participation (the crate) or a matrix-js-sdk client and session", + ); useEffect(() => { rootLogger.info("START CALL VIEW SCOPE"); const scope = new ObservableScope(); - const reactionsReader = new ReactionsReader(scope, props.rtcSession); const { autoLeaveWhenOthersLeft, waitForCallPickup, sendNotificationType } = urlParams; + const options = { + ...callViewModelOptionsFromParams(urlParams), + encryptionSystem: props.e2eeSystem, + hostBridge, + autoLeaveWhenOthersLeft, + waitForCallPickup: waitForCallPickup && sendNotificationType === "ring", + // We merely sample the current mode here, so the user would need to + // manually rejoin to switch to a different one. + matrixRTCMode: matrixRTCModeSetting.value$.value, + windowSize$: scope.behavior(observeElementSize$(rootElement)), + }; - const vm = createJsClientCallViewModel$( - scope, - props.rtcSession, - props.matrixRoom, - mediaDevices, - props.muteStates, - { - ...callViewModelOptionsFromParams(urlParams), - encryptionSystem: props.e2eeSystem, - hostBridge, - autoLeaveWhenOthersLeft, - waitForCallPickup: waitForCallPickup && sendNotificationType === "ring", - // We merely sample the current mode here, so the user would need to - // manually rejoin to switch to a different one. - matrixRTCMode: matrixRTCModeSetting.value$.value, - windowSize$: scope.behavior(observeElementSize$(rootElement)), - }, - reactionsReader.raisedHands$, - reactionsReader.reactions$, - scope.behavior(trackProcessorState$), - ); + let vm: CallViewModel; + if (participation !== null && drivers !== null) { + rootLogger.info( + `Call view model implementation: ${CallViewModelImplementation.MatrixRtc}`, + ); + const reactionsReader = new ParticipationReactionsReader( + scope, + participation, + drivers.clientDriver, + ); + vm = createCallViewModel$( + scope, + participation, + drivers.clientDriver, + mediaDevices, + props.muteStates, + options, + reactionsReader.raisedHands$, + reactionsReader.reactions$, + scope.behavior(trackProcessorState$), + ); + } else if (rtcSession !== undefined) { + rootLogger.info( + `Call view model implementation: ${CallViewModelImplementation.MatrixJsSdk}`, + ); + const reactionsReader = new ReactionsReader(scope, rtcSession); + vm = createJsClientCallViewModel$( + scope, + rtcSession, + rtcSession.room, + mediaDevices, + props.muteStates, + options, + reactionsReader.raisedHands$, + reactionsReader.reactions$, + scope.behavior(trackProcessorState$), + ); + } else { + return; // unreachable: checked above + } // TODO move this somewhere else once we use the callViewModel in the lobby as well! vm.join(); setVm(vm); @@ -163,8 +222,8 @@ export const ActiveCall: FC = (props) => { scope.end(); }; }, [ - props.rtcSession, - props.matrixRoom, + rtcSession, + client, props.muteStates, props.e2eeSystem, props.onLeft, @@ -172,10 +231,39 @@ export const ActiveCall: FC = (props) => { hostBridge, mediaDevices, trackProcessorState$, - props.client, rootElement, + participation, + drivers, ]); + // Who we are, as the tiles, hands and reactions are keyed. Both drivers + // and client name the same identity; the drivers are always there. + const ownIdentifier = + drivers !== null + ? `${drivers.clientDriver.userId}:${drivers.clientDriver.deviceId}` + : `${client?.getUserId()}:${client?.getDeviceId()}`; + + // Reactions relate to our current membership event, wherever that lives. + const jsSdkMemberships = useMatrixRTCSessionMemberships(rtcSession); + const ownParticipationMembership = useBehavior( + participation?.ownMembership$ ?? NO_OWN_MEMBERSHIP, + ); + const ownMembershipEventId = + participation !== null + ? ownParticipationMembership?.member.eventId + : jsSdkMemberships.find( + (m) => + m.userId === client?.getUserId() && + m.deviceId === client?.getDeviceId(), + )?.eventId; + const reactionsTimeline = useMemo( + () => + participation === null && client !== undefined + ? jsSdkReactionsTimeline(client, roomId) + : drivers!.clientDriver, + [participation, drivers, client, roomId], + ); + useEffect(() => { if (vm === null) return; @@ -185,7 +273,7 @@ export const ActiveCall: FC = (props) => { vm, props.muteStates, mediaDevices, - `${props.client.getUserId()}:${props.client.getDeviceId()}`, + ownIdentifier, { showControls: urlParams.showControls, header: urlParams.header }, ); setFooterVm(footerVm); @@ -195,15 +283,15 @@ export const ActiveCall: FC = (props) => { scope.end(); }; }, [ - props.rtcSession, - props.matrixRoom, + rtcSession, + client, props.muteStates, props.e2eeSystem, props.onLeft, urlParams, mediaDevices, trackProcessorState$, - props.client, + ownIdentifier, vm, ]); @@ -212,7 +300,12 @@ export const ActiveCall: FC = (props) => { if (developerSettingsVm === null) return null; return ( - + = (props) => { }; export interface InCallViewProps { - client: MatrixClient; + /** The matrix-js-sdk client, when that implementation carries the call. */ + client?: MatrixClient; vm: CallViewModel; footerVm: ViewModel; developerSettingsVm: ViewModel; matrixInfo: MatrixInfo; - rtcSession: MatrixRTCSession; - matrixRoom: MatrixRoom; + /** The matrix-js-sdk session, when that implementation carries the call. */ + rtcSession?: MatrixRTCSession; + roomId: string; muteStates: MuteStates; onShareClick: (() => void) | null; } @@ -241,7 +336,7 @@ export const InCallView: FC = ({ footerVm, developerSettingsVm, matrixInfo, - matrixRoom, + roomId, muteStates, onShareClick, }) => { @@ -634,9 +729,7 @@ export const InCallView: FC = ({ } }; - const rageshakeRequestModalProps = useRageshakeRequestModal( - matrixRoom.roomId, - ); + const rageshakeRequestModalProps = useRageshakeRequestModal(roomId); useAppBarSecondaryButton( = ({ setSettingsOpen(false)} tab={settingsTab} diff --git a/src/room/InviteModal.test.tsx b/src/room/InviteModal.test.tsx index 79f3f9285..2d66d17e0 100644 --- a/src/room/InviteModal.test.tsx +++ b/src/room/InviteModal.test.tsx @@ -7,25 +7,27 @@ Please see LICENSE in the repository root for full details. import { render, screen } from "@testing-library/react"; import { expect, test, vi } from "vitest"; -import { type Room } from "matrix-js-sdk"; import { axe } from "vitest-axe"; import { BrowserRouter } from "react-router-dom"; import userEvent from "@testing-library/user-event"; import { InviteModal } from "./InviteModal"; +import { E2eeType } from "../e2ee/e2eeType"; // Used by copy-to-clipboard window.prompt = (): null => null; test("InviteModal is accessible", async () => { const user = userEvent.setup(); - const room = { - roomId: "!a:example.org", - name: "Mission Control", - } as unknown as Room; const onDismiss = vi.fn(); const { container } = render( - , + , { wrapper: BrowserRouter }, ); diff --git a/src/room/InviteModal.tsx b/src/room/InviteModal.tsx index 759dce302..94545afe0 100644 --- a/src/room/InviteModal.tsx +++ b/src/room/InviteModal.tsx @@ -13,7 +13,6 @@ import { useState, } from "react"; import { useTranslation } from "react-i18next"; -import { type Room } from "matrix-js-sdk"; import { Button, Text } from "@vector-im/compound-web"; import { LinkIcon, @@ -25,22 +24,29 @@ import { Modal } from "../Modal"; import { getAbsoluteRoomUrl } from "../utils/matrix"; import styles from "./InviteModal.module.css"; import { Toast } from "../Toast"; -import { useRoomEncryptionSystem } from "../e2ee/sharedKeyManagement"; +import { type EncryptionSystem } from "../e2ee/sharedKeyManagement"; import { QrCode } from "../QrCode"; interface Props { - room: Room; + roomId: string; + roomName: string; + e2eeSystem: EncryptionSystem; open: boolean; onDismiss: () => void; } -export const InviteModal: FC = ({ room, open, onDismiss }) => { +export const InviteModal: FC = ({ + roomId, + roomName, + e2eeSystem, + open, + onDismiss, +}) => { const { t } = useTranslation(); - const e2eeSystem = useRoomEncryptionSystem(room.roomId); const url = useMemo( - () => getAbsoluteRoomUrl(room.roomId, e2eeSystem, room.name), - [e2eeSystem, room.name, room.roomId], + () => getAbsoluteRoomUrl(roomId, e2eeSystem, roomName), + [e2eeSystem, roomName, roomId], ); const [toastOpen, setToastOpen] = useState(false); const onToastDismiss = useCallback(() => setToastOpen(false), [setToastOpen]); diff --git a/src/room/LobbyView.tsx b/src/room/LobbyView.tsx index 9e6e0ed99..b75744c50 100644 --- a/src/room/LobbyView.tsx +++ b/src/room/LobbyView.tsx @@ -53,7 +53,8 @@ import { type ViewModel } from "../state/ViewModel"; import { useAppBarPrimaryButtonIconKind } from "../AppBar"; interface Props { - client: MatrixClient; + /** The matrix-js-sdk client, for what the developer settings still read from it. */ + client?: MatrixClient; matrixInfo: MatrixInfo; muteStates: MuteStates; onEnter: () => void; @@ -258,15 +259,13 @@ export const LobbyView: FC = ({ )} - {client && ( - - )} + ); }; diff --git a/src/room/RoomPage.tsx b/src/room/RoomPage.tsx index 71bceea76..a9494216a 100644 --- a/src/room/RoomPage.tsx +++ b/src/room/RoomPage.tsx @@ -6,7 +6,14 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial Please see LICENSE in the repository root for full details. */ -import { type FC, useEffect, useState, type ReactNode, useRef } from "react"; +import { + type ComponentProps, + type FC, + useEffect, + useState, + type ReactNode, + useRef, +} from "react"; import { type MatrixError } from "matrix-js-sdk"; import { logger } from "matrix-js-sdk/lib/logger"; import { Trans, useTranslation } from "react-i18next"; @@ -16,6 +23,10 @@ import { useClientLegacy } from "../ClientContext"; import { ErrorPage, FullScreenView, LoadingPage } from "../FullScreenView"; import { RoomAuthView } from "./RoomAuthView"; import { CallView } from "./CallView"; +import { type MatrixClient } from "matrix-js-sdk"; +import { type MatrixRTCSession } from "matrix-js-sdk/lib/matrixrtc"; +import { MatrixDriverProvider } from "../driver/MatrixDriverContext"; +import { useJsSdkDrivers } from "../driver/jsSdk/useJsSdkDrivers"; import { useRoomIdentifier, useUrlParams } from "../UrlParams"; import { useRegisterPasswordlessUser } from "../auth/useRegisterPasswordlessUser"; import { HomePage } from "../home/HomePage"; @@ -102,7 +113,7 @@ export const RoomPage: FC = (): ReactNode => { switch (groupCallState.kind) { case "loaded": return ( - { if (!roomIdOrAlias) return ; return groupCallView(); }; + +/** + * The call, with the matrix-js-sdk drivers over this page's client provided + * for the Rust implementation (see `CallViewModelImplementation`). + */ +const LoadedCall: FC< + ComponentProps & { + client: MatrixClient; + rtcSession: MatrixRTCSession; + } +> = (props) => { + const drivers = useJsSdkDrivers(props.client, props.rtcSession.room); + return ( + + + + ); +}; diff --git a/src/room/useJoinRule.ts b/src/room/useJoinRule.ts deleted file mode 100644 index ae17e1626..000000000 --- a/src/room/useJoinRule.ts +++ /dev/null @@ -1,18 +0,0 @@ -/* -Copyright 2022-2024 New Vector Ltd. - -SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial -Please see LICENSE in the repository root for full details. -*/ - -import { useCallback } from "react"; - -import type { JoinRule, Room } from "matrix-js-sdk"; -import { useRoomState } from "./useRoomState"; - -export function useJoinRule(room: Room): JoinRule { - return useRoomState( - room, - useCallback((state) => state.getJoinRule(), []), - ); -} diff --git a/src/room/useRoomAvatar.ts b/src/room/useRoomAvatar.ts deleted file mode 100644 index 7287c6521..000000000 --- a/src/room/useRoomAvatar.ts +++ /dev/null @@ -1,18 +0,0 @@ -/* -Copyright 2022-2024 New Vector Ltd. - -SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial -Please see LICENSE in the repository root for full details. -*/ - -import { useCallback } from "react"; -import { type Room } from "matrix-js-sdk"; - -import { useRoomState } from "./useRoomState"; - -export function useRoomAvatar(room: Room): string | null { - return useRoomState( - room, - useCallback(() => room.getMxcAvatarUrl(), [room]), - ); -} diff --git a/src/room/useRoomInfo.test.tsx b/src/room/useRoomInfo.test.tsx new file mode 100644 index 000000000..1b2032e92 --- /dev/null +++ b/src/room/useRoomInfo.test.tsx @@ -0,0 +1,64 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { act, renderHook } from "@testing-library/react"; +import { describe, expect, it } from "vitest"; +import { type ReactNode } from "react"; + +import { MatrixDriverProvider } from "../driver/MatrixDriverContext"; +import { MockElementCallMatrixClientDriver } from "../driver/MockElementCallMatrixClientDriver"; +import { MockRtcMatrixDriver } from "../driver/MockRtcMatrixDriver"; +import { useOwnProfile } from "../profile/useOwnProfile"; +import { useRoomInfo } from "./useRoomInfo"; + +function providing(clientDriver: MockElementCallMatrixClientDriver) { + return ({ children }: { children: ReactNode }): ReactNode => ( + + {children} + + ); +} + +describe("useRoomInfo", () => { + it("reads the room from the client driver and follows its changes", () => { + const clientDriver = new MockElementCallMatrixClientDriver({ + roomInfo: { name: "Mission Control", joinRule: "invite" }, + }); + const { result } = renderHook(() => useRoomInfo(), { + wrapper: providing(clientDriver), + }); + expect(result.current).toMatchObject({ + name: "Mission Control", + joinRule: "invite", + }); + act(() => clientDriver.setRoomInfo({ name: "Launch Control" })); + expect(result.current.name).toBe("Launch Control"); + }); + + it("throws without drivers", () => { + expect(() => renderHook(() => useRoomInfo())).toThrow(/No Matrix drivers/); + }); +}); + +describe("useOwnProfile", () => { + it("reads our own profile and follows its changes", () => { + const clientDriver = new MockElementCallMatrixClientDriver({ + ownProfile: { displayName: "Me", avatarUrl: "mxc://x/me" }, + }); + const { result } = renderHook(() => useOwnProfile(), { + wrapper: providing(clientDriver), + }); + expect(result.current).toEqual({ + displayName: "Me", + avatarUrl: "mxc://x/me", + }); + act(() => clientDriver.setOwnProfile({ displayName: "Myself" })); + expect(result.current.displayName).toBe("Myself"); + }); +}); diff --git a/src/room/useRoomInfo.ts b/src/room/useRoomInfo.ts new file mode 100644 index 000000000..385b6e70b --- /dev/null +++ b/src/room/useRoomInfo.ts @@ -0,0 +1,36 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { useEffect, useState } from "react"; + +import { + type RoomDriver, + type RoomInfo, +} from "../driver/ElementCallMatrixClientDriver"; +import { useMatrixDrivers } from "../driver/MatrixDriverContext"; + +/** + * The room's name, alias, avatar, join rule, encryption and whether we may + * open its slot, from the given room driver, kept current. + */ +export function useRoomInfoFrom(room: RoomDriver): RoomInfo { + const [info, setInfo] = useState(() => room.getRoomInfo()); + useEffect(() => { + setInfo(room.getRoomInfo()); + return room.subscribeRoomInfo(setInfo); + }, [room]); + return info; +} + +/** + * {@link useRoomInfoFrom} for the call's room: the client driver the host + * provided. Replaces `useRoomName`, `useRoomAvatar` and `useJoinRule` under + * `CallView`. + */ +export function useRoomInfo(): RoomInfo { + return useRoomInfoFrom(useMatrixDrivers().clientDriver); +} diff --git a/src/room/useRoomState.ts b/src/room/useRoomState.ts deleted file mode 100644 index ad08f7a21..000000000 --- a/src/room/useRoomState.ts +++ /dev/null @@ -1,37 +0,0 @@ -/* -Copyright 2022-2024 New Vector Ltd. - -SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial -Please see LICENSE in the repository root for full details. -*/ - -import { useCallback } from "react"; -import { - type RoomState, - RoomStateEvent, - type Room, - RoomEvent, -} from "matrix-js-sdk"; - -import { useTypedEventEmitterState } from "../useEvents"; - -/** - * A React hook for values computed from room state. - * @param room The room. - * @param f A mapping from the current room state to the computed value. - * @returns The computed value. - */ -export function useRoomState(room: Room, f: (state: RoomState) => T): T { - // TODO: matrix-js-sdk says that Room.currentState is deprecated, but it's not - // clear how to reactively track the current state of the room without it - const currentState = useTypedEventEmitterState( - room, - RoomEvent.CurrentStateUpdated, - useCallback(() => room.currentState, [room]), - ); - return useTypedEventEmitterState( - currentState, - RoomStateEvent.Update, - useCallback(() => f(currentState), [f, currentState]), - ); -} diff --git a/src/settings/DeveloperSettingsTab.tsx b/src/settings/DeveloperSettingsTab.tsx index ec5bf7b08..d73beca15 100644 --- a/src/settings/DeveloperSettingsTab.tsx +++ b/src/settings/DeveloperSettingsTab.tsx @@ -45,6 +45,7 @@ import { muteAllAudio as muteAllAudioSetting, alwaysShowIphoneEarpiece as alwaysShowIphoneEarpieceSetting, matrixRTCMode as matrixRTCModeSetting, + callViewModelImplementation as callViewModelImplementationSetting, customLivekitUrl as customLivekitUrlSetting, advancedScreenShare as advancedScreenShareSetting, screenShareResolution as screenShareResolutionSetting, @@ -62,12 +63,17 @@ import { type VideoCodec, enableExtendedLivekitLogs as enableExtendedLivekitLogsSetting, } from "./settings"; -import { MatrixRTCMode } from "../config/ConfigOptions"; +import { + CallViewModelImplementation, + MatrixRTCMode, +} from "../config/ConfigOptions"; import styles from "./DeveloperSettingsTab.module.css"; import settingsStyles from "./SettingsModal.module.css"; import { Slider } from "../Slider"; import { useUrlParams } from "../UrlParams"; import { getSFUConfigWithOpenID } from "../livekit/openIDSFU"; +import { useOptionalMatrixDrivers } from "../driver/MatrixDriverContext"; +import { ELEMENT_CALL_SLOT_ID } from "../state/rtc/slot"; import { useBehavior } from "../useBehavior"; import { type ViewModel } from "../state/ViewModel.ts"; @@ -103,7 +109,8 @@ const KeyRotationStatus: FC<{ info: KeyRotationInfo }> = ({ info }) => ( ); interface Props { - client: MatrixClient; + /** The matrix-js-sdk client, when the host has one; the drivers otherwise. */ + client?: MatrixClient; roomId?: string; livekitRooms?: { room: LivekitRoom; @@ -129,17 +136,40 @@ export const DeveloperSettingsTab: FC = ({ debugTileLayoutSetting, ); + const drivers = useOptionalMatrixDrivers(); const [stickyEventsSupported, setStickyEventsSupported] = useState(false); useEffect(() => { - client - .doesServerSupportUnstableFeature(UNSTABLE_MSC4354_STICKY_EVENTS) + const probe = + client !== undefined + ? client.doesServerSupportUnstableFeature( + UNSTABLE_MSC4354_STICKY_EVENTS, + ) + : drivers !== null + ? drivers.clientDriver + .getCapabilities() + .then((capabilities) => capabilities.stickyEvents) + : Promise.resolve(false); + probe .then((result) => { setStickyEventsSupported(result); }) .catch((ex) => { logger.warn("Failed to check if sticky events are supported", ex); }); - }, [client]); + }, [client, drivers]); + // What the host knows about itself, for the facts below. + const [diagnostics, setDiagnostics] = useState>({}); + useEffect(() => { + drivers?.clientDriver + .getDiagnostics?.() + .then(setDiagnostics) + .catch((ex) => + logger.warn("Could not read the driver's diagnostics", ex), + ); + }, [drivers]); + const ownUserId = client?.getUserId() ?? drivers?.clientDriver.userId ?? null; + const ownDeviceId = + client?.getDeviceId() ?? drivers?.clientDriver.deviceId ?? null; const [matrixRTCMode, setMatrixRTCMode] = useSetting(matrixRTCModeSetting); const matrixRTCModeRadioGroup = useId(); @@ -155,6 +185,20 @@ export const DeveloperSettingsTab: FC = ({ const matrixRTCModeForced = configMatrixRTCMode !== undefined; const effectiveMatrixRTCMode = configMatrixRTCMode ?? matrixRTCMode; + const [implementation, setImplementation] = useSetting( + callViewModelImplementationSetting, + ); + const implementationRadioGroup = useId(); + const onImplementationChange = useCallback( + (e: ChangeEvent) => { + setImplementation(e.target.value as CallViewModelImplementation); + }, + [setImplementation], + ); + const configImplementation = Config.get().call_view_model_implementation; + const implementationForced = configImplementation !== undefined; + const effectiveImplementation = configImplementation ?? implementation; + const [showConnectionStats, setShowConnectionStats] = useSetting( showConnectionStatsSetting, ); @@ -387,17 +431,20 @@ export const DeveloperSettingsTab: FC = ({

{t("developer_mode.crypto_version", { - version: client.getCrypto()?.getVersion() || "unknown", + version: + client?.getCrypto()?.getVersion() || + diagnostics.crypto_version || + "unknown", })}

{t("developer_mode.matrix_id", { - id: client.getUserId() || "unknown", + id: ownUserId || "unknown", })}

{t("developer_mode.device_id", { - id: client.getDeviceId() || "unknown", + id: ownDeviceId || "unknown", })}

{keyRotation !== null && } @@ -512,25 +559,45 @@ export const DeveloperSettingsTab: FC = ({ } try { - const userId = client.getUserId(); - const deviceId = client.getDeviceId(); - - if (userId === null || deviceId === null) { + if (ownUserId === null || ownDeviceId === null) { throw new Error("Invalid user or device ID"); } - await getSFUConfigWithOpenID( - client, - { userId, deviceId, memberId: "" }, - customLivekitUrlTextBuffer, - roomId, - ); + if (client !== undefined) { + await getSFUConfigWithOpenID( + client, + { userId: ownUserId, deviceId: ownDeviceId, memberId: "" }, + customLivekitUrlTextBuffer, + roomId, + ); + } else if (drivers !== null) { + // Ask the service for a token the way the crate would. + await drivers.rtcDriver.getLivekitToken({ + url: customLivekitUrlTextBuffer, + roomId, + slotId: ELEMENT_CALL_SLOT_ID, + memberJson: JSON.stringify({ + id: "", + claimed_user_id: ownUserId, + claimed_device_id: ownDeviceId, + }), + legacySfuGet: false, + }); + } setCustomLivekitUrlUpdateError(null); setCustomLivekitUrl(customLivekitUrlTextBuffer); } catch { setCustomLivekitUrlUpdateError("invalid URL (did not update)"); } }, - [customLivekitUrlTextBuffer, setCustomLivekitUrl, client, roomId], + [ + customLivekitUrlTextBuffer, + setCustomLivekitUrl, + client, + drivers, + roomId, + ownUserId, + ownDeviceId, + ], )} value={customLivekitUrlTextBuffer ?? ""} onChange={useCallback( @@ -590,6 +657,63 @@ export const DeveloperSettingsTab: FC = ({ + + + {t("developer_mode.callViewModelImplementation.title")} + + {implementationForced && ( +

{t("developer_mode.callViewModelImplementation.forced")}

+ )} +
+ + } + > + + + {t( + "developer_mode.callViewModelImplementation.matrix_js_sdk.description", + )} + + + + } + > + + + {t( + "developer_mode.callViewModelImplementation.matrix_rtc.description", + )} + + +
{livekitRooms?.map((livekitRoom) => (

diff --git a/src/settings/ProfileSettingsTab.tsx b/src/settings/ProfileSettingsTab.tsx index 7a4ac0770..e7c4bc9bc 100644 --- a/src/settings/ProfileSettingsTab.tsx +++ b/src/settings/ProfileSettingsTab.tsx @@ -5,23 +5,48 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial Please see LICENSE in the repository root for full details. */ -import { type FC, useCallback, useEffect, useMemo, useRef } from "react"; -import { type MatrixClient } from "matrix-js-sdk"; +import { type FC, useCallback, useEffect, useRef, useState } from "react"; import { useTranslation } from "react-i18next"; import { logger } from "matrix-js-sdk/lib/logger"; -import { useProfile } from "../profile/useProfile"; +import { useOwnProfile } from "../profile/useOwnProfile"; +import { useMatrixDrivers } from "../driver/MatrixDriverContext"; import { FieldRow, InputField, ErrorMessage } from "../input/Input"; import { AvatarInputField } from "../input/AvatarInputField"; import styles from "./ProfileSettingsTab.module.css"; -interface Props { - client: MatrixClient; -} -export const ProfileSettingsTab: FC = ({ client }) => { +export const ProfileSettingsTab: FC = () => { const { t } = useTranslation(); - const { error, displayName, avatarUrl, saveProfile } = useProfile(client); - const userId = useMemo(() => client.getUserId(), [client]); + const { clientDriver } = useMatrixDrivers(); + const { displayName, avatarUrl } = useOwnProfile(); + const userId = clientDriver.userId; + const [error, setError] = useState(undefined); + // The driver may offer no way to edit the profile; then it is shown as is. + const canEdit = + clientDriver.setDisplayName !== undefined && + clientDriver.setAvatar !== undefined; + const saveProfile = useCallback( + async ({ + displayName, + avatar, + removeAvatar, + }: { + displayName: string; + avatar: Blob | undefined; + removeAvatar: boolean; + }): Promise => { + try { + await clientDriver.setDisplayName?.(displayName); + if (removeAvatar) await clientDriver.setAvatar?.(null); + else if (avatar) await clientDriver.setAvatar?.(avatar); + setError(undefined); + } catch (e) { + setError(e instanceof Error ? e : new Error(String(e))); + throw e; + } + }, + [clientDriver], + ); const formRef = useRef(null); @@ -58,9 +83,7 @@ export const ProfileSettingsTab: FC = ({ client }) => { saveProfile({ displayName, - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - avatar: avatar && avatarSize > 0 ? avatar : undefined, + avatar: avatar instanceof Blob && avatarSize > 0 ? avatar : undefined, removeAvatar: removeAvatar.current && (!avatar || avatarSize === 0), }).catch((e) => { logger.error("Failed to save profile", e); @@ -72,15 +95,16 @@ export const ProfileSettingsTab: FC = ({ client }) => { return (
- {userId && displayName && ( + {displayName && ( )} @@ -91,7 +115,7 @@ export const ProfileSettingsTab: FC = ({ client }) => { label={t("common.username")} type="text" disabled - value={client.getUserId()!} + value={userId} /> @@ -101,9 +125,10 @@ export const ProfileSettingsTab: FC = ({ client }) => { label={t("common.display_name")} type="text" required + disabled={!canEdit} autoComplete="off" placeholder={t("common.display_name")} - defaultValue={displayName} + defaultValue={displayName ?? undefined} data-testid="profile_displayname" /> diff --git a/src/settings/SettingsModal.tsx b/src/settings/SettingsModal.tsx index 933ac66f5..a29991e0d 100644 --- a/src/settings/SettingsModal.tsx +++ b/src/settings/SettingsModal.tsx @@ -54,7 +54,8 @@ interface Props { onDismiss: () => void; tab: SettingsTab; onTabChange: (tab: SettingsTab) => void; - client: MatrixClient; + /** The matrix-js-sdk client, for what the developer tab still reads from it. */ + client?: MatrixClient; roomId?: string; livekitRooms?: { room: LivekitRoom; @@ -211,7 +212,7 @@ export const SettingsModal: FC = ({ const profileTab: Tab = { key: "profile", name: t("common.profile"), - content: , + content: , }; const feedbackTab: Tab = { diff --git a/src/settings/__snapshots__/DeveloperSettingsTab.test.tsx.snap b/src/settings/__snapshots__/DeveloperSettingsTab.test.tsx.snap index 63a68ac4b..0c4f107ea 100644 --- a/src/settings/__snapshots__/DeveloperSettingsTab.test.tsx.snap +++ b/src/settings/__snapshots__/DeveloperSettingsTab.test.tsx.snap @@ -30,7 +30,7 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` class="_field_1bd8c0 _inputField_1bd8c0" > renders and matches snapshot 1`] = ` class="_field_1bd8c0 _checkboxField_1bd8c0" > @@ -87,7 +87,7 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` class="_field_1bd8c0 _checkboxField_1bd8c0" > @@ -124,7 +124,7 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` class="_field_1bd8c0 _checkboxField_1bd8c0" > @@ -162,7 +162,7 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` class="_field_1bd8c0 _checkboxField_1bd8c0" > @@ -199,7 +199,7 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` class="_field_1bd8c0 _checkboxField_1bd8c0" > @@ -237,7 +237,7 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` > @@ -245,9 +245,9 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` class="_controls_17lij_8" > renders and matches snapshot 1`] = `

Currently, no overwrite is set. Url from config is used. @@ -285,10 +285,10 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` class="_container_1ug7n_10" > renders and matches snapshot 1`] = ` > Compatible with homeservers that do not support sticky events (but all other EC clients are v0.17.0 or later) @@ -326,9 +326,9 @@ exports[`DeveloperSettingsTab > renders and matches snapshot 1`] = ` class="_container_1ug7n_10" > renders and matches snapshot 1`] = ` > Compatible only with homservers supporting sticky events and all EC clients v0.17.0 or later +