@resonatehq/sdk 0.10.4 → 0.11.1

package/README.md

@@ -104,3 +104,63 @@ resonate tree countdown.1
 ```
 
 Now try killing the worker mid-countdown and restarting. **The countdown picks up right where it left off without missing a beat.**
+
+## Async/await
+
+The SDK also ships an async/await engine: the same durable model, written with ordinary `async` functions instead of generators. Import it from `@resonatehq/sdk/async`:
+
+```typescript
+import { Resonate, type Context } from "@resonatehq/sdk/async";
+
+async function countdown(ctx: Context, count: number, delay: number) {
+  for (let i = count; i > 0; i--) {
+    // Run a function, persist its result
+    await ctx.run((ctx: Context) => console.log(`Countdown: ${i}`));
+    // Sleep
+    await ctx.sleep(delay * 1000);
+  }
+  console.log("Done!");
+}
+
+// Instantiate Resonate
+const resonate = new Resonate({ url: "http://localhost:8001" });
+// Register the function
+resonate.register(countdown);
+```
+
+Same server, same CLI, same durable promises — the rest of the quickstart is unchanged.
+
+One difference to know about: operations are **eager**. Calling `ctx.run(...)` starts the work immediately and returns an awaitable handle, so fan-out is ordinary promise code:
+
+```typescript
+async function checkout(ctx: Context) {
+  const payment = ctx.run(chargeCard);     // starts now
+  const inventory = ctx.run(reserveItems); // runs concurrently
+  return await Promise.all([payment, inventory]);
+}
+```
+
+## Migrating from generators
+
+Both engines live in the same package and speak the same protocol to the same server, so you can migrate one function at a time. The mechanical changes:
+
+| Generator engine | Async engine |
+| --- | --- |
+| `import { Resonate } from "@resonatehq/sdk"` | `import { Resonate } from "@resonatehq/sdk/async"` |
+| `function* (context: Context, ...)` | `async function (ctx: Context, ...)` |
+| `yield* context.run(...)`, `yield* context.sleep(...)` | `await ctx.run(...)`, `await ctx.sleep(...)` |
+| `yield context.beginRun(...)`, later `yield future` | `const p = ctx.run(...)`, later `await p` — every op is eager |
+| `resonate.run(id, func, ...args)` → the result | `resonate.run(id, func, ...args)` → a handle; `await handle.result()` |
+| `resonate.beginRun(id, func, ...args)` → a handle | same call — there are no `begin*` variants, `run` *is* begin-run |
+
+Two things to watch:
+
+- **Retries are opt-in.** The generator engine retries plain functions with exponential backoff by default. The async engine never retries by default — an async workflow and a plain async function are indistinguishable at runtime, so there is no safe blanket default. To keep retry behavior, pass a policy explicitly:
+
+  ```typescript
+  import { Exponential } from "@resonatehq/sdk/async";
+
+  await ctx.run(chargeCard, ctx.options({ retryPolicy: new Exponential() }));
+  ```
+
+- **Only await durable promises inside a workflow.** A plain `await` on a timer or network call is invisible to the engine — the workflow may resume after its execution pass has ended and abort. Wrap side effects in `ctx.run`, the same rule as `context.run` in the generator engine.

package/dist/async/context.d.ts

@@ -0,0 +1,270 @@
+import type { Clock } from "../clock.js";
+import { type ResonateError } from "../exceptions.js";
+import type { Options, OptionsBuilder } from "../options.js";
+import type { Registry } from "../registry.js";
+import { type RetryPolicy } from "../retries.js";
+import type { TraceCollector } from "../trace.js";
+import type { Effects } from "../types.js";
+export type AnyFunc = (ctx: any, ...args: any[]) => any;
+export type Params<F> = F extends (ctx: any, ...args: infer P) => any ? P : never;
+export type ParamsWithOptions<F> = [...Params<F>, Options?];
+export type Return<F> = F extends (...args: any[]) => infer R ? Awaited<R> : never;
+/**
+ * Read-only execution metadata available to every function. A "leaf" function
+ * types its first parameter as `Info` — it gets identity + dependencies but no
+ * durable operations, so it never suspends and always completes in one pass.
+ */
+export interface Info {
+    readonly id: string;
+    readonly parentId: string;
+    readonly originId: string;
+    /** The id-generation prefix (resonate:prefix). Set once at the top and
+     * propagated down unchanged — through every child AND across detached
+     * re-roots — so recursive detached ids stay bounded. */
+    readonly prefixId: string;
+    readonly branchId: string;
+    readonly timeoutAt: number;
+    readonly attempt: number;
+    readonly version: number;
+    readonly func: string;
+    getDependency<T = any>(key: string): T | undefined;
+}
+/**
+ * Full durable API available to a "workflow" function (first parameter typed
+ * `Context`). All operations are eager — calling `run`/`rpc`/`sleep` begins the
+ * work immediately and returns an already-running {@link DurablePromise}.
+ * Awaiting one now is call-and-wait; holding several and awaiting them later is
+ * fan-out.
+ *
+ * A pending durable promise makes the returned promise **hang** (never settle)
+ * for this pass — the engine ends the pass out of band. So `await` here behaves
+ * like a normal JS promise: it only ever throws a real rejection.
+ */
+export interface Context extends Info {
+    run<F extends AnyFunc>(func: F, ...args: ParamsWithOptions<F>): DurablePromise<Return<F>>;
+    run<T>(func: string, ...args: any[]): DurablePromise<T>;
+    rpc<F extends AnyFunc>(func: F, ...args: ParamsWithOptions<F>): DurablePromise<Return<F>>;
+    rpc<T>(func: string, ...args: any[]): DurablePromise<T>;
+    /**
+     * Spawns a workflow as a fresh root promise — independent execution lifecycle
+     * and replay scope (lineage break, new originId). Unlike `run`/`rpc`, the
+     * spawned workflow is not a child of the current invocation: it survives parent
+     * completion and is dispatched independently by the server.
+     *
+     * The returned promise resolves with a {@link DetachedHandle} once the spawn is
+     * durably created — it does NOT wait for, and the parent does NOT suspend on,
+     * the detached workflow's result. This is the primitive behind the bounded
+     * replay forever-loop (recursive-tail) pattern.
+     *
+     * @example
+     * ```ts
+     * async function playGame(ctx: Context, n: number) {
+     *   // ...play one game...
+     *   await ctx.detached(playGame, n + 1); // last statement, then return
+     * }
+     * ```
+     */
+    detached<F extends AnyFunc>(func: F, ...args: ParamsWithOptions<F>): DurablePromise<DetachedHandle>;
+    detached(func: string, ...args: any[]): DurablePromise<DetachedHandle>;
+    /**
+     * Creates a latent durable promise (DPC) with no associated function, intended
+     * to be resolved out of band (human-in-the-loop / external signal) via
+     * `resonate.promises.resolve(id)`. Awaiting it suspends the parent until the
+     * promise is settled externally. The id is `${ctx.id}.${seq}`.
+     */
+    promise<T>(opts?: {
+        timeout?: number;
+        data?: any;
+        tags?: {
+            [key: string]: string;
+        };
+    }): DurablePromise<T>;
+    sleep(ms: number): DurablePromise<void>;
+    sleep(opts: {
+        for?: number;
+        until?: Date;
+    }): DurablePromise<void>;
+    sleep(msOrOpts: number | {
+        for?: number;
+        until?: Date;
+    }): DurablePromise<void>;
+    options(opts?: Partial<Omit<Options, "id">>): Options;
+    /**
+     * Aborts the entire pass if condition is true (`panic`) / false (`assert`):
+     * no promise is settled and the task is released for redelivery — mirroring
+     * the generator engine's DIE. The abort is recorded on the context before
+     * the throw, so a surrounding user try/catch cannot suppress it.
+     */
+    panic(condition: boolean, msg?: string): void;
+    assert(condition: boolean, msg?: string): void;
+    date: {
+        now(): DurablePromise<number>;
+    };
+    math: {
+        random(): DurablePromise<number>;
+    };
+}
+/**
+ * The internal outcome of a durable operation. Unlike the user-facing promise
+ * (which may hang on suspend), an outcome ALWAYS settles, so the pass's drain
+ * can read it without hanging.
+ */
+export type Outcome = {
+    kind: "value";
+    value: any;
+} | {
+    kind: "error";
+    error: any;
+} | {
+    kind: "suspended";
+    remote: string[];
+};
+/** Lightweight reference to a detached (independently-rooted) workflow. */
+export interface DetachedHandle {
+    readonly id: string;
+}
+/**
+ * The branded handle returned by every durable operation on {@link Context}
+ * (`run`, `rpc`, `sleep`, `detached`, `promise`). Behaves exactly like the
+ * user-facing promise it wraps (then/catch/finally/await, including the
+ * hang-on-suspend semantics) and additionally exposes the durable promise `id`.
+ *
+ * The brand marks the awaitables that are safe inside a workflow: replay
+ * determinism requires that `await` only ever targets durable promises —
+ * awaiting a timer, I/O, or a plain async-helper chain lets durable ids be
+ * assigned in completion order, which cross-wires them on replay.
+ */
+export declare class DurablePromise<T> implements Promise<T> {
+    /** The durable promise id (`""` when the op failed before creating one). */
+    readonly id: string;
+    private readonly promise;
+    readonly [Symbol.toStringTag] = "DurablePromise";
+    constructor(
+    /** The durable promise id (`""` when the op failed before creating one). */
+    id: string, promise: Promise<T>);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+}
+interface AsyncContextConfig {
+    id: string;
+    oId?: string;
+    prId?: string;
+    bId?: string;
+    pId?: string;
+    func: string;
+    clock: Clock;
+    registry: Registry;
+    dependencies: Map<string, any>;
+    optsBuilder: OptionsBuilder;
+    timeout: number;
+    version: number;
+    attempt?: number;
+}
+export declare class AsyncContext implements Context {
+    readonly id: string;
+    readonly originId: string;
+    readonly prefixId: string;
+    readonly branchId: string;
+    readonly parentId: string;
+    readonly func: string;
+    readonly timeoutAt: number;
+    readonly attempt: number;
+    readonly version: number;
+    readonly clock: Clock;
+    private registry;
+    private dependencies;
+    private optsBuilder;
+    private effects;
+    /** Lifecycle-event sink for this pass; shared with the root + every child. */
+    private trace;
+    private seq;
+    /** Set once the pass is finalized (drain stable); durable ops then panic. */
+    private closed;
+    /** Every started op's always-settling outcome; the pass drains these. */
+    readonly spawnedHandles: Promise<Outcome>[];
+    /** Resolved the first time any op observes a pending remote → ends the pass. */
+    readonly suspendSignal: Promise<void>;
+    private _fireSuspend;
+    /** Resolved by ctx.panic → ends the pass; the recorded error aborts it. */
+    readonly panicSignal: Promise<void>;
+    private _firePanic;
+    private _panicError?;
+    /** Tail of the creation sequencer chain (serializes promiseCreate calls). */
+    private createTail;
+    constructor(cfg: AsyncContextConfig, effects: Effects, trace: TraceCollector);
+    /** The panic that aborted this pass, if any. Authoritative: set by ctx.panic
+     * before the throw, so it survives a user try/catch around the call. */
+    get panicError(): ResonateError | undefined;
+    /** End the pass: a durable op observed a pending remote. Idempotent. */
+    fireSuspend(): void;
+    /**
+     * Finalize the pass. Every op in `spawnedHandles` has been drained; a durable
+     * op started after this point comes from a continuation that outlived the pass
+     * (parked on a non-durable await — a timer, I/O, etc.). It would escape the
+     * drain and race task.suspend/fulfill as a zombie, so it panics instead.
+     */
+    close(): void;
+    private guardOpen;
+    private child;
+    private claimCreateSlot;
+    private createSlotted;
+    run(funcOrName: AnyFunc | string, ...args: any[]): DurablePromise<any>;
+    rpc(funcOrName: AnyFunc | string, ...args: any[]): DurablePromise<any>;
+    sleep(ms: number): DurablePromise<void>;
+    sleep(opts: {
+        for?: number;
+        until?: Date;
+    }): DurablePromise<void>;
+    detached(funcOrName: AnyFunc | string, ...args: any[]): DurablePromise<DetachedHandle>;
+    promise<T>({ timeout, data, tags, }?: {
+        timeout?: number;
+        data?: any;
+        tags?: {
+            [key: string]: string;
+        };
+    }): DurablePromise<T>;
+    private remoteOutcome;
+    private track;
+    private facing;
+    private settle;
+    getDependency<T = any>(name: string): T | undefined;
+    options(opts?: Partial<Pick<Options, "tags" | "target" | "timeout" | "version" | "retryPolicy" | "nonRetryableErrors">>): Options;
+    panic(condition: boolean, msg?: string): void;
+    assert(condition: boolean, msg?: string): void;
+    readonly date: {
+        now: () => DurablePromise<number>;
+    };
+    readonly math: {
+        random: () => DurablePromise<number>;
+    };
+    private createReq;
+    private localCreateReq;
+    private remoteCreateReq;
+    private detachedCreateReq;
+    private latentCreateReq;
+    private sleepCreateReq;
+    private seqid;
+}
+/**
+ * Run a user function to completion or suspension under `ctx`.
+ *
+ * The function may park forever on a hung `await`, so we race it against the
+ * suspend signal rather than waiting for it to finish. Whatever wins, we then
+ * drain every started op (their outcomes always settle) to collect the complete
+ * set of remote-todos — this is the authoritative suspend decision.
+ */
+export declare function run(ctx: AsyncContext, func: AnyFunc, args: any[]): Promise<Outcome>;
+/**
+ * Run a user function with in-process retries (mirrors `util.executeWithRetry`
+ * for the generator engine). Each attempt runs under a FRESH context — so a
+ * function that creates durable children re-creates them with identical ids and
+ * replays via dedup, exactly like a cross-process replay.
+ *
+ * Only an `error` outcome is retried; `value` and `suspended` short-circuit. A
+ * retry is skipped (and the error returned) when the error is non-retryable, the
+ * policy is exhausted, or the next delay would exceed the function's timeout.
+ */
+export declare function runWithRetry(makeCtx: (attempt: number) => AsyncContext, func: AnyFunc, args: any[], policy: RetryPolicy, nonRetryableErrors: Array<new (...args: any[]) => Error>, clock: Clock, timeoutAt: number): Promise<Outcome>;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/async/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/async/context.ts"],"names":[],"mappings":"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"}