#temporal.mbt

#Status

• Target: MoonBit native builds on Linux.
• API level: low-level Core handles and raw protobuf Bytes.
• Stability: experimental. Names and option shapes may change while the binding tracks the Temporal SDK Core bridge.
• Build model: Cargo builds the vendored Rust bridge as a static library during MoonBit native builds.

#What Is Included

• Runtime for owning the Temporal Core runtime.
• Connection for connecting to Temporal services and making raw RPC calls.
• Worker for polling and completing Core worker tasks with protobuf bytes.
• CancellationToken for cancelling in-flight RPC calls.
• Random for deterministic Core-compatible random values.
• EphemeralServer helpers for starting Temporal test/dev servers through Core.
• Structured MoonBit option types for runtime, connection, RPC, worker, and ephemeral server configuration.

#Build Requirements

• MoonBit toolchain with native target support.
• Rust/Cargo toolchain.
• A C compiler and linker for MoonBit native stubs.
• Protocol Buffers compiler (protoc), available on PATH or selected by PROTOC.

cargo build --manifest-path vendor/temporal-sdk-core/Cargo.toml \
  -p temporalio-sdk-core-c-bridge --release

vendor/temporal-sdk-core/target/

#Quick Check

moon check --target native
moon test --target native

node scripts/vendor_temporal_core.mjs --check

node scripts/vendor_temporal_core.mjs

#Ownership And Lifetimes

• Runtime
• Connection
• Worker
• CancellationToken
• Random
• EphemeralServer

#Protobuf Bytes

• RpcCallOptions::request is an encoded Temporal request message.
• Connection::rpc_call_blocking returns the encoded response message.
• Worker poll methods return encoded activation/task messages.
• Worker completion and heartbeat methods accept encoded completion/heartbeat messages.

#Metadata Encoding

key1
value1
key2
value2

#Creating A Runtime

let runtime = match Runtime::new() {
  Ok(runtime) => runtime
  Err(err) => abort(err.message)
}

#Connecting To Temporal

let options = ConnectionOptions::new(
  "http://127.0.0.1:7233",
  client_name="temporal.mbt-example",
  client_version="0.1.0",
  identity="example-worker",
)

let connection = match Connection::connect_blocking(runtime, options) {
  Ok(connection) => connection
  Err(err) => abort(err.message)
}

connection.update_api_key("new-api-key")
connection.update_metadata(b"authorization\nBearer token")

#Raw RPC Calls

let call = RpcCallOptions::new(
  Workflow,
  "GetSystemInfo",
  request=b"",
  timeout_millis=5000U,
)

match connection.rpc_call_blocking(call) {
  Ok(response_bytes) => {
    // Decode temporal.api.workflowservice.v1.GetSystemInfoResponse here.
    ignore(response_bytes)
  }
  Err(failure) => {
    abort(failure.message)
  }
}

let token = CancellationToken::new()
let call = RpcCallOptions::new(
  Workflow,
  "GetSystemInfo",
  cancellation_token=token,
)
token.cancel()
ignore(connection.rpc_call_blocking(call))

#Workers

let worker_options = WorkerOptions::new(
  "default",
  "moonbit-task-queue",
  build_id="temporal.mbt-example",
)

let worker = match Worker::new(connection, worker_options) {
  Ok(worker) => worker
  Err(err) => abort(err.message)
}

match worker.poll_workflow_activation_blocking() {
  Ok(Some(activation)) => {
    // Decode the activation protobuf and eventually complete it.
    ignore(activation)
  }
  Ok(None) => ()
  Err(err) => abort(err.message)
}

let completion : Bytes = b"...encoded completion..."
match worker.complete_workflow_activation_blocking(completion) {
  Ok(()) => ()
  Err(err) => abort(err.message)
}

worker.initiate_shutdown()
ignore(worker.finalize_shutdown_blocking())

#Ephemeral Servers

let options = DevServerOptions::default()
let (server, target) = match EphemeralServer::start_dev_server_blocking(runtime, options) {
  Ok(pair) => pair
  Err(err) => abort(err.message)
}

let connection = Connection::connect_blocking(
  runtime,
  ConnectionOptions::new(target),
)

ignore(connection)
ignore(server.shutdown_blocking())

#Deterministic Random

test "deterministic random" {
  let random = Random::new(123UL)
  let value = random.int32_range(1, 10)
  assert_true(value >= 1 && value < 10)

  let bytes = random.fill_bytes(8)
  assert_eq(bytes.length(), 8)
}

#Error Handling

#Maintaining The Vendor Snapshot

node scripts/vendor_temporal_core.mjs
node scripts/vendor_temporal_core.mjs --check
moon test --target native