@restatedev/restate-sdk-cloudflare-workers 1.11.1 → 1.13.0

package/dist/index.d.cts

@@ -1,10 +1,12 @@
 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, SendOptions, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.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 { internal_d_exports } from "./internal.cjs";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.cjs";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.cjs";
+import { isRestatePromise } from "./promises.cjs";
 import { EndpointOptions } from "./endpoint/types.cjs";
-import { internal_d_exports } from "./internal.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 { ServeOptions, createEndpointHandler, endpoint, serve } from "./node.cjs";
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, InferArg, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, 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, SendOptions, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, 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, object, rpc, serde, serve, service, workflow };
+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 };

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 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, SendOptions, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.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 { internal_d_exports } from "./internal.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
+import { isRestatePromise } from "./promises.js";
 import { EndpointOptions } from "./endpoint/types.js";
-import { internal_d_exports } from "./internal.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 { ServeOptions, createEndpointHandler, endpoint, serve } from "./node.js";
-export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, InferArg, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, 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, SendOptions, SendOpts, Serde, ServeOptions, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, 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, object, rpc, serde, serve, service, workflow };
+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 };

package/dist/index.js

@@ -1,8 +1,9 @@
 import { CancelledError, RestateError, RetryableError, TerminalError, TimeoutError } from "./types/errors.js";
