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

package/dist/endpoint.d.cts

@@ -1,7 +1,8 @@
 import { ObjectOptions, ServiceOptions, WorkflowOptions } from "./types/rpc.cjs";
 import { LoggerTransport } from "./logging/logger_transport.cjs";
 import { JournalValueCodec, ServiceDefinition, VirtualObjectDefinition, WorkflowDefinition } from "@restatedev/restate-sdk-core";
-import { Http2ServerRequest, Http2ServerResponse } from "http2";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
 
 //#region src/endpoint.d.ts
 type DefaultServiceOptions = ServiceOptions & ObjectOptions & WorkflowOptions;
@@ -63,12 +64,15 @@ interface RestateEndpointBase<E> {
 /**
  * RestateEndpoint encapsulates all the Restate services served by this endpoint.
  *
- * A RestateEndpoint can either be served as HTTP2 server, using the methods {@link RestateEndpoint.listen} or {@link RestateEndpoint.http2Handler}.
+ * A RestateEndpoint can be served as:
+ * - An HTTP/2 server using {@link RestateEndpoint.listen}, {@link RestateEndpoint.http2Handler}
+ * - An HTTP/1.1 server using {@link RestateEndpoint.http1Handler}
+ * - A combined HTTP/1.1 + HTTP/2 server using {@link RestateEndpoint.handler}
  *
  * For Lambda, check {@link LambdaEndpoint}
  *
  * @example
- * A typical endpoint served as HTTP server would look like this:
+ * A typical endpoint served as HTTP/2 server:
  * ```
  * import * as restate from "@restatedev/restate-sdk";
  *
@@ -77,6 +81,28 @@ interface RestateEndpointBase<E> {
  *   .bind(myService)
  *   .listen(8000);
  * ```
+ *
+ * @example
+ * Using the HTTP/1.1 handler with your own server:
+ * ```
+ * import * as http from "node:http";
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * const endpoint = restate.endpoint().bind(myService);
+ * const server = http.createServer(endpoint.http1Handler());
+ * server.listen(8000);
+ * ```
+ *
+ * @example
+ * Using the combined handler with an HTTP/2 server that also accepts HTTP/1.1:
+ * ```
+ * import * as http2 from "node:http2";
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * const endpoint = restate.endpoint().bind(myService);
+ * const server = http2.createSecureServer({ key, cert, allowHTTP1: true }, endpoint.handler());
+ * server.listen(8000);
+ * ```
  */
 interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
   /**
@@ -103,9 +129,65 @@ interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
    */
   listen(port?: number): Promise<number>;
   /**
-   * Returns an http2 server handler. See {@link RestateEndpoint.listen} for more details.
+   * Returns an http2 server handler.
+   *
+   * By default, this handler uses bidirectional streaming (`BIDI_STREAM`).
+   * Set `bidirectional: false` to use request-response mode (`REQUEST_RESPONSE`).
+   *
+   * See {@link RestateEndpoint.listen} for more details.
+   */
+  http2Handler(options?: {
+    bidirectional?: boolean;
+  }): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+  /**
+   * Returns an http1 server handler.
+   *
+   * By default, this handler operates in request-response protocol mode (`REQUEST_RESPONSE`),
+   * which buffers the full request before sending the response. This is the safest mode
+   * for HTTP/1.1 and works across all environments and proxies.
+   *
+   * Set `bidirectional: true` to enable bidirectional streaming (`BIDI_STREAM`) for
+   * HTTP/1.1 servers that support it. Note that some proxies and clients may not
+   * handle HTTP/1.1 bidirectional streaming correctly.
+   *
+   * @example
+   * ```
+   * const httpServer = http.createServer(endpoint.http1Handler());
+   * httpServer.listen(port);
+   * ```
+   */
+  http1Handler(options?: {
+    bidirectional?: boolean;
+  }): (request: IncomingMessage, response: ServerResponse) => void;
+  /**
+   * Returns a combined request handler that auto-detects HTTP/1 vs HTTP/2
+   * requests and dispatches to the appropriate internal handler.
+   *
+   * By default (when `bidirectional` is omitted), HTTP/2+ requests use
+   * bidirectional streaming (`BIDI_STREAM`) and HTTP/1 requests use
+   * request-response mode (`REQUEST_RESPONSE`).
+   *
+   * Set `bidirectional: true` to force `BIDI_STREAM` for all requests,
+   * or `bidirectional: false` to force `REQUEST_RESPONSE` for all requests.
+   *
+   * This is useful with `http2.createSecureServer({ allowHTTP1: true })`, where
+   * the same server handles both HTTP/1.1 and HTTP/2 connections.
+   *
+   * @example
+   * ```
+   * const server = http2.createSecureServer(
+   *   { key, cert, allowHTTP1: true },
+   *   endpoint.handler()
+   * );
+   * server.listen(port);
+   * ```
    */
-  http2Handler(): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+  handler(options?: {
+    bidirectional?: boolean;
+  }): {
+    (request: IncomingMessage, response: ServerResponse): void;
+    (request: Http2ServerRequest, response: Http2ServerResponse): void;
+  };
 }
 //#endregion
 export { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase };

