A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(desktop): add the account engine core
Hampus5bd32095f6f2
diff --git a/fluxer_desktop/src/engine/AccountEngine.ts b/fluxer_desktop/src/engine/AccountEngine.tsnew file mode 100644index 000000000..00af8cb76--- /dev/null+++ b/fluxer_desktop/src/engine/AccountEngine.ts@@ -0,0 +1,740 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import {+ AccountSession,+ type AdmittedGateway,+ accountTokenTag,+ type PersistedAccountSummary,+} from '@electron/engine/AccountSession';+import {CacheDatabase} from '@electron/engine/CacheDatabase';+import {DispatchPump} from '@electron/engine/DispatchPump';+import type {EngineClock, EngineTimer} from '@electron/engine/EngineClock';+import {GatewayClose} from '@electron/engine/GatewayClient';+import type {GatewayTransportFactory} from '@electron/engine/GatewayTransport';+import type {EngineMessagePort} from '@electron/engine/HostChannel';+import {+ ACCOUNT_ENGINE_HOST_PROTOCOL_VERSION,+ type EngineAccountRecord,+ type EngineInitMessage,+ type EngineLogLevel,+ type EnginePowerEvent,+ type EngineToHostMessage,+ type HostToEngineMessage,+ parseEngineAccountRecord,+} from '@electron/engine/HostProtocol';+import {MentionLog} from '@electron/engine/MentionLog';+import {type AccountEngineHandlers, RendererPortServer} from '@electron/engine/RendererPortServer';+import {SessionScheduler} from '@electron/engine/SessionScheduler';+import {SqliteRowStore} from '@electron/engine/SqliteRowStore';+import {SummaryPublisher} from '@electron/engine/SummaryPublisher';+import {+ ACCOUNT_ENGINE_LIMITS,+ type AccountEngineAccountActivity,+ type AccountEngineAccountSummary,+ type AccountEngineClientConfig,+ AccountEngineConnectionState,+ AccountEngineErrorCode,+ type AccountEngineEvent,+ type AccountEngineMention,+ AccountEngineRequestError,+} from '@fluxer/desktop_ipc/src/AccountEngineContract';+import type {CreateAccountEngineCore} from '@fluxer/desktop_ipc/src/AccountEngineCoreContract';++const HOST_REQUEST_TIMEOUT_MS = 30_000;+const FOREGROUND_HINT_HOLD_MS = 30_000;+const RENDERER_REATTACH_GRACE_MS = 30_000;+const HEALTH_INTERVAL_MS = 60_000;+const POWER_PROBE_STAGGER_MS = 50;+const CLIENT_CONFIG_META_KEY = 'client_config';+const UNREAD_BADGE_CUSTOMIZATION_META_KEY = 'unread_badge_customization';+const SEED_BATCH_SIZE = 4;++interface AccountEngineDependencies {+ readonly send: (message: EngineToHostMessage) => void;+ readonly clock: EngineClock;+ readonly transport: GatewayTransportFactory;+ readonly transportKind: 'native' | 'websocket';+ readonly transportError: string | null;+ readonly createCore: CreateAccountEngineCore;+ readonly snapshotSchemaEpoch: number;+ readonly exit: () => void;+ readonly memoryUsage: () => {rss: number; heapUsed: number};+}++interface RendererTokenRotation {+ readonly previousTokenTag: string;+ readonly token: string;+}++interface PendingHostRequest {+ readonly resolve: (value: HostToEngineMessage) => void;+ readonly reject: (error: Error) => void;+ readonly timer: EngineTimer;+}++function parseSummary(json: string): PersistedAccountSummary | null {+ try {+ const value = JSON.parse(json) as PersistedAccountSummary;+ return typeof value?.accountKey === 'string' ? value : null;+ } catch {+ return null;+ }+}++function parseClientConfig(json: string | null): AccountEngineClientConfig | null {+ if (json === null) {+ return null;+ }+ try {+ const value = JSON.parse(json) as AccountEngineClientConfig;+ if (+ typeof value?.apiVersion === 'number' &&+ typeof value.identifyFlags === 'number' &&+ typeof value.properties === 'object'+ ) {+ return value;+ }+ } catch {}+ return null;+}++function parseAccountKeySet(json: string | null): Set<string> {+ if (json === null) {+ return new Set();+ }+ try {+ const value: unknown = JSON.parse(json);+ if (Array.isArray(value)) {+ return new Set(value.filter((entry): entry is string => typeof entry === 'string'));+ }+ } catch {}+ return new Set();+}++export class AccountEngine {+ private readonly deps: AccountEngineDependencies;+ private readonly clock: EngineClock;+ private readonly scheduler: SessionScheduler;+ private readonly pump = new DispatchPump();+ private readonly sessions = new Map<string, AccountSession>();+ private readonly pendingHost = new Map<number, PendingHostRequest>();+ private readonly persistedSummaries = new Map<string, PersistedAccountSummary>();+ private readonly rendererRotations = new Map<string, RendererTokenRotation>();+ private nextRequestId = 1;+ private cache: CacheDatabase | null = null;+ private store: SqliteRowStore | null = null;+ private mentionLog: MentionLog | null = null;+ private publisher: SummaryPublisher;+ private config: AccountEngineClientConfig | null = null;+ private renderer: RendererPortServer | null = null;+ private foregroundHint: string | null = null;+ private hintTimer: EngineTimer | null = null;+ private reattachTimer: EngineTimer | null = null;+ private readonly orphans = new Set<string>();+ private healthTimer: EngineTimer | null = null;+ private shuttingDown = false;+ private records = new Map<string, EngineAccountRecord>();+ private unreadBadgeCustomization = new Set<string>();++ constructor(deps: AccountEngineDependencies) {+ this.deps = deps;+ this.clock = deps.clock;+ this.scheduler = new SessionScheduler(deps.clock);+ this.publisher = this.createPublisher();+ }++ session(accountKey: string): AccountSession | null {+ return this.sessions.get(accountKey) ?? null;+ }++ handleHostMessage(message: HostToEngineMessage, port: EngineMessagePort | null): void {+ switch (message.type) {+ case 'init':+ this.init(message);+ return;+ case 'accounts':+ this.applyAccounts(message.accounts);+ return;+ case 'attachRenderer':+ if (port !== null) {+ this.attachRenderer(port);+ }+ return;+ case 'detachRenderer':+ this.detachRenderer();+ return;+ case 'admitResult':+ case 'httpResult':+ this.settleHostRequest(message.requestId, message);+ return;+ case 'tokenPersisted':+ this.tokenPersisted(message);+ return;+ case 'power':+ this.handlePower(message.event);+ return;+ case 'shutdown':+ this.shutdown();+ return;+ }+ }++ handlers(): AccountEngineHandlers {+ return {+ configure: (config) => this.configure(config),+ claimForeground: ({accountKey}) => this.claimForeground(accountKey),+ getSummaries: () => this.summaries(),+ getActivity: (params) => this.getActivity(params.accountKeys, params.channelLimit, params.mentionLimit),+ beginPromotion: ({accountKey}) => {+ const session = this.sessions.get(accountKey);+ if (session === undefined || this.store === null) {+ return null;+ }+ this.adoptForeground(accountKey);+ return session.serialize(async () => {+ await session.settleSubscriptionRelease();+ return session.beginPromotion();+ });+ },+ completePromotion: ({accountKey}) => {+ const session = this.requireSession(accountKey);+ return session.serialize(() => {+ session.completePromotion();+ return null;+ });+ },+ abortPromotion: ({accountKey}) => {+ const session = this.requireSession(accountKey);+ return session.serialize(() => {+ session.abortPromotion();+ return null;+ });+ },+ demote: (demotion) => {+ const session = this.requireSession(demotion.accountKey);+ return session.serialize(async () => {+ await session.demote(demotion);+ return null;+ });+ },+ ackChannel: (params) => this.ackChannel(params.accountKey, params.channelId, params.messageId),+ reconnect: ({accountKey}) => {+ this.requireSession(accountKey).reconnect();+ return null;+ },+ setUnreadBadgeCustomization: ({enabledAccountKeys}) => this.setUnreadBadgeCustomization(enabledAccountKeys),+ };+ }++ private createPublisher(): SummaryPublisher {+ return new SummaryPublisher({+ clock: this.clock,+ coalesceMs: ACCOUNT_ENGINE_LIMITS.summaryCoalesceMs,+ emit: (summaries) => {+ this.deps.send({type: 'summaries', summaries});+ this.emit({type: 'summaries', summaries});+ },+ persist: (summary) => {+ try {+ const session = this.sessions.get(summary.accountKey);+ const persisted: PersistedAccountSummary = {...summary, mentionCounts: session?.mentionCounts() ?? {}};+ this.cache?.writeSummary(summary.accountKey, JSON.stringify(persisted));+ } catch (error) {+ this.log('warn', 'Account engine could not persist a summary', String(error));+ }+ },+ });+ }++ private init(message: EngineInitMessage): void {+ if (this.cache !== null || message.protocol !== ACCOUNT_ENGINE_HOST_PROTOCOL_VERSION) {+ return;+ }+ const cache = new CacheDatabase(message.cachePath, this.deps.snapshotSchemaEpoch, this.clock);+ if (cache.openReport.reset !== 'none') {+ this.log('warn', `Account engine cache was reset (${cache.openReport.reset})`);+ }+ if (cache.openReport.memoryFallback !== null) {+ this.log('error', 'Account engine cache is in memory for this session', cache.openReport.memoryFallback);+ }+ this.cache = cache;+ this.store = new SqliteRowStore(cache);+ this.mentionLog = new MentionLog(cache);+ this.config = parseClientConfig(cache.getMeta(CLIENT_CONFIG_META_KEY));+ this.unreadBadgeCustomization = parseAccountKeySet(cache.getMeta(UNREAD_BADGE_CUSTOMIZATION_META_KEY));+ for (const json of cache.readSummaries().values()) {+ const summary = parseSummary(json);+ if (summary !== null) {+ this.persistedSummaries.set(summary.accountKey, summary);+ }+ }+ this.foregroundHint = message.foregroundHint;+ this.applyAccounts(message.accounts);+ this.deps.send({type: 'summaries', summaries: this.summaries()});+ if (message.accountsComplete !== false) {+ const known = new Set(this.records.keys());+ for (const accountKey of cache.knownAccountKeys()) {+ if (!known.has(accountKey)) {+ cache.purgeAccount(accountKey);+ }+ }+ }+ if (this.foregroundHint !== null) {+ this.hintTimer = this.clock.setTimeout(() => this.releaseForegroundHint(), FOREGROUND_HINT_HOLD_MS);+ }+ this.healthTimer = this.clock.setTimeout(() => this.reportHealth(), HEALTH_INTERVAL_MS);+ this.deps.send({type: 'ready', transport: this.deps.transportKind, transportError: this.deps.transportError});+ }++ private applyAccounts(input: ReadonlyArray<unknown>): void {+ if (this.cache === null) {+ return;+ }+ const next = new Map<string, EngineAccountRecord>();+ for (const value of input) {+ const record = parseEngineAccountRecord(value);+ if (record !== null) {+ next.set(record.accountKey, record);+ }+ }+ const removed: Array<string> = [];+ for (const accountKey of this.records.keys()) {+ if (!next.has(accountKey)) {+ removed.push(accountKey);+ }+ }+ this.records = next;+ for (const [accountKey, rotation] of this.rendererRotations) {+ const token = next.get(accountKey)?.token;+ if (token === undefined || token === rotation.token) {+ this.rendererRotations.delete(accountKey);+ }+ }+ for (const accountKey of removed) {+ this.removeAccount(accountKey);+ }+ const added: Array<AccountSession> = [];+ for (const record of next.values()) {+ const existing = this.sessions.get(record.accountKey);+ if (existing !== undefined) {+ void existing.serialize(() => existing.updateRecord(record));+ continue;+ }+ const session = this.createSession(record);+ session.setUnreadBadgeCustomization(this.unreadBadgeCustomization.has(record.accountKey));+ this.sessions.set(record.accountKey, session);+ this.publisher.seed(session.summary());+ added.push(session);+ }+ if (removed.length > 0) {+ this.deps.send({type: 'removed', accountKeys: removed});+ this.emit({type: 'removed', accountKeys: removed});+ }+ added.sort((left, right) => right.priority - left.priority);+ this.startGradually(added);+ }++ private startGradually(sessions: ReadonlyArray<AccountSession>): void {+ let index = 0;+ const step = (): void => {+ if (this.shuttingDown) {+ return;+ }+ const end = Math.min(sessions.length, index + SEED_BATCH_SIZE);+ for (; index < end; index += 1) {+ const session = sessions[index];+ if (this.sessions.get(session.accountKey) !== session) {+ continue;+ }+ session.start({held: session.accountKey === this.foregroundHint});+ this.publisher.update(session.summary());+ }+ if (index < sessions.length) {+ setImmediate(step);+ }+ };+ step();+ }++ private createSession(record: EngineAccountRecord): AccountSession {+ const store = this.store!;+ return new AccountSession(+ record,+ {+ clock: this.clock,+ scheduler: this.scheduler,+ pump: this.pump,+ transport: this.deps.transport,+ store,+ createCore: this.deps.createCore,+ admit: (accountKey, url) => this.admit(accountKey, url),+ config: () => this.config,+ commitCache: () => this.cache?.commit(),+ onSummaryChanged: (session) => {+ if (this.sessions.get(session.accountKey) === session) {+ this.publisher.update(session.summary());+ }+ },+ onNotification: (notification) => this.emit({type: 'notification', notification}),+ onMention: (accountKey, mention) => this.recordMention(accountKey, mention),+ onChannelRead: (accountKey, channelId) => this.emit({type: 'channel-read', accountKey, channelId}),+ onAuthFailed: (accountKey, tokenTag) => this.emit({type: 'auth-failed', accountKey, tokenTag}),+ onTokenRotated: (accountKey, previousToken, token) =>+ this.deps.send({type: 'tokenRotated', accountKey, previousToken, token}),+ log: (level, message, detail) => this.log(level, message, detail),+ },+ this.persistedSummaries.get(record.accountKey) ?? null,+ );+ }++ private removeAccount(accountKey: string): void {+ const session = this.sessions.get(accountKey);+ this.sessions.delete(accountKey);+ this.publisher.remove(accountKey);+ this.persistedSummaries.delete(accountKey);+ if (session !== undefined) {+ session.stop(GatewayClose.NORMAL, 'signed out', {dispose: true});+ }+ this.cache?.purgeAccount(accountKey);+ if (this.unreadBadgeCustomization.delete(accountKey)) {+ this.persistUnreadBadgeCustomization();+ }+ }++ private recordMention(accountKey: string, mention: AccountEngineMention): void {+ try {+ this.mentionLog?.record(accountKey, mention);+ } catch (error) {+ this.log('warn', 'Account engine could not record a mention', String(error));+ }+ }++ private configure(config: AccountEngineClientConfig): null {+ this.config = config;+ this.cache?.setMeta(CLIENT_CONFIG_META_KEY, JSON.stringify(config));+ for (const session of this.sessions.values()) {+ session.configChanged();+ }+ return null;+ }++ private setUnreadBadgeCustomization(enabledAccountKeys: ReadonlyArray<string>): null {+ this.unreadBadgeCustomization = new Set(enabledAccountKeys);+ this.persistUnreadBadgeCustomization();+ for (const session of this.sessions.values()) {+ session.setUnreadBadgeCustomization(this.unreadBadgeCustomization.has(session.accountKey));+ }+ return null;+ }++ private persistUnreadBadgeCustomization(): void {+ this.cache?.setMeta(UNREAD_BADGE_CUSTOMIZATION_META_KEY, JSON.stringify([...this.unreadBadgeCustomization]));+ }++ private claimForeground(accountKey: string | null): null {+ this.adoptForeground(accountKey);+ if (accountKey === null) {+ return null;+ }+ const session = this.sessions.get(accountKey);+ if (session === undefined) {+ this.foregroundHint = accountKey;+ return null;+ }+ void session.serialize(() => session.claimForeground());+ return null;+ }++ private adoptForeground(accountKey: string | null): void {+ if (this.reattachTimer !== null) {+ this.clock.clearTimeout(this.reattachTimer);+ this.reattachTimer = null;+ }+ if (accountKey !== this.foregroundHint) {+ this.releaseForegroundHint();+ } else if (this.hintTimer !== null) {+ this.clock.clearTimeout(this.hintTimer);+ this.hintTimer = null;+ }+ if (accountKey !== null) {+ this.orphans.delete(accountKey);+ }+ this.releaseOrphans();+ }++ private releaseOrphans(): void {+ const orphans = Array.from(this.orphans);+ this.orphans.clear();+ for (const accountKey of orphans) {+ const session = this.sessions.get(accountKey);+ if (session !== undefined && accountKey !== this.foregroundHint) {+ void session.serialize(() => session.releaseHold());+ }+ }+ }++ private collectOrphans(): void {+ for (const session of this.sessions.values()) {+ if (session.isHeld) {+ this.orphans.add(session.accountKey);+ }+ }+ }++ private releaseForegroundHint(): void {+ if (this.hintTimer !== null) {+ this.clock.clearTimeout(this.hintTimer);+ this.hintTimer = null;+ }+ const hint = this.foregroundHint;+ this.foregroundHint = null;+ if (hint !== null) {+ this.sessions.get(hint)?.releaseHold();+ }+ }++ private summaries(): Array<AccountEngineAccountSummary> {+ return Array.from(this.sessions.values(), (session) => session.summary());+ }++ private getActivity(+ accountKeys: ReadonlyArray<string> | null,+ channelLimit: number,+ mentionLimit: number,+ ): Array<AccountEngineAccountActivity> {+ const keys = accountKeys ?? Array.from(this.sessions.keys());+ const result: Array<AccountEngineAccountActivity> = [];+ for (const accountKey of keys) {+ const session = this.sessions.get(accountKey);+ if (session === undefined) {+ continue;+ }+ try {+ const activity = session.activity(channelLimit);+ result.push({+ accountKey,+ channels: activity.channels,+ totalChannelCount: activity.totalChannelCount,+ mentions: this.mentionLog?.list(accountKey, mentionLimit) ?? [],+ });+ } catch (error) {+ this.log('warn', 'Account engine could not build activity', String(error));+ }+ }+ return result;+ }++ private async ackChannel(accountKey: string, channelId: string, messageId: string): Promise<boolean> {+ const session = this.requireSession(accountKey);+ const response = await this.hostRequest({+ type: 'http',+ requestId: 0,+ accountKey,+ method: 'POST',+ path: `/channels/${channelId}/messages/${messageId}/ack`,+ body: '{}',+ });+ if (response.type !== 'httpResult' || !response.ok) {+ return false;+ }+ if (this.sessions.get(accountKey) === session) {+ this.emit({type: 'channel-read', accountKey, channelId});+ }+ return true;+ }++ private async admit(accountKey: string, url: string): Promise<AdmittedGateway> {+ const response = await this.hostRequest({type: 'admit', requestId: 0, accountKey, url});+ if (response.type !== 'admitResult' || !response.ok || response.url === null) {+ throw new Error(response.type === 'admitResult' ? (response.error ?? 'Admission refused') : 'Admission refused');+ }+ return {url: response.url, address: response.address};+ }++ private hostRequest(message: Extract<EngineToHostMessage, {type: 'admit' | 'http'}>): Promise<HostToEngineMessage> {+ const requestId = this.nextRequestId++;+ return new Promise<HostToEngineMessage>((resolve, reject) => {+ const timer = this.clock.setTimeout(() => {+ this.pendingHost.delete(requestId);+ reject(new AccountEngineRequestError(AccountEngineErrorCode.TIMEOUT, 'The desktop host did not answer'));+ }, HOST_REQUEST_TIMEOUT_MS);+ this.pendingHost.set(requestId, {resolve, reject, timer});+ this.deps.send({...message, requestId});+ });+ }++ private settleHostRequest(requestId: number, message: HostToEngineMessage): void {+ const pending = this.pendingHost.get(requestId);+ if (pending === undefined) {+ return;+ }+ this.pendingHost.delete(requestId);+ this.clock.clearTimeout(pending.timer);+ pending.resolve(message);+ }++ private requireSession(accountKey: string): AccountSession {+ const session = this.sessions.get(accountKey);+ if (session === undefined) {+ throw new AccountEngineRequestError(AccountEngineErrorCode.UNKNOWN_ACCOUNT, 'Unknown account');+ }+ return session;+ }++ private attachRenderer(port: EngineMessagePort): void {+ this.renderer?.close();+ this.collectOrphans();+ this.scheduleHeldRelease();+ let server: RendererPortServer;+ server = new RendererPortServer(port, this.handlers(), () => {+ if (this.renderer === server) {+ this.renderer = null;+ this.scheduleHeldRelease();+ }+ });+ this.renderer = server;+ server.emit({type: 'summaries', summaries: this.summaries()});+ for (const session of this.sessions.values()) {+ const tokenTag = session.authFailedTokenTag;+ if (tokenTag !== null) {+ server.emit({type: 'auth-failed', accountKey: session.accountKey, tokenTag});+ }+ }+ for (const [accountKey, rotation] of this.rendererRotations) {+ server.emit({type: 'account-token-rotated', accountKey, ...rotation});+ }+ }++ private tokenPersisted(message: Extract<HostToEngineMessage, {type: 'tokenPersisted'}>): void {+ const {accountKey, previousToken, token, outcome} = message;+ if (outcome === 'persisted') {+ this.rendererRotations.delete(accountKey);+ this.emit({type: 'account-record-changed', accountKey});+ return;+ }+ if (outcome !== 'renderer' || this.sessions.get(accountKey)?.currentToken !== token) {+ return;+ }+ const pending = this.rendererRotations.get(accountKey);+ const rotation: RendererTokenRotation = {+ previousTokenTag:+ pending !== undefined && pending.token === previousToken+ ? pending.previousTokenTag+ : accountTokenTag(previousToken),+ token,+ };+ this.rendererRotations.set(accountKey, rotation);+ this.emit({type: 'account-token-rotated', accountKey, ...rotation});+ }++ private detachRenderer(): void {+ const renderer = this.renderer;+ this.renderer = null;+ renderer?.close();+ this.collectOrphans();+ this.scheduleHeldRelease();+ }++ private scheduleHeldRelease(): void {+ if (this.reattachTimer !== null || this.shuttingDown || this.orphans.size === 0) {+ return;+ }+ this.reattachTimer = this.clock.setTimeout(() => {+ this.reattachTimer = null;+ if (this.foregroundHint !== null && this.orphans.has(this.foregroundHint)) {+ this.foregroundHint = null;+ }+ this.releaseOrphans();+ }, RENDERER_REATTACH_GRACE_MS);+ }++ private handlePower(event: EnginePowerEvent): void {+ switch (event) {+ case 'offline':+ this.scheduler.setOnline(false);+ for (const session of this.sessions.values()) {+ session.markOffline();+ }+ return;+ case 'online':+ this.scheduler.setOnline(true);+ this.probeAll();+ return;+ case 'resume':+ case 'unlock-screen':+ this.probeAll();+ return;+ case 'suspend':+ case 'lock-screen':+ return;+ }+ }++ private probeAll(): void {+ let index = 0;+ for (const session of this.sessions.values()) {+ const state = session.connectionState;+ if (state === AccountEngineConnectionState.READY) {+ this.clock.setTimeout(() => session.probe(), index * POWER_PROBE_STAGGER_MS);+ index += 1;+ } else if (state === AccountEngineConnectionState.BACKOFF || state === AccountEngineConnectionState.OFFLINE) {+ session.retryNowIfWaiting();+ }+ }+ }++ private reportHealth(): void {+ this.healthTimer = null;+ if (this.shuttingDown) {+ return;+ }+ for (const session of this.sessions.values()) {+ session.refreshUnread();+ }+ const usage = this.deps.memoryUsage();+ this.deps.send({type: 'health', rss: usage.rss, heapUsed: usage.heapUsed, sessions: this.sessions.size});+ this.healthTimer = this.clock.setTimeout(() => this.reportHealth(), HEALTH_INTERVAL_MS);+ }++ private shutdown(): void {+ if (this.shuttingDown) {+ return;+ }+ this.shuttingDown = true;+ for (const timer of [this.hintTimer, this.reattachTimer, this.healthTimer]) {+ if (timer !== null) {+ this.clock.clearTimeout(timer);+ }+ }+ for (const session of this.sessions.values()) {+ session.stop(GatewayClose.NORMAL, 'shutdown', {dispose: false});+ }+ this.scheduler.dispose();+ this.publisher.persistNow();+ this.renderer?.close();+ this.renderer = null;+ try {+ this.cache?.close();+ } catch (error) {+ this.log('warn', 'Account engine cache close failed', String(error));+ }+ this.deps.send({type: 'shutdownComplete'});+ this.deps.exit();+ }++ private emit(event: AccountEngineEvent): void {+ this.renderer?.emit(event);+ }++ private log(level: EngineLogLevel, message: string, detail?: unknown): void {+ let serialized: string | null = null;+ if (detail !== undefined) {+ try {+ serialized = typeof detail === 'string' ? detail : JSON.stringify(detail);+ } catch {+ serialized = String(detail);+ }+ }+ this.deps.send({type: 'log', level, message, detail: serialized});+ }+}