@restatedev/restate-sdk 1.11.1 → 1.13.0

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

@@ -1,24 +1 @@
-import type * as vm from "./endpoint/handlers/vm/sdk_shared_core_wasm_bindings.js";
-import { InputReader, OutputWriter } from "./endpoint/handlers/types.js";
-/**
- * Adapter between input stream and vm. It moves forward when [awaitNextProgress] is invoked.
- */
-export declare class InputPump {
-    private readonly coreVm;
-    private readonly inputReader;
-    private readonly errorCallback;
-    private currentRead?;
-    constructor(coreVm: vm.WasmVM, inputReader: InputReader, errorCallback: (e: any) => void);
-    awaitNextProgress(): Promise<void>;
-    private readNext;
-}
-/**
- * Adapter between output stream and vm. It moves forward when [awaitNextProgress] is invoked.
- */
-export declare class OutputPump {
-    private readonly coreVm;
-    private readonly outputWriter;
-    constructor(coreVm: vm.WasmVM, outputWriter: OutputWriter);
-    awaitNextProgress(): Promise<void>;
-}
-//# sourceMappingURL=io.d.ts.map
+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

package/dist/lambda.js.map

@@ -1 +1 @@
-{"version":3,"file":"lambda.js","names":[],"sources":["../src/lambda.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\nexport * from \"./common_api.js\";\n\nimport {\n  LambdaEndpointImpl,\n  type LambdaEndpoint,\n} from \"./endpoint/lambda_endpoint.js\";\nimport type { EndpointOptions } from \"./endpoint/types.js\";\nimport { withOptions } from \"./endpoint/withOptions.js\";\n\n/**\n * Create a new {@link LambdaEndpoint}.\n * @deprecated Please use {@link createEndpointHandler}\n */\nexport function endpoint(): LambdaEndpoint {\n  return new LambdaEndpointImpl();\n}\n\n/**\n * Creates a Lambda handler that encapsulates all the Restate services served by this endpoint.\n *\n * @param {EndpointOptions} options - Configuration options for the endpoint handler.\n * @returns A Lambda handler function.\n *\n * @example\n * A typical endpoint served as Lambda would look like this:\n * ```\n * import { createEndpointHandler } from \"@restatedev/restate-sdk/lambda\";\n *\n * export const handler = createEndpointHandler({ services: [myService] })\n */\nexport function createEndpointHandler(options: EndpointOptions) {\n  return withOptions<LambdaEndpoint>(\n    new LambdaEndpointImpl(),\n    options\n  ).handler();\n}\nexport { type LambdaEndpoint } from \"./endpoint/lambda_endpoint.js\";\n"],"mappings":";;;;;;;;;;;;;AAwBA,SAAgB,WAA2B;AACzC,QAAO,IAAI,oBAAoB;;;;;;;;;;;;;;;AAgBjC,SAAgB,sBAAsB,SAA0B;AAC9D,QAAO,YACL,IAAI,oBAAoB,EACxB,QACD,CAAC,SAAS"}
+{"version":3,"file":"lambda.js","names":[],"sources":["../src/lambda.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\nexport * from \"./common_api.js\";\n\nimport {\n  LambdaEndpointImpl,\n  type LambdaEndpoint,\n} from \"./endpoint/lambda_endpoint.js\";\nimport type { EndpointOptions } from \"./endpoint/types.js\";\nimport { withOptions } from \"./endpoint/withOptions.js\";\n\n/**\n * Create a new {@link LambdaEndpoint}.\n * @deprecated Please use {@link createEndpointHandler}\n */\nexport function endpoint(): LambdaEndpoint {\n  return new LambdaEndpointImpl();\n}\n\n/**\n * Creates a Lambda handler that encapsulates all the Restate services served by this endpoint.\n *\n * @param {EndpointOptions} options - Configuration options for the endpoint handler.\n * @returns A Lambda handler function.\n *\n * @example\n * A typical endpoint served as Lambda would look like this:\n * ```\n * import { createEndpointHandler } from \"@restatedev/restate-sdk/lambda\";\n *\n * export const handler = createEndpointHandler({ services: [myService] })\n */\nexport function createEndpointHandler(options: EndpointOptions) {\n  return withOptions<LambdaEndpoint>(\n    new LambdaEndpointImpl(),\n    options\n  ).handler();\n}\nexport { type LambdaEndpoint } from \"./endpoint/lambda_endpoint.js\";\n"],"mappings":";;;;;;;;;;;;;;AAwBA,SAAgB,WAA2B;AACzC,QAAO,IAAI,oBAAoB;;;;;;;;;;;;;;;AAgBjC,SAAgB,sBAAsB,SAA0B;AAC9D,QAAO,YACL,IAAI,oBAAoB,EACxB,QACD,CAAC,SAAS"}