package/dist/endpoint.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"endpoint.d.cts","names":[],"sources":["../src/endpoint.ts"],"sourcesContent":[],"mappings":";;;;;;KAyBY,qBAAA,GAAwB,iBAClC,gBACA;UAEe;EAJL;;;;;EAIK,IAAA,CAAA,UAAA,MAAA,EAAmB,CAAA,CAAA,CAAA,OAAA,EAQ5B,iBAR4B,CAQV,CARU,EAQP,CARO,CAAA,GAS5B,uBAT4B,CASJ,CATI,EASD,CATC,CAAA,GAU5B,kBAV4B,CAUT,CAVS,EAUN,CAVM,CAAA,CAAA,EAW/B,CAX+B;EAQV;;;;;;;;;EAGrB,cAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EAWgC,CAXhC;EAWgC;;;;;;;EAwCyC,qBAAA,CAAA,OAAA,EA/B7C,qBA+B6C,CAAA,EA/BrB,CA+BqB;EAAC;AAqB/E;;;;;;;;;;;;;;;;;;;;oBA7BoB,kBAAkB;;;;;;;iDAQW,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;;UAqB7D,eAAA,SAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;yBAuBpC;;;;4BAMZ,8BACC"}
+{"version":3,"file":"endpoint.d.cts","names":[],"sources":["../src/endpoint.ts"],"sourcesContent":[],"mappings":";;;;;;;KA0BY,qBAAA,GAAwB,iBAClC,gBACA;UAEe;EAJL;;;;;EAIK,IAAA,CAAA,UAAA,MAAA,EAAmB,CAAA,CAAA,CAAA,OAAA,EAQ5B,iBAR4B,CAQV,CARU,EAQP,CARO,CAAA,GAS5B,uBAT4B,CASJ,CATI,EASD,CATC,CAAA,GAU5B,kBAV4B,CAUT,CAVS,EAUN,CAVM,CAAA,CAAA,EAW/B,CAX+B;EAQV;;;;;;;;;EAGrB,cAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EAWgC,CAXhC;EAWgC;;;;;;;EAwCyC,qBAAA,CAAA,OAAA,EA/B7C,qBA+B6C,CAAA,EA/BrB,CA+BqB;EAAC;AA8C/E;;;;;;;;;;;;;;;;;;;;oBAtDoB,kBAAkB;;;;;;;iDAQW,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8C7D,eAAA,SAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;yBAuBpC;;;;;;;;;;;gBAYT,8BAA8B;;;;;;;;;;;;;;;;;;;;gBAqB9B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0B7B,2BAA2B;cAC3B,8BAA8B"}

package/dist/endpoint.d.ts

@@ -1,7 +1,8 @@
 import { ObjectOptions, ServiceOptions, WorkflowOptions } from "./types/rpc.js";
 import { LoggerTransport } from "./logging/logger_transport.js";
 import { JournalValueCodec, ServiceDefinition, VirtualObjectDefinition, WorkflowDefinition } from "@restatedev/restate-sdk-core";
-import { Http2ServerRequest, Http2ServerResponse } from "http2";
+import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
+import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/endpoint.d.ts
 type DefaultServiceOptions = ServiceOptions & ObjectOptions & WorkflowOptions;
