@weft-js/start 0.1.1 → 0.1.3

package/crate/src/envelope.rs

@@ -0,0 +1,163 @@
+//! One crossing per server function (PLAN §4.3). The request is `POST /_weft/fn/:id` with the JSON body `{ "input": … }`:
+//!
+//! ```text
+//! weft-ctx: base64url(JSON of the Envelope)
+//! weft-sig: hex(HMAC-SHA256(secret, "weft1\n" + id + "\n" + weft-ctx + "\n" + body))
+//! ```
+//!
+//! The signature covers the function and the body as well as the claims, so a signed call can't be replayed against
+//! another function or with another input, and `iat` bounds how long it can be replayed at all.
+
+use std::fmt::Write as _;
+
+use base64::Engine;
+use base64::engine::general_purpose::URL_SAFE_NO_PAD;
+use hmac::{Hmac, KeyInit, Mac};
+use sha2::Sha256;
+
+pub use crate::ctx::Envelope;
+
+/// How far `iat` may be from this machine's clock.
+pub const MAX_SKEW_MS: u64 = 60_000;
+
+/// Why a call was refused before any handler ran.
+#[derive(Debug, PartialEq, Eq)]
+pub enum Refused {
+    /// No `weft-ctx`/`weft-sig`, or they don't decode.
+    Malformed,
+    /// The signature doesn't match: a wrong secret, or a changed call.
+    BadSignature,
+    /// `iat` is too far from now.
+    Stale,
+}
+
+impl std::fmt::Display for Refused {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Refused::Malformed => "no readable weft-ctx and weft-sig headers",
+            Refused::BadSignature => {
+                "the signature doesn't match: is WEFT_RUST_SECRET the same on both sides?"
+            }
+            Refused::Stale => "the call was signed too long ago (or a clock is off)",
+        })
+    }
+}
+
+fn keyed(secret: &[u8], id: &str, ctx: &str, body: &[u8]) -> Hmac<Sha256> {
+    let mut mac = Hmac::<Sha256>::new_from_slice(secret).expect("HMAC takes a key of any length");
+    mac.update(b"weft1\n");
+    mac.update(id.as_bytes());
+    mac.update(b"\n");
+    mac.update(ctx.as_bytes());
+    mac.update(b"\n");
+    mac.update(body);
+    mac
+}
+
+fn hex_decode(s: &str) -> Option<Vec<u8>> {
+    if !s.len().is_multiple_of(2) {
+        return None;
+    }
+    (0..s.len())
+        .step_by(2)
+        .map(|i| u8::from_str_radix(s.get(i..i + 2)?, 16).ok())
+        .collect()
+}
+
+/// The `weft-sig` for a call. TS is the signer; this is here for tests and hand-written callers.
+pub fn sign(secret: &[u8], id: &str, ctx: &str, body: &[u8]) -> String {
+    let mut hex = String::with_capacity(64);
+    for b in keyed(secret, id, ctx, body).finalize().into_bytes() {
+        let _ = write!(hex, "{b:02x}");
+    }
+    hex
+}
+
+/// Check the signature (in constant time), then decode the envelope and check its age against `now_ms`.
+pub fn verify(
+    secret: &[u8],
+    id: &str,
+    ctx: &str,
+    sig: &str,
+    body: &[u8],
+    now_ms: u64,
+) -> Result<Envelope, Refused> {
+    let sig = hex_decode(sig).ok_or(Refused::Malformed)?;
+    keyed(secret, id, ctx, body)
+        .verify_slice(&sig)
+        .map_err(|_| Refused::BadSignature)?;
+    let json = URL_SAFE_NO_PAD
+        .decode(ctx)
+        .map_err(|_| Refused::Malformed)?;
+    let envelope: Envelope = serde_json::from_slice(&json).map_err(|_| Refused::Malformed)?;
+    if envelope.iat.abs_diff(now_ms) > MAX_SKEW_MS {
+        return Err(Refused::Stale);
+    }
+    Ok(envelope)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const CTX: &str = "eyJ1c2VyIjp7ImlkIjoidTEiLCJyb2xlcyI6WyJhZG1pbiJdfSwicmVxdWVzdElkIjoicjEiLCJkZWFkbGluZU1zIjoxMDAwLCJ0cmFjZXBhcmVudCI6bnVsbCwiaWF0IjoxMDAwMDAwfQ";
+
+    #[test]
+    fn the_signature_covers_the_function_the_claims_and_the_body() {
+        let sig = sign(b"s3cret", "f.abc", CTX, b"{}");
+        let ok = verify(b"s3cret", "f.abc", CTX, &sig, b"{}", 1_000_000).unwrap();
+        assert_eq!(ok.user.unwrap().id, "u1");
+        assert_eq!(ok.deadline_ms, 1000);
+        assert_eq!(
+            verify(b"other", "f.abc", CTX, &sig, b"{}", 1_000_000).unwrap_err(),
+            Refused::BadSignature
+        );
+        assert_eq!(
+            verify(b"s3cret", "g.abc", CTX, &sig, b"{}", 1_000_000).unwrap_err(),
+            Refused::BadSignature
+        );
+        assert_eq!(
+            verify(b"s3cret", "f.abc", CTX, &sig, b"[]", 1_000_000).unwrap_err(),
+            Refused::BadSignature
+        );
+        assert_eq!(
+            verify(b"s3cret", "f.abc", "e30", &sig, b"{}", 1_000_000).unwrap_err(),
+            Refused::BadSignature
+        );
+    }
+
+    #[test]
+    fn an_old_call_is_refused_even_with_a_good_signature() {
+        let sig = sign(b"k", "f", CTX, b"{}");
+        assert!(verify(b"k", "f", CTX, &sig, b"{}", 1_000_000 + MAX_SKEW_MS).is_ok());
+        assert_eq!(
+            verify(b"k", "f", CTX, &sig, b"{}", 1_000_000 + MAX_SKEW_MS + 1).unwrap_err(),
+            Refused::Stale
+        );
+    }
+
+    #[test]
+    fn junk_headers_are_malformed_not_a_panic() {
+        assert_eq!(
+            verify(b"k", "f", CTX, "zz", b"{}", 0).unwrap_err(),
+            Refused::Malformed
+        );
+        assert_eq!(
+            verify(b"k", "f", CTX, "abc", b"{}", 0).unwrap_err(),
+            Refused::Malformed
+        );
+        assert_eq!(
+            verify(b"k", "f", CTX, "é", b"{}", 0).unwrap_err(),
+            Refused::Malformed
+        );
+    }
+
+    /// The same vector `packages/start/test/rust.test.mjs` signs in JS: the two sides agree byte for byte.
+    #[test]
+    fn matches_the_typescript_signer() {
+        assert_eq!(
+            sign(b"s3cret", "f.abc", CTX, b"{\"input\":{\"q\":\"x\"}}"),
+            "1a4c89d125bdeda4db5f2dd02045bc1044ff4ecfacff00c7f42f602ceef3ad08"
+        );
+    }
+}

