@voxgig/sdkgen 4.21.0 → 4.23.0

package/project/.sdk/tm/rust/feature/paging.rs

@@ -1,13 +1,3 @@
-// Pagination support for list operations (mirrors go
-// feature/paging_feature.go). On the way out (PreRequest) it stamps
-// page/limit (or a cursor) into the request query; on the way back
-// (PreResult) it reads the server's pagination signals — a `Link:
-// rel="next"` header, `X-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body — and records
-// them on `result.paging`. A per-call cursor/page from ctrl takes priority
-// (used by auto-iteration). Parameter names (`pageParam`, `limitParam`,
-// `cursorParam`), the page size (`limit`) and the start page (`startPage`,
-// default 1) are configurable.
 
 use std::cell::RefCell;
 use std::rc::Rc;

package/project/.sdk/tm/rust/feature/proxy.rs

@@ -1,11 +1,3 @@
-// Outbound HTTP(S) proxy support (mirrors go feature/proxy_feature.go).
-// Wraps the active transport and annotates each request's fetch definition
-// with the proxy target (`fetchdef.proxy`). The default ureq transport
-// honours the annotation by routing the request through an agent
-// configured with that proxy (see utility/fetcher.rs); custom transports
-// can do the same. The proxy target comes from options (`url`) or, when
-// `fromEnv` is set, the standard HTTPS_PROXY / HTTP_PROXY / NO_PROXY
-// environment variables. Hosts matching `noProxy` bypass the proxy.
 
 use std::cell::RefCell;
 use std::rc::Rc;

package/project/.sdk/tm/rust/feature/ratelimit.rs

@@ -1,9 +1,3 @@
-// Client-side rate limiting via a token bucket (mirrors go
-// feature/ratelimit_feature.go). Each request consumes a token; when the
-// bucket is empty the request waits until the bucket refills at `rate`
-// tokens per second (with capacity `burst`, default: rate). The clock
-// (`now`) and the wait (`sleep`) are injectable so the accounting can be
-// tested deterministically.
 
 use std::cell::RefCell;
 use std::rc::Rc;

package/project/.sdk/tm/rust/feature/rbac.rs

