@restatedev/restate-sdk-gen 0.0.0 → 1.14.2

package/dist/index.js

@@ -0,0 +1,1078 @@
+import * as restate from "@restatedev/restate-sdk";
+
+//#region src/current.ts
+let CURRENT = null;
+/**
+* Save the previous slot, install `value` as the current. Returns the
+* previous value so `clearCurrent` can restore it (supports nested
+* scheduler invocations on the same thread, even though we don't expect
+* any in production).
+*/
+function setCurrent(value) {
+	const prev = CURRENT;
+	CURRENT = value;
+	return prev;
+}
+/** Restore a slot previously captured by `setCurrent`. */
+function clearCurrent(prev) {
+	CURRENT = prev;
+}
+/**
+* Read the slot, throwing if no fiber is currently advancing. Callers
+* cast the return type — the slot is intentionally `unknown` here so
+* this module stays free of cycles.
+*/
+function getCurrent() {
+	if (CURRENT === null) throw new Error("@restatedev/restate-sdk-gen: free-standing API called outside an active fiber. Call from inside `execute(ctx, gen(function*() { ... }))`.");
+	return CURRENT;
+}
+
+//#endregion
+//#region src/free.ts
+/**
+* Read the active `RestateOperations` from the current-fiber slot.
+* Throws if called outside a fiber's synchronous advance span (e.g.,
+* at module init or inside an `ops.run` async closure that resolved
+* after the fiber returned).
+*/
+function currentOps() {
+	return getCurrent();
+}
+/**
+* Run a side-effecting closure as a journal entry. See
+* `RestateOperations.run` for full semantics.
+*
+* `name` is derived from `action.name` (works for named functions and
+* arrow functions assigned to a `const`) or specified explicitly via
+* `opts.name`. If neither resolves, throws.
+*/
+const run = (action, opts) => currentOps().run(action, opts);
+const sleep = (duration, name) => currentOps().sleep(duration, name);
+const awakeable = (serde) => currentOps().awakeable(serde);
+const resolveAwakeable = (id, payload, serde) => currentOps().resolveAwakeable(id, payload, serde);
+const rejectAwakeable = (id, reason) => currentOps().rejectAwakeable(id, reason);
+const signal = (name, serde) => currentOps().signal(name, serde);
+const attach = (invocationId, serde) => currentOps().attach(invocationId, serde);
+const serviceClient = (api) => currentOps().serviceClient(api);
+const objectClient = (api, key) => currentOps().objectClient(api, key);
+const workflowClient = (api, key) => currentOps().workflowClient(api, key);
+const serviceSendClient = (api) => currentOps().serviceSendClient(api);
+const objectSendClient = (api, key) => currentOps().objectSendClient(api, key);
+const workflowSendClient = (api, key) => currentOps().workflowSendClient(api, key);
+const genericCall = (call) => currentOps().genericCall(call);
+const genericSend = (call) => currentOps().genericSend(call);
+const cancel = (invocationId) => currentOps().cancel(invocationId);
+const channel = () => currentOps().channel();
+const state = () => currentOps().state();
+const sharedState = () => currentOps().sharedState();
+const workflowPromise = (name, serde) => currentOps().workflowPromise(name, serde);
+/**
+* Wait for every future to settle; return their values in input order.
+* Heterogeneous-tuple typing — `all([fA, fB])` where `fA: Future<A>`
+* and `fB: Future<B>` yields `Future<[A, B]>`. Mirrors `Promise.all`.
+*/
+const all = (futures) => currentOps().all(futures);
+/**
+* Return the first future to settle; losers continue running but their
+* results are discarded. Heterogeneous-tuple typing — `race([fA, fB])`
+* yields `Future<A | B>`. Mirrors `Promise.race`.
+*/
+const race = (futures) => currentOps().race(futures);
+/**
+* First-to-succeed wins (non-rejected). Rejects with `AggregateError(errors)`
+* when every input rejects (including the empty input case). Tuple-aware —
+* `any([fA, fB])` yields `Future<A | B>`. Mirrors `Promise.any`.
+*/
+const any = (futures) => currentOps().any(futures);
+/**
+* Wait for every future to settle; never rejects. Tuple-aware —
+* `allSettled([fA, fB])` yields
+* `Future<[FutureSettledResult<A>, FutureSettledResult<B>]>`.
+* Mirrors `Promise.allSettled`.
+*/
+const allSettled = (futures) => currentOps().allSettled(futures);
+
+//#endregion
+//#region src/operation.ts
+const opTag = Symbol("restateOperation");
+function makePrimitive(node) {
+	const op = {
+		[opTag]: node,
+		*[Symbol.iterator]() {
+			return yield op;
+		}
+	};
+	return op;
+}
+function awaitRace(futures) {
+	const op = {
+		[opTag]: {
+			_tag: "AwaitRace",
+			futures
+		},
+		*[Symbol.iterator]() {
+			return yield op;
+		}
+	};
+	return op;
+}
+function gen(body) {
+	return { [Symbol.iterator]: body };
+}
+function spawn(op) {
+	return makePrimitive({
+		_tag: "Spawn",
+		child: op
+	});
+}
+function* select(branches) {
+	const tags = Object.keys(branches);
+	const tag = tags[(yield* awaitRace(tags.map((t) => branches[t]))).index];
+	return {
+		tag,
+		future: branches[tag]
+	};
+}
+
+//#endregion
+//#region src/state.ts
+/**
+* Build a `State<TState>` over the given context. The runtime delegates
+* straight to `ctx.get` / `ctx.set` / etc.; the TState generic is purely
+* a TS-level convenience and gets erased at runtime.
+*
+* For shared (read-only) contexts, the returned State has the same
+* runtime shape but the caller should use the `SharedState<TState>`
+* type to drop the write methods. The convenience method
+* `RestateOperations.sharedState()` does this cast.
+*/
+function makeState(ctx, sched, adapt$1) {
+	const writeCtx = ctx;
+	return {
+		get(name, serde) {
+			return sched.makeJournalFuture(adapt$1(ctx.get(name, serde)));
+		},
+		keys() {
+			return sched.makeJournalFuture(adapt$1(ctx.stateKeys()));
+		},
+		set(name, value, serde) {
+			writeCtx.set(name, value, serde);
+		},
+		clear(name) {
+			writeCtx.clear(name);
+		},
+		clearAll() {
+			writeCtx.clearAll();
+		}
+	};
+}
+
+//#endregion
+//#region src/clients.ts
+/**
+* Wrap an SDK `Client<M>` so each handler-invocation returns
+* `Future<T>` (via the supplied `toFuture` adapter) instead of
+* `InvocationPromise<T>`.
+*/
+function wrapClient(client, toFuture) {
+	return new Proxy(client, { get(target, prop, receiver) {
+		const orig = Reflect.get(target, prop, receiver);
+		if (typeof orig !== "function") return orig;
+		return (...args) => {
+			return toFuture(orig.apply(target, args));
+		};
+	} });
+}
+/**
+* Wrap an SDK `DurablePromise<T>` so each method returns `Future<...>`
+* instead of `Promise<...>`/`RestatePromise<...>`.
+*/
+function wrapDurablePromise(dp, toFuture) {
+	return {
+		peek: () => toFuture(dp.peek()),
+		resolve: (value) => toFuture(dp.resolve(value)),
+		reject: (errorMsg) => toFuture(dp.reject(errorMsg)),
+		get: () => toFuture(dp.get())
+	};
+}
+
+//#endregion
+//#region src/default-lib.ts
+const defaultLib = {
+	all(items) {
+		return restate.RestatePromise.all(items);
+	},
+	race(items) {
+		return restate.RestatePromise.race(items);
+	},
+	any(items) {
+		return restate.RestatePromise.any(items);
+	},
+	allSettled(items) {
+		return restate.RestatePromise.allSettled(items);
+	},
+	isCancellation(e) {
+		return e instanceof restate.CancelledError;
+	}
+};
+
+//#endregion
+//#region src/future.ts
+const futureBacking = Symbol("restateFutureBacking");
+/**
+* Internal accessor — read the backing off a Future. Only the scheduler
+* and fiber call this; user code never sees Backing.
+*/
+function getBacking(f) {
+	return f[futureBacking];
+}
+function makeFuture(backing) {
+	const future = {
+		[futureBacking]: backing,
+		*[Symbol.iterator]() {
+			return yield leafOp;
+		}
+	};
+	const leafOp = makePrimitive({
+		_tag: "Leaf",
+		future
+	});
+	return future;
+}
+function isJournalBacked(f) {
+	return getBacking(f).kind === "journal";
+}
+
+//#endregion
+//#region src/fiber.ts
+var Fiber = class {
+	it;
+	sched;
+	state = {
+		kind: "ready",
+		resume: null
+	};
+	waiters = [];
+	constructor(op, sched) {
+		this.it = op[Symbol.iterator]();
+		this.sched = sched;
+	}
+	isDone() {
+		return this.state.kind === "done";
+	}
+	/**
+	* For a fiber known to be done, return its settled outcome. Throws
+	* if called on a non-done fiber — callers must check `isDone()` first
+	* (or use `awaitCompletion` for the polymorphic version).
+	*/
+	settledValue() {
+		if (this.state.kind !== "done") throw new Error("Fiber.settledValue called on non-done fiber");
+		return this.state.settled;
+	}
+	/**
+	* Returns the parked sources this fiber is currently racing against.
+	* Empty if the fiber is parked only on routine waiters (e.g.,
+	* waiting on a sibling fiber to finish), or in any non-parked state.
+	* The scheduler reads these to assemble its main-loop race.
+	*/
+	parkedSources() {
+		return this.state.kind === "parked" ? this.state.promises : [];
+	}
+	/**
+	* "I want to be notified when this fiber is done." If the fiber is
+	* already done, returns its settled outcome immediately (caller
+	* should NOT also expect the waiter to be invoked). Otherwise
+	* returns null and queues the waiter for invocation when the fiber
+	* eventually finishes.
+	*/
+	awaitCompletion(waiter) {
+		if (this.state.kind === "done") return this.state.settled;
+		this.waiters.push(waiter);
+		return null;
+	}
+	/**
+	* Wake this fiber with a resume value. Transitions to ready and
+	* notifies the scheduler. May be called from any state except done
+	* (waking a done fiber is a programming error and is ignored
+	* defensively).
+	*/
+	wake(resume) {
+		if (this.state.kind === "done") return;
+		this.state = {
+			kind: "ready",
+			resume
+		};
+		this.sched.markReady(this);
+	}
+	/**
+	* Drive the fiber's iterator until it parks (yields a primitive
+	* whose dispatch ends with the fiber waiting on a source) or
+	* finishes (returns or throws).
+	*
+	* No-op if the fiber is not in the ready state — protects against
+	* stale entries in the scheduler's ready queue.
+	*/
+	advance() {
+		if (this.state.kind !== "ready") return;
+		const prevSlot = setCurrent(this.sched.contextSlot);
+		try {
+			let resume = this.state.resume;
+			while (true) {
+				let next;
+				try {
+					next = stepIterator(this.it, resume);
+				} catch (e) {
+					this.finish({
+						ok: false,
+						e
+					});
+					return;
+				}
+				if (next.done) {
+					this.finish({
+						ok: true,
+						v: next.value
+					});
+					return;
+				}
+				const node = next.value[opTag];
+				let outcome;
+				switch (node._tag) {
+					case "Leaf":
+						outcome = this.parkOnLeaf(node);
+						break;
+					case "Spawn":
+						outcome = {
+							ok: true,
+							v: this.sched.spawnFuture(node.child)
+						};
+						break;
+					case "AwaitRace":
+						outcome = this.parkOnAwaitRace(node.futures);
+						break;
+				}
+				if (outcome === null) return;
+				resume = outcome;
+			}
+		} finally {
+			clearCurrent(prevSlot);
+		}
+	}
+	/**
+	* Park on a single Future, or short-circuit if the Future is already
+	* settled. Returns the Settled value to feed back into the iterator
+	* if a short-circuit is possible (routine-backed future whose target
+	* already finished); returns null if the fiber is parked and the
+	* caller should suspend.
+	*/
+	parkOnLeaf(leaf) {
+		const backing = getBacking(leaf.future);
+		if (backing.kind === "journal") {
+			this.state = {
+				kind: "parked",
+				promises: [{
+					promise: backing.promise,
+					fire: (s) => this.wake(s)
+				}]
+			};
+			return null;
+		}
+		const settled = backing.target.awaitCompletion((s) => this.wake(s));
+		if (settled !== null) return settled;
+		this.state = {
+			kind: "parked",
+			promises: []
+		};
+		return null;
+	}
+	/**
+	* Park on the first-to-settle of a list of Futures, or short-circuit
+	* if any source is already settled. Returns `{index, settled}`
+	* (wrapped as Settled) on short-circuit, or null if parked.
+	*
+	* On the parked path, every source registers a one-shot fire
+	* callback that wakes the fiber with `{index, settled}`. The `won`
+	* flag guards against duplicate wakes when multiple sources settle
+	* in the same tick. Local sources (fibers, channels) park on the
+	* target's waiter list; journal sources race in the main loop's
+	* race promise.
+	*/
+	parkOnAwaitRace(futures) {
+		for (let i = 0; i < futures.length; i++) {
+			const b = getBacking(futures[i]);
+			if (b.kind === "local" && b.target.isDone()) return {
+				ok: true,
+				v: {
+					index: i,
+					settled: b.target.settledValue()
+				}
+			};
+		}
+		let won = false;
+		const promises = [];
+		for (let i = 0; i < futures.length; i++) {
+			const idx = i;
+			const b = getBacking(futures[i]);
+			const fireOnce = (settled) => {
+				if (won) return;
+				won = true;
+				this.wake({
+					ok: true,
+					v: {
+						index: idx,
+						settled
+					}
+				});
+			};
+			if (b.kind === "local") b.target.awaitCompletion(fireOnce);
+			else promises.push({
+				promise: b.promise,
+				fire: fireOnce
+			});
+		}
+		this.state = {
+			kind: "parked",
+			promises
+		};
+		return null;
+	}
+	/**
+	* Iterator finished or threw. Transition to done, fire all waiters
+	* with the settled outcome, notify scheduler.
+	*/
+	finish(settled) {
+		this.state = {
+			kind: "done",
+			settled
+		};
+		const waiters = this.waiters;
+		this.waiters = [];
+		for (const w of waiters) w(settled);
+		this.sched.markDone(this);
+	}
+};
+/**
+* Drive a generator iterator one step, feeding it whatever value or
+* exception the caller is resuming with. `resume === null` is the
+* very first step; `{ok: true, v}` resumes with a value; `{ok: false,
+* e}` throws into the iterator (or, if the iterator has no `throw`
+* method, rethrows so the fiber fails).
+*/
+function stepIterator(it, resume) {
+	if (resume === null) return it.next(void 0);
+	if (resume.ok) return it.next(resume.v);
+	if (it.throw) return it.throw(resume.e);
+	throw resume.e;
+}
+
+//#endregion
+//#region src/channel.ts
+var ChannelImpl = class {
+	state = { kind: "pending" };
+	waiters = [];
+	fire(value) {
+		if (this.state.kind === "settled") return;
+		this.state = {
+			kind: "settled",
+			value
+		};
+		const ws = this.waiters;
+		this.waiters = [];
+		const settled = {
+			ok: true,
+			v: value
+		};
+		for (const w of ws) w(settled);
+	}
+	isDone() {
+		return this.state.kind === "settled";
+	}
+	settledValue() {
+		if (this.state.kind !== "settled") throw new Error("ChannelImpl.settledValue called on a pending channel");
+		return {
+			ok: true,
+			v: this.state.value
+		};
+	}
+	awaitCompletion(waiter) {
+		if (this.state.kind === "settled") return {
+			ok: true,
+			v: this.state.value
+		};
+		this.waiters.push(waiter);
+		return null;
+	}
+};
+function makeChannel() {
+	const impl = new ChannelImpl();
+	return {
+		send: (v) => gen(function* () {
+			impl.fire(v);
+		}),
+		receive: makeFuture({
+			kind: "local",
+			target: impl
+		})
+	};
+}
+
+//#endregion
+//#region src/scheduler.ts
+var Scheduler = class {
+	fibers = /* @__PURE__ */ new Set();
+	ready = [];
+	lib;
+	abortController = new AbortController();
+	/**
+	* Slot for the RestateOperations bound to this scheduler. Set by
+	* `execute()` after construction (we can't pass it into the ctor
+	* because RestateOperations needs the scheduler to construct itself).
+	* `Fiber.advance` publishes this to the module-level current-fiber
+	* slot read by free-standing API functions. Typed `unknown` here to
+	* keep this module independent of `restate-operations.ts`.
+	*/
+	contextSlot = null;
+	constructor(lib) {
+		this.lib = lib;
+	}
+	/**
+	* The scheduler's current AbortSignal. Aborts when invocation
+	* cancellation is observed (the SDK rejects the main race promise
+	* with TerminalError). After cancellation has been delivered to
+	* fibers and the scheduler has resumed, this getter returns a
+	* *fresh* signal — one that is not aborted, even though the previous
+	* cancel was just delivered.
+	*
+	* Pass `signal` to AbortSignal-aware APIs in `ops.run` closures
+	* (e.g. `fetch(url, {signal})`) so they cancel promptly when the
+	* surrounding work is cancelled. Cleanup closures yielded after a
+	* caught CancelledError get a fresh, unaborted signal — so they can
+	* do real work and only abort if a *new* cancellation arrives.
+	*/
+	get abortSignal() {
+		return this.abortController.signal;
+	}
+	markReady(f) {
+		this.ready.push(f);
+	}
+	markDone(f) {
+		this.fibers.delete(f);
+	}
+	spawnFuture(op) {
+		return makeFuture({
+			kind: "local",
+			target: this.createFiber(op)
+		});
+	}
+	createFiber(op) {
+		const f = new Fiber(op, this);
+		this.fibers.add(f);
+		this.ready.push(f);
+		return f;
+	}
+	makeJournalFuture(promise) {
+		return makeFuture({
+			kind: "journal",
+			promise
+		});
+	}
+	/**
+	* Spawn an operation as a fresh fiber and return a Future that
+	* resolves with its eventual value. Same as the SchedulerOps method;
+	* exposed publicly for external callers (combinator helpers, the
+	* main run() entry point).
+	*/
+	spawnDetached(op) {
+		return this.spawnFuture(op);
+	}
+	/**
+	* Construct a single-shot in-memory channel. Send must be called from
+	* a fiber currently advancing under this scheduler. See `channel.ts`
+	* for full semantics.
+	*/
+	makeChannel() {
+		return makeChannel();
+	}
+	/**
+	* Combinator over Futures. Fast path when every input is journal-
+	* backed: use the lib's all/race for a single combinator entry.
+	* Otherwise, fall back to a synthesized fiber that yields each in
+	* turn.
+	*
+	* Tuple-aware typing (mirrors `Promise.all` in the standard lib):
+	* `all([fA, fB])` where `fA: Future<A>` and `fB: Future<B>`
+	* yields `Future<[A, B]>`, not `Future<(A | B)[]>`. The `const T`
+	* lets TS infer a tuple from a literal array.
+	*/
+	all(futures) {
+		const fs = futures;
+		if (fs.every(isJournalBacked)) {
+			const promises = fs.map((f) => f[futureBacking].promise);
+			return this.makeJournalFuture(this.lib.all(promises));
+		}
+		return this.spawnDetached(gen(function* () {
+			const out = new Array(fs.length);
+			for (let i = 0; i < fs.length; i++) out[i] = yield* fs[i];
+			return out;
+		}));
+	}
+	race(futures) {
+		const fs = futures;
+		return this.spawnDetached(gen(function* () {
+			const result = yield* awaitRace(fs);
+			if (result.settled.ok) return result.settled.v;
+			throw result.settled.e;
+		}));
+	}
+	/**
+	* First-success combinator. Mirrors `Promise.any` /
+	* `RestatePromise.any`: settles with the first input that succeeds
+	* (non-rejected); rejects with `AggregateError(errors)` when every
+	* input rejects (including the empty-array case).
+	*
+	* Fast path collapses to a single `lib.any` over journal awaitables.
+	* Fallback synthesizes a fiber that loops `awaitAnyOf` over the
+	* still-pending subset, accumulating rejections in input order until
+	* one input fulfills or all have rejected.
+	*
+	* Tuple-aware: `any([fA, fB])` where `fA: Future<A>` and `fB:
+	* Future<B>` yields `Future<A | B>` (the union of slot types), same
+	* shape as `Promise.any`.
+	*/
+	any(futures) {
+		const fs = futures;
+		if (fs.every(isJournalBacked)) {
+			const promises = fs.map((f) => f[futureBacking].promise);
+			return this.makeJournalFuture(this.lib.any(promises));
+		}
+		return this.spawnDetached(gen(function* () {
+			const errors = new Array(fs.length);
+			const remaining = /* @__PURE__ */ new Set();
+			for (let i = 0; i < fs.length; i++) remaining.add(i);
+			while (remaining.size > 0) {
+				const liveIdx = Array.from(remaining);
+				const result = yield* awaitRace(liveIdx.map((i) => fs[i]));
+				const original = liveIdx[result.index];
+				if (result.settled.ok) return result.settled.v;
+				errors[original] = result.settled.e;
+				remaining.delete(original);
+			}
+			throw new AggregateError(errors, "All promises were rejected");
+		}));
+	}
+	/**
+	* Settle-all combinator. Mirrors `Promise.allSettled` /
+	* `RestatePromise.allSettled`: resolves with an array of
+	* `FutureSettledResult` in input order, never rejects.
+	*
+	* Fast path collapses to a single `lib.allSettled`. Fallback yields
+	* each Future in turn — safe because Futures are eager (already in
+	* flight); sequential harvesting just reads them as they complete
+	* without blocking concurrency.
+	*
+	* Tuple-aware: `allSettled([fA, fB])` yields
+	* `Future<[FutureSettledResult<A>, FutureSettledResult<B>]>`.
+	*/
+	allSettled(futures) {
+		const fs = futures;
+		if (fs.every(isJournalBacked)) {
+			const promises = fs.map((f) => f[futureBacking].promise);
+			return this.makeJournalFuture(this.lib.allSettled(promises));
+		}
+		return this.spawnDetached(gen(function* () {
+			const out = new Array(fs.length);
+			for (let i = 0; i < fs.length; i++) try {
+				out[i] = {
+					status: "fulfilled",
+					value: yield* fs[i]
+				};
+			} catch (reason) {
+				out[i] = {
+					status: "rejected",
+					reason
+				};
+			}
+			return out;
+		}));
+	}
+	drainReady() {
+		while (this.ready.length > 0) this.ready.shift().advance();
+	}
+	/**
+	* Run an operation to completion. Drain the ready queue, then loop:
+	* collect every PromiseSource from every parked fiber, race them,
+	* dispatch the winner via its fire callback, drain. Stop when no
+	* fiber is alive.
+	*/
+	async run(op) {
+		const main = this.createFiber(op);
+		this.drainReady();
+		while (this.fibers.size > 0) {
+			const items = [];
+			for (const f of this.fibers) for (const src of f.parkedSources()) items.push(src);
+			if (items.length === 0) throw new Error("scheduler stuck: live fibers but nothing pending on a journal promise");
+			const tagged = items.map(({ promise }, i$1) => promise.map((v, e) => e !== void 0 ? {
+				i: i$1,
+				ok: false,
+				e
+			} : {
+				i: i$1,
+				ok: true,
+				v
+			}));
+			let raceWinner;
+			try {
+				raceWinner = await this.lib.race(tagged);
+			} catch (e) {
+				if (this.lib.isCancellation(e)) {
+					this.abortController.abort(e);
+					this.abortController = new AbortController();
+				}
+				const errSettled = {
+					ok: false,
+					e
+				};
+				for (const it of items) it.fire(errSettled);
+				this.drainReady();
+				continue;
+			}
+			const { i,...settledFields } = raceWinner;
+			const settled = settledFields.ok ? {
+				ok: true,
+				v: settledFields.v
+			} : {
+				ok: false,
+				e: settledFields.e
+			};
+			items[i].fire(settled);
+			this.drainReady();
+		}
+		if (!main.isDone()) throw new Error("scheduler exited but main fiber never completed");
+		const final = main.settledValue();
+		if (final.ok) return final.v;
+		throw final.e;
+	}
+};
+
+//#endregion
+//#region src/restate-operations.ts
+function adapt(p) {
+	return p;
+}
+/**
+* Wrap a user-supplied `run` closure to surface the abort reason
+* (typically a TerminalError(CANCELLED)) on throw paths if the signal
+* aborted during execution. This converts AbortError (and any other
+* abort-caused failure) into the canonical cancellation TerminalError
+* for journal recording.
+*
+* Defensive coercion: if `signal.reason` is itself not a TerminalError
+* (which shouldn't happen in production but might during testing or
+* with non-cancellation race rejections), we wrap it in one. The
+* journal must record a *terminal* outcome to avoid retries against
+* a cancelled invocation.
+*
+* Exposed for testing — the wrapper's behavior is the part that has
+* semantic bite, separate from the ctx.run plumbing.
+*/
+function wrapActionForCancellation(signal$1, action) {
+	return async () => {
+		try {
+			return await action({ signal: signal$1 });
+		} catch (e) {
+			if (signal$1.aborted) throw asTerminalError(signal$1.reason);
+			throw e;
+		}
+	};
+}
+/**
+* Resolve the journal-entry name; throw `TerminalError` if neither
+* source provides one.
+*
+* `TerminalError` (not a plain `Error`) because a missing name is a
+* programming bug — retrying the invocation will hit the same code
+* path and fail the same way. The SDK treats terminal errors as
+* non-retryable; the invocation fails fast instead of looping.
+*/
+function resolveRunName(action, opts) {
+	const fromOpts = opts?.name?.trim();
+	if (fromOpts) return fromOpts;
+	const fromFn = action.name;
+	if (fromFn) return fromFn;
+	throw new restate.TerminalError("@restatedev/restate-sdk-gen: run() requires a journal-entry name. Either pass a named function (`run(myFn)`) or supply `{ name: '...' }` in the second argument.");
+}
+/** Translate our `RetryOptions` into the SDK's flat `RunOptions` shape. */
+function toSdkRunOptions(opts) {
+	const out = {};
+	if (opts?.serde !== void 0) out.serde = opts.serde;
+	const r = opts?.retry;
+	if (r) {
+		if (r.maxAttempts !== void 0) out.maxRetryAttempts = r.maxAttempts;
+		if (r.maxDuration !== void 0) out.maxRetryDuration = r.maxDuration;
+		if (r.initialInterval !== void 0) out.initialRetryInterval = r.initialInterval;
+		if (r.maxInterval !== void 0) out.maxRetryInterval = r.maxInterval;
+		if (r.intervalFactor !== void 0) out.retryIntervalFactor = r.intervalFactor;
+	}
+	return out;
+}
+function asTerminalError(reason) {
+	if (reason instanceof restate.TerminalError) return reason;
+	return new restate.CancelledError();
+}
+var RestateOperations = class {
+	ctx;
+	sched;
+	constructor(context, sched) {
+		this.ctx = context;
+		this.sched = sched;
+	}
+	toFuture(p) {
+		return this.sched.makeJournalFuture(adapt(p));
+	}
+	/**
+	* Run a side-effecting closure as a journal entry.
+	*
+	* The closure receives `{ signal }` — an AbortSignal that fires when
+	* invocation cancellation arrives. Pass it into AbortSignal-aware
+	* APIs (e.g. `fetch(url, { signal })`) to abort in-flight syscalls.
+	*
+	* `name` is the journal entry's stable identifier (must be
+	* deterministic across replay). It can come from either:
+	*
+	*   - `opts.name` — explicit override
+	*   - `action.name` — the function's own name (works for `function`
+	*     declarations and arrow functions assigned to a `const`,
+	*     since JS infers names from the binding site)
+	*
+	* If neither resolves, `run` throws.
+	*
+	* @example Named function — name derived
+	*   async function fetchUser({ signal }: RunActionOpts): Promise<User> {
+	*     const r = await fetch(`/users/${id}`, { signal });
+	*     return r.json();
+	*   }
+	*   yield* run(fetchUser);
+	*
+	* @example Named arrow — name derived from binding
+	*   const fetchUser = async ({ signal }: RunActionOpts) => { ... };
+	*   yield* run(fetchUser);
+	*
+	* @example Inline arrow — name explicit
+	*   yield* run(async ({ signal }) => fetch(url, { signal }), { name: "fetch" });
+	*
+	* @example With retry policy
+	*   yield* run(fetchUser, { retry: { maxAttempts: 3 } });
+	*
+	* Cancellation hygiene: if the closure throws while the signal is
+	* aborted, we rethrow `signal.reason` (the original TerminalError)
+	* instead of whatever the closure threw. This ensures the journal
+	* entry records `TerminalError(CANCELLED)` rather than `AbortError`.
+	*/
+	run(action, opts) {
+		const name = resolveRunName(action, opts);
+		const wrapped = wrapActionForCancellation(this.sched.abortSignal, action);
+		return this.sched.makeJournalFuture(adapt(this.ctx.run(name, wrapped, toSdkRunOptions(opts))));
+	}
+	sleep(duration, name) {
+		return this.sched.makeJournalFuture(adapt(this.ctx.sleep(duration, name)));
+	}
+	awakeable(serde) {
+		const { id, promise } = this.ctx.awakeable(serde);
+		return {
+			id,
+			promise: this.sched.makeJournalFuture(adapt(promise))
+		};
+	}
+	resolveAwakeable(id, payload, serde) {
+		this.ctx.resolveAwakeable(id, payload, serde);
+	}
+	rejectAwakeable(id, reason) {
+		this.ctx.rejectAwakeable(id, reason);
+	}
+	signal(name, serde) {
+		return this.sched.makeJournalFuture(adapt(this.ctx.signal(name, serde)));
+	}
+	attach(invocationId, serde) {
+		return this.sched.makeJournalFuture(adapt(this.ctx.attach(invocationId, serde)));
+	}
+	/**
+	* Typed RPC client for a service: `ops.serviceClient(api).foo(arg)`
+	* yields a `Future<T>` whose value is the handler's return value.
+	*
+	* Same shape as `ctx.serviceClient(api)` from the SDK, but each
+	* handler-method returns `Future<T>` rather than `InvocationPromise<T>`.
+	*/
+	serviceClient(api) {
+		return wrapClient(this.ctx.serviceClient(api), (p) => this.toFuture(p));
+	}
+	/** Typed RPC client for a virtual object. See {@link serviceClient}. */
+	objectClient(api, key) {
+		return wrapClient(this.ctx.objectClient(api, key), (p) => this.toFuture(p));
+	}
+	/** Typed RPC client for a workflow. See {@link serviceClient}. */
+	workflowClient(api, key) {
+		return wrapClient(this.ctx.workflowClient(api, key), (p) => this.toFuture(p));
+	}
+	serviceSendClient(api) {
+		return this.ctx.serviceSendClient(api);
+	}
+	objectSendClient(api, key) {
+		return this.ctx.objectSendClient(api, key);
+	}
+	workflowSendClient(api, key) {
+		return this.ctx.workflowSendClient(api, key);
+	}
+	genericCall(call) {
+		return this.toFuture(this.ctx.genericCall(call));
+	}
+	genericSend(call) {
+		return this.ctx.genericSend(call);
+	}
+	/**
+	* Cancel another invocation by its id. To observe cancellation
+	* arriving at *this* invocation, catch the `TerminalError` thrown by
+	* the next `yield*` boundary or use the `signal` exposed inside
+	* `ops.run` closures.
+	*/
+	cancel(invocationId) {
+		this.ctx.cancel(invocationId);
+	}
+	/**
+	* Workflow-bound durable promise. Use only inside a workflow handler
+	* (the underlying context must be `WorkflowContext` or
+	* `WorkflowSharedContext`). Returns a wrapper whose `peek`/`get`/
+	* `resolve`/`reject` methods return Futures.
+	*/
+	workflowPromise(name, serde) {
+		const wfCtx = this.ctx;
+		return wrapDurablePromise(wfCtx.promise(name, serde), (p) => this.toFuture(p));
+	}
+	spawn(op) {
+		return spawn(op);
+	}
+	/**
+	* Create a single-shot in-memory channel. Returns a Channel<T> with
+	* `send(v)` (fire-and-forget, idempotent — first call settles, rest
+	* are dropped) and `receive: Future<T>` (a stable settle-once Future,
+	* the same handle on every access).
+	*
+	* Canonical use: cooperative cancellation. Spawn a routine that
+	* selects over its work and `stop.receive`; the canceller calls
+	* `stop.send()` to request termination. The receiver decides what
+	* to do — return a partial result, do cleanup yields, ignore.
+	*
+	* Because `receive` is a stable, settle-once Future, multiple readers
+	* all observe the same value (one-time broadcast) and the worker can
+	* use it in every iteration of a select-loop without leaking orphan
+	* receivers.
+	*
+	* Multi-event streams (producer-consumer, progress events) are NOT
+	* supported — Channel is intentionally single-shot. A separate
+	* primitive for that use case is yet to be designed.
+	*/
+	channel() {
+		return this.sched.makeChannel();
+	}
+	/**
+	* Per-invocation read-write key-value store. Use from a handler whose
+	* underlying context is ObjectContext or WorkflowContext.
+	*
+	* The optional `TState` generic gives keyof-checked names and per-key
+	* value types:
+	*
+	*   ops.state<{count: number; user: User}>()
+	*     // state.get("count") → Future<number | null>
+	*
+	* Without it, names are `string` and values are inferred per call:
+	*
+	*   ops.state()
+	*     // state.get<number>("count") → Future<number | null>
+	*
+	* Calling write methods from a shared (read-only) context throws at
+	* runtime — for shared handlers, use `sharedState()` below to get a
+	* narrower type that drops the write methods.
+	*/
+	state() {
+		return makeState(this.ctx, this.sched, adapt);
+	}
+	/**
+	* Per-invocation read-only key-value store. Use from a handler whose
+	* underlying context is ObjectSharedContext or WorkflowSharedContext.
+	*
+	* Same `TState` generic as `state()`. Returns the read-only subset
+	* (`get`, `keys`); attempting to call writes is a type error.
+	*/
+	sharedState() {
+		return makeState(this.ctx, this.sched, adapt);
+	}
+	/**
+	* Wait for every future to settle; return their values in input
+	* order. Heterogeneous-tuple typing — `all([fA, fB])` where
+	* `fA: Future<A>` and `fB: Future<B>` yields `Future<[A, B]>`.
+	* Mirrors `Promise.all` from the standard lib.
+	*/
+	all(futures) {
+		return this.sched.all(futures);
+	}
+	/**
+	* Return the first future to settle; losers continue running but
+	* their results are discarded. Heterogeneous-tuple typing —
+	* `race([fA, fB])` yields `Future<A | B>`. Mirrors `Promise.race`.
+	*/
+	race(futures) {
+		return this.sched.race(futures);
+	}
+	/**
+	* First-success combinator. Resolves with the first input that
+	* succeeds (non-rejected); rejects with `AggregateError(errors)` when
+	* every input rejects (including an empty input array). See `Promise.any`.
+	*
+	* Tuple-aware typing — `any([fA, fB])` where `fA: Future<A>` and
+	* `fB: Future<B>` yields `Future<A | B>`.
+	*/
+	any(futures) {
+		return this.sched.any(futures);
+	}
+	/**
+	* Settle-all combinator. Resolves with an array of
+	* `FutureSettledResult` in input order; never rejects. See
+	* `Promise.allSettled`.
+	*
+	* Tuple-aware typing — `allSettled([fA, fB])` yields
+	* `Future<[FutureSettledResult<A>, FutureSettledResult<B>]>`.
+	*/
+	allSettled(futures) {
+		return this.sched.allSettled(futures);
+	}
+	*select(branches) {
+		return yield* select(branches);
+	}
+};
+/**
+* Run a generator-based workflow against a Restate context.
+*
+* `op` is an `Operation<T>` — typically the result of
+* `gen(function*() { ... })`. Inside the generator body, reach for the
+* free-standing API (`run`, `sleep`, `all`, `state`, …) imported
+* from `@restatedev/restate-sdk-gen`. They read the active scheduler from a
+* synchronous current-fiber slot installed by `Fiber.advance`.
+*
+* `gen()` already takes a factory, so the same `Operation` is re-
+* iterable across multiple `execute()` calls — no need for a builder
+* lambda at this boundary.
+*
+* @example
+*   execute(ctx, gen(function* () {
+*     const greeting = yield* run(async () => "hi", { name: "compose" });
+*     return greeting;
+*   }));
+*/
+async function execute(context, op) {
+	const sched = new Scheduler(defaultLib);
+	sched.contextSlot = new RestateOperations(context, sched);
+	return sched.run(op);
+}
+
+//#endregion
+export { all, allSettled, any, attach, awakeable, cancel, channel, execute, gen, genericCall, genericSend, objectClient, objectSendClient, race, rejectAwakeable, resolveAwakeable, run, select, serviceClient, serviceSendClient, sharedState, signal, sleep, spawn, state, workflowClient, workflowPromise, workflowSendClient, wrapActionForCancellation };
+//# sourceMappingURL=index.js.map