@restatedev/restate-sdk-cloudflare-workers 1.9.1 → 1.10.1

package/dist/types/errors.d.ts

@@ -0,0 +1,71 @@
+import { Duration } from "@restatedev/restate-sdk-core";
+
+//#region src/types/errors.d.ts
+
+declare class RestateError extends Error {
+  readonly code: number;
+  name: string;
+  constructor(message: string, options?: {
+    errorCode?: number;
+    cause?: any;
+  });
+}
+/**
+ * Does not lead to Restate retries.
+ *
+ * Leads to an output message with a failure defined.
+ */
+declare class TerminalError extends RestateError {
+  name: string;
+  constructor(message: string, options?: {
+    /**
+     * Error code. This should be an HTTP status code, and in case the service was invoked from the ingress, this will be propagated back to the caller.
+     */
+    errorCode?: number;
+    /**
+     * @deprecated YOU MUST NOT USE THIS FIELD, AS IT WON'T BE RECORDED AND CAN LEAD TO NON-DETERMINISM! From the next SDK version, the constructor won't accept this field anymore.
+     */
+    cause?: any;
+  });
+}
+/**
+ * Returned by `RestatePromise.withTimeout` when the timeout is reached.
+ */
+declare class TimeoutError extends TerminalError {
+  name: string;
+  constructor();
+}
+/**
+ * Returned when the invocation was cancelled.
+ */
+declare class CancelledError extends TerminalError {
+  name: string;
+  constructor();
+}
+interface RetryableErrorOptions {
+  /**
+   * In how long it should retry.
+   */
+  retryAfter?: Duration | number;
+}
+/**
+ * Error that Restate will retry. By using this error type within a `ctx.run` closure,
+ * you can dynamically provide the retry delay specified in {@link RetryableErrorOptions}.
+ *
+ * You can wrap another error using {@link from}.
+ */
+declare class RetryableError extends RestateError {
+  name: string;
+  readonly retryAfter?: Duration | number;
+  constructor(message: string, options?: RetryableErrorOptions & {
+    errorCode?: number;
+    cause?: any;
+  });
+  /**
+   * Create a `RetryableError` from the given cause.
+   */
+  static from(cause: any, options?: RetryableErrorOptions): RetryableError;
+}
+//#endregion
+export { CancelledError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/types/errors.ts"],"sourcesContent":[],"mappings":";;;;AAsJwB,cAzEX,YAAA,SAAqB,KAAA,CAyEV;EAIV,SAAA,IAAA,EAAA,MAAA;EAgBsB,IAAA,EAAA,MAAA;EAAwB,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,QAAA,EAAA;IAvBxB,SAAA,CAAA,EAAA,MAAA;IAAY,KAAA,CAAA,EAAA,GAAA;;;;;;;;cAvDnC,aAAA,SAAsB,YAAA;;;;;;;;;;;;;;;;cAuBtB,YAAA,SAAqB,aAAA;;;;;;;cAWrB,cAAA,SAAuB,aAAA;;;;UAQnB,qBAAA;;;;eAIF;;;;;;;;cASF,cAAA,SAAuB,YAAA;;wBAGZ;yCAIV;;;;;;;oCAgBsB,wBAAwB"}

package/dist/types/errors.js

@@ -0,0 +1,102 @@
+//#region src/types/errors.ts
+const INTERNAL_ERROR_CODE = 500;
+const TIMEOUT_ERROR_CODE = 408;
+const CANCEL_ERROR_CODE = 409;
+const UNKNOWN_ERROR_CODE = 500;
+const CLOSED_ERROR_CODE = 598;
+const SUSPENDED_ERROR_CODE = 599;
+function ensureError(e, asTerminalError) {
+	if (e instanceof TerminalError) return e;
+	const maybeTerminalError = asTerminalError ? asTerminalError(e) : void 0;
+	if (maybeTerminalError) return maybeTerminalError;
+	if (e instanceof Error) return e;
+	if (typeof e === "object" && e !== null && "code" in e && "message" in e) return new RestateError(e.message, { errorCode: e.code });
+	let msg;
+	try {
+		msg = JSON.stringify(e);
+	} catch {
+		msg = "(no JSON representation)";
+	}
+	return /* @__PURE__ */ new Error("Non-Error value: " + msg);
+}
+function logError(log, e) {
+	if (e instanceof RestateError) {
+		if (e.code === SUSPENDED_ERROR_CODE) {
+			log.info("Invocation suspended");
+			return;
+		} else if (e.code === CLOSED_ERROR_CODE) {
+			log.error("DANGER! The invocation is closed, but some related operation is still running. \nThis might indicate that a RestatePromise is being awaited on an asynchronous task, outside the handler, or you're awaiting a RestatePromise inside a ctx.run.\nThis is dangerous, and can lead the service to deadlock. Please fix the issue.\nDiagnostic: ", e);
+			return;
+		}
+	}
+	log.warn("Error when processing a Restate context operation.\n", e);
+}
+var RestateError = class extends Error {
+	code;
+	name = "RestateError";
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.code = options?.errorCode ?? INTERNAL_ERROR_CODE;
+	}
+};
+/**
+* Does not lead to Restate retries.
+*
+* Leads to an output message with a failure defined.
+*/
+var TerminalError = class extends RestateError {
+	name = "TerminalError";
+	constructor(message, options) {
+		super(message, options);
+	}
+};
+/**
+* Returned by `RestatePromise.withTimeout` when the timeout is reached.
+*/
+var TimeoutError = class extends TerminalError {
+	name = "TimeoutError";
+	constructor() {
+		super("Timeout occurred", { errorCode: TIMEOUT_ERROR_CODE });
+	}
+};
+/**
+* Returned when the invocation was cancelled.
+*/
+var CancelledError = class extends TerminalError {
+	name = "CancelledError";
+	constructor() {
+		super("Cancelled", { errorCode: CANCEL_ERROR_CODE });
+	}
+};
+/**
+* Error that Restate will retry. By using this error type within a `ctx.run` closure,
+* you can dynamically provide the retry delay specified in {@link RetryableErrorOptions}.
+*
+* You can wrap another error using {@link from}.
+*/
+var RetryableError = class RetryableError extends RestateError {
+	name = "RetryableError";
+	retryAfter;
+	constructor(message, options) {
+		super(message, {
+			errorCode: options?.errorCode,
+			cause: options?.cause
+		});
+		this.retryAfter = options?.retryAfter;
+	}
+	/**
+	* Create a `RetryableError` from the given cause.
+	*/
+	static from(cause, options) {
+		const error = ensureError(cause);
+		return new RetryableError(error.message, {
+			errorCode: error["errorCode"],
+			cause,
+			...options
+		});
+	}
+};
+
+//#endregion
+export { CancelledError, INTERNAL_ERROR_CODE, RestateError, RetryableError, TerminalError, TimeoutError, UNKNOWN_ERROR_CODE, ensureError, logError };
+//# sourceMappingURL=errors.js.map

