Merge remote-tracking branch 'origin' into innovation/archive/web-work

2026-02-10 13:40:06 +00:00 · 2025-04-18 15:39:04 -04:00
parent 1e9a21e831 f86a5c2b6e
commit 1fae2d5b4c
1201 changed files with 32709 additions and 30762 deletions
--- a/libs/angular/src/auth/components/change-password.component.ts
+++ b/libs/angular/src/auth/components/change-password.component.ts
@@ -1,11 +1,12 @@
 // FIXME: Update this file to be type safe and remove this and next line
 // @ts-strict-ignore
 import { Directive, OnDestroy, OnInit } from "@angular/core";
-import { Subject, firstValueFrom, map, takeUntil } from "rxjs";
+import { Subject, firstValueFrom, map, switchMap, takeUntil } from "rxjs";

 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { MasterPasswordPolicyOptions } from "@bitwarden/common/admin-console/models/domain/master-password-policy-options";
 import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
+import { getUserId } from "@bitwarden/common/auth/services/account.service";
 import { InternalMasterPasswordServiceAbstraction } from "@bitwarden/common/key-management/master-password/abstractions/master-password.service.abstraction";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { MessagingService } from "@bitwarden/common/platform/abstractions/messaging.service";
@@ -52,9 +53,12 @@ export class ChangePasswordComponent implements OnInit, OnDestroy {
    this.email = await firstValueFrom(
      this.accountService.activeAccount$.pipe(map((a) => a?.email)),
    );
-    this.policyService
-      .masterPasswordPolicyOptions$()
-      .pipe(takeUntil(this.destroy$))
+    this.accountService.activeAccount$
+      .pipe(
+        getUserId,
+        switchMap((userId) => this.policyService.masterPasswordPolicyOptions$(userId)),
+        takeUntil(this.destroy$),
+      )
      .subscribe(
        (enforcedPasswordPolicyOptions) =>
          (this.enforcedPolicyOptions ??= enforcedPasswordPolicyOptions),
--- a/libs/angular/src/auth/components/remove-password.component.ts
+++ b/libs/angular/src/auth/components/remove-password.component.ts
@@ -1,103 +0,0 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
-import { Directive, OnInit } from "@angular/core";
-import { Router } from "@angular/router";
-import { firstValueFrom, map } from "rxjs";
-
-import { OrganizationApiServiceAbstraction } from "@bitwarden/common/admin-console/abstractions/organization/organization-api.service.abstraction";
-import { Organization } from "@bitwarden/common/admin-console/models/domain/organization";
-import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
-import { KeyConnectorService } from "@bitwarden/common/key-management/key-connector/abstractions/key-connector.service";
-import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
-import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service";
-import { SyncService } from "@bitwarden/common/vault/abstractions/sync/sync.service.abstraction";
-import { DialogService, ToastService } from "@bitwarden/components";
-
-@Directive()
-export class RemovePasswordComponent implements OnInit {
-  actionPromise: Promise<void | boolean>;
-  continuing = false;
-  leaving = false;
-
-  loading = true;
-  organization: Organization;
-  email: string;
-
-  constructor(
-    private router: Router,
-    private accountService: AccountService,
-    private syncService: SyncService,
-    private platformUtilsService: PlatformUtilsService,
-    private i18nService: I18nService,
-    private keyConnectorService: KeyConnectorService,
-    private organizationApiService: OrganizationApiServiceAbstraction,
-    private dialogService: DialogService,
-    private toastService: ToastService,
-  ) {}
-
-  async ngOnInit() {
-    this.organization = await this.keyConnectorService.getManagingOrganization();
-    this.email = await firstValueFrom(
-      this.accountService.activeAccount$.pipe(map((a) => a?.email)),
-    );
-    await this.syncService.fullSync(false);
-    this.loading = false;
-  }
-
-  convert = async () => {
-    this.continuing = true;
-    this.actionPromise = this.keyConnectorService.migrateUser();
-
-    try {
-      await this.actionPromise;
-      this.toastService.showToast({
-        variant: "success",
-        title: null,
-        message: this.i18nService.t("removedMasterPassword"),
-      });
-      await this.keyConnectorService.removeConvertAccountRequired();
-      // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      this.router.navigate([""]);
-    } catch (e) {
-      this.toastService.showToast({
-        variant: "error",
-        title: this.i18nService.t("errorOccurred"),
-        message: e.message,
-      });
-    }
-  };
-
-  leave = async () => {
-    const confirmed = await this.dialogService.openSimpleDialog({
-      title: this.organization.name,
-      content: { key: "leaveOrganizationConfirmation" },
-      type: "warning",
-    });
-
-    if (!confirmed) {
-      return false;
-    }
-
-    try {
-      this.leaving = true;
-      this.actionPromise = this.organizationApiService.leave(this.organization.id);
-      await this.actionPromise;
-      this.toastService.showToast({
-        variant: "success",
-        title: null,
-        message: this.i18nService.t("leftOrganization"),
-      });
-      await this.keyConnectorService.removeConvertAccountRequired();
-      // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      this.router.navigate([""]);
-    } catch (e) {
-      this.toastService.showToast({
-        variant: "error",
-        title: this.i18nService.t("errorOccurred"),
-        message: e,
-      });
-    }
-  };
-}
--- a/libs/angular/src/auth/components/set-password.component.ts
+++ b/libs/angular/src/auth/components/set-password.component.ts
@@ -211,7 +211,10 @@ export class SetPasswordComponent extends BaseChangePasswordComponent implements

            // RSA Encrypt user key with organization public key
            const userKey = await this.keyService.getUserKey();
-            const encryptedUserKey = await this.encryptService.rsaEncrypt(userKey.key, publicKey);
+            const encryptedUserKey = await this.encryptService.encapsulateKeyUnsigned(
+              userKey,
+              publicKey,
+            );

            const resetRequest = new OrganizationUserResetPasswordEnrollmentRequest();
            resetRequest.masterPasswordHash = masterPasswordHash;
--- a/libs/angular/src/auth/components/set-pin.component.ts
+++ b/libs/angular/src/auth/components/set-pin.component.ts
@@ -1,6 +1,5 @@
 // FIXME: Update this file to be type safe and remove this and next line
 // @ts-strict-ignore
-import { DialogRef } from "@angular/cdk/dialog";
 import { Directive, OnInit } from "@angular/core";
 import { FormBuilder, Validators } from "@angular/forms";
 import { firstValueFrom } from "rxjs";
@@ -9,6 +8,7 @@ import { PinServiceAbstraction } from "@bitwarden/auth/common";
 import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
 import { UserVerificationService } from "@bitwarden/common/auth/abstractions/user-verification/user-verification.service.abstraction";
 import { Utils } from "@bitwarden/common/platform/misc/utils";
+import { DialogRef } from "@bitwarden/components";
 import { KeyService } from "@bitwarden/key-management";

@Directive()
@@ -16,7 +16,7 @@ export class SetPinComponent implements OnInit {
  showMasterPasswordOnClientRestartOption = true;

  setPinForm = this.formBuilder.group({
-    pin: ["", [Validators.required]],
+    pin: ["", [Validators.required, Validators.minLength(4)]],
    requireMasterPasswordOnClientRestart: true,
  });

@@ -37,24 +37,26 @@ export class SetPinComponent implements OnInit {
  }

  submit = async () => {
-    const pin = this.setPinForm.get("pin").value;
+    const pinFormControl = this.setPinForm.controls.pin;
    const requireMasterPasswordOnClientRestart = this.setPinForm.get(
      "requireMasterPasswordOnClientRestart",
    ).value;

-    if (Utils.isNullOrWhitespace(pin)) {
-      this.dialogRef.close(false);
+    if (Utils.isNullOrWhitespace(pinFormControl.value) || pinFormControl.invalid) {
      return;
    }

    const userId = (await firstValueFrom(this.accountService.activeAccount$))?.id;
    const userKey = await this.keyService.getUserKey();

-    const userKeyEncryptedPin = await this.pinService.createUserKeyEncryptedPin(pin, userKey);
+    const userKeyEncryptedPin = await this.pinService.createUserKeyEncryptedPin(
+      pinFormControl.value,
+      userKey,
+    );
    await this.pinService.setUserKeyEncryptedPin(userKeyEncryptedPin, userId);

    const pinKeyEncryptedUserKey = await this.pinService.createPinKeyEncryptedUserKey(
-      pin,
+      pinFormControl.value,
      userKey,
      userId,
    );
--- a/libs/angular/src/auth/components/sso.component.spec.ts
+++ b/libs/angular/src/auth/components/sso.component.spec.ts
@@ -17,10 +17,10 @@ import { SsoLoginServiceAbstraction } from "@bitwarden/common/auth/abstractions/
 import { TwoFactorProviderType } from "@bitwarden/common/auth/enums/two-factor-provider-type";
 import { AuthResult } from "@bitwarden/common/auth/models/domain/auth-result";
 import { ForceSetPasswordReason } from "@bitwarden/common/auth/models/domain/force-set-password-reason";
+import { CryptoFunctionService } from "@bitwarden/common/key-management/crypto/abstractions/crypto-function.service";
 import { InternalMasterPasswordServiceAbstraction } from "@bitwarden/common/key-management/master-password/abstractions/master-password.service.abstraction";
 import { FakeMasterPasswordService } from "@bitwarden/common/key-management/master-password/services/fake-master-password.service";
 import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service";
-import { CryptoFunctionService } from "@bitwarden/common/platform/abstractions/crypto-function.service";
 import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { LogService } from "@bitwarden/common/platform/abstractions/log.service";
--- a/libs/angular/src/auth/components/sso.component.ts
+++ b/libs/angular/src/auth/components/sso.component.ts
@@ -18,9 +18,9 @@ import { SsoLoginServiceAbstraction } from "@bitwarden/common/auth/abstractions/
 import { AuthResult } from "@bitwarden/common/auth/models/domain/auth-result";
 import { ForceSetPasswordReason } from "@bitwarden/common/auth/models/domain/force-set-password-reason";
 import { SsoPreValidateResponse } from "@bitwarden/common/auth/models/response/sso-pre-validate.response";
+import { CryptoFunctionService } from "@bitwarden/common/key-management/crypto/abstractions/crypto-function.service";
 import { InternalMasterPasswordServiceAbstraction } from "@bitwarden/common/key-management/master-password/abstractions/master-password.service.abstraction";
 import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service";
-import { CryptoFunctionService } from "@bitwarden/common/platform/abstractions/crypto-function.service";
 import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { LogService } from "@bitwarden/common/platform/abstractions/log.service";
--- a/libs/angular/src/auth/components/two-factor-options-v1.component.ts
+++ b/libs/angular/src/auth/components/two-factor-options-v1.component.ts
@@ -1,44 +0,0 @@
-import { Directive, EventEmitter, OnInit, Output } from "@angular/core";
-import { Router } from "@angular/router";
-import { firstValueFrom } from "rxjs";
-
-import {
-  TwoFactorProviderDetails,
-  TwoFactorService,
-} from "@bitwarden/common/auth/abstractions/two-factor.service";
-import { TwoFactorProviderType } from "@bitwarden/common/auth/enums/two-factor-provider-type";
-import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service";
-import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
-import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service";
-
-@Directive()
-export class TwoFactorOptionsComponentV1 implements OnInit {
-  @Output() onProviderSelected = new EventEmitter<TwoFactorProviderType>();
-  @Output() onRecoverSelected = new EventEmitter();
-
-  providers: any[] = [];
-
-  constructor(
-    protected twoFactorService: TwoFactorService,
-    protected router: Router,
-    protected i18nService: I18nService,
-    protected platformUtilsService: PlatformUtilsService,
-    protected win: Window,
-    protected environmentService: EnvironmentService,
-  ) {}
-
-  async ngOnInit() {
-    this.providers = await this.twoFactorService.getSupportedProviders(this.win);
-  }
-
-  async choose(p: TwoFactorProviderDetails) {
-    this.onProviderSelected.emit(p.type);
-  }
-
-  async recover() {
-    const env = await firstValueFrom(this.environmentService.environment$);
-    const webVault = env.getWebVaultUrl();
-    this.platformUtilsService.launchUri(webVault + "/#/recover-2fa");
-    this.onRecoverSelected.emit();
-  }
-}
--- a/libs/angular/src/auth/components/two-factor-v1.component.spec.ts
+++ b/libs/angular/src/auth/components/two-factor-v1.component.spec.ts
@@ -1,505 +0,0 @@
-import { Component } from "@angular/core";
-import { ComponentFixture, TestBed } from "@angular/core/testing";
-import { ActivatedRoute, convertToParamMap, Router } from "@angular/router";
-import { mock, MockProxy } from "jest-mock-extended";
-import { BehaviorSubject } from "rxjs";
-
-import { WINDOW } from "@bitwarden/angular/services/injection-tokens";
-import {
-  LoginStrategyServiceAbstraction,
-  LoginEmailServiceAbstraction,
-  FakeKeyConnectorUserDecryptionOption as KeyConnectorUserDecryptionOption,
-  FakeTrustedDeviceUserDecryptionOption as TrustedDeviceUserDecryptionOption,
-  FakeUserDecryptionOptions as UserDecryptionOptions,
-  UserDecryptionOptionsServiceAbstraction,
-} from "@bitwarden/auth/common";
-import { ApiService } from "@bitwarden/common/abstractions/api.service";
-import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
-import { SsoLoginServiceAbstraction } from "@bitwarden/common/auth/abstractions/sso-login.service.abstraction";
-import { TwoFactorService } from "@bitwarden/common/auth/abstractions/two-factor.service";
-import { AuthResult } from "@bitwarden/common/auth/models/domain/auth-result";
-import { ForceSetPasswordReason } from "@bitwarden/common/auth/models/domain/force-set-password-reason";
-import { TokenTwoFactorRequest } from "@bitwarden/common/auth/models/request/identity-token/token-two-factor.request";
-import { InternalMasterPasswordServiceAbstraction } from "@bitwarden/common/key-management/master-password/abstractions/master-password.service.abstraction";
-import { FakeMasterPasswordService } from "@bitwarden/common/key-management/master-password/services/fake-master-password.service";
-import { AppIdService } from "@bitwarden/common/platform/abstractions/app-id.service";
-import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service";
-import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service";
-import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
-import { LogService } from "@bitwarden/common/platform/abstractions/log.service";
-import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service";
-import { StateService } from "@bitwarden/common/platform/abstractions/state.service";
-import { FakeAccountService, mockAccountServiceWith } from "@bitwarden/common/spec";
-import { UserId } from "@bitwarden/common/types/guid";
-import { ToastService } from "@bitwarden/components";
-
-import { TwoFactorComponentV1 } from "./two-factor-v1.component";
-
-// test component that extends the TwoFactorComponent
-@Component({})
-class TestTwoFactorComponent extends TwoFactorComponentV1 {}
-
-interface TwoFactorComponentProtected {
-  trustedDeviceEncRoute: string;
-  changePasswordRoute: string;
-  forcePasswordResetRoute: string;
-  successRoute: string;
-}
-
-describe("TwoFactorComponent", () => {
-  let component: TestTwoFactorComponent;
-  let _component: TwoFactorComponentProtected;
-
-  let fixture: ComponentFixture<TestTwoFactorComponent>;
-  const userId = "userId" as UserId;
-
-  // Mock Services
-  let mockLoginStrategyService: MockProxy<LoginStrategyServiceAbstraction>;
-  let mockRouter: MockProxy<Router>;
-  let mockI18nService: MockProxy<I18nService>;
-  let mockApiService: MockProxy<ApiService>;
-  let mockPlatformUtilsService: MockProxy<PlatformUtilsService>;
-  let mockWin: MockProxy<Window>;
-  let mockEnvironmentService: MockProxy<EnvironmentService>;
-  let mockStateService: MockProxy<StateService>;
-  let mockLogService: MockProxy<LogService>;
-  let mockTwoFactorService: MockProxy<TwoFactorService>;
-  let mockAppIdService: MockProxy<AppIdService>;
-  let mockLoginEmailService: MockProxy<LoginEmailServiceAbstraction>;
-  let mockUserDecryptionOptionsService: MockProxy<UserDecryptionOptionsServiceAbstraction>;
-  let mockSsoLoginService: MockProxy<SsoLoginServiceAbstraction>;
-  let mockConfigService: MockProxy<ConfigService>;
-  let mockMasterPasswordService: FakeMasterPasswordService;
-  let mockAccountService: FakeAccountService;
-  let mockToastService: MockProxy<ToastService>;
-
-  let mockUserDecryptionOpts: {
-    noMasterPassword: UserDecryptionOptions;
-    withMasterPassword: UserDecryptionOptions;
-    withMasterPasswordAndTrustedDevice: UserDecryptionOptions;
-    withMasterPasswordAndTrustedDeviceWithManageResetPassword: UserDecryptionOptions;
-    withMasterPasswordAndKeyConnector: UserDecryptionOptions;
-    noMasterPasswordWithTrustedDevice: UserDecryptionOptions;
-    noMasterPasswordWithTrustedDeviceWithManageResetPassword: UserDecryptionOptions;
-    noMasterPasswordWithKeyConnector: UserDecryptionOptions;
-  };
-
-  let selectedUserDecryptionOptions: BehaviorSubject<UserDecryptionOptions>;
-  let authenticationSessionTimeoutSubject: BehaviorSubject<boolean>;
-
-  beforeEach(() => {
-    authenticationSessionTimeoutSubject = new BehaviorSubject<boolean>(false);
-    mockLoginStrategyService = mock<LoginStrategyServiceAbstraction>();
-    mockLoginStrategyService.authenticationSessionTimeout$ = authenticationSessionTimeoutSubject;
-    mockRouter = mock<Router>();
-    mockI18nService = mock<I18nService>();
-    mockApiService = mock<ApiService>();
-    mockPlatformUtilsService = mock<PlatformUtilsService>();
-    mockWin = mock<Window>();
-    mockEnvironmentService = mock<EnvironmentService>();
-    mockStateService = mock<StateService>();
-    mockLogService = mock<LogService>();
-    mockTwoFactorService = mock<TwoFactorService>();
-    mockAppIdService = mock<AppIdService>();
-    mockLoginEmailService = mock<LoginEmailServiceAbstraction>();
-    mockUserDecryptionOptionsService = mock<UserDecryptionOptionsServiceAbstraction>();
-    mockSsoLoginService = mock<SsoLoginServiceAbstraction>();
-    mockConfigService = mock<ConfigService>();
-    mockAccountService = mockAccountServiceWith(userId);
-    mockToastService = mock<ToastService>();
-    mockMasterPasswordService = new FakeMasterPasswordService();
-
-    mockUserDecryptionOpts = {
-      noMasterPassword: new UserDecryptionOptions({
-        hasMasterPassword: false,
-        trustedDeviceOption: undefined,
-        keyConnectorOption: undefined,
-      }),
-      withMasterPassword: new UserDecryptionOptions({
-        hasMasterPassword: true,
-        trustedDeviceOption: undefined,
-        keyConnectorOption: undefined,
-      }),
-      withMasterPasswordAndTrustedDevice: new UserDecryptionOptions({
-        hasMasterPassword: true,
-        trustedDeviceOption: new TrustedDeviceUserDecryptionOption(true, false, false, false),
-        keyConnectorOption: undefined,
-      }),
-      withMasterPasswordAndTrustedDeviceWithManageResetPassword: new UserDecryptionOptions({
-        hasMasterPassword: true,
-        trustedDeviceOption: new TrustedDeviceUserDecryptionOption(true, false, true, false),
-        keyConnectorOption: undefined,
-      }),
-      withMasterPasswordAndKeyConnector: new UserDecryptionOptions({
-        hasMasterPassword: true,
-        trustedDeviceOption: undefined,
-        keyConnectorOption: new KeyConnectorUserDecryptionOption("http://example.com"),
-      }),
-      noMasterPasswordWithTrustedDevice: new UserDecryptionOptions({
-        hasMasterPassword: false,
-        trustedDeviceOption: new TrustedDeviceUserDecryptionOption(true, false, false, false),
-        keyConnectorOption: undefined,
-      }),
-      noMasterPasswordWithTrustedDeviceWithManageResetPassword: new UserDecryptionOptions({
-        hasMasterPassword: false,
-        trustedDeviceOption: new TrustedDeviceUserDecryptionOption(true, false, true, false),
-        keyConnectorOption: undefined,
-      }),
-      noMasterPasswordWithKeyConnector: new UserDecryptionOptions({
-        hasMasterPassword: false,
-        trustedDeviceOption: undefined,
-        keyConnectorOption: new KeyConnectorUserDecryptionOption("http://example.com"),
-      }),
-    };
-
-    selectedUserDecryptionOptions = new BehaviorSubject<UserDecryptionOptions>(
-      mockUserDecryptionOpts.withMasterPassword,
-    );
-    mockUserDecryptionOptionsService.userDecryptionOptions$ = selectedUserDecryptionOptions;
-
-    TestBed.configureTestingModule({
-      declarations: [TestTwoFactorComponent],
-      providers: [
-        { provide: LoginStrategyServiceAbstraction, useValue: mockLoginStrategyService },
-        { provide: Router, useValue: mockRouter },
-        { provide: I18nService, useValue: mockI18nService },
-        { provide: ApiService, useValue: mockApiService },
-        { provide: PlatformUtilsService, useValue: mockPlatformUtilsService },
-        { provide: WINDOW, useValue: mockWin },
-        { provide: EnvironmentService, useValue: mockEnvironmentService },
-        { provide: StateService, useValue: mockStateService },
-        {
-          provide: ActivatedRoute,
-          useValue: {
-            snapshot: {
-              // Default to standard 2FA flow - not SSO + 2FA
-              queryParamMap: convertToParamMap({ sso: "false" }),
-            },
-          },
-        },
-        { provide: LogService, useValue: mockLogService },
-        { provide: TwoFactorService, useValue: mockTwoFactorService },
-        { provide: AppIdService, useValue: mockAppIdService },
-        { provide: LoginEmailServiceAbstraction, useValue: mockLoginEmailService },
-        {
-          provide: UserDecryptionOptionsServiceAbstraction,
-          useValue: mockUserDecryptionOptionsService,
-        },
-        { provide: SsoLoginServiceAbstraction, useValue: mockSsoLoginService },
-        { provide: ConfigService, useValue: mockConfigService },
-        { provide: InternalMasterPasswordServiceAbstraction, useValue: mockMasterPasswordService },
-        { provide: AccountService, useValue: mockAccountService },
-        { provide: ToastService, useValue: mockToastService },
-      ],
-    });
-
-    fixture = TestBed.createComponent(TestTwoFactorComponent);
-    component = fixture.componentInstance;
-    _component = component as any;
-  });
-
-  afterEach(() => {
-    // Reset all mocks after each test
-    jest.resetAllMocks();
-  });
-
-  it("should create", () => {
-    expect(component).toBeTruthy();
-  });
-
-  // Shared tests
-  const testChangePasswordOnSuccessfulLogin = () => {
-    it("navigates to the component's defined change password route when user doesn't have a MP and key connector isn't enabled", async () => {
-      // Act
-      await component.doSubmit();
-
-      // Assert
-      expect(mockRouter.navigate).toHaveBeenCalledTimes(1);
-      expect(mockRouter.navigate).toHaveBeenCalledWith([_component.changePasswordRoute], {
-        queryParams: {
-          identifier: component.orgIdentifier,
-        },
-      });
-    });
-  };
-
-  const testForceResetOnSuccessfulLogin = (reasonString: string) => {
-    it(`navigates to the component's defined forcePasswordResetRoute route when response.forcePasswordReset is ${reasonString}`, async () => {
-      // Act
-      await component.doSubmit();
-
-      // expect(mockRouter.navigate).toHaveBeenCalledTimes(1);
-      expect(mockRouter.navigate).toHaveBeenCalledWith([_component.forcePasswordResetRoute], {
-        queryParams: {
-          identifier: component.orgIdentifier,
-        },
-      });
-    });
-  };
-
-  describe("Standard 2FA scenarios", () => {
-    describe("doSubmit", () => {
-      const token = "testToken";
-      const remember = false;
-      const captchaToken = "testCaptchaToken";
-
-      beforeEach(() => {
-        component.token = token;
-        component.remember = remember;
-        component.captchaToken = captchaToken;
-
-        selectedUserDecryptionOptions.next(mockUserDecryptionOpts.withMasterPassword);
-      });
-
-      it("calls authService.logInTwoFactor with correct parameters when form is submitted", async () => {
-        // Arrange
-        mockLoginStrategyService.logInTwoFactor.mockResolvedValue(new AuthResult());
-
-        // Act
-        await component.doSubmit();
-
-        // Assert
-        expect(mockLoginStrategyService.logInTwoFactor).toHaveBeenCalledWith(
-          new TokenTwoFactorRequest(component.selectedProviderType, token, remember),
-          captchaToken,
-        );
-      });
-
-      it("should return when handleCaptchaRequired returns true", async () => {
-        // Arrange
-        const captchaSiteKey = "testCaptchaSiteKey";
-        const authResult = new AuthResult();
-        authResult.captchaSiteKey = captchaSiteKey;
-
-        mockLoginStrategyService.logInTwoFactor.mockResolvedValue(authResult);
-
-        // Note: the any casts are required b/c typescript cant recognize that
-        // handleCaptureRequired is a method on TwoFactorComponent b/c it is inherited
-        // from the CaptchaProtectedComponent
-        const handleCaptchaRequiredSpy = jest
-          .spyOn<any, any>(component, "handleCaptchaRequired")
-          .mockReturnValue(true);
-
-        // Act
-        const result = await component.doSubmit();
-
-        // Assert
-        expect(handleCaptchaRequiredSpy).toHaveBeenCalled();
-        expect(result).toBeUndefined();
-      });
-
-      it("calls onSuccessfulLogin when defined", async () => {
-        // Arrange
-        component.onSuccessfulLogin = jest.fn().mockResolvedValue(undefined);
-        mockLoginStrategyService.logInTwoFactor.mockResolvedValue(new AuthResult());
-
-        // Act
-        await component.doSubmit();
-
-        // Assert
-        expect(component.onSuccessfulLogin).toHaveBeenCalled();
-      });
-
-      it("calls loginEmailService.clearValues() when login is successful", async () => {
-        // Arrange
-        mockLoginStrategyService.logInTwoFactor.mockResolvedValue(new AuthResult());
-        // spy on loginEmailService.clearValues
-        const clearValuesSpy = jest.spyOn(mockLoginEmailService, "clearValues");
-
-        // Act
-        await component.doSubmit();
-
-        // Assert
-        expect(clearValuesSpy).toHaveBeenCalled();
-      });
-
-      describe("Set Master Password scenarios", () => {
-        beforeEach(() => {
-          const authResult = new AuthResult();
-          mockLoginStrategyService.logInTwoFactor.mockResolvedValue(authResult);
-        });
-
-        describe("Given user needs to set a master password", () => {
-          beforeEach(() => {
-            // Only need to test the case where the user has no master password to test the primary change mp flow here
-            selectedUserDecryptionOptions.next(mockUserDecryptionOpts.noMasterPassword);
-          });
-
-          testChangePasswordOnSuccessfulLogin();
-        });
-
-        it("does not navigate to the change password route when the user has key connector even if user has no master password", async () => {
-          selectedUserDecryptionOptions.next(
-            mockUserDecryptionOpts.noMasterPasswordWithKeyConnector,
-          );
-
-          await component.doSubmit();
-
-          expect(mockRouter.navigate).not.toHaveBeenCalledWith([_component.changePasswordRoute], {
-            queryParams: {
-              identifier: component.orgIdentifier,
-            },
-          });
-        });
-      });
-
-      describe("Force Master Password Reset scenarios", () => {
-        [
-          ForceSetPasswordReason.AdminForcePasswordReset,
-          ForceSetPasswordReason.WeakMasterPassword,
-        ].forEach((forceResetPasswordReason) => {
-          const reasonString = ForceSetPasswordReason[forceResetPasswordReason];
-
-          beforeEach(() => {
-            // use standard user with MP because this test is not concerned with password reset.
-            selectedUserDecryptionOptions.next(mockUserDecryptionOpts.withMasterPassword);
-
-            const authResult = new AuthResult();
-            authResult.forcePasswordReset = forceResetPasswordReason;
-            mockLoginStrategyService.logInTwoFactor.mockResolvedValue(authResult);
-          });
-
-          testForceResetOnSuccessfulLogin(reasonString);
-        });
-      });
-
-      it("calls onSuccessfulLoginNavigate when the callback is defined", async () => {
-        // Arrange
-        component.onSuccessfulLoginNavigate = jest.fn().mockResolvedValue(undefined);
-        mockLoginStrategyService.logInTwoFactor.mockResolvedValue(new AuthResult());
-
-        // Act
-        await component.doSubmit();
-
-        // Assert
-        expect(component.onSuccessfulLoginNavigate).toHaveBeenCalled();
-      });
-
-      it("navigates to the component's defined success route when the login is successful and onSuccessfulLoginNavigate is undefined", async () => {
-        mockLoginStrategyService.logInTwoFactor.mockResolvedValue(new AuthResult());
-
-        // Act
-        await component.doSubmit();
-
-        // Assert
-        expect(component.onSuccessfulLoginNavigate).not.toBeDefined();
-
-        expect(mockRouter.navigate).toHaveBeenCalledTimes(1);
-        expect(mockRouter.navigate).toHaveBeenCalledWith([_component.successRoute], undefined);
-      });
-    });
-  });
-
-  describe("SSO > 2FA scenarios", () => {
-    beforeEach(() => {
-      const mockActivatedRoute = TestBed.inject(ActivatedRoute);
-      mockActivatedRoute.snapshot.queryParamMap.get = jest.fn().mockReturnValue("true");
-    });
-
-    describe("doSubmit", () => {
-      const token = "testToken";
-      const remember = false;
-      const captchaToken = "testCaptchaToken";
-
-      beforeEach(() => {
-        component.token = token;
-        component.remember = remember;
-        component.captchaToken = captchaToken;
-      });
-
-      describe("Trusted Device Encryption scenarios", () => {
-        beforeEach(() => {
-          mockConfigService.getFeatureFlag.mockResolvedValue(true);
-        });
-
-        describe("Given Trusted Device Encryption is enabled and user needs to set a master password", () => {
-          beforeEach(() => {
-            selectedUserDecryptionOptions.next(
-              mockUserDecryptionOpts.noMasterPasswordWithTrustedDeviceWithManageResetPassword,
-            );
-
-            const authResult = new AuthResult();
-            mockLoginStrategyService.logInTwoFactor.mockResolvedValue(authResult);
-          });
-
-          it("navigates to the component's defined trusted device encryption route and sets correct flag when user doesn't have a MP and key connector isn't enabled", async () => {
-            // Act
-            await component.doSubmit();
-
-            // Assert
-            expect(mockMasterPasswordService.mock.setForceSetPasswordReason).toHaveBeenCalledWith(
-              ForceSetPasswordReason.TdeUserWithoutPasswordHasPasswordResetPermission,
-              userId,
-            );
-
-            expect(mockRouter.navigate).toHaveBeenCalledTimes(1);
-            expect(mockRouter.navigate).toHaveBeenCalledWith(
-              [_component.trustedDeviceEncRoute],
-              undefined,
-            );
-          });
-        });
-
-        describe("Given Trusted Device Encryption is enabled, user doesn't need to set a MP, and forcePasswordReset is required", () => {
-          [
-            ForceSetPasswordReason.AdminForcePasswordReset,
-            ForceSetPasswordReason.WeakMasterPassword,
-          ].forEach((forceResetPasswordReason) => {
-            const reasonString = ForceSetPasswordReason[forceResetPasswordReason];
-
-            beforeEach(() => {
-              // use standard user with MP because this test is not concerned with password reset.
-              selectedUserDecryptionOptions.next(
-                mockUserDecryptionOpts.withMasterPasswordAndTrustedDevice,
-              );
-
-              const authResult = new AuthResult();
-              authResult.forcePasswordReset = forceResetPasswordReason;
-              mockLoginStrategyService.logInTwoFactor.mockResolvedValue(authResult);
-            });
-
-            testForceResetOnSuccessfulLogin(reasonString);
-          });
-        });
-
-        describe("Given Trusted Device Encryption is enabled, user doesn't need to set a MP, and forcePasswordReset is not required", () => {
-          let authResult;
-          beforeEach(() => {
-            selectedUserDecryptionOptions.next(
-              mockUserDecryptionOpts.withMasterPasswordAndTrustedDevice,
-            );
-
-            authResult = new AuthResult();
-            authResult.forcePasswordReset = ForceSetPasswordReason.None;
-            mockLoginStrategyService.logInTwoFactor.mockResolvedValue(authResult);
-          });
-
-          it("navigates to the component's defined trusted device encryption route when login is successful and onSuccessfulLoginTdeNavigate is undefined", async () => {
-            await component.doSubmit();
-
-            expect(mockRouter.navigate).toHaveBeenCalledTimes(1);
-            expect(mockRouter.navigate).toHaveBeenCalledWith(
-              [_component.trustedDeviceEncRoute],
-              undefined,
-            );
-          });
-
-          it("calls onSuccessfulLoginTdeNavigate instead of router.navigate when the callback is defined", async () => {
-            component.onSuccessfulLoginTdeNavigate = jest.fn().mockResolvedValue(undefined);
-
-            await component.doSubmit();
-
-            expect(mockRouter.navigate).not.toHaveBeenCalled();
-            expect(component.onSuccessfulLoginTdeNavigate).toHaveBeenCalled();
-          });
-        });
-      });
-    });
-  });
-
-  it("navigates to the timeout route when timeout expires", async () => {
-    authenticationSessionTimeoutSubject.next(true);
-
-    expect(mockRouter.navigate).toHaveBeenCalledWith(["authentication-timeout"]);
-  });
-});
--- a/libs/angular/src/auth/components/two-factor-v1.component.ts
+++ b/libs/angular/src/auth/components/two-factor-v1.component.ts
@@ -1,514 +0,0 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
-import { Directive, Inject, OnInit, OnDestroy } from "@angular/core";
-import { takeUntilDestroyed } from "@angular/core/rxjs-interop";
-import { ActivatedRoute, NavigationExtras, Router } from "@angular/router";
-import { firstValueFrom } from "rxjs";
-import { first } from "rxjs/operators";
-
-import { WINDOW } from "@bitwarden/angular/services/injection-tokens";
-import {
-  LoginStrategyServiceAbstraction,
-  LoginEmailServiceAbstraction,
-  TrustedDeviceUserDecryptionOption,
-  UserDecryptionOptions,
-  UserDecryptionOptionsServiceAbstraction,
-} from "@bitwarden/auth/common";
-import { ApiService } from "@bitwarden/common/abstractions/api.service";
-import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
-import { SsoLoginServiceAbstraction } from "@bitwarden/common/auth/abstractions/sso-login.service.abstraction";
-import { TwoFactorService } from "@bitwarden/common/auth/abstractions/two-factor.service";
-import { AuthenticationType } from "@bitwarden/common/auth/enums/authentication-type";
-import { TwoFactorProviderType } from "@bitwarden/common/auth/enums/two-factor-provider-type";
-import { AuthResult } from "@bitwarden/common/auth/models/domain/auth-result";
-import { ForceSetPasswordReason } from "@bitwarden/common/auth/models/domain/force-set-password-reason";
-import { TokenTwoFactorRequest } from "@bitwarden/common/auth/models/request/identity-token/token-two-factor.request";
-import { TwoFactorEmailRequest } from "@bitwarden/common/auth/models/request/two-factor-email.request";
-import { TwoFactorProviders } from "@bitwarden/common/auth/services/two-factor.service";
-import { WebAuthnIFrame } from "@bitwarden/common/auth/webauthn-iframe";
-import { InternalMasterPasswordServiceAbstraction } from "@bitwarden/common/key-management/master-password/abstractions/master-password.service.abstraction";
-import { AppIdService } from "@bitwarden/common/platform/abstractions/app-id.service";
-import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service";
-import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service";
-import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
-import { LogService } from "@bitwarden/common/platform/abstractions/log.service";
-import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service";
-import { StateService } from "@bitwarden/common/platform/abstractions/state.service";
-import { ToastService } from "@bitwarden/components";
-
-import { CaptchaProtectedComponent } from "./captcha-protected.component";
-
-@Directive()
-export class TwoFactorComponentV1 extends CaptchaProtectedComponent implements OnInit, OnDestroy {
-  token = "";
-  remember = false;
-  webAuthnReady = false;
-  webAuthnNewTab = false;
-  providers = TwoFactorProviders;
-  providerType = TwoFactorProviderType;
-  selectedProviderType: TwoFactorProviderType = TwoFactorProviderType.Authenticator;
-  webAuthnSupported = false;
-  webAuthn: WebAuthnIFrame = null;
-  title = "";
-  twoFactorEmail: string = null;
-  formPromise: Promise<any>;
-  emailPromise: Promise<any>;
-  orgIdentifier: string = null;
-
-  duoFramelessUrl: string = null;
-  duoResultListenerInitialized = false;
-
-  onSuccessfulLogin: () => Promise<void>;
-  onSuccessfulLoginNavigate: () => Promise<void>;
-
-  onSuccessfulLoginTde: () => Promise<void>;
-  onSuccessfulLoginTdeNavigate: () => Promise<void>;
-
-  protected loginRoute = "login";
-
-  protected trustedDeviceEncRoute = "login-initiated";
-  protected changePasswordRoute = "set-password";
-  protected forcePasswordResetRoute = "update-temp-password";
-  protected successRoute = "vault";
-  protected twoFactorTimeoutRoute = "authentication-timeout";
-
-  get isDuoProvider(): boolean {
-    return (
-      this.selectedProviderType === TwoFactorProviderType.Duo ||
-      this.selectedProviderType === TwoFactorProviderType.OrganizationDuo
-    );
-  }
-
-  constructor(
-    protected loginStrategyService: LoginStrategyServiceAbstraction,
-    protected router: Router,
-    protected i18nService: I18nService,
-    protected apiService: ApiService,
-    protected platformUtilsService: PlatformUtilsService,
-    @Inject(WINDOW) protected win: Window,
-    protected environmentService: EnvironmentService,
-    protected stateService: StateService,
-    protected route: ActivatedRoute,
-    protected logService: LogService,
-    protected twoFactorService: TwoFactorService,
-    protected appIdService: AppIdService,
-    protected loginEmailService: LoginEmailServiceAbstraction,
-    protected userDecryptionOptionsService: UserDecryptionOptionsServiceAbstraction,
-    protected ssoLoginService: SsoLoginServiceAbstraction,
-    protected configService: ConfigService,
-    protected masterPasswordService: InternalMasterPasswordServiceAbstraction,
-    protected accountService: AccountService,
-    protected toastService: ToastService,
-  ) {
-    super(environmentService, i18nService, platformUtilsService, toastService);
-
-    this.webAuthnSupported = this.platformUtilsService.supportsWebAuthn(win);
-
-    // Add subscription to authenticationSessionTimeout$ and navigate to twoFactorTimeoutRoute if expired
-    this.loginStrategyService.authenticationSessionTimeout$
-      .pipe(takeUntilDestroyed())
-      .subscribe(async (expired) => {
-        if (!expired) {
-          return;
-        }
-
-        try {
-          await this.router.navigate([this.twoFactorTimeoutRoute]);
-        } catch (err) {
-          this.logService.error(`Failed to navigate to ${this.twoFactorTimeoutRoute} route`, err);
-        }
-      });
-  }
-
-  async ngOnInit() {
-    if (!(await this.authing()) || (await this.twoFactorService.getProviders()) == null) {
-      // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      this.router.navigate([this.loginRoute]);
-      return;
-    }
-
-    this.route.queryParams.pipe(first()).subscribe((qParams) => {
-      if (qParams.identifier != null) {
-        this.orgIdentifier = qParams.identifier;
-      }
-    });
-
-    if (await this.needsLock()) {
-      this.successRoute = "lock";
-    }
-
-    if (this.win != null && this.webAuthnSupported) {
-      const env = await firstValueFrom(this.environmentService.environment$);
-      const webVaultUrl = env.getWebVaultUrl();
-      this.webAuthn = new WebAuthnIFrame(
-        this.win,
-        webVaultUrl,
-        this.webAuthnNewTab,
-        this.platformUtilsService,
-        this.i18nService,
-        (token: string) => {
-          this.token = token;
-          // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-          // eslint-disable-next-line @typescript-eslint/no-floating-promises
-          this.submit();
-        },
-        (error: string) => {
-          this.toastService.showToast({
-            variant: "error",
-            title: this.i18nService.t("errorOccurred"),
-            message: this.i18nService.t("webauthnCancelOrTimeout"),
-          });
-        },
-        (info: string) => {
-          if (info === "ready") {
-            this.webAuthnReady = true;
-          }
-        },
-      );
-    }
-
-    this.selectedProviderType = await this.twoFactorService.getDefaultProvider(
-      this.webAuthnSupported,
-    );
-    await this.init();
-  }
-
-  ngOnDestroy(): void {
-    this.cleanupWebAuthn();
-    this.webAuthn = null;
-  }
-
-  async init() {
-    if (this.selectedProviderType == null) {
-      this.title = this.i18nService.t("loginUnavailable");
-      return;
-    }
-
-    this.cleanupWebAuthn();
-    this.title = (TwoFactorProviders as any)[this.selectedProviderType].name;
-    const providerData = await this.twoFactorService.getProviders().then((providers) => {
-      return providers.get(this.selectedProviderType);
-    });
-    switch (this.selectedProviderType) {
-      case TwoFactorProviderType.WebAuthn:
-        if (!this.webAuthnNewTab) {
-          setTimeout(async () => {
-            await this.authWebAuthn();
-          }, 500);
-        }
-        break;
-      case TwoFactorProviderType.Duo:
-      case TwoFactorProviderType.OrganizationDuo:
-        // Setup listener for duo-redirect.ts connector to send back the code
-        if (!this.duoResultListenerInitialized) {
-          // setup client specific duo result listener
-          this.setupDuoResultListener();
-          this.duoResultListenerInitialized = true;
-        }
-        // flow must be launched by user so they can choose to remember the device or not.
-        this.duoFramelessUrl = providerData.AuthUrl;
-        break;
-      case TwoFactorProviderType.Email:
-        this.twoFactorEmail = providerData.Email;
-        if ((await this.twoFactorService.getProviders()).size > 1) {
-          await this.sendEmail(false);
-        }
-        break;
-      default:
-        break;
-    }
-  }
-
-  async submit() {
-    await this.setupCaptcha();
-
-    if (this.token == null || this.token === "") {
-      this.toastService.showToast({
-        variant: "error",
-        title: this.i18nService.t("errorOccurred"),
-        message: this.i18nService.t("verificationCodeRequired"),
-      });
-      return;
-    }
-
-    if (this.selectedProviderType === TwoFactorProviderType.WebAuthn) {
-      if (this.webAuthn != null) {
-        this.webAuthn.stop();
-      } else {
-        return;
-      }
-    } else if (
-      this.selectedProviderType === TwoFactorProviderType.Email ||
-      this.selectedProviderType === TwoFactorProviderType.Authenticator
-    ) {
-      this.token = this.token.replace(" ", "").trim();
-    }
-
-    await this.doSubmit();
-    if (this.selectedProviderType === TwoFactorProviderType.WebAuthn && this.webAuthn != null) {
-      this.webAuthn.start();
-    }
-  }
-
-  async doSubmit() {
-    this.formPromise = this.loginStrategyService.logInTwoFactor(
-      new TokenTwoFactorRequest(this.selectedProviderType, this.token, this.remember),
-      this.captchaToken,
-    );
-    const authResult: AuthResult = await this.formPromise;
-
-    await this.handleLoginResponse(authResult);
-  }
-
-  protected handleMigrateEncryptionKey(result: AuthResult): boolean {
-    if (!result.requiresEncryptionKeyMigration) {
-      return false;
-    }
-
-    this.toastService.showToast({
-      variant: "error",
-      title: this.i18nService.t("errorOccured"),
-      message: this.i18nService.t("encryptionKeyMigrationRequired"),
-    });
-    return true;
-  }
-
-  // Each client will have own implementation
-  protected setupDuoResultListener(): void {}
-
-  private async handleLoginResponse(authResult: AuthResult) {
-    if (this.handleCaptchaRequired(authResult)) {
-      return;
-    } else if (this.handleMigrateEncryptionKey(authResult)) {
-      return;
-    }
-
-    // Save off the OrgSsoIdentifier for use in the TDE flows
-    // - TDE login decryption options component
-    // - Browser SSO on extension open
-    const userId = (await firstValueFrom(this.accountService.activeAccount$))?.id;
-    await this.ssoLoginService.setActiveUserOrganizationSsoIdentifier(this.orgIdentifier, userId);
-    this.loginEmailService.clearValues();
-
-    // note: this flow affects both TDE & standard users
-    if (this.isForcePasswordResetRequired(authResult)) {
-      return await this.handleForcePasswordReset(this.orgIdentifier);
-    }
-
-    const userDecryptionOpts = await firstValueFrom(
-      this.userDecryptionOptionsService.userDecryptionOptions$,
-    );
-
-    const tdeEnabled = await this.isTrustedDeviceEncEnabled(userDecryptionOpts.trustedDeviceOption);
-
-    if (tdeEnabled) {
-      return await this.handleTrustedDeviceEncryptionEnabled(
-        authResult,
-        this.orgIdentifier,
-        userDecryptionOpts,
-      );
-    }
-
-    // User must set password if they don't have one and they aren't using either TDE or key connector.
-    const requireSetPassword =
-      !userDecryptionOpts.hasMasterPassword && userDecryptionOpts.keyConnectorOption === undefined;
-
-    if (requireSetPassword || authResult.resetMasterPassword) {
-      // Change implies going no password -> password in this case
-      return await this.handleChangePasswordRequired(this.orgIdentifier);
-    }
-
-    return await this.handleSuccessfulLogin();
-  }
-
-  private async isTrustedDeviceEncEnabled(
-    trustedDeviceOption: TrustedDeviceUserDecryptionOption,
-  ): Promise<boolean> {
-    const ssoTo2faFlowActive = this.route.snapshot.queryParamMap.get("sso") === "true";
-
-    return ssoTo2faFlowActive && trustedDeviceOption !== undefined;
-  }
-
-  private async handleTrustedDeviceEncryptionEnabled(
-    authResult: AuthResult,
-    orgIdentifier: string,
-    userDecryptionOpts: UserDecryptionOptions,
-  ): Promise<void> {
-    // If user doesn't have a MP, but has reset password permission, they must set a MP
-    if (
-      !userDecryptionOpts.hasMasterPassword &&
-      userDecryptionOpts.trustedDeviceOption.hasManageResetPasswordPermission
-    ) {
-      // Set flag so that auth guard can redirect to set password screen after decryption (trusted or untrusted device)
-      // Note: we cannot directly navigate to the set password screen in this scenario as we are in a pre-decryption state, and
-      // if you try to set a new MP before decrypting, you will invalidate the user's data by making a new user key.
-      const userId = (await firstValueFrom(this.accountService.activeAccount$))?.id;
-      await this.masterPasswordService.setForceSetPasswordReason(
-        ForceSetPasswordReason.TdeUserWithoutPasswordHasPasswordResetPermission,
-        userId,
-      );
-    }
-
-    if (this.onSuccessfulLoginTde != null) {
-      // Note: awaiting this will currently cause a hang on desktop & browser as they will wait for a full sync to complete
-      // before navigating to the success route.
-      // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      this.onSuccessfulLoginTde();
-    }
-
-    // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    this.navigateViaCallbackOrRoute(
-      this.onSuccessfulLoginTdeNavigate,
-      // Navigate to TDE page (if user was on trusted device and TDE has decrypted
-      //  their user key, the login-initiated guard will redirect them to the vault)
-      [this.trustedDeviceEncRoute],
-    );
-  }
-
-  private async handleChangePasswordRequired(orgIdentifier: string) {
-    await this.router.navigate([this.changePasswordRoute], {
-      queryParams: {
-        identifier: orgIdentifier,
-      },
-    });
-  }
-
-  /**
-   * Determines if a user needs to reset their password based on certain conditions.
-   * Users can be forced to reset their password via an admin or org policy disallowing weak passwords.
-   * Note: this is different from the SSO component login flow as a user can
-   * login with MP and then have to pass 2FA to finish login and we can actually
-   * evaluate if they have a weak password at that time.
-   *
-   * @param {AuthResult} authResult - The authentication result.
-   * @returns {boolean} Returns true if a password reset is required, false otherwise.
-   */
-  private isForcePasswordResetRequired(authResult: AuthResult): boolean {
-    const forceResetReasons = [
-      ForceSetPasswordReason.AdminForcePasswordReset,
-      ForceSetPasswordReason.WeakMasterPassword,
-    ];
-
-    return forceResetReasons.includes(authResult.forcePasswordReset);
-  }
-
-  private async handleForcePasswordReset(orgIdentifier: string) {
-    // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    this.router.navigate([this.forcePasswordResetRoute], {
-      queryParams: {
-        identifier: orgIdentifier,
-      },
-    });
-  }
-
-  private async handleSuccessfulLogin() {
-    if (this.onSuccessfulLogin != null) {
-      // Note: awaiting this will currently cause a hang on desktop & browser as they will wait for a full sync to complete
-      // before navigating to the success route.
-      // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      this.onSuccessfulLogin();
-    }
-    await this.navigateViaCallbackOrRoute(this.onSuccessfulLoginNavigate, [this.successRoute]);
-  }
-
-  private async navigateViaCallbackOrRoute(
-    callback: () => Promise<unknown>,
-    commands: unknown[],
-    extras?: NavigationExtras,
-  ): Promise<void> {
-    if (callback) {
-      await callback();
-    } else {
-      await this.router.navigate(commands, extras);
-    }
-  }
-
-  async sendEmail(doToast: boolean) {
-    if (this.selectedProviderType !== TwoFactorProviderType.Email) {
-      return;
-    }
-
-    if (this.emailPromise != null) {
-      return;
-    }
-
-    if ((await this.loginStrategyService.getEmail()) == null) {
-      this.toastService.showToast({
-        variant: "error",
-        title: this.i18nService.t("errorOccurred"),
-        message: this.i18nService.t("sessionTimeout"),
-      });
-      return;
-    }
-
-    try {
-      const request = new TwoFactorEmailRequest();
-      request.email = await this.loginStrategyService.getEmail();
-      request.masterPasswordHash = await this.loginStrategyService.getMasterPasswordHash();
-      request.ssoEmail2FaSessionToken =
-        await this.loginStrategyService.getSsoEmail2FaSessionToken();
-      request.deviceIdentifier = await this.appIdService.getAppId();
-      request.authRequestAccessCode = await this.loginStrategyService.getAccessCode();
-      request.authRequestId = await this.loginStrategyService.getAuthRequestId();
-      this.emailPromise = this.apiService.postTwoFactorEmail(request);
-      await this.emailPromise;
-      if (doToast) {
-        this.toastService.showToast({
-          variant: "success",
-          title: null,
-          message: this.i18nService.t("verificationCodeEmailSent", this.twoFactorEmail),
-        });
-      }
-    } catch (e) {
-      this.logService.error(e);
-    }
-
-    this.emailPromise = null;
-  }
-
-  async authWebAuthn() {
-    const providerData = await this.twoFactorService.getProviders().then((providers) => {
-      return providers.get(this.selectedProviderType);
-    });
-
-    if (!this.webAuthnSupported || this.webAuthn == null) {
-      return;
-    }
-
-    this.webAuthn.init(providerData);
-  }
-
-  private cleanupWebAuthn() {
-    if (this.webAuthn != null) {
-      this.webAuthn.stop();
-      this.webAuthn.cleanup();
-    }
-  }
-
-  private async authing(): Promise<boolean> {
-    return (await firstValueFrom(this.loginStrategyService.currentAuthType$)) !== null;
-  }
-
-  private async needsLock(): Promise<boolean> {
-    const authType = await firstValueFrom(this.loginStrategyService.currentAuthType$);
-    return authType == AuthenticationType.Sso || authType == AuthenticationType.UserApiKey;
-  }
-
-  async launchDuoFrameless() {
-    if (this.duoFramelessUrl === null) {
-      this.toastService.showToast({
-        variant: "error",
-        title: null,
-        message: this.i18nService.t("duoHealthCheckResultsInNullAuthUrlError"),
-      });
-      return;
-    }
-
-    this.platformUtilsService.launchUri(this.duoFramelessUrl);
-  }
-}
--- a/libs/angular/src/auth/functions/unauth-ui-refresh-route-swap.ts
+++ b/libs/angular/src/auth/functions/unauth-ui-refresh-route-swap.ts
@@ -1,36 +0,0 @@
-import { Type, inject } from "@angular/core";
-import { Route, Routes } from "@angular/router";
-
-import { FeatureFlag } from "@bitwarden/common/enums/feature-flag.enum";
-import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service";
-
-import { componentRouteSwap } from "../../utils/component-route-swap";
-
-/**
- * Helper function to swap between two components based on the UnauthenticatedExtensionUIRefresh feature flag.
- * We need this because the auth teams's authenticated UI will be refreshed as part of the MVP but the
- * unauthenticated UIs will not necessarily make the cut.
- * Note: Even though this is primarily an extension refresh initiative, this will be used across clients
- * as we are consolidating the unauthenticated UIs into single libs/auth components which affects all clients.
- * @param defaultComponent - The current non-refreshed component to render.
- * @param refreshedComponent - The new refreshed component to render.
- * @param options - The shared route options to apply to both components.
- * @param altOptions - The alt route options to apply to the alt component. If not provided, the base options will be used.
- */
-export function unauthUiRefreshSwap(
-  defaultComponent: Type<any>,
-  refreshedComponent: Type<any>,
-  options: Route,
-  altOptions?: Route,
-): Routes {
-  return componentRouteSwap(
-    defaultComponent,
-    refreshedComponent,
-    async () => {
-      const configService = inject(ConfigService);
-      return configService.getFeatureFlag(FeatureFlag.UnauthenticatedExtensionUIRefresh);
-    },
-    options,
-    altOptions,
-  );
-}
--- a/libs/angular/src/auth/validators/inputs-field-match.validator.ts
+++ b/libs/angular/src/auth/validators/inputs-field-match.validator.ts
@@ -1,167 +0,0 @@
-import { AbstractControl, UntypedFormGroup, ValidationErrors, ValidatorFn } from "@angular/forms";
-
-import { FormGroupControls } from "../../platform/abstractions/form-validation-errors.service";
-
-export class InputsFieldMatch {
-  /**
-   *  Check to ensure two fields do not have the same value
-   *
-   * @deprecated Use compareInputs() instead
-   */
-  static validateInputsDoesntMatch(matchTo: string, errorMessage: string): ValidatorFn {
-    return (control: AbstractControl) => {
-      if (control.parent && control.parent.controls) {
-        return control?.value === (control?.parent?.controls as FormGroupControls)[matchTo].value
-          ? {
-              inputsMatchError: {
-                message: errorMessage,
-              },
-            }
-          : null;
-      }
-
-      return null;
-    };
-  }
-
-  //check to ensure two fields have the same value
-  static validateInputsMatch(matchTo: string, errorMessage: string): ValidatorFn {
-    return (control: AbstractControl) => {
-      if (control.parent && control.parent.controls) {
-        return control?.value === (control?.parent?.controls as FormGroupControls)[matchTo].value
-          ? null
-          : {
-              inputsDoesntMatchError: {
-                message: errorMessage,
-              },
-            };
-      }
-
-      return null;
-    };
-  }
-
-  /**
-   * Checks the formGroup if two fields have the same value and validation is controlled from either field
-   *
-   * @deprecated
-   * Use compareInputs() instead.
-   *
-   * For more info on deprecation
-   * - Do not use untyped `options` object in formBuilder.group() {@link https://angular.dev/api/forms/UntypedFormBuilder}
-   * - Use formBuilder.group() overload with AbstractControlOptions type instead {@link https://angular.dev/api/forms/AbstractControlOptions}
-   *
-   * Remove this method after deprecated instances are replaced
-   */
-  static validateFormInputsMatch(field: string, fieldMatchTo: string, errorMessage: string) {
-    return (formGroup: UntypedFormGroup) => {
-      const fieldCtrl = formGroup.controls[field];
-      const fieldMatchToCtrl = formGroup.controls[fieldMatchTo];
-
-      if (fieldCtrl.value !== fieldMatchToCtrl.value) {
-        fieldMatchToCtrl.setErrors({
-          inputsDoesntMatchError: {
-            message: errorMessage,
-          },
-        });
-      } else {
-        fieldMatchToCtrl.setErrors(null);
-      }
-    };
-  }
-
-  /**
-   * Checks whether two form controls do or do not have the same input value (except for empty string values).
-   *
-   * - Validation is controlled from either form control.
-   * - The error message is displayed under controlB by default, but can be set to controlA.
-   *
-   * @param validationGoal Whether you want to verify that the form control input values match or do not match
-   * @param controlNameA The name of the first form control to compare.
-   * @param controlNameB The name of the second form control to compare.
-   * @param errorMessage The error message to display if there is an error. This will probably
-   *                     be an i18n translated string.
-   * @param showErrorOn The control under which you want to display the error (default is controlB).
-   */
-  static compareInputs(
-    validationGoal: "match" | "doNotMatch",
-    controlNameA: string,
-    controlNameB: string,
-    errorMessage: string,
-    showErrorOn: "controlA" | "controlB" = "controlB",
-  ): ValidatorFn {
-    return (control: AbstractControl): ValidationErrors | null => {
-      const controlA = control.get(controlNameA);
-      const controlB = control.get(controlNameB);
-
-      if (!controlA || !controlB) {
-        return null;
-      }
-
-      const controlThatShowsError = showErrorOn === "controlA" ? controlA : controlB;
-
-      // Don't compare empty strings
-      if (controlA.value === "" && controlB.value === "") {
-        return pass();
-      }
-
-      const controlValuesMatch = controlA.value === controlB.value;
-
-      if (validationGoal === "match") {
-        if (controlValuesMatch) {
-          return pass();
-        } else {
-          return fail();
-        }
-      }
-
-      if (validationGoal === "doNotMatch") {
-        if (!controlValuesMatch) {
-          return pass();
-        } else {
-          return fail();
-        }
-      }
-
-      return null; // default return
-
-      function fail() {
-        controlThatShowsError.setErrors({
-          // Preserve any pre-existing errors
-          ...controlThatShowsError.errors,
-          // Add new inputMatchError
-          inputMatchError: {
-            message: errorMessage,
-          },
-        });
-
-        return {
-          inputMatchError: {
-            message: errorMessage,
-          },
-        };
-      }
-
-      function pass(): null {
-        // Get the current errors object
-        const errorsObj = controlThatShowsError?.errors;
-
-        if (errorsObj != null) {
-          // Remove any inputMatchError if it exists, since that is the sole error we are targeting with this validator
-          if (errorsObj?.inputMatchError) {
-            delete errorsObj.inputMatchError;
-          }
-
-          // Check if the errorsObj is now empty
-          const isEmptyObj = Object.keys(errorsObj).length === 0;
-
-          // If the errorsObj is empty, set errors to null, otherwise set the errors to an object of pre-existing errors (other than inputMatchError)
-          controlThatShowsError.setErrors(isEmptyObj ? null : errorsObj);
-        }
-
-        // Return null for this validator
-        return null;
-      }
-    };
-  }
-}
--- a/libs/angular/src/billing/components/add-account-credit-dialog/add-account-credit-dialog.component.ts
+++ b/libs/angular/src/billing/components/add-account-credit-dialog/add-account-credit-dialog.component.ts
@@ -1,6 +1,5 @@
 // FIXME: Update this file to be type safe and remove this and next line
 // @ts-strict-ignore
-import { DIALOG_DATA, DialogConfig, DialogRef } from "@angular/cdk/dialog";
 import { Component, ElementRef, Inject, OnInit, ViewChild } from "@angular/core";
 import { FormControl, FormGroup, Validators } from "@angular/forms";
 import { firstValueFrom, map } from "rxjs";
@@ -16,7 +15,7 @@ import { BitPayInvoiceRequest } from "@bitwarden/common/billing/models/request/b
 import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service";
 import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service";
 import { UserId } from "@bitwarden/common/types/guid";
-import { DialogService } from "@bitwarden/components";
+import { DIALOG_DATA, DialogConfig, DialogRef, DialogService } from "@bitwarden/components";

 export type AddAccountCreditDialogParams = {
  organizationId?: string;
--- a/libs/angular/src/billing/components/invoices/invoices.component.html
+++ b/libs/angular/src/billing/components/invoices/invoices.component.html
@@ -35,7 +35,7 @@
          {{ "open" | i18n | titlecase }}
        </span>
        <span *ngIf="expandedInvoiceStatus === 'unpaid'">
-          <i class="bwi bwi-exclamation-circle tw-text-muted" aria-hidden="true"></i>
+          <i class="bwi bwi-error tw-text-muted" aria-hidden="true"></i>
          {{ "unpaid" | i18n | titlecase }}
        </span>
        <span *ngIf="expandedInvoiceStatus === 'paid'">
--- a/libs/angular/src/billing/components/manage-tax-information/manage-tax-information.component.ts
+++ b/libs/angular/src/billing/components/manage-tax-information/manage-tax-information.component.ts
@@ -77,6 +77,18 @@ export class ManageTaxInformationComponent implements OnInit, OnDestroy {
  }

  async ngOnInit() {
+    this.formGroup.valueChanges.pipe(takeUntil(this.destroy$)).subscribe((values) => {
+      this.taxInformation = {
+        country: values.country,
+        postalCode: values.postalCode,
+        taxId: values.taxId,
+        line1: values.line1,
+        line2: values.line2,
+        city: values.city,
+        state: values.state,
+      };
+    });
+
    if (this.startWith) {
      this.formGroup.controls.country.setValue(this.startWith.country);
      this.formGroup.controls.postalCode.setValue(this.startWith.postalCode);
@@ -95,18 +107,6 @@ export class ManageTaxInformationComponent implements OnInit, OnDestroy {
      }
    }

-    this.formGroup.valueChanges.pipe(takeUntil(this.destroy$)).subscribe((values) => {
-      this.taxInformation = {
-        country: values.country,
-        postalCode: values.postalCode,
-        taxId: values.taxId,
-        line1: values.line1,
-        line2: values.line2,
-        city: values.city,
-        state: values.state,
-      };
-    });
-
    this.formGroup.controls.country.valueChanges
      .pipe(debounceTime(1000), takeUntil(this.destroy$))
      .subscribe((country: string) => {
--- a/libs/angular/src/platform/abstractions/view-cache.service.ts
+++ b/libs/angular/src/platform/abstractions/view-cache.service.ts
@@ -9,7 +9,7 @@ type Deserializer<T> = {
   * @param jsonValue The JSON object representation of your state.
   * @returns The fully typed version of your state.
   */
-  readonly deserializer?: (jsonValue: Jsonify<T>) => T;
+  readonly deserializer?: (jsonValue: Jsonify<T>) => T | null;
 };

 type BaseCacheOptions<T> = {
--- a/libs/angular/src/services/jslib-services.module.ts
+++ b/libs/angular/src/services/jslib-services.module.ts
@@ -4,48 +4,48 @@ import { ErrorHandler, LOCALE_ID, NgModule } from "@angular/core";
 import { Subject } from "rxjs";

 import {
-  OrganizationUserApiService,
-  DefaultOrganizationUserApiService,
  CollectionService,
  DefaultCollectionService,
+  DefaultOrganizationUserApiService,
+  OrganizationUserApiService,
 } from "@bitwarden/admin-console/common";
 import {
-  SetPasswordJitService,
-  DefaultSetPasswordJitService,
-  RegistrationFinishService as RegistrationFinishServiceAbstraction,
-  DefaultRegistrationFinishService,
  AnonLayoutWrapperDataService,
  DefaultAnonLayoutWrapperDataService,
-  LoginComponentService,
+  DefaultLoginApprovalComponentService,
  DefaultLoginComponentService,
-  LoginDecryptionOptionsService,
  DefaultLoginDecryptionOptionsService,
-  TwoFactorAuthComponentService,
+  DefaultRegistrationFinishService,
+  DefaultSetPasswordJitService,
  DefaultTwoFactorAuthComponentService,
  DefaultTwoFactorAuthEmailComponentService,
-  TwoFactorAuthEmailComponentService,
  DefaultTwoFactorAuthWebAuthnComponentService,
+  LoginComponentService,
+  LoginDecryptionOptionsService,
+  RegistrationFinishService as RegistrationFinishServiceAbstraction,
+  SetPasswordJitService,
+  TwoFactorAuthComponentService,
+  TwoFactorAuthEmailComponentService,
  TwoFactorAuthWebAuthnComponentService,
-  DefaultLoginApprovalComponentService,
 } from "@bitwarden/auth/angular";
 import {
-  AuthRequestServiceAbstraction,
-  AuthRequestService,
-  PinServiceAbstraction,
-  PinService,
-  LoginStrategyServiceAbstraction,
-  LoginStrategyService,
-  LoginEmailServiceAbstraction,
-  LoginEmailService,
-  InternalUserDecryptionOptionsServiceAbstraction,
-  UserDecryptionOptionsService,
-  UserDecryptionOptionsServiceAbstraction,
-  LogoutReason,
  AuthRequestApiService,
+  AuthRequestService,
+  AuthRequestServiceAbstraction,
  DefaultAuthRequestApiService,
  DefaultLoginSuccessHandlerService,
-  LoginSuccessHandlerService,
+  InternalUserDecryptionOptionsServiceAbstraction,
  LoginApprovalComponentServiceAbstraction,
+  LoginEmailService,
+  LoginEmailServiceAbstraction,
+  LoginStrategyService,
+  LoginStrategyServiceAbstraction,
+  LoginSuccessHandlerService,
+  LogoutReason,
+  PinService,
+  PinServiceAbstraction,
+  UserDecryptionOptionsService,
+  UserDecryptionOptionsServiceAbstraction,
 } from "@bitwarden/auth/common";
 import { ApiService as ApiServiceAbstraction } from "@bitwarden/common/abstractions/api.service";
 import { AuditService as AuditServiceAbstraction } from "@bitwarden/common/abstractions/audit.service";
@@ -75,12 +75,13 @@ import { OrganizationApiService } from "@bitwarden/common/admin-console/services
 import { OrgDomainApiService } from "@bitwarden/common/admin-console/services/organization-domain/org-domain-api.service";
 import { OrgDomainService } from "@bitwarden/common/admin-console/services/organization-domain/org-domain.service";
 import { DefaultOrganizationManagementPreferencesService } from "@bitwarden/common/admin-console/services/organization-management-preferences/default-organization-management-preferences.service";
+import { DefaultPolicyService } from "@bitwarden/common/admin-console/services/policy/default-policy.service";
 import { PolicyApiService } from "@bitwarden/common/admin-console/services/policy/policy-api.service";
-import { PolicyService } from "@bitwarden/common/admin-console/services/policy/policy.service";
 import { ProviderApiService } from "@bitwarden/common/admin-console/services/provider/provider-api.service";
 import { ProviderService } from "@bitwarden/common/admin-console/services/provider.service";
 import { AccountApiService as AccountApiServiceAbstraction } from "@bitwarden/common/auth/abstractions/account-api.service";
 import {
+  AccountService,
  AccountService as AccountServiceAbstraction,
  InternalAccountService,
 } from "@bitwarden/common/auth/abstractions/account.service";
@@ -117,16 +118,16 @@ import { WebAuthnLoginApiService } from "@bitwarden/common/auth/services/webauth
 import { WebAuthnLoginPrfKeyService } from "@bitwarden/common/auth/services/webauthn-login/webauthn-login-prf-key.service";
 import { WebAuthnLoginService } from "@bitwarden/common/auth/services/webauthn-login/webauthn-login.service";
 import {
-  AutofillSettingsServiceAbstraction,
  AutofillSettingsService,
+  AutofillSettingsServiceAbstraction,
 } from "@bitwarden/common/autofill/services/autofill-settings.service";
 import {
-  BadgeSettingsServiceAbstraction,
  BadgeSettingsService,
+  BadgeSettingsServiceAbstraction,
 } from "@bitwarden/common/autofill/services/badge-settings.service";
 import {
-  DomainSettingsService,
  DefaultDomainSettingsService,
+  DomainSettingsService,
 } from "@bitwarden/common/autofill/services/domain-settings.service";
 import {
  BillingApiServiceAbstraction,
@@ -143,9 +144,11 @@ import { OrganizationBillingApiService } from "@bitwarden/common/billing/service
 import { OrganizationBillingService } from "@bitwarden/common/billing/services/organization-billing.service";
 import { TaxService } from "@bitwarden/common/billing/services/tax.service";
 import { BulkEncryptService } from "@bitwarden/common/key-management/crypto/abstractions/bulk-encrypt.service";
+import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from "@bitwarden/common/key-management/crypto/abstractions/crypto-function.service";
 import { EncryptService } from "@bitwarden/common/key-management/crypto/abstractions/encrypt.service";
 import { BulkEncryptServiceImplementation } from "@bitwarden/common/key-management/crypto/services/bulk-encrypt.service.implementation";
 import { MultithreadEncryptServiceImplementation } from "@bitwarden/common/key-management/crypto/services/multithread-encrypt.service.implementation";
+import { WebCryptoFunctionService } from "@bitwarden/common/key-management/crypto/services/web-crypto-function.service";
 import { DeviceTrustServiceAbstraction } from "@bitwarden/common/key-management/device-trust/abstractions/device-trust.service.abstraction";
 import { DeviceTrustService } from "@bitwarden/common/key-management/device-trust/services/device-trust.service.implementation";
 import { KeyConnectorService as KeyConnectorServiceAbstraction } from "@bitwarden/common/key-management/key-connector/abstractions/key-connector.service";
@@ -165,7 +168,6 @@ import { AppIdService as AppIdServiceAbstraction } from "@bitwarden/common/platf
 import { BroadcasterService } from "@bitwarden/common/platform/abstractions/broadcaster.service";
 import { ConfigApiServiceAbstraction } from "@bitwarden/common/platform/abstractions/config/config-api.service.abstraction";
 import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service";
-import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from "@bitwarden/common/platform/abstractions/crypto-function.service";
 import {
  EnvironmentService,
  RegionConfig,
@@ -199,8 +201,8 @@ import {
  WebPushNotificationsApiService,
 } from "@bitwarden/common/platform/notifications/internal";
 import {
-  TaskSchedulerService,
  DefaultTaskSchedulerService,
+  TaskSchedulerService,
 } from "@bitwarden/common/platform/scheduling";
 import { AppIdService } from "@bitwarden/common/platform/services/app-id.service";
 import { ConfigApiService } from "@bitwarden/common/platform/services/config/config-api.service";
@@ -218,13 +220,12 @@ import { StateService } from "@bitwarden/common/platform/services/state.service"
 import { StorageServiceProvider } from "@bitwarden/common/platform/services/storage-service.provider";
 import { UserAutoUnlockKeyService } from "@bitwarden/common/platform/services/user-auto-unlock-key.service";
 import { ValidationService } from "@bitwarden/common/platform/services/validation.service";
-import { WebCryptoFunctionService } from "@bitwarden/common/platform/services/web-crypto-function.service";
 import {
  ActiveUserStateProvider,
+  DerivedStateProvider,
  GlobalStateProvider,
  SingleUserStateProvider,
  StateProvider,
-  DerivedStateProvider,
 } from "@bitwarden/common/platform/state";
 /* eslint-disable import/no-restricted-paths -- We need the implementations to inject, but generally these should not be accessed */
 import { DefaultActiveUserStateProvider } from "@bitwarden/common/platform/state/implementations/default-active-user-state.provider";
@@ -279,6 +280,7 @@ import { FolderApiService } from "@bitwarden/common/vault/services/folder/folder
 import { FolderService } from "@bitwarden/common/vault/services/folder/folder.service";
 import { TotpService } from "@bitwarden/common/vault/services/totp.service";
 import { VaultSettingsService } from "@bitwarden/common/vault/services/vault-settings/vault-settings.service";
+import { DefaultTaskService, TaskService } from "@bitwarden/common/vault/tasks";
 import { ToastService } from "@bitwarden/components";
 import {
  GeneratorHistoryService,
@@ -291,34 +293,32 @@ import {
  UsernameGenerationServiceAbstraction,
 } from "@bitwarden/generator-legacy";
 import {
-  KeyService,
-  DefaultKeyService,
+  BiometricsService,
  BiometricStateService,
  DefaultBiometricStateService,
-  BiometricsService,
  DefaultKdfConfigService,
-  KdfConfigService,
-  UserAsymmetricKeysRegenerationService,
-  DefaultUserAsymmetricKeysRegenerationService,
-  UserAsymmetricKeysRegenerationApiService,
+  DefaultKeyService,
  DefaultUserAsymmetricKeysRegenerationApiService,
+  DefaultUserAsymmetricKeysRegenerationService,
+  KdfConfigService,
+  KeyService,
+  UserAsymmetricKeysRegenerationApiService,
+  UserAsymmetricKeysRegenerationService,
 } from "@bitwarden/key-management";
 import { SafeInjectionToken } from "@bitwarden/ui-common";
 import {
-  DefaultTaskService,
  DefaultEndUserNotificationService,
  EndUserNotificationService,
  NewDeviceVerificationNoticeService,
  PasswordRepromptService,
-  TaskService,
 } from "@bitwarden/vault";
 import {
-  VaultExportService,
-  VaultExportServiceAbstraction,
-  OrganizationVaultExportService,
-  OrganizationVaultExportServiceAbstraction,
  IndividualVaultExportService,
  IndividualVaultExportServiceAbstraction,
+  OrganizationVaultExportService,
+  OrganizationVaultExportServiceAbstraction,
+  VaultExportService,
+  VaultExportServiceAbstraction,
 } from "@bitwarden/vault-export-core";

 import { DeviceTrustToastService as DeviceTrustToastServiceAbstraction } from "../auth/services/device-trust-toast.service.abstraction";
@@ -333,24 +333,24 @@ import { AbstractThemingService } from "../platform/services/theming/theming.ser
 import { safeProvider, SafeProvider } from "../platform/utils/safe-provider";

 import {
+  CLIENT_TYPE,
+  DEFAULT_VAULT_TIMEOUT,
+  ENV_ADDITIONAL_REGIONS,
+  INTRAPROCESS_MESSAGING_SUBJECT,
  LOCALES_DIRECTORY,
  LOCKED_CALLBACK,
-  LOGOUT_CALLBACK,
  LOG_MAC_FAILURES,
+  LOGOUT_CALLBACK,
  MEMORY_STORAGE,
  OBSERVABLE_DISK_STORAGE,
  OBSERVABLE_MEMORY_STORAGE,
+  REFRESH_ACCESS_TOKEN_ERROR_CALLBACK,
  SECURE_STORAGE,
  STATE_FACTORY,
  SUPPORTS_SECURE_STORAGE,
  SYSTEM_LANGUAGE,
  SYSTEM_THEME_OBSERVABLE,
  WINDOW,
-  DEFAULT_VAULT_TIMEOUT,
-  INTRAPROCESS_MESSAGING_SUBJECT,
-  CLIENT_TYPE,
-  REFRESH_ACCESS_TOKEN_ERROR_CALLBACK,
-  ENV_ADDITIONAL_REGIONS,
 } from "./injection-tokens";
 import { ModalService } from "./modal.service";

@@ -505,6 +505,7 @@ const safeProviders: SafeProvider[] = [
      configService: ConfigService,
      stateProvider: StateProvider,
      accountService: AccountServiceAbstraction,
+      logService: LogService,
    ) =>
      new CipherService(
        keyService,
@@ -520,6 +521,7 @@ const safeProviders: SafeProvider[] = [
        configService,
        stateProvider,
        accountService,
+        logService,
      ),
    deps: [
      KeyService,
@@ -535,6 +537,7 @@ const safeProviders: SafeProvider[] = [
      ConfigService,
      StateProvider,
      AccountServiceAbstraction,
+      LogService,
    ],
  }),
  safeProvider({
@@ -846,6 +849,7 @@ const safeProviders: SafeProvider[] = [
      CryptoFunctionServiceAbstraction,
      KdfConfigService,
      AccountServiceAbstraction,
+      ApiServiceAbstraction,
    ],
  }),
  safeProvider({
@@ -946,7 +950,7 @@ const safeProviders: SafeProvider[] = [
  }),
  safeProvider({
    provide: InternalPolicyService,
-    useClass: PolicyService,
+    useClass: DefaultPolicyService,
    deps: [StateProvider, OrganizationServiceAbstraction],
  }),
  safeProvider({
@@ -956,7 +960,7 @@ const safeProviders: SafeProvider[] = [
  safeProvider({
    provide: PolicyApiServiceAbstraction,
    useClass: PolicyApiService,
-    deps: [InternalPolicyService, ApiServiceAbstraction],
+    deps: [InternalPolicyService, ApiServiceAbstraction, AccountService],
  }),
  safeProvider({
    provide: InternalMasterPasswordServiceAbstraction,
@@ -1171,9 +1175,7 @@ const safeProviders: SafeProvider[] = [
      KdfConfigService,
      KeyGenerationServiceAbstraction,
      LogService,
-      MasterPasswordServiceAbstraction,
      StateProvider,
-      StateServiceAbstraction,
    ],
  }),
  safeProvider({
@@ -1253,12 +1255,13 @@ const safeProviders: SafeProvider[] = [
      I18nServiceAbstraction,
      OrganizationApiServiceAbstraction,
      SyncService,
+      ConfigService,
    ],
  }),
  safeProvider({
    provide: AutofillSettingsServiceAbstraction,
    useClass: AutofillSettingsService,
-    deps: [StateProvider, PolicyServiceAbstraction],
+    deps: [StateProvider, PolicyServiceAbstraction, AccountService],
  }),
  safeProvider({
    provide: BadgeSettingsServiceAbstraction,
@@ -1468,17 +1471,25 @@ const safeProviders: SafeProvider[] = [
  safeProvider({
    provide: LoginSuccessHandlerService,
    useClass: DefaultLoginSuccessHandlerService,
-    deps: [SyncService, UserAsymmetricKeysRegenerationService],
+    deps: [SyncService, UserAsymmetricKeysRegenerationService, LoginEmailService],
  }),
  safeProvider({
    provide: TaskService,
    useClass: DefaultTaskService,
-    deps: [StateProvider, ApiServiceAbstraction, OrganizationServiceAbstraction, ConfigService],
+    deps: [
+      StateProvider,
+      ApiServiceAbstraction,
+      OrganizationServiceAbstraction,
+      ConfigService,
+      AuthServiceAbstraction,
+      NotificationsService,
+      MessageListener,
+    ],
  }),
  safeProvider({
    provide: EndUserNotificationService,
    useClass: DefaultEndUserNotificationService,
-    deps: [StateProvider, ApiServiceAbstraction],
+    deps: [StateProvider, ApiServiceAbstraction, NotificationsService],
  }),
  safeProvider({
    provide: DeviceTrustToastServiceAbstraction,
--- a/libs/angular/src/tools/send/add-edit.component.ts
+++ b/libs/angular/src/tools/send/add-edit.component.ts
@@ -155,9 +155,14 @@ export class AddEditComponent implements OnInit, OnDestroy {
  }

  async ngOnInit() {
-    this.policyService
-      .policyAppliesToActiveUser$(PolicyType.DisableSend)
-      .pipe(takeUntil(this.destroy$))
+    this.accountService.activeAccount$
+      .pipe(
+        getUserId,
+        switchMap((userId) =>
+          this.policyService.policyAppliesToUser$(PolicyType.DisableSend, userId),
+        ),
+        takeUntil(this.destroy$),
+      )
      .subscribe((policyAppliesToActiveUser) => {
        this.disableSend = policyAppliesToActiveUser;
        if (this.disableSend) {
@@ -168,7 +173,7 @@ export class AddEditComponent implements OnInit, OnDestroy {
    this.accountService.activeAccount$
      .pipe(
        getUserId,
-        switchMap((userId) => this.policyService.getAll$(PolicyType.SendOptions, userId)),
+        switchMap((userId) => this.policyService.policiesByType$(PolicyType.SendOptions, userId)),
        map((policies) => policies?.some((p) => p.data.disableHideEmail)),
        takeUntil(this.destroy$),
      )
--- a/libs/angular/src/tools/send/send.component.ts
+++ b/libs/angular/src/tools/send/send.component.ts
@@ -9,6 +9,7 @@ import {
  from,
  switchMap,
  takeUntil,
+  combineLatest,
 } from "rxjs";

 import { SearchService } from "@bitwarden/common/abstractions/search.service";
@@ -85,18 +86,23 @@ export class SendComponent implements OnInit, OnDestroy {
  ) {}

  async ngOnInit() {
-    const userId = await firstValueFrom(getUserId(this.accountService.activeAccount$));
-
-    this.policyService
-      .policyAppliesToActiveUser$(PolicyType.DisableSend)
-      .pipe(takeUntil(this.destroy$))
-      .subscribe((policyAppliesToActiveUser) => {
-        this.disableSend = policyAppliesToActiveUser;
+    this.accountService.activeAccount$
+      .pipe(
+        getUserId,
+        switchMap((userId) =>
+          this.policyService.policyAppliesToUser$(PolicyType.DisableSend, userId),
+        ),
+        takeUntil(this.destroy$),
+      )
+      .subscribe((policyAppliesToUser) => {
+        this.disableSend = policyAppliesToUser;
      });

-    this._searchText$
+    combineLatest([this._searchText$, this.accountService.activeAccount$.pipe(getUserId)])
      .pipe(
-        switchMap((searchText) => from(this.searchService.isSearchable(userId, searchText))),
+        switchMap(([searchText, userId]) =>
+          from(this.searchService.isSearchable(userId, searchText)),
+        ),
        takeUntil(this.destroy$),
      )
      .subscribe((isSearchable) => {
--- a/libs/angular/src/vault/components/add-edit.component.ts
+++ b/libs/angular/src/vault/components/add-edit.component.ts
@@ -2,7 +2,7 @@
 // @ts-strict-ignore
 import { DatePipe } from "@angular/common";
 import { Directive, EventEmitter, Input, OnDestroy, OnInit, Output } from "@angular/core";
-import { concatMap, firstValueFrom, map, Observable, Subject, takeUntil } from "rxjs";
+import { concatMap, firstValueFrom, map, Observable, Subject, switchMap, takeUntil } from "rxjs";

 import { CollectionService, CollectionView } from "@bitwarden/admin-console/common";
 import { AuditService } from "@bitwarden/common/abstractions/audit.service";
@@ -193,9 +193,12 @@ export class AddEditComponent implements OnInit, OnDestroy {
  }

  async ngOnInit() {
-    this.policyService
-      .policyAppliesToActiveUser$(PolicyType.PersonalOwnership)
+    this.accountService.activeAccount$
      .pipe(
+        getUserId,
+        switchMap((userId) =>
+          this.policyService.policyAppliesToUser$(PolicyType.PersonalOwnership, userId),
+        ),
        concatMap(async (policyAppliesToActiveUser) => {
          this.personalOwnershipPolicyAppliesToActiveUser = policyAppliesToActiveUser;
          await this.init();
@@ -419,10 +422,15 @@ export class AddEditComponent implements OnInit, OnDestroy {

    const activeUserId = await firstValueFrom(this.accountService.activeAccount$.pipe(getUserId));
    const cipher = await this.encryptCipher(activeUserId);
+
    try {
      this.formPromise = this.saveCipher(cipher);
-      await this.formPromise;
-      this.cipher.id = cipher.id;
+      const savedCipher = await this.formPromise;
+
+      // Reset local cipher from the saved cipher returned from the server
+      this.cipher = await savedCipher.decrypt(
+        await this.cipherService.getKeyForCipherKeyDecryption(savedCipher, activeUserId),
+      );
      this.toastService.showToast({
        variant: "success",
        title: null,
--- a/libs/angular/src/vault/components/vault-items.component.ts
+++ b/libs/angular/src/vault/components/vault-items.component.ts
@@ -1,13 +1,22 @@
 // FIXME: Update this file to be type safe and remove this and next line
 // @ts-strict-ignore
 import { Directive, EventEmitter, Input, OnDestroy, OnInit, Output } from "@angular/core";
-import { BehaviorSubject, Subject, firstValueFrom, from, switchMap, takeUntil } from "rxjs";
+import { takeUntilDestroyed } from "@angular/core/rxjs-interop";
+import {
+  BehaviorSubject,
+  Subject,
+  combineLatest,
+  filter,
+  from,
+  of,
+  switchMap,
+  takeUntil,
+} from "rxjs";

 import { SearchService } from "@bitwarden/common/abstractions/search.service";
 import { Organization } from "@bitwarden/common/admin-console/models/domain/organization";
 import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
 import { getUserId } from "@bitwarden/common/auth/services/account.service";
-import { UserId } from "@bitwarden/common/types/guid";
 import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
 import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view";

@@ -21,17 +30,17 @@ export class VaultItemsComponent implements OnInit, OnDestroy {

  loaded = false;
  ciphers: CipherView[] = [];
-  filter: (cipher: CipherView) => boolean = null;
  deleted = false;
  organization: Organization;

  protected searchPending = false;

-  private userId: UserId;
+  /** Construct filters as an observable so it can be appended to the cipher stream. */
+  private _filter$ = new BehaviorSubject<(cipher: CipherView) => boolean | null>(null);
  private destroy$ = new Subject<void>();
-  private searchTimeout: any = null;
  private isSearchable: boolean = false;
  private _searchText$ = new BehaviorSubject<string>("");
+
  get searchText() {
    return this._searchText$.value;
  }
@@ -39,18 +48,28 @@ export class VaultItemsComponent implements OnInit, OnDestroy {
    this._searchText$.next(value);
  }

+  get filter() {
+    return this._filter$.value;
+  }
+
+  set filter(value: (cipher: CipherView) => boolean | null) {
+    this._filter$.next(value);
+  }
+
  constructor(
    protected searchService: SearchService,
    protected cipherService: CipherService,
    protected accountService: AccountService,
-  ) {}
+  ) {
+    this.subscribeToCiphers();
+  }

  async ngOnInit() {
-    this.userId = await firstValueFrom(getUserId(this.accountService.activeAccount$));
-
-    this._searchText$
+    combineLatest([getUserId(this.accountService.activeAccount$), this._searchText$])
      .pipe(
-        switchMap((searchText) => from(this.searchService.isSearchable(this.userId, searchText))),
+        switchMap(([userId, searchText]) =>
+          from(this.searchService.isSearchable(userId, searchText)),
+        ),
        takeUntil(this.destroy$),
      )
      .subscribe((isSearchable) => {
@@ -80,23 +99,6 @@ export class VaultItemsComponent implements OnInit, OnDestroy {

  async applyFilter(filter: (cipher: CipherView) => boolean = null) {
    this.filter = filter;
-    await this.search(null);
-  }
-
-  async search(timeout: number = null, indexedCiphers?: CipherView[]) {
-    this.searchPending = false;
-    if (this.searchTimeout != null) {
-      clearTimeout(this.searchTimeout);
-    }
-    if (timeout == null) {
-      await this.doSearch(indexedCiphers);
-      return;
-    }
-    this.searchPending = true;
-    this.searchTimeout = setTimeout(async () => {
-      await this.doSearch(indexedCiphers);
-      this.searchPending = false;
-    }, timeout);
  }

  selectCipher(cipher: CipherView) {
@@ -121,25 +123,44 @@ export class VaultItemsComponent implements OnInit, OnDestroy {

  protected deletedFilter: (cipher: CipherView) => boolean = (c) => c.isDeleted === this.deleted;

-  protected async doSearch(indexedCiphers?: CipherView[], userId?: UserId) {
-    // Get userId from activeAccount if not provided from parent stream
-    if (!userId) {
-      userId = await firstValueFrom(getUserId(this.accountService.activeAccount$));
-    }
+  /**
+   * Creates stream of dependencies that results in the list of ciphers to display
+   * within the vault list.
+   *
+   * Note: This previously used promises but race conditions with how the ciphers were
+   * stored in electron. Using observables is more reliable as fresh values will always
+   * cascade through the components.
+   */
+  private subscribeToCiphers() {
+    getUserId(this.accountService.activeAccount$)
+      .pipe(
+        switchMap((userId) =>
+          combineLatest([
+            this.cipherService.cipherViews$(userId).pipe(filter((ciphers) => ciphers != null)),
+            this.cipherService.failedToDecryptCiphers$(userId),
+            this._searchText$,
+            this._filter$,
+            of(userId),
+          ]),
+        ),
+        switchMap(([indexedCiphers, failedCiphers, searchText, filter, userId]) => {
+          let allCiphers = indexedCiphers ?? [];
+          const _failedCiphers = failedCiphers ?? [];

-    indexedCiphers =
-      indexedCiphers ?? (await firstValueFrom(this.cipherService.cipherViews$(userId)));
+          allCiphers = [..._failedCiphers, ...allCiphers];

-    const failedCiphers = await firstValueFrom(this.cipherService.failedToDecryptCiphers$(userId));
-    if (failedCiphers != null && failedCiphers.length > 0) {
-      indexedCiphers = [...failedCiphers, ...indexedCiphers];
-    }
-
-    this.ciphers = await this.searchService.searchCiphers(
-      this.userId,
-      this.searchText,
-      [this.filter, this.deletedFilter],
-      indexedCiphers,
-    );
+          return this.searchService.searchCiphers(
+            userId,
+            searchText,
+            [filter, this.deletedFilter],
+            allCiphers,
+          );
+        }),
+        takeUntilDestroyed(),
+      )
+      .subscribe((ciphers) => {
+        this.ciphers = ciphers;
+        this.loaded = true;
+      });
  }
 }
--- a/libs/angular/src/vault/components/view.component.ts
+++ b/libs/angular/src/vault/components/view.component.ts
@@ -11,7 +11,17 @@ import {
  OnInit,
  Output,
 } from "@angular/core";
-import { filter, firstValueFrom, map, Observable } from "rxjs";
+import {
+  BehaviorSubject,
+  combineLatest,
+  filter,
+  firstValueFrom,
+  map,
+  Observable,
+  of,
+  switchMap,
+  tap,
+} from "rxjs";

 import { ApiService } from "@bitwarden/common/abstractions/api.service";
 import { AuditService } from "@bitwarden/common/abstractions/audit.service";
@@ -46,11 +56,22 @@ import { DialogService, ToastService } from "@bitwarden/components";
 import { KeyService } from "@bitwarden/key-management";
 import { PasswordRepromptService } from "@bitwarden/vault";

-const BroadcasterSubscriptionId = "ViewComponent";
+const BroadcasterSubscriptionId = "BaseViewComponent";

@Directive()
 export class ViewComponent implements OnDestroy, OnInit {
-  @Input() cipherId: string;
+  /** Observable of cipherId$ that will update each time the `Input` updates */
+  private _cipherId$ = new BehaviorSubject<string>(null);
+
+  @Input()
+  set cipherId(value: string) {
+    this._cipherId$.next(value);
+  }
+
+  get cipherId(): string {
+    return this._cipherId$.getValue();
+  }
+
  @Input() collectionId: string;
  @Output() onEditCipher = new EventEmitter<CipherView>();
  @Output() onCloneCipher = new EventEmitter<CipherView>();
@@ -59,6 +80,7 @@ export class ViewComponent implements OnDestroy, OnInit {
  @Output() onRestoredCipher = new EventEmitter<CipherView>();

  canDeleteCipher$: Observable<boolean>;
+  canRestoreCipher$: Observable<boolean>;
  cipher: CipherView;
  showPassword: boolean;
  showPasswordCount: boolean;
@@ -125,13 +147,30 @@ export class ViewComponent implements OnDestroy, OnInit {
        switch (message.command) {
          case "syncCompleted":
            if (message.successfully) {
-              await this.load();
              this.changeDetectorRef.detectChanges();
            }
            break;
        }
      });
    });
+
+    // Set up the subscription to the activeAccount$ and cipherId$ observables
+    combineLatest([this.accountService.activeAccount$.pipe(getUserId), this._cipherId$])
+      .pipe(
+        tap(() => this.cleanUp()),
+        switchMap(([userId, cipherId]) => {
+          const cipher$ = this.cipherService.cipherViews$(userId).pipe(
+            map((ciphers) => ciphers?.find((c) => c.id === cipherId)),
+            filter((cipher) => !!cipher),
+          );
+          return combineLatest([of(userId), cipher$]);
+        }),
+      )
+      .subscribe(([userId, cipher]) => {
+        this.cipher = cipher;
+
+        void this.constructCipherDetails(userId);
+      });
  }

  ngOnDestroy() {
@@ -139,76 +178,8 @@ export class ViewComponent implements OnDestroy, OnInit {
    this.cleanUp();
  }

-  async load() {
-    this.cleanUp();
-
-    // Grab individual cipher from `cipherViews$` for the most up-to-date information
-    const activeUserId = await firstValueFrom(this.accountService.activeAccount$.pipe(getUserId));
-    this.cipher = await firstValueFrom(
-      this.cipherService.cipherViews$(activeUserId).pipe(
-        map((ciphers) => ciphers?.find((c) => c.id === this.cipherId)),
-        filter((cipher) => !!cipher),
-      ),
-    );
-
-    this.canAccessPremium = await firstValueFrom(
-      this.billingAccountProfileStateService.hasPremiumFromAnySource$(activeUserId),
-    );
-    this.showPremiumRequiredTotp =
-      this.cipher.login.totp && !this.canAccessPremium && !this.cipher.organizationUseTotp;
-    this.canDeleteCipher$ = this.cipherAuthorizationService.canDeleteCipher$(this.cipher, [
-      this.collectionId as CollectionId,
-    ]);
-
-    if (this.cipher.folderId) {
-      this.folder = await (
-        await firstValueFrom(this.folderService.folderViews$(activeUserId))
-      ).find((f) => f.id == this.cipher.folderId);
-    }
-
-    const canGenerateTotp =
-      this.cipher.type === CipherType.Login &&
-      this.cipher.login.totp &&
-      (this.cipher.organizationUseTotp || this.canAccessPremium);
-
-    this.totpInfo$ = canGenerateTotp
-      ? this.totpService.getCode$(this.cipher.login.totp).pipe(
-          map((response) => {
-            const epoch = Math.round(new Date().getTime() / 1000.0);
-            const mod = epoch % response.period;
-
-            // Format code
-            const totpCodeFormatted =
-              response.code.length > 4
-                ? `${response.code.slice(0, Math.floor(response.code.length / 2))} ${response.code.slice(Math.floor(response.code.length / 2))}`
-                : response.code;
-
-            return {
-              totpCode: response.code,
-              totpCodeFormatted,
-              totpDash: +(Math.round(((78.6 / response.period) * mod + "e+2") as any) + "e-2"),
-              totpSec: response.period - mod,
-              totpLow: response.period - mod <= 7,
-            } as TotpInfo;
-          }),
-        )
-      : undefined;
-
-    if (this.previousCipherId !== this.cipherId) {
-      // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      this.eventCollectionService.collect(EventType.Cipher_ClientViewed, this.cipherId);
-    }
-    this.previousCipherId = this.cipherId;
-  }
-
  async edit() {
-    if (await this.promptPassword()) {
-      this.onEditCipher.emit(this.cipher);
-      return true;
-    }
-
-    return false;
+    this.onEditCipher.emit(this.cipher);
  }

  async clone() {
@@ -536,4 +507,61 @@ export class ViewComponent implements OnDestroy, OnInit {
    this.showCardCode = false;
    this.passwordReprompted = false;
  }
+
+  /**
+   * When a cipher is viewed, construct all details for the view that are not directly
+   * available from the cipher object itself.
+   */
+  private async constructCipherDetails(userId: UserId) {
+    this.canAccessPremium = await firstValueFrom(
+      this.billingAccountProfileStateService.hasPremiumFromAnySource$(userId),
+    );
+    this.showPremiumRequiredTotp =
+      this.cipher.login.totp && !this.canAccessPremium && !this.cipher.organizationUseTotp;
+    this.canDeleteCipher$ = this.cipherAuthorizationService.canDeleteCipher$(this.cipher, [
+      this.collectionId as CollectionId,
+    ]);
+    this.canRestoreCipher$ = this.cipherAuthorizationService.canRestoreCipher$(this.cipher);
+
+    if (this.cipher.folderId) {
+      this.folder = await (
+        await firstValueFrom(this.folderService.folderViews$(userId))
+      ).find((f) => f.id == this.cipher.folderId);
+    }
+
+    const canGenerateTotp =
+      this.cipher.type === CipherType.Login &&
+      this.cipher.login.totp &&
+      (this.cipher.organizationUseTotp || this.canAccessPremium);
+
+    this.totpInfo$ = canGenerateTotp
+      ? this.totpService.getCode$(this.cipher.login.totp).pipe(
+          map((response) => {
+            const epoch = Math.round(new Date().getTime() / 1000.0);
+            const mod = epoch % response.period;
+
+            // Format code
+            const totpCodeFormatted =
+              response.code.length > 4
+                ? `${response.code.slice(0, Math.floor(response.code.length / 2))} ${response.code.slice(Math.floor(response.code.length / 2))}`
+                : response.code;
+
+            return {
+              totpCode: response.code,
+              totpCodeFormatted,
+              totpDash: +(Math.round(((78.6 / response.period) * mod + "e+2") as any) + "e-2"),
+              totpSec: response.period - mod,
+              totpLow: response.period - mod <= 7,
+            } as TotpInfo;
+          }),
+        )
+      : undefined;
+
+    if (this.previousCipherId !== this.cipherId) {
+      // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      this.eventCollectionService.collect(EventType.Cipher_ClientViewed, this.cipherId);
+    }
+    this.previousCipherId = this.cipherId;
+  }
 }
--- a/libs/angular/src/vault/vault-filter/services/vault-filter.service.ts
+++ b/libs/angular/src/vault/vault-filter/services/vault-filter.service.ts
@@ -112,13 +112,23 @@ export class VaultFilterService implements DeprecatedVaultFilterServiceAbstracti

  async checkForSingleOrganizationPolicy(): Promise<boolean> {
    return await firstValueFrom(
-      this.policyService.policyAppliesToActiveUser$(PolicyType.SingleOrg),
+      this.accountService.activeAccount$.pipe(
+        getUserId,
+        switchMap((userId) =>
+          this.policyService.policyAppliesToUser$(PolicyType.SingleOrg, userId),
+        ),
+      ),
    );
  }

  async checkForPersonalOwnershipPolicy(): Promise<boolean> {
    return await firstValueFrom(
-      this.policyService.policyAppliesToActiveUser$(PolicyType.PersonalOwnership),
+      this.accountService.activeAccount$.pipe(
+        getUserId,
+        switchMap((userId) =>
+          this.policyService.policyAppliesToUser$(PolicyType.PersonalOwnership, userId),
+        ),
+      ),
    );
  }