@@ -63,12 +64,15 @@ interface RestateEndpointBase<E> {
 /**
  * RestateEndpoint encapsulates all the Restate services served by this endpoint.
  *
- * A RestateEndpoint can either be served as HTTP2 server, using the methods {@link RestateEndpoint.listen} or {@link RestateEndpoint.http2Handler}.
+ * A RestateEndpoint can be served as:
+ * - An HTTP/2 server using {@link RestateEndpoint.listen}, {@link RestateEndpoint.http2Handler}
+ * - An HTTP/1.1 server using {@link RestateEndpoint.http1Handler}
+ * - A combined HTTP/1.1 + HTTP/2 server using {@link RestateEndpoint.handler}
  *
  * For Lambda, check {@link LambdaEndpoint}
  *
  * @example
- * A typical endpoint served as HTTP server would look like this:
+ * A typical endpoint served as HTTP/2 server:
  * ```
  * import * as restate from "@restatedev/restate-sdk";
  *
@@ -77,6 +81,28 @@ interface RestateEndpointBase<E> {
  *   .bind(myService)
  *   .listen(8000);
  * ```
+ *
+ * @example
+ * Using the HTTP/1.1 handler with your own server:
+ * ```
+ * import * as http from "node:http";
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * const endpoint = restate.endpoint().bind(myService);
+ * const server = http.createServer(endpoint.http1Handler());
+ * server.listen(8000);
+ * ```
+ *
+ * @example
+ * Using the combined handler with an HTTP/2 server that also accepts HTTP/1.1:
+ * ```
+ * import * as http2 from "node:http2";
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * const endpoint = restate.endpoint().bind(myService);
+ * const server = http2.createSecureServer({ key, cert, allowHTTP1: true }, endpoint.handler());
+ * server.listen(8000);
+ * ```
  */
 interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
   /**
@@ -103,9 +129,65 @@ interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
    */
   listen(port?: number): Promise<number>;
   /**
-   * Returns an http2 server handler. See {@link RestateEndpoint.listen} for more details.
+   * Returns an http2 server handler.
+   *
+   * By default, this handler uses bidirectional streaming (`BIDI_STREAM`).
+   * Set `bidirectional: false` to use request-response mode (`REQUEST_RESPONSE`).
+   *
+   * See {@link RestateEndpoint.listen} for more details.
+   */
+  http2Handler(options?: {
+    bidirectional?: boolean;
+  }): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+  /**
+   * Returns an http1 server handler.
+   *
+   * By default, this handler operates in request-response protocol mode (`REQUEST_RESPONSE`),
+   * which buffers the full request before sending the response. This is the safest mode
+   * for HTTP/1.1 and works across all environments and proxies.
+   *
+   * Set `bidirectional: true` to enable bidirectional streaming (`BIDI_STREAM`) for
+   * HTTP/1.1 servers that support it. Note that some proxies and clients may not
+   * handle HTTP/1.1 bidirectional streaming correctly.
+   *
+   * @example
+   * ```
+   * const httpServer = http.createServer(endpoint.http1Handler());
+   * httpServer.listen(port);
+   * ```
+   */
+  http1Handler(options?: {
+    bidirectional?: boolean;
+  }): (request: IncomingMessage, response: ServerResponse) => void;
+  /**
+   * Returns a combined request handler that auto-detects HTTP/1 vs HTTP/2
+   * requests and dispatches to the appropriate internal handler.
+   *
+   * By default (when `bidirectional` is omitted), HTTP/2+ requests use
+   * bidirectional streaming (`BIDI_STREAM`) and HTTP/1 requests use
+   * request-response mode (`REQUEST_RESPONSE`).
+   *
+   * Set `bidirectional: true` to force `BIDI_STREAM` for all requests,
+   * or `bidirectional: false` to force `REQUEST_RESPONSE` for all requests.
+   *
+   * This is useful with `http2.createSecureServer({ allowHTTP1: true })`, where
+   * the same server handles both HTTP/1.1 and HTTP/2 connections.
+   *
+   * @example
+   * ```
+   * const server = http2.createSecureServer(
+   *   { key, cert, allowHTTP1: true },
+   *   endpoint.handler()
+   * );
+   * server.listen(port);
+   * ```
    */
-  http2Handler(): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+  handler(options?: {
+    bidirectional?: boolean;
+  }): {
+    (request: IncomingMessage, response: ServerResponse): void;
+    (request: Http2ServerRequest, response: Http2ServerResponse): void;
+  };
 }
 //#endregion
 export { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase };

package/dist/endpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"endpoint.d.ts","names":[],"sources":["../src/endpoint.ts"],"sourcesContent":[],"mappings":";;;;;;KAyBY,qBAAA,GAAwB,iBAClC,gBACA;UAEe;EAJL;;;;;EAIK,IAAA,CAAA,UAAA,MAAA,EAAmB,CAAA,CAAA,CAAA,OAAA,EAQ5B,iBAR4B,CAQV,CARU,EAQP,CARO,CAAA,GAS5B,uBAT4B,CASJ,CATI,EASD,CATC,CAAA,GAU5B,kBAV4B,CAUT,CAVS,EAUN,CAVM,CAAA,CAAA,EAW/B,CAX+B;EAQV;;;;;;;;;EAGrB,cAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EAWgC,CAXhC;EAWgC;;;;;;;EAwCyC,qBAAA,CAAA,OAAA,EA/B7C,qBA+B6C,CAAA,EA/BrB,CA+BqB;EAAC;AAqB/E;;;;;;;;;;;;;;;;;;;;oBA7BoB,kBAAkB;;;;;;;iDAQW,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;;UAqB7D,eAAA,SAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;yBAuBpC;;;;4BAMZ,8BACC"}
+{"version":3,"file":"endpoint.d.ts","names":[],"sources":["../src/endpoint.ts"],"sourcesContent":[],"mappings":";;;;;;;KA0BY,qBAAA,GAAwB,iBAClC,gBACA;UAEe;EAJL;;;;;EAIK,IAAA,CAAA,UAAA,MAAA,EAAmB,CAAA,CAAA,CAAA,OAAA,EAQ5B,iBAR4B,CAQV,CARU,EAQP,CARO,CAAA,GAS5B,uBAT4B,CASJ,CATI,EASD,CATC,CAAA,GAU5B,kBAV4B,CAUT,CAVS,EAUN,CAVM,CAAA,CAAA,EAW/B,CAX+B;EAQV;;;;;;;;;EAGrB,cAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EAWgC,CAXhC;EAWgC;;;;;;;EAwCyC,qBAAA,CAAA,OAAA,EA/B7C,qBA+B6C,CAAA,EA/BrB,CA+BqB;EAAC;AA8C/E;;;;;;;;;;;;;;;;;;;;oBAtDoB,kBAAkB;;;;;;;iDAQW,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8C7D,eAAA,SAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;yBAuBpC;;;;;;;;;;;gBAYT,8BAA8B;;;;;;;;;;;;;;;;;;;;gBAqB9B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0B7B,2BAA2B;cAC3B,8BAA8B"}

package/dist/error_sanitization.cjs

@@ -0,0 +1,26 @@
+const require_errors = require('./types/errors.cjs');
+const require_context_impl = require('./context_impl.cjs');
+
+//#region src/error_sanitization.ts
+/**
+* Strips SDK-internal metadata from an error before it enters the interceptor
+* chain. Interceptors see a plain Error — no CommandError.
+*/
+function sanitizeError(e) {
+	if (e instanceof require_context_impl.CommandError) return require_errors.ensureError(e.cause);
+	return require_errors.ensureError(e);
+}
+/**
+* Restores SDK-internal metadata after the interceptor chain exits, using the
+* original error's metadata and the interceptor's error as the new cause.
+* If the original had no SDK metadata, the interceptor's error passes through
+* unchanged.
+*/
+function restoreError(interceptorError, original) {
+	if (original instanceof require_context_impl.CommandError) return original.commandIndex !== void 0 ? new require_context_impl.CommandError(interceptorError, original.commandType, original.commandIndex) : new require_context_impl.CommandError(interceptorError, original.commandType);
+	return interceptorError;
+}
+
+//#endregion
+exports.restoreError = restoreError;
+exports.sanitizeError = sanitizeError;

package/dist/error_sanitization.js