package/dist/logging/logger.d.cts

@@ -0,0 +1 @@
+import "./logger_transport.cjs";

package/dist/logging/logger.d.ts

@@ -1,10 +1 @@
-import type { LoggerContext, LoggerTransport, LogSource } from "./logger_transport.js";
-import { RestateLogLevel } from "./logger_transport.js";
-/**
- * Logging facade used internally by the Restate SDK.
- */
-export interface Logger extends Console {
-    logForLevel(level: RestateLogLevel, message?: any, ...optionalParams: any[]): void;
-}
-export declare function createLogger(loggerTransport: LoggerTransport, source: LogSource, context?: LoggerContext, isReplaying?: () => boolean): Logger;
-//# sourceMappingURL=logger.d.ts.map
+import "./logger_transport.js";

package/dist/node.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');
@@ -18,18 +19,33 @@ function endpoint() {
 	return new require_node_endpoint.NodeEndpoint();
 }
 /**
-* Creates an HTTP/2 request handler for the provided services.
+* Creates a request handler for the provided services.
+*
+* The returned handler auto-detects the HTTP protocol version per request:
+* - HTTP/2+ requests use bidirectional streaming (`BIDI_STREAM`)
+* - HTTP/1.1 requests use request-response mode (`REQUEST_RESPONSE`) by default
 *
-* @example
+* Set `bidirectional: true` to force `BIDI_STREAM` for all requests, or
+* `bidirectional: false` to force `REQUEST_RESPONSE` for all requests.
+*
+* @example HTTP/2 server
 * ```
 * const httpServer = http2.createServer(createEndpointHandler({ services: [myService] }));
 * httpServer.listen(port);
 * ```
-* @param {EndpointOptions} options - Configuration options for the endpoint handler.
-* @returns An HTTP/2 request handler function.
+*
+* @example HTTP/1.1 server
+* ```
+* const httpServer = http.createServer(createEndpointHandler({ services: [myService] }));
+* httpServer.listen(port);
+* ```
+*
+* @param {NodeEndpointOptions} options - Configuration options for the endpoint handler.
+* @returns A request handler function compatible with both HTTP/1.1 and HTTP/2 servers.
 */
 function createEndpointHandler(options) {
-	return require_withOptions.withOptions(new require_node_endpoint.NodeEndpoint(), options).http2Handler();
+	const { bidirectional,...endpointOptions } = options;
+	return require_withOptions.withOptions(new require_node_endpoint.NodeEndpoint(), endpointOptions).handler({ bidirectional });
 }
 /**
 * Serves this Restate services as HTTP2 server, listening to the given port.
@@ -79,6 +95,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/node.d.cts

@@ -1,11 +1,14 @@
 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 * as http0 from "http";
 import * as http20 from "http2";
 
 //#region src/node.d.ts
@@ -15,17 +18,52 @@ import * as http20 from "http2";
  */
 declare function endpoint(): RestateEndpoint;
 /**
- * Creates an HTTP/2 request handler for the provided services.
+ * Options for creating a Node.js endpoint handler.
+ *
+ * Extends {@link EndpointOptions} with Node.js-specific options for controlling
+ * the protocol mode.
+ */
+interface NodeEndpointOptions extends EndpointOptions {
+  /**
+   * Controls the protocol mode used by the handler.
+   *
+   * - `undefined` (default): auto-detect based on HTTP version.
+   *   HTTP/2+ uses bidirectional streaming (`BIDI_STREAM`),
+   *   HTTP/1.1 uses request-response mode (`REQUEST_RESPONSE`).
+   * - `true`: force `BIDI_STREAM` for all requests.
+   * - `false`: force `REQUEST_RESPONSE` for all requests.
+   */
+  bidirectional?: boolean;
+}
+/**
+ * Creates a request handler for the provided services.
+ *
+ * The returned handler auto-detects the HTTP protocol version per request:
+ * - HTTP/2+ requests use bidirectional streaming (`BIDI_STREAM`)
+ * - HTTP/1.1 requests use request-response mode (`REQUEST_RESPONSE`) by default
  *
- * @example
+ * Set `bidirectional: true` to force `BIDI_STREAM` for all requests, or
+ * `bidirectional: false` to force `REQUEST_RESPONSE` for all requests.
+ *
+ * @example HTTP/2 server
  * ```
  * const httpServer = http2.createServer(createEndpointHandler({ services: [myService] }));
  * httpServer.listen(port);
  * ```
- * @param {EndpointOptions} options - Configuration options for the endpoint handler.
- * @returns An HTTP/2 request handler function.
+ *
+ * @example HTTP/1.1 server
+ * ```
+ * const httpServer = http.createServer(createEndpointHandler({ services: [myService] }));
+ * httpServer.listen(port);
+ * ```
+ *
+ * @param {NodeEndpointOptions} options - Configuration options for the endpoint handler.
+ * @returns A request handler function compatible with both HTTP/1.1 and HTTP/2 servers.
  */
