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

package/dist/types/rpc.js

@@ -0,0 +1,406 @@
+import { TerminalError, ensureError } from "./errors.js";
+
+//#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 TerminalError(`Failed to deserialize input: ${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
+export { HandlerKind, HandlerWrapper, Opts, SendOpts, handlers, makeRpcCallProxy, makeRpcSendProxy, object, rpc, service, workflow };
+//# sourceMappingURL=rpc.js.map

package/dist/types/rpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.js","names":["opts: ClientCallOptions<I, O>","opts: ClientSendOptions<I>","parameter: unknown","opts:\n    | ClientCallOptions<unknown, unknown>\n    | ClientSendOptions<unknown>\n    | undefined","kind: HandlerKind","handler: Function","inputSerde?: Serde<unknown>","outputSerde?: Serde<unknown>","accept?: string","description?: string","metadata?: Record<string, string>","idempotencyRetention?: Duration | number","journalRetention?: Duration | number","inactivityTimeout?: Duration | number","abortTimeout?: Duration | number","ingressPrivate?: boolean","enableLazyState?: boolean","retryPolicy?: RetryPolicy","asTerminalError?: (error: any) => TerminalError | undefined","req: unknown","res: unknown","workflow","service","handlers","object","runWrapper: HandlerWrapper","wrapper: HandlerWrapper"],"sources":["../../src/types/rpc.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/* eslint-disable @typescript-eslint/no-unsafe-function-type */\n/* eslint-disable @typescript-eslint/no-unsafe-call */\n/* eslint-disable @typescript-eslint/no-namespace */\n\nimport type {\n  Context,\n  GenericCall,\n  GenericSend,\n  InvocationHandle,\n  InvocationPromise,\n  ObjectContext,\n  ObjectSharedContext,\n  TypedState,\n  UntypedState,\n  WorkflowContext,\n  WorkflowSharedContext,\n} from \"../context.js\";\n\nimport {\n  type ServiceHandler,\n  type ServiceDefinition,\n  type ObjectHandler,\n  type VirtualObjectDefinition,\n  type WorkflowHandler,\n  type WorkflowDefinition,\n  type WorkflowSharedHandler,\n  type Serde,\n  type Duration,\n} from \"@restatedev/restate-sdk-core\";\nimport { ensureError, TerminalError } from \"./errors.js\";\n\n// ----------- rpc clients -------------------------------------------------------\n\nexport type ClientCallOptions<I, O> = {\n  input?: Serde<I>;\n  output?: Serde<O>;\n  headers?: Record<string, string>;\n  idempotencyKey?: string;\n};\n\nexport class Opts<I, O> {\n  /**\n   * Create a call configuration from the provided options.\n   *\n   * @param opts the call configuration\n   */\n  public static from<I, O>(opts: ClientCallOptions<I, O>): Opts<I, O> {\n    return new Opts<I, O>(opts);\n  }\n\n  private constructor(private readonly opts: ClientCallOptions<I, O>) {}\n\n  public getOpts(): ClientCallOptions<I, O> {\n    return this.opts;\n  }\n}\n\nexport type ClientSendOptions<I> = {\n  input?: Serde<I>;\n  /**\n   * Makes a type-safe one-way RPC to the specified target service, after a delay specified by the\n   * milliseconds' argument.\n   * This method is like setting up a fault-tolerant cron job that enqueues the message in a\n   * message queue.\n   * The handler calling this function does not have to stay active for the delay time.\n   *\n   * Both the delay timer and the message are durably stored in Restate and guaranteed to be reliably\n   * delivered. The delivery happens no earlier than specified through the delay, but may happen\n   * later, if the target service is down, or backpressuring the system.\n   *\n   * The delay message is journaled for durable execution and will thus not be duplicated when the\n   * handler is re-invoked for retries or after suspending.\n   *\n   * This call will return immediately; the message sending happens asynchronously in the background.\n   * Despite that, the message is guaranteed to be sent, because the completion of the invocation that\n   * triggers the send (calls this function) happens logically after the sending. That means that any\n   * failure where the message does not reach Restate also cannot complete this invocation, and will\n   * hence recover this handler and (through the durable execution) recover the message to be sent.\n   *\n   * @example\n   * ```ts\n   * ctx.serviceSendClient(Service).anotherAction(1337, { delay: { seconds: 60 } });\n   * ```\n   */\n  delay?: Duration | number;\n  headers?: Record<string, string>;\n  idempotencyKey?: string;\n};\n\nexport class SendOpts<I> {\n  public static from<I>(opts: ClientSendOptions<I>): SendOpts<I> {\n    return new SendOpts<I>(opts);\n  }\n\n  public getOpts(): ClientSendOptions<I> {\n    return this.opts;\n  }\n\n  private constructor(private readonly opts: ClientSendOptions<I>) {}\n}\n\nexport namespace rpc {\n  export const opts = <I, O>(opts: ClientCallOptions<I, O>) => Opts.from(opts);\n\n  export const sendOpts = <I>(opts: ClientSendOptions<I>) =>\n    SendOpts.from(opts);\n}\n\nfunction optsFromArgs(args: unknown[]): {\n  parameter?: unknown;\n  opts?:\n    | ClientCallOptions<unknown, unknown>\n    | ClientSendOptions<unknown>\n    | undefined;\n} {\n  let parameter: unknown;\n  let opts:\n    | ClientCallOptions<unknown, unknown>\n    | ClientSendOptions<unknown>\n    | undefined;\n  switch (args.length) {\n    case 0: {\n      break;\n    }\n    case 1: {\n      if (args[0] instanceof Opts) {\n        opts = args[0].getOpts();\n      } else if (args[0] instanceof SendOpts) {\n        opts = args[0].getOpts();\n      } else {\n        parameter = args[0];\n      }\n      break;\n    }\n    case 2: {\n      parameter = args[0];\n      if (args[1] instanceof Opts) {\n        opts = args[1].getOpts();\n      } else if (args[1] instanceof SendOpts) {\n        opts = args[1].getOpts();\n      } else {\n        throw new TypeError(\n          \"The second argument must be either Opts or SendOpts\"\n        );\n      }\n      break;\n    }\n    default: {\n      throw new TypeError(\"unexpected number of arguments\");\n    }\n  }\n  return {\n    parameter,\n    opts,\n  };\n}\n\nexport const makeRpcCallProxy = <T>(\n  genericCall: (call: GenericCall<unknown, unknown>) => Promise<unknown>,\n  defaultSerde: Serde<any>,\n  service: string,\n  key?: string\n): T => {\n  const clientProxy = new Proxy(\n    {},\n    {\n      get: (_target, prop) => {\n        const method = prop as string;\n        return (...args: unknown[]) => {\n          const { parameter, opts } = optsFromArgs(args);\n          const requestSerde = opts?.input ?? defaultSerde;\n          const responseSerde =\n            (opts as ClientCallOptions<unknown, unknown> | undefined)?.output ??\n            defaultSerde;\n          return genericCall({\n            service,\n            method,\n            parameter,\n            key,\n            headers: opts?.headers,\n            inputSerde: requestSerde,\n            outputSerde: responseSerde,\n            idempotencyKey: opts?.idempotencyKey,\n          });\n        };\n      },\n    }\n  );\n\n  return clientProxy as T;\n};\n\nexport const makeRpcSendProxy = <T>(\n  genericSend: (send: GenericSend<unknown>) => void,\n  defaultSerde: Serde<any>,\n  service: string,\n  key?: string,\n  legacyDelay?: number\n): T => {\n  const clientProxy = new Proxy(\n    {},\n    {\n      get: (_target, prop) => {\n        const method = prop as string;\n        return (...args: unknown[]) => {\n          const { parameter, opts } = optsFromArgs(args);\n          const requestSerde = opts?.input ?? defaultSerde;\n          const delay =\n            legacyDelay ??\n            (opts as ClientSendOptions<unknown> | undefined)?.delay;\n          return genericSend({\n            service,\n            method,\n            parameter,\n            key,\n            headers: opts?.headers,\n            delay,\n            inputSerde: requestSerde,\n            idempotencyKey: opts?.idempotencyKey,\n          });\n        };\n      },\n    }\n  );\n\n  return clientProxy as T;\n};\n\nexport type InferArg<P> = P extends [infer A, ...any[]] ? A : unknown;\n\nexport type Client<M> = {\n  [K in keyof M as M[K] extends never ? never : K]: M[K] extends (\n    arg: any,\n    ...args: infer P\n  ) => PromiseLike<infer O>\n    ? (\n        ...args: [...P, ...[opts?: Opts<InferArg<P>, O>]]\n      ) => InvocationPromise<O>\n    : never;\n};\n\nexport type SendClient<M> = {\n  [K in keyof M as M[K] extends never ? never : K]: M[K] extends (\n    arg: any,\n    ...args: infer P\n  ) => void\n    ? (...args: [...P, ...[opts?: SendOpts<InferArg<P>>]]) => InvocationHandle\n    : never;\n};\n\n// ----------- handlers ----------------------------------------------\n\nexport enum HandlerKind {\n  SERVICE,\n  EXCLUSIVE,\n  SHARED,\n  WORKFLOW,\n}\n\nexport type ServiceHandlerOpts<I, O> = {\n  /**\n   * Defines which Content-Type values are accepted when this handler is invoked via the ingress.\n   * Wildcards are supported, for example `application/*` or `* / *`.\n   *\n   * If unset, `input.contentType` will be used as the default.\n   *\n   * This setting does not affect deserialization. To customize how the input is deserialized,\n   * provide an `input` Serde.\n   */\n  accept?: string;\n\n  /**\n   * Serde used to deserialize the input parameter.\n   * Defaults to `restate.serde.json`.\n   *\n   * Provide a custom Serde if the input is not JSON, or use\n   * `restate.serde.binary` to skip serialization/deserialization altogether;\n   * in that case the input parameter is a `Uint8Array`.\n   */\n  input?: Serde<I>;\n\n  /**\n   * Serde used to serialize the output value.\n   * Defaults to `restate.serde.json`.\n   *\n   * Provide a custom Serde if the output is not JSON, or use\n   * `restate.serde.binary` to skip serialization/deserialization altogether;\n   * in that case the output value is a `Uint8Array`.\n   */\n  output?: Serde<O>;\n\n  /**\n   * Human-readable description of the handler, shown in documentation/admin tools.\n   */\n  description?: string;\n\n  /**\n   * Arbitrary key/value metadata for the handler. Exposed via the Admin API.\n   */\n  metadata?: Record<string, string>;\n\n  /**\n   * The retention duration of idempotent requests to this handler.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  idempotencyRetention?: Duration | number;\n\n  /**\n   * The journal retention for invocations to this handler.\n   *\n   * When a request has an idempotency key, `idempotencyRetention` caps the journal retention time.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  journalRetention?: Duration | number;\n\n  /**\n   * Guards against stalled invocations. Once this timeout expires, Restate requests a graceful\n   * suspension of the invocation (preserving intermediate progress).\n   *\n   * If the invocation does not react to the suspension request, `abortTimeout` is used to abort it.\n   *\n   * Overrides the inactivity timeout set at the service level and the default configured in the Restate server.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  inactivityTimeout?: Duration | number;\n\n  /**\n   * Guards against invocations that fail to terminate after inactivity.\n   * The abort timeout starts after `inactivityTimeout` expires and a graceful termination was requested.\n   * When this timer expires, the invocation is aborted.\n   *\n   * This timer may interrupt user code. If more time is needed for graceful termination, increase this value.\n   *\n   * Overrides the abort timeout set at the service level and the default configured in the Restate server.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  abortTimeout?: Duration | number;\n\n  /**\n   * When set to `true`, this handler cannot be invoked via the Restate server HTTP or Kafka ingress;\n   * it can only be called from other services.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  ingressPrivate?: boolean;\n\n  /**\n   * Retry policy to apply to all requests to this handler. For each unspecified field, the default value configured in the service or, if absent, in the restate-server configuration file, will be applied instead.\n   */\n  retryPolicy?: RetryPolicy;\n};\n\nexport type ObjectHandlerOpts<I, O> = ServiceHandlerOpts<I, O> & {\n  /**\n   * When set to `true`, lazy state will be enabled for all invocations to this handler.\n   *\n   * *NOTE:* You can set this field only if you register this endpoint against restate-server >= 1.4,\n   * otherwise the service discovery will fail.\n   */\n  enableLazyState?: boolean;\n};\n\nexport type WorkflowHandlerOpts<I, O> = ServiceHandlerOpts<I, O> & {\n  /**\n   * When set to `true`, lazy state will be enabled for all invocations to this handler.\n   *\n   * *NOTE:* You can set this field only if you register this endpoint against restate-server >= 1.4,\n   * otherwise the service discovery will fail.\n   */\n  enableLazyState?: boolean;\n};\n\nconst HANDLER_SYMBOL = Symbol(\"Handler\");\n\nexport class HandlerWrapper {\n  public static from(\n    kind: HandlerKind,\n    handler: Function,\n    opts?:\n      | ServiceHandlerOpts<unknown, unknown>\n      | ObjectHandlerOpts<unknown, unknown>\n      | WorkflowHandlerOpts<unknown, unknown>\n  ): HandlerWrapper {\n    // we must create here a copy of the handler\n    // to be able to reuse the original handler in other places.\n    // like for example the same logic but under different routes.\n    const handlerCopy = function (this: any, ...args: any[]): any {\n      return handler.apply(this, args);\n    };\n\n    return new HandlerWrapper(\n      kind,\n      handlerCopy,\n      opts?.input,\n      opts?.output,\n      opts?.accept,\n      opts?.description,\n      opts?.metadata,\n      opts?.idempotencyRetention,\n      opts?.journalRetention,\n      opts?.inactivityTimeout,\n      opts?.abortTimeout,\n      opts?.ingressPrivate,\n      opts !== undefined && \"enableLazyState\" in opts\n        ? opts?.enableLazyState\n        : undefined,\n      opts?.retryPolicy\n    );\n  }\n\n  public static fromHandler(handler: any): HandlerWrapper | undefined {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return handler[HANDLER_SYMBOL] as HandlerWrapper | undefined;\n  }\n\n  private constructor(\n    public readonly kind: HandlerKind,\n    private handler: Function,\n    public readonly inputSerde?: Serde<unknown>,\n    public readonly outputSerde?: Serde<unknown>,\n    public readonly accept?: string,\n    public readonly description?: string,\n    public readonly metadata?: Record<string, string>,\n    public readonly idempotencyRetention?: Duration | number,\n    public readonly journalRetention?: Duration | number,\n    public readonly inactivityTimeout?: Duration | number,\n    public readonly abortTimeout?: Duration | number,\n    public readonly ingressPrivate?: boolean,\n    public readonly enableLazyState?: boolean,\n    public readonly retryPolicy?: RetryPolicy,\n    public readonly asTerminalError?: (error: any) => TerminalError | undefined\n  ) {}\n\n  bindInstance(t: unknown) {\n    this.handler = this.handler.bind(t) as Function;\n  }\n\n  async invoke(context: { defaultSerde: Serde<any> }, input: Uint8Array) {\n    let req: unknown;\n    try {\n      req = (this.inputSerde ?? context.defaultSerde).deserialize(input);\n    } catch (e) {\n      const error = ensureError(e);\n      throw new TerminalError(`Failed to deserialize input: ${error.message}`, {\n        errorCode: 400,\n      });\n    }\n\n    const res: unknown = await this.handler(context, req);\n    return (this.outputSerde ?? context.defaultSerde).serialize(res);\n  }\n\n  /**\n   * Instead of a HandlerWrapper with a handler property,\n   * return the original handler with a HandlerWrapper property.\n   * This is needed to keep the appearance of regular functions\n   * bound to an object, so that for example, `this.foo(ctx, arg)` would\n   * work.\n   */\n  transpose<F>(): F {\n    const handler = this.handler;\n    const existing = HandlerWrapper.fromHandler(handler);\n    if (existing !== undefined) {\n      return handler as F;\n    }\n    Object.defineProperty(handler, HANDLER_SYMBOL, { value: this });\n    return handler as F;\n  }\n}\n\n// ----------- handler decorators ----------------------------------------------\nexport type RemoveVoidArgument<F> = F extends (\n  ctx: infer C,\n  arg: infer A\n) => infer R\n  ? A extends void\n    ? (ctx: C) => R\n    : F\n  : F;\n\nexport namespace handlers {\n  /**\n   * Create a service handler.\n   *\n   * @param opts additional configuration\n   * @param fn the actual handler code to execute\n   */\n  export function handler<O, I = void>(\n    opts: ServiceHandlerOpts<I, O>,\n    fn: (ctx: Context, input: I) => Promise<O>\n  ): RemoveVoidArgument<typeof fn> {\n    return HandlerWrapper.from(HandlerKind.SERVICE, fn, opts).transpose();\n  }\n\n  export namespace workflow {\n    export function workflow<\n      O,\n      I = void,\n      TState extends TypedState = UntypedState,\n    >(\n      opts: WorkflowHandlerOpts<I, O>,\n      fn: (ctx: WorkflowContext<TState>, input: I) => Promise<O>\n    ): RemoveVoidArgument<typeof fn>;\n\n    export function workflow<\n      O,\n      I = void,\n      TState extends TypedState = UntypedState,\n    >(\n      fn: (ctx: WorkflowContext<TState>, input: I) => Promise<O>\n    ): RemoveVoidArgument<typeof fn>;\n\n    export function workflow<O, I = void>(\n      optsOrFn:\n        | WorkflowHandlerOpts<I, O>\n        | ((ctx: WorkflowContext, input: I) => Promise<O>),\n      fn?: (ctx: WorkflowContext, input: I) => Promise<O>\n    ) {\n      if (typeof optsOrFn === \"function\") {\n        return HandlerWrapper.from(HandlerKind.WORKFLOW, optsOrFn).transpose();\n      }\n      const opts = optsOrFn satisfies WorkflowHandlerOpts<I, O>;\n      if (typeof fn !== \"function\") {\n        throw new TypeError(\"The second argument must be a function\");\n      }\n      return HandlerWrapper.from(HandlerKind.WORKFLOW, fn, opts).transpose();\n    }\n\n    /**\n     * Creates a shared handler for a workflow.\n     *\n     * A shared handler allows a read-only concurrent execution\n     * for a given key.\n     *\n     * @param opts additional configurations\n     * @param fn the handler to execute\n     */\n    export function shared<\n      O,\n      I = void,\n      TState extends TypedState = UntypedState,\n    >(\n      opts: WorkflowHandlerOpts<I, O>,\n      fn: (ctx: WorkflowSharedContext<TState>, input: I) => Promise<O>\n    ): RemoveVoidArgument<typeof fn>;\n\n    /**\n     * Creates a shared handler for a workflow.\n     *\n     * A shared handler allows a read-only concurrent execution\n     * for a given key.\n     *\n     * @param opts additional configurations\n     * @param fn the handler to execute\n     */\n    export function shared<\n      O,\n      I = void,\n      TState extends TypedState = UntypedState,\n    >(\n      fn: (ctx: WorkflowSharedContext<TState>, input: I) => Promise<O>\n    ): RemoveVoidArgument<typeof fn>;\n\n    /**\n     * Creates a shared handler for a workflow\n     *\n     * A shared handler allows a read-only concurrent execution\n     * for a given key.\n     *\n     * @param opts additional configurations\n     * @param fn the handler to execute\n     */\n    export function shared<O, I = void>(\n      optsOrFn:\n        | WorkflowHandlerOpts<I, O>\n        | ((ctx: WorkflowSharedContext, input: I) => Promise<O>),\n      fn?: (ctx: WorkflowSharedContext, input: I) => Promise<O>\n    ) {\n      if (typeof optsOrFn === \"function\") {\n        return HandlerWrapper.from(HandlerKind.SHARED, optsOrFn).transpose();\n      }\n      const opts = optsOrFn satisfies ObjectHandlerOpts<I, O>;\n      if (typeof fn !== \"function\") {\n        throw new TypeError(\"The second argument must be a function\");\n      }\n      return HandlerWrapper.from(HandlerKind.SHARED, fn, opts).transpose();\n    }\n  }\n\n  export namespace object {\n    /**\n     * Creates an exclusive handler for a virtual Object.\n     *\n     * note : This applies only to a virtual object.\n     *\n     * @param opts additional configurations\n     * @param fn the handler to execute\n     */\n    export function exclusive<\n      O,\n      I = void,\n      TState extends TypedState = UntypedState,\n    >(\n      opts: ObjectHandlerOpts<I, O>,\n      fn: (ctx: ObjectContext<TState>, input: I) => Promise<O>\n    ): RemoveVoidArgument<typeof fn>;\n\n    /**\n     * Creates an exclusive handler for a virtual Object.\n     *\n     *\n     * note 1: This applies only to a virtual object.\n     * note 2: This is the default for virtual objects, so if no\n     *         additional reconfiguration is needed, you can simply\n     *         use the handler directly (no need to use exclusive).\n     *         This variant here is only for symmetry/convenance.\n     *\n     * @param fn the handler to execute\n     */\n    export function exclusive<\n      O,\n      I = void,\n      TState extends TypedState = UntypedState,\n    >(\n      fn: (ctx: ObjectContext<TState>, input: I) => Promise<O>\n    ): RemoveVoidArgument<typeof fn>;\n\n    /**\n     * Creates an exclusive handler for a virtual Object.\n     *\n     *\n     * note 1: This applies only to a virtual object.\n     * note 2: This is the default for virtual objects, so if no\n     *         additional reconfiguration is needed, you can simply\n     *         use the handler directly (no need to use exclusive).\n     *         This variant here is only for symmetry/convenance.\n     *\n     * @param opts additional configurations\n     * @param fn the handler to execute\n     */\n    export function exclusive<O, I = void>(\n      optsOrFn:\n        | ObjectHandlerOpts<I, O>\n        | ((ctx: ObjectContext, input: I) => Promise<O>),\n      fn?: (ctx: ObjectContext, input: I) => Promise<O>\n    ) {\n      if (typeof optsOrFn === \"function\") {\n        return HandlerWrapper.from(HandlerKind.EXCLUSIVE, optsOrFn).transpose();\n      }\n      const opts = optsOrFn satisfies ObjectHandlerOpts<I, O>;\n      if (typeof fn !== \"function\") {\n        throw new TypeError(\"The second argument must be a function\");\n      }\n      return HandlerWrapper.from(HandlerKind.EXCLUSIVE, fn, opts).transpose();\n    }\n\n    /**\n     * Creates a shared handler for a virtual Object.\n     *\n     * A shared handler allows a read-only concurrent execution\n     * for a given key.\n     *\n     * note: This applies only to a virtual object.\n     *\n     * @param opts additional configurations\n     * @param fn the handler to execute\n     */\n    export function shared<\n      O,\n      I = void,\n      TState extends TypedState = UntypedState,\n    >(\n      opts: ObjectHandlerOpts<I, O>,\n      fn: (ctx: ObjectSharedContext<TState>, input: I) => Promise<O>\n    ): RemoveVoidArgument<typeof fn>;\n\n    /**\n     * Creates a shared handler for a virtual Object.\n     *\n     * A shared handler allows a read-only concurrent execution\n     * for a given key.\n     *\n     * note: This applies only to a virtual object.\n     *\n     * @param opts additional configurations\n     * @param fn the handler to execute\n     */\n    export function shared<\n      O,\n      I = void,\n      TState extends TypedState = UntypedState,\n    >(\n      fn: (ctx: ObjectSharedContext<TState>, input: I) => Promise<O>\n    ): RemoveVoidArgument<typeof fn>;\n\n    /**\n     * Creates a shared handler for a virtual Object.\n     *\n     * A shared handler allows a read-only concurrent execution\n     * for a given key.\n     *\n     * note: This applies only to a virtual object.\n     *\n     * @param opts additional configurations\n     * @param fn the handler to execute\n     */\n    export function shared<I, O>(\n      optsOrFn:\n        | ObjectHandlerOpts<I, O>\n        | ((ctx: ObjectSharedContext, input: I) => Promise<O>),\n      fn?: (ctx: ObjectSharedContext, input: I) => Promise<O>\n    ) {\n      if (typeof optsOrFn === \"function\") {\n        return HandlerWrapper.from(HandlerKind.SHARED, optsOrFn).transpose();\n      }\n      const opts = optsOrFn satisfies ObjectHandlerOpts<I, O>;\n      if (typeof fn !== \"function\") {\n        throw new TypeError(\"The second argument must be a function\");\n      }\n      return HandlerWrapper.from(HandlerKind.SHARED, fn, opts).transpose();\n    }\n  }\n}\n\n// ----------- services ----------------------------------------------\n\nexport type ServiceOpts<U> = {\n  [K in keyof U]: U[K] extends ServiceHandler<U[K], Context>\n    ? U[K]\n    : ServiceHandler<U[K], Context>;\n};\n\nexport type RetryPolicy = {\n  /**\n   * Max number of retry attempts (including the initial).\n   * When reached, the behavior specified in {@link onMaxAttempts} will be applied.\n   */\n  maxAttempts?: number;\n\n  /**\n   * What to do when max attempts are reached.\n   *\n   * If `pause`, the invocation will enter the paused state and can be manually resumed from the CLI/UI.\n   *\n   * If `kill`, the invocation will get automatically killed.\n   */\n  onMaxAttempts?: \"pause\" | \"kill\";\n\n  /**\n   * Initial interval for the first retry attempt.\n   * Retry interval will grow by a factor specified in `exponentiationFactor`.\n   *\n   * If a number is provided, it will be interpreted as milliseconds.\n   */\n  initialInterval?: Duration | number;\n\n  /**\n   * Max interval between retries.\n   * Retry interval will grow by a factor specified in `exponentiationFactor`.\n   *\n   * If a number is provided, it will be interpreted as milliseconds.\n   */\n  maxInterval?: Duration | number;\n\n  /**\n   * Exponentiation factor to use when computing the next retry delay.\n   */\n  exponentiationFactor?: number;\n};\n\nexport type ServiceOptions = {\n  /**\n   * The retention duration of idempotent requests to this service.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  idempotencyRetention?: Duration | number;\n\n  /**\n   * Journal retention applied to all requests to all handlers of this service.\n   *\n   * When a request includes an idempotency key, `idempotencyRetention` caps the journal retention time.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  journalRetention?: Duration | number;\n\n  /**\n   * Guards against stalled invocations. Once this timeout expires, Restate requests a graceful\n   * suspension of the invocation (preserving intermediate progress).\n   *\n   * If the invocation does not react to the suspension request, `abortTimeout` is used to abort it.\n   *\n   * Overrides the default inactivity timeout configured in the Restate server for all invocations to this service.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  inactivityTimeout?: Duration | number;\n\n  /**\n   * Guards against invocations that fail to terminate after inactivity.\n   * The abort timeout starts after `inactivityTimeout` expires and a graceful termination was requested.\n   * When this timer expires, the invocation is aborted.\n   *\n   * This timer may interrupt user code. If more time is needed for graceful termination, increase this value.\n   *\n   * Overrides the default abort timeout configured in the Restate server for invocations to this service.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  abortTimeout?: Duration | number;\n\n  /**\n   * When set to `true`, this service (and all its handlers) cannot be invoked via the Restate server\n   * HTTP or Kafka ingress; it can only be called from other services.\n   *\n   * Note: Available only when registering this endpoint with restate-server v1.4 or newer; otherwise service discovery will fail.\n   */\n  ingressPrivate?: boolean;\n\n  /**\n   * Retry policy to apply to all requests to this service. For each unspecified field, the default value configured in the restate-server configuration file will be applied instead.\n   */\n  retryPolicy?: RetryPolicy;\n\n  /**\n   * By default, Restate treats errors as terminal (non-retryable) only when they are instances of `TerminalError`.\n   *\n   * Use this hook to map domain-specific errors to `TerminalError` (or return `undefined` to keep them retryable).\n   * When mapped to `TerminalError`, the error will not be retried.\n   *\n   * Note: This applies to errors thrown inside `ctx.run` closures as well as errors thrown by Restate handlers.\n   *\n   * Example:\n   *\n   * ```ts\n   * class MyValidationError extends Error {}\n   *\n   * const greeter = restate.service({\n   *   name: \"greeter\",\n   *   handlers: {\n   *     greet: async (ctx: restate.Context, name: string) => {\n   *       if (name.length === 0) {\n   *         throw new MyValidationError(\"Length too short\");\n   *       }\n   *       return `Hello ${name}`;\n   *     }\n   *   },\n   *   options: {\n   *     asTerminalError: (err) => {\n   *       if (err instanceof MyValidationError) {\n   *         // My validation error is terminal\n   *         return new restate.TerminalError(err.message, { errorCode: 400 });\n   *       }\n   *\n   *       // Any other error is retryable\n   *     }\n   *   }\n   * });\n   * ```\n   */\n  asTerminalError?: (error: any) => TerminalError | undefined;\n\n  /**\n   * Default serde to use for requests, responses, state, side effects, awakeables, promises. Used when no other serde is specified.\n   *\n   * If not provided, defaults to `serde.json`.\n   */\n  serde?: Serde<any>;\n};\n\n/**\n * Define a Restate service.\n *\n * @example Here is an example of how to define a service:\n *\n * ```ts\n * const greeter = service({\n *   name: \"greeter\",\n *   handlers: {\n *     greet: async (ctx: Context, name: string) => {\n *       return `Hello ${name}`;\n *     }\n *   }\n * });\n * ```\n *\n * To use the service, you can bind it to an endpoint:\n * ```\n * ...\n * endpoint.bind(greeter)\n * ```\n * @example To use a service, you can export its type to be used in a client:\n * ```\n * export type Greeter = typeof greeter;\n * ...\n * ...\n * import type { Greeter } from \"./greeter\";\n * const client = ctx.serviceClient<Greeter>({ name : \"greeter\"});\n * client.greet(\"World\").then(console.log);\n * ```\n *\n * @example Alternatively to avoid repeating the service name, you can:\n * ```\n * import type {Greeter} from \"./greeter\";\n * const Greeter: Greeter = { name : \"greeter\"};\n *\n * // now you can reference the service like this:\n * const client = ctx.serviceClient(Greeter);\n * ```\n *\n * @param name the service name\n * @param handlers the handlers for the service\n * @param description an optional description for the service\n * @param metadata an optional metadata for the service\n * @type P the name of the service\n * @type M the handlers for the service\n */\nexport const service = <P extends string, M>(service: {\n  name: P;\n  handlers: ServiceOpts<M> & ThisType<M>;\n  description?: string;\n  metadata?: Record<string, string>;\n  options?: ServiceOptions;\n}): ServiceDefinition<P, M> => {\n  if (!service.handlers) {\n    throw new Error(\"service must be defined\");\n  }\n  const handlers = Object.entries(service.handlers).map(([name, handler]) => {\n    if (handler instanceof Function) {\n      if (HandlerWrapper.fromHandler(handler) !== undefined) {\n        return [name, handler];\n      }\n      return [\n        name,\n        HandlerWrapper.from(HandlerKind.SERVICE, handler).transpose(),\n      ];\n    }\n    throw new TypeError(`Unexpected handler type ${name}`);\n  });\n\n  return {\n    name: service.name,\n    service: Object.fromEntries(handlers) as object,\n    metadata: service.metadata,\n    description: service.description,\n    options: service.options,\n  } as ServiceDefinition<P, M>;\n};\n\n// ----------- objects ----------------------------------------------\n\nexport type ObjectOpts<U> = {\n  [K in keyof U]: U[K] extends ObjectHandler<U[K], ObjectContext<any>>\n    ? U[K]\n    : U[K] extends ObjectHandler<U[K], ObjectSharedContext<any>>\n      ? U[K]\n      :\n          | ObjectHandler<U[K], ObjectContext<any>>\n          | ObjectHandler<U[K], ObjectSharedContext<any>>;\n};\n\nexport type ObjectOptions = ServiceOptions & {\n  /**\n   * When set to `true`, lazy state will be enabled for all invocations to this service.\n   *\n   * *NOTE:* You can set this field only if you register this endpoint against restate-server >= 1.4,\n   * otherwise the service discovery will fail.\n   */\n  enableLazyState?: boolean;\n};\n\n/**\n * Define a Restate virtual object.\n *\n * @example Here is an example of how to define a virtual object:\n * ```ts\n *        const counter = object({\n *            name: \"counter\",\n *            handlers: {\n *                  add: async (ctx: ObjectContext, amount: number) => {},\n *                  get: async (ctx: ObjectContext) => {}\n *            }\n *        })\n *  ```\n *\n * @example To use the object, you can bind it to an endpoint:\n * ```ts\n * ...\n * endpoint.bind(counter)\n * ```\n *\n *  @see to interact with the object, you can use the object client:\n * ```ts\n * ...\n * const client = ctx.objectClient<typeof counter>({ name: \"counter\"});\n * const res = await client.add(1)\n * ```\n *\n * ### Shared handlers\n *\n * Shared handlers are used to allow concurrent read-only access to the object.\n * This is useful when you want to allow multiple clients to read the object's state at the same time.\n * To define a shared handler, you can use the `shared` decorator as shown below:\n *\n * ```ts\n *      const counter = object({\n *          name: \"counter\",\n *          handlers: {\n *\n *            add: async (ctx: ObjectContext, amount: number) => { .. },\n *\n *            get: handlers.object.shared(async (ctx: ObjectSharedContext) => {\n *                  return ctx.get<number>(\"count\");\n *            })\n *       }\n *     });\n * ```\n *\n * @param name the name of the object\n * @param handlers the handlers for the object\n * @param description an optional description for the object\n * @param metadata an optional metadata for the object\n * @type P the name of the object\n * @type M the handlers for the object\n */\nexport const object = <P extends string, M>(object: {\n  name: P;\n  handlers: ObjectOpts<M> & ThisType<M>;\n  description?: string;\n  metadata?: Record<string, string>;\n  options?: ObjectOptions;\n}): VirtualObjectDefinition<P, M> => {\n  if (!object.handlers) {\n    throw new Error(\"object options must be defined\");\n  }\n\n  const handlers = Object.entries(object.handlers).map(([name, handler]) => {\n    if (handler instanceof Function) {\n      if (HandlerWrapper.fromHandler(handler) !== undefined) {\n        return [name, handler];\n      }\n\n      return [\n        name,\n        HandlerWrapper.from(HandlerKind.EXCLUSIVE, handler).transpose(),\n      ];\n    }\n    throw new TypeError(`Unexpected handler type ${name}`);\n  });\n\n  return {\n    name: object.name,\n    object: Object.fromEntries(handlers) as object,\n    metadata: object.metadata,\n    description: object.description,\n    options: object.options,\n  } as VirtualObjectDefinition<P, M>;\n};\n\n// ----------- workflows ----------------------------------------------\n\n/**\n * A workflow handlers is a type that describes the handlers for a workflow.\n * The handlers must contain exactly one handler named 'run', and this handler must accept as a first argument a WorkflowContext.\n * It can contain any number of additional handlers, which must accept as a first argument a WorkflowSharedContext.\n * The handlers can not be named 'workflowSubmit', 'workflowAttach', 'workflowOutput' - as these are reserved.\n * @see {@link workflow} for an example.\n */\nexport type WorkflowOpts<U> = {\n  run: (ctx: WorkflowContext<any>, argument: any) => Promise<any>;\n} & {\n  [K in keyof U]: K extends\n    | \"workflowSubmit\"\n    | \"workflowAttach\"\n    | \"workflowOutput\"\n    ? `${K} is a reserved keyword`\n    : K extends \"run\"\n      ? U[K] extends WorkflowHandler<U[K], WorkflowContext<any>>\n        ? U[K]\n        : \"An handler named 'run' must take as a first argument a WorkflowContext, and must return a Promise\"\n      : U[K] extends WorkflowSharedHandler<U[K], WorkflowSharedContext<any>>\n        ? U[K]\n        : \"An handler other then 'run' must accept as a first argument a WorkflowSharedContext\";\n};\n\nexport type WorkflowOptions = ServiceOptions & {\n  /**\n   * The retention duration for this workflow.\n   *\n   * *NOTE:* You can set this field only if you register this endpoint against restate-server >= 1.4,\n   * otherwise the service discovery will fail.\n   */\n  workflowRetention?: Duration | number;\n  /**\n   * When set to `true`, lazy state will be enabled for all invocations to this service.\n   *\n   * *NOTE:* You can set this field only if you register this endpoint against restate-server >= 1.4,\n   * otherwise the service discovery will fail.\n   */\n  enableLazyState?: boolean;\n};\n\n/**\n * Define a Restate workflow.\n *\n *\n * @example Here is an example of how to define a workflow:\n * ```ts\n * const mywf = workflow({\n *   name: \"mywf\",\n *   handlers: {\n *     run: async (ctx: WorkflowContext, argument: any) => {\n *       return \"Hello World\";\n *     }\n *   }\n * });\n * ```\n *\n * ### Note:\n * * That a workflow must contain exactly one handler named 'run', and this handler must accept as a first argument a WorkflowContext.\n * * The workflow handlers other than 'run' must accept as a first argument a WorkflowSharedContext.\n * * The workflow handlers can not be named 'workflowSubmit', 'workflowAttach', 'workflowOutput' - as these are reserved keywords.\n *\n * @example To use the workflow, you can bind it to an endpoint:\n * ```ts\n * endpoint.bind(mywf)\n * ```\n *\n * @example To interact with the workflow, you can use the workflow client:\n * ```ts\n * const client = ctx.workflowClient<typeof mywf>({ name: \"mywf\"});\n * const res = await client.run(\"Hello\");\n * ```\n *\n * To use the workflow client from any other environment (like a browser), please refer to the documentation.\n * https://docs.restate.dev\n *\n *\n *\n * @param name the workflow name\n * @param handlers the handlers for the workflow.\n */\nexport const workflow = <P extends string, M>(workflow: {\n  name: P;\n  handlers: WorkflowOpts<M> & ThisType<M>;\n  description?: string;\n  metadata?: Record<string, string>;\n  options?: WorkflowOptions;\n}): WorkflowDefinition<P, M> => {\n  if (!workflow.handlers) {\n    throw new Error(\"workflow must contain handlers\");\n  }\n\n  //\n  // Add the main 'run' handler\n  //\n  const runHandler = workflow.handlers[\"run\"];\n  let runWrapper: HandlerWrapper;\n\n  if (runHandler instanceof HandlerWrapper) {\n    runWrapper = runHandler;\n  } else if (runHandler instanceof Function) {\n    runWrapper =\n      HandlerWrapper.fromHandler(runHandler) ??\n      HandlerWrapper.from(HandlerKind.WORKFLOW, runHandler);\n  } else {\n    throw new TypeError(`Missing main workflow handler, named 'run'`);\n  }\n  if (runWrapper.kind !== HandlerKind.WORKFLOW) {\n    throw new TypeError(\n      `Workflow's main handler handler run, must be of type workflow'`\n    );\n  }\n\n  const handlers = [[\"run\", runWrapper.transpose()]];\n\n  //\n  // Add all the shared handlers now\n  //\n\n  for (const [name, handler] of Object.entries(workflow.handlers)) {\n    if (name === \"run\") {\n      continue;\n    }\n    let wrapper: HandlerWrapper;\n\n    if (handler instanceof HandlerWrapper) {\n      wrapper = handler;\n    } else if (handler instanceof Function) {\n      wrapper =\n        HandlerWrapper.fromHandler(handler) ??\n        HandlerWrapper.from(HandlerKind.SHARED, handler);\n    } else {\n      throw new TypeError(`Unexpected handler type ${name}`);\n    }\n    if (wrapper.kind === HandlerKind.WORKFLOW) {\n      throw new TypeError(\n        `A workflow must contain exactly one handler annotated as workflow, named 'run'. Please use a shared handler for any additional handlers`\n      );\n    }\n    handlers.push([name, wrapper.transpose()]);\n  }\n\n  return {\n    name: workflow.name,\n    workflow: Object.fromEntries(handlers) as object,\n    metadata: workflow.metadata,\n    description: workflow.description,\n    options: workflow.options,\n  } as WorkflowDefinition<P, M>;\n};\n"],"mappings":"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"}

