import {  type ManagedRelayAccessTokenCacheEntry,  type ManagedRelayAccessTokenStore,} from "@t3tools/client-runtime/relay";import * as Data from "effect/Data";import * as Effect from "effect/Effect";import * as Schema from "effect/Schema";import * as SecureStore from "expo-secure-store"; const MANAGED_RELAY_TOKEN_CACHE_KEY = "t3code.cloud.relay-access-tokens";const MANAGED_RELAY_TOKEN_CACHE_VERSION = 1; const ManagedRelayAccessTokenCacheEntrySchema = Schema.Struct({  accountId: Schema.String,  clientId: Schema.Literals(["t3-mobile", "t3-web"]),  relayUrl: Schema.String,  thumbprint: Schema.String,  scopes: Schema.Array(    Schema.Literals(["environment:connect", "environment:status", "mobile:registration"]),  ),  accessToken: Schema.String,  expiresAtMillis: Schema.Number,}); const ManagedRelayAccessTokenCacheSchema = Schema.fromJsonString(  Schema.Struct({    version: Schema.Literal(MANAGED_RELAY_TOKEN_CACHE_VERSION),    entries: Schema.Array(ManagedRelayAccessTokenCacheEntrySchema),  }),); const decodeManagedRelayAccessTokenCache = Schema.decodeUnknownEffect(  ManagedRelayAccessTokenCacheSchema,);const encodeManagedRelayAccessTokenCache = Schema.encodeEffect(ManagedRelayAccessTokenCacheSchema); export class ManagedRelayTokenStoreError extends Data.TaggedError("ManagedRelayTokenStoreError")<{  readonly message: string;  readonly cause: unknown;}> {} const storeError =  (message: string) =>  (cause: unknown): ManagedRelayTokenStoreError =>    new ManagedRelayTokenStoreError({ message, cause }); function logStoreFailure(operation: string) {  return (error: ManagedRelayTokenStoreError) =>    Effect.logWarning(`Managed relay token store ${operation} failed.`).pipe(      Effect.annotateLogs({        errorTag: error._tag,        message: error.message,      }),    );} const loadManagedRelayAccessTokens = Effect.tryPromise({  try: () => SecureStore.getItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY),  catch: storeError("Could not read persisted relay access tokens."),}).pipe(  Effect.flatMap((encoded) =>    encoded === null      ? Effect.succeed<ReadonlyArray<ManagedRelayAccessTokenCacheEntry>>([])      : decodeManagedRelayAccessTokenCache(encoded).pipe(          Effect.map((cache) => cache.entries),          Effect.mapError(storeError("Persisted relay access tokens are invalid.")),        ),  ),); const saveManagedRelayAccessTokens = (entries: ReadonlyArray<ManagedRelayAccessTokenCacheEntry>) =>  encodeManagedRelayAccessTokenCache({    version: MANAGED_RELAY_TOKEN_CACHE_VERSION,    entries,  }).pipe(    Effect.mapError(storeError("Could not encode relay access tokens.")),    Effect.flatMap((encoded) =>      Effect.tryPromise({        try: () => SecureStore.setItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY, encoded),        catch: storeError("Could not persist relay access tokens."),      }),    ),  ); const clearManagedRelayAccessTokens = Effect.tryPromise({  try: () => SecureStore.deleteItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY),  catch: storeError("Could not clear persisted relay access tokens."),}); export const managedRelayAccessTokenStore: ManagedRelayAccessTokenStore = {  load: loadManagedRelayAccessTokens.pipe(    Effect.tapError(logStoreFailure("load")),    Effect.orElseSucceed(() => []),    Effect.withSpan("mobile.managedRelayTokenStore.load"),  ),  save: Effect.fn("mobile.managedRelayTokenStore.save")((entries) =>    saveManagedRelayAccessTokens(entries).pipe(      Effect.tapError(logStoreFailure("save")),      Effect.ignore,    ),  ),  clear: clearManagedRelayAccessTokens.pipe(    Effect.tapError(logStoreFailure("clear")),    Effect.ignore,    Effect.withSpan("mobile.managedRelayTokenStore.clear"),  ),};