-declare function createEndpointHandler(options: EndpointOptions): (request: http20.Http2ServerRequest, response: http20.Http2ServerResponse) => void;
+declare function createEndpointHandler(options: NodeEndpointOptions): {
+  (request: http0.IncomingMessage, response: http0.ServerResponse): void;
+  (request: http20.Http2ServerRequest, response: http20.Http2ServerResponse): void;
+};
 interface ServeOptions extends EndpointOptions {
   port?: number;
 }
@@ -48,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, 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 };
+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 };
 //# sourceMappingURL=node.d.cts.map

package/dist/node.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.cts","names":[],"sources":["../src/node.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBAqBgB,QAAA,CAAA,GAAY;;;;AAA5B;AAeA;;;;;AAOA;AAkBA;AAAwB,iBAzBR,qBAAA,CAyBQ,OAAA,EAzBuB,eAyBvB,CAAA,EAAA,CAAA,OAAA,EAzBsC,MAAA,CAAA,kBAyBtC,EAAA,QAAA,EAzBsC,MAAA,CAAA,mBAyBtC,EAAA,GAAA,IAAA;AAAoB,UAlB3B,YAAA,SAAqB,eAkBM,CAAA;EAAY,IAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;iBAAxC,KAAA;;;GAA4B,eAAY"}
+{"version":3,"file":"node.d.cts","names":[],"sources":["../src/node.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;iBAqBgB,QAAA,CAAA,GAAY;;;;;;;AAAZ,UAUC,mBAAA,SAA4B,eAVF,CAAA;EAU1B;AAsCjB;;;;;;;AAQA;EAkBgB,aAAK,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA1BL,qBAAA,UAA+B;YAAmB,KAAA,CAAA;;;UAQjD,YAAA,SAAqB;;;;;;;;;;;;;;;;;iBAkBtB,KAAA;;;GAA4B,eAAY"}