# SDKs and language support

One's platform implementation can remain predominantly Rust without requiring
application code in every language to execute through Rust. SDKs project exact
One contracts into idiomatic target-language APIs; they are not independent
copies of Planning, Build, Authority, Deployment, or History.

> **Capability illustration:** The portable workflow spellings on this page
> remain illustrative. The current TypeScript implementation covers bounded
> unary contract values, clients, service handlers, authority-bound application
> dispatch, and Build receipts; portable workflow and TypeScript
> implementation-body support remain typed unavailable.

## Support has explicit depth

“Supports Python” or “supports TypeScript” is incomplete without naming the
capability:

| Capability | What the language receives |
| --- | --- |
| Contract values | generated/dynamic types, bounds, validators, identities, faults and causes |
| Client | typed call, stream, job and workflow handles plus compatibility and context propagation |
| Service/activity worker | generated handler interfaces, bounded worker lifecycle, cancellation, authority and effect context |
| Portable workflow | One's deterministic command API, activities, timers, signals/updates, replay and versioning |
| Implementation bodies | exact source-language definition, profile, frontend, toolchain, dependencies, build/runtime and conformance |
| Native embedding | a separately governed ABI, ownership and lifecycle boundary |

A lower capability does not imply a higher one. Generating a TypeScript client
does not make TypeScript a complete `.one` implementation-body language, and a
wire-compatible Python server does not prove portable workflow replay.

## Generated contracts, ordinary code

A generated target-language package supplies exact types and symbolic
operation references:

```ts
import { OneClient } from "@one/sdk";
import {
  FulfillmentClient,
  type FulfillOrderInput,
} from "@parcelhub/contracts";

const client = new FulfillmentClient(
  await OneClient.connect({ endpoint }),
);

const run = await client.fulfillOrder.start({
  orderId: "order-123",
} satisfies FulfillOrderInput);

const result = await run.result();
```

The validator, constructors, and pure helpers can run entirely in TypeScript.
The client can communicate directly with an admitted remote endpoint over the
selected protocol. A local Rust daemon or FFI call is not implied.

Server and activity SDKs add generated handler interfaces and a language
runtime host:

```ts
import { service } from "@one/sdk";
import { Greeter, Greeting } from "claim";

export default service.implements(Greeter, {
  async sayHello(cx, request) {
    await cx.checkpoint();
    return Greeting.create({
      message: `Hello, ${request.name}!`,
    });
  },
});
```

Planning selects whether that implementation is embedded, a WebAssembly
component, a separate process, or remote. The chosen boundary makes codecs,
copies, lifecycle, isolation, failure, authority, and cost visible.

## Full implementation support is more than an SDK

To admit a Python, TypeScript, Go, or other body in a `.one` implementation
item, the exact `using` profile must resolve:

- the source-language definition and release;
- parser, analyzer and formatter contracts and admitted tools;
- the contract projection and runtime-support revisions;
- package/module dependency and target constraints;
- compiler/build and worker/runtime realization; and
- artifact, conformance, binding and admission evidence.

Generic `.one` tooling can still frame and preserve an unavailable language
body byte-for-byte. Language-aware checking and building return typed
unavailable output rather than guessing from an installed SDK.

## Provider-specific SDKs remain available

Portable One SDKs are the ordinary path, but an implementation can deliberately
use a provider SDK such as Temporal's. Its exact profile and dependency closure
make that descent and portability loss visible. One can still own the semantic
contract, artifact, provider selection, authority, deployment and evidence
around the provider-specific code.

Task queues, worker registration, endpoints, credentials and grants are
normally derived from the selected plan. A user-authored provider bootstrap is
allowed as an explicit external/provider-specific component; One claims only
the integration and evidence that actually enter its contracts.

## Current implementation

The repository currently provides the Rust facade and lower Rust atoms plus a
receipted generated Rust contract projection used by ParcelHub's typed Get and
Place clients. Native One is an implemented body language for the bounded
SafeAsync unary slice, with exact analysis, bytecode and Component Build, and
runtime evidence.

TypeScript now has a Contracts-owned `sdk/v1` projection and the dependency-free
`@one/contracts` support package. For bounded unary OCS contracts it has parity
with the generated Rust SDK: strict ESM values, exact validators,
arbitrary-precision `bigint` codecs, structured exits, request and scope
commitments, typed clients, service handler interfaces, owner-governed fault
identities, typed effect-recovery handoff, authority preflight/admission, and
bounded application dispatch. The generic Build action, project manifest, and
`one export contract-projection` path materialize either Rust or TypeScript
bindings with canonical configuration and output receipts.

Select the TypeScript artifact on a root with the same projection lifecycle as
Rust:

```toml
artifact_forms = ["projection_receipt", "typescript_bindings"]
typescript_bindings_output = "generated/contracts.ts"
typescript_projection_receipt = "generated/contracts.receipt"
```

This does not duplicate Rust-owned atoms. Planning, Authority, Build,
Deployment, and History remain their existing owners, and a selected host or
transport adapter supplies their contracts to the generated SDK. Portable
workflow support, a concrete TypeScript runtime provider/package resolver, and
a TypeScript `.one` implementation-body profile remain unavailable.

Continue with [implementation items](/one/language/implementation-items),
[interoperability](/one/compose/interoperability), and
[workflows and effects](/one/build/workflows-and-effects).

Canonical owners:
[Contracts](https://github.com/muijf/one/blob/main/systems/contracts/AGENTS.md),
[System IDL](https://github.com/muijf/one/blob/main/systems/system-idl/AGENTS.md),
[Build](https://github.com/muijf/one/blob/main/systems/build/AGENTS.md), and
[Developer Interface](https://github.com/muijf/one/blob/main/systems/developer-interface/AGENTS.md).