@@ -0,0 +1,26 @@
+import { ensureError } from "./types/errors.js";
+import { CommandError } from "./context_impl.js";
+
+//#region src/error_sanitization.ts
+/**
+* Strips SDK-internal metadata from an error before it enters the interceptor
+* chain. Interceptors see a plain Error — no CommandError.
+*/
+function sanitizeError(e) {
+	if (e instanceof CommandError) return ensureError(e.cause);
+	return ensureError(e);
+}
+/**
+* Restores SDK-internal metadata after the interceptor chain exits, using the
+* original error's metadata and the interceptor's error as the new cause.
+* If the original had no SDK metadata, the interceptor's error passes through
+* unchanged.
+*/
+function restoreError(interceptorError, original) {
+	if (original instanceof CommandError) return original.commandIndex !== void 0 ? new CommandError(interceptorError, original.commandType, original.commandIndex) : new CommandError(interceptorError, original.commandType);
+	return interceptorError;
+}
+
+//#endregion
+export { restoreError, sanitizeError };
+//# sourceMappingURL=error_sanitization.js.map

package/dist/error_sanitization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error_sanitization.js","names":[],"sources":["../src/error_sanitization.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\nimport { CommandError } from \"./context_impl.js\";\nimport { ensureError } from \"./types/errors.js\";\n\n/**\n * Strips SDK-internal metadata from an error before it enters the interceptor\n * chain. Interceptors see a plain Error — no CommandError.\n */\nexport function sanitizeError(e: unknown): Error {\n  if (e instanceof CommandError) return ensureError(e.cause);\n  return ensureError(e);\n}\n\n/**\n * Restores SDK-internal metadata after the interceptor chain exits, using the\n * original error's metadata and the interceptor's error as the new cause.\n * If the original had no SDK metadata, the interceptor's error passes through\n * unchanged.\n */\nexport function restoreError(\n  interceptorError: unknown,\n  original: unknown\n): unknown {\n  if (original instanceof CommandError) {\n    return original.commandIndex !== undefined\n      ? new CommandError(\n          interceptorError,\n          original.commandType,\n          original.commandIndex\n        )\n      : new CommandError(interceptorError, original.commandType);\n  }\n  return interceptorError;\n}\n"],"mappings":";;;;;;;;AAkBA,SAAgB,cAAc,GAAmB;AAC/C,KAAI,aAAa,aAAc,QAAO,YAAY,EAAE,MAAM;AAC1D,QAAO,YAAY,EAAE;;;;;;;;AASvB,SAAgB,aACd,kBACA,UACS;AACT,KAAI,oBAAoB,aACtB,QAAO,SAAS,iBAAiB,SAC7B,IAAI,aACF,kBACA,SAAS,aACT,SAAS,aACV,GACD,IAAI,aAAa,kBAAkB,SAAS,YAAY;AAE9D,QAAO"}

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

