@restatedev/restate-sdk-cloudflare-workers 1.17.3 → 1.18.0

package/dist/endpoint/handlers/vm/sdk_shared_core_wasm_bindings_bg.wasm.d.ts

@@ -29,7 +29,7 @@ export const wasmvm_is_completed: (a: number, b: number) => number;
 export const wasmvm_is_processing: (a: number) => number;
 export const wasmvm_is_ready_to_execute: (a: number) => [number, number, number];
 export const wasmvm_last_command_index: (a: number) => number;
-export const wasmvm_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+export const wasmvm_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
 export const wasmvm_notify_error: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wasmvm_notify_error_for_next_command: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const wasmvm_notify_error_for_specific_command: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
@@ -45,8 +45,8 @@ export const wasmvm_sys_attach_invocation: (a: number, b: number, c: number) =>
 export const wasmvm_sys_awakeable: (a: number) => [number, number, number];
 export const wasmvm_sys_call: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number) => [number, number, number];
 export const wasmvm_sys_cancel_invocation: (a: number, b: number, c: number) => [number, number];
-export const wasmvm_sys_clear_all_state: (a: number) => [number, number];
-export const wasmvm_sys_clear_state: (a: number, b: number, c: number) => [number, number];
+export const wasmvm_sys_clear_all_state: (a: number, b: number, c: number) => [number, number];
+export const wasmvm_sys_clear_state: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const wasmvm_sys_complete_awakeable_failure: (a: number, b: number, c: number, d: any) => [number, number];
 export const wasmvm_sys_complete_awakeable_success: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const wasmvm_sys_complete_promise_failure: (a: number, b: number, c: number, d: any) => [number, number, number];
@@ -56,13 +56,13 @@ export const wasmvm_sys_complete_signal_success: (a: number, b: number, c: numbe
 export const wasmvm_sys_end: (a: number) => [number, number];
 export const wasmvm_sys_get_invocation_output: (a: number, b: number, c: number) => [number, number, number];
 export const wasmvm_sys_get_promise: (a: number, b: number, c: number) => [number, number, number];
-export const wasmvm_sys_get_state: (a: number, b: number, c: number) => [number, number, number];
-export const wasmvm_sys_get_state_keys: (a: number) => [number, number, number];
+export const wasmvm_sys_get_state: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+export const wasmvm_sys_get_state_keys: (a: number, b: number, c: number) => [number, number, number];
 export const wasmvm_sys_input: (a: number) => [number, number, number];
 export const wasmvm_sys_peek_promise: (a: number, b: number, c: number) => [number, number, number];
 export const wasmvm_sys_run: (a: number, b: number, c: number) => [number, number, number];
 export const wasmvm_sys_send: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: bigint, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number) => [number, number, number];
-export const wasmvm_sys_set_state: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const wasmvm_sys_set_state: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
 export const wasmvm_sys_signal: (a: number, b: number, c: number) => [number, number, number];
 export const wasmvm_sys_sleep: (a: number, b: bigint, c: number, d: number) => [number, number, number];
 export const wasmvm_sys_write_output_failure: (a: number, b: any) => [number, number];

package/dist/fetch.d.cts

