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

package/dist/internal.d.cts

@@ -1,10 +1,24 @@
 import { isSuspendedError } from "./types/errors.cjs";
 import { Context, InvocationId, RestatePromise } from "./context.cjs";
+import { Serde } from "@restatedev/restate-sdk-core";
 
 //#region src/internal.d.ts
 declare namespace internal_d_exports {
-  export { ContextInternal, isSuspendedError };
+  export { ContextInternal, GetProjectOptions, asInternal, isSuspendedError };
 }
+/**
+ * Downcast the given context to {@link ContextInternal}, to access the internal APIs.
+ *
+ * Works with every context type passed to handlers, e.g. `Context`, `ObjectContext`, `ObjectSharedContext`, `WorkflowContext`.
+ *
+ * @example
+ * ```ts
+ * const ctxInternal = restate.internal.asInternal(ctx);
+ * ```
+ *
+ * @experimental
+ */
+declare function asInternal(ctx: Context): ContextInternal;
 /**
  * Internal {@link Context} interface exposing additional features.
  *
@@ -40,7 +54,7 @@ interface ContextInternal extends Context {
    *   name: "greeter",
    *   handlers: {
    *     greet: async (ctx: restate.Context, name: string) => {
-   *       ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const ctxInternal = restate.internal.asInternal(ctx);
    *       const result = await RestatePromise.race([
    *         ctx.run(() => longRunningTask(name)),
    *         ctxInternal.cancellation().map(() => { throw new restate.TerminalError("Cancelled") }),
@@ -58,7 +72,7 @@ interface ContextInternal extends Context {
    *   name: "greeter",
    *   handlers: {
    *     greet: async (ctx: restate.Context, name: string) => {
-   *       const ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const ctxInternal = restate.internal.asInternal(ctx);
    *       const controller = new AbortController();
    *       const cancellation = ctxInternal.cancellation()
    *         .map(() => {
@@ -82,7 +96,7 @@ interface ContextInternal extends Context {
    *   name: "greeter",
    *   handlers: {
    *     greet: async (ctx: restate.Context, name: string) => {
-   *       const ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const ctxInternal = restate.internal.asInternal(ctx);
    *       try {
    *         return await RestatePromise.race([
    *           ctx.run(() => longRunningTask(name)),
@@ -118,7 +132,56 @@ interface ContextInternal extends Context {
    * @experimental
    */
   cancelPreviousCalls(): RestatePromise<InvocationId[]>;
+  /**
+   * Get state from the Restate runtime, apply the given `projection` to it,
+   * and record in the journal only the result of the projection.
+   *
+   * Use this to read big state values when you need only a small part of them:
+   * unlike `ctx.get`, the complete state value is not recorded in the journal,
+   * only its projection.
+   *
+   * It will appear in the UI as run(project:state_key).
+   *
+   * This method **MUST** only be used within Virtual Object and Workflow handlers.
+   *
+   * **NOTE:** Requires Restate >= 1.8 with service protocol V8 enabled, and **does not** work with request/response protocol mode (e.g. with AWS Lambda).
+   *
+   * @param name key of the state to retrieve
+   * @param projection function receiving the state value, or `null` if the state is empty.
+   * @param options serde for the state value, and serde for the projection result.
+   * @returns a {@link RestatePromise} resolved with the result of the projection.
+   *
+   * @example
+   * ```ts
+   * const ctxInternal = restate.internal.asInternal(ctx);
+   * const itemsCount = await ctxInternal.getProject<Item[], number>(
+   *   "items",
+   *   (items) => items?.length ?? 0
+   * );
+   * ```
+   *
+   * @experimental
+   */
+  getProject<TValue, TResult>(name: string, projection: (value: TValue | null) => TResult | Promise<TResult>, options?: GetProjectOptions<TValue, TResult>): RestatePromise<TResult>;
 }
+/**
+ * Options for {@link ContextInternal.getProject}.
+ *
+ * @experimental
+ */
+type GetProjectOptions<TValue, TResult> = {
+  /**
+   * Serde used to deserialize the state value.
+   */
+  serde?: Serde<TValue>;
+  /**
+   * Serde used to serialize the projection result, recorded in the journal.
+   *
+   * If not set, defaults to {@link GetProjectOptions.serde} when that is set,
+   * otherwise to the default serde.
+   */
+  resultSerde?: Serde<TResult>;
+};
 //#endregion
 export { internal_d_exports };
 //# sourceMappingURL=internal.d.cts.map

package/dist/internal.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.cts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;AAWiB,UAAA,eAAA,SAAwB,OAAR,CAAA;EAgGf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAA;;;;;;;;;;yBAWO,eAAe"}
+{"version":3,"file":"internal.d.cts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AAiBA;AAWA;;AA2GwC,iBAtHxB,UAAA,CAsHwB,GAAA,EAtHR,OAsHQ,CAAA,EAtHE,eAsHF;;;;;;;;AAmC1B,UA9IG,eAAA,SAAwB,OA8I3B,CAAA;EACM;;;;AAQpB;;;;EAYgB,YAAA,EAAA,EAAA,OAAA;EAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAnEH;;;;;;;;;;yBAWO,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAkChB,kBAAkB,UAAU,QAAQ,oBAC9C,kBAAkB,QAAQ,WACnC,eAAe;;;;;;;KAQR;;;;UAIF,MAAM;;;;;;;gBAQA,MAAM"}