package/dist/fetch.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.cts","names":[],"sources":["../src/fetch.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;iBAyBgB,QAAA,CAAA,GAAY;UAIX,oBAAA,SAA6B;;AAJ9C;AAIA;AAiCA;;;;;EAAmE,aAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;iBAAnD,qBAAA,UAA+B,iCAAoB,qCAAA,QAAA"}
+{"version":3,"file":"fetch.d.cts","names":[],"sources":["../src/fetch.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;iBAyBgB,QAAA,CAAA,GAAY;UAIX,oBAAA,SAA6B;;;;AAJ9C;AAIA;AAiCA;;;EAAmE,aAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;iBAAnD,qBAAA,UAA+B,iCAAoB,qCAAA,QAAA"}

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

package/dist/fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.ts","names":[],"sources":["../src/fetch.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;iBAyBgB,QAAA,CAAA,GAAY;UAIX,oBAAA,SAA6B;;AAJ9C;AAIA;AAiCA;;;;;EAAmE,aAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;iBAAnD,qBAAA,UAA+B,iCAAoB,qCAAA,QAAA"}
+{"version":3,"file":"fetch.d.ts","names":[],"sources":["../src/fetch.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;iBAyBgB,QAAA,CAAA,GAAY;UAIX,oBAAA,SAA6B;;;;AAJ9C;AAIA;AAiCA;;;EAAmE,aAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;iBAAnD,qBAAA,UAA+B,iCAAoB,qCAAA,QAAA"}

package/dist/fetch.js.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.js","names":[],"sources":["../src/fetch.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  type FetchEndpoint,\n  FetchEndpointImpl,\n} from \"./endpoint/fetch_endpoint.js\";\nimport type { EndpointOptions } from \"./endpoint/types.js\";\nimport { withOptions } from \"./endpoint/withOptions.js\";\n\n/**\n * Create a new {@link RestateEndpoint} in request response protocol mode.\n * Bidirectional mode (must be served over http2) can be enabled with .enableHttp2()\n * @deprecated Please use {@link createEndpointHandler}\n */\nexport function endpoint(): FetchEndpoint {\n  return new FetchEndpointImpl(\"REQUEST_RESPONSE\");\n}\n\nexport interface FetchEndpointOptions extends EndpointOptions {\n  /**\n   * Enables bidirectional communication for the handler.\n   *\n   * When set to `true`, the handler supports bidirectional streaming (e.g., via HTTP/2 or compatible HTTP/1.1 servers).\n   * When `false`, the handler operates in request-response mode only.\n   *\n   * @default false\n   */\n  bidirectional?: boolean;\n}\n\n/**\n * Creates a Fetch handler that encapsulates all the Restate services served by this endpoint.\n *\n * @param {FetchEndpointOptions} options - Configuration options for the endpoint handler.\n * @returns A fetch handler function.\n *\n * @example\n * A typical request-response handler would look like this:\n * ```\n * import { createEndpointHandler } from \"@restatedev/restate-sdk/fetch\";\n *\n * export const handler = createEndpointHandler({ services: [myService] })\n *\n * @example\n * A typical bidirectional handler (works with http2 and some http1.1 servers) would look like this:\n * ```\n * import { createEndpointHandler } from \"@restatedev/restate-sdk/fetch\";\n *\n * export const handler = createEndpointHandler({ services: [myService], bidirectional: true })\n *\n */\nexport function createEndpointHandler(options: FetchEndpointOptions) {\n  return withOptions<FetchEndpoint>(\n    new FetchEndpointImpl(\n      options.bidirectional ? \"BIDI_STREAM\" : \"REQUEST_RESPONSE\"\n    ),\n    options\n  ).handler().fetch;\n}\nexport { type FetchEndpoint } from \"./endpoint/fetch_endpoint.js\";\n"],"mappings":";;;;;;;;;;;;;;AAyBA,SAAgB,WAA0B;AACxC,QAAO,IAAI,kBAAkB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;AAoClD,SAAgB,sBAAsB,SAA+B;AACnE,QAAO,YACL,IAAI,kBACF,QAAQ,gBAAgB,gBAAgB,mBACzC,EACD,QACD,CAAC,SAAS,CAAC"}
+{"version":3,"file":"fetch.js","names":[],"sources":["../src/fetch.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  type FetchEndpoint,\n  FetchEndpointImpl,\n} from \"./endpoint/fetch_endpoint.js\";\nimport type { EndpointOptions } from \"./endpoint/types.js\";\nimport { withOptions } from \"./endpoint/withOptions.js\";\n\n/**\n * Create a new {@link RestateEndpoint} in request response protocol mode.\n * Bidirectional mode (must be served over http2) can be enabled with .enableHttp2()\n * @deprecated Please use {@link createEndpointHandler}\n */\nexport function endpoint(): FetchEndpoint {\n  return new FetchEndpointImpl(\"REQUEST_RESPONSE\");\n}\n\nexport interface FetchEndpointOptions extends EndpointOptions {\n  /**\n   * Enables bidirectional communication for the handler.\n   *\n   * When set to `true`, the handler supports bidirectional streaming (e.g., via HTTP/2 or compatible HTTP/1.1 servers).\n   * When `false`, the handler operates in request-response mode only.\n   *\n   * @default false\n   */\n  bidirectional?: boolean;\n}\n\n/**\n * Creates a Fetch handler that encapsulates all the Restate services served by this endpoint.\n *\n * @param {FetchEndpointOptions} options - Configuration options for the endpoint handler.\n * @returns A fetch handler function.\n *\n * @example\n * A typical request-response handler would look like this:\n * ```\n * import { createEndpointHandler } from \"@restatedev/restate-sdk/fetch\";\n *\n * export const handler = createEndpointHandler({ services: [myService] })\n *\n * @example\n * A typical bidirectional handler (works with http2 and some http1.1 servers) would look like this:\n * ```\n * import { createEndpointHandler } from \"@restatedev/restate-sdk/fetch\";\n *\n * export const handler = createEndpointHandler({ services: [myService], bidirectional: true })\n *\n */\nexport function createEndpointHandler(options: FetchEndpointOptions) {\n  return withOptions<FetchEndpoint>(\n    new FetchEndpointImpl(\n      options.bidirectional ? \"BIDI_STREAM\" : \"REQUEST_RESPONSE\"\n    ),\n    options\n  ).handler().fetch;\n}\nexport { type FetchEndpoint } from \"./endpoint/fetch_endpoint.js\";\n"],"mappings":";;;;;;;;;;;;;;;AAyBA,SAAgB,WAA0B;AACxC,QAAO,IAAI,kBAAkB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;AAoClD,SAAgB,sBAAsB,SAA+B;AACnE,QAAO,YACL,IAAI,kBACF,QAAQ,gBAAgB,gBAAgB,mBACzC,EACD,QACD,CAAC,SAAS,CAAC"}