package/dist/user_agent.cjs

@@ -0,0 +1,7 @@
+const require_package = require('./package.cjs');
+
+//#region src/user_agent.ts
+const X_RESTATE_SERVER = `restate-sdk-typescript/${require_package.version}`;
+
+//#endregion
+exports.X_RESTATE_SERVER = X_RESTATE_SERVER;

package/dist/user_agent.js

@@ -0,0 +1,8 @@
+import { version } from "./package.js";
+
+//#region src/user_agent.ts
+const X_RESTATE_SERVER = `restate-sdk-typescript/${version}`;
+
+//#endregion
+export { X_RESTATE_SERVER };
+//# sourceMappingURL=user_agent.js.map

package/dist/user_agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user_agent.js","names":["pkg.version"],"sources":["../src/user_agent.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\nimport pkg from \"../package.json\" with { type: \"json\" };\n\nexport const X_RESTATE_SERVER = `restate-sdk-typescript/${pkg.version}`;\n"],"mappings":";;;AAaA,MAAa,mBAAmB,0BAA0BA"}

package/dist/utils/completable_promise.cjs

@@ -0,0 +1,22 @@
+
+//#region src/utils/completable_promise.ts
+var CompletablePromise = class {
+	success;
+	failure;
+	promise;
+	constructor() {
+		this.promise = new Promise((resolve, reject) => {
+			this.success = resolve;
+			this.failure = reject;
+		});
+	}
+	resolve(value) {
+		this.success(value);
+	}
+	reject(reason) {
+		this.failure(reason);
+	}
+};
+
+//#endregion
+exports.CompletablePromise = CompletablePromise;