package/dist/types/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/types/errors.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { Duration } from \"@restatedev/restate-sdk-core\";\n\nexport const INTERNAL_ERROR_CODE = 500;\nexport const TIMEOUT_ERROR_CODE = 408;\nexport const CANCEL_ERROR_CODE = 409;\nexport const UNKNOWN_ERROR_CODE = 500;\n\n// From shared core!\nexport const CLOSED_ERROR_CODE = 598;\nexport const SUSPENDED_ERROR_CODE = 599;\n\nexport function ensureError(\n  e: unknown,\n  asTerminalError?: (error: any) => TerminalError | undefined\n): Error {\n  if (e instanceof TerminalError) {\n    return e;\n  }\n  // Try convert to terminal error\n  const maybeTerminalError = asTerminalError ? asTerminalError(e) : undefined;\n  if (maybeTerminalError) {\n    return maybeTerminalError;\n  }\n\n  if (e instanceof Error) {\n    return e;\n  }\n  if (typeof e === \"object\" && e !== null && \"code\" in e && \"message\" in e) {\n    // This is an error from the VM\n    return new RestateError(e.message as string, {\n      errorCode: e.code as number,\n    });\n  }\n\n  // None of the types we know\n  let msg;\n  try {\n    msg = JSON.stringify(e);\n  } catch {\n    msg = \"(no JSON representation)\";\n  }\n\n  return new Error(\"Non-Error value: \" + msg);\n}\n\nexport function logError(log: Console, e: unknown) {\n  if (e instanceof RestateError) {\n    if (e.code === SUSPENDED_ERROR_CODE) {\n      log.info(\"Invocation suspended\");\n      return;\n    } else if (e.code === CLOSED_ERROR_CODE) {\n      log.error(\n        \"DANGER! The invocation is closed, but some related operation is still running. \\n\" +\n          \"This might indicate that a RestatePromise is being awaited on an asynchronous task, outside the handler, or you're awaiting a RestatePromise inside a ctx.run.\\n\" +\n          \"This is dangerous, and can lead the service to deadlock. Please fix the issue.\\n\" +\n          \"Diagnostic: \",\n        e\n      );\n      return;\n    }\n  }\n  log.warn(\"Error when processing a Restate context operation.\\n\", e);\n}\n\nexport class RestateError extends Error {\n  public readonly code: number;\n  public override name = \"RestateError\";\n\n  constructor(message: string, options?: { errorCode?: number; cause?: any }) {\n    super(message, { cause: options?.cause });\n    this.code = options?.errorCode ?? INTERNAL_ERROR_CODE;\n  }\n}\n\n/**\n * Does not lead to Restate retries.\n *\n * Leads to an output message with a failure defined.\n */\nexport class TerminalError extends RestateError {\n  public override name = \"TerminalError\";\n\n  constructor(\n    message: string,\n    options?: {\n      /**\n       * Error code. This should be an HTTP status code, and in case the service was invoked from the ingress, this will be propagated back to the caller.\n       */\n      errorCode?: number;\n      /**\n       * @deprecated YOU MUST NOT USE THIS FIELD, AS IT WON'T BE RECORDED AND CAN LEAD TO NON-DETERMINISM! From the next SDK version, the constructor won't accept this field anymore.\n       */\n      cause?: any;\n    }\n  ) {\n    super(message, options);\n  }\n}\n\n/**\n * Returned by `RestatePromise.withTimeout` when the timeout is reached.\n */\nexport class TimeoutError extends TerminalError {\n  public override name = \"TimeoutError\";\n\n  constructor() {\n    super(\"Timeout occurred\", { errorCode: TIMEOUT_ERROR_CODE });\n  }\n}\n\n/**\n * Returned when the invocation was cancelled.\n */\nexport class CancelledError extends TerminalError {\n  public override name = \"CancelledError\";\n\n  constructor() {\n    super(\"Cancelled\", { errorCode: CANCEL_ERROR_CODE });\n  }\n}\n\nexport interface RetryableErrorOptions {\n  /**\n   * In how long it should retry.\n   */\n  retryAfter?: Duration | number;\n}\n\n/**\n * Error that Restate will retry. By using this error type within a `ctx.run` closure,\n * you can dynamically provide the retry delay specified in {@link RetryableErrorOptions}.\n *\n * You can wrap another error using {@link from}.\n */\nexport class RetryableError extends RestateError {\n  public override name = \"RetryableError\";\n\n  readonly retryAfter?: Duration | number;\n\n  constructor(\n    message: string,\n    options?: RetryableErrorOptions & {\n      errorCode?: number;\n      cause?: any;\n    }\n  ) {\n    super(message, {\n      errorCode: options?.errorCode,\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      cause: options?.cause,\n    });\n    this.retryAfter = options?.retryAfter;\n  }\n\n  /**\n   * Create a `RetryableError` from the given cause.\n   */\n  static from(cause: any, options?: RetryableErrorOptions): RetryableError {\n    const error = ensureError(cause);\n    return new RetryableError(error.message, {\n      errorCode: error[\"errorCode\" as keyof typeof error] as number,\n      cause: cause,\n      ...options,\n    });\n  }\n}\n"],"mappings":";AAeA,MAAa,sBAAsB;AACnC,MAAa,qBAAqB;AAClC,MAAa,oBAAoB;AACjC,MAAa,qBAAqB;AAGlC,MAAa,oBAAoB;AACjC,MAAa,uBAAuB;AAEpC,SAAgB,YACd,GACA,iBACO;AACP,KAAI,aAAa,cACf,QAAO;CAGT,MAAM,qBAAqB,kBAAkB,gBAAgB,EAAE,GAAG;AAClE,KAAI,mBACF,QAAO;AAGT,KAAI,aAAa,MACf,QAAO;AAET,KAAI,OAAO,MAAM,YAAY,MAAM,QAAQ,UAAU,KAAK,aAAa,EAErE,QAAO,IAAI,aAAa,EAAE,SAAmB,EAC3C,WAAW,EAAE,MACd,CAAC;CAIJ,IAAI;AACJ,KAAI;AACF,QAAM,KAAK,UAAU,EAAE;SACjB;AACN,QAAM;;AAGR,wBAAO,IAAI,MAAM,sBAAsB,IAAI;;AAG7C,SAAgB,SAAS,KAAc,GAAY;AACjD,KAAI,aAAa,cACf;MAAI,EAAE,SAAS,sBAAsB;AACnC,OAAI,KAAK,uBAAuB;AAChC;aACS,EAAE,SAAS,mBAAmB;AACvC,OAAI,MACF,iVAIA,EACD;AACD;;;AAGJ,KAAI,KAAK,wDAAwD,EAAE;;AAGrE,IAAa,eAAb,cAAkC,MAAM;CACtC,AAAgB;CAChB,AAAgB,OAAO;CAEvB,YAAY,SAAiB,SAA+C;AAC1E,QAAM,SAAS,EAAE,OAAO,SAAS,OAAO,CAAC;AACzC,OAAK,OAAO,SAAS,aAAa;;;;;;;;AAStC,IAAa,gBAAb,cAAmC,aAAa;CAC9C,AAAgB,OAAO;CAEvB,YACE,SACA,SAUA;AACA,QAAM,SAAS,QAAQ;;;;;;AAO3B,IAAa,eAAb,cAAkC,cAAc;CAC9C,AAAgB,OAAO;CAEvB,cAAc;AACZ,QAAM,oBAAoB,EAAE,WAAW,oBAAoB,CAAC;;;;;;AAOhE,IAAa,iBAAb,cAAoC,cAAc;CAChD,AAAgB,OAAO;CAEvB,cAAc;AACZ,QAAM,aAAa,EAAE,WAAW,mBAAmB,CAAC;;;;;;;;;AAiBxD,IAAa,iBAAb,MAAa,uBAAuB,aAAa;CAC/C,AAAgB,OAAO;CAEvB,AAAS;CAET,YACE,SACA,SAIA;AACA,QAAM,SAAS;GACb,WAAW,SAAS;GAEpB,OAAO,SAAS;GACjB,CAAC;AACF,OAAK,aAAa,SAAS;;;;;CAM7B,OAAO,KAAK,OAAY,SAAiD;EACvE,MAAM,QAAQ,YAAY,MAAM;AAChC,SAAO,IAAI,eAAe,MAAM,SAAS;GACvC,WAAW,MAAM;GACV;GACP,GAAG;GACJ,CAAC"}