@@ -1,12 +1,3 @@
-// Client-side role/permission enforcement (mirrors go
-// feature/rbac_feature.go). Before an operation resolves its endpoint, the
-// required permission for that entity+operation is checked against the
-// permissions the client holds; a disallowed call is short-circuited with
-// an `rbac_denied` error (via ctx.out["point"], which MakePoint surfaces)
-// and never touches the network. Required permissions come from `rules`
-// (keyed by `<entity>.<op>`, `<op>`, or `*`); the default when no rule
-// matches is controlled by `deny` (default: allow when unspecified). Held
-// permissions are the `permissions` list (a `*` grants everything).
 
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -131,7 +122,6 @@ impl Feature for RbacFeature {
 
         let required = match self.required(ctx) {
             None => {
-                // No rule: honour the default policy.
                 if fopt_bool(&self.options, "deny", false) {
                     self.reject(ctx, "<default-deny>");
                 }

package/project/.sdk/tm/rust/feature/retry.rs

@@ -1,9 +1,3 @@
-// Automatic retry of transient failures with exponential backoff and
-// jitter (mirrors go feature/retry_feature.go). Wraps the active transport
-// so a single operation call may make several HTTP attempts. A failure is
-// retryable when the transport returns an error, or responds with a status
-// in `statuses` (default: 408, 425, 429, 500, 502, 503, 504). An HTTP
-// 429/503 with a `Retry-After` header overrides the computed backoff.
 
 use std::cell::RefCell;
 use std::rc::Rc;

package/project/.sdk/tm/rust/feature/secrets.rs

@@ -1,58 +1,3 @@
-// Secret access via a vendored @voxgig/sekreto provider chain, and the
-// access-token exchange some APIs require on top of it. The rust port of
-// tm/ts/src/feature/secrets/SecretsFeature.ts, following the GO port's
-// structure - same contract, rust idiom.
-//
-// The SDK's `apikey` option keeps exactly its old meaning: an explicit
-// credential given in code. This feature makes it ONE SOURCE among several
-// rather than the only one: when active, the apikey is resolved through a
-// sekreto chain in which the explicit option (when set) is the FIRST
-// provider - a `memory` store named `options` - so an explicit value always
-// wins, by sekreto's own first-hit rule rather than by special-case logic.
-// When the option is unset the remaining providers (env, dotenv, a vault)
-// are asked in order, and moving a credential from code to a vault becomes
-// a configuration change.
-//
-// MISS vs ERROR (sekreto's invariant): a provider MISS falls through - the
-// op proceeds, unauthenticated if nothing else supplies a credential. A
-// provider ERROR (unreachable vault, bad creds) must FAIL the op: a broken
-// vault never degrades into an unauthenticated request.
-//
-// WHERE RESOLUTION HAPPENS, and why it is not the PreSpec hook. rust's
-// feature hooks return `()` (core/types.rs `fn pre_spec(&mut self, _ctx)
-// {}`), so a hook cannot fail an operation the way ts's awaited hook
-// rejection can - and `direct()` / `graphql()` run no feature hooks at all
-// (Main.fragment.rs raw_request calls utility.fetch directly). So, exactly
-// as in the go port, resolution happens at the TRANSPORT SEAM: the one
-// place every wire path crosses. The wrapper refuses to send while the
-// last resolution stands failed, which is fail-closed for the entity
-// pipeline and the raw paths alike, with one implementation.
-//
-// WHERE THE CREDENTIAL LIVES, and why it is not the options map. The ts
-// reference writes `options.apikey`; this port does NOT. `options_map()`
-// deep-clones on every prepare_auth call and the root options Value is
-// shared by every context, so a feature that mutated it would be visible
-// everywhere at once and would defeat the `auth: null` suppression pin.
-// The resolved credential is held in FEATURE STATE and written into each
-// request's header at the transport, the same construction prepare_auth
-// uses (options.auth.prefix), so the wire is identical and the options map
-// stays frozen after construction.
-//
-// EXCHANGE: some APIs will not take a long-lived credential at all. What
-// the chain resolves is then a REFRESH token, which buys a short-lived
-// ACCESS token from a token endpoint (`exchange.path`, relative to
-// options.base); the access token is what every request carries, and when
-// a response status in `exchange.statuses` (401) says it is spent the
-// wrapper buys another and retries the same request once. Test mode buys
-// nothing and answers with a deterministic fake token.
-//
-// THREADING: this SDK is single-threaded by construction (Value is
-// Rc/RefCell-backed, so !Send), which is why go's mutex/channel machinery
-// collapses to a RefCell here. The discipline that replaces it: the
-// transport closure must hold NO RefCell borrow across `inner(...)` or
-// across a provider lookup, or the failure is a runtime `already borrowed`
-// panic rather than a compile error. Every borrow below is scoped for that
-// reason.
 
 pub mod plugin;
 pub mod plugins;
@@ -121,10 +66,7 @@ pub struct SecretsState {
     options: Value,
     mode: String,
 
-    /// The RESOLVED credential, injected into each request at the
-    /// transport seam.
     cred: String,
-    /// The refresh token the chain resolved, when exchanging.
     refresh: String,
 
     /// A settled SUCCESSFUL resolution. Kept only while caching is on
@@ -156,22 +98,6 @@ impl SecretsState {
     }
 }
 
-/// A provider given as a plain callable.
-///
-/// A live `Rc<dyn Provider>` cannot travel inside a Value - the SDK union
-/// is Noval|Null|Bool|Num|Str|List|Map|Func|Sentinel, and adding a variant
-/// to the vendored struct library to carry SDK objects would be wrong - so
-/// go's `providers: [&customProvider{...}]` has no direct rust
-/// translation. This is the Value-shaped half of the answer (the typed
-/// half is `SecretsFeature::add_provider`): the callable is handed the
-/// secret NAME and answers
-///
-///   Value::Str(v)                  -> a HIT
-///   Value::Noval / Value::Null     -> a MISS, the chain continues
-///   { "__err__": "..." }           -> an ERROR, which fails the operation
-///
-/// The miss/error split is the whole point: conflating them turns a broken
-/// vault into a silent unauthenticated request.
 struct FuncProvider {
     f: Value,
 }
@@ -194,11 +120,6 @@ impl Provider for FuncProvider {
     }
 }
 
-/// SDK Value -> voxgig/plugin Value, so an option map can be handed to
-/// sekreto's `specof`. The two are different types on purpose: sekreto's
-/// is an owned BTreeMap tree with an Opaque variant for host objects, the
-/// SDK's is Rc/RefCell-backed and closed. Callables and sentinels have no
-/// counterpart and become null.
 fn to_plugin_value(v: &Value) -> PluginValue {
     match v {
         Value::Bool(b) => PluginValue::Bool(*b),
@@ -255,7 +176,6 @@ impl SecretsFeature {
         self.state.borrow().cred.clone()
     }
 
-    /// Resolve now, rather than at the next request.
     pub fn resolve(&self) -> Result<(), ProjectNameError> {
         resolve(&self.state)
     }
@@ -281,8 +201,6 @@ impl Feature for SecretsFeature {
         self.add_opts.clone()
     }
 
-    // Sync by feature contract: build the chain, never look anything up
-    // here.
     fn init(&mut self, ctx: &Rc<Context>, options: &Value) {
         self.active = fopt_bool(options, "active", false);
 
@@ -323,16 +241,6 @@ impl Feature for SecretsFeature {
             });
         }
 
-        // The explicit credential, when set, is the first store in the
-        // chain.
-        //
-        // WHICH option that is depends on the exchange. Without one, the
-        // secret being resolved IS the credential the transport sends, so
-        // `apikey` is it. With one, the secret is a REFRESH token and
-        // `apikey` means the opposite thing - an access token the caller
-        // already holds - so the explicit seat belongs to
-        // `exchange.refresh`, and apikey is left alone to serve as the
-        // starting access token (see resolve_once).
         let explicit = if state.exchange.is_none() {
             match getp(&state.options, "apikey") {
                 Value::Str(s) => s,
@@ -368,13 +276,6 @@ impl Feature for SecretsFeature {
                         ..Default::default()
                     }),
                     Value::Map(_) => specs.push(specof(&to_plugin_value(p))),
-                    // FAIL CLOSED, never drop. An entry that is neither a
-                    // callable nor a spec (a bare "hashicorp" where a spec
-                    // map was meant) must not leave the chain quietly
-                    // shorter than the options say: sekreto's own wording
-                    // lands in the init-failure gate, which refuses to send.
-                    // The rust ProviderSpec is typed, so the refusal is
-                    // raised at this arm, as the go port does.
                     _ => {
                         if state.initerr.is_none() {
                             state.initerr = Some(format!(
@@ -415,25 +316,12 @@ impl Feature for SecretsFeature {
 
         self.state = Rc::new(RefCell::new(state));
 
-        // The public accessor, published on the client's shared map: rust
-        // options are pure data, and the generated client must not name a
-        // feature type, so `sdk.secrets()` has no rust spelling. A Value
-        // callable does have one, and it reaches every caller - and every
-        // test - with no downcast.
-        //
-        //   let s = getp(&client.get_root_ctx().shared.borrow(), "secrets");
-        //   call_vfn(&s, &ja(vec![Value::str("getfrom"),
-        //                         Value::str("options"), Value::str("apikey")]))
         let shared = ctx.shared.borrow().clone();
         if let Value::Map(_) = shared {
             let h = self.state.clone();
             setp(&shared, "secrets", vfn(move |arg| secrets_call(&h, arg)));
         }
 
-        // Wrap the transport. The fail-closed gate needs the seam whenever
-        // the feature is active - hooks cannot fail an operation and the
-        // raw paths run none - and the exchange additionally needs to SEE
-        // responses, since expiry is only ever discovered from one.
         let util = ctx.util();
         let inner: FetcherFn = util.fetcher.borrow().clone();
         let state = self.state.clone();
@@ -443,7 +331,6 @@ impl Feature for SecretsFeature {
     }
 }
 
-// ---- the accessor -------------------------------------------------------
 
 fn secrets_call(state: &Rc<RefCell<SecretsState>>, arg: &Value) -> Value {
     let args: Vec<Value> = match arg {
@@ -505,19 +392,7 @@ fn secrets_call(state: &Rc<RefCell<SecretsState>>, arg: &Value) -> Value {
     }
 }
 
-// ---- resolution ---------------------------------------------------------
-
-// One resolution, shared by every request. A settled HIT is kept only when
-// caching is on; a FAILURE is never kept, so a transient vault outage never
-// poisons the client permanently - the next operation asks again.
-//
-// A MISS is not kept either, however caching is set. That rule is
-// sekreto's, not this feature's: `A miss is never cached: the next read
-// asks again`, in sekreto's own source. Keeping a settled miss here would
-// override that from the layer above, and a secret provisioned after
-// startup - a mounted file, a policy granted a minute late - would never be
-// picked up for the life of the client. `cache` is about caching a HIT; it
-// was never a promise to keep saying no.
+
 fn resolve(state: &Rc<RefCell<SecretsState>>) -> Result<(), ProjectNameError> {
     {
         let s = state.borrow();
@@ -573,12 +448,6 @@ fn resolve_once(state: &Rc<RefCell<SecretsState>>) -> Result<bool, ProjectNameEr
         let mut s = state.borrow_mut();
 
         if s.exchange.is_none() {
-            // An UNCACHED miss after an earlier hit is a revocation: the
-            // chain now says no provider has the secret, so the resolved
-            // value must not keep going out on the wire. (An explicit
-            // apikey OPTION is never lost here - it seats FIRST in the
-            // chain as a memory provider, so the chain HITS while one is
-            // set and the miss branch is unreachable.)
             let hit = found.is_some();
             s.cred = found.unwrap_or_default();
             return Ok(hit);
@@ -604,13 +473,6 @@ fn resolve_once(state: &Rc<RefCell<SecretsState>>) -> Result<bool, ProjectNameEr
             return Ok(true);
         }
 
-        // `auth: null` is the documented way to send NO credential, and a
-        // purchase is a credential-bearing call: the refresh token goes to
-        // the token endpoint in the request body. with_refresh honours
-        // suppression for the RETRY, but it runs after this - by then the
-        // refresh token has already left the process, and no later check
-        // can call it back. The suppression has to be honoured here, before
-        // the first purchase, or it only ever half-held.
         if !authactive(&s.options) {
             return Ok(false);
         }
@@ -619,7 +481,6 @@ fn resolve_once(state: &Rc<RefCell<SecretsState>>) -> Result<bool, ProjectNameEr
     buy(state).map(|_| true)
 }
 
-// ---- the transport seam -------------------------------------------------
 
 fn transport(
     state: &Rc<RefCell<SecretsState>>,
@@ -628,12 +489,6 @@ fn transport(
     fetchdef: &Value,
     inner: &FetcherFn,
 ) -> Result<Value, ProjectNameError> {
-    // Fail-closed, at the ONE seam every wire path crosses. Entity ops,
-    // direct(), graphql() and the exchange retries all come through here,
-    // so resolving HERE is what gives the raw paths - which run no feature
-    // hooks at all - the same credential the entity pipeline gets. A
-    // provider ERROR refuses the request with the provider's own error;
-    // never an unauthenticated send.
     resolve(state)?;
 
     let (token, exchanging) = {
@@ -641,12 +496,6 @@ fn transport(
         (s.cred.clone(), s.exchange.is_some())
     };
 
-    // Inject the resolved credential into THIS request's header. The
-    // header was built by prepare_auth from the options apikey; the
-    // chain-resolved value lives in feature state instead, so the wrapper
-    // writes it here - same construction, same suppression rules - and the
-    // shared options map stays untouched. A MISS leaves whatever
-    // prepare_auth built, which is nothing.
     if !token.is_empty() {
         reauth(state, fetchdef, &token);
     }
@@ -658,14 +507,6 @@ fn transport(
     with_refresh(state, ctx, url, fetchdef, inner)
 }
 
-// Buy a token and try the request again when the API says the current one
-// is spent.
-//
-// The retry rewrites the authorization header IN PLACE on the fetchdef,
-// because the header was built by the synchronous prepare_auth before this
-// request left and carries the token that just failed. Rebuilt the way
-// prepare_auth builds it, from the same options.auth.prefix, so the two
-// cannot drift.
 fn with_refresh(
     state: &Rc<RefCell<SecretsState>>,
     ctx: &Rc<Context>,
@@ -673,11 +514,6 @@ fn with_refresh(
     fetchdef: &Value,
     inner: &FetcherFn,
 ) -> Result<Value, ProjectNameError> {
-    // `auth: null` is the documented way to send NO credential, and
-    // prepare_auth honours it by removing the header. A refusal of a
-    // deliberately unauthenticated request is not an expired token and
-    // cannot be fixed by buying one - retrying would transmit exactly the
-    // credential the caller suppressed.
     let (suppressed, max) = {
         let s = state.borrow();
         (
@@ -792,15 +628,8 @@ fn reauth(state: &Rc<RefCell<SecretsState>>, fetchdef: &Value, token: &str) {
     }
 }
 
-// ---- the access-token exchange -----------------------------------------
 
 fn buy(state: &Rc<RefCell<SecretsState>>) -> Result<String, ProjectNameError> {
-    // TEST MODE BUYS NOTHING. The test feature replaces the transport so
-    // no request leaves the process; an exchange here would be the one
-    // call it could not stop, and it would need a live token endpoint for
-    // a suite whose whole point is not needing one. A deterministic,
-    // obviously-fake token instead - the same answer make_options gives a
-    // required server variable, for the same reason.
     let (testmode, response) = {
         let s = state.borrow();
         (
@@ -848,8 +677,6 @@ fn buy_once(state: &Rc<RefCell<SecretsState>>) -> Result<String, ProjectNameErro
         )));
     }
 
-    // The token endpoint is RELATIVE to the base, which already carries
-    // whatever account or tenant segment the server URL declares.
     let base = match getp(&options, "base") {
         Value::Str(s) => s,
         _ => String::new(),
@@ -860,9 +687,6 @@ fn buy_once(state: &Rc<RefCell<SecretsState>>) -> Result<String, ProjectNameErro
         x.path.trim_start_matches('/')
     );
 
-    // The body is SERIALISED, never concatenated: a refresh token (or a
-    // configured request-field name) carrying a quote, backslash or
-    // newline must arrive as that literal value, not as malformed JSON.
     let body = vs::jsonify(
         &jo(vec![(x.request.as_str(), Value::str(refresh))]),
         Some(&JsonFlags {
@@ -880,10 +704,6 @@ fn buy_once(state: &Rc<RefCell<SecretsState>>) -> Result<String, ProjectNameErro
         ("body", Value::str(body)),
     ]);
 
-    // Deliberately NOT the SDK transport. The transport is what this
-    // feature wraps, and sending the token request back through it would
-    // recurse on the first expiry - and would route the exchange through
-    // the test mock, which knows nothing about it.
     let sys_fetch = getpath(&["system", "fetch"], &options);
 
     let res = if let Value::Func(_) = sys_fetch {
@@ -896,10 +716,6 @@ fn buy_once(state: &Rc<RefCell<SecretsState>>) -> Result<String, ProjectNameErro
         }
         out
     } else {
-        // No custom transport supplied - the ordinary case. make_options
-        // leaves system.fetch unset, so the exchange gets its own raw HTTP
-        // path; requiring a custom transport for the COMMON case would
-        // reject every live token purchase before a request was made.
         raw_exchange_fetch(&url, &fetchdef)?
     };
 
@@ -933,8 +749,6 @@ fn buy_once(state: &Rc<RefCell<SecretsState>>) -> Result<String, ProjectNameErro
     Ok(token)
 }
 
-// The token-exchange transport of last resort: plain ureq, answering with
-// the same shape the system.fetch seam promises ("status" + "json").
 fn raw_exchange_fetch(fullurl: &str, fetchdef: &Value) -> Result<Value, ProjectNameError> {
     let method = get_str(fetchdef, "method")
         .filter(|m| !m.is_empty())

package/project/.sdk/tm/rust/feature/streaming.rs

@@ -1,10 +1,3 @@
-// Streaming result support (mirrors go feature/streaming_feature.go,
-// adapted to a synchronous runtime). For list-style operations it attaches
-// a `result.stream` producer so callers can consume items incrementally
-// with `for item in (result.stream)()` instead of materialising the whole
-// list themselves. A `chunkSize` groups items into list batches when set;
-// a `chunkDelay` (ms) paces delivery via the injectable `sleep` for
-// offline tests.
 
 use std::rc::Rc;
 

package/project/.sdk/tm/rust/feature/support.rs

@@ -1,9 +1,3 @@
-// Shared option readers for the feature implementations (mirrors go
-// feature/feature_options.go). Feature options arrive as Value maps (from
-// SDK options or test harnesses); callables (clocks, sleepers, generators,
-// sinks) arrive as Value::Func entries. These helpers normalise access and
-// supply defaults, mirroring the `null == opts.x ? def : opts.x` pattern of
-// the ts features.
 
 use crate::core::helpers::{call_vfn, getp, now_ms, sleep_ms, to_int};
 use crate::utility::voxgigstruct::Value;

package/project/.sdk/tm/rust/feature/telemetry.rs

@@ -1,12 +1,3 @@
-// Distributed-tracing telemetry (mirrors go feature/telemetry_feature.go).
-// Opens a span per operation (PrePoint), propagates trace context to the
-// server as W3C `traceparent` plus `X-Trace-Id` / `X-Span-Id` headers
-// (PreRequest), and closes the span on completion (PreDone) or failure
-// (PreUnexpected). Each span closes exactly once (the per-context marker
-// in ctx.out is consumed on close). Finished spans accumulate on the
-// feature; an `exporter` callback, when provided, is invoked with each
-// finished span. Trace/span id generation (`idgen`) and the clock (`now`)
-// are injectable for deterministic tests.
 
 use std::rc::Rc;
 

package/project/.sdk/tm/rust/feature/test.rs

@@ -1,8 +1,3 @@
-// The offline `test` feature (mirrors go feature/test_feature.go): an
-// in-memory mock transport that serves entity CRUD from a fixture, so
-// generated tests run with no live server. An optional `net` block wraps
-// the mock with simulated network conditions (latency, first-N failures,
-// connection errors, offline) — see make_netsim below.
 
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -33,28 +28,21 @@ impl TestFeature {
     }
 }
 
-// THE MOCK HAS TO AGREE WITH THE MODEL.
-//
-// A point carrying `transform.res: `body.item`` describes an API that answers
-// {"item": {...}}, and the response transform unwraps that key on the way
-// back. Handing back the bare payload means the transform unwraps a property
-// that is not there, and the caller gets nothing — a mock that only ever
-// simulates APIs whose responses happen to be unwrapped.
-//
-// univec's list op declares `body.data`, so every list returned zero items
-// while the fixture plainly held two. Mirrors the go/ts/lua/php mocks, which
-// already wrap; rust, c and zig were the three that did not.
 fn envelope(ctx: &Rc<Context>, data: Value) -> Value {
     if data.is_noval() || data.is_null() {
         return data;
     }
     let restf = crate::core::helpers::getpath(&["transform", "res"], &ctx.point.borrow());
     if let Value::Str(spec) = restf {
-        // Exactly `body.<key>` — a deeper path is not an envelope this mock
-        // can synthesise, so it is left alone rather than guessed at.
+        // Rebuild whatever nesting the transform unwraps: a GraphQL op unwraps
+        // `body.data.<field>`, not just one envelope property.
         if let Some(inner) = spec.strip_prefix("`body.").and_then(|r| r.strip_suffix('`')) {
-            if !inner.is_empty() && !inner.contains('.') {
-                return jo(vec![(inner, data)]);
+            if !inner.is_empty() {
+                let mut out = data;
+                for seg in inner.split('.').rev() {
+                    out = jo(vec![(seg, out)]);
+                }
+                return out;
             }
         }
     }
@@ -206,9 +194,6 @@ fn test_fetch(
         }
 
         "update" => {
-            // Match the existing entity by id only (or its alias). Reqdata
-            // also contains the new field values, which would otherwise
-            // cause select to filter out the entity we want to update.
             let reqdata = ctx.reqdata.borrow().clone();
             let update_match = Value::empty_map();
             if let Value::Map(_) = reqdata {

package/project/.sdk/tm/rust/feature/timeout.rs

@@ -1,10 +1,3 @@
-// Per-request timeout (mirrors go feature/timeout_feature.go, adapted to a
-// synchronous single-threaded transport like the ruby port). The active
-// transport is wrapped with a deadline of `ms` milliseconds (default
-// 30000; <= 0 disables). The transport is synchronous, so the elapsed
-// (injectable `now`) clock is checked around the inner call: when the call
-// took longer than the deadline its result is discarded and a `timeout`
-// error is returned instead.
 
 use std::cell::RefCell;
 use std::rc::Rc;