package/dist/utils/completable_promise.js

@@ -0,0 +1,22 @@
+//#region src/utils/completable_promise.ts
+var CompletablePromise = class {
+	success;
+	failure;
+	promise;
+	constructor() {
+		this.promise = new Promise((resolve, reject) => {
+			this.success = resolve;
+			this.failure = reject;
+		});
+	}
+	resolve(value) {
+		this.success(value);
+	}
+	reject(reason) {
+		this.failure(reason);
+	}
+};
+
+//#endregion
+export { CompletablePromise };
+//# sourceMappingURL=completable_promise.js.map

package/dist/utils/completable_promise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"completable_promise.js","names":[],"sources":["../../src/utils/completable_promise.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// Like https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers\n// (not yet available in node)\nexport class CompletablePromise<T> {\n  private success!: (value: T | PromiseLike<T>) => void;\n  private failure!: (reason?: unknown) => void;\n\n  public readonly promise: Promise<T>;\n\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.success = resolve;\n      this.failure = reject;\n    });\n  }\n\n  public resolve(value: T) {\n    this.success(value);\n  }\n\n  public reject(reason?: unknown) {\n    this.failure(reason);\n  }\n}\n"],"mappings":";AAaA,IAAa,qBAAb,MAAmC;CACjC,AAAQ;CACR,AAAQ;CAER,AAAgB;CAEhB,cAAc;AACZ,OAAK,UAAU,IAAI,SAAS,SAAS,WAAW;AAC9C,QAAK,UAAU;AACf,QAAK,UAAU;IACf;;CAGJ,AAAO,QAAQ,OAAU;AACvB,OAAK,QAAQ,MAAM;;CAGrB,AAAO,OAAO,QAAkB;AAC9B,OAAK,QAAQ,OAAO"}