package/dist/types/rpc.cjs

@@ -0,0 +1,425 @@
+const require_errors = require('./errors.cjs');
+
+//#region src/types/rpc.ts
+var Opts = class Opts {
+	/**
+	* Create a call configuration from the provided options.
+	*
+	* @param opts the call configuration
+	*/
+	static from(opts) {
+		return new Opts(opts);
+	}
+	constructor(opts) {
+		this.opts = opts;
+	}
+	getOpts() {
+		return this.opts;
+	}
+};
+var SendOpts = class SendOpts {
+	static from(opts) {
+		return new SendOpts(opts);
+	}
+	getOpts() {
+		return this.opts;
+	}
+	constructor(opts) {
+		this.opts = opts;
+	}
+};
+let rpc;
+(function(_rpc) {
+	_rpc.opts = (opts) => Opts.from(opts);
+	_rpc.sendOpts = (opts) => SendOpts.from(opts);
+})(rpc || (rpc = {}));
+function optsFromArgs(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
+	};
+}
+const makeRpcCallProxy = (genericCall, defaultSerde, service$1, key) => {
+	return new Proxy({}, { get: (_target, prop) => {
+		const method = prop;
+		return (...args) => {
+			const { parameter, opts } = optsFromArgs(args);
+			const requestSerde = opts?.input ?? defaultSerde;
+			const responseSerde = opts?.output ?? defaultSerde;
+			return genericCall({
+				service: service$1,
+				method,
+				parameter,
+				key,
+				headers: opts?.headers,
+				inputSerde: requestSerde,
+				outputSerde: responseSerde,
+				idempotencyKey: opts?.idempotencyKey
+			});
+		};
+	} });
+};
+const makeRpcSendProxy = (genericSend, defaultSerde, service$1, key, legacyDelay) => {
+	return new Proxy({}, { get: (_target, prop) => {
+		const method = prop;
+		return (...args) => {
+			const { parameter, opts } = optsFromArgs(args);
+			const requestSerde = opts?.input ?? defaultSerde;
+			const delay = legacyDelay ?? opts?.delay;
+			return genericSend({
+				service: service$1,
+				method,
+				parameter,
+				key,
+				headers: opts?.headers,
+				delay,
+				inputSerde: requestSerde,
+				idempotencyKey: opts?.idempotencyKey
+			});
+		};
+	} });
+};
+let HandlerKind = /* @__PURE__ */ function(HandlerKind$1) {
+	HandlerKind$1[HandlerKind$1["SERVICE"] = 0] = "SERVICE";
+	HandlerKind$1[HandlerKind$1["EXCLUSIVE"] = 1] = "EXCLUSIVE";
+	HandlerKind$1[HandlerKind$1["SHARED"] = 2] = "SHARED";
+	HandlerKind$1[HandlerKind$1["WORKFLOW"] = 3] = "WORKFLOW";
+	return HandlerKind$1;
+}({});
+const HANDLER_SYMBOL = Symbol("Handler");
+var HandlerWrapper = class HandlerWrapper {
+	static from(kind, handler, opts) {
+		const handlerCopy = function(...args) {
+			return handler.apply(this, args);
+		};
+		return new HandlerWrapper(kind, handlerCopy, opts?.input, opts?.output, opts?.accept, opts?.description, opts?.metadata, opts?.idempotencyRetention, opts?.journalRetention, opts?.inactivityTimeout, opts?.abortTimeout, opts?.ingressPrivate, opts !== void 0 && "enableLazyState" in opts ? opts?.enableLazyState : void 0, opts?.retryPolicy);
+	}
+	static fromHandler(handler) {
+		return handler[HANDLER_SYMBOL];
+	}
+	constructor(kind, handler, inputSerde, outputSerde, accept, description, metadata, idempotencyRetention, journalRetention, inactivityTimeout, abortTimeout, ingressPrivate, enableLazyState, retryPolicy, asTerminalError) {
+		this.kind = kind;
+		this.handler = handler;
+		this.inputSerde = inputSerde;
+		this.outputSerde = outputSerde;
+		this.accept = accept;
+		this.description = description;
+		this.metadata = metadata;
+		this.idempotencyRetention = idempotencyRetention;
+		this.journalRetention = journalRetention;
+		this.inactivityTimeout = inactivityTimeout;
+		this.abortTimeout = abortTimeout;
+		this.ingressPrivate = ingressPrivate;
+		this.enableLazyState = enableLazyState;
+		this.retryPolicy = retryPolicy;
+		this.asTerminalError = asTerminalError;
+	}
+	bindInstance(t) {
+		this.handler = this.handler.bind(t);
+	}
+	async invoke(context, input) {
+		let req;
+		try {
+			req = (this.inputSerde ?? context.defaultSerde).deserialize(input);
+		} catch (e) {
+			throw new require_errors.TerminalError(`Failed to deserialize input: ${require_errors.ensureError(e).message}`, { errorCode: 400 });
+		}
+		const res = await this.handler(context, req);
+		return (this.outputSerde ?? context.defaultSerde).serialize(res);
+	}
+	/**
+	* Instead of a HandlerWrapper with a handler property,
+	* return the original handler with a HandlerWrapper property.
+	* This is needed to keep the appearance of regular functions
+	* bound to an object, so that for example, `this.foo(ctx, arg)` would
+	* work.
+	*/
+	transpose() {
+		const handler = this.handler;
+		if (HandlerWrapper.fromHandler(handler) !== void 0) return handler;
+		Object.defineProperty(handler, HANDLER_SYMBOL, { value: this });
+		return handler;
+	}
+};
+let handlers;
+(function(_handlers) {
+	function handler(opts, fn) {
+		return HandlerWrapper.from(HandlerKind.SERVICE, fn, opts).transpose();
+	}
+	_handlers.handler = handler;
+	let workflow$1;
+	(function(_workflow) {
+		function workflow$2(optsOrFn, fn) {
+			if (typeof optsOrFn === "function") return HandlerWrapper.from(HandlerKind.WORKFLOW, optsOrFn).transpose();
+			const opts = optsOrFn;
+			if (typeof fn !== "function") throw new TypeError("The second argument must be a function");
+			return HandlerWrapper.from(HandlerKind.WORKFLOW, fn, opts).transpose();
+		}
+		_workflow.workflow = workflow$2;
+		function shared(optsOrFn, fn) {
+			if (typeof optsOrFn === "function") return HandlerWrapper.from(HandlerKind.SHARED, optsOrFn).transpose();
+			const opts = optsOrFn;
+			if (typeof fn !== "function") throw new TypeError("The second argument must be a function");
+			return HandlerWrapper.from(HandlerKind.SHARED, fn, opts).transpose();
+		}
+		_workflow.shared = shared;
+	})(workflow$1 || (workflow$1 = _handlers.workflow || (_handlers.workflow = {})));
+	let object$1;
+	(function(_object) {
+		function exclusive(optsOrFn, fn) {
+			if (typeof optsOrFn === "function") return HandlerWrapper.from(HandlerKind.EXCLUSIVE, optsOrFn).transpose();
+			const opts = optsOrFn;
+			if (typeof fn !== "function") throw new TypeError("The second argument must be a function");
+			return HandlerWrapper.from(HandlerKind.EXCLUSIVE, fn, opts).transpose();
+		}
+		_object.exclusive = exclusive;
+		function shared(optsOrFn, fn) {
+			if (typeof optsOrFn === "function") return HandlerWrapper.from(HandlerKind.SHARED, optsOrFn).transpose();
+			const opts = optsOrFn;
+			if (typeof fn !== "function") throw new TypeError("The second argument must be a function");
+			return HandlerWrapper.from(HandlerKind.SHARED, fn, opts).transpose();
+		}
+		_object.shared = shared;
+	})(object$1 || (object$1 = _handlers.object || (_handlers.object = {})));
+})(handlers || (handlers = {}));
+/**
+* Define a Restate service.
+*
+* @example Here is an example of how to define a service:
+*
+* ```ts
+* const greeter = service({
+*   name: "greeter",
+*   handlers: {
+*     greet: async (ctx: Context, name: string) => {
+*       return `Hello ${name}`;
+*     }
+*   }
+* });
+* ```
+*
+* To use the service, you can bind it to an endpoint:
+* ```
+* ...
+* endpoint.bind(greeter)
+* ```
+* @example To use a service, you can export its type to be used in a client:
+* ```
+* export type Greeter = typeof greeter;
+* ...
+* ...
+* import type { Greeter } from "./greeter";
+* const client = ctx.serviceClient<Greeter>({ name : "greeter"});
+* client.greet("World").then(console.log);
+* ```
+*
+* @example Alternatively to avoid repeating the service name, you can:
+* ```
+* import type {Greeter} from "./greeter";
+* const Greeter: Greeter = { name : "greeter"};
+*
+* // now you can reference the service like this:
+* const client = ctx.serviceClient(Greeter);
+* ```
+*
+* @param name the service name
+* @param handlers the handlers for the service
+* @param description an optional description for the service
+* @param metadata an optional metadata for the service
+* @type P the name of the service
+* @type M the handlers for the service
+*/
+const service = (service$1) => {
+	if (!service$1.handlers) throw new Error("service must be defined");
+	const handlers$1 = Object.entries(service$1.handlers).map(([name, handler]) => {
+		if (handler instanceof Function) {
+			if (HandlerWrapper.fromHandler(handler) !== void 0) return [name, handler];
+			return [name, HandlerWrapper.from(HandlerKind.SERVICE, handler).transpose()];
+		}
+		throw new TypeError(`Unexpected handler type ${name}`);
+	});
+	return {
+		name: service$1.name,
+		service: Object.fromEntries(handlers$1),
+		metadata: service$1.metadata,
+		description: service$1.description,
+		options: service$1.options
+	};
+};
+/**
+* Define a Restate virtual object.
+*
+* @example Here is an example of how to define a virtual object:
+* ```ts
+*        const counter = object({
+*            name: "counter",
+*            handlers: {
+*                  add: async (ctx: ObjectContext, amount: number) => {},
+*                  get: async (ctx: ObjectContext) => {}
+*            }
+*        })
+*  ```
+*
+* @example To use the object, you can bind it to an endpoint:
+* ```ts
+* ...
+* endpoint.bind(counter)
+* ```
+*
+*  @see to interact with the object, you can use the object client:
+* ```ts
+* ...
+* const client = ctx.objectClient<typeof counter>({ name: "counter"});
+* const res = await client.add(1)
+* ```
+*
+* ### Shared handlers
+*
+* Shared handlers are used to allow concurrent read-only access to the object.
+* This is useful when you want to allow multiple clients to read the object's state at the same time.
+* To define a shared handler, you can use the `shared` decorator as shown below:
+*
+* ```ts
+*      const counter = object({
+*          name: "counter",
+*          handlers: {
+*
+*            add: async (ctx: ObjectContext, amount: number) => { .. },
+*
+*            get: handlers.object.shared(async (ctx: ObjectSharedContext) => {
+*                  return ctx.get<number>("count");
+*            })
+*       }
+*     });
+* ```
+*
+* @param name the name of the object
+* @param handlers the handlers for the object
+* @param description an optional description for the object
+* @param metadata an optional metadata for the object
+* @type P the name of the object
+* @type M the handlers for the object
+*/
+const object = (object$1) => {
+	if (!object$1.handlers) throw new Error("object options must be defined");
+	const handlers$1 = Object.entries(object$1.handlers).map(([name, handler]) => {
+		if (handler instanceof Function) {
+			if (HandlerWrapper.fromHandler(handler) !== void 0) return [name, handler];
+			return [name, HandlerWrapper.from(HandlerKind.EXCLUSIVE, handler).transpose()];
+		}
+		throw new TypeError(`Unexpected handler type ${name}`);
+	});
+	return {
+		name: object$1.name,
+		object: Object.fromEntries(handlers$1),
+		metadata: object$1.metadata,
+		description: object$1.description,
+		options: object$1.options
+	};
+};
+/**
+* Define a Restate workflow.
+*
+*
+* @example Here is an example of how to define a workflow:
+* ```ts
+* const mywf = workflow({
+*   name: "mywf",
+*   handlers: {
+*     run: async (ctx: WorkflowContext, argument: any) => {
+*       return "Hello World";
+*     }
+*   }
+* });
+* ```
+*
+* ### Note:
+* * That a workflow must contain exactly one handler named 'run', and this handler must accept as a first argument a WorkflowContext.
+* * The workflow handlers other than 'run' must accept as a first argument a WorkflowSharedContext.
+* * The workflow handlers can not be named 'workflowSubmit', 'workflowAttach', 'workflowOutput' - as these are reserved keywords.
+*
+* @example To use the workflow, you can bind it to an endpoint:
+* ```ts
+* endpoint.bind(mywf)
+* ```
+*
+* @example To interact with the workflow, you can use the workflow client:
+* ```ts
+* const client = ctx.workflowClient<typeof mywf>({ name: "mywf"});
+* const res = await client.run("Hello");
+* ```
+*
+* To use the workflow client from any other environment (like a browser), please refer to the documentation.
+* https://docs.restate.dev
+*
+*
+*
+* @param name the workflow name
+* @param handlers the handlers for the workflow.
+*/
+const workflow = (workflow$1) => {
+	if (!workflow$1.handlers) throw new Error("workflow must contain handlers");
+	const runHandler = workflow$1.handlers["run"];
+	let runWrapper;
+	if (runHandler instanceof HandlerWrapper) runWrapper = runHandler;
+	else if (runHandler instanceof Function) runWrapper = HandlerWrapper.fromHandler(runHandler) ?? HandlerWrapper.from(HandlerKind.WORKFLOW, runHandler);
+	else throw new TypeError(`Missing main workflow handler, named 'run'`);
+	if (runWrapper.kind !== HandlerKind.WORKFLOW) throw new TypeError(`Workflow's main handler handler run, must be of type workflow'`);
+	const handlers$1 = [["run", runWrapper.transpose()]];
+	for (const [name, handler] of Object.entries(workflow$1.handlers)) {
+		if (name === "run") continue;
+		let wrapper;
+		if (handler instanceof HandlerWrapper) wrapper = handler;
+		else if (handler instanceof Function) wrapper = HandlerWrapper.fromHandler(handler) ?? HandlerWrapper.from(HandlerKind.SHARED, handler);
+		else throw new TypeError(`Unexpected handler type ${name}`);
+		if (wrapper.kind === HandlerKind.WORKFLOW) throw new TypeError(`A workflow must contain exactly one handler annotated as workflow, named 'run'. Please use a shared handler for any additional handlers`);
+		handlers$1.push([name, wrapper.transpose()]);
+	}
+	return {
+		name: workflow$1.name,
+		workflow: Object.fromEntries(handlers$1),
+		metadata: workflow$1.metadata,
+		description: workflow$1.description,
+		options: workflow$1.options
+	};
+};
+
+//#endregion
+exports.HandlerKind = HandlerKind;
+exports.HandlerWrapper = HandlerWrapper;
+exports.Opts = Opts;
+exports.SendOpts = SendOpts;
+Object.defineProperty(exports, 'handlers', {
+  enumerable: true,
+  get: function () {
+    return handlers;
+  }
+});
+exports.makeRpcCallProxy = makeRpcCallProxy;
+exports.makeRpcSendProxy = makeRpcSendProxy;
+exports.object = object;
+Object.defineProperty(exports, 'rpc', {
+  enumerable: true,
+  get: function () {
+    return rpc;
+  }
+});
+exports.service = service;
+exports.workflow = workflow;