[INFO] fetching crate tea-actor-utility 0.1.0...
[INFO] testing tea-actor-utility-0.1.0 against try#c2e32f1c9652b13ed99608599c1e855462f421f3 for pr-146098-7
[INFO] extracting crate tea-actor-utility 0.1.0 into /workspace/builds/worker-1-tc2/source
[INFO] started tweaking crates.io crate tea-actor-utility 0.1.0
[INFO] finished tweaking crates.io crate tea-actor-utility 0.1.0
[INFO] tweaked toml for crates.io crate tea-actor-utility 0.1.0 written to /workspace/builds/worker-1-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate tea-actor-utility 0.1.0 on toolchain c2e32f1c9652b13ed99608599c1e855462f421f3
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2e32f1c9652b13ed99608599c1e855462f421f3" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2e32f1c9652b13ed99608599c1e855462f421f3" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]      Locking 24 packages to latest compatible versions
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2e32f1c9652b13ed99608599c1e855462f421f3" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4848fb76d95f26979359cc7e45710b1dbc8f3acb7aeedee7c460d7702230f228" "/opt/rustwide/cargo-home/bin/cargo" "+c2e32f1c9652b13ed99608599c1e855462f421f3" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 0db2fea450f6875e6ccf92dd47ae569b1b6b4aea335c56a546dfc26efdcd39bc
[INFO] running `Command { std: "docker" "start" "-a" "0db2fea450f6875e6ccf92dd47ae569b1b6b4aea335c56a546dfc26efdcd39bc", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "0db2fea450f6875e6ccf92dd47ae569b1b6b4aea335c56a546dfc26efdcd39bc", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "0db2fea450f6875e6ccf92dd47ae569b1b6b4aea335c56a546dfc26efdcd39bc", kill_on_drop: false }`
[INFO] [stdout] 0db2fea450f6875e6ccf92dd47ae569b1b6b4aea335c56a546dfc26efdcd39bc
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4848fb76d95f26979359cc7e45710b1dbc8f3acb7aeedee7c460d7702230f228" "/opt/rustwide/cargo-home/bin/cargo" "+c2e32f1c9652b13ed99608599c1e855462f421f3" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] fecbf9df9603d1c96977607484b99ed4ac50efa03cdc5d47e9ff9564f4db7ebb
[INFO] running `Command { std: "docker" "start" "-a" "fecbf9df9603d1c96977607484b99ed4ac50efa03cdc5d47e9ff9564f4db7ebb", kill_on_drop: false }`
[INFO] [stderr]    Compiling wapc-guest v0.3.2
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]    Compiling rmp v0.8.14
[INFO] [stderr]    Compiling log v0.4.28
[INFO] [stderr]    Compiling rmp-serde v0.14.4
[INFO] [stderr]    Compiling wascc-codec v0.8.1
[INFO] [stderr]    Compiling tea-codec v0.1.1
[INFO] [stderr]    Compiling wascc-actor v0.7.4
[INFO] [stderr]    Compiling tea-actor-utility v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]  --> src/actor_kvp.rs:9:67
[INFO] [stdout]   |
[INFO] [stdout] 8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]   |                                                                                                                ---------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 9 |   let req = SetRequest{key: key.to_owned(), value:serialize(value)?, expires_s:0};
[INFO] [stdout]   |                                                   ----------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]   |                                                   |
[INFO] [stdout]   |                                                   this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]   |
[INFO] [stdout]   = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]   = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]  --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]   = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]  --> src/actor_kvp.rs:9:67
[INFO] [stdout]   |
[INFO] [stdout] 8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]   |                                                                                                                ---------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 9 |   let req = SetRequest{key: key.to_owned(), value:serialize(value)?, expires_s:0};
[INFO] [stdout]   |                                                   ----------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]   |                                                   |
[INFO] [stdout]   |                                                   this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]   |
[INFO] [stdout]   = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]   = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]  --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]   = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]  --> src/actor_kvp.rs:9:67
[INFO] [stdout]   |
[INFO] [stdout] 8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]   |                                                                                                                ---------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 9 |   let req = SetRequest{key: key.to_owned(), value:serialize(value)?, expires_s:0};
[INFO] [stdout]   |                                                   ----------------^ doesn't have a size known at compile-time
[INFO] [stdout]   |                                                   |
[INFO] [stdout]   |                                                   this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]   |
[INFO] [stdout]   = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]   = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]   = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:13:19
[INFO] [stdout]    |
[INFO] [stdout]  8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                ---------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 13 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:13:19
[INFO] [stdout]    |
[INFO] [stdout]  8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                ---------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 13 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:13:19
[INFO] [stdout]    |
[INFO] [stdout]  8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                ---------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 13 |     serialize(req)?
[INFO] [stdout]    |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:14:17
[INFO] [stdout]    |
[INFO] [stdout]  8 |   pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                  ---------------- required `dyn StdError: Send` because of this
[INFO] [stdout]  9 |     let req = SetRequest{key: key.to_owned(), value:serialize(value)?, expires_s:0};
[INFO] [stdout] 10 |     let res : SetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 11 | |     CAPABILITY,
[INFO] [stdout] 12 | |     OP_SET,
[INFO] [stdout] 13 | |     serialize(req)?
[INFO] [stdout] 14 | |   )?.as_slice())?; 
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:14:17
[INFO] [stdout]    |
[INFO] [stdout]  8 |   pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                  ---------------- required `dyn StdError: Sync` because of this
[INFO] [stdout]  9 |     let req = SetRequest{key: key.to_owned(), value:serialize(value)?, expires_s:0};
[INFO] [stdout] 10 |     let res : SetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 11 | |     CAPABILITY,
[INFO] [stdout] 12 | |     OP_SET,
[INFO] [stdout] 13 | |     serialize(req)?
[INFO] [stdout] 14 | |   )?.as_slice())?; 
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:14:17
[INFO] [stdout]    |
[INFO] [stdout]  8 |   pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                  ---------------- required `dyn StdError: Sized` because of this
[INFO] [stdout]  9 |     let req = SetRequest{key: key.to_owned(), value:serialize(value)?, expires_s:0};
[INFO] [stdout] 10 |     let res : SetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 11 | |     CAPABILITY,
[INFO] [stdout] 12 | |     OP_SET,
[INFO] [stdout] 13 | |     serialize(req)?
[INFO] [stdout] 14 | |   )?.as_slice())?; 
[INFO] [stdout]    | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:15:52
[INFO] [stdout]    |
[INFO] [stdout]  8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                ---------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 15 |   let result: T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |                   ---------------------------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:15:52
[INFO] [stdout]    |
[INFO] [stdout]  8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                ---------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 15 |   let result: T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |                   ---------------------------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:15:52
[INFO] [stdout]    |
[INFO] [stdout]  8 | pub fn set_forever<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                ---------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 15 |   let result: T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |                   ---------------------------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:24:19
[INFO] [stdout]    |
[INFO] [stdout] 19 | pub fn add (binding_name: &'static str, key: &str, value: i32) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                   ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 24 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:24:19
[INFO] [stdout]    |
[INFO] [stdout] 19 | pub fn add (binding_name: &'static str, key: &str, value: i32) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                   ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 24 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:24:19
[INFO] [stdout]    |
[INFO] [stdout] 19 | pub fn add (binding_name: &'static str, key: &str, value: i32) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                   ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 24 |     serialize(req)?
[INFO] [stdout]    |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:25:17
[INFO] [stdout]    |
[INFO] [stdout] 19 |   pub fn add (binding_name: &'static str, key: &str, value: i32) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                     ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 20 |     let req = AddRequest{key: key.to_owned(), value:value};
[INFO] [stdout] 21 |     let res: AddResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 22 | |     CAPABILITY,
[INFO] [stdout] 23 | |     OP_ADD,
[INFO] [stdout] 24 | |     serialize(req)?
[INFO] [stdout] 25 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:25:17
[INFO] [stdout]    |
[INFO] [stdout] 19 |   pub fn add (binding_name: &'static str, key: &str, value: i32) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                     ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 20 |     let req = AddRequest{key: key.to_owned(), value:value};
[INFO] [stdout] 21 |     let res: AddResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 22 | |     CAPABILITY,
[INFO] [stdout] 23 | |     OP_ADD,
[INFO] [stdout] 24 | |     serialize(req)?
[INFO] [stdout] 25 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:25:17
[INFO] [stdout]    |
[INFO] [stdout] 19 |   pub fn add (binding_name: &'static str, key: &str, value: i32) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                     ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 20 |     let req = AddRequest{key: key.to_owned(), value:value};
[INFO] [stdout] 21 |     let res: AddResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 22 | |     CAPABILITY,
[INFO] [stdout] 23 | |     OP_ADD,
[INFO] [stdout] 24 | |     serialize(req)?
[INFO] [stdout] 25 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:34:19
[INFO] [stdout]    |
[INFO] [stdout] 29 | pub fn del (binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                       --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 34 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:34:19
[INFO] [stdout]    |
[INFO] [stdout] 29 | pub fn del (binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                       --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 34 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:34:19
[INFO] [stdout]    |
[INFO] [stdout] 29 | pub fn del (binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                       --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 34 |     serialize(req)?
[INFO] [stdout]    |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:35:17
[INFO] [stdout]    |
[INFO] [stdout] 29 |   pub fn del (binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                         --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 30 |     let req = DelRequest{key: key.to_owned()};
[INFO] [stdout] 31 |     let res: DelResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 32 | |     CAPABILITY,
[INFO] [stdout] 33 | |     OP_DEL,
[INFO] [stdout] 34 | |     serialize(req)?
[INFO] [stdout] 35 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:35:17
[INFO] [stdout]    |
[INFO] [stdout] 29 |   pub fn del (binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                         --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 30 |     let req = DelRequest{key: key.to_owned()};
[INFO] [stdout] 31 |     let res: DelResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 32 | |     CAPABILITY,
[INFO] [stdout] 33 | |     OP_DEL,
[INFO] [stdout] 34 | |     serialize(req)?
[INFO] [stdout] 35 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:35:17
[INFO] [stdout]    |
[INFO] [stdout] 29 |   pub fn del (binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                         --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 30 |     let req = DelRequest{key: key.to_owned()};
[INFO] [stdout] 31 |     let res: DelResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 32 | |     CAPABILITY,
[INFO] [stdout] 33 | |     OP_DEL,
[INFO] [stdout] 34 | |     serialize(req)?
[INFO] [stdout] 35 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:44:19
[INFO] [stdout]    |
[INFO] [stdout] 39 | pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                 ------------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 44 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:44:19
[INFO] [stdout]    |
[INFO] [stdout] 39 | pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                 ------------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 44 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:44:19
[INFO] [stdout]    |
[INFO] [stdout] 39 | pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                 ------------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 44 |     serialize(req)?
[INFO] [stdout]    |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:45:17
[INFO] [stdout]    |
[INFO] [stdout] 39 |   pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                   ------------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 40 |     let req = GetRequest{key: key.to_owned()};
[INFO] [stdout] 41 |     let res : GetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 42 | |     CAPABILITY,
[INFO] [stdout] 43 | |     OP_GET,
[INFO] [stdout] 44 | |     serialize(req)?
[INFO] [stdout] 45 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:45:17
[INFO] [stdout]    |
[INFO] [stdout] 39 |   pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                   ------------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 40 |     let req = GetRequest{key: key.to_owned()};
[INFO] [stdout] 41 |     let res : GetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 42 | |     CAPABILITY,
[INFO] [stdout] 43 | |     OP_GET,
[INFO] [stdout] 44 | |     serialize(req)?
[INFO] [stdout] 45 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:45:17
[INFO] [stdout]    |
[INFO] [stdout] 39 |   pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                   ------------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 40 |     let req = GetRequest{key: key.to_owned()};
[INFO] [stdout] 41 |     let res : GetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 42 | |     CAPABILITY,
[INFO] [stdout] 43 | |     OP_GET,
[INFO] [stdout] 44 | |     serialize(req)?
[INFO] [stdout] 45 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:48:54
[INFO] [stdout]    |
[INFO] [stdout] 39 | pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                 ------------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 48 |     let result: T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |                     ---------------------------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:48:54
[INFO] [stdout]    |
[INFO] [stdout] 39 | pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                 ------------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 48 |     let result: T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |                     ---------------------------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:48:54
[INFO] [stdout]    |
[INFO] [stdout] 39 | pub fn get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Option<T>> {
[INFO] [stdout]    |                                                                                 ------------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 48 |     let result: T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |                     ---------------------------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:61:19
[INFO] [stdout]    |
[INFO] [stdout] 56 | pub fn list_clear(binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                             --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 61 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:61:19
[INFO] [stdout]    |
[INFO] [stdout] 56 | pub fn list_clear(binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                             --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 61 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:61:19
[INFO] [stdout]    |
[INFO] [stdout] 56 | pub fn list_clear(binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                             --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 61 |     serialize(req)?
[INFO] [stdout]    |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:62:17
[INFO] [stdout]    |
[INFO] [stdout] 56 |   pub fn list_clear(binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                               --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 57 |     let req = DelRequest{key: key.to_owned()};
[INFO] [stdout] 58 |     let res: DelResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 59 | |     CAPABILITY,
[INFO] [stdout] 60 | |     OP_DEL,
[INFO] [stdout] 61 | |     serialize(req)?
[INFO] [stdout] 62 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:62:17
[INFO] [stdout]    |
[INFO] [stdout] 56 |   pub fn list_clear(binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                               --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 57 |     let req = DelRequest{key: key.to_owned()};
[INFO] [stdout] 58 |     let res: DelResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 59 | |     CAPABILITY,
[INFO] [stdout] 60 | |     OP_DEL,
[INFO] [stdout] 61 | |     serialize(req)?
[INFO] [stdout] 62 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:62:17
[INFO] [stdout]    |
[INFO] [stdout] 56 |   pub fn list_clear(binding_name: &'static str, key: &str) -> HandlerResult<String> {
[INFO] [stdout]    |                                                               --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 57 |     let req = DelRequest{key: key.to_owned()};
[INFO] [stdout] 58 |     let res: DelResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  __________________________-
[INFO] [stdout] 59 | |     CAPABILITY,
[INFO] [stdout] 60 | |     OP_DEL,
[INFO] [stdout] 61 | |     serialize(req)?
[INFO] [stdout] 62 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:71:19
[INFO] [stdout]    |
[INFO] [stdout] 66 | pub fn list_range<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, start:i32, stop:i32) -> HandlerResult<Vec<T>> {
[INFO] [stdout]    |                                                                                                                         --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 71 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:71:19
[INFO] [stdout]    |
[INFO] [stdout] 66 | pub fn list_range<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, start:i32, stop:i32) -> HandlerResult<Vec<T>> {
[INFO] [stdout]    |                                                                                                                         --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 71 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:71:19
[INFO] [stdout]    |
[INFO] [stdout] 66 | pub fn list_range<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, start:i32, stop:i32) -> HandlerResult<Vec<T>> {
[INFO] [stdout]    |                                                                                                                         --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 71 |     serialize(req)?
[INFO] [stdout]    |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:72:17
[INFO] [stdout]    |
[INFO] [stdout] 66 |   pub fn list_range<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, start:i32, stop:i32) -> HandlerResult<Vec<T>> {
[INFO] [stdout]    |                                                                                                                           --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 67 |     let req = ListRangeRequest{key: key.to_owned(), start: start, stop: stop};
[INFO] [stdout] 68 |     let res: ListRangeResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ________________________________-
[INFO] [stdout] 69 | |     CAPABILITY,
[INFO] [stdout] 70 | |     OP_RANGE,
[INFO] [stdout] 71 | |     serialize(req)?
[INFO] [stdout] 72 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:72:17
[INFO] [stdout]    |
[INFO] [stdout] 66 |   pub fn list_range<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, start:i32, stop:i32) -> HandlerResult<Vec<T>> {
[INFO] [stdout]    |                                                                                                                           --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 67 |     let req = ListRangeRequest{key: key.to_owned(), start: start, stop: stop};
[INFO] [stdout] 68 |     let res: ListRangeResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ________________________________-
[INFO] [stdout] 69 | |     CAPABILITY,
[INFO] [stdout] 70 | |     OP_RANGE,
[INFO] [stdout] 71 | |     serialize(req)?
[INFO] [stdout] 72 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:72:17
[INFO] [stdout]    |
[INFO] [stdout] 66 |   pub fn list_range<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, start:i32, stop:i32) -> HandlerResult<Vec<T>> {
[INFO] [stdout]    |                                                                                                                           --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 67 |     let req = ListRangeRequest{key: key.to_owned(), start: start, stop: stop};
[INFO] [stdout] 68 |     let res: ListRangeResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ________________________________-
[INFO] [stdout] 69 | |     CAPABILITY,
[INFO] [stdout] 70 | |     OP_RANGE,
[INFO] [stdout] 71 | |     serialize(req)?
[INFO] [stdout] 72 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:78:73
[INFO] [stdout]    |
[INFO] [stdout] 77 | pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                              ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 78 |   let req = ListPushRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]    |                                                         ----------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |                                                         |
[INFO] [stdout]    |                                                         this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:78:73
[INFO] [stdout]    |
[INFO] [stdout] 77 | pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                              ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 78 |   let req = ListPushRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]    |                                                         ----------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |                                                         |
[INFO] [stdout]    |                                                         this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:78:73
[INFO] [stdout]    |
[INFO] [stdout] 77 | pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                              ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 78 |   let req = ListPushRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]    |                                                         ----------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |                                                         |
[INFO] [stdout]    |                                                         this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:82:19
[INFO] [stdout]    |
[INFO] [stdout] 77 | pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                              ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 82 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:82:19
[INFO] [stdout]    |
[INFO] [stdout] 77 | pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                              ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 82 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:82:19
[INFO] [stdout]    |
[INFO] [stdout] 77 | pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                              ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 82 |     serialize(req)?
[INFO] [stdout]    |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:83:17
[INFO] [stdout]    |
[INFO] [stdout] 77 |   pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                                ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 78 |     let req = ListPushRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 79 |     let res : ListResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ____________________________-
[INFO] [stdout] 80 | |     CAPABILITY,
[INFO] [stdout] 81 | |     OP_PUSH,
[INFO] [stdout] 82 | |     serialize(req)?
[INFO] [stdout] 83 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:83:17
[INFO] [stdout]    |
[INFO] [stdout] 77 |   pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                                ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 78 |     let req = ListPushRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 79 |     let res : ListResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ____________________________-
[INFO] [stdout] 80 | |     CAPABILITY,
[INFO] [stdout] 81 | |     OP_PUSH,
[INFO] [stdout] 82 | |     serialize(req)?
[INFO] [stdout] 83 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:83:17
[INFO] [stdout]    |
[INFO] [stdout] 77 |   pub fn list_push<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]    |                                                                                                                ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 78 |     let req = ListPushRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 79 |     let res : ListResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ____________________________-
[INFO] [stdout] 80 | |     CAPABILITY,
[INFO] [stdout] 81 | |     OP_PUSH,
[INFO] [stdout] 82 | |     serialize(req)?
[INFO] [stdout] 83 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:88:68
[INFO] [stdout]    |
[INFO] [stdout] 87 | ...eserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                          ---------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 88 | ...to_owned(), value: serialize(value)?, expires_s:expires_s};
[INFO] [stdout]    |                       ----------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |                       |
[INFO] [stdout]    |                       this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:88:68
[INFO] [stdout]    |
[INFO] [stdout] 87 | ...eserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                          ---------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 88 | ...to_owned(), value: serialize(value)?, expires_s:expires_s};
[INFO] [stdout]    |                       ----------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |                       |
[INFO] [stdout]    |                       this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:88:68
[INFO] [stdout]    |
[INFO] [stdout] 87 | ...eserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                          ---------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 88 | ...to_owned(), value: serialize(value)?, expires_s:expires_s};
[INFO] [stdout]    |                       ----------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |                       |
[INFO] [stdout]    |                       this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:92:19
[INFO] [stdout]    |
[INFO] [stdout] 87 | pub fn set<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                       ---------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 92 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:92:19
[INFO] [stdout]    |
[INFO] [stdout] 87 | pub fn set<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                       ---------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 92 |     serialize(req)?
[INFO] [stdout]    |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:92:19
[INFO] [stdout]    |
[INFO] [stdout] 87 | pub fn set<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                       ---------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 92 |     serialize(req)?
[INFO] [stdout]    |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |     |
[INFO] [stdout]    |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:93:17
[INFO] [stdout]    |
[INFO] [stdout] 87 |   pub fn set<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                         ---------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 88 |     let req = SetRequest{key: key.to_owned(), value: serialize(value)?, expires_s:expires_s};
[INFO] [stdout] 89 |     let res : SetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 90 | |     CAPABILITY,
[INFO] [stdout] 91 | |     OP_SET,
[INFO] [stdout] 92 | |     serialize(req)?
[INFO] [stdout] 93 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:93:17
[INFO] [stdout]    |
[INFO] [stdout] 87 |   pub fn set<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                         ---------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 88 |     let req = SetRequest{key: key.to_owned(), value: serialize(value)?, expires_s:expires_s};
[INFO] [stdout] 89 |     let res : SetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 90 | |     CAPABILITY,
[INFO] [stdout] 91 | |     OP_SET,
[INFO] [stdout] 92 | |     serialize(req)?
[INFO] [stdout] 93 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:93:17
[INFO] [stdout]    |
[INFO] [stdout] 87 |   pub fn set<'de, T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                                         ---------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 88 |     let req = SetRequest{key: key.to_owned(), value: serialize(value)?, expires_s:expires_s};
[INFO] [stdout] 89 |     let res : SetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]    |  ___________________________-
[INFO] [stdout] 90 | |     CAPABILITY,
[INFO] [stdout] 91 | |     OP_SET,
[INFO] [stdout] 92 | |     serialize(req)?
[INFO] [stdout] 93 | |   )?.as_slice())?;
[INFO] [stdout]    | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]    | |________________|
[INFO] [stdout]    |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:94:53
[INFO] [stdout]    |
[INFO] [stdout] 87 | ..., T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                            ---------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 94 | ... T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |         ---------------------------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]    |         |
[INFO] [stdout]    |         this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:94:53
[INFO] [stdout]    |
[INFO] [stdout] 87 | ..., T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                            ---------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 94 | ... T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |         ---------------------------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]    |         |
[INFO] [stdout]    |         this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]   --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]   --> src/actor_kvp.rs:94:53
[INFO] [stdout]    |
[INFO] [stdout] 87 | ..., T: Serialize + Deserialize<'de>> (binding_name: &'static str, key: &str, value: &T, expires_s:i32) -> HandlerResult<T> {
[INFO] [stdout]    |                                                                                                            ---------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 94 | ... T = deserialize(res.value.as_slice())?;
[INFO] [stdout]    |         ---------------------------------^ doesn't have a size known at compile-time
[INFO] [stdout]    |         |
[INFO] [stdout]    |         this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]    |
[INFO] [stdout]    = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]    = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]    = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:100:76
[INFO] [stdout]     |
[INFO] [stdout]  99 | pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                          ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 100 |   let req = ListDelItemRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                            ----------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |                                                            |
[INFO] [stdout]     |                                                            this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:100:76
[INFO] [stdout]     |
[INFO] [stdout]  99 | pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                          ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 100 |   let req = ListDelItemRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                            ----------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |                                                            |
[INFO] [stdout]     |                                                            this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:100:76
[INFO] [stdout]     |
[INFO] [stdout]  99 | pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                          ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 100 |   let req = ListDelItemRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                            ----------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |                                                            |
[INFO] [stdout]     |                                                            this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:104:19
[INFO] [stdout]     |
[INFO] [stdout]  99 | pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                          ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 104 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:104:19
[INFO] [stdout]     |
[INFO] [stdout]  99 | pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                          ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 104 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:104:19
[INFO] [stdout]     |
[INFO] [stdout]  99 | pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                          ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 104 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:105:17
[INFO] [stdout]     |
[INFO] [stdout]  99 |   pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                            ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 100 |     let req = ListDelItemRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 101 |     let res : ListResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ____________________________-
[INFO] [stdout] 102 | |     CAPABILITY,
[INFO] [stdout] 103 | |     OP_LIST_DEL,
[INFO] [stdout] 104 | |     serialize(req)?
[INFO] [stdout] 105 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:105:17
[INFO] [stdout]     |
[INFO] [stdout]  99 |   pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                            ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 100 |     let req = ListDelItemRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 101 |     let res : ListResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ____________________________-
[INFO] [stdout] 102 | |     CAPABILITY,
[INFO] [stdout] 103 | |     OP_LIST_DEL,
[INFO] [stdout] 104 | |     serialize(req)?
[INFO] [stdout] 105 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:105:17
[INFO] [stdout]     |
[INFO] [stdout]  99 |   pub fn list_del_item<T: Serialize> (binding_name: &'static str, key: &str, value: &T) -> HandlerResult<i32> {
[INFO] [stdout]     |                                                                                            ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 100 |     let req = ListDelItemRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 101 |     let res : ListResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ____________________________-
[INFO] [stdout] 102 | |     CAPABILITY,
[INFO] [stdout] 103 | |     OP_LIST_DEL,
[INFO] [stdout] 104 | |     serialize(req)?
[INFO] [stdout] 105 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:110:71
[INFO] [stdout]     |
[INFO] [stdout] 109 | pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                   ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 110 |   let req = SetAddRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                       ----------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |                                                       |
[INFO] [stdout]     |                                                       this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:110:71
[INFO] [stdout]     |
[INFO] [stdout] 109 | pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                   ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 110 |   let req = SetAddRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                       ----------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |                                                       |
[INFO] [stdout]     |                                                       this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:110:71
[INFO] [stdout]     |
[INFO] [stdout] 109 | pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                   ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 110 |   let req = SetAddRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                       ----------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |                                                       |
[INFO] [stdout]     |                                                       this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:114:19
[INFO] [stdout]     |
[INFO] [stdout] 109 | pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                   ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 114 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:114:19
[INFO] [stdout]     |
[INFO] [stdout] 109 | pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                   ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 114 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:114:19
[INFO] [stdout]     |
[INFO] [stdout] 109 | pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                   ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 114 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:115:17
[INFO] [stdout]     |
[INFO] [stdout] 109 |   pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                     ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 110 |     let req = SetAddRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 111 |     let res: SetOperationResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 112 | |     CAPABILITY,
[INFO] [stdout] 113 | |     OP_SET_ADD,
[INFO] [stdout] 114 | |     serialize(req)?
[INFO] [stdout] 115 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:115:17
[INFO] [stdout]     |
[INFO] [stdout] 109 |   pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                     ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 110 |     let req = SetAddRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 111 |     let res: SetOperationResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 112 | |     CAPABILITY,
[INFO] [stdout] 113 | |     OP_SET_ADD,
[INFO] [stdout] 114 | |     serialize(req)?
[INFO] [stdout] 115 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:115:17
[INFO] [stdout]     |
[INFO] [stdout] 109 |   pub fn set_add<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                     ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 110 |     let req = SetAddRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 111 |     let res: SetOperationResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 112 | |     CAPABILITY,
[INFO] [stdout] 113 | |     OP_SET_ADD,
[INFO] [stdout] 114 | |     serialize(req)?
[INFO] [stdout] 115 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:121:74
[INFO] [stdout]     |
[INFO] [stdout] 120 | pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                      ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 121 |   let req = SetRemoveRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                          ----------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |                                                          |
[INFO] [stdout]     |                                                          this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:121:74
[INFO] [stdout]     |
[INFO] [stdout] 120 | pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                      ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 121 |   let req = SetRemoveRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                          ----------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |                                                          |
[INFO] [stdout]     |                                                          this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:121:74
[INFO] [stdout]     |
[INFO] [stdout] 120 | pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                      ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 121 |   let req = SetRemoveRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout]     |                                                          ----------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |                                                          |
[INFO] [stdout]     |                                                          this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:125:19
[INFO] [stdout]     |
[INFO] [stdout] 120 | pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                      ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 125 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:125:19
[INFO] [stdout]     |
[INFO] [stdout] 120 | pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                      ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 125 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:125:19
[INFO] [stdout]     |
[INFO] [stdout] 120 | pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                      ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 125 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:126:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |   pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                        ------------------ required `dyn StdError: Send` because of this
[INFO] [stdout] 121 |     let req = SetRemoveRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 122 |     let res: SetOperationResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 123 | |     CAPABILITY,
[INFO] [stdout] 124 | |     OP_SET_REMOVE,
[INFO] [stdout] 125 | |     serialize(req)?
[INFO] [stdout] 126 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:126:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |   pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                        ------------------ required `dyn StdError: Sync` because of this
[INFO] [stdout] 121 |     let req = SetRemoveRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 122 |     let res: SetOperationResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 123 | |     CAPABILITY,
[INFO] [stdout] 124 | |     OP_SET_REMOVE,
[INFO] [stdout] 125 | |     serialize(req)?
[INFO] [stdout] 126 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:126:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |   pub fn set_remove<T: Serialize> (binding_name: &'static str, key: &str, value: &T) ->HandlerResult<i32>{
[INFO] [stdout]     |                                                                                        ------------------ required `dyn StdError: Sized` because of this
[INFO] [stdout] 121 |     let req = SetRemoveRequest{key: key.to_owned(), value: serialize(value)?};
[INFO] [stdout] 122 |     let res: SetOperationResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 123 | |     CAPABILITY,
[INFO] [stdout] 124 | |     OP_SET_REMOVE,
[INFO] [stdout] 125 | |     serialize(req)?
[INFO] [stdout] 126 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:139:19
[INFO] [stdout]     |
[INFO] [stdout] 133 | pub fn set_union<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                             --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 139 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:139:19
[INFO] [stdout]     |
[INFO] [stdout] 133 | pub fn set_union<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                             --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 139 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:139:19
[INFO] [stdout]     |
[INFO] [stdout] 133 | pub fn set_union<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                             --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 139 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:140:17
[INFO] [stdout]     |
[INFO] [stdout] 133 |   pub fn set_union<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                               --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 136 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 137 | |     CAPABILITY,
[INFO] [stdout] 138 | |     OP_SET_UNION,
[INFO] [stdout] 139 | |     serialize(req)?
[INFO] [stdout] 140 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:140:17
[INFO] [stdout]     |
[INFO] [stdout] 133 |   pub fn set_union<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                               --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 136 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 137 | |     CAPABILITY,
[INFO] [stdout] 138 | |     OP_SET_UNION,
[INFO] [stdout] 139 | |     serialize(req)?
[INFO] [stdout] 140 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:140:17
[INFO] [stdout]     |
[INFO] [stdout] 133 |   pub fn set_union<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                               --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 136 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 137 | |     CAPABILITY,
[INFO] [stdout] 138 | |     OP_SET_UNION,
[INFO] [stdout] 139 | |     serialize(req)?
[INFO] [stdout] 140 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:153:19
[INFO] [stdout]     |
[INFO] [stdout] 147 | pub fn set_intersect<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                                 --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 153 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:153:19
[INFO] [stdout]     |
[INFO] [stdout] 147 | pub fn set_intersect<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                                 --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 153 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:153:19
[INFO] [stdout]     |
[INFO] [stdout] 147 | pub fn set_intersect<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                                 --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 153 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:154:17
[INFO] [stdout]     |
[INFO] [stdout] 147 |   pub fn set_intersect<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                                   --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 150 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 151 | |     CAPABILITY,
[INFO] [stdout] 152 | |     OP_SET_INTERSECT,
[INFO] [stdout] 153 | |     serialize(req)?
[INFO] [stdout] 154 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:154:17
[INFO] [stdout]     |
[INFO] [stdout] 147 |   pub fn set_intersect<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                                   --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 150 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 151 | |     CAPABILITY,
[INFO] [stdout] 152 | |     OP_SET_INTERSECT,
[INFO] [stdout] 153 | |     serialize(req)?
[INFO] [stdout] 154 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:154:17
[INFO] [stdout]     |
[INFO] [stdout] 147 |   pub fn set_intersect<'de, T: Deserialize<'de>> (binding_name: &'static str, keys: Vec<&str>) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                                   --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 150 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 151 | |     CAPABILITY,
[INFO] [stdout] 152 | |     OP_SET_INTERSECT,
[INFO] [stdout] 153 | |     serialize(req)?
[INFO] [stdout] 154 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:164:19
[INFO] [stdout]     |
[INFO] [stdout] 159 | pub fn set_query<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                       --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 164 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:164:19
[INFO] [stdout]     |
[INFO] [stdout] 159 | pub fn set_query<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                       --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 164 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:164:19
[INFO] [stdout]     |
[INFO] [stdout] 159 | pub fn set_query<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                       --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 164 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:165:17
[INFO] [stdout]     |
[INFO] [stdout] 159 |   pub fn set_query<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                         --------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 160 |     let req = SetQueryRequest{key: key.to_owned()};
[INFO] [stdout] 161 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 162 | |     CAPABILITY,
[INFO] [stdout] 163 | |     OP_SET_QUERY,
[INFO] [stdout] 164 | |     serialize(req)?
[INFO] [stdout] 165 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:165:17
[INFO] [stdout]     |
[INFO] [stdout] 159 |   pub fn set_query<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                         --------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 160 |     let req = SetQueryRequest{key: key.to_owned()};
[INFO] [stdout] 161 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 162 | |     CAPABILITY,
[INFO] [stdout] 163 | |     OP_SET_QUERY,
[INFO] [stdout] 164 | |     serialize(req)?
[INFO] [stdout] 165 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:165:17
[INFO] [stdout]     |
[INFO] [stdout] 159 |   pub fn set_query<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<T>>{
[INFO] [stdout]     |                                                                                         --------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 160 |     let req = SetQueryRequest{key: key.to_owned()};
[INFO] [stdout] 161 |     let res: SetQueryResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  _______________________________-
[INFO] [stdout] 162 | |     CAPABILITY,
[INFO] [stdout] 163 | |     OP_SET_QUERY,
[INFO] [stdout] 164 | |     serialize(req)?
[INFO] [stdout] 165 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:175:19
[INFO] [stdout]     |
[INFO] [stdout] 170 | pub fn exists(binding_name: &'static str, key: &str) -> HandlerResult<bool> {
[INFO] [stdout]     |                                                         ------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 175 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:175:19
[INFO] [stdout]     |
[INFO] [stdout] 170 | pub fn exists(binding_name: &'static str, key: &str) -> HandlerResult<bool> {
[INFO] [stdout]     |                                                         ------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 175 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:175:19
[INFO] [stdout]     |
[INFO] [stdout] 170 | pub fn exists(binding_name: &'static str, key: &str) -> HandlerResult<bool> {
[INFO] [stdout]     |                                                         ------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 175 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:176:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |   pub fn exists(binding_name: &'static str, key: &str) -> HandlerResult<bool> {
[INFO] [stdout]     |                                                           ------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 171 |     let req = KeyExistsQuery{key: key.to_owned()};
[INFO] [stdout] 172 |     let res : GetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________-
[INFO] [stdout] 173 | |     CAPABILITY,
[INFO] [stdout] 174 | |     OP_KEY_EXISTS,
[INFO] [stdout] 175 | |     serialize(req)?
[INFO] [stdout] 176 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:176:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |   pub fn exists(binding_name: &'static str, key: &str) -> HandlerResult<bool> {
[INFO] [stdout]     |                                                           ------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 171 |     let req = KeyExistsQuery{key: key.to_owned()};
[INFO] [stdout] 172 |     let res : GetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________-
[INFO] [stdout] 173 | |     CAPABILITY,
[INFO] [stdout] 174 | |     OP_KEY_EXISTS,
[INFO] [stdout] 175 | |     serialize(req)?
[INFO] [stdout] 176 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:176:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |   pub fn exists(binding_name: &'static str, key: &str) -> HandlerResult<bool> {
[INFO] [stdout]     |                                                           ------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 171 |     let req = KeyExistsQuery{key: key.to_owned()};
[INFO] [stdout] 172 |     let res : GetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________-
[INFO] [stdout] 173 | |     CAPABILITY,
[INFO] [stdout] 174 | |     OP_KEY_EXISTS,
[INFO] [stdout] 175 | |     serialize(req)?
[INFO] [stdout] 176 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:181:88
[INFO] [stdout]     |
[INFO] [stdout] 180 | pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                ------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 181 |   let req = KeyVecInsertQuery{key: key.to_string(), value: (value.0, serialize(value.1)?), overwrite: overwrite};
[INFO] [stdout]     |                                                                      ------------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |                                                                      |
[INFO] [stdout]     |                                                                      this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:181:88
[INFO] [stdout]     |
[INFO] [stdout] 180 | pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                ------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 181 |   let req = KeyVecInsertQuery{key: key.to_string(), value: (value.0, serialize(value.1)?), overwrite: overwrite};
[INFO] [stdout]     |                                                                      ------------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |                                                                      |
[INFO] [stdout]     |                                                                      this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:181:88
[INFO] [stdout]     |
[INFO] [stdout] 180 | pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                ------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 181 |   let req = KeyVecInsertQuery{key: key.to_string(), value: (value.0, serialize(value.1)?), overwrite: overwrite};
[INFO] [stdout]     |                                                                      ------------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |                                                                      |
[INFO] [stdout]     |                                                                      this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:185:19
[INFO] [stdout]     |
[INFO] [stdout] 180 | pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                ------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 185 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:185:19
[INFO] [stdout]     |
[INFO] [stdout] 180 | pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                ------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 185 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:185:19
[INFO] [stdout]     |
[INFO] [stdout] 180 | pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                ------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 185 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:186:17
[INFO] [stdout]     |
[INFO] [stdout] 180 |   pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                  ------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 181 |     let req = KeyVecInsertQuery{key: key.to_string(), value: (value.0, serialize(value.1)?), overwrite: overwrite};
[INFO] [stdout] 182 |     let res: KeyVecInsertResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 183 | |     CAPABILITY,
[INFO] [stdout] 184 | |     OP_KEYVEC_INSERT,
[INFO] [stdout] 185 | |     serialize(req)?
[INFO] [stdout] 186 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:186:17
[INFO] [stdout]     |
[INFO] [stdout] 180 |   pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                  ------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 181 |     let req = KeyVecInsertQuery{key: key.to_string(), value: (value.0, serialize(value.1)?), overwrite: overwrite};
[INFO] [stdout] 182 |     let res: KeyVecInsertResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 183 | |     CAPABILITY,
[INFO] [stdout] 184 | |     OP_KEYVEC_INSERT,
[INFO] [stdout] 185 | |     serialize(req)?
[INFO] [stdout] 186 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:186:17
[INFO] [stdout]     |
[INFO] [stdout] 180 |   pub fn keyvec_insert<T: Serialize>(binding_name: &'static str, key: &str, value:(i32, &T), overwrite: bool) -> HandlerResult<bool>{
[INFO] [stdout]     |                                                                                                                  ------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 181 |     let req = KeyVecInsertQuery{key: key.to_string(), value: (value.0, serialize(value.1)?), overwrite: overwrite};
[INFO] [stdout] 182 |     let res: KeyVecInsertResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ___________________________________-
[INFO] [stdout] 183 | |     CAPABILITY,
[INFO] [stdout] 184 | |     OP_KEYVEC_INSERT,
[INFO] [stdout] 185 | |     serialize(req)?
[INFO] [stdout] 186 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:195:19
[INFO] [stdout]     |
[INFO] [stdout] 190 | pub fn keyvec_get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<(i32, T)>>{
[INFO] [stdout]     |                                                                                        ---------------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 195 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:195:19
[INFO] [stdout]     |
[INFO] [stdout] 190 | pub fn keyvec_get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<(i32, T)>>{
[INFO] [stdout]     |                                                                                        ---------------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 195 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:195:19
[INFO] [stdout]     |
[INFO] [stdout] 190 | pub fn keyvec_get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<(i32, T)>>{
[INFO] [stdout]     |                                                                                        ---------------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 195 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:196:17
[INFO] [stdout]     |
[INFO] [stdout] 190 |   pub fn keyvec_get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<(i32, T)>>{
[INFO] [stdout]     |                                                                                          ---------------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 191 |     let req = KeyVecGetQuery{key: key.to_string()};
[INFO] [stdout] 192 |     let res: KeyVecGetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ________________________________-
[INFO] [stdout] 193 | |     CAPABILITY,
[INFO] [stdout] 194 | |     OP_KEYVEC_GET,
[INFO] [stdout] 195 | |     serialize(req)?
[INFO] [stdout] 196 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:196:17
[INFO] [stdout]     |
[INFO] [stdout] 190 |   pub fn keyvec_get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<(i32, T)>>{
[INFO] [stdout]     |                                                                                          ---------------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 191 |     let req = KeyVecGetQuery{key: key.to_string()};
[INFO] [stdout] 192 |     let res: KeyVecGetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ________________________________-
[INFO] [stdout] 193 | |     CAPABILITY,
[INFO] [stdout] 194 | |     OP_KEYVEC_GET,
[INFO] [stdout] 195 | |     serialize(req)?
[INFO] [stdout] 196 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:196:17
[INFO] [stdout]     |
[INFO] [stdout] 190 |   pub fn keyvec_get<'de, T: Deserialize<'de>> (binding_name: &'static str, key: &str) -> HandlerResult<Vec<(i32, T)>>{
[INFO] [stdout]     |                                                                                          ---------------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 191 |     let req = KeyVecGetQuery{key: key.to_string()};
[INFO] [stdout] 192 |     let res: KeyVecGetResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ________________________________-
[INFO] [stdout] 193 | |     CAPABILITY,
[INFO] [stdout] 194 | |     OP_KEYVEC_GET,
[INFO] [stdout] 195 | |     serialize(req)?
[INFO] [stdout] 196 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:208:19
[INFO] [stdout]     |
[INFO] [stdout] 203 | pub fn keyvec_tail_off(binding_name: &'static str, key: &str, remain: usize) -> HandlerResult<usize>{
[INFO] [stdout]     |                                                                                 -------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] ...
[INFO] [stdout] 208 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:208:19
[INFO] [stdout]     |
[INFO] [stdout] 203 | pub fn keyvec_tail_off(binding_name: &'static str, key: &str, remain: usize) -> HandlerResult<usize>{
[INFO] [stdout]     |                                                                                 -------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] ...
[INFO] [stdout] 208 |     serialize(req)?
[INFO] [stdout]     |     --------------^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:208:19
[INFO] [stdout]     |
[INFO] [stdout] 203 | pub fn keyvec_tail_off(binding_name: &'static str, key: &str, remain: usize) -> HandlerResult<usize>{
[INFO] [stdout]     |                                                                                 -------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] ...
[INFO] [stdout] 208 |     serialize(req)?
[INFO] [stdout]     |     --------------^ doesn't have a size known at compile-time
[INFO] [stdout]     |     |
[INFO] [stdout]     |     this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Send` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:209:17
[INFO] [stdout]     |
[INFO] [stdout] 203 |   pub fn keyvec_tail_off(binding_name: &'static str, key: &str, remain: usize) -> HandlerResult<usize>{
[INFO] [stdout]     |                                                                                   -------------------- required `dyn StdError: Send` because of this
[INFO] [stdout] 204 |     let req = KeyVecTailOffQuery{key: key.to_string(), remain: remain};
[INFO] [stdout] 205 |     let res: KeyVecTailOffResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ____________________________________-
[INFO] [stdout] 206 | |     CAPABILITY,
[INFO] [stdout] 207 | |     OP_KEYVEC_TAILOFF,
[INFO] [stdout] 208 | |     serialize(req)?
[INFO] [stdout] 209 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be sent between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Send` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Send`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sync` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:209:17
[INFO] [stdout]     |
[INFO] [stdout] 203 |   pub fn keyvec_tail_off(binding_name: &'static str, key: &str, remain: usize) -> HandlerResult<usize>{
[INFO] [stdout]     |                                                                                   -------------------- required `dyn StdError: Sync` because of this
[INFO] [stdout] 204 |     let req = KeyVecTailOffQuery{key: key.to_string(), remain: remain};
[INFO] [stdout] 205 |     let res: KeyVecTailOffResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ____________________________________-
[INFO] [stdout] 206 | |     CAPABILITY,
[INFO] [stdout] 207 | |     OP_KEYVEC_TAILOFF,
[INFO] [stdout] 208 | |     serialize(req)?
[INFO] [stdout] 209 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ `dyn StdError` cannot be shared between threads safely
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sync` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Unique<dyn StdError>` to implement `Sync`
[INFO] [stdout] note: required because it appears within the type `Box<dyn StdError>`
[INFO] [stdout]    --> /rustc/c2e32f1c9652b13ed99608599c1e855462f421f3/library/alloc/src/boxed.rs:235:11
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: `?` couldn't convert the error: `dyn StdError: Sized` is not satisfied
[INFO] [stdout]    --> src/actor_kvp.rs:209:17
[INFO] [stdout]     |
[INFO] [stdout] 203 |   pub fn keyvec_tail_off(binding_name: &'static str, key: &str, remain: usize) -> HandlerResult<usize>{
[INFO] [stdout]     |                                                                                   -------------------- required `dyn StdError: Sized` because of this
[INFO] [stdout] 204 |     let req = KeyVecTailOffQuery{key: key.to_string(), remain: remain};
[INFO] [stdout] 205 |     let res: KeyVecTailOffResponse = deserialize(untyped::host(binding_name).call(
[INFO] [stdout]     |  ____________________________________-
[INFO] [stdout] 206 | |     CAPABILITY,
[INFO] [stdout] 207 | |     OP_KEYVEC_TAILOFF,
[INFO] [stdout] 208 | |     serialize(req)?
[INFO] [stdout] 209 | |   )?.as_slice())?;
[INFO] [stdout]     | |                -^ doesn't have a size known at compile-time
[INFO] [stdout]     | |________________|
[INFO] [stdout]     |                  this can't be annotated with `?` because it has type `Result<_, Box<(dyn StdError + 'static)>>`
[INFO] [stdout]     |
[INFO] [stdout]     = help: the trait `Sized` is not implemented for `dyn StdError`
[INFO] [stdout]     = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
[INFO] [stdout]     = note: required for `Box<dyn StdError>` to implement `StdError`
[INFO] [stdout]     = note: required for `Box<dyn StdError + Send + Sync>` to implement `From<Box<dyn StdError>>`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0277`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `tea-actor-utility` (lib) due to 138 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] running `Command { std: "docker" "inspect" "fecbf9df9603d1c96977607484b99ed4ac50efa03cdc5d47e9ff9564f4db7ebb", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "fecbf9df9603d1c96977607484b99ed4ac50efa03cdc5d47e9ff9564f4db7ebb", kill_on_drop: false }`
[INFO] [stdout] fecbf9df9603d1c96977607484b99ed4ac50efa03cdc5d47e9ff9564f4db7ebb
