import { ClientCapabilities, PlatformConnectionSource, Persistence, } from "@t3tools/client-runtime/platform"; import { BearerConnectionCredential, BearerConnectionProfile, BearerConnectionRegistration, BearerConnectionTarget, ConnectionBlockedError, type ConnectionAttemptError, ConnectionTransientError, Connectivity, mapRemoteEnvironmentError, type PlatformConnectionRegistration, PrimaryConnectionRegistration, PrimaryConnectionTarget, sshTargetKey, Wakeups, } from "@t3tools/client-runtime/connection"; import { bootstrapRemoteBearerSession } from "@t3tools/client-runtime/authorization"; import { fetchRemoteEnvironmentDescriptor } from "@t3tools/client-runtime/environment"; import { managedRelayAccountChanges, managedRelaySessionAtom } from "@t3tools/client-runtime/relay"; import { EnvironmentRpcRequestObserver } from "@t3tools/client-runtime/rpc"; import { AuthStandardClientScopes, type DesktopBridge, type DesktopEnvironmentBootstrap, type DesktopSshEnvironmentBootstrap, type DesktopSshEnvironmentTarget, type EnvironmentId, PRIMARY_LOCAL_ENVIRONMENT_ID, } from "@t3tools/contracts"; import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Queue from "effect/Queue"; import * as Ref from "effect/Ref"; import * as Stream from "effect/Stream"; import { FetchHttpClient } from "effect/http"; import { APP_VERSION } from "../branding"; import { readDesktopPrimaryBearerToken } from "../environments/primary/desktopAuth"; import * as PrimaryEnvironmentHttpLayer from "../environments/primary/httpLayer"; import { readPrimaryEnvironmentTarget, type PrimaryEnvironmentTarget, } from "../environments/primary/target"; import { clearComposerDraftsEnvironment } from "../composerDraftStore"; import { isHostedStaticApp } from "../hostedPairing"; import { isLocalEnvironmentDisabled } from "../localEnvironment"; import { randomUUID } from "../lib/utils"; import { appAtomRegistry } from "../rpc/atomRegistry"; import { acknowledgeRpcRequest, trackRpcRequestSent } from "../rpc/requestLatencyState"; import { desktopLocalConnectionId, readDesktopSecondaryBootstrapsResult, type DesktopSecondaryBootstrapsRead, } from "./desktopLocal"; import * as ConnectionStorage from "./storage"; import { clientPresentationMetadata } from "./clientMetadata"; let nextObservedRpcRequestId = 0; function currentNetworkStatus(): "unknown" | "offline" | "online" { if (typeof navigator === "undefined") { return "unknown"; } return navigator.onLine ? "online" : "offline"; } const layerConnectivity = Connectivity.layer({ status: Effect.sync(currentNetworkStatus), changes: Stream.callback((queue) => Effect.acquireRelease( Effect.sync(() => { const online = () => Queue.offerUnsafe(queue, "online"); const offline = () => Queue.offerUnsafe(queue, "offline"); window.addEventListener("online", online); window.addEventListener("offline", offline); return { online, offline }; }), ({ online, offline }) => Effect.sync(() => { window.removeEventListener("online", online); window.removeEventListener("offline", offline); }), ).pipe(Effect.asVoid), ), }); interface NetworkInformationLike extends EventTarget { readonly type?: string; } // change also fires for same-network bandwidth and latency estimates; count only type changes. const networkPathChanges = Stream.callback<"network-changed">((queue) => Effect.acquireRelease( Effect.sync(() => { const connection = typeof navigator === "undefined" ? undefined : (navigator as Navigator & { readonly connection?: NetworkInformationLike }).connection; if (connection?.type === undefined) return undefined; let previous = connection.type; const listener = () => { const type = connection.type; if (type === undefined || type === previous) return; previous = type; Queue.offerUnsafe(queue, "network-changed"); }; connection.addEventListener("change", listener); return { connection, listener }; }), (subscription) => Effect.sync(() => subscription?.connection.removeEventListener("change", subscription.listener), ), ).pipe(Effect.asVoid), ); const layerWakeups = Wakeups.layer({ changes: Stream.mergeAll( [ Stream.callback<"application-active">((queue) => Effect.acquireRelease( Effect.sync(() => { const listener = () => { if (document.visibilityState === "visible") { Queue.offerUnsafe(queue, "application-active"); } }; document.addEventListener("visibilitychange", listener); return listener; }), (listener) => Effect.sync(() => { document.removeEventListener("visibilitychange", listener); }), ).pipe(Effect.asVoid), ), managedRelayAccountChanges(appAtomRegistry).pipe( Stream.map(() => "credentials-changed" as const), ), networkPathChanges, ], { concurrency: "unbounded" }, ), }); export function currentClientMetadata() { return clientPresentationMetadata({ appVersion: APP_VERSION, hosted: isHostedStaticApp(), identity: { userAgent: navigator.userAgent, platform: navigator.platform, maxTouchPoints: navigator.maxTouchPoints, }, desktopBridge: window.desktopBridge, }); } function sshPreparationError(cause: unknown) { const message = cause instanceof Error ? cause.message : String(cause); if (message.toLowerCase().includes("cancel")) { return new ConnectionBlockedError({ reason: "authentication", detail: message, }); } return new ConnectionTransientError({ reason: "remote-unavailable", detail: `Could not prepare the SSH environment: ${message}`, }); } // IPC keeps running after its waiter is interrupted. A retry can adopt only // that interrupted waiter's unfinished setup. const pendingSshSetups = new Map< string, { readonly promise: Promise; signal: AbortSignal } >(); const ensureDesktopSshEnvironment = (bridge: DesktopBridge, target: DesktopSshEnvironmentTarget) => Effect.tryPromise({ try: (signal) => { const key = sshTargetKey(target); const pending = pendingSshSetups.get(key); if (pending?.signal.aborted) { pending.signal = signal; return pending.promise; } const setup = { promise: bridge.ensureSshEnvironment(target, { issuePairingToken: true }), signal, }; pendingSshSetups.set(key, setup); const forget = () => { if (pendingSshSetups.get(key) === setup) pendingSshSetups.delete(key); }; setup.promise.then(forget, forget); return setup.promise; }, catch: sshPreparationError, }); export const provisionDesktopSshEnvironment = Effect.fn( "web.connectionPlatform.ssh.provisionDesktop", )(function* ( bridge: DesktopBridge, target: DesktopSshEnvironmentTarget, expectedEnvironmentId?: EnvironmentId, ) { const bootstrap = yield* ensureDesktopSshEnvironment(bridge, target); const pairingToken = bootstrap.pairingToken; if (pairingToken === null) { return yield* new ConnectionBlockedError({ reason: "authentication", detail: "The SSH environment did not issue a pairing credential.", }); } const descriptor = yield* Effect.tryPromise({ try: () => bridge.fetchSshEnvironmentDescriptor(bootstrap.httpBaseUrl), catch: sshPreparationError, }); if (expectedEnvironmentId !== undefined && descriptor.environmentId !== expectedEnvironmentId) { return yield* new ConnectionBlockedError({ reason: "configuration", detail: `That host reaches ${descriptor.label}, a different machine. Add it as its own environment instead.`, }); } const access = yield* Effect.tryPromise({ try: () => bridge.bootstrapSshBearerSession(bootstrap.httpBaseUrl, pairingToken), catch: (cause) => { const error = sshPreparationError(cause); // A reused remote server on another build can fail to decode the grant // the desktop's runner just minted, and answers 500 on every retry. if ( error._tag === "ConnectionBlockedError" || descriptor.serverVersion === APP_VERSION || !error.detail.includes("[ssh_http:500]") ) { return error; } return new ConnectionBlockedError({ reason: "configuration", detail: `${descriptor.label} runs T3 Code ${descriptor.serverVersion}, but this desktop is ${APP_VERSION}, and that server could not accept its pairing. Restart the T3 server on ${descriptor.label} so it runs ${APP_VERSION}, then retry.`, }); }, }); return { environmentId: descriptor.environmentId, label: descriptor.label, bootstrap, bearerToken: access.access_token, }; }); /** Reuses SSH pairing tokens with all standard scopes to avoid adding a session on each connection. */ export const prepareDesktopSshEnvironment = Effect.fn("web.connectionPlatform.ssh.prepareDesktop")( function* ( bridge: DesktopBridge, input: { readonly target: DesktopSshEnvironmentTarget; readonly expectedEnvironmentId: EnvironmentId; readonly bearerToken?: string; }, ) { const bearerToken = input.bearerToken; if (bearerToken !== undefined) { const bootstrap = yield* Effect.tryPromise({ try: () => bridge.ensureSshEnvironment(input.target, { issuePairingToken: false }), catch: sshPreparationError, }); // Check identity before sending saved credentials or pairing. const descriptor = yield* Effect.tryPromise({ try: () => bridge.fetchSshEnvironmentDescriptor(bootstrap.httpBaseUrl), catch: sshPreparationError, }); if (descriptor.environmentId !== input.expectedEnvironmentId) { return yield* new ConnectionBlockedError({ reason: "configuration", detail: `That host reaches ${descriptor.label}, a different machine. Add it as its own environment instead.`, }); } const session = yield* Effect.tryPromise({ try: () => bridge.fetchSshSessionState(bootstrap.httpBaseUrl, bearerToken), catch: sshPreparationError, }); // Stored grants never widen; re-pair tokens missing newer standard scopes. const granted = session.permissions ?? session.scopes ?? []; if ( session.authenticated && AuthStandardClientScopes.every((scope) => granted.includes(scope)) ) { return { bootstrap, bearerToken }; } } const provisioned = yield* provisionDesktopSshEnvironment( bridge, input.target, input.expectedEnvironmentId, ); return { bootstrap: provisioned.bootstrap, bearerToken: provisioned.bearerToken }; }, ); const ANALYTICS_DEVICE_ID_KEY = "t3code:analytics-device-id"; // Lives as long as this browser profile's site data. Storage can be blocked, which only drops the id. const analyticsDevice = { id: Effect.sync( Option.liftThrowable(() => { const existing = window.localStorage.getItem(ANALYTICS_DEVICE_ID_KEY); if (existing) return existing; const created = randomUUID(); window.localStorage.setItem(ANALYTICS_DEVICE_ID_KEY, created); return created; }), ), }; const layerCapabilities = Layer.effectContext( Effect.sync(() => { const presentation = ClientCapabilities.ClientPresentation.of({ metadata: currentClientMetadata(), }); const cloudSession = ClientCapabilities.CloudSession.of({ identity: Effect.sync(() => Option.fromNullishOr(appAtomRegistry.get(managedRelaySessionAtom)), ), clerkToken: Effect.gen(function* () { const session = appAtomRegistry.get(managedRelaySessionAtom); if (session === null) { return yield* new ConnectionBlockedError({ reason: "authentication", detail: "Sign in to T3 Connect to connect this environment.", }); } const token = yield* session.readClerkToken().pipe( Effect.mapError( (error) => new ConnectionTransientError({ reason: "network", detail: error.message, }), ), ); if (token === null) { return yield* new ConnectionBlockedError({ reason: "authentication", detail: "The T3 Connect session is unavailable.", }); } return token; }), }); const identity = ClientCapabilities.RelayDeviceIdentity.of({ deviceId: Effect.succeedNone, }); const primaryAuth = ClientCapabilities.PrimaryEnvironmentAuth.of({ bearerToken: Effect.tryPromise({ try: readDesktopPrimaryBearerToken, catch: (cause) => new ConnectionTransientError({ reason: "remote-unavailable", detail: `Could not load the desktop primary credential: ${String(cause)}`, }), }).pipe(Effect.map(Option.fromNullishOr)), }); const ssh = ClientCapabilities.SshEnvironmentGateway.of({ provision: Effect.fn("web.connectionPlatform.ssh.provision")( function* (target, expectedEnvironmentId) { const bridge = window.desktopBridge; if (bridge === undefined) { return yield* new ConnectionBlockedError({ reason: "unsupported", detail: "SSH environments are only available in the desktop app.", }); } return yield* provisionDesktopSshEnvironment(bridge, target, expectedEnvironmentId); }, ), prepare: Effect.fn("web.connectionPlatform.ssh.prepare")(function* (input) { const bridge = window.desktopBridge; if (bridge === undefined) { return yield* new ConnectionBlockedError({ reason: "unsupported", detail: "SSH environments are only available in the desktop app.", }); } return yield* prepareDesktopSshEnvironment(bridge, input); }), disconnect: Effect.fn("web.connectionPlatform.ssh.disconnect")(function* (target) { const bridge = window.desktopBridge; if (bridge === undefined) { return; } pendingSshSetups.delete(sshTargetKey(target)); yield* Effect.tryPromise({ try: () => bridge.disconnectSshEnvironment(target), catch: (cause) => new ConnectionTransientError({ reason: "remote-unavailable", detail: `Could not disconnect the SSH environment: ${String(cause)}`, }), }); }), }); return Context.make(ClientCapabilities.CloudSession, cloudSession).pipe( Context.add(ClientCapabilities.AnalyticsDevice, analyticsDevice), Context.add(ClientCapabilities.PrimaryEnvironmentAuth, primaryAuth), Context.add(ClientCapabilities.RelayDeviceIdentity, identity), Context.add(ClientCapabilities.ClientPresentation, presentation), Context.add(ClientCapabilities.SshEnvironmentGateway, ssh), ); }), ); const loadPrimaryConnectionRegistration = Effect.fn( "web.connectionPlatform.loadPrimaryConnectionRegistration", )(function* (resolved: PrimaryEnvironmentTarget) { const descriptor = yield* fetchRemoteEnvironmentDescriptor({ httpBaseUrl: resolved.target.httpBaseUrl, }).pipe( Effect.provide(PrimaryEnvironmentHttpLayer.layer), Effect.mapError(mapRemoteEnvironmentError), ); return new PrimaryConnectionRegistration({ target: new PrimaryConnectionTarget({ environmentId: descriptor.environmentId, label: descriptor.label, httpBaseUrl: resolved.target.httpBaseUrl, wsBaseUrl: resolved.target.wsBaseUrl, }), }); }); const loadSecondaryConnectionRegistration = Effect.fn( "web.connectionPlatform.loadSecondaryConnectionRegistration", )(function* (entry: DesktopEnvironmentBootstrap) { if ( entry.httpBaseUrl === null || entry.wsBaseUrl === null || entry.bootstrapToken === undefined ) { return yield* new ConnectionTransientError({ reason: "endpoint-unavailable", detail: `Desktop-local backend ${entry.id} is not ready yet.`, }); } const httpBaseUrl = entry.httpBaseUrl; const wsBaseUrl = entry.wsBaseUrl; const descriptor = yield* fetchRemoteEnvironmentDescriptor({ httpBaseUrl }).pipe( Effect.mapError(mapRemoteEnvironmentError), ); const issuedAtEpochMs = yield* Clock.currentTimeMillis; const access = yield* bootstrapRemoteBearerSession({ httpBaseUrl, credential: entry.bootstrapToken, scopes: AuthStandardClientScopes, clientMetadata: currentClientMetadata(), }).pipe(Effect.mapError(mapRemoteEnvironmentError)); // Desktop operations need the pool backend id to reach the owning instance; RPC uses the environment id. const connectionId = desktopLocalConnectionId(entry.id); const label = entry.label || descriptor.label; return { registration: new BearerConnectionRegistration({ target: new BearerConnectionTarget({ environmentId: descriptor.environmentId, label, connectionId, }), profile: new BearerConnectionProfile({ connectionId, environmentId: descriptor.environmentId, label, httpBaseUrl, wsBaseUrl, }), credential: new BearerConnectionCredential({ token: access.access_token }), }), expiresAtEpochMs: secondaryBearerExpiresAtEpochMs(issuedAtEpochMs, access.expires_in), refreshAtEpochMs: secondaryBearerRefreshAtEpochMs(issuedAtEpochMs, access.expires_in), }; }); // The bridge has no topology event. Cache registrations until bearer credentials near expiry. const PLATFORM_POLL_INTERVAL = "3 seconds"; const SECONDARY_BEARER_REFRESH_SKEW_MS = 5_000; function secondaryBearerExpiresAtEpochMs( issuedAtEpochMs: number, expiresInSeconds: number, ): number { return issuedAtEpochMs + Math.max(0, expiresInSeconds * 1_000); } function secondaryBearerRefreshAtEpochMs( issuedAtEpochMs: number, expiresInSeconds: number, ): number { return Math.max( issuedAtEpochMs, secondaryBearerExpiresAtEpochMs(issuedAtEpochMs, expiresInSeconds) - SECONDARY_BEARER_REFRESH_SKEW_MS, ); } interface CachedPlatformRegistration { readonly signature: string; readonly registration: PlatformConnectionRegistration; readonly expiresAtEpochMs?: number; readonly refreshAtEpochMs?: number; readonly bootstrapToken?: string; } export type PrimaryEnvironmentTargetRead = | { readonly _tag: "Success"; readonly target: PrimaryEnvironmentTarget | null; } | { readonly _tag: "Failure"; readonly cause: unknown; }; function readPrimaryEnvironmentTargetResult( readTarget: () => PrimaryEnvironmentTarget | null = readPrimaryEnvironmentTarget, ): PrimaryEnvironmentTargetRead { try { return { _tag: "Success", target: readTarget() }; } catch (cause) { return { _tag: "Failure", cause }; } } export function primaryRegistrationToRetainAfterTopologyRead( previous: ReadonlyMap, topologyRead: PrimaryEnvironmentTargetRead, ): CachedPlatformRegistration | undefined { return topologyRead._tag === "Failure" ? previous.get(PRIMARY_LOCAL_ENVIRONMENT_ID) : undefined; } export function canReuseCachedPlatformRegistration( cached: CachedPlatformRegistration, signature: string, nowEpochMs: number, ): boolean { return ( cached.signature === signature && (cached.refreshAtEpochMs === undefined || nowEpochMs < cached.refreshAtEpochMs) ); } export function canRetainCachedPlatformRegistrationAfterRefreshFailure( cached: CachedPlatformRegistration, signature: string, nowEpochMs: number, ): boolean { return ( cached.signature === signature && cached.expiresAtEpochMs !== undefined && nowEpochMs < cached.expiresAtEpochMs ); } const REJECTED_BOOTSTRAP_RETRY_INITIAL_MS = 60_000; const REJECTED_BOOTSTRAP_RETRY_MAX_MS = 30 * 60_000; export interface RejectedSecondaryBootstrap { readonly signature: string; readonly retryAtEpochMs: number; readonly delayMs: number; } /** Retry with backoff: a backend can restart on the same port with a fresh grant and no topology change. */ export function isRejectedSecondaryBootstrap( rejected: RejectedSecondaryBootstrap | undefined, signature: string, nowEpochMs: number, ): rejected is RejectedSecondaryBootstrap { return ( rejected !== undefined && rejected.signature === signature && nowEpochMs < rejected.retryAtEpochMs ); } export function nextRejectedSecondaryBootstrap( previous: RejectedSecondaryBootstrap | undefined, signature: string, nowEpochMs: number, ): RejectedSecondaryBootstrap { const delayMs = previous?.signature === signature ? Math.min(previous.delayMs * 2, REJECTED_BOOTSTRAP_RETRY_MAX_MS) : REJECTED_BOOTSTRAP_RETRY_INITIAL_MS; return { signature, retryAtEpochMs: nowEpochMs + delayMs, delayMs }; } export function isRejectedBootstrapCredentialError(error: ConnectionAttemptError): boolean { return error._tag === "ConnectionBlockedError" && error.reason === "authentication"; } export function secondaryRegistrationsToRetainAfterTopologyRead( previous: ReadonlyMap, topologyRead: DesktopSecondaryBootstrapsRead, nowEpochMs: number, ): ReadonlyMap { if (topologyRead._tag === "Success") { return new Map(); } return new Map( [...previous].filter( ([, cached]) => cached.expiresAtEpochMs !== undefined && nowEpochMs < cached.expiresAtEpochMs, ), ); } const layerPlatformConnectionSource = Layer.effect( PlatformConnectionSource.PlatformConnectionSource, Effect.gen(function* () { if (isHostedStaticApp() || isLocalEnvironmentDisabled()) { return PlatformConnectionSource.PlatformConnectionSource.of({ registrations: Stream.empty, }); } const cacheRef = yield* Ref.make(new Map()); const rejectedRef = yield* Ref.make(new Map()); const buildPlatformRegistrations = Effect.gen(function* () { const previous = yield* Ref.get(cacheRef); const nowEpochMs = yield* Clock.currentTimeMillis; const next = new Map(); const registrations: Array = []; const primaryTopologyRead = readPrimaryEnvironmentTargetResult(); const retainedPrimary = primaryRegistrationToRetainAfterTopologyRead( previous, primaryTopologyRead, ); if (retainedPrimary !== undefined) { next.set(PRIMARY_LOCAL_ENVIRONMENT_ID, retainedPrimary); registrations.push(retainedPrimary.registration); } if (primaryTopologyRead._tag === "Failure") { yield* Effect.logWarning("Could not read the primary environment topology.", { cause: primaryTopologyRead.cause, }); } else if (primaryTopologyRead.target !== null) { const primaryTarget = primaryTopologyRead.target; const signature = `primary|${primaryTarget.target.httpBaseUrl}|${primaryTarget.target.wsBaseUrl}`; const cached = previous.get(PRIMARY_LOCAL_ENVIRONMENT_ID); if ( cached !== undefined && canReuseCachedPlatformRegistration(cached, signature, nowEpochMs) ) { next.set(PRIMARY_LOCAL_ENVIRONMENT_ID, cached); registrations.push(cached.registration); } else { const built = yield* loadPrimaryConnectionRegistration(primaryTarget).pipe( Effect.tapError((error) => Effect.logWarning("Could not discover the primary environment.", { error }), ), Effect.option, ); if (Option.isSome(built)) { const cacheEntry = { signature, registration: built.value }; next.set(PRIMARY_LOCAL_ENVIRONMENT_ID, cacheEntry); registrations.push(built.value); } } } const topologyRead = readDesktopSecondaryBootstrapsResult(); for (const [id, cached] of secondaryRegistrationsToRetainAfterTopologyRead( previous, topologyRead, nowEpochMs, )) { next.set(id, cached); registrations.push(cached.registration); } if (topologyRead._tag === "Failure") { yield* Effect.logWarning("Could not read the desktop-local backend topology.", { cause: topologyRead.cause, }); } else { const rejected = yield* Ref.get(rejectedRef); const nextRejected = new Map(); for (const bootstrap of topologyRead.bootstraps) { // Token rotation only controls exchange retries; dropping endpoint bearers also clears drafts. const endpointSignature = `${bootstrap.httpBaseUrl}|${bootstrap.wsBaseUrl}`; const signature = `${endpointSignature}|${bootstrap.bootstrapToken ?? ""}`; const cached = previous.get(bootstrap.id); // Rotation may mean a restart; retain the old bearer if the new exchange fails. if ( cached !== undefined && cached.bootstrapToken === bootstrap.bootstrapToken && canReuseCachedPlatformRegistration(cached, endpointSignature, nowEpochMs) ) { next.set(bootstrap.id, cached); registrations.push(cached.registration); continue; } const previouslyRejected = rejected.get(bootstrap.id); if (isRejectedSecondaryBootstrap(previouslyRejected, signature, nowEpochMs)) { nextRejected.set(bootstrap.id, previouslyRejected); if ( cached !== undefined && canRetainCachedPlatformRegistrationAfterRefreshFailure( cached, endpointSignature, nowEpochMs, ) ) { next.set(bootstrap.id, cached); registrations.push(cached.registration); } continue; } const built = yield* loadSecondaryConnectionRegistration(bootstrap).pipe( Effect.tapError((error) => Effect.logWarning("Could not connect a desktop-local backend.", { id: bootstrap.id, error, }), ), Effect.tapError((error) => isRejectedBootstrapCredentialError(error) ? // Start backoff at rejection; this poll can outlast the first delay. Clock.currentTimeMillis.pipe( Effect.map((rejectedAtEpochMs) => nextRejected.set( bootstrap.id, nextRejectedSecondaryBootstrap( previouslyRejected, signature, rejectedAtEpochMs, ), ), ), ) : Effect.void, ), Effect.option, ); if (Option.isSome(built)) { const cacheEntry = { signature: endpointSignature, ...(bootstrap.bootstrapToken === undefined ? {} : { bootstrapToken: bootstrap.bootstrapToken }), ...built.value, }; next.set(bootstrap.id, cacheEntry); registrations.push(built.value.registration); } else if ( cached !== undefined && canRetainCachedPlatformRegistrationAfterRefreshFailure( cached, endpointSignature, nowEpochMs, ) ) { next.set(bootstrap.id, cached); registrations.push(cached.registration); } } yield* Ref.set(rejectedRef, nextRejected); } yield* Ref.set(cacheRef, next); return registrations as ReadonlyArray; }).pipe(Effect.provide(FetchHttpClient.layer)); return PlatformConnectionSource.PlatformConnectionSource.of({ registrations: Stream.tick(PLATFORM_POLL_INTERVAL).pipe( Stream.mapEffect(() => buildPlatformRegistrations), ), }); }), ); const layerEnvironmentOwnedDataCleanup = Layer.succeed( Persistence.EnvironmentOwnedDataCleanup, Persistence.EnvironmentOwnedDataCleanup.of({ clear: Effect.fn("Persistence.EnvironmentOwnedDataCleanup.clear")(function (environmentId) { return Effect.sync(() => { clearComposerDraftsEnvironment(environmentId); }); }), }), ); const layerRpcRequestObserver = Layer.succeed( EnvironmentRpcRequestObserver, EnvironmentRpcRequestObserver.of({ // Every RPC passes through this observer; the request owns its span. observe: Effect.fnUntraced(function* ({ environmentId, environmentLabel, method }) { return yield* Effect.sync(() => { nextObservedRpcRequestId += 1; const requestId = `${environmentId}:${nextObservedRpcRequestId}`; trackRpcRequestSent(requestId, method, `${method} ยท ${environmentLabel}`); return Effect.sync(() => { acknowledgeRpcRequest(requestId); }); }); }), }), ); type ConnectionPlatformLayerSource = | typeof ConnectionStorage.layer | typeof layerConnectivity | typeof layerWakeups | typeof layerCapabilities | typeof layerPlatformConnectionSource | typeof layerEnvironmentOwnedDataCleanup | typeof layerRpcRequestObserver; export const layer: Layer.Layer< Layer.Success, Layer.Error, Layer.Services > = Layer.mergeAll( ConnectionStorage.layer, layerConnectivity, layerWakeups, layerCapabilities, layerPlatformConnectionSource, layerEnvironmentOwnedDataCleanup, layerRpcRequestObserver, );