package/dist/utils/rand.cjs

@@ -0,0 +1,72 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let node_buffer = require("node:buffer");
+node_buffer = require_rolldown_runtime.__toESM(node_buffer);
+
+//#region src/utils/rand.ts
+var RandImpl = class RandImpl {
+	randstate256;
+	constructor(id, checkState = () => void 0) {
+		this.checkState = checkState;
+		if (typeof id === "bigint") {
+			let x = id & RandImpl.U64_MASK;
+			const next = () => {
+				x = x + 11400714819323198485n & RandImpl.U64_MASK;
+				let z = x;
+				z ^= z >> 30n;
+				z = z * 13787848793156543929n & RandImpl.U64_MASK;
+				z ^= z >> 27n;
+				z = z * 10723151780598845931n & RandImpl.U64_MASK;
+				z ^= z >> 31n;
+				return z & RandImpl.U64_MASK;
+			};
+			this.randstate256 = [
+				next(),
+				next(),
+				next(),
+				next()
+			];
+		} else this.randstate256 = id;
+	}
+	static U64_MASK = (1n << 64n) - 1n;
+	u64() {
+		const result = RandImpl.rotl(this.randstate256[0] + this.randstate256[3] & RandImpl.U64_MASK, 23n) + this.randstate256[0] & RandImpl.U64_MASK;
+		const t = this.randstate256[1] << 17n & RandImpl.U64_MASK;
+		this.randstate256[2] ^= this.randstate256[0];
+		this.randstate256[3] ^= this.randstate256[1];
+		this.randstate256[1] ^= this.randstate256[2];
+		this.randstate256[0] ^= this.randstate256[3];
+		this.randstate256[2] ^= t;
+		this.randstate256[3] = RandImpl.rotl(this.randstate256[3], 45n);
+		return result;
+	}
+	static rotl(x, k) {
+		return x << k & RandImpl.U64_MASK | x >> 64n - k;
+	}
+	static U53_MASK = (1n << 53n) - 1n;
+	random() {
+		this.checkState("rand.random");
+		const u53 = this.u64() & RandImpl.U53_MASK;
+		return Number(u53) / 2 ** 53;
+	}
+	uuidv4() {
+		this.checkState("rand.uuidv4");
+		const buf = node_buffer.Buffer.alloc(16);
+		buf.writeBigUInt64LE(this.u64(), 0);
+		buf.writeBigUInt64LE(this.u64(), 8);
+		buf[6] = buf[6] & 15 | 64;
+		buf[8] = buf[8] & 63 | 128;
+		return uuidStringify(buf);
+	}
+};
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
+/**
+* Convert array of 16 byte values to UUID string format of the form:
+* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+*/
+function uuidStringify(arr, offset = 0) {
+	return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+//#endregion
+exports.RandImpl = RandImpl;