# Distributed Async Await — specification, server implementers' guide, and SDK authors' handbook

> The protocol specification, server implementers' guide, and SDK authors' handbook for Distributed Async Await.

- [Distributed Async Await](/): "The protocol specification, server implementers' guide, and SDK authors' handbook for Distributed Async Await."
- [Coroutines in your language](/sdk/coroutines): "Expressing a durable function idiomatically — sync generators or async futures — and how the SDK drives it, compared across the reference SDKs."
- [Encoding, codecs, encryption](/sdk/encoding-and-codecs): "How a step's arguments and results become the encoded strings a promise carries, the codec that gives them meaning, and the honest state of encryption across the SDKs."
- [The function registry & invocation surface](/sdk/function-registry): "Letting developers register durable functions and invoke them — locally and remotely — how a name becomes a targeted promise, and how a fresh process resolves it back to code."
- [How to build a Resonate SDK](/sdk): "A handbook for developers implementing the Distributed Async Await protocol in their own language — from the protocol mental model to production concerns."
- [Why an SDK exists](/sdk/introduction): "A durable execution SDK exists to make one hard guarantee feel like ordinary code. Understanding that job is the whole foundation for building one."
- [Local mode for development](/sdk/local-mode): "Running the whole engine in-process so a developer can build with nothing else installed — what it faithfully emulates, and the one gap you have to be honest about."
- [Production concerns](/sdk/production-concerns): "What running the SDK you built actually demands — observability, versioning functions in flight, performance levers, and the failure modes operators will see."
- [Promise lifecycle in code](/sdk/promise-lifecycle): "Modeling the durable promise in your language — creation, settlement, the value schema, the terminal states, and the idempotency that makes every write safe to retry."
- [The protocol at a glance](/sdk/protocol-at-a-glance): "The moving parts you will implement — promises, tasks, messages, and the loop that ties them together — named once so later chapters can use them."
- [Replay and deterministic execution](/sdk/replay-and-determinism): "The heart of durable execution — replaying a function from its recorded promises, the deterministic ids that make it work, and the contract that keeps it correct."
- [Suspend, resume, and the settlement chain](/sdk/suspend-resume-settlement): "How a function suspends while awaiting work without holding a thread, how the server resumes it when that work settles, and the chain that propagates a result back through the call graph."
- [Talking to the server](/sdk/talking-to-the-server): "The transport layer — the connection abstraction, the request/response envelope, and the poll transport that delivers work to your worker over SSE."
- [Tasks and the worker loop](/sdk/tasks-and-the-worker-loop): "How a worker claims work, holds a lease, heartbeats, and returns results — the version-based concurrency and the loop at the center of every SDK."
- [Testing your SDK against the spec](/sdk/testing-against-the-spec): "The server invariants your implementation must never violate, how to find out whether it does, and why the shipped server — not the prose — is the final word."
- [Time, retries, and policies](/sdk/time-retries-policies): "Durable sleep as a timer promise, scheduling work without a live process, and how a retry policy is expressed and where it actually runs."
- [The abstract machine: ServerState, effects, and handlers](/server/abstract-machine): "How the Lean 4 spec defines the server as a deterministic state machine — ServerState, atomic effects, and pure handler functions — and why that shape is the right foundation for an implementer."
- [The request/response envelope and transport](/server/envelope-and-transport): "The JSON envelope every handler reads and writes, the status-code vocabulary, and how the reference server binds the protocol to HTTP — separating spec requirement from reference convention."
- [Implementing the promise handlers](/server/implementing-promises): "Exact semantics for the five specified promise handlers (P-01–P-05) plus the search stub (P-06), derived from the Lean 4 specification: state transitions, idempotency rules, the settlement scrub, and the link between create and task dispatch."
- [Implementing schedules](/server/implementing-schedules): "How to implement the three specified schedule handlers (plus the search stub) and the onScheduleTimeout catch-up loop in a conformant DAA server."
- [Implementing tasks: the full handler reference](/server/implementing-tasks): "Spec-precise implementation notes for the nine specified task handlers — create, acquire, fence, heartbeat, suspend, fulfill, release, halt, continue — plus task.get and the unimplemented search stub."
- [Build a server](/server): "Why durable execution is a protocol, what conformance means, and how the three existing implementations prove any sufficiently capable substrate can become a provider."
- [The outbox and message delivery](/server/outbox-and-delivery): "How the server's outbox — part of machine state, not an implementation detail — drives task dispatch and promise unblocking with exactly-two message types and at-least-once delivery."
- [State model: records, enums, and internal fields](/server/state-model): "The exact structure of every object in ServerState — PromiseObject, TaskObject, Schedule, timeout lists, and outbox — including which fields appear on the wire and which are internal-only."
- [Storage strategies: backing a DAA server](/server/storage-strategies): "The substrate requirements every DAA server storage layer must meet, with three worked case studies: relational SQL, wide-column NoSQL, and a message-broker KV store."
- [Testing and conformance: what you can verify today](/server/testing-and-conformance): "How to build an oracle-diff harness against the public reference state machine, use the debug endpoints for seeded simulation, assert the spec's structural invariants, and understand the current state of public conformance tooling."
- [Timeouts and projection](/server/timeouts-and-projection): "The three timeout lists, the four internal transitions, and the projection convention — why your reads and stored state can legally diverge."
- [Unspecified surface: what the spec deliberately leaves open](/server/unspecified-surface): "A reference list of behaviors the Lean spec explicitly does not define — search handlers, nextCron, expand, preload, auth, transport, and concurrency — so implementers know what is theirs to choose."
- [Distributed Coordination Protocol](/spec/execution-model/coordination-protocol): How callers and remote callees coordinate via durable promises — eventual and immediate resumption.
- [Execution model](/spec/execution-model): Coordination, recovery, and message-passing protocols that make distributed programs make progress.
- [Message Passing Protocol](/spec/execution-model/message-passing): The wire-level contract — envelope, status codes, addressing, transport variants — that all Distributed Async Await communication rides on.
- [Recovery Protocol](/spec/execution-model/recovery-protocol): How a logical execution survives the failure of a physical process — settlement chain, lease and heartbeat, and the invariants a conformant server maintains.
- [Glossary](/spec/glossary): Load-bearing terms used throughout the Distributed Async Await specification.
- [Specification](/spec): The Distributed Async Await specification — protocols, definitions, and models for durable execution.
- [Durable Function Specification](/spec/programming-model/durable-function-specification): Formal definition of interruption tolerance and the constraints a function must satisfy for the equivalence to hold.
- [Durable Promise Specification](/spec/programming-model/durable-promise-specification): API + state-transition table for durable promises — the persistent coordination primitive of Distributed Async Await.
- [Programming model](/spec/programming-model): Functions and promises lifted to span processes, machines, and time. Defines the developer interface.
- [Function Executions](/spec/system-model/executions): The fundamental unit of computation — lifecycle, long-running semantics, and the logical/physical distinction.
- [System model](/spec/system-model): A first-principles model of distributed systems — processes, executions, and tasks — that grounds the rest of the specification.
- [Processes](/spec/system-model/processes): The fundamental unit of locality — lifecycle, fail-stop failure, and the logical/physical distinction.
- [Tasks](/spec/system-model/tasks): The unit of work the server delivers to a worker — lifecycle, version-based concurrency, and lease semantics.