@restatedev/restate-sdk-gen 0.0.0 → 1.14.3

package/dist/index.js

@@ -0,0 +1,1475 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import * as restate from "@restatedev/restate-sdk";
+import { Opts, SendOpts } from "@restatedev/restate-sdk";
+import { Opts as Opts$1, SendOpts as SendOpts$1, connect } from "@restatedev/restate-sdk-clients";
+import { serde } from "@restatedev/restate-sdk-core";
+
+//#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/invocation-reference.ts
+var InvocationReferenceImpl = class {
+	constructor(id, _outputSerde) {
+		this.id = id;
+		this._outputSerde = _outputSerde;
+	}
+	attach(serde$1) {
+		return getCurrent().attach(this.id, serde$1 ?? this._outputSerde);
+	}
+	signal(name, serde$1) {
+		return getCurrent().invocationSignal(this.id, name, serde$1);
+	}
+	cancel() {
+		getCurrent().cancel(this.id);
+	}
+};
+
+//#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();
+}
+const rand = () => currentOps().rand;
+const date = () => currentOps().date;
+const logger = () => currentOps().console;
+/**
+* Returns the current invocation's request metadata plus the optional
+* virtual-object / workflow key. The `key` field is only present when
+* the handler belongs to an object or workflow.
+*/
+const handlerRequest = () => currentOps().handlerRequest();
+/**
+* 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$1) => currentOps().awakeable(serde$1);
+const resolveAwakeable = (id, payload, serde$1) => currentOps().resolveAwakeable(id, payload, serde$1);
+const rejectAwakeable = (id, reason) => currentOps().rejectAwakeable(id, reason);
+const signal = (name, serde$1) => currentOps().signal(name, serde$1);
+const attach = (invocationId, serde$1) => currentOps().attach(invocationId, serde$1);
+function client(def, key) {
+	return currentOps().client(def, key);
+}
+function sendClient(def, key) {
+	return currentOps().sendClient(def, key);
+}
+const call = (c) => currentOps().call(c);
+const send = (c, outputSerde) => currentOps().send(c, outputSerde);
+/**
+* Create an InvocationReference from a known invocation ID (e.g. retrieved from state).
+* `attach()` and `cancel()` on the result use the current fiber slot like all free functions.
+*/
+function invocation(id, opts) {
+	return new InvocationReferenceImpl(id, opts?.outputSerde);
+}
+const cancel = (invocationId) => currentOps().cancel(invocationId);
+const channel = () => currentOps().channel();
+const state = () => currentOps().state();
+const sharedState = () => currentOps().sharedState();
+const workflowPromise = (name, serde$1) => currentOps().workflowPromise(name, serde$1);
+/**
+* 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);
+/**
+* Register `op` as a fresh routine and return a `Future<T>` for its
+* eventual outcome. Eager — the child is already in flight by the time
+* `spawn` returns. See `RestateOperations.spawn` for full semantics.
+*/
+const spawn = (op) => currentOps().spawn(op);
+
+//#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* 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/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 "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 operations object bound to this scheduler. Defaults
+	* to the scheduler itself so tests (which don't construct a
+	* `RestateOperations`) still get a slot exposing `.spawn`. Production
+	* `execute()` overrides this with a `RestateOperations` instance
+	* 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;
+	constructor(lib) {
+		this.lib = lib;
+		this.contextSlot = this;
+	}
+	/**
+	* 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);
+	}
+	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
+		});
+	}
+	/**
+	* Register an Operation as a fresh fiber and return a Future that
+	* resolves with its eventual value. Eager: by the time this returns,
+	* the fiber is queued ready and will be advanced on the next drain.
+	*
+	* Used by combinator fallbacks (race, allSettled, …), by
+	* `RestateOperations.spawn`, and via the slot interface by the free
+	* `spawn` function.
+	*/
+	spawn(op) {
+		return makeFuture({
+			kind: "local",
+			target: this.createFiber(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.spawn(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.spawn(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.spawn(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.spawn(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/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$1) {
+			return sched.makeJournalFuture(adapt$1(ctx.get(name, serde$1)));
+		},
+		keys() {
+			return sched.makeJournalFuture(adapt$1(ctx.stateKeys()));
+		},
+		set(name, value, serde$1) {
+			writeCtx.set(name, value, serde$1);
+		},
+		clear(name) {
+			writeCtx.clear(name);
+		},
+		clearAll() {
+			writeCtx.clearAll();
+		}
+	};
+}
+
+//#endregion
+//#region src/clients.ts
+function makeClient(def, key, call$1) {
+	return new Proxy({}, { get(_target, methodName) {
+		return (...args) => {
+			const { parameter, opts } = optsFromArgs$1(args);
+			const callOpts = opts;
+			const desc = def._handlers[methodName];
+			const outputSerde = callOpts?.output ?? desc?._outputSerde;
+			return call$1({
+				service: def.name,
+				key,
+				method: String(methodName),
+				parameter,
+				inputSerde: callOpts?.input ?? desc?._inputSerde ?? restate.serde.json,
+				outputSerde: outputSerde ?? restate.serde.json,
+				idempotencyKey: callOpts?.idempotencyKey,
+				headers: callOpts?.headers,
+				name: callOpts?.name
+			});
+		};
+	} });
+}
+function makeSendClient(def, key, send$1) {
+	return new Proxy({}, { get(_target, methodName) {
+		return (...args) => {
+			const { parameter, opts } = optsFromArgs$1(args);
+			const sendOpts = opts;
+			const desc = def._handlers[methodName];
+			return send$1({
+				service: def.name,
+				key,
+				method: String(methodName),
+				parameter,
+				inputSerde: sendOpts?.input ?? desc?._inputSerde ?? restate.serde.json,
+				delay: sendOpts?.delay,
+				idempotencyKey: sendOpts?.idempotencyKey,
+				headers: sendOpts?.headers,
+				name: sendOpts?.name
+			}, desc?._outputSerde);
+		};
+	} });
+}
+function optsFromArgs$1(args) {
+	let parameter;
+	let opts;
+	switch (args.length) {
+		case 0: break;
+		case 1:
+			if (args[0] instanceof Opts) opts = args[0].getOpts();
+			else if (args[0] instanceof SendOpts) opts = args[0].getOpts();
+			else parameter = args[0];
+			break;
+		case 2:
+			parameter = args[0];
+			if (args[1] instanceof Opts) opts = args[1].getOpts();
+			else if (args[1] instanceof SendOpts) opts = args[1].getOpts();
+			else throw new TypeError("The second argument must be either Opts or SendOpts");
+			break;
+		default: throw new TypeError("unexpected number of arguments");
+	}
+	return {
+		parameter,
+		opts
+	};
+}
+
+//#endregion
+//#region src/durable-promise.ts
+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/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));
+	}
+	get rand() {
+		return this.ctx.rand;
+	}
+	get date() {
+		return {
+			now: () => this.toFuture(this.ctx.date.now()),
+			toJSON: () => this.toFuture(this.ctx.date.toJSON())
+		};
+	}
+	get console() {
+		return this.ctx.console;
+	}
+	/**
+	* 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$1) {
+		const { id, promise } = this.ctx.awakeable(serde$1);
+		return {
+			id,
+			promise: this.sched.makeJournalFuture(adapt(promise))
+		};
+	}
+	resolveAwakeable(id, payload, serde$1) {
+		this.ctx.resolveAwakeable(id, payload, serde$1);
+	}
+	rejectAwakeable(id, reason) {
+		this.ctx.rejectAwakeable(id, reason);
+	}
+	signal(name, serde$1) {
+		return this.sched.makeJournalFuture(adapt(this.ctx.signal(name, serde$1)));
+	}
+	attach(invocationId, serde$1) {
+		return this.sched.makeJournalFuture(adapt(this.ctx.attach(invocationId, serde$1)));
+	}
+	/**
+	* Returns the current invocation's request metadata plus the optional
+	* virtual-object / workflow key. The `key` field is only present when
+	* the handler belongs to an object or workflow.
+	*/
+	handlerRequest() {
+		const req = this.ctx.request();
+		const ctx = this.ctx;
+		return {
+			attemptHeaders: req.attemptHeaders,
+			body: req.body,
+			extraArgs: req.extraArgs,
+			headers: req.headers,
+			id: req.id,
+			target: req.target,
+			get key() {
+				return ctx.key;
+			}
+		};
+	}
+	client(def, key) {
+		return makeClient(def, key, (o) => this.call(o));
+	}
+	sendClient(def, key) {
+		return makeSendClient(def, key, (o, serde$1) => this.send(o, serde$1));
+	}
+	call(opts) {
+		const restatePromise = this.ctx.genericCall(opts);
+		const resultFuture = this.toFuture(restatePromise);
+		const invocation$1 = this.invocationReferenceFromHandle(restatePromise, opts.outputSerde);
+		return Object.assign(resultFuture, { invocation: invocation$1 });
+	}
+	send(opts, outputSerde) {
+		const handle = this.ctx.genericSend(opts);
+		return this.invocationReferenceFromHandle(handle, outputSerde);
+	}
+	invocationReferenceFromHandle(handle, outputSerde) {
+		const idFuture = this.toFuture(handle.invocationId);
+		return this.sched.spawn(gen(function* () {
+			return new InvocationReferenceImpl(yield* idFuture, outputSerde);
+		}));
+	}
+	invocationSignal(invocationId, name, serde$1) {
+		return this.ctx.invocation(invocationId).signal(name, serde$1);
+	}
+	/**
+	* 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$1) {
+		const wfCtx = this.ctx;
+		return wrapDurablePromise(wfCtx.promise(name, serde$1), (p) => this.toFuture(p));
+	}
+	/**
+	* Register `op` as a fresh routine and return a `Future<T>` for its
+	* eventual outcome. Eager: by the time `spawn` returns, the child is
+	* already queued and will advance on the next scheduler tick — same
+	* model as `run`/`sleep`/`awakeable`. The returned Future can be
+	* yielded on, handed to combinators, or stored.
+	*/
+	spawn(op) {
+		return this.sched.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
+//#region src/define.ts
+function makeDescriptor(inputSerde, outputSerde) {
+	return {
+		_inputSerde: inputSerde,
+		_outputSerde: outputSerde
+	};
+}
+/** HandlerDef has _genFn as an object property; bare gen fns are plain functions */
+function isHandlerDef(entry) {
+	return typeof entry === "object" && entry !== null && typeof entry._genFn === "function";
+}
+/** Convert a Standard Schema to a Serde via restate.serde.schema() */
+function toSerde(schema) {
+	return restate.serde.schema(schema);
+}
+function extractEntry(entry) {
+	if (isHandlerDef(entry)) return {
+		genFn: entry._genFn,
+		inputSerde: entry._inputSerde,
+		outputSerde: entry._outputSerde
+	};
+	return {
+		genFn: entry,
+		inputSerde: void 0,
+		outputSerde: void 0
+	};
+}
+/** serdes(opts, fn) — explicit Serde per field */
+function serdes(opts, fn) {
+	return {
+		_genFn: fn,
+		_inputSerde: opts.input,
+		_outputSerde: opts.output
+	};
+}
+/** schemas(opts, fn) — Standard Schema (Zod, TypeBox, Valibot, …) per field */
+function schemas(opts, fn) {
+	return {
+		_genFn: fn,
+		_inputSerde: toSerde(opts.input),
+		_outputSerde: toSerde(opts.output)
+	};
+}
+function service(config) {
+	const { name, description, metadata, handlers, options } = config;
+	const { handlers: perHandlerOpts,...serviceOpts } = options ?? {};
+	const coreHandlers = {};
+	const descriptors = {};
+	for (const [handlerName, entry] of Object.entries(handlers)) {
+		const { genFn, inputSerde, outputSerde } = extractEntry(entry);
+		const handlerOpts = perHandlerOpts?.[handlerName] ?? {};
+		coreHandlers[handlerName] = restate.handlers.handler({
+			input: inputSerde,
+			output: outputSerde,
+			...handlerOpts
+		}, async (ctx, input) => execute(ctx, genFn(input)));
+		descriptors[handlerName] = makeDescriptor(inputSerde, outputSerde);
+	}
+	const coreDef = restate.service({
+		name,
+		handlers: coreHandlers,
+		description,
+		metadata,
+		options: serviceOpts
+	});
+	return Object.assign(coreDef, {
+		_kind: "service",
+		_handlers: descriptors
+	});
+}
+function object(config) {
+	const { name, description, metadata, handlers, options } = config;
+	const { handlers: perHandlerOpts,...objectOpts } = options ?? {};
+	const coreHandlers = {};
+	const descriptors = {};
+	for (const [handlerName, entry] of Object.entries(handlers)) {
+		const { genFn, inputSerde, outputSerde } = extractEntry(entry);
+		const { shared,...restOpts } = perHandlerOpts?.[handlerName] ?? {};
+		const sdkOpts = {
+			input: inputSerde,
+			output: outputSerde,
+			...restOpts
+		};
+		const fn = async (ctx, input) => execute(ctx, genFn(input));
+		coreHandlers[handlerName] = shared ? restate.handlers.object.shared(sdkOpts, fn) : restate.handlers.object.exclusive(sdkOpts, fn);
+		descriptors[handlerName] = makeDescriptor(inputSerde, outputSerde);
+	}
+	const coreDef = restate.object({
+		name,
+		handlers: coreHandlers,
+		description,
+		metadata,
+		options: objectOpts
+	});
+	return Object.assign(coreDef, {
+		_kind: "object",
+		_handlers: descriptors
+	});
+}
+function workflow(config) {
+	const { name, description, metadata, handlers, options } = config;
+	const { handlers: perHandlerOpts,...workflowOpts } = options ?? {};
+	const coreHandlers = {};
+	const descriptors = {};
+	for (const [handlerName, entry] of Object.entries(handlers)) {
+		const { genFn, inputSerde, outputSerde } = extractEntry(entry);
+		const sdkOpts = {
+			input: inputSerde,
+			output: outputSerde,
+			...perHandlerOpts?.[handlerName] ?? {}
+		};
+		const fn = async (ctx, input) => execute(ctx, genFn(input));
+		coreHandlers[handlerName] = handlerName === "run" ? restate.handlers.workflow.workflow(sdkOpts, fn) : restate.handlers.workflow.shared(sdkOpts, fn);
+		descriptors[handlerName] = makeDescriptor(inputSerde, outputSerde);
+	}
+	const coreDef = restate.workflow({
+		name,
+		handlers: coreHandlers,
+		description,
+		metadata,
+		options: workflowOpts
+	});
+	return Object.assign(coreDef, {
+		_kind: "workflow",
+		_handlers: descriptors
+	});
+}
+
+//#endregion
+//#region src/interface.ts
+var interface_exports = /* @__PURE__ */ __export({
+	implement: () => implement,
+	json: () => json,
+	object: () => object$1,
+	schemas: () => schemas$1,
+	serdes: () => serdes$1,
+	service: () => service$1,
+	workflow: () => workflow$1
+});
+/** json<I, O>() — type params, default JSON serde */
+function json() {
+	return makeDescriptor(void 0, void 0);
+}
+/** serdes(opts) — explicit Serde per field */
+function serdes$1(opts) {
+	return makeDescriptor(opts.input, opts.output);
+}
+/** schemas(opts) — Standard Schema (Zod, TypeBox, Valibot, …) per field */
+function schemas$1(opts) {
+	return makeDescriptor(opts.input ? toSerde(opts.input) : void 0, opts.output ? toSerde(opts.output) : void 0);
+}
+function service$1(name, handlers) {
+	return {
+		name,
+		_kind: "service",
+		_handlers: handlers
+	};
+}
+function object$1(name, handlers) {
+	return {
+		name,
+		_kind: "object",
+		_handlers: handlers
+	};
+}
+function workflow$1(name, handlers) {
+	return {
+		name,
+		_kind: "workflow",
+		_handlers: handlers
+	};
+}
+function implement(iface, config) {
+	const handlerEntries = {};
+	for (const [name, desc] of Object.entries(iface._handlers)) {
+		const genFn = config.handlers[name];
+		if (!genFn) throw new Error(`implement(): missing handler "${name}"`);
+		handlerEntries[name] = {
+			_genFn: genFn,
+			_inputSerde: desc._inputSerde,
+			_outputSerde: desc._outputSerde
+		};
+	}
+	if (iface._kind === "service") return service({
+		name: iface.name,
+		handlers: handlerEntries,
+		options: config.options
+	});
+	else if (iface._kind === "object") return object({
+		name: iface.name,
+		handlers: handlerEntries,
+		options: config.options
+	});
+	else return workflow({
+		name: iface.name,
+		handlers: handlerEntries,
+		options: config.options
+	});
+}
+
+//#endregion
+//#region src/ingress.ts
+var ingress_exports = /* @__PURE__ */ __export({
+	SendOpts: () => SendOpts$1,
+	client: () => client$1,
+	connect: () => connect$1,
+	sendClient: () => sendClient$1
+});
+/**
+* Connect to the Restate Ingress.
+*
+* @param opts connection options
+* @returns a connection the the restate ingress
+*/
+function connect$1(opts) {
+	return connect(opts);
+}
+function client$1(ingress, def, key) {
+	return new Proxy({}, { get(_target, methodName) {
+		return (...args) => {
+			const { parameter, opts } = optsFromArgs(args);
+			const desc = def._handlers[methodName];
+			const mergedOpts = Opts$1.from({
+				...opts?.opts,
+				input: opts?.opts?.input ?? desc?._inputSerde,
+				output: opts?.opts?.output ?? desc?._outputSerde
+			});
+			return ingress.call({
+				service: def.name,
+				handler: methodName,
+				parameter,
+				key,
+				opts: mergedOpts
+			});
+		};
+	} });
+}
+function sendClient$1(ingress, def, key) {
+	return new Proxy({}, { get(_target, methodName) {
+		return (...args) => {
+			const { parameter, opts } = optsFromArgs(args);
+			const desc = def._handlers[methodName];
+			const mergedOpts = SendOpts$1.from({
+				...opts?.opts,
+				input: opts?.opts?.input ?? desc?._inputSerde
+			});
+			return ingress.send({
+				service: def.name,
+				handler: methodName,
+				parameter,
+				key,
+				opts: mergedOpts
+			});
+		};
+	} });
+}
+function optsFromArgs(args) {
+	let parameter;
+	let opts;
+	switch (args.length) {
+		case 0: break;
+		case 1:
+			if (args[0] instanceof Opts$1) opts = args[0];
+			else if (args[0] instanceof SendOpts$1) opts = args[0];
+			else parameter = args[0];
+			break;
+		case 2:
+			parameter = args[0];
+			if (args[1] instanceof Opts$1) opts = args[1];
+			else if (args[1] instanceof SendOpts$1) opts = args[1];
+			else throw new TypeError("The second argument must be either Opts or SendOpts");
+			break;
+		default: throw new TypeError("unexpected number of arguments");
+	}
+	return {
+		parameter,
+		opts
+	};
+}
+
+//#endregion
+export { all, allSettled, any, attach, awakeable, call, cancel, channel, client, ingress_exports as clients, date, gen, handlerRequest, interface_exports as iface, implement, invocation, logger, object, race, rand, rejectAwakeable, resolveAwakeable, run, schemas, select, send, sendClient, serde, serdes, service, sharedState, signal, sleep, spawn, state, workflow, workflowPromise, wrapActionForCancellation };
+//# sourceMappingURL=index.js.map