package/crate/src/functions.rs

@@ -0,0 +1,173 @@
+//! A service's functions by contract id, and what a call comes to on any transport: `weft::router` puts them behind
+//! HTTP, `weft::native!` behind Node-API or a WASM export. The body of a reply is the same on all of them:
+//!
+//! ```text
+//! { "ok": true, "value": …, "tags": […], "touched": […] }
+//! { "ok": false, "error": { "code": "NotFound", "data": … } }
+//! ```
+
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+
+use serde::Serialize;
+use serde::de::DeserializeOwned;
+use serde_json::{Value, json};
+
+use crate::ctx::{Base, FromBase};
+
+pub(crate) type Boxed = Pin<Box<dyn Future<Output = Answer> + Send>>;
+pub(crate) type Handler = Arc<dyn Fn(Base, Vec<u8>) -> Boxed + Send + Sync>;
+
+/// How a call ended, before the reports are added.
+pub(crate) enum Answer {
+    /// The value, already JSON: nothing reads it on this side.
+    Value(String),
+    Failed(Failed),
+    /// serde refused what TS sent: the two sides were built from different contracts.
+    Drift(String),
+}
+
+/// What a function's error becomes on the wire.
+pub enum Failed {
+    /// A declared error: `{ "code": …, "data": … }`, which TS checks against the declaration.
+    Typed(Value),
+    /// Anything else. The detail stays in this log: the client gets a request id.
+    Internal(String),
+}
+
+/// An error type a function can return. Generated for each function that declares `errors`.
+pub trait Failure {
+    fn failed(self) -> Failed;
+}
+
+/// The error of a function that declares none. Any `std::error::Error` converts into it, so `?` works.
+#[derive(Debug)]
+pub struct Error(pub String);
+
+impl Error {
+    pub fn msg(message: impl Into<String>) -> Self {
+        Error(message.into())
+    }
+}
+
+impl<E: std::error::Error> From<E> for Error {
+    fn from(e: E) -> Self {
+        Error(e.to_string())
+    }
+}
+
+impl Failure for Error {
+    fn failed(self) -> Failed {
+        Failed::Internal(self.0)
+    }
+}
+
+/// A service's functions, by contract id. `contract::functions(service)` builds it; [`crate::router`] serves it.
+pub struct Functions {
+    service: &'static str,
+    hash: &'static str,
+    table: HashMap<&'static str, Handler>,
+}
+
+impl Functions {
+    pub fn new(service: &'static str, hash: &'static str) -> Self {
+        Functions {
+            service,
+            hash,
+            table: HashMap::new(),
+        }
+    }
+
+    /// One function. Called by generated code.
+    #[must_use]
+    pub fn add<C, I, O, E, F, Fut>(mut self, id: &'static str, f: F) -> Self
+    where
+        C: FromBase + Send + 'static,
+        I: DeserializeOwned + Send + 'static,
+        O: Serialize,
+        E: Failure,
+        F: Fn(C, I) -> Fut + Send + Sync + 'static,
+        Fut: Future<Output = Result<O, E>> + Send + 'static,
+    {
+        #[derive(serde::Deserialize)]
+        struct Body<I> {
+            input: I,
+        }
+        let f = Arc::new(f);
+        let handler: Handler = Arc::new(move |base, body| {
+            let f = f.clone();
+            Box::pin(async move {
+                let input = match serde_json::from_slice::<Body<I>>(&body) {
+                    Ok(b) => b.input,
+                    Err(e) => return Answer::Drift(e.to_string()),
+                };
+                drop(body);
+                let Some(ctx) = C::from_base(base) else {
+                    return Answer::Drift(
+                        "the claims don't fit this function's declaration".into(),
+                    );
+                };
+                match f(ctx, input).await {
+                    Ok(v) => match serde_json::to_string(&v) {
+                        Ok(v) => Answer::Value(v),
+                        Err(e) => Answer::Failed(Failed::Internal(format!(
+                            "the result didn't serialize: {e}"
+                        ))),
+                    },
+                    Err(e) => Answer::Failed(e.failed()),
+                }
+            })
+        });
+        self.table.insert(id, handler);
+        self
+    }
+
+    pub(crate) fn service(&self) -> &'static str {
+        self.service
+    }
+
+    pub(crate) fn hash(&self) -> &'static str {
+        self.hash
+    }
+
+    pub(crate) fn ids(&self) -> Vec<&'static str> {
+        let mut ids: Vec<_> = self.table.keys().copied().collect();
+        ids.sort_unstable();
+        ids
+    }
+
+    pub(crate) fn handler(&self, id: &str) -> Option<Handler> {
+        self.table.get(id).cloned()
+    }
+}
+
+pub(crate) fn ok_body(value: &str, base: &Base) -> String {
+    let list = |l: Vec<String>| serde_json::to_string(&l).expect("strings serialize");
+    format!(
+        r#"{{"ok":true,"value":{value},"tags":{},"touched":{}}}"#,
+        list(base.tags()),
+        list(base.touched())
+    )
+}
+
+/// `detail` crosses only inside this process: TS logs it, and a client never sees it.
+pub(crate) fn internal_body(base: &Base, detail: Option<&str>) -> Value {
+    let mut error = json!({ "code": "Internal", "requestId": base.request_id() });
+    if let Some(d) = detail {
+        error["detail"] = json!(d);
+    }
+    json!({ "ok": false, "error": error })
+}
+
+pub(crate) fn drift_body(detail: &str) -> Value {
+    json!({ "ok": false, "error": { "code": "Drift", "message": detail } })
+}
+
+pub(crate) fn panic_text(p: &(dyn std::any::Any + Send)) -> String {
+    p.downcast_ref::<&str>()
+        .map(std::string::ToString::to_string)
+        .or_else(|| p.downcast_ref::<String>().cloned())
+        .unwrap_or_else(|| "no message".into())
+}