package/dist/internal.d.ts

@@ -1,10 +1,24 @@
 import { isSuspendedError } from "./types/errors.js";
 import { Context, InvocationId, RestatePromise } from "./context.js";
+import { Serde } from "@restatedev/restate-sdk-core";
 
 //#region src/internal.d.ts
 declare namespace internal_d_exports {
-  export { ContextInternal, isSuspendedError };
+  export { ContextInternal, GetProjectOptions, asInternal, isSuspendedError };
 }
+/**
+ * Downcast the given context to {@link ContextInternal}, to access the internal APIs.
+ *
+ * Works with every context type passed to handlers, e.g. `Context`, `ObjectContext`, `ObjectSharedContext`, `WorkflowContext`.
+ *
+ * @example
+ * ```ts
+ * const ctxInternal = restate.internal.asInternal(ctx);
+ * ```
+ *
+ * @experimental
+ */
+declare function asInternal(ctx: Context): ContextInternal;
 /**
  * Internal {@link Context} interface exposing additional features.
  *
@@ -40,7 +54,7 @@ interface ContextInternal extends Context {
    *   name: "greeter",
    *   handlers: {
    *     greet: async (ctx: restate.Context, name: string) => {
-   *       ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const ctxInternal = restate.internal.asInternal(ctx);
    *       const result = await RestatePromise.race([
    *         ctx.run(() => longRunningTask(name)),
    *         ctxInternal.cancellation().map(() => { throw new restate.TerminalError("Cancelled") }),
@@ -58,7 +72,7 @@ interface ContextInternal extends Context {
    *   name: "greeter",
    *   handlers: {
    *     greet: async (ctx: restate.Context, name: string) => {
-   *       const ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const ctxInternal = restate.internal.asInternal(ctx);
    *       const controller = new AbortController();
    *       const cancellation = ctxInternal.cancellation()
    *         .map(() => {
@@ -82,7 +96,7 @@ interface ContextInternal extends Context {
    *   name: "greeter",
    *   handlers: {
    *     greet: async (ctx: restate.Context, name: string) => {
-   *       const ctxInternal = ctx as restate.internal.ContextInternal;
+   *       const ctxInternal = restate.internal.asInternal(ctx);
    *       try {
    *         return await RestatePromise.race([
    *           ctx.run(() => longRunningTask(name)),
@@ -118,7 +132,56 @@ interface ContextInternal extends Context {
    * @experimental
    */
   cancelPreviousCalls(): RestatePromise<InvocationId[]>;
+  /**
+   * Get state from the Restate runtime, apply the given `projection` to it,
+   * and record in the journal only the result of the projection.
+   *
+   * Use this to read big state values when you need only a small part of them:
+   * unlike `ctx.get`, the complete state value is not recorded in the journal,
+   * only its projection.
+   *
+   * It will appear in the UI as run(project:state_key).
+   *
+   * This method **MUST** only be used within Virtual Object and Workflow handlers.
+   *
+   * **NOTE:** Requires Restate >= 1.8 with service protocol V8 enabled, and **does not** work with request/response protocol mode (e.g. with AWS Lambda).
+   *
+   * @param name key of the state to retrieve
+   * @param projection function receiving the state value, or `null` if the state is empty.
+   * @param options serde for the state value, and serde for the projection result.
+   * @returns a {@link RestatePromise} resolved with the result of the projection.
+   *
+   * @example
+   * ```ts
+   * const ctxInternal = restate.internal.asInternal(ctx);
+   * const itemsCount = await ctxInternal.getProject<Item[], number>(
+   *   "items",
+   *   (items) => items?.length ?? 0
+   * );
+   * ```
+   *
+   * @experimental
+   */
+  getProject<TValue, TResult>(name: string, projection: (value: TValue | null) => TResult | Promise<TResult>, options?: GetProjectOptions<TValue, TResult>): RestatePromise<TResult>;
 }
+/**
+ * Options for {@link ContextInternal.getProject}.
+ *
+ * @experimental
+ */
+type GetProjectOptions<TValue, TResult> = {
+  /**
+   * Serde used to deserialize the state value.
+   */
+  serde?: Serde<TValue>;
+  /**
+   * Serde used to serialize the projection result, recorded in the journal.
+   *
+   * If not set, defaults to {@link GetProjectOptions.serde} when that is set,
+   * otherwise to the default serde.
+   */
+  resultSerde?: Serde<TResult>;
+};
 //#endregion
 export { internal_d_exports };
 //# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;AAWiB,UAAA,eAAA,SAAwB,OAAR,CAAA;EAgGf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAA;;;;;;;;;;yBAWO,eAAe"}