-import { Opts, SendOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
+import { isRestatePromise } from "./promises.js";
 import { InvocationIdParser, RestatePromise } from "./context.js";
+import { Opts, SendOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
 import { internal_exports } from "./internal.js";
 import { CombineablePromise, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, serde } from "./common_api.js";
 import { createEndpointHandler, endpoint, serve } from "./node.js";
 
-export { CancelledError, CombineablePromise, InvocationIdParser, Opts, RestateError, RestatePromise, RetryableError, SendOpts, TerminalError, TimeoutError, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_exports as internal, object, rpc, serde, serve, service, workflow };
+export { CancelledError, CombineablePromise, InvocationIdParser, Opts, RestateError, RestatePromise, RetryableError, SendOpts, TerminalError, TimeoutError, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_exports as internal, isRestatePromise, object, rpc, serde, serve, service, workflow };

package/dist/internal.cjs

@@ -1,6 +1,8 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_errors = require('./types/errors.cjs');
 
 //#region src/internal.ts
-var internal_exports = {};
+var internal_exports = /* @__PURE__ */ require_rolldown_runtime.__export({ isSuspendedError: () => require_errors.isSuspendedError });
 
 //#endregion
 Object.defineProperty(exports, 'internal_exports', {

package/dist/internal.d.cts

@@ -1,8 +1,10 @@
-import { Context } from "./context.cjs";
+import { TerminalError, 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 };
+  export { ContextInternal, InvocationReference, SignalReference, isSuspendedError };
 }
 /**
  * Internal {@link Context} interface exposing additional features.
@@ -21,6 +23,188 @@ interface ContextInternal extends Context {
    * @experimental
    */
   isProcessing(): boolean;
+  /**
+   * Returns a {@link RestatePromise} that resolves with `undefined` when Restate signals cancellation
+   * of the current invocation.
+   *
+   * This method **MUST** only be used when the handler (or its parent service/endpoint) is configured
+   * with `explicitCancellation: true`. Without configuring this option, cancellations are propagated automatically,
+   * and this promise will **NEVER** resolve.
+   *
+   * **Promise reuse:** calling this method multiple times returns the **same** promise instance as long as
+   * the current cancellation signal has not yet arrived. Once the promise resolves (cancellation received),
+   * later calls return a **new** promise that will resolve on the next cancellation signal.
+   *
+   * @example Race a long-running side effect against cancellation
+   * ```ts
+   * const greeter = restate.service({
+   *   name: "greeter",
+   *   handlers: {
+   *     greet: async (ctx: restate.Context, name: string) => {
+   *       ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const result = await RestatePromise.race([
+   *         ctx.run(() => longRunningTask(name)),
+   *         ctxInternal.cancellation().map(() => { throw new restate.TerminalError("Cancelled") }),
+   *       ]);
+   *       return result;
+   *     },
+   *   },
+   *   options: { explicitCancellation: true },
+   * });
+   * ```
+   *
+   * @example Use the cancellation promise to create an AbortSignal for ctx.run
+   * ```ts
+   * const greeter = restate.service({
+   *   name: "greeter",
+   *   handlers: {
+   *     greet: async (ctx: restate.Context, name: string) => {
+   *       const ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const controller = new AbortController();
+   *       const cancellation = ctxInternal.cancellation()
+   *         .map(() => {
+   *            controller.abort();
+   *            throw new restate.TerminalError("Cancelled");
+   *         });
+   *
+   *       return RestatePromise.race([
+   *         ctx.run(() => fetch(`https://api.example.com/greet/${name}`, { signal: controller.signal })),
+   *         cancellation,
+   *       ]);
+   *     },
+   *   },
+   *   options: { explicitCancellation: true },
+   * });
+   * ```
+   *
+   * @example Handle cancellation, perform cleanup, then listen for the next cancellation
+   * ```ts
+   * const greeter = restate.service({
+   *   name: "greeter",
+   *   handlers: {
+   *     greet: async (ctx: restate.Context, name: string) => {
+   *       const ctxInternal = ctx as restate.internal.ContextInternal;
+   *       try {
+   *         return await RestatePromise.race([
+   *           ctx.run(() => longRunningTask(name)),
+   *           ctxInternal.cancellation().map(() => { throw new restate.TerminalError("Cancelled") }),
+   *         ]);
+   *       } catch (e) {
+   *         // Perform cleanup
+   *         await ctx.run(() => cleanupResources(name));
+   *
+   *         // After cancellation is resolved, ctx.cancellation() returns a fresh promise.
+   *         // Race cleanup confirmation against the next cancellation signal.
+   *         await RestatePromise.race([
+   *           ctx.run(() => confirmCleanup(name)),
+   *           ctxInternal.cancellation().map(() => { throw new restate.TerminalError("Canceled during cleanup") }),
+   *         ]);
+   *       }
+   *     },
+   *   },
+   *   options: { explicitCancellation: true },
+   * });
+   * ```
+   *
+   * @experimental
+   */
+  cancellation(): RestatePromise<void>;
+  /**
+   * Cancel all previous calls made from this handler.
+   *
+   * This method **MUST** only be used when the handler (or its parent service/endpoint) is configured
+   * with `explicitCancellation: true`. Without configuring this option, this operation will always be a no-op.
+   *
+   * @return the invocation id of the canceled calls.
+   * @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":";;;;;;;;;;AASA;;;UAAiB,eAAA,SAAwB"}
+{"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"}

package/dist/internal.d.ts

@@ -1,8 +1,10 @@
-import { Context } from "./context.js";
+import { TerminalError, 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 };
+  export { ContextInternal, InvocationReference, SignalReference, isSuspendedError };
 }
 /**
  * Internal {@link Context} interface exposing additional features.
@@ -21,6 +23,188 @@ interface ContextInternal extends Context {
    * @experimental
    */
   isProcessing(): boolean;
+  /**
+   * Returns a {@link RestatePromise} that resolves with `undefined` when Restate signals cancellation
+   * of the current invocation.
+   *
+   * This method **MUST** only be used when the handler (or its parent service/endpoint) is configured
+   * with `explicitCancellation: true`. Without configuring this option, cancellations are propagated automatically,
+   * and this promise will **NEVER** resolve.
+   *
+   * **Promise reuse:** calling this method multiple times returns the **same** promise instance as long as
+   * the current cancellation signal has not yet arrived. Once the promise resolves (cancellation received),
+   * later calls return a **new** promise that will resolve on the next cancellation signal.
+   *
+   * @example Race a long-running side effect against cancellation
+   * ```ts
+   * const greeter = restate.service({
+   *   name: "greeter",
+   *   handlers: {
+   *     greet: async (ctx: restate.Context, name: string) => {
+   *       ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const result = await RestatePromise.race([
+   *         ctx.run(() => longRunningTask(name)),
+   *         ctxInternal.cancellation().map(() => { throw new restate.TerminalError("Cancelled") }),
+   *       ]);
+   *       return result;
+   *     },
+   *   },
+   *   options: { explicitCancellation: true },
+   * });
+   * ```
+   *
+   * @example Use the cancellation promise to create an AbortSignal for ctx.run
+   * ```ts
+   * const greeter = restate.service({
+   *   name: "greeter",
+   *   handlers: {
+   *     greet: async (ctx: restate.Context, name: string) => {
+   *       const ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const controller = new AbortController();
+   *       const cancellation = ctxInternal.cancellation()
+   *         .map(() => {
+   *            controller.abort();
+   *            throw new restate.TerminalError("Cancelled");
+   *         });
+   *
+   *       return RestatePromise.race([
+   *         ctx.run(() => fetch(`https://api.example.com/greet/${name}`, { signal: controller.signal })),
+   *         cancellation,
+   *       ]);
+   *     },
+   *   },
+   *   options: { explicitCancellation: true },
+   * });
+   * ```
+   *
+   * @example Handle cancellation, perform cleanup, then listen for the next cancellation
+   * ```ts
+   * const greeter = restate.service({
+   *   name: "greeter",
+   *   handlers: {
+   *     greet: async (ctx: restate.Context, name: string) => {
+   *       const ctxInternal = ctx as restate.internal.ContextInternal;
+   *       try {
+   *         return await RestatePromise.race([
+   *           ctx.run(() => longRunningTask(name)),
+   *           ctxInternal.cancellation().map(() => { throw new restate.TerminalError("Cancelled") }),
+   *         ]);
+   *       } catch (e) {
+   *         // Perform cleanup
+   *         await ctx.run(() => cleanupResources(name));
+   *
+   *         // After cancellation is resolved, ctx.cancellation() returns a fresh promise.
+   *         // Race cleanup confirmation against the next cancellation signal.
+   *         await RestatePromise.race([
+   *           ctx.run(() => confirmCleanup(name)),
+   *           ctxInternal.cancellation().map(() => { throw new restate.TerminalError("Canceled during cleanup") }),
+   *         ]);
+   *       }
+   *     },
+   *   },
+   *   options: { explicitCancellation: true },
+   * });
+   * ```
+   *
+   * @experimental
+   */
+  cancellation(): RestatePromise<void>;
+  /**
+   * Cancel all previous calls made from this handler.
+   *
+   * This method **MUST** only be used when the handler (or its parent service/endpoint) is configured
+   * with `explicitCancellation: true`. Without configuring this option, this operation will always be a no-op.
+   *
+   * @return the invocation id of the canceled calls.
+   * @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":";;;;;;;;;;AASA;;;UAAiB,eAAA,SAAwB"}
+{"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"}

package/dist/internal.js

@@ -1,5 +1,8 @@
+import { __export } from "./_virtual/rolldown_runtime.js";
+import { isSuspendedError } from "./types/errors.js";
+
 //#region src/internal.ts
-var internal_exports = {};
+var internal_exports = /* @__PURE__ */ __export({ isSuspendedError: () => isSuspendedError });
 
 //#endregion
 export { internal_exports };

package/dist/internal.js.map

@@ -1 +1 @@
-{"version":3,"file":"internal.js","names":[],"sources":["../src/internal.ts"],"sourcesContent":["import { Context } from \"./context.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"],"mappings":""}
+{"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":""}

package/dist/io.d.cts

@@ -0,0 +1 @@
+import "./endpoint/handlers/types.cjs";

package/dist/io.d.ts

@@ -0,0 +1 @@
+import "./endpoint/handlers/types.js";

package/dist/lambda.cjs

@@ -1,7 +1,8 @@
 const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const require_errors = require('./types/errors.cjs');
-const require_rpc = require('./types/rpc.cjs');
+const require_promises = require('./promises.cjs');
 const require_context = require('./context.cjs');
+const require_rpc = require('./types/rpc.cjs');
 const require_internal = require('./internal.cjs');
 const require_common_api = require('./common_api.cjs');
 const require_withOptions = require('./endpoint/withOptions.cjs');
@@ -64,6 +65,7 @@ Object.defineProperty(exports, 'internal', {
     return require_internal.internal_exports;
   }
 });
+exports.isRestatePromise = require_promises.isRestatePromise;
 exports.object = require_rpc.object;
 Object.defineProperty(exports, 'rpc', {
   enumerable: true,

package/dist/lambda.d.cts

@@ -1,10 +1,12 @@
 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, SendOptions, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.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 { internal_d_exports } from "./internal.cjs";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.cjs";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.cjs";
+import { isRestatePromise } from "./promises.cjs";
 import { EndpointOptions } from "./endpoint/types.cjs";
-import { internal_d_exports } from "./internal.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 { LambdaEndpoint } from "./endpoint/lambda_endpoint.cjs";
 
@@ -29,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, InferArg, 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, SendOptions, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, 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, 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, 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 };
 //# sourceMappingURL=lambda.d.cts.map

package/dist/lambda.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"lambda.d.cts","names":[],"sources":["../src/lambda.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBAwBgB,QAAA,CAAA,GAAY;;;;AAA5B;AAiBA;;;;;;;;;iBAAgB,qBAAA,UAA+B,4CAAe"}
+{"version":3,"file":"lambda.d.cts","names":[],"sources":["../src/lambda.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;iBAwBgB,QAAA,CAAA,GAAY;;;;;;AAA5B;AAiBA;;;;;;;iBAAgB,qBAAA,UAA+B,4CAAe"}

package/dist/lambda.d.ts

@@ -1,10 +1,12 @@
 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, SendOptions, TypedState, UntypedState, WorkflowContext, WorkflowSharedContext } from "./context.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 { internal_d_exports } from "./internal.js";
 import { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
 import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
+import { isRestatePromise } from "./promises.js";
 import { EndpointOptions } from "./endpoint/types.js";
-import { internal_d_exports } from "./internal.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 { LambdaEndpoint } from "./endpoint/lambda_endpoint.js";
 
@@ -29,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, InferArg, 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, SendOptions, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, 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, 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, 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 };
 //# sourceMappingURL=lambda.d.ts.map

package/dist/lambda.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lambda.d.ts","names":[],"sources":["../src/lambda.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBAwBgB,QAAA,CAAA,GAAY;;;;AAA5B;AAiBA;;;;;;;;;iBAAgB,qBAAA,UAA+B,4CAAe"}
+{"version":3,"file":"lambda.d.ts","names":[],"sources":["../src/lambda.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;iBAwBgB,QAAA,CAAA,GAAY;;;;;;AAA5B;AAiBA;;;;;;;iBAAgB,qBAAA,UAA+B,4CAAe"}

package/dist/lambda.js

@@ -1,6 +1,7 @@
 import { CancelledError, RestateError, RetryableError, TerminalError, TimeoutError } from "./types/errors.js";
-import { Opts, SendOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
+import { isRestatePromise } from "./promises.js";
 import { InvocationIdParser, RestatePromise } from "./context.js";
+import { Opts, SendOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
 import { internal_exports } from "./internal.js";
 import { CombineablePromise, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, serde } from "./common_api.js";
 import { withOptions } from "./endpoint/withOptions.js";
@@ -32,5 +33,5 @@ function createEndpointHandler(options) {
 }
 
 //#endregion
-export { CancelledError, CombineablePromise, InvocationIdParser, Opts, RestateError, RestatePromise, RetryableError, SendOpts, TerminalError, TimeoutError, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_exports as internal, object, rpc, serde, service, workflow };
+export { CancelledError, CombineablePromise, InvocationIdParser, Opts, RestateError, RestatePromise, RetryableError, SendOpts, TerminalError, TimeoutError, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, internal_exports as internal, isRestatePromise, object, rpc, serde, service, workflow };
 //# sourceMappingURL=lambda.js.map