package/dist/hooks.d.cts

@@ -0,0 +1,87 @@
+import { Request } from "./context.cjs";
+
+//#region src/hooks.d.ts
+
+/**
+ * Interceptors wrap handler and ctx.run() execution. They are part of the
+ * invocation — anything that happens inside them (including after `next()`)
+ * affects the invocation outcome.
+ *
+ * ## Error behavior
+ *
+ * Errors thrown at any point (before or after `next()`) affect the invocation:
+ *
+ * - **{@link TerminalError}** — the invocation **fails immediately**, no retry.
+ * - **Any other error** — Restate **retries** the invocation.
+ * - On suspension or pause, `next()` also rejects with an error. This does not
+ *   mean the invocation failed — the attempt is simply ending. Do any cleanup
+ *   you need and rethrow.
+ *
+ * ## Output
+ *
+ * Interceptors **cannot alter the handler's success return value** (the `void`
+ * signature means there is no way to replace it), but they **can transform
+ * errors** by catching and rethrowing a different error.
+ *
+ * ## Rules
+ *
+ * - `next()` must be called exactly once.
+ *
+ * ## When interceptors fire
+ *
+ * - `handler` fires on every attempt.
+ * - `run` fires when the `ctx.run()` closure executes. If the result is
+ *   already in the journal, the closure is skipped and so is the interceptor.
+ *
+ * @example
+ * ```ts
+ * interceptor: {
+ *   handler: async (next) => {
+ *     console.log(`before ${ctx.request.target}`);
+ *     try {
+ *       await next();
+ *       console.log(`after ${ctx.request.target}`);
+ *     } catch (e) {
+ *       console.log(`error ${ctx.request.target}: ${e}`);
+ *       // Always rethrow — swallowing the error changes the
+ *       // invocation outcome. You can also throw a different
+ *       // error (e.g. TerminalError to fail immediately).
+ *       throw e;
+ *     }
+ *   },
+ *   run: async (name, next) => {
+ *     console.log(`  before run "${name}"`);
+ *     try {
+ *       await next();
+ *       console.log(`  after run "${name}"`);
+ *     } catch (e) {
+ *       console.log(`  error run "${name}": ${e}`);
+ *       throw e;
+ *     }
+ *   },
+ * }
+ * ```
+ */
+interface Interceptor {
+  /** Wraps the entire handler invocation. Fires on every attempt. */
+  handler?: (next: () => Promise<void>) => Promise<void>;
+  /**
+   * Wraps each `ctx.run()` call. Only fires for runs that actually execute —
+   * replayed runs (already in the journal) are skipped.
+   * `name` is the run's label.
+   */
+  run?: (name: string, next: () => Promise<void>) => Promise<void>;
+}
+interface Hooks {
+  interceptor?: Interceptor;
+}
+/**
+ * Factory called on every attempt. Receives the invocation request,
+ * returns hooks for that attempt's lifetime. Each attempt gets a fresh call.
+ */
+type HooksProvider = (ctx: {
+  request: Request;
+}) => Hooks;
+//#endregion
+export { Hooks, HooksProvider, Interceptor };
+//# sourceMappingURL=hooks.d.cts.map

