feat: migrate from Cedar to SpiceDB authorization system

This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.

Key changes:

- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization

This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.

Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.

12 files changed, 0 insertions, 1124 deletions

diff --git a/vendor/futures-task/.cargo-checksum.json b/vendor/futures-task/.cargo-checksum.json
deleted file mode 100644
index bd2e7db0..00000000
--- a/vendor/futures-task/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"25eb5ef7e3dc6c78c1cd32dd91f7bcd01cc81f5c1c2c36cd951e636fbddb1fda","LICENSE-APACHE":"275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427","LICENSE-MIT":"6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd","README.md":"6762ad0401a70d3b3e1faf6967b310de688da34c16174fd079ebc88fcff2cc4c","src/arc_wake.rs":"0e3f7d7883b75337b0b92ff55e477f0bf96f6eb08def7d953676a289fd9696ec","src/future_obj.rs":"be75a5b6f124cd25038c60961b5933062a06ccdce569e58e41c357802d3d1891","src/lib.rs":"b49478700ee4d64df460c225f1b4b3ce11ff5c24065602efe88ffb0f3ce4ca59","src/noop_waker.rs":"41246601dab77f69bf09257afc3321031a5a31a7eda51787029870eda9922356","src/spawn.rs":"cd0dafb52700e087a2793bb42d70da84e9e10181d5407ea74843d935f40cea02","src/waker.rs":"3fd071a6e951d873aa896b3ee7b377a70d340e738a51aef85f5bb1c46d3451a8","src/waker_ref.rs":"640264ad52ccd2ebbb650104eaab9a2d24b8d08749f8c76226bd22bd51006f2a"},"package":"f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"}
\ No newline at end of file
diff --git a/vendor/futures-task/Cargo.toml b/vendor/futures-task/Cargo.toml
deleted file mode 100644
index c34ac5a5..00000000
--- a/vendor/futures-task/Cargo.toml
+++ /dev/null
@@ -1,57 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-rust-version = "1.56"
-name = "futures-task"
-version = "0.3.31"
-build = false
-autobins = false
-autoexamples = false
-autotests = false
-autobenches = false
-description = """
-Tools for working with tasks.
-"""
-homepage = "https://rust-lang.github.io/futures-rs"
-readme = "README.md"
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/rust-lang/futures-rs"
-
-[package.metadata.docs.rs]
-all-features = true
-
-[lib]
-name = "futures_task"
-path = "src/lib.rs"
-
-[dependencies]
-
-[dev-dependencies]
-
-[features]
-alloc = []
-cfg-target-has-atomic = []
-default = ["std"]
-std = ["alloc"]
-unstable = []
-
-[lints.rust]
-missing_debug_implementations = "warn"
-rust_2018_idioms = "warn"
-single_use_lifetimes = "warn"
-unreachable_pub = "warn"
-
-[lints.rust.unexpected_cfgs]
-level = "warn"
-priority = 0
-check-cfg = ["cfg(futures_sanitizer)"]
diff --git a/vendor/futures-task/LICENSE-APACHE b/vendor/futures-task/LICENSE-APACHE
deleted file mode 100644
index 9eb0b097..00000000
--- a/vendor/futures-task/LICENSE-APACHE
+++ /dev/null
@@ -1,202 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright (c) 2016 Alex Crichton
-Copyright (c) 2017 The Tokio Authors
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/futures-task/LICENSE-MIT b/vendor/futures-task/LICENSE-MIT
deleted file mode 100644
index 8ad082ec..00000000
--- a/vendor/futures-task/LICENSE-MIT
+++ /dev/null
@@ -1,26 +0,0 @@
-Copyright (c) 2016 Alex Crichton
-Copyright (c) 2017 The Tokio Authors
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/futures-task/README.md b/vendor/futures-task/README.md
deleted file mode 100644
index 1ebec2d7..00000000
--- a/vendor/futures-task/README.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# futures-task
-
-Tools for working with tasks.
-
-## Usage
-
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-futures-task = "0.3"
-```
-
-The current `futures-task` requires Rust 1.56 or later.
-
-## License
-
-Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or
-[MIT license](LICENSE-MIT) at your option.
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in the work by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
diff --git a/vendor/futures-task/src/arc_wake.rs b/vendor/futures-task/src/arc_wake.rs
deleted file mode 100644
index aa6de0fc..00000000
--- a/vendor/futures-task/src/arc_wake.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use alloc::sync::Arc;
-
-/// A way of waking up a specific task.
-///
-/// By implementing this trait, types that are expected to be wrapped in an `Arc`
-/// can be converted into [`Waker`] objects.
-/// Those Wakers can be used to signal executors that a task it owns
-/// is ready to be `poll`ed again.
-///
-/// Currently, there are two ways to convert `ArcWake` into [`Waker`]:
-///
-/// * [`waker`](super::waker()) converts `Arc<impl ArcWake>` into [`Waker`].
-/// * [`waker_ref`](super::waker_ref()) converts `&Arc<impl ArcWake>` into [`WakerRef`] that
-///   provides access to a [`&Waker`][`Waker`].
-///
-/// [`Waker`]: std::task::Waker
-/// [`WakerRef`]: super::WakerRef
-// Note: Send + Sync required because `Arc<T>` doesn't automatically imply
-// those bounds, but `Waker` implements them.
-pub trait ArcWake: Send + Sync {
-    /// Indicates that the associated task is ready to make progress and should
-    /// be `poll`ed.
-    ///
-    /// This function can be called from an arbitrary thread, including threads which
-    /// did not create the `ArcWake` based [`Waker`].
-    ///
-    /// Executors generally maintain a queue of "ready" tasks; `wake` should place
-    /// the associated task onto this queue.
-    ///
-    /// [`Waker`]: std::task::Waker
-    fn wake(self: Arc<Self>) {
-        Self::wake_by_ref(&self)
-    }
-
-    /// Indicates that the associated task is ready to make progress and should
-    /// be `poll`ed.
-    ///
-    /// This function can be called from an arbitrary thread, including threads which
-    /// did not create the `ArcWake` based [`Waker`].
-    ///
-    /// Executors generally maintain a queue of "ready" tasks; `wake_by_ref` should place
-    /// the associated task onto this queue.
-    ///
-    /// This function is similar to [`wake`](ArcWake::wake), but must not consume the provided data
-    /// pointer.
-    ///
-    /// [`Waker`]: std::task::Waker
-    fn wake_by_ref(arc_self: &Arc<Self>);
-}
diff --git a/vendor/futures-task/src/future_obj.rs b/vendor/futures-task/src/future_obj.rs
deleted file mode 100644
index a6113821..00000000
--- a/vendor/futures-task/src/future_obj.rs
+++ /dev/null
@@ -1,335 +0,0 @@
-use core::{
-    fmt,
-    future::Future,
-    marker::PhantomData,
-    mem,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-/// A custom trait object for polling futures, roughly akin to
-/// `Box<dyn Future<Output = T> + 'a>`.
-///
-/// This custom trait object was introduced as currently it is not possible to
-/// take `dyn Trait` by value and `Box<dyn Trait>` is not available in no_std
-/// contexts.
-pub struct LocalFutureObj<'a, T> {
-    future: *mut (dyn Future<Output = T> + 'static),
-    drop_fn: unsafe fn(*mut (dyn Future<Output = T> + 'static)),
-    _marker: PhantomData<&'a ()>,
-}
-
-// As LocalFutureObj only holds pointers, even if we move it, the pointed to values won't move,
-// so this is safe as long as we don't provide any way for a user to directly access the pointers
-// and move their values.
-impl<T> Unpin for LocalFutureObj<'_, T> {}
-
-#[allow(single_use_lifetimes)]
-#[allow(clippy::transmute_ptr_to_ptr)]
-unsafe fn remove_future_lifetime<'a, T>(
-    ptr: *mut (dyn Future<Output = T> + 'a),
-) -> *mut (dyn Future<Output = T> + 'static) {
-    unsafe { mem::transmute(ptr) }
-}
-
-#[allow(single_use_lifetimes)]
-unsafe fn remove_drop_lifetime<'a, T>(
-    ptr: unsafe fn(*mut (dyn Future<Output = T> + 'a)),
-) -> unsafe fn(*mut (dyn Future<Output = T> + 'static)) {
-    unsafe { mem::transmute(ptr) }
-}
-
-impl<'a, T> LocalFutureObj<'a, T> {
-    /// Create a `LocalFutureObj` from a custom trait object representation.
-    #[inline]
-    pub fn new<F: UnsafeFutureObj<'a, T> + 'a>(f: F) -> Self {
-        Self {
-            future: unsafe { remove_future_lifetime(f.into_raw()) },
-            drop_fn: unsafe { remove_drop_lifetime(F::drop) },
-            _marker: PhantomData,
-        }
-    }
-
-    /// Converts the `LocalFutureObj` into a `FutureObj`.
-    ///
-    /// # Safety
-    ///
-    /// To make this operation safe one has to ensure that the `UnsafeFutureObj`
-    /// instance from which this `LocalFutureObj` was created actually
-    /// implements `Send`.
-    #[inline]
-    pub unsafe fn into_future_obj(self) -> FutureObj<'a, T> {
-        FutureObj(self)
-    }
-}
-
-impl<T> fmt::Debug for LocalFutureObj<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("LocalFutureObj").finish()
-    }
-}
-
-impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T> {
-    #[inline]
-    fn from(f: FutureObj<'a, T>) -> Self {
-        f.0
-    }
-}
-
-impl<T> Future for LocalFutureObj<'_, T> {
-    type Output = T;
-
-    #[inline]
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
-        unsafe { Pin::new_unchecked(&mut *self.future).poll(cx) }
-    }
-}
-
-impl<T> Drop for LocalFutureObj<'_, T> {
-    fn drop(&mut self) {
-        unsafe { (self.drop_fn)(self.future) }
-    }
-}
-
-/// A custom trait object for polling futures, roughly akin to
-/// `Box<dyn Future<Output = T> + Send + 'a>`.
-///
-/// This custom trait object was introduced as currently it is not possible to
-/// take `dyn Trait` by value and `Box<dyn Trait>` is not available in no_std
-/// contexts.
-///
-/// You should generally not need to use this type outside of `no_std` or when
-/// implementing `Spawn`, consider using `BoxFuture` instead.
-pub struct FutureObj<'a, T>(LocalFutureObj<'a, T>);
-
-impl<T> Unpin for FutureObj<'_, T> {}
-unsafe impl<T> Send for FutureObj<'_, T> {}
-
-impl<'a, T> FutureObj<'a, T> {
-    /// Create a `FutureObj` from a custom trait object representation.
-    #[inline]
-    pub fn new<F: UnsafeFutureObj<'a, T> + Send>(f: F) -> Self {
-        Self(LocalFutureObj::new(f))
-    }
-}
-
-impl<T> fmt::Debug for FutureObj<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("FutureObj").finish()
-    }
-}
-
-impl<T> Future for FutureObj<'_, T> {
-    type Output = T;
-
-    #[inline]
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
-        Pin::new(&mut self.0).poll(cx)
-    }
-}
-
-/// A custom implementation of a future trait object for `FutureObj`, providing
-/// a vtable with drop support.
-///
-/// This custom representation is typically used only in `no_std` contexts,
-/// where the default `Box`-based implementation is not available.
-///
-/// # Safety
-///
-/// See the safety notes on individual methods for what guarantees an
-/// implementor must provide.
-pub unsafe trait UnsafeFutureObj<'a, T>: 'a {
-    /// Convert an owned instance into a (conceptually owned) fat pointer.
-    ///
-    /// # Safety
-    ///
-    /// ## Implementor
-    ///
-    /// The trait implementor must guarantee that it is safe to convert the
-    /// provided `*mut (dyn Future<Output = T> + 'a)` into a `Pin<&mut (dyn
-    /// Future<Output = T> + 'a)>` and call methods on it, non-reentrantly,
-    /// until `UnsafeFutureObj::drop` is called with it.
-    #[allow(clippy::unnecessary_safety_doc)]
-    fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a);
-
-    /// Drops the future represented by the given fat pointer.
-    ///
-    /// # Safety
-    ///
-    /// ## Implementor
-    ///
-    /// The trait implementor must guarantee that it is safe to call this
-    /// function once per `into_raw` invocation.
-    ///
-    /// ## Caller
-    ///
-    /// The caller must ensure:
-    ///
-    ///  * the pointer passed was obtained from an `into_raw` invocation from
-    ///    this same trait object
-    ///  * the pointer is not currently in use as a `Pin<&mut (dyn Future<Output
-    ///    = T> + 'a)>`
-    ///  * the pointer must not be used again after this function is called
-    unsafe fn drop(ptr: *mut (dyn Future<Output = T> + 'a));
-}
-
-unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for &'a mut F
-where
-    F: Future<Output = T> + Unpin + 'a,
-{
-    fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-        self as *mut dyn Future<Output = T>
-    }
-
-    unsafe fn drop(_ptr: *mut (dyn Future<Output = T> + 'a)) {}
-}
-
-unsafe impl<'a, T> UnsafeFutureObj<'a, T> for &'a mut (dyn Future<Output = T> + Unpin + 'a) {
-    fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-        self as *mut dyn Future<Output = T>
-    }
-
-    unsafe fn drop(_ptr: *mut (dyn Future<Output = T> + 'a)) {}
-}
-
-unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for Pin<&'a mut F>
-where
-    F: Future<Output = T> + 'a,
-{
-    fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-        unsafe { self.get_unchecked_mut() as *mut dyn Future<Output = T> }
-    }
-
-    unsafe fn drop(_ptr: *mut (dyn Future<Output = T> + 'a)) {}
-}
-
-unsafe impl<'a, T> UnsafeFutureObj<'a, T> for Pin<&'a mut (dyn Future<Output = T> + 'a)> {
-    fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-        unsafe { self.get_unchecked_mut() as *mut dyn Future<Output = T> }
-    }
-
-    unsafe fn drop(_ptr: *mut (dyn Future<Output = T> + 'a)) {}
-}
-
-#[cfg(feature = "alloc")]
-mod if_alloc {
-    use super::*;
-    use alloc::boxed::Box;
-
-    unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for Box<F>
-    where
-        F: Future<Output = T> + 'a,
-    {
-        fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-            Box::into_raw(self)
-        }
-
-        unsafe fn drop(ptr: *mut (dyn Future<Output = T> + 'a)) {
-            drop(unsafe { Box::from_raw(ptr.cast::<F>()) })
-        }
-    }
-
-    unsafe impl<'a, T: 'a> UnsafeFutureObj<'a, T> for Box<dyn Future<Output = T> + 'a> {
-        fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-            Box::into_raw(self)
-        }
-
-        unsafe fn drop(ptr: *mut (dyn Future<Output = T> + 'a)) {
-            drop(unsafe { Box::from_raw(ptr) })
-        }
-    }
-
-    unsafe impl<'a, T: 'a> UnsafeFutureObj<'a, T> for Box<dyn Future<Output = T> + Send + 'a> {
-        fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-            Box::into_raw(self)
-        }
-
-        unsafe fn drop(ptr: *mut (dyn Future<Output = T> + 'a)) {
-            drop(unsafe { Box::from_raw(ptr) })
-        }
-    }
-
-    unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for Pin<Box<F>>
-    where
-        F: Future<Output = T> + 'a,
-    {
-        fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-            let mut this = mem::ManuallyDrop::new(self);
-            unsafe { this.as_mut().get_unchecked_mut() as *mut _ }
-        }
-
-        unsafe fn drop(ptr: *mut (dyn Future<Output = T> + 'a)) {
-            drop(Pin::from(unsafe { Box::from_raw(ptr) }))
-        }
-    }
-
-    unsafe impl<'a, T: 'a> UnsafeFutureObj<'a, T> for Pin<Box<dyn Future<Output = T> + 'a>> {
-        fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-            let mut this = mem::ManuallyDrop::new(self);
-            unsafe { this.as_mut().get_unchecked_mut() as *mut _ }
-        }
-
-        unsafe fn drop(ptr: *mut (dyn Future<Output = T> + 'a)) {
-            drop(Pin::from(unsafe { Box::from_raw(ptr) }))
-        }
-    }
-
-    unsafe impl<'a, T: 'a> UnsafeFutureObj<'a, T> for Pin<Box<dyn Future<Output = T> + Send + 'a>> {
-        fn into_raw(self) -> *mut (dyn Future<Output = T> + 'a) {
-            let mut this = mem::ManuallyDrop::new(self);
-            unsafe { this.as_mut().get_unchecked_mut() as *mut _ }
-        }
-
-        unsafe fn drop(ptr: *mut (dyn Future<Output = T> + 'a)) {
-            drop(Pin::from(unsafe { Box::from_raw(ptr) }))
-        }
-    }
-
-    impl<'a, F: Future<Output = ()> + Send + 'a> From<Box<F>> for FutureObj<'a, ()> {
-        fn from(boxed: Box<F>) -> Self {
-            Self::new(boxed)
-        }
-    }
-
-    impl<'a> From<Box<dyn Future<Output = ()> + Send + 'a>> for FutureObj<'a, ()> {
-        fn from(boxed: Box<dyn Future<Output = ()> + Send + 'a>) -> Self {
-            Self::new(boxed)
-        }
-    }
-
-    impl<'a, F: Future<Output = ()> + Send + 'a> From<Pin<Box<F>>> for FutureObj<'a, ()> {
-        fn from(boxed: Pin<Box<F>>) -> Self {
-            Self::new(boxed)
-        }
-    }
-
-    impl<'a> From<Pin<Box<dyn Future<Output = ()> + Send + 'a>>> for FutureObj<'a, ()> {
-        fn from(boxed: Pin<Box<dyn Future<Output = ()> + Send + 'a>>) -> Self {
-            Self::new(boxed)
-        }
-    }
-
-    impl<'a, F: Future<Output = ()> + 'a> From<Box<F>> for LocalFutureObj<'a, ()> {
-        fn from(boxed: Box<F>) -> Self {
-            Self::new(boxed)
-        }
-    }
-
-    impl<'a> From<Box<dyn Future<Output = ()> + 'a>> for LocalFutureObj<'a, ()> {
-        fn from(boxed: Box<dyn Future<Output = ()> + 'a>) -> Self {
-            Self::new(boxed)
-        }
-    }
-
-    impl<'a, F: Future<Output = ()> + 'a> From<Pin<Box<F>>> for LocalFutureObj<'a, ()> {
-        fn from(boxed: Pin<Box<F>>) -> Self {
-            Self::new(boxed)
-        }
-    }
-
-    impl<'a> From<Pin<Box<dyn Future<Output = ()> + 'a>>> for LocalFutureObj<'a, ()> {
-        fn from(boxed: Pin<Box<dyn Future<Output = ()> + 'a>>) -> Self {
-            Self::new(boxed)
-        }
-    }
-}
diff --git a/vendor/futures-task/src/lib.rs b/vendor/futures-task/src/lib.rs
deleted file mode 100644
index c119b6b1..00000000
--- a/vendor/futures-task/src/lib.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-//! Tools for working with tasks.
-
-#![no_std]
-#![doc(test(
-    no_crate_inject,
-    attr(
-        deny(warnings, rust_2018_idioms, single_use_lifetimes),
-        allow(dead_code, unused_assignments, unused_variables)
-    )
-))]
-#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
-
-#[cfg(feature = "alloc")]
-extern crate alloc;
-#[cfg(feature = "std")]
-extern crate std;
-
-mod spawn;
-pub use crate::spawn::{LocalSpawn, Spawn, SpawnError};
-
-#[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
-#[cfg(feature = "alloc")]
-mod arc_wake;
-#[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
-#[cfg(feature = "alloc")]
-pub use crate::arc_wake::ArcWake;
-
-#[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
-#[cfg(feature = "alloc")]
-mod waker;
-#[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
-#[cfg(feature = "alloc")]
-pub use crate::waker::waker;
-
-#[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
-#[cfg(feature = "alloc")]
-mod waker_ref;
-#[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
-#[cfg(feature = "alloc")]
-pub use crate::waker_ref::{waker_ref, WakerRef};
-
-mod future_obj;
-pub use crate::future_obj::{FutureObj, LocalFutureObj, UnsafeFutureObj};
-
-mod noop_waker;
-pub use crate::noop_waker::noop_waker;
-pub use crate::noop_waker::noop_waker_ref;
-
-#[doc(no_inline)]
-pub use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
diff --git a/vendor/futures-task/src/noop_waker.rs b/vendor/futures-task/src/noop_waker.rs
deleted file mode 100644
index f76a8a2e..00000000
--- a/vendor/futures-task/src/noop_waker.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-//! Utilities for creating zero-cost wakers that don't do anything.
-
-use core::ptr::null;
-use core::task::{RawWaker, RawWakerVTable, Waker};
-
-unsafe fn noop_clone(_data: *const ()) -> RawWaker {
-    noop_raw_waker()
-}
-
-unsafe fn noop(_data: *const ()) {}
-
-const NOOP_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(noop_clone, noop, noop, noop);
-
-const fn noop_raw_waker() -> RawWaker {
-    RawWaker::new(null(), &NOOP_WAKER_VTABLE)
-}
-
-/// Create a new [`Waker`] which does
-/// nothing when `wake()` is called on it.
-///
-/// # Examples
-///
-/// ```
-/// use futures::task::noop_waker;
-/// let waker = noop_waker();
-/// waker.wake();
-/// ```
-#[inline]
-pub fn noop_waker() -> Waker {
-    // FIXME: Since 1.46.0 we can use transmute in consts, allowing this function to be const.
-    unsafe { Waker::from_raw(noop_raw_waker()) }
-}
-
-/// Get a static reference to a [`Waker`] which
-/// does nothing when `wake()` is called on it.
-///
-/// # Examples
-///
-/// ```
-/// use futures::task::noop_waker_ref;
-/// let waker = noop_waker_ref();
-/// waker.wake_by_ref();
-/// ```
-#[inline]
-pub fn noop_waker_ref() -> &'static Waker {
-    struct SyncRawWaker(RawWaker);
-    unsafe impl Sync for SyncRawWaker {}
-
-    static NOOP_WAKER_INSTANCE: SyncRawWaker = SyncRawWaker(noop_raw_waker());
-
-    // SAFETY: `Waker` is #[repr(transparent)] over its `RawWaker`.
-    unsafe { &*(&NOOP_WAKER_INSTANCE.0 as *const RawWaker as *const Waker) }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    #[cfg(feature = "std")]
-    fn issue_2091_cross_thread_segfault() {
-        let waker = std::thread::spawn(super::noop_waker_ref).join().unwrap();
-        waker.wake_by_ref();
-    }
-}
diff --git a/vendor/futures-task/src/spawn.rs b/vendor/futures-task/src/spawn.rs
deleted file mode 100644
index 4a9a45a4..00000000
--- a/vendor/futures-task/src/spawn.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-use crate::{FutureObj, LocalFutureObj};
-use core::fmt;
-
-/// The `Spawn` trait allows for pushing futures onto an executor that will
-/// run them to completion.
-pub trait Spawn {
-    /// Spawns a future that will be run to completion.
-    ///
-    /// # Errors
-    ///
-    /// The executor may be unable to spawn tasks. Spawn errors should
-    /// represent relatively rare scenarios, such as the executor
-    /// having been shut down so that it is no longer able to accept
-    /// tasks.
-    fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError>;
-
-    /// Determines whether the executor is able to spawn new tasks.
-    ///
-    /// This method will return `Ok` when the executor is *likely*
-    /// (but not guaranteed) to accept a subsequent spawn attempt.
-    /// Likewise, an `Err` return means that `spawn` is likely, but
-    /// not guaranteed, to yield an error.
-    #[inline]
-    fn status(&self) -> Result<(), SpawnError> {
-        Ok(())
-    }
-}
-
-/// The `LocalSpawn` is similar to [`Spawn`], but allows spawning futures
-/// that don't implement `Send`.
-pub trait LocalSpawn {
-    /// Spawns a future that will be run to completion.
-    ///
-    /// # Errors
-    ///
-    /// The executor may be unable to spawn tasks. Spawn errors should
-    /// represent relatively rare scenarios, such as the executor
-    /// having been shut down so that it is no longer able to accept
-    /// tasks.
-    fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError>;
-
-    /// Determines whether the executor is able to spawn new tasks.
-    ///
-    /// This method will return `Ok` when the executor is *likely*
-    /// (but not guaranteed) to accept a subsequent spawn attempt.
-    /// Likewise, an `Err` return means that `spawn` is likely, but
-    /// not guaranteed, to yield an error.
-    #[inline]
-    fn status_local(&self) -> Result<(), SpawnError> {
-        Ok(())
-    }
-}
-
-/// An error that occurred during spawning.
-pub struct SpawnError {
-    _priv: (),
-}
-
-impl fmt::Debug for SpawnError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("SpawnError").field(&"shutdown").finish()
-    }
-}
-
-impl fmt::Display for SpawnError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Executor is shutdown")
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for SpawnError {}
-
-impl SpawnError {
-    /// Spawning failed because the executor has been shut down.
-    pub fn shutdown() -> Self {
-        Self { _priv: () }
-    }
-
-    /// Check whether spawning failed to the executor being shut down.
-    pub fn is_shutdown(&self) -> bool {
-        true
-    }
-}
-
-impl<Sp: ?Sized + Spawn> Spawn for &Sp {
-    fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
-        Sp::spawn_obj(self, future)
-    }
-
-    fn status(&self) -> Result<(), SpawnError> {
-        Sp::status(self)
-    }
-}
-
-impl<Sp: ?Sized + Spawn> Spawn for &mut Sp {
-    fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
-        Sp::spawn_obj(self, future)
-    }
-
-    fn status(&self) -> Result<(), SpawnError> {
-        Sp::status(self)
-    }
-}
-
-impl<Sp: ?Sized + LocalSpawn> LocalSpawn for &Sp {
-    fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError> {
-        Sp::spawn_local_obj(self, future)
-    }
-
-    fn status_local(&self) -> Result<(), SpawnError> {
-        Sp::status_local(self)
-    }
-}
-
-impl<Sp: ?Sized + LocalSpawn> LocalSpawn for &mut Sp {
-    fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError> {
-        Sp::spawn_local_obj(self, future)
-    }
-
-    fn status_local(&self) -> Result<(), SpawnError> {
-        Sp::status_local(self)
-    }
-}
-
-#[cfg(feature = "alloc")]
-mod if_alloc {
-    use super::*;
-    use alloc::{boxed::Box, rc::Rc};
-
-    impl<Sp: ?Sized + Spawn> Spawn for Box<Sp> {
-        fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
-            (**self).spawn_obj(future)
-        }
-
-        fn status(&self) -> Result<(), SpawnError> {
-            (**self).status()
-        }
-    }
-
-    impl<Sp: ?Sized + LocalSpawn> LocalSpawn for Box<Sp> {
-        fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError> {
-            (**self).spawn_local_obj(future)
-        }
-
-        fn status_local(&self) -> Result<(), SpawnError> {
-            (**self).status_local()
-        }
-    }
-
-    impl<Sp: ?Sized + Spawn> Spawn for Rc<Sp> {
-        fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
-            (**self).spawn_obj(future)
-        }
-
-        fn status(&self) -> Result<(), SpawnError> {
-            (**self).status()
-        }
-    }
-
-    impl<Sp: ?Sized + LocalSpawn> LocalSpawn for Rc<Sp> {
-        fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError> {
-            (**self).spawn_local_obj(future)
-        }
-
-        fn status_local(&self) -> Result<(), SpawnError> {
-            (**self).status_local()
-        }
-    }
-
-    #[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
-    impl<Sp: ?Sized + Spawn> Spawn for alloc::sync::Arc<Sp> {
-        fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
-            (**self).spawn_obj(future)
-        }
-
-        fn status(&self) -> Result<(), SpawnError> {
-            (**self).status()
-        }
-    }
-
-    #[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
-    impl<Sp: ?Sized + LocalSpawn> LocalSpawn for alloc::sync::Arc<Sp> {
-        fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError> {
-            (**self).spawn_local_obj(future)
-        }
-
-        fn status_local(&self) -> Result<(), SpawnError> {
-            (**self).status_local()
-        }
-    }
-}
diff --git a/vendor/futures-task/src/waker.rs b/vendor/futures-task/src/waker.rs
deleted file mode 100644
index ce90aa83..00000000
--- a/vendor/futures-task/src/waker.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use super::arc_wake::ArcWake;
-use alloc::sync::Arc;
-use core::mem;
-use core::task::{RawWaker, RawWakerVTable, Waker};
-
-pub(super) fn waker_vtable<W: ArcWake + 'static>() -> &'static RawWakerVTable {
-    &RawWakerVTable::new(
-        clone_arc_raw::<W>,
-        wake_arc_raw::<W>,
-        wake_by_ref_arc_raw::<W>,
-        drop_arc_raw::<W>,
-    )
-}
-
-/// Creates a [`Waker`] from an `Arc<impl ArcWake>`.
-///
-/// The returned [`Waker`] will call
-/// [`ArcWake.wake()`](ArcWake::wake) if awoken.
-pub fn waker<W>(wake: Arc<W>) -> Waker
-where
-    W: ArcWake + 'static,
-{
-    let ptr = Arc::into_raw(wake).cast::<()>();
-
-    unsafe { Waker::from_raw(RawWaker::new(ptr, waker_vtable::<W>())) }
-}
-
-// FIXME: panics on Arc::clone / refcount changes could wreak havoc on the
-// code here. We should guard against this by aborting.
-
-#[allow(clippy::redundant_clone)] // The clone here isn't actually redundant.
-unsafe fn increase_refcount<T: ArcWake + 'static>(data: *const ()) {
-    // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop
-    let arc = mem::ManuallyDrop::new(unsafe { Arc::<T>::from_raw(data.cast::<T>()) });
-    // Now increase refcount, but don't drop new refcount either
-    let _arc_clone: mem::ManuallyDrop<_> = arc.clone();
-}
-
-// used by `waker_ref`
-#[inline(always)]
-unsafe fn clone_arc_raw<T: ArcWake + 'static>(data: *const ()) -> RawWaker {
-    unsafe { increase_refcount::<T>(data) }
-    RawWaker::new(data, waker_vtable::<T>())
-}
-
-unsafe fn wake_arc_raw<T: ArcWake + 'static>(data: *const ()) {
-    let arc: Arc<T> = unsafe { Arc::from_raw(data.cast::<T>()) };
-    ArcWake::wake(arc);
-}
-
-// used by `waker_ref`
-unsafe fn wake_by_ref_arc_raw<T: ArcWake + 'static>(data: *const ()) {
-    // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop
-    let arc = mem::ManuallyDrop::new(unsafe { Arc::<T>::from_raw(data.cast::<T>()) });
-    ArcWake::wake_by_ref(&arc);
-}
-
-unsafe fn drop_arc_raw<T: ArcWake + 'static>(data: *const ()) {
-    drop(unsafe { Arc::<T>::from_raw(data.cast::<T>()) })
-}
diff --git a/vendor/futures-task/src/waker_ref.rs b/vendor/futures-task/src/waker_ref.rs
deleted file mode 100644
index 5957b4d4..00000000
--- a/vendor/futures-task/src/waker_ref.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use super::arc_wake::ArcWake;
-use super::waker::waker_vtable;
-use alloc::sync::Arc;
-use core::marker::PhantomData;
-use core::mem::ManuallyDrop;
-use core::ops::Deref;
-use core::task::{RawWaker, Waker};
-
-/// A [`Waker`] that is only valid for a given lifetime.
-///
-/// Note: this type implements [`Deref<Target = Waker>`](std::ops::Deref),
-/// so it can be used to get a `&Waker`.
-#[derive(Debug)]
-pub struct WakerRef<'a> {
-    waker: ManuallyDrop<Waker>,
-    _marker: PhantomData<&'a ()>,
-}
-
-impl<'a> WakerRef<'a> {
-    /// Create a new [`WakerRef`] from a [`Waker`] reference.
-    #[inline]
-    pub fn new(waker: &'a Waker) -> Self {
-        // copy the underlying (raw) waker without calling a clone,
-        // as we won't call Waker::drop either.
-        let waker = ManuallyDrop::new(unsafe { core::ptr::read(waker) });
-        Self { waker, _marker: PhantomData }
-    }
-
-    /// Create a new [`WakerRef`] from a [`Waker`] that must not be dropped.
-    ///
-    /// Note: this if for rare cases where the caller created a [`Waker`] in
-    /// an unsafe way (that will be valid only for a lifetime to be determined
-    /// by the caller), and the [`Waker`] doesn't need to or must not be
-    /// destroyed.
-    #[inline]
-    pub fn new_unowned(waker: ManuallyDrop<Waker>) -> Self {
-        Self { waker, _marker: PhantomData }
-    }
-}
-
-impl Deref for WakerRef<'_> {
-    type Target = Waker;
-
-    #[inline]
-    fn deref(&self) -> &Waker {
-        &self.waker
-    }
-}
-
-/// Creates a reference to a [`Waker`] from a reference to `Arc<impl ArcWake>`.
-///
-/// The resulting [`Waker`] will call
-/// [`ArcWake.wake()`](ArcWake::wake) if awoken.
-#[inline]
-pub fn waker_ref<W>(wake: &Arc<W>) -> WakerRef<'_>
-where
-    W: ArcWake + 'static,
-{
-    // simply copy the pointer instead of using Arc::into_raw,
-    // as we don't actually keep a refcount by using ManuallyDrop.<
-    let ptr = Arc::as_ptr(wake).cast::<()>();
-
-    let waker =
-        ManuallyDrop::new(unsafe { Waker::from_raw(RawWaker::new(ptr, waker_vtable::<W>())) });
-    WakerRef::new_unowned(waker)
-}