@restatedev/restate-sdk 1.14.4 → 1.15.0-rc.0

package/dist/fetch.d.cts

@@ -1,7 +1,7 @@
 import { CancelledError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.cjs";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
 import { Client, ClientCallOptions, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, 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, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request as Request$1, RestatePromise, RunAction, RunOptions, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
+import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request as Request$1, RestatePromise, RunAction, RunOptions, 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";
@@ -51,5 +51,5 @@ interface FetchEndpointOptions extends EndpointOptions {
  */
 declare function createEndpointHandler(options: FetchEndpointOptions): (request: Request, ...extraArgs: unknown[]) => Promise<Response>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, type FetchEndpoint, FetchEndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request$1 as Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, type FetchEndpoint, FetchEndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request$1 as Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, 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, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.js";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
 import { Client, ClientCallOptions, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, 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, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request as Request$1, RestatePromise, RunAction, RunOptions, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
+import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request as Request$1, RestatePromise, RunAction, RunOptions, 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";
@@ -51,5 +51,5 @@ interface FetchEndpointOptions extends EndpointOptions {
  */
 declare function createEndpointHandler(options: FetchEndpointOptions): (request: Request, ...extraArgs: unknown[]) => Promise<Response>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, type FetchEndpoint, FetchEndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request$1 as Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, type FetchEndpoint, FetchEndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request$1 as Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, 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, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.cjs";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
 import { Client, ClientCallOptions, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, 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, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
+import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, 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";
@@ -9,4 +9,4 @@ import { isRestatePromise } from "./promises.cjs";
 import { EndpointOptions } from "./endpoint/types.cjs";
 import { CombineablePromise, Duration, JournalValueCodec, ObjectHandler, RestateContext, RestateObjectContext, RestateObjectSharedContext, RestateWorkflowContext, RestateWorkflowSharedContext, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowSharedHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, serde } from "./common_api.cjs";
 import { NodeEndpointOptions, ServeOptions, createEndpointHandler, endpoint, serve } from "./node.cjs";
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { CancelledError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.js";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
 import { Client, ClientCallOptions, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, 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, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
+import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, 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";
@@ -9,4 +9,4 @@ import { isRestatePromise } from "./promises.js";
 import { EndpointOptions } from "./endpoint/types.js";
 import { CombineablePromise, Duration, JournalValueCodec, ObjectHandler, RestateContext, RestateObjectContext, RestateObjectSharedContext, RestateWorkflowContext, RestateWorkflowSharedContext, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowSharedHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, serde } from "./common_api.js";
 import { NodeEndpointOptions, ServeOptions, createEndpointHandler, endpoint, serve } from "./node.js";
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };

package/dist/internal.d.cts

@@ -1,10 +1,9 @@
-import { TerminalError, isSuspendedError } from "./types/errors.cjs";
+import { isSuspendedError } from "./types/errors.cjs";
 import { Context, InvocationId, RestatePromise } from "./context.cjs";
-import { Serde } from "@restatedev/restate-sdk-core";
 
 //#region src/internal.d.ts
 declare namespace internal_d_exports {
-  export { ContextInternal, InvocationReference, SignalReference, isSuspendedError };
+  export { ContextInternal, isSuspendedError };
 }
 /**
  * Internal {@link Context} interface exposing additional features.
@@ -119,92 +118,6 @@ interface ContextInternal extends Context {
    * @experimental
    */
   cancelPreviousCalls(): RestatePromise<InvocationId[]>;
-  /**
-   * Wait for a named signal to arrive on the current invocation.
-   *
-   * Signals are identified by name and are scoped to the current invocation.
-   * Another handler can send a signal to this invocation using
-   * {@link InvocationReference.signal}, specifying this invocation's
-   * ID (available via `ctx.request().id`) and the same signal name.
-   *
-   * @param name the name of the signal to wait for.
-   * @param serde optional custom serializer/deserializer for the payload.
-   * @returns a {@link RestatePromise} that resolves when the signal arrives.
-   *
-   * @example
-   * const ctxInternal = ctx as restate.internal.ContextInternal;
-   * const approved = await ctxInternal.signal<boolean>("approved");
-   *
-   * @experimental
-   */
-  signal<T>(name: string, serde?: Serde<T>): RestatePromise<T>;
-  /**
-   * Get a reference to a target invocation, to send signals to it.
-   *
-   * @param invocationId the invocation ID of the target invocation.
-   * @returns an {@link InvocationReference} for the target invocation.
-   *
-   * @example
-   * const ctxInternal = ctx as restate.internal.ContextInternal;
-   * const target = ctxInternal.invocation(targetInvocationId);
-   * target.signal("approved").resolve(true);
-   * target.signal("approved").reject("Request denied");
-   *
-   * @experimental
-   */
-  invocation(invocationId: InvocationId): InvocationReference;
-}
-/**
- * A reference to a target invocation, used to send signals.
- *
- * @experimental
- */
-interface InvocationReference {
-  /**
-   * Get a handle to a named signal on the target invocation.
-   *
-   * @param name the name of the signal.
-   * @param serde optional custom serializer/deserializer for the payload.
-   * @returns a {@link SignalReference} to resolve or reject the signal.
-   *
-   * @experimental
-   */
-  signal<T>(name: string, serde?: Serde<T>): SignalReference<T>;
-  /**
-   * Cancel the target invocation.
-   */
-  cancel(): void;
-  /**
-   * Attach to the target invocation and wait for its result.
-   *
-   * @param serde optional custom serializer/deserializer for the result.
-   * @returns a {@link RestatePromise} that resolves with the invocation result.
-   */
-  attach<T>(serde?: Serde<T>): RestatePromise<T>;
-}
-/**
- * A handle to send a signal value to a target invocation.
- *
- * @experimental
- */
-interface SignalReference<T> {
-  /**
-   * Resolve the signal with a value.
-   *
-   * @param payload the payload to send.
-   *
-   * @experimental
-   */
-  resolve(payload?: T): void;
-  /**
-   * Reject the signal. The target invocation waiting on this signal will be
-   * woken up with a terminal error containing the provided reason.
-   *
-   * @param reason the reason for rejection, either a string message or a {@link TerminalError}.
-   *
-   * @experimental
-   */
-  reject(reason: string | TerminalError): void;
 }
 //#endregion
 export { internal_d_exports };

package/dist/internal.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.cts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;UAaiB,eAAA,SAAwB;EAAxB;;;;;;;;EA+IU,YAAA,EAAA,EAAA,OAAA;EAAe;;;AAQ1C;;;;;;;;;;AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAtFkB;;;;;;;;;;yBAWO,eAAe;;;;;;;;;;;;;;;;;;;kCAoBN,MAAM,KAAK,eAAe;;;;;;;;;;;;;;;2BAgBjC,eAAe;;;;;;;UAQzB,mBAAA;;;;;;;;;;kCAUiB,MAAM,KAAK,gBAAgB;;;;;;;;;;;oBAazC,MAAM,KAAK,eAAe;;;;;;;UAQ7B;;;;;;;;oBAQG;;;;;;;;;0BAUM"}
+{"version":3,"file":"internal.d.cts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;AAWiB,UAAA,eAAA,SAAwB,OAAR,CAAA;EAgGf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAA;;;;;;;;;;yBAWO,eAAe"}

package/dist/internal.d.ts

@@ -1,10 +1,9 @@
-import { TerminalError, isSuspendedError } from "./types/errors.js";
+import { isSuspendedError } from "./types/errors.js";
 import { Context, InvocationId, RestatePromise } from "./context.js";
-import { Serde } from "@restatedev/restate-sdk-core";
 
 //#region src/internal.d.ts
 declare namespace internal_d_exports {
-  export { ContextInternal, InvocationReference, SignalReference, isSuspendedError };
+  export { ContextInternal, isSuspendedError };
 }
 /**
  * Internal {@link Context} interface exposing additional features.
@@ -119,92 +118,6 @@ interface ContextInternal extends Context {
    * @experimental
    */
   cancelPreviousCalls(): RestatePromise<InvocationId[]>;
-  /**
-   * Wait for a named signal to arrive on the current invocation.
-   *
-   * Signals are identified by name and are scoped to the current invocation.
-   * Another handler can send a signal to this invocation using
-   * {@link InvocationReference.signal}, specifying this invocation's
-   * ID (available via `ctx.request().id`) and the same signal name.
-   *
-   * @param name the name of the signal to wait for.
-   * @param serde optional custom serializer/deserializer for the payload.
-   * @returns a {@link RestatePromise} that resolves when the signal arrives.
-   *
-   * @example
-   * const ctxInternal = ctx as restate.internal.ContextInternal;
-   * const approved = await ctxInternal.signal<boolean>("approved");
-   *
-   * @experimental
-   */
-  signal<T>(name: string, serde?: Serde<T>): RestatePromise<T>;
-  /**
-   * Get a reference to a target invocation, to send signals to it.
-   *
-   * @param invocationId the invocation ID of the target invocation.
-   * @returns an {@link InvocationReference} for the target invocation.
-   *
-   * @example
-   * const ctxInternal = ctx as restate.internal.ContextInternal;
-   * const target = ctxInternal.invocation(targetInvocationId);
-   * target.signal("approved").resolve(true);
-   * target.signal("approved").reject("Request denied");
-   *
-   * @experimental
-   */
-  invocation(invocationId: InvocationId): InvocationReference;
-}
-/**
- * A reference to a target invocation, used to send signals.
- *
- * @experimental
- */
-interface InvocationReference {
-  /**
-   * Get a handle to a named signal on the target invocation.
-   *
-   * @param name the name of the signal.
-   * @param serde optional custom serializer/deserializer for the payload.
-   * @returns a {@link SignalReference} to resolve or reject the signal.
-   *
-   * @experimental
-   */
-  signal<T>(name: string, serde?: Serde<T>): SignalReference<T>;
-  /**
-   * Cancel the target invocation.
-   */
-  cancel(): void;
-  /**
-   * Attach to the target invocation and wait for its result.
-   *
-   * @param serde optional custom serializer/deserializer for the result.
-   * @returns a {@link RestatePromise} that resolves with the invocation result.
-   */
-  attach<T>(serde?: Serde<T>): RestatePromise<T>;
-}
-/**
- * A handle to send a signal value to a target invocation.
- *
- * @experimental
- */
-interface SignalReference<T> {
-  /**
-   * Resolve the signal with a value.
-   *
-   * @param payload the payload to send.
-   *
-   * @experimental
-   */
-  resolve(payload?: T): void;
-  /**
-   * Reject the signal. The target invocation waiting on this signal will be
-   * woken up with a terminal error containing the provided reason.
-   *
-   * @param reason the reason for rejection, either a string message or a {@link TerminalError}.
-   *
-   * @experimental
-   */
-  reject(reason: string | TerminalError): void;
 }
 //#endregion
 export { internal_d_exports };

package/dist/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;UAaiB,eAAA,SAAwB;EAAxB;;;;;;;;EA+IU,YAAA,EAAA,EAAA,OAAA;EAAe;;;AAQ1C;;;;;;;;;;AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAtFkB;;;;;;;;;;yBAWO,eAAe;;;;;;;;;;;;;;;;;;;kCAoBN,MAAM,KAAK,eAAe;;;;;;;;;;;;;;;2BAgBjC,eAAe;;;;;;;UAQzB,mBAAA;;;;;;;;;;kCAUiB,MAAM,KAAK,gBAAgB;;;;;;;;;;;oBAazC,MAAM,KAAK,eAAe;;;;;;;UAQ7B;;;;;;;;oBAQG;;;;;;;;;0BAUM"}
+{"version":3,"file":"internal.d.ts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;AAWiB,UAAA,eAAA,SAAwB,OAAR,CAAA;EAgGf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAA;;;;;;;;;;yBAWO,eAAe"}

package/dist/internal.js.map

@@ -1 +1 @@
-{"version":3,"file":"internal.js","names":[],"sources":["../src/internal.ts"],"sourcesContent":["import type { Serde } from \"@restatedev/restate-sdk-core\";\nimport { Context, InvocationId, RestatePromise } from \"./context.js\";\nimport type { TerminalError } from \"./types/errors.js\";\n\nexport { isSuspendedError } from \"./types/errors.js\";\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   *       ctxInternal = ctx as restate.internal.ContextInternal;\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 = ctx as restate.internal.ContextInternal;\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 = ctx as restate.internal.ContextInternal;\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   * Wait for a named signal to arrive on the current invocation.\n   *\n   * Signals are identified by name and are scoped to the current invocation.\n   * Another handler can send a signal to this invocation using\n   * {@link InvocationReference.signal}, specifying this invocation's\n   * ID (available via `ctx.request().id`) and the same signal name.\n   *\n   * @param name the name of the signal to wait for.\n   * @param serde optional custom serializer/deserializer for the payload.\n   * @returns a {@link RestatePromise} that resolves when the signal arrives.\n   *\n   * @example\n   * const ctxInternal = ctx as restate.internal.ContextInternal;\n   * const approved = await ctxInternal.signal<boolean>(\"approved\");\n   *\n   * @experimental\n   */\n  signal<T>(name: string, serde?: Serde<T>): RestatePromise<T>;\n\n  /**\n   * Get a reference to a target invocation, to send signals to it.\n   *\n   * @param invocationId the invocation ID of the target invocation.\n   * @returns an {@link InvocationReference} for the target invocation.\n   *\n   * @example\n   * const ctxInternal = ctx as restate.internal.ContextInternal;\n   * const target = ctxInternal.invocation(targetInvocationId);\n   * target.signal(\"approved\").resolve(true);\n   * target.signal(\"approved\").reject(\"Request denied\");\n   *\n   * @experimental\n   */\n  invocation(invocationId: InvocationId): InvocationReference;\n}\n\n/**\n * A reference to a target invocation, used to send signals.\n *\n * @experimental\n */\nexport interface InvocationReference {\n  /**\n   * Get a handle to a named signal on the target invocation.\n   *\n   * @param name the name of the signal.\n   * @param serde optional custom serializer/deserializer for the payload.\n   * @returns a {@link SignalReference} to resolve or reject the signal.\n   *\n   * @experimental\n   */\n  signal<T>(name: string, serde?: Serde<T>): SignalReference<T>;\n\n  /**\n   * Cancel the target invocation.\n   */\n  cancel(): void;\n\n  /**\n   * Attach to the target invocation and wait for its result.\n   *\n   * @param serde optional custom serializer/deserializer for the result.\n   * @returns a {@link RestatePromise} that resolves with the invocation result.\n   */\n  attach<T>(serde?: Serde<T>): RestatePromise<T>;\n}\n\n/**\n * A handle to send a signal value to a target invocation.\n *\n * @experimental\n */\nexport interface SignalReference<T> {\n  /**\n   * Resolve the signal with a value.\n   *\n   * @param payload the payload to send.\n   *\n   * @experimental\n   */\n  resolve(payload?: T): void;\n\n  /**\n   * Reject the signal. The target invocation waiting on this signal will be\n   * woken up with a terminal error containing the provided reason.\n   *\n   * @param reason the reason for rejection, either a string message or a {@link TerminalError}.\n   *\n   * @experimental\n   */\n  reject(reason: string | TerminalError): void;\n}\n"],"mappings":""}
+{"version":3,"file":"internal.js","names":[],"sources":["../src/internal.ts"],"sourcesContent":["import { Context, InvocationId, RestatePromise } from \"./context.js\";\n\nexport { isSuspendedError } from \"./types/errors.js\";\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   *       ctxInternal = ctx as restate.internal.ContextInternal;\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 = ctx as restate.internal.ContextInternal;\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 = ctx as restate.internal.ContextInternal;\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"],"mappings":""}

package/dist/lambda.d.cts

@@ -1,7 +1,7 @@
 import { CancelledError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.cjs";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
 import { Client, ClientCallOptions, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, 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, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
+import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, 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";
@@ -31,5 +31,5 @@ declare function endpoint(): LambdaEndpoint;
  */
 declare function createEndpointHandler(options: EndpointOptions): (event: any, ctx: any) => Promise<any>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, 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, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.js";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
 import { Client, ClientCallOptions, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, 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, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
+import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, 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";
@@ -31,5 +31,5 @@ declare function endpoint(): LambdaEndpoint;
  */
 declare function createEndpointHandler(options: EndpointOptions): (event: any, ctx: any) => Promise<any>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, 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, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.cjs";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.cjs";
 import { Client, ClientCallOptions, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, 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, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.cjs";
+import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, 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";
@@ -86,5 +86,5 @@ declare function serve({
   ...options
 }: ServeOptions): Promise<number>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, 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, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.js";
 import { Hooks, HooksProvider, Interceptor } from "./hooks.js";
 import { Client, ClientCallOptions, ClientSendOptions, InferArg, ObjectHandlerOpts, ObjectOptions, ObjectOpts, Opts, RemoveVoidArgument, RetryPolicy, SendClient, 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, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, Target, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.js";
+import { Context, ContextDate, DurablePromise, GenericCall, GenericSend, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, KeyValueStore, ObjectContext, ObjectSharedContext, Rand, Request, RestatePromise, RunAction, RunOptions, 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";
@@ -86,5 +86,5 @@ declare function serve({
   ...options
 }: ServeOptions): Promise<number>;
 //#endregion
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_d_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, Hooks, HooksProvider, InferArg, Interceptor, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, InvocationReference, JournalValueCodec, KeyValueStore, LogMetadata, LogSource, LoggerContext, LoggerTransport, NodeEndpointOptions, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, SignalReference, Target, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, 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.14.4";
+var version = "1.15.0-rc.0";
 
 //#endregion
 Object.defineProperty(exports, 'version', {

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "1.14.4";
+var version = "1.15.0-rc.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.14.4\",\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.15.0-rc.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    \"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"}

package/dist/promises.cjs

@@ -1,6 +1,5 @@
 const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const require_errors = require('./types/errors.cjs');
-const require_completable_promise = require('./utils/completable_promise.cjs');
 let node_timers_promises = require("node:timers/promises");
 node_timers_promises = require_rolldown_runtime.__toESM(node_timers_promises);
 
@@ -30,7 +29,7 @@ function extractContext(n) {
 var BaseRestatePromise = class extends InternalRestatePromise {
 	[RESTATE_CTX_SYMBOL];
 	pollingPromise;
-	cancelPromise = new require_completable_promise.CompletablePromise();
+	cancelPromise = Promise.withResolvers();
 	constructor(ctx) {
 		super();
 		this[RESTATE_CTX_SYMBOL] = ctx;
@@ -51,7 +50,7 @@ var BaseRestatePromise = class extends InternalRestatePromise {
 		return Promise.race([this.cancelPromise.promise, this.publicPromise()]);
 	}
 	orTimeout(duration) {
-		return new CombinatorRestatePromise(this[RESTATE_CTX_SYMBOL], ([thisPromise, sleepPromise]) => {
+		return new CombinatorRestatePromise(this[RESTATE_CTX_SYMBOL], "Unknown", ([thisPromise, sleepPromise]) => {
 			return new Promise((resolve, reject) => {
 				thisPromise.then(resolve, reject);
 				sleepPromise.then(() => {
@@ -69,14 +68,14 @@ var BaseRestatePromise = class extends InternalRestatePromise {
 };
 var SingleRestatePromise = class extends BaseRestatePromise {
 	state = PromiseState.NOT_COMPLETED;
-	completablePromise = new require_completable_promise.CompletablePromise();
+	completablePromise = Promise.withResolvers();
 	constructor(ctx, handle, completer) {
 		super(ctx);
 		this.handle = handle;
 		this.completer = completer;
 	}
-	uncompletedLeaves() {
-		return this.state === PromiseState.COMPLETED ? [] : [this.handle];
+	unresolvedFuture() {
+		return this.state === PromiseState.COMPLETED ? null : { Single: this.handle };
 	}
 	async tryComplete() {
 		if (this.state === PromiseState.COMPLETED) return;
@@ -105,14 +104,15 @@ var InvocationRestatePromise = class extends SingleRestatePromise {
 var CombinatorRestatePromise = class CombinatorRestatePromise extends BaseRestatePromise {
 	state = PromiseState.NOT_COMPLETED;
 	combinatorPromise;
-	constructor(ctx, combinatorConstructor, childs) {
+	constructor(ctx, combinatorVariant, combinatorConstructor, childs) {
 		super(ctx);
+		this.combinatorVariant = combinatorVariant;
 		this.childs = childs;
 		this.combinatorPromise = combinatorConstructor(childs.map((p) => p.publicPromise())).finally(() => {
 			this.state = PromiseState.COMPLETED;
 		});
 	}
-	static fromPromises(combinatorConstructor, promises) {
+	static fromPromises(combinatorVariant, combinatorConstructor, promises) {
 		const castedPromises = [];
 		let foundContext = void 0;
 		for (const [idx, promise] of promises.entries()) {
@@ -125,10 +125,13 @@ var CombinatorRestatePromise = class CombinatorRestatePromise extends BaseRestat
 			castedPromises.push(promise);
 		}
 		if (foundContext === void 0) return ConstRestatePromise.fromPromise(combinatorConstructor(castedPromises), true);
-		return new CombinatorRestatePromise(foundContext, combinatorConstructor, castedPromises);
+		return new CombinatorRestatePromise(foundContext, combinatorVariant, combinatorConstructor, castedPromises);
 	}
-	uncompletedLeaves() {
-		return this.state === PromiseState.COMPLETED ? [] : this.childs.flatMap((p) => p.uncompletedLeaves());
+	unresolvedFuture() {
+		if (this.state === PromiseState.COMPLETED) return null;
+		const children = this.childs.map((p) => p.unresolvedFuture()).filter((f) => f !== null);
+		if (children.length === 0) return null;
+		return { [this.combinatorVariant]: children };
 	}
 	async tryComplete() {
 		await Promise.allSettled(this.childs.map((c) => c.tryComplete()));
@@ -159,8 +162,9 @@ var MappedRestatePromise = class extends BaseRestatePromise {
 	async tryComplete() {
 		await this.inner.tryComplete();
 	}
-	uncompletedLeaves() {
-		return this.inner.uncompletedLeaves();
+	unresolvedFuture() {
+		const inner = this.inner.unresolvedFuture();
+		return inner === null ? null : { Unknown: [inner] };
 	}
 	publicPromise() {
 		return this._mappedPromise ??= this.buildMappedPromise();
@@ -221,8 +225,8 @@ var ConstRestatePromise = class ConstRestatePromise extends InternalRestatePromi
 	tryComplete() {
 		return Promise.resolve();
 	}
-	uncompletedLeaves() {
-		return [];
+	unresolvedFuture() {
+		return null;
 	}
 	[Symbol.toStringTag] = "ConstRestatePromise";
 };
@@ -250,10 +254,10 @@ var PromisesExecutor = class {
 		}
 		return (0, node_timers_promises.setImmediate)().then(async () => {
 			try {
-				const handles = restatePromise.uncompletedLeaves();
-				if (handles.length === 0) return;
-				const doProgressResult = this.coreVm.do_progress(new Uint32Array(handles));
-				if (doProgressResult === "AnyCompleted") {} else if (doProgressResult === "ReadFromInput" || doProgressResult === "WaitingPendingRun") {
+				const unresolvedFuture = restatePromise.unresolvedFuture();
+				if (unresolvedFuture === null) return;
+				const doProgressResult = this.coreVm.do_progress(unresolvedFuture);
+				if (doProgressResult === "AnyCompleted") {} else if (doProgressResult === "WaitExternalProgress") {
 					await this.outputPump.awaitNextProgress();
 					await this.externalProgressChannel.awaitNext();
 				} else if (doProgressResult === "CancelSignalReceived") {

package/dist/promises.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"promises.d.cts","names":[],"sources":["../src/promises.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBA+CgB,uBAAuB,QAAQ,UAAU,eAAe"}
+{"version":3,"file":"promises.d.cts","names":[],"sources":["../src/promises.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBA8CgB,uBAAuB,QAAQ,UAAU,eAAe"}

package/dist/promises.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"promises.d.ts","names":[],"sources":["../src/promises.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBA+CgB,uBAAuB,QAAQ,UAAU,eAAe"}
+{"version":3,"file":"promises.d.ts","names":[],"sources":["../src/promises.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBA8CgB,uBAAuB,QAAQ,UAAU,eAAe"}