@restatedev/restate-sdk-gen 1.14.2 → 1.14.3

package/dist/index.js

@@ -1,4 +1,8 @@
+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;
@@ -27,6 +31,24 @@ function getCurrent() {
 	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
 /**
@@ -38,6 +60,15 @@ function getCurrent() {
 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.
@@ -48,24 +79,31 @@ function currentOps() {
 */
 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 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) => 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 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) => currentOps().workflowPromise(name, serde);
+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>`
@@ -91,6 +129,12 @@ const any = (futures) => currentOps().any(futures);
 * 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
@@ -119,12 +163,6 @@ function awaitRace(futures) {
 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];
@@ -134,88 +172,6 @@ function* select(branches) {
 	};
 }
 
-//#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");
@@ -341,12 +297,6 @@ var Fiber = class {
 					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;
@@ -524,16 +474,20 @@ var Scheduler = class {
 	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).
+	* 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 = null;
+	contextSlot;
 	constructor(lib) {
 		this.lib = lib;
+		this.contextSlot = this;
 	}
 	/**
 	* The scheduler's current AbortSignal. Aborts when invocation
@@ -558,12 +512,6 @@ var Scheduler = class {
 	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);
@@ -577,13 +525,19 @@ var Scheduler = class {
 		});
 	}
 	/**
-	* 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).
+	* 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.
 	*/
-	spawnDetached(op) {
-		return this.spawnFuture(op);
+	spawn(op) {
+		return makeFuture({
+			kind: "local",
+			target: this.createFiber(op)
+		});
 	}
 	/**
 	* Construct a single-shot in-memory channel. Send must be called from
@@ -610,7 +564,7 @@ var Scheduler = class {
 			const promises = fs.map((f) => f[futureBacking].promise);
 			return this.makeJournalFuture(this.lib.all(promises));
 		}
-		return this.spawnDetached(gen(function* () {
+		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;
@@ -618,7 +572,7 @@ var Scheduler = class {
 	}
 	race(futures) {
 		const fs = futures;
-		return this.spawnDetached(gen(function* () {
+		return this.spawn(gen(function* () {
 			const result = yield* awaitRace(fs);
 			if (result.settled.ok) return result.settled.v;
 			throw result.settled.e;
@@ -645,7 +599,7 @@ var Scheduler = class {
 			const promises = fs.map((f) => f[futureBacking].promise);
 			return this.makeJournalFuture(this.lib.any(promises));
 		}
-		return this.spawnDetached(gen(function* () {
+		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);
@@ -679,7 +633,7 @@ var Scheduler = class {
 			const promises = fs.map((f) => f[futureBacking].promise);
 			return this.makeJournalFuture(this.lib.allSettled(promises));
 		}
-		return this.spawnDetached(gen(function* () {
+		return this.spawn(gen(function* () {
 			const out = new Array(fs.length);
 			for (let i = 0; i < fs.length; i++) try {
 				out[i] = {
@@ -754,6 +708,137 @@ var Scheduler = class {
 	}
 };
 
+//#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) {
@@ -829,6 +914,18 @@ var RestateOperations = class {
 	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.
 	*
@@ -876,57 +973,69 @@ var RestateOperations = class {
 	sleep(duration, name) {
 		return this.sched.makeJournalFuture(adapt(this.ctx.sleep(duration, name)));
 	}
-	awakeable(serde) {
-		const { id, promise } = this.ctx.awakeable(serde);
+	awakeable(serde$1) {
+		const { id, promise } = this.ctx.awakeable(serde$1);
 		return {
 			id,
 			promise: this.sched.makeJournalFuture(adapt(promise))
 		};
 	}
-	resolveAwakeable(id, payload, serde) {
-		this.ctx.resolveAwakeable(id, payload, serde);
+	resolveAwakeable(id, payload, serde$1) {
+		this.ctx.resolveAwakeable(id, payload, serde$1);
 	}
 	rejectAwakeable(id, reason) {
 		this.ctx.rejectAwakeable(id, reason);
 	}
-	signal(name, serde) {
-		return this.sched.makeJournalFuture(adapt(this.ctx.signal(name, serde)));
+	signal(name, serde$1) {
+		return this.sched.makeJournalFuture(adapt(this.ctx.signal(name, serde$1)));
 	}
-	attach(invocationId, serde) {
-		return this.sched.makeJournalFuture(adapt(this.ctx.attach(invocationId, serde)));
+	attach(invocationId, serde$1) {
+		return this.sched.makeJournalFuture(adapt(this.ctx.attach(invocationId, serde$1)));
 	}
 	/**
-	* 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>`.
+	* 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.
 	*/
-	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));
+	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;
+			}
+		};
 	}
-	/** Typed RPC client for a workflow. See {@link serviceClient}. */
-	workflowClient(api, key) {
-		return wrapClient(this.ctx.workflowClient(api, key), (p) => this.toFuture(p));
+	client(def, key) {
+		return makeClient(def, key, (o) => this.call(o));
 	}
-	serviceSendClient(api) {
-		return this.ctx.serviceSendClient(api);
+	sendClient(def, key) {
+		return makeSendClient(def, key, (o, serde$1) => this.send(o, serde$1));
 	}
-	objectSendClient(api, key) {
-		return this.ctx.objectSendClient(api, key);
+	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 });
 	}
-	workflowSendClient(api, key) {
-		return this.ctx.workflowSendClient(api, key);
+	send(opts, outputSerde) {
+		const handle = this.ctx.genericSend(opts);
+		return this.invocationReferenceFromHandle(handle, outputSerde);
 	}
-	genericCall(call) {
-		return this.toFuture(this.ctx.genericCall(call));
+	invocationReferenceFromHandle(handle, outputSerde) {
+		const idFuture = this.toFuture(handle.invocationId);
+		return this.sched.spawn(gen(function* () {
+			return new InvocationReferenceImpl(yield* idFuture, outputSerde);
+		}));
 	}
-	genericSend(call) {
-		return this.ctx.genericSend(call);
+	invocationSignal(invocationId, name, serde$1) {
+		return this.ctx.invocation(invocationId).signal(name, serde$1);
 	}
 	/**
 	* Cancel another invocation by its id. To observe cancellation
@@ -943,12 +1052,19 @@ var RestateOperations = class {
 	* `WorkflowSharedContext`). Returns a wrapper whose `peek`/`get`/
 	* `resolve`/`reject` methods return Futures.
 	*/
-	workflowPromise(name, serde) {
+	workflowPromise(name, serde$1) {
 		const wfCtx = this.ctx;
-		return wrapDurablePromise(wfCtx.promise(name, serde), (p) => this.toFuture(p));
+		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 spawn(op);
+		return this.sched.spawn(op);
 	}
 	/**
 	* Create a single-shot in-memory channel. Returns a Channel<T> with
@@ -1074,5 +1190,286 @@ async function execute(context, 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 };
+//#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