+{"version":3,"file":"internal.d.ts","names":[],"sources":["../src/internal.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AAiBA;AAWA;;AA2GwC,iBAtHxB,UAAA,CAsHwB,GAAA,EAtHR,OAsHQ,CAAA,EAtHE,eAsHF;;;;;;;;AAmC1B,UA9IG,eAAA,SAAwB,OA8I3B,CAAA;EACM;;;;AAQpB;;;;EAYgB,YAAA,EAAA,EAAA,OAAA;EAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAnEH;;;;;;;;;;yBAWO,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAkChB,kBAAkB,UAAU,QAAQ,oBAC9C,kBAAkB,QAAQ,WACnC,eAAe;;;;;;;KAQR;;;;UAIF,MAAM;;;;;;;gBAQA,MAAM"}

package/dist/internal.js

@@ -2,7 +2,25 @@ import { __export } from "./_virtual/rolldown_runtime.js";
 import { isSuspendedError } from "./types/errors.js";
 
 //#region src/internal.ts
-var internal_exports = /* @__PURE__ */ __export({ isSuspendedError: () => isSuspendedError });
+var internal_exports = /* @__PURE__ */ __export({
+	asInternal: () => asInternal,
+	isSuspendedError: () => isSuspendedError
+});
+/**
+* Downcast the given context to {@link ContextInternal}, to access the internal APIs.
+*
+* Works with every context type passed to handlers, e.g. `Context`, `ObjectContext`, `ObjectSharedContext`, `WorkflowContext`.
+*
+* @example
+* ```ts
+* const ctxInternal = restate.internal.asInternal(ctx);
+* ```
+*
+* @experimental
+*/
+function asInternal(ctx) {
+	return ctx;
+}
 
 //#endregion
 export { internal_exports };

package/dist/internal.js.map

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

package/dist/lambda.d.cts

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

package/dist/lambda.d.ts

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

package/dist/node.d.cts

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

package/dist/node.d.ts

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

package/dist/package.cjs

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

package/dist/package.js

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

package/dist/package.js.map

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

package/dist/promises.cjs

@@ -234,10 +234,11 @@ var ConstRestatePromise = class ConstRestatePromise extends InternalRestatePromi
 * Promises executor, gluing VM with I/O and Promises given to user space.
 */
 var PromisesExecutor = class {
-	constructor(coreVm, outputPump, runClosuresTracker, externalProgressChannel, errorCallback) {
+	constructor(coreVm, outputPump, runClosuresTracker, ephemeralRequestTracker, externalProgressChannel, errorCallback) {
 		this.coreVm = coreVm;
 		this.outputPump = outputPump;
 		this.runClosuresTracker = runClosuresTracker;
+		this.ephemeralRequestTracker = ephemeralRequestTracker;
 		this.externalProgressChannel = externalProgressChannel;
 		this.errorCallback = errorCallback;
 	}
@@ -263,6 +264,9 @@ var PromisesExecutor = class {
 				} else if (doProgressResult === "CancelSignalReceived") {
 					restatePromise.tryCancel();
 					return;
+				} else if ("EphemeralNotificationReady" in doProgressResult) {
+					const completionId = doProgressResult.EphemeralNotificationReady;
+					await this.ephemeralRequestTracker.complete(completionId, this.coreVm.take_ephemeral_notification(completionId));
 				} else {
 					this.runClosuresTracker.executeRun(doProgressResult.ExecuteRun);
 					await (0, node_timers_promises.setImmediate)();

package/dist/promises.d.cts.map

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

package/dist/promises.d.ts.map

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

package/dist/promises.js

@@ -232,10 +232,11 @@ var ConstRestatePromise = class ConstRestatePromise extends InternalRestatePromi
 * Promises executor, gluing VM with I/O and Promises given to user space.
 */
 var PromisesExecutor = class {
-	constructor(coreVm, outputPump, runClosuresTracker, externalProgressChannel, errorCallback) {
+	constructor(coreVm, outputPump, runClosuresTracker, ephemeralRequestTracker, externalProgressChannel, errorCallback) {
 		this.coreVm = coreVm;
 		this.outputPump = outputPump;
 		this.runClosuresTracker = runClosuresTracker;
+		this.ephemeralRequestTracker = ephemeralRequestTracker;
 		this.externalProgressChannel = externalProgressChannel;
 		this.errorCallback = errorCallback;
 	}
@@ -261,6 +262,9 @@ var PromisesExecutor = class {
 				} else if (doProgressResult === "CancelSignalReceived") {
 					restatePromise.tryCancel();
 					return;
+				} else if ("EphemeralNotificationReady" in doProgressResult) {
+					const completionId = doProgressResult.EphemeralNotificationReady;
+					await this.ephemeralRequestTracker.complete(completionId, this.coreVm.take_ephemeral_notification(completionId));
 				} else {
 					this.runClosuresTracker.executeRun(doProgressResult.ExecuteRun);
 					await setImmediate();