@@ -1,7 +1,7 @@
 import { CancelledError, PauseError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.cjs";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
-import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.cjs";
-import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request as Request$1, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
+import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, StatePreload, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.cjs";
+import { Context, ContextDate, DurablePromise, EntryOptions, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request as Request$1, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.cjs";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.cjs";
 import { internal_d_exports } from "./internal.cjs";
@@ -52,5 +52,5 @@ interface FetchEndpointOptions extends EndpointOptions {
  */
 declare function createEndpointHandler(options: FetchEndpointOptions): (request: Request, ...extraArgs: unknown[]) => Promise<Response>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, type FetchEndpoint, FetchEndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request$1 as Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, EntryOptions, type FetchEndpoint, FetchEndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request$1 as Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, StatePreload, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
 //# sourceMappingURL=fetch.d.cts.map

package/dist/fetch.d.ts

@@ -1,7 +1,7 @@
 import { CancelledError, PauseError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.js";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
-import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
-import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request as Request$1, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
+import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, StatePreload, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
+import { Context, ContextDate, DurablePromise, EntryOptions, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request as Request$1, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
 import { internal_d_exports } from "./internal.js";
@@ -52,5 +52,5 @@ interface FetchEndpointOptions extends EndpointOptions {
  */
 declare function createEndpointHandler(options: FetchEndpointOptions): (request: Request, ...extraArgs: unknown[]) => Promise<Response>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, type FetchEndpoint, FetchEndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request$1 as Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, EntryOptions, type FetchEndpoint, FetchEndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request$1 as Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, StatePreload, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
 //# sourceMappingURL=fetch.d.ts.map

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { CancelledError, PauseError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.cjs";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
-import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.cjs";
-import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
+import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, StatePreload, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.cjs";
+import { Context, ContextDate, DurablePromise, EntryOptions, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.cjs";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.cjs";
 import { internal_d_exports } from "./internal.cjs";
@@ -10,4 +10,4 @@ import { FnOf, ObjectImplHandlers, ObjectPerHandlerOpts, ServiceImplHandlers, Se
 import { EndpointOptions } from "./endpoint/types.cjs";
 import { CombineablePromise, Descriptor, DescriptorOpts, Duration, HandlerDescriptor, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferInput, InferOutput, JournalValueCodec, ObjectDescriptor, ObjectHandler, RestateContext, RestateObjectContext, RestateObjectSharedContext, RestateWorkflowContext, RestateWorkflowSharedContext, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceInterface, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowSharedHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, iface, serde } from "./common_api.cjs";
 import { NodeEndpointOptions, ServeOptions, createEndpointHandler, endpoint, serve } from "./node.cjs";
-export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, EntryOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, StatePreload, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { CancelledError, PauseError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.js";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
-import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
-import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
+import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, StatePreload, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
+import { Context, ContextDate, DurablePromise, EntryOptions, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
 import { internal_d_exports } from "./internal.js";
@@ -10,4 +10,4 @@ import { FnOf, ObjectImplHandlers, ObjectPerHandlerOpts, ServiceImplHandlers, Se
 import { EndpointOptions } from "./endpoint/types.js";
 import { CombineablePromise, Descriptor, DescriptorOpts, Duration, HandlerDescriptor, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferInput, InferOutput, JournalValueCodec, ObjectDescriptor, ObjectHandler, RestateContext, RestateObjectContext, RestateObjectSharedContext, RestateWorkflowContext, RestateWorkflowSharedContext, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceInterface, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowSharedHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, iface, serde } from "./common_api.js";
 import { NodeEndpointOptions, ServeOptions, createEndpointHandler, endpoint, serve } from "./node.js";
-export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, EntryOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, StatePreload, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };

package/dist/internal.cjs

@@ -1,12 +1,39 @@
 const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const require_errors = require('./types/errors.cjs');
+const require_components = require('./endpoint/components.cjs');
 
 //#region src/internal.ts
 var internal_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
 	asInternal: () => asInternal,
+	explicitRecovery: () => explicitRecovery,
 	isSuspendedError: () => require_errors.isSuspendedError
 });
 /**
+* Run the handlers with explicit recovery: a retried or resumed invocation doesn't replay the journal of its earlier attempts,
+* but runs the handler again from the start, executing every context operation anew, e.g. reading the current state.
+*
+* The handler takes care of recovering from the effects of the earlier attempts, which might repeat (at least once):
+* * Each attempt's calls and sends are new requests. To reach the invocation an earlier attempt started, give it an idempotency key that is the same on every attempt, such as one made from `ctx.request().id`.
+* * `ctx.run` executes its action again on every attempt.
+* * Awakeables are not supported.
+*
+* Spread the returned options into the service or handler options. Handler options take precedence over service options.
+*
+* @example
+* ```ts
+* const counter = restate.object({
+*   name: "counter",
+*   handlers: { ... },
+*   options: { ...restate.internal.explicitRecovery() },
+* });
+* ```
+*
+* @experimental
+*/
+function explicitRecovery() {
+	return { [require_components.EXPLICIT_RECOVERY]: true };
+}
+/**
 * Downcast the given context to {@link ContextInternal}, to access the internal APIs.
 *
 * Works with every context type passed to handlers, e.g. `Context`, `ObjectContext`, `ObjectSharedContext`, `WorkflowContext`.

package/dist/internal.d.cts

@@ -4,8 +4,37 @@ import { Serde } from "@restatedev/restate-sdk-core";
 
 //#region src/internal.d.ts
 declare namespace internal_d_exports {
-  export { ContextInternal, GetProjectOptions, asInternal, isSuspendedError };
+  export { ContextInternal, ExplicitRecoveryOptions, GetProjectOptions, asInternal, explicitRecovery, isSuspendedError };
 }
+/**
+ * Options set by {@link explicitRecovery}, to spread into the options of a service, virtual object, workflow or handler.
+ *
+ * @experimental
+ */
+type ExplicitRecoveryOptions = Record<never, never>;
+/**
+ * Run the handlers with explicit recovery: a retried or resumed invocation doesn't replay the journal of its earlier attempts,
+ * but runs the handler again from the start, executing every context operation anew, e.g. reading the current state.
+ *
+ * The handler takes care of recovering from the effects of the earlier attempts, which might repeat (at least once):
+ * * Each attempt's calls and sends are new requests. To reach the invocation an earlier attempt started, give it an idempotency key that is the same on every attempt, such as one made from `ctx.request().id`.
+ * * `ctx.run` executes its action again on every attempt.
+ * * Awakeables are not supported.
+ *
+ * Spread the returned options into the service or handler options. Handler options take precedence over service options.
+ *
+ * @example
+ * ```ts
+ * const counter = restate.object({
+ *   name: "counter",
+ *   handlers: { ... },
+ *   options: { ...restate.internal.explicitRecovery() },
+ * });
+ * ```
+ *
+ * @experimental
+ */
+declare function explicitRecovery(): ExplicitRecoveryOptions;
 /**
  * Downcast the given context to {@link ContextInternal}, to access the internal APIs.
  *

package/dist/internal.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.cts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AAiBA;AAWA;;AA2GwC,iBAtHxB,UAAA,CAsHwB,GAAA,EAtHR,OAsHQ,CAAA,EAtHE,eAsHF;;;;;;;;AAmC1B,UA9IG,eAAA,SAAwB,OA8I3B,CAAA;EACM;;;;AAQpB;;;;EAYgB,YAAA,EAAA,EAAA,OAAA;EAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAnEH;;;;;;;;;;yBAWO,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAkChB,kBAAkB,UAAU,QAAQ,oBAC9C,kBAAkB,QAAQ,WACnC,eAAe;;;;;;;KAQR;;;;UAIF,MAAM;;;;;;;gBAQA,MAAM"}
+{"version":3,"file":"internal.d.cts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;KAWY,uBAAA,GAA0B;;;;;;AAAtC;AAwBA;AAiBA;AAWA;;;;;;;;;;;;;;AAAgD,iBA5BhC,gBAAA,CAAA,CA4BgC,EA5BZ,uBA4BY;AAuJhD;;;;;;;;;;;;iBAlKgB,UAAA,MAAgB,UAAU;;;;;;;;UAWzB,eAAA,SAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGvB;;;;;;;;;;yBAWO,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAkChB,kBAAkB,UAAU,QAAQ,oBAC9C,kBAAkB,QAAQ,WACnC,eAAe;;;;;;;KAQR;;;;UAIF,MAAM;;;;;;;gBAQA,MAAM"}

package/dist/internal.d.ts

@@ -4,8 +4,37 @@ import { Serde } from "@restatedev/restate-sdk-core";
 
 //#region src/internal.d.ts
 declare namespace internal_d_exports {
-  export { ContextInternal, GetProjectOptions, asInternal, isSuspendedError };
+  export { ContextInternal, ExplicitRecoveryOptions, GetProjectOptions, asInternal, explicitRecovery, isSuspendedError };
 }
+/**
+ * Options set by {@link explicitRecovery}, to spread into the options of a service, virtual object, workflow or handler.
+ *
+ * @experimental
+ */
+type ExplicitRecoveryOptions = Record<never, never>;
+/**
+ * Run the handlers with explicit recovery: a retried or resumed invocation doesn't replay the journal of its earlier attempts,
+ * but runs the handler again from the start, executing every context operation anew, e.g. reading the current state.
+ *
+ * The handler takes care of recovering from the effects of the earlier attempts, which might repeat (at least once):
+ * * Each attempt's calls and sends are new requests. To reach the invocation an earlier attempt started, give it an idempotency key that is the same on every attempt, such as one made from `ctx.request().id`.
+ * * `ctx.run` executes its action again on every attempt.
+ * * Awakeables are not supported.
+ *
+ * Spread the returned options into the service or handler options. Handler options take precedence over service options.
+ *
+ * @example
+ * ```ts
+ * const counter = restate.object({
+ *   name: "counter",
+ *   handlers: { ... },
+ *   options: { ...restate.internal.explicitRecovery() },
+ * });
+ * ```
+ *
+ * @experimental
+ */
+declare function explicitRecovery(): ExplicitRecoveryOptions;
 /**
  * Downcast the given context to {@link ContextInternal}, to access the internal APIs.
  *

package/dist/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AAiBA;AAWA;;AA2GwC,iBAtHxB,UAAA,CAsHwB,GAAA,EAtHR,OAsHQ,CAAA,EAtHE,eAsHF;;;;;;;;AAmC1B,UA9IG,eAAA,SAAwB,OA8I3B,CAAA;EACM;;;;AAQpB;;;;EAYgB,YAAA,EAAA,EAAA,OAAA;EAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAnEH;;;;;;;;;;yBAWO,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAkChB,kBAAkB,UAAU,QAAQ,oBAC9C,kBAAkB,QAAQ,WACnC,eAAe;;;;;;;KAQR;;;;UAIF,MAAM;;;;;;;gBAQA,MAAM"}
+{"version":3,"file":"internal.d.ts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;KAWY,uBAAA,GAA0B;;;;;;AAAtC;AAwBA;AAiBA;AAWA;;;;;;;;;;;;;;AAAgD,iBA5BhC,gBAAA,CAAA,CA4BgC,EA5BZ,uBA4BY;AAuJhD;;;;;;;;;;;;iBAlKgB,UAAA,MAAgB,UAAU;;;;;;;;UAWzB,eAAA,SAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGvB;;;;;;;;;;yBAWO,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAkChB,kBAAkB,UAAU,QAAQ,oBAC9C,kBAAkB,QAAQ,WACnC,eAAe;;;;;;;KAQR;;;;UAIF,MAAM;;;;;;;gBAQA,MAAM"}

package/dist/internal.js

@@ -1,12 +1,39 @@
 import { __export } from "./_virtual/rolldown_runtime.js";
 import { isSuspendedError } from "./types/errors.js";
+import { EXPLICIT_RECOVERY } from "./endpoint/components.js";
 
 //#region src/internal.ts
 var internal_exports = /* @__PURE__ */ __export({
 	asInternal: () => asInternal,
+	explicitRecovery: () => explicitRecovery,
 	isSuspendedError: () => isSuspendedError
 });
 /**
+* Run the handlers with explicit recovery: a retried or resumed invocation doesn't replay the journal of its earlier attempts,
+* but runs the handler again from the start, executing every context operation anew, e.g. reading the current state.
+*
+* The handler takes care of recovering from the effects of the earlier attempts, which might repeat (at least once):
+* * Each attempt's calls and sends are new requests. To reach the invocation an earlier attempt started, give it an idempotency key that is the same on every attempt, such as one made from `ctx.request().id`.
+* * `ctx.run` executes its action again on every attempt.
+* * Awakeables are not supported.
+*
+* Spread the returned options into the service or handler options. Handler options take precedence over service options.
+*
+* @example
+* ```ts
+* const counter = restate.object({
+*   name: "counter",
+*   handlers: { ... },
+*   options: { ...restate.internal.explicitRecovery() },
+* });
+* ```
+*
+* @experimental
+*/
+function explicitRecovery() {
+	return { [EXPLICIT_RECOVERY]: true };
+}
+/**
 * Downcast the given context to {@link ContextInternal}, to access the internal APIs.
 *
 * Works with every context type passed to handlers, e.g. `Context`, `ObjectContext`, `ObjectSharedContext`, `WorkflowContext`.

package/dist/internal.js.map

@@ -1 +1 @@
-{"version":3,"file":"internal.js","names":[],"sources":["../src/internal.ts"],"sourcesContent":["import { Context, InvocationId, RestatePromise } from \"./context.js\";\nimport type { Serde } from \"@restatedev/restate-sdk-core\";\n\nexport { isSuspendedError } from \"./types/errors.js\";\n\n/**\n * Downcast the given context to {@link ContextInternal}, to access the internal APIs.\n *\n * Works with every context type passed to handlers, e.g. `Context`, `ObjectContext`, `ObjectSharedContext`, `WorkflowContext`.\n *\n * @example\n * ```ts\n * const ctxInternal = restate.internal.asInternal(ctx);\n * ```\n *\n * @experimental\n */\nexport function asInternal(ctx: Context): ContextInternal {\n  return ctx as ContextInternal;\n}\n\n/**\n * Internal {@link Context} interface exposing additional features.\n *\n * Please note that this API is to be considered experimental and might change without notice.\n *\n * @experimental\n */\nexport interface ContextInternal extends Context {\n  /**\n   * Returns true if the handler is in the processing phase.\n   * This is the mechanism used by `ctx.console` to distinguish whether we should log or not in replaying/processing.\n   *\n   * **WARNING**: This method should not be used to influence control flow, as it will **surely** lead to non-determinism errors!\n   *\n   * @experimental\n   */\n  isProcessing(): boolean;\n\n  /**\n   * Returns a {@link RestatePromise} that resolves with `undefined` when Restate signals cancellation\n   * of the current invocation.\n   *\n   * This method **MUST** only be used when the handler (or its parent service/endpoint) is configured\n   * with `explicitCancellation: true`. Without configuring this option, cancellations are propagated automatically,\n   * and this promise will **NEVER** resolve.\n   *\n   * **Promise reuse:** calling this method multiple times returns the **same** promise instance as long as\n   * the current cancellation signal has not yet arrived. Once the promise resolves (cancellation received),\n   * later calls return a **new** promise that will resolve on the next cancellation signal.\n   *\n   * @example Race a long-running side effect against cancellation\n   * ```ts\n   * const greeter = restate.service({\n   *   name: \"greeter\",\n   *   handlers: {\n   *     greet: async (ctx: restate.Context, name: string) => {\n   *       const ctxInternal = restate.internal.asInternal(ctx);\n   *       const result = await RestatePromise.race([\n   *         ctx.run(() => longRunningTask(name)),\n   *         ctxInternal.cancellation().map(() => { throw new restate.TerminalError(\"Cancelled\") }),\n   *       ]);\n   *       return result;\n   *     },\n   *   },\n   *   options: { explicitCancellation: true },\n   * });\n   * ```\n   *\n   * @example Use the cancellation promise to create an AbortSignal for ctx.run\n   * ```ts\n   * const greeter = restate.service({\n   *   name: \"greeter\",\n   *   handlers: {\n   *     greet: async (ctx: restate.Context, name: string) => {\n   *       const ctxInternal = restate.internal.asInternal(ctx);\n   *       const controller = new AbortController();\n   *       const cancellation = ctxInternal.cancellation()\n   *         .map(() => {\n   *            controller.abort();\n   *            throw new restate.TerminalError(\"Cancelled\");\n   *         });\n   *\n   *       return RestatePromise.race([\n   *         ctx.run(() => fetch(`https://api.example.com/greet/${name}`, { signal: controller.signal })),\n   *         cancellation,\n   *       ]);\n   *     },\n   *   },\n   *   options: { explicitCancellation: true },\n   * });\n   * ```\n   *\n   * @example Handle cancellation, perform cleanup, then listen for the next cancellation\n   * ```ts\n   * const greeter = restate.service({\n   *   name: \"greeter\",\n   *   handlers: {\n   *     greet: async (ctx: restate.Context, name: string) => {\n   *       const ctxInternal = restate.internal.asInternal(ctx);\n   *       try {\n   *         return await RestatePromise.race([\n   *           ctx.run(() => longRunningTask(name)),\n   *           ctxInternal.cancellation().map(() => { throw new restate.TerminalError(\"Cancelled\") }),\n   *         ]);\n   *       } catch (e) {\n   *         // Perform cleanup\n   *         await ctx.run(() => cleanupResources(name));\n   *\n   *         // After cancellation is resolved, ctx.cancellation() returns a fresh promise.\n   *         // Race cleanup confirmation against the next cancellation signal.\n   *         await RestatePromise.race([\n   *           ctx.run(() => confirmCleanup(name)),\n   *           ctxInternal.cancellation().map(() => { throw new restate.TerminalError(\"Canceled during cleanup\") }),\n   *         ]);\n   *       }\n   *     },\n   *   },\n   *   options: { explicitCancellation: true },\n   * });\n   * ```\n   *\n   * @experimental\n   */\n  cancellation(): RestatePromise<void>;\n\n  /**\n   * Cancel all previous calls made from this handler.\n   *\n   * This method **MUST** only be used when the handler (or its parent service/endpoint) is configured\n   * with `explicitCancellation: true`. Without configuring this option, this operation will always be a no-op.\n   *\n   * @return the invocation id of the canceled calls.\n   * @experimental\n   */\n  cancelPreviousCalls(): RestatePromise<InvocationId[]>;\n\n  /**\n   * Get state from the Restate runtime, apply the given `projection` to it,\n   * and record in the journal only the result of the projection.\n   *\n   * Use this to read big state values when you need only a small part of them:\n   * unlike `ctx.get`, the complete state value is not recorded in the journal,\n   * only its projection.\n   *\n   * It will appear in the UI as run(project:state_key).\n   *\n   * This method **MUST** only be used within Virtual Object and Workflow handlers.\n   *\n   * **NOTE:** Requires Restate >= 1.8 with service protocol V8 enabled, and **does not** work with request/response protocol mode (e.g. with AWS Lambda).\n   *\n   * @param name key of the state to retrieve\n   * @param projection function receiving the state value, or `null` if the state is empty.\n   * @param options serde for the state value, and serde for the projection result.\n   * @returns a {@link RestatePromise} resolved with the result of the projection.\n   *\n   * @example\n   * ```ts\n   * const ctxInternal = restate.internal.asInternal(ctx);\n   * const itemsCount = await ctxInternal.getProject<Item[], number>(\n   *   \"items\",\n   *   (items) => items?.length ?? 0\n   * );\n   * ```\n   *\n   * @experimental\n   */\n  getProject<TValue, TResult>(\n    name: string,\n    projection: (value: TValue | null) => TResult | Promise<TResult>,\n    options?: GetProjectOptions<TValue, TResult>\n  ): RestatePromise<TResult>;\n}\n\n/**\n * Options for {@link ContextInternal.getProject}.\n *\n * @experimental\n */\nexport type GetProjectOptions<TValue, TResult> = {\n  /**\n   * Serde used to deserialize the state value.\n   */\n  serde?: Serde<TValue>;\n\n  /**\n   * Serde used to serialize the projection result, recorded in the journal.\n   *\n   * If not set, defaults to {@link GetProjectOptions.serde} when that is set,\n   * otherwise to the default serde.\n   */\n  resultSerde?: Serde<TResult>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiBA,SAAgB,WAAW,KAA+B;AACxD,QAAO"}
+{"version":3,"file":"internal.js","names":[],"sources":["../src/internal.ts"],"sourcesContent":["import { Context, InvocationId, RestatePromise } from \"./context.js\";\nimport type { Serde } from \"@restatedev/restate-sdk-core\";\nimport { EXPLICIT_RECOVERY } from \"./endpoint/components.js\";\n\nexport { isSuspendedError } from \"./types/errors.js\";\n\n/**\n * Options set by {@link explicitRecovery}, to spread into the options of a service, virtual object, workflow or handler.\n *\n * @experimental\n */\nexport type ExplicitRecoveryOptions = Record<never, never>;\n\n/**\n * Run the handlers with explicit recovery: a retried or resumed invocation doesn't replay the journal of its earlier attempts,\n * but runs the handler again from the start, executing every context operation anew, e.g. reading the current state.\n *\n * The handler takes care of recovering from the effects of the earlier attempts, which might repeat (at least once):\n * * Each attempt's calls and sends are new requests. To reach the invocation an earlier attempt started, give it an idempotency key that is the same on every attempt, such as one made from `ctx.request().id`.\n * * `ctx.run` executes its action again on every attempt.\n * * Awakeables are not supported.\n *\n * Spread the returned options into the service or handler options. Handler options take precedence over service options.\n *\n * @example\n * ```ts\n * const counter = restate.object({\n *   name: \"counter\",\n *   handlers: { ... },\n *   options: { ...restate.internal.explicitRecovery() },\n * });\n * ```\n *\n * @experimental\n */\nexport function explicitRecovery(): ExplicitRecoveryOptions {\n  const options = { [EXPLICIT_RECOVERY]: true };\n  return options;\n}\n\n/**\n * Downcast the given context to {@link ContextInternal}, to access the internal APIs.\n *\n * Works with every context type passed to handlers, e.g. `Context`, `ObjectContext`, `ObjectSharedContext`, `WorkflowContext`.\n *\n * @example\n * ```ts\n * const ctxInternal = restate.internal.asInternal(ctx);\n * ```\n *\n * @experimental\n */\nexport function asInternal(ctx: Context): ContextInternal {\n  return ctx as ContextInternal;\n}\n\n/**\n * Internal {@link Context} interface exposing additional features.\n *\n * Please note that this API is to be considered experimental and might change without notice.\n *\n * @experimental\n */\nexport interface ContextInternal extends Context {\n  /**\n   * Returns true if the handler is in the processing phase.\n   * This is the mechanism used by `ctx.console` to distinguish whether we should log or not in replaying/processing.\n   *\n   * **WARNING**: This method should not be used to influence control flow, as it will **surely** lead to non-determinism errors!\n   *\n   * @experimental\n   */\n  isProcessing(): boolean;\n\n  /**\n   * Returns a {@link RestatePromise} that resolves with `undefined` when Restate signals cancellation\n   * of the current invocation.\n   *\n   * This method **MUST** only be used when the handler (or its parent service/endpoint) is configured\n   * with `explicitCancellation: true`. Without configuring this option, cancellations are propagated automatically,\n   * and this promise will **NEVER** resolve.\n   *\n   * **Promise reuse:** calling this method multiple times returns the **same** promise instance as long as\n   * the current cancellation signal has not yet arrived. Once the promise resolves (cancellation received),\n   * later calls return a **new** promise that will resolve on the next cancellation signal.\n   *\n   * @example Race a long-running side effect against cancellation\n   * ```ts\n   * const greeter = restate.service({\n   *   name: \"greeter\",\n   *   handlers: {\n   *     greet: async (ctx: restate.Context, name: string) => {\n   *       const ctxInternal = restate.internal.asInternal(ctx);\n   *       const result = await RestatePromise.race([\n   *         ctx.run(() => longRunningTask(name)),\n   *         ctxInternal.cancellation().map(() => { throw new restate.TerminalError(\"Cancelled\") }),\n   *       ]);\n   *       return result;\n   *     },\n   *   },\n   *   options: { explicitCancellation: true },\n   * });\n   * ```\n   *\n   * @example Use the cancellation promise to create an AbortSignal for ctx.run\n   * ```ts\n   * const greeter = restate.service({\n   *   name: \"greeter\",\n   *   handlers: {\n   *     greet: async (ctx: restate.Context, name: string) => {\n   *       const ctxInternal = restate.internal.asInternal(ctx);\n   *       const controller = new AbortController();\n   *       const cancellation = ctxInternal.cancellation()\n   *         .map(() => {\n   *            controller.abort();\n   *            throw new restate.TerminalError(\"Cancelled\");\n   *         });\n   *\n   *       return RestatePromise.race([\n   *         ctx.run(() => fetch(`https://api.example.com/greet/${name}`, { signal: controller.signal })),\n   *         cancellation,\n   *       ]);\n   *     },\n   *   },\n   *   options: { explicitCancellation: true },\n   * });\n   * ```\n   *\n   * @example Handle cancellation, perform cleanup, then listen for the next cancellation\n   * ```ts\n   * const greeter = restate.service({\n   *   name: \"greeter\",\n   *   handlers: {\n   *     greet: async (ctx: restate.Context, name: string) => {\n   *       const ctxInternal = restate.internal.asInternal(ctx);\n   *       try {\n   *         return await RestatePromise.race([\n   *           ctx.run(() => longRunningTask(name)),\n   *           ctxInternal.cancellation().map(() => { throw new restate.TerminalError(\"Cancelled\") }),\n   *         ]);\n   *       } catch (e) {\n   *         // Perform cleanup\n   *         await ctx.run(() => cleanupResources(name));\n   *\n   *         // After cancellation is resolved, ctx.cancellation() returns a fresh promise.\n   *         // Race cleanup confirmation against the next cancellation signal.\n   *         await RestatePromise.race([\n   *           ctx.run(() => confirmCleanup(name)),\n   *           ctxInternal.cancellation().map(() => { throw new restate.TerminalError(\"Canceled during cleanup\") }),\n   *         ]);\n   *       }\n   *     },\n   *   },\n   *   options: { explicitCancellation: true },\n   * });\n   * ```\n   *\n   * @experimental\n   */\n  cancellation(): RestatePromise<void>;\n\n  /**\n   * Cancel all previous calls made from this handler.\n   *\n   * This method **MUST** only be used when the handler (or its parent service/endpoint) is configured\n   * with `explicitCancellation: true`. Without configuring this option, this operation will always be a no-op.\n   *\n   * @return the invocation id of the canceled calls.\n   * @experimental\n   */\n  cancelPreviousCalls(): RestatePromise<InvocationId[]>;\n\n  /**\n   * Get state from the Restate runtime, apply the given `projection` to it,\n   * and record in the journal only the result of the projection.\n   *\n   * Use this to read big state values when you need only a small part of them:\n   * unlike `ctx.get`, the complete state value is not recorded in the journal,\n   * only its projection.\n   *\n   * It will appear in the UI as run(project:state_key).\n   *\n   * This method **MUST** only be used within Virtual Object and Workflow handlers.\n   *\n   * **NOTE:** Requires Restate >= 1.8 with service protocol V8 enabled, and **does not** work with request/response protocol mode (e.g. with AWS Lambda).\n   *\n   * @param name key of the state to retrieve\n   * @param projection function receiving the state value, or `null` if the state is empty.\n   * @param options serde for the state value, and serde for the projection result.\n   * @returns a {@link RestatePromise} resolved with the result of the projection.\n   *\n   * @example\n   * ```ts\n   * const ctxInternal = restate.internal.asInternal(ctx);\n   * const itemsCount = await ctxInternal.getProject<Item[], number>(\n   *   \"items\",\n   *   (items) => items?.length ?? 0\n   * );\n   * ```\n   *\n   * @experimental\n   */\n  getProject<TValue, TResult>(\n    name: string,\n    projection: (value: TValue | null) => TResult | Promise<TResult>,\n    options?: GetProjectOptions<TValue, TResult>\n  ): RestatePromise<TResult>;\n}\n\n/**\n * Options for {@link ContextInternal.getProject}.\n *\n * @experimental\n */\nexport type GetProjectOptions<TValue, TResult> = {\n  /**\n   * Serde used to deserialize the state value.\n   */\n  serde?: Serde<TValue>;\n\n  /**\n   * Serde used to serialize the projection result, recorded in the journal.\n   *\n   * If not set, defaults to {@link GetProjectOptions.serde} when that is set,\n   * otherwise to the default serde.\n   */\n  resultSerde?: Serde<TResult>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,mBAA4C;AAE1D,QADgB,GAAG,oBAAoB,MAAM;;;;;;;;;;;;;;AAgB/C,SAAgB,WAAW,KAA+B;AACxD,QAAO"}

package/dist/lambda.d.cts

@@ -1,7 +1,7 @@
 import { CancelledError, PauseError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.cjs";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
-import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.cjs";
-import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
+import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, StatePreload, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.cjs";
+import { Context, ContextDate, DurablePromise, EntryOptions, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.cjs";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.cjs";
 import { internal_d_exports } from "./internal.cjs";
@@ -32,5 +32,5 @@ declare function endpoint(): LambdaEndpoint;
  */
 declare function createEndpointHandler(options: EndpointOptions): (event: any, ctx: any) => Promise<any>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, EntryOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, StatePreload, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
 //# sourceMappingURL=lambda.d.cts.map

package/dist/lambda.d.ts

@@ -1,7 +1,7 @@
 import { CancelledError, PauseError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.js";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
-import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
-import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
+import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, StatePreload, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
+import { Context, ContextDate, DurablePromise, EntryOptions, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
 import { internal_d_exports } from "./internal.js";
@@ -32,5 +32,5 @@ declare function endpoint(): LambdaEndpoint;
  */
 declare function createEndpointHandler(options: EndpointOptions): (event: any, ctx: any) => Promise<any>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, EntryOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, StatePreload, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
 //# sourceMappingURL=lambda.d.ts.map

package/dist/node.d.cts

@@ -1,7 +1,7 @@
 import { CancelledError, PauseError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.cjs";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
-import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.cjs";
-import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
+import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, StatePreload, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.cjs";
+import { Context, ContextDate, DurablePromise, EntryOptions, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.cjs";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.cjs";
 import { internal_d_exports } from "./internal.cjs";
@@ -87,5 +87,5 @@ declare function serve({
   ...options
 }: ServeOptions): Promise<number>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, EntryOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, StatePreload, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
 //# sourceMappingURL=node.d.cts.map

package/dist/node.d.ts

@@ -1,7 +1,7 @@
 import { CancelledError, PauseError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.js";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
-import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
-import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
+import { Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, SendClientFromDescriptors, SendOpts, ServiceHandlerOpts, ServiceOptions, ServiceOpts, StatePreload, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
+import { Context, ContextDate, DurablePromise, EntryOptions, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, ScopedContext, SignalReference, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
 import { internal_d_exports } from "./internal.js";
@@ -87,5 +87,5 @@ declare function serve({
   ...options
 }: ServeOptions): Promise<number>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientFromDescriptors, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, Descriptor, DescriptorOpts, DurablePromise, Duration, EndpointOptions, EntryOptions, FnOf, GenericCall, GenericSend, HandlerDescriptor, Hooks, HooksProvider, ImplementedDefinition, ImplementedObjectDefinition, ImplementedServiceDefinition, ImplementedWorkflowDefinition, InferArg, InferInput, InferOutput, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectDescriptor, ObjectHandler, ObjectHandlerOpts, ObjectImplHandlers, ObjectOptions, ObjectOpts, ObjectPerHandlerOpts, ObjectSharedContext, Opts, PauseError, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, ScopedContext, SendClient, SendClientFromDescriptors, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceDescriptor, ServiceHandler, ServiceHandlerOpts, ServiceImplHandlers, ServiceInterface, ServiceOptions, ServiceOpts, ServicePerHandlerOpts, SignalReference, StatePreload, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowDescriptor, WorkflowHandler, WorkflowHandlerOpts, WorkflowImplHandlers, WorkflowOptions, WorkflowOpts, WorkflowPerHandlerOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, iface, implement, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
 //# sourceMappingURL=node.d.ts.map

package/dist/package.cjs

@@ -1,6 +1,6 @@
 
 //#region package.json
-var version = "1.17.3";
+var version = "1.18.0";
 
 //#endregion
 Object.defineProperty(exports, 'version', {

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "1.17.3";
+var version = "1.18.0";
 
 //#endregion
 export { version };

package/dist/package.js.map

@@ -1 +1 @@
-{"version":3,"file":"package.js","names":[],"sources":["../package.json"],"sourcesContent":["{\n  \"name\": \"@restatedev/restate-sdk\",\n  \"version\": \"1.17.3\",\n  \"description\": \"Typescript SDK for Restate\",\n  \"author\": \"Restate Developers\",\n  \"email\": \"code@restate.dev\",\n  \"license\": \"MIT\",\n  \"homepage\": \"https://github.com/restatedev/sdk-typescript#readme\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/restatedev/sdk-typescript.git\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/restatedev/sdk-typescript/issues\"\n  },\n  \"type\": \"module\",\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.cts\",\n  \"exports\": {\n    \".\": {\n      \"import\": \"./dist/index.js\",\n      \"require\": \"./dist/index.cjs\"\n    },\n    \"./fetch\": {\n      \"import\": \"./dist/fetch.js\",\n      \"require\": \"./dist/fetch.cjs\"\n    },\n    \"./lambda\": {\n      \"import\": \"./dist/lambda.js\",\n      \"require\": \"./dist/lambda.cjs\"\n    },\n    \"./node\": {\n      \"import\": \"./dist/node.js\",\n      \"require\": \"./dist/node.cjs\"\n    },\n    \"./package.json\": \"./package.json\"\n  },\n  \"files\": [\n    \"dist\",\n    \"README.md\"\n  ],\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"scripts\": {\n    \"test\": \"turbo run _test --filter={.}...\",\n    \"_test\": \"vitest run\",\n    \"build\": \"turbo run _build --filter={.}...\",\n    \"_build\": \"tsc --noEmit && tsdown\",\n    \"dev\": \"tsc --noEmit --watch\",\n    \"clean\": \"rm -rf dist *.tsbuildinfo .turbo\",\n    \"check:types\": \"turbo run _check:types --filter={.}...\",\n    \"_check:types\": \"tsc --noEmit --project tsconfig.build.json\",\n    \"lint\": \"eslint .\",\n    \"check:exports\": \"turbo run _check:exports --filter={.}...\",\n    \"_check:exports\": \"attw --pack .\",\n    \"check:api\": \"turbo run _check:api --filter={.}...\",\n    \"_check:api\": \"api-extractor run --local && api-extractor run --local --config api-extractor.fetch.json && api-extractor run --local --config api-extractor.lambda.json && api-extractor run --local --config api-extractor.node.json\",\n    \"prepublishOnly\": \"pnpm -w verify\"\n  },\n  \"dependencies\": {\n    \"@restatedev/restate-sdk-core\": \"workspace:*\"\n  },\n  \"devDependencies\": {\n    \"@types/aws-lambda\": \"^8.10.115\"\n  },\n  \"typesVersions\": {\n    \"*\": {\n      \"fetch\": [\n        \"./dist/fetch.d.ts\"\n      ],\n      \"lambda\": [\n        \"./dist/lambda.d.ts\"\n      ],\n      \"node\": [\n        \"./dist/node.d.ts\"\n      ]\n    }\n  }\n}\n"],"mappings":";cAEa"}
+{"version":3,"file":"package.js","names":[],"sources":["../package.json"],"sourcesContent":["{\n  \"name\": \"@restatedev/restate-sdk\",\n  \"version\": \"1.18.0\",\n  \"description\": \"Typescript SDK for Restate\",\n  \"author\": \"Restate Developers\",\n  \"email\": \"code@restate.dev\",\n  \"license\": \"MIT\",\n  \"homepage\": \"https://github.com/restatedev/sdk-typescript#readme\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/restatedev/sdk-typescript.git\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/restatedev/sdk-typescript/issues\"\n  },\n  \"type\": \"module\",\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.cts\",\n  \"exports\": {\n    \".\": {\n      \"import\": \"./dist/index.js\",\n      \"require\": \"./dist/index.cjs\"\n    },\n    \"./fetch\": {\n      \"import\": \"./dist/fetch.js\",\n      \"require\": \"./dist/fetch.cjs\"\n    },\n    \"./lambda\": {\n      \"import\": \"./dist/lambda.js\",\n      \"require\": \"./dist/lambda.cjs\"\n    },\n    \"./node\": {\n      \"import\": \"./dist/node.js\",\n      \"require\": \"./dist/node.cjs\"\n    },\n    \"./package.json\": \"./package.json\"\n  },\n  \"files\": [\n    \"dist\",\n    \"README.md\"\n  ],\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"scripts\": {\n    \"test\": \"turbo run _test --filter={.}...\",\n    \"_test\": \"vitest run\",\n    \"build\": \"turbo run _build --filter={.}...\",\n    \"_build\": \"tsc --noEmit && tsdown\",\n    \"dev\": \"tsc --noEmit --watch\",\n    \"clean\": \"rm -rf dist *.tsbuildinfo .turbo\",\n    \"check:types\": \"turbo run _check:types --filter={.}...\",\n    \"_check:types\": \"tsc --noEmit --project tsconfig.build.json\",\n    \"lint\": \"eslint .\",\n    \"check:exports\": \"turbo run _check:exports --filter={.}...\",\n    \"_check:exports\": \"attw --pack .\",\n    \"check:api\": \"turbo run _check:api --filter={.}...\",\n    \"_check:api\": \"api-extractor run --local && api-extractor run --local --config api-extractor.fetch.json && api-extractor run --local --config api-extractor.lambda.json && api-extractor run --local --config api-extractor.node.json\"\n  },\n  \"dependencies\": {\n    \"@restatedev/restate-sdk-core\": \"workspace:*\"\n  },\n  \"devDependencies\": {\n    \"@types/aws-lambda\": \"^8.10.115\"\n  },\n  \"typesVersions\": {\n    \"*\": {\n      \"fetch\": [\n        \"./dist/fetch.d.ts\"\n      ],\n      \"lambda\": [\n        \"./dist/lambda.d.ts\"\n      ],\n      \"node\": [\n        \"./dist/node.d.ts\"\n      ]\n    }\n  }\n}\n"],"mappings":";cAEa"}

package/dist/types/errors.cjs

@@ -92,8 +92,9 @@ var RetryableError = class RetryableError extends RestateError {
 	*/
 	static from(cause, options) {
 		const error = ensureError(cause);
+		const errorCode = error instanceof RestateError ? error.code : error["errorCode"];
 		return new RetryableError(error.message, {
-			errorCode: error["errorCode"],
+			errorCode,
 			cause,
 			...options
 		});
@@ -118,8 +119,9 @@ var PauseError = class PauseError extends RestateError {
 	*/
 	static from(cause) {
 		const error = ensureError(cause);
+		const errorCode = error instanceof RestateError ? error.code : error["errorCode"];
 		return new PauseError(error.message, {
-			errorCode: error["errorCode"],
+			errorCode,
 			cause
 		});
 	}

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.cts","names":[],"sources":["../../src/types/errors.ts"],"sourcesContent":[],"mappings":";;;;AAwHa,cA3CA,YAAA,SAAqB,KAAA,CA2Ca;EAWlC,SAAA,IAAA,EAAA,MAAe;EAQX,IAAA,EAAA,MAAA;EAaJ,WAAA,CAAA,OAAe,EAAA,MAAA,EAAA,OAuBQ,CAvBR,EAAA;IAGJ,SAAA,CAAA,EAAA,MAAA;IAIV,KAAA,CAAA,EAAA,GAAA;EAgBsB,CAAA;;;;AAgBpC;AAuCA;;cA1Ia,aAAA,SAAsB,YAAA;;sBAEN;;;;;;;;;;;;eAeZ;;;;;;cAWJ,YAAA,SAAqB,aAAA;;;;;;;cAWrB,cAAA,SAAuB,aAAA;;;;UAQnB,qBAAA;;;;eAIF;;;;;;;;cASF,cAAA,SAAuB,YAAA;;wBAGZ;yCAIV;;;;;;;oCAgBsB,wBAAwB;;;;;;;;cAgB/C,UAAA,SAAmB,YAAA;;;;;;;;;2BAoBL;;;;;;;;;;;iBAmBX,gBAAA"}
+{"version":3,"file":"errors.d.cts","names":[],"sources":["../../src/types/errors.ts"],"sourcesContent":[],"mappings":";;;;AAwHa,cA3CA,YAAA,SAAqB,KAAA,CA2Ca;EAWlC,SAAA,IAAA,EAAA,MAAe;EAQX,IAAA,EAAA,MAAA;EAaJ,WAAA,CAAA,OAAe,EAAA,MAAA,EAAA,OAuBQ,CAvBR,EAAA;IAGJ,SAAA,CAAA,EAAA,MAAA;IAIV,KAAA,CAAA,EAAA,GAAA;EAgBsB,CAAA;;;;AAoBpC;AA2CA;;cAlJa,aAAA,SAAsB,YAAA;;sBAEN;;;;;;;;;;;;eAeZ;;;;;;cAWJ,YAAA,SAAqB,aAAA;;;;;;;cAWrB,cAAA,SAAuB,aAAA;;;;UAQnB,qBAAA;;;;eAIF;;;;;;;;cASF,cAAA,SAAuB,YAAA;;wBAGZ;yCAIV;;;;;;;oCAgBsB,wBAAwB;;;;;;;;cAoB/C,UAAA,SAAmB,YAAA;;;;;;;;;2BAoBL;;;;;;;;;;;iBAuBX,gBAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/types/errors.ts"],"sourcesContent":[],"mappings":";;;;AAwHa,cA3CA,YAAA,SAAqB,KAAA,CA2Ca;EAWlC,SAAA,IAAA,EAAA,MAAe;EAQX,IAAA,EAAA,MAAA;EAaJ,WAAA,CAAA,OAAe,EAAA,MAAA,EAAA,OAuBQ,CAvBR,EAAA;IAGJ,SAAA,CAAA,EAAA,MAAA;IAIV,KAAA,CAAA,EAAA,GAAA;EAgBsB,CAAA;;;;AAgBpC;AAuCA;;cA1Ia,aAAA,SAAsB,YAAA;;sBAEN;;;;;;;;;;;;eAeZ;;;;;;cAWJ,YAAA,SAAqB,aAAA;;;;;;;cAWrB,cAAA,SAAuB,aAAA;;;;UAQnB,qBAAA;;;;eAIF;;;;;;;;cASF,cAAA,SAAuB,YAAA;;wBAGZ;yCAIV;;;;;;;oCAgBsB,wBAAwB;;;;;;;;cAgB/C,UAAA,SAAmB,YAAA;;;;;;;;;2BAoBL;;;;;;;;;;;iBAmBX,gBAAA"}
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/types/errors.ts"],"sourcesContent":[],"mappings":";;;;AAwHa,cA3CA,YAAA,SAAqB,KAAA,CA2Ca;EAWlC,SAAA,IAAA,EAAA,MAAe;EAQX,IAAA,EAAA,MAAA;EAaJ,WAAA,CAAA,OAAe,EAAA,MAAA,EAAA,OAuBQ,CAvBR,EAAA;IAGJ,SAAA,CAAA,EAAA,MAAA;IAIV,KAAA,CAAA,EAAA,GAAA;EAgBsB,CAAA;;;;AAoBpC;AA2CA;;cAlJa,aAAA,SAAsB,YAAA;;sBAEN;;;;;;;;;;;;eAeZ;;;;;;cAWJ,YAAA,SAAqB,aAAA;;;;;;;cAWrB,cAAA,SAAuB,aAAA;;;;UAQnB,qBAAA;;;;eAIF;;;;;;;;cASF,cAAA,SAAuB,YAAA;;wBAGZ;yCAIV;;;;;;;oCAgBsB,wBAAwB;;;;;;;;cAoB/C,UAAA,SAAmB,YAAA;;;;;;;;;2BAoBL;;;;;;;;;;;iBAuBX,gBAAA"}

package/dist/types/errors.js

@@ -91,8 +91,9 @@ var RetryableError = class RetryableError extends RestateError {
 	*/
 	static from(cause, options) {
 		const error = ensureError(cause);
+		const errorCode = error instanceof RestateError ? error.code : error["errorCode"];
 		return new RetryableError(error.message, {
-			errorCode: error["errorCode"],
+			errorCode,
 			cause,
 			...options
 		});
@@ -117,8 +118,9 @@ var PauseError = class PauseError extends RestateError {
 	*/
 	static from(cause) {
 		const error = ensureError(cause);
+		const errorCode = error instanceof RestateError ? error.code : error["errorCode"];
 		return new PauseError(error.message, {
-			errorCode: error["errorCode"],
+			errorCode,
 			cause
 		});
 	}