package/dist/hooks.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.cts","names":[],"sources":["../src/hooks.ts"],"sourcesContent":[],"mappings":";;;;;;AAgEA;;;;;;AAaA;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAvBiB,WAAA;;yBAEQ,kBAAkB;;;;;;mCAMR,kBAAkB;;UAKpC,KAAA;gBACD;;;;;;KASJ,aAAA;WAAiC;MAAc"}

package/dist/hooks.d.ts

@@ -0,0 +1,87 @@
+import { Request } from "./context.js";
+
+//#region src/hooks.d.ts
+
+/**
+ * Interceptors wrap handler and ctx.run() execution. They are part of the
+ * invocation — anything that happens inside them (including after `next()`)
+ * affects the invocation outcome.
+ *
+ * ## Error behavior
+ *
+ * Errors thrown at any point (before or after `next()`) affect the invocation:
+ *
+ * - **{@link TerminalError}** — the invocation **fails immediately**, no retry.
+ * - **Any other error** — Restate **retries** the invocation.
+ * - On suspension or pause, `next()` also rejects with an error. This does not
+ *   mean the invocation failed — the attempt is simply ending. Do any cleanup
+ *   you need and rethrow.
+ *
+ * ## Output
+ *
+ * Interceptors **cannot alter the handler's success return value** (the `void`
+ * signature means there is no way to replace it), but they **can transform
+ * errors** by catching and rethrowing a different error.
+ *
+ * ## Rules
+ *
+ * - `next()` must be called exactly once.
+ *
+ * ## When interceptors fire
+ *
+ * - `handler` fires on every attempt.
+ * - `run` fires when the `ctx.run()` closure executes. If the result is
+ *   already in the journal, the closure is skipped and so is the interceptor.
+ *
+ * @example
+ * ```ts
+ * interceptor: {
+ *   handler: async (next) => {
+ *     console.log(`before ${ctx.request.target}`);
+ *     try {
+ *       await next();
+ *       console.log(`after ${ctx.request.target}`);
+ *     } catch (e) {
+ *       console.log(`error ${ctx.request.target}: ${e}`);
+ *       // Always rethrow — swallowing the error changes the
+ *       // invocation outcome. You can also throw a different
+ *       // error (e.g. TerminalError to fail immediately).
+ *       throw e;
+ *     }
+ *   },
+ *   run: async (name, next) => {
+ *     console.log(`  before run "${name}"`);
+ *     try {
+ *       await next();
+ *       console.log(`  after run "${name}"`);
+ *     } catch (e) {
+ *       console.log(`  error run "${name}": ${e}`);
+ *       throw e;
+ *     }
+ *   },
+ * }
+ * ```
+ */
+interface Interceptor {
+  /** Wraps the entire handler invocation. Fires on every attempt. */
+  handler?: (next: () => Promise<void>) => Promise<void>;
+  /**
+   * Wraps each `ctx.run()` call. Only fires for runs that actually execute —
+   * replayed runs (already in the journal) are skipped.
+   * `name` is the run's label.
+   */
+  run?: (name: string, next: () => Promise<void>) => Promise<void>;
+}
+interface Hooks {
+  interceptor?: Interceptor;
+}
+/**
+ * Factory called on every attempt. Receives the invocation request,
+ * returns hooks for that attempt's lifetime. Each attempt gets a fresh call.
+ */
+type HooksProvider = (ctx: {
+  request: Request;
+}) => Hooks;
+//#endregion
+export { Hooks, HooksProvider, Interceptor };
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../src/hooks.ts"],"sourcesContent":[],"mappings":";;;;;;AAgEA;;;;;;AAaA;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAvBiB,WAAA;;yBAEQ,kBAAkB;;;;;;mCAMR,kBAAkB;;UAKpC,KAAA;gBACD;;;;;;KASJ,aAAA;WAAiC;MAAc"}

package/dist/index.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_node = require('./node.cjs');
@@ -37,6 +38,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,