package/crate/src/lib.rs

@@ -0,0 +1,118 @@
+//! The Rust side of weft's `remote()` and `native()` (PLAN §4.3, research 36 and 39). A sidecar or an addon implements
+//! server functions declared in TypeScript: Zod stays the source of truth, `.weft/contract.json` carries it, and `weft::build::generate` turns it into
+//! serde types, a typed error enum per function and one `Service` trait, so a change on the TS side stops `cargo` exactly
+//! where the Rust no longer matches.
+//!
+//! ```ignore
+//! // build.rs: fn main() { weft::build::generate("search") }
+//! weft::contract!();
+//! use contract::*;
+//!
+//! struct Search;
+//! impl Service for Search {
+//!     async fn search_docs(&self, ctx: weft::SharedCtx, input: SearchDocsInput) -> Result<SearchDocsOutput, weft::Error> {
+//!         ctx.touch("docs");
+//!         Ok(vec![])
+//!     }
+//! }
+//!
+//! #[tokio::main]
+//! async fn main() -> std::io::Result<()> {
+//!     weft::serve(weft::router(contract::functions(Search))).await
+//! }
+//! ```
+//!
+//! An addon is the same `impl Service` in a `cdylib`, with one line in place of `main`:
+//!
+//! ```ignore
+//! weft::native!(contract::functions(Media));
+//! ```
+//!
+//! TS keeps the public edge, sessions, CSRF, the cache and validation on both sides of the call. Rust only sees input
+//! that already passed, and claims, never cookies.
+
+#[cfg(feature = "build")]
+pub mod build;
+
+#[cfg(feature = "core")]
+#[cfg_attr(
+    not(any(feature = "server", feature = "native")),
+    allow(
+        dead_code,
+        reason = "`core` alone is what generated code names; the rest is for `server` and `native`"
+    )
+)]
+mod ctx;
+#[cfg(feature = "server")]
+mod envelope;
+#[cfg(feature = "core")]
+#[cfg_attr(
+    not(any(feature = "server", feature = "native")),
+    allow(
+        dead_code,
+        reason = "`core` alone is what generated code names; the rest is for `server` and `native`"
+    )
+)]
+mod functions;
+#[cfg(feature = "native")]
+#[doc(hidden)]
+#[cfg_attr(
+    test,
+    allow(dead_code, reason = "Node-API registers exports outside test builds")
+)]
+pub mod native;
+#[cfg(feature = "otel")]
+mod otel;
+#[cfg(feature = "server")]
+mod server;
+
+#[cfg(feature = "core")]
+pub use ctx::{Base, Ctx, Envelope, FromBase, SharedCtx, User, UserCtx};
+#[cfg(feature = "server")]
+pub use envelope::{Refused, sign, verify};
+#[cfg(feature = "core")]
+pub use functions::{Error, Failed, Failure, Functions};
+#[cfg(feature = "server")]
+pub use server::{router, router_with, serve};
+
+/// The generated contract, as `pub mod contract`: the types, the `Service` trait and `functions()`.
+#[macro_export]
+macro_rules! contract {
+    () => {
+        #[allow(dead_code, unused, clippy::all)]
+        pub mod contract {
+            include!(concat!(env!("OUT_DIR"), "/weft_contract.rs"));
+        }
+    };
+}
+
+/// This crate's functions as a Node-API addon, or a `.wasm` on that target: a `native()` crate's one line of glue.
+#[cfg(feature = "native")]
+#[macro_export]
+macro_rules! native {
+    ($functions:expr) => {
+        #[cfg(not(target_family = "wasm"))]
+        ::weft::__rt::napi::ctor::declarative::ctor! {
+            #[ctor(unsafe)]
+            fn __weft_native() {
+                ::weft::native::install(|| $functions)
+            }
+        }
+        #[cfg(target_family = "wasm")]
+        #[unsafe(no_mangle)]
+        pub extern "C" fn weft_init() {
+            ::weft::native::install(|| $functions)
+        }
+    };
+}
+
+/// What generated code names, so an app doesn't have to depend on what its schemas happen to use.
+#[cfg(feature = "core")]
+#[doc(hidden)]
+pub mod __rt {
+    pub use chrono;
+    #[cfg(all(feature = "native", not(target_family = "wasm")))]
+    pub use napi;
+    pub use regress;
+    pub use uuid;
+}

package/crate/src/native.rs

@@ -0,0 +1,212 @@
+//! `native()` (PLAN §4.3, research 39): a service's functions in-process. One crossing per function, as with a sidecar,
+//! with no HTTP and no signature: nothing outside the process can reach it.
+//!
+//! A real addon runs each call on the host's worker pool, so a long one doesn't hold the event loop. A `.wasm` is the
+//! same code behind a small ABI of its own, on whatever thread calls it. Neither brings an async runtime: this is for
+//! CPU, and a function that waits on IO belongs in `remote()`.
+
+use std::future::Future;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+use std::pin::pin;
+use std::sync::OnceLock;
+use std::task::{Context, Poll, Waker};
+
+use serde_json::json;
+
+use crate::ctx::{Base, Envelope};
+use crate::functions::{Answer, Failed, Functions, drift_body, internal_body, ok_body, panic_text};
+
+static MAKE: OnceLock<fn() -> Functions> = OnceLock::new();
+static FUNCTIONS: OnceLock<Functions> = OnceLock::new();
+
+/// Called once by `weft::native!`. The service is built on the first call, not while the library loads.
+pub fn install(make: fn() -> Functions) {
+    let _ = MAKE.set(make);
+}
+
+fn functions() -> &'static Functions {
+    FUNCTIONS.get_or_init(|| MAKE.get().expect("weft::native! ran")())
+}
+
+/// `{ service, hash, functions }`: TS refuses a library built from another contract (R103).
+fn contract() -> String {
+    let f = functions();
+    json!({ "service": f.service(), "hash": f.hash(), "functions": f.ids() }).to_string()
+}
+
+#[cfg(not(target_family = "wasm"))]
+fn wait<F: Future>(mut future: std::pin::Pin<&mut F>) -> F::Output {
+    struct Unpark(std::thread::Thread);
+    impl std::task::Wake for Unpark {
+        fn wake(self: std::sync::Arc<Self>) {
+            self.0.unpark();
+        }
+    }
+    let waker = Waker::from(std::sync::Arc::new(Unpark(std::thread::current())));
+    let mut cx = Context::from_waker(&waker);
+    loop {
+        match future.as_mut().poll(&mut cx) {
+            Poll::Ready(v) => return v,
+            Poll::Pending => std::thread::park(),
+        }
+    }
+}
+
+#[cfg(target_family = "wasm")]
+fn wait<F: Future>(future: std::pin::Pin<&mut F>) -> F::Output {
+    match future.poll(&mut Context::from_waker(Waker::noop())) {
+        Poll::Ready(v) => v,
+        Poll::Pending => {
+            panic!(
+                "a `native()` function can't wait on WASM: nothing would wake it. Use `remote()` for IO"
+            )
+        }
+    }
+}
+
+/// One call, start to finish, on this thread.
+fn dispatch(id: &str, ctx: &str, body: Vec<u8>) -> String {
+    let envelope: Envelope = match serde_json::from_str(ctx) {
+        Ok(e) => e,
+        Err(e) => return drift_body(&format!("the call's context didn't parse: {e}")).to_string(),
+    };
+    let Some(handler) = functions().handler(id) else {
+        return drift_body(&format!(
+            "this library has no function `{id}`: rebuild it from the current contract"
+        ))
+        .to_string();
+    };
+    let base = Base::new(id, envelope);
+    let call = handler(base.clone(), body);
+    let answer = catch_unwind(AssertUnwindSafe(|| wait(pin!(call)))).unwrap_or_else(|p| {
+        Answer::Failed(Failed::Internal(format!("panicked: {}", panic_text(&*p))))
+    });
+    match answer {
+        Answer::Value(value) => ok_body(&value, &base),
+        Answer::Failed(Failed::Typed(error)) => json!({ "ok": false, "error": error }).to_string(),
+        Answer::Failed(Failed::Internal(detail)) => internal_body(&base, Some(&detail)).to_string(),
+        Answer::Drift(detail) => drift_body(&detail).to_string(),
+    }
+}
+
+#[cfg(not(target_family = "wasm"))]
+mod addon {
+    use napi::bindgen_prelude::{AsyncTask, Env, Result, Task};
+    use napi_derive::napi;
+
+    pub struct Call {
+        id: String,
+        ctx: String,
+        body: Option<String>,
+    }
+
+    impl Task for Call {
+        type Output = String;
+        type JsValue = String;
+
+        fn compute(&mut self) -> Result<String> {
+            Ok(super::dispatch(
+                &self.id,
+                &self.ctx,
+                self.body.take().unwrap_or_default().into_bytes(),
+            ))
+        }
+
+        fn resolve(&mut self, _: Env, reply: String) -> Result<String> {
+            Ok(reply)
+        }
+    }
+
+    #[napi]
+    pub fn call(id: String, ctx: String, body: String) -> AsyncTask<Call> {
+        AsyncTask::new(Call {
+            id,
+            ctx,
+            body: Some(body),
+        })
+    }
+
+    #[napi]
+    pub fn contract() -> String {
+        super::contract()
+    }
+}
+
+/// A pointer and a length in one number: the only return value this ABI needs, and it fits a JS `BigInt`.
+#[cfg(target_family = "wasm")]
+mod wasm {
+    #[link(wasm_import_module = "weft")]
+    unsafe extern "C" {
+        fn now() -> f64;
+        fn panicked(ptr: *const u8, len: usize);
+    }
+
+    fn give(text: String) -> u64 {
+        let bytes = text.into_bytes().into_boxed_slice();
+        let len = bytes.len() as u64;
+        ((Box::into_raw(bytes).cast::<u8>() as u64) << 32) | len
+    }
+
+    /// # Safety
+    /// `ptr` and `len` are valid UTF-8 that outlives `'a`.
+    unsafe fn text<'a>(ptr: *const u8, len: usize) -> &'a str {
+        // SAFETY: the caller's contract above.
+        unsafe { std::str::from_utf8_unchecked(std::slice::from_raw_parts(ptr, len)) }
+    }
+
+    #[unsafe(no_mangle)]
+    pub extern "C" fn weft_alloc(len: usize) -> *mut u8 {
+        Box::into_raw(vec![0u8; len].into_boxed_slice()).cast::<u8>()
+    }
+
+    /// # Safety
+    /// `ptr` and `len` are what `weft_alloc`, `weft_call` or `weft_contract` handed out.
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn weft_free(ptr: *mut u8, len: usize) {
+        // SAFETY: the caller hands back a boxed slice of exactly `len` bytes.
+        drop(unsafe { Box::from_raw(std::ptr::slice_from_raw_parts_mut(ptr, len)) });
+    }
+
+    /// `body` is the caller's, and is taken over, as `weft_alloc` gave it.
+    ///
+    /// # Safety
+    /// Each pair is valid UTF-8 from `weft_alloc`.
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn weft_call(
+        id: *const u8,
+        id_len: usize,
+        ctx: *const u8,
+        ctx_len: usize,
+        body: *mut u8,
+        body_len: usize,
+    ) -> u64 {
+        // A panic aborts here: the instance traps, and TS starts a new one. This is how the message gets out first.
+        static HOOK: std::sync::Once = std::sync::Once::new();
+        HOOK.call_once(|| {
+            std::panic::set_hook(Box::new(|info| {
+                let message = info.to_string();
+                // SAFETY: the host copies the bytes out during the call; `message` is live and UTF-8.
+                unsafe { panicked(message.as_ptr(), message.len()) }
+            }));
+        });
+        // SAFETY: `body` is a `weft_alloc` box of `body_len` bytes, and it's ours now.
+        let body =
+            unsafe { Box::from_raw(std::ptr::slice_from_raw_parts_mut(body, body_len)) }.into_vec();
+        // SAFETY: the caller keeps both strings, valid UTF-8, for the whole call.
+        let (id, ctx) = unsafe { (text(id, id_len), text(ctx, ctx_len)) };
+        give(super::dispatch(id, ctx, body))
+    }
+
+    #[unsafe(no_mangle)]
+    pub extern "C" fn weft_contract() -> u64 {
+        give(super::contract())
+    }
+
+    pub(crate) fn time() -> f64 {
+        // SAFETY: a plain import: no arguments, no memory.
+        unsafe { now() }
+    }
+}
+
+#[cfg(target_family = "wasm")]
+pub(crate) use wasm::time as now_ms;