@restatedev/restate-sdk 1.9.1 → 1.10.0

package/dist/endpoint.d.cts

@@ -0,0 +1,112 @@
+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";
+
+//#region src/endpoint.d.ts
+type DefaultServiceOptions = ServiceOptions & ObjectOptions & WorkflowOptions;
+interface RestateEndpointBase<E> {
+  /**
+   * Binds a new durable service / virtual object / workflow.
+   *
+   * see restate.service, restate.object, and restate.workflow for more details.
+   **/
+  bind<P extends string, M>(service: ServiceDefinition<P, M> | VirtualObjectDefinition<P, M> | WorkflowDefinition<P, M>): E;
+  /**
+   * Provide a list of v1 request identity public keys eg `publickeyv1_2G8dCQhArfvGpzPw5Vx2ALciR4xCLHfS5YaT93XjNxX9` to validate
+   * incoming requests against, limiting requests to Restate clusters with the corresponding private keys. This public key format is
+   * logged by the Restate process at startup if a request identity private key is provided.
+   *
+   * If this function is called, all incoming requests irrelevant of endpoint type will be expected to have
+   * `x-restate-signature-scheme: v1` and `x-restate-jwt-v1: <valid jwt signed with one of these keys>`. If not called,
+   *
+   */
+  withIdentityV1(...keys: string[]): E;
+  /**
+   * Set default service options that will be used by all services bind to this endpoint.
+   *
+   * Options can be overridden on each service/handler.
+   *
+   * @param options
+   */
+  defaultServiceOptions(options: DefaultServiceOptions): E;
+  /**
+   * Replace the default console-based {@link LoggerTransport}
+   * @param logger
+   * @example
+   * Using console:
+   * ```ts
+   * restate.setLogger((meta, message, ...o) => {console.log(`${meta.level}: `, message, ...o)})
+   * ```
+   * @example
+   * Using winston:
+   * ```ts
+   * const logger = createLogger({ ... })
+   * restate.setLogger((meta, message, ...o) => {logger.log(meta.level, {invocationId: meta.context?.invocationId}, [message, ...o].join(' '))})
+   * ```
+   * @example
+   * Using pino:
+   * ```ts
+   * const logger = pino()
+   * restate.setLogger((meta, message, ...o) => {logger[meta.level]({invocationId: meta.context?.invocationId}, [message, ...o].join(' '))})
+   * ```
+   */
+  setLogger(logger: LoggerTransport): E;
+  /**
+   * Provider for the codec to use for journal values. One codec will be instantiated globally for this endpoint.
+   * Check {@link JournalValueCodec} for more details
+   *
+   * @experimental
+   */
+  journalValueCodecProvider(codecProvider: () => Promise<JournalValueCodec>): 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}.
+ *
+ * For Lambda, check {@link LambdaEndpoint}
+ *
+ * @example
+ * A typical endpoint served as HTTP server would look like this:
+ * ```
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * restate
+ *   .endpoint()
+ *   .bind(myService)
+ *   .listen(8000);
+ * ```
+ */
+interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
+  /**
+   * Serve this Restate Endpoint as HTTP2 server, listening to the given port.
+   *
+   * If the port is undefined, this method will use the port set in the `PORT`
+   * environment variable. If that variable is undefined as well, the method will
+   * default to port 9080.
+   *
+   * The returned promise resolves with the bound port when the server starts listening, or rejects with a failure otherwise.
+   *
+   * This method is a shorthand for:
+   *
+   * @example
+   * ```
+   * const httpServer = http2.createServer(endpoint.http2Handler());
+   * httpServer.listen(port);
+   * ```
+   *
+   * If you need to manually control the server lifecycle, we suggest to manually instantiate the http2 server and use {@link RestateEndpoint.http2Handler}.
+   *
+   * @param port The port to listen at. May be undefined (see above).
+   * @returns a Promise that resolves with the bound port, or rejects with a failure otherwise.
+   */
+  listen(port?: number): Promise<number>;
+  /**
+   * Returns an http2 server handler. See {@link RestateEndpoint.listen} for more details.
+   */
+  http2Handler(): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+}
+//#endregion
+export { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase };
+//# sourceMappingURL=endpoint.d.cts.map

package/dist/endpoint.d.cts.map

@@ -0,0 +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"}

package/dist/endpoint.d.ts

@@ -0,0 +1,112 @@
+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";
+
+//#region src/endpoint.d.ts
+type DefaultServiceOptions = ServiceOptions & ObjectOptions & WorkflowOptions;
+interface RestateEndpointBase<E> {
+  /**
+   * Binds a new durable service / virtual object / workflow.
+   *
+   * see restate.service, restate.object, and restate.workflow for more details.
+   **/
+  bind<P extends string, M>(service: ServiceDefinition<P, M> | VirtualObjectDefinition<P, M> | WorkflowDefinition<P, M>): E;
+  /**
+   * Provide a list of v1 request identity public keys eg `publickeyv1_2G8dCQhArfvGpzPw5Vx2ALciR4xCLHfS5YaT93XjNxX9` to validate
+   * incoming requests against, limiting requests to Restate clusters with the corresponding private keys. This public key format is
+   * logged by the Restate process at startup if a request identity private key is provided.
+   *
+   * If this function is called, all incoming requests irrelevant of endpoint type will be expected to have
+   * `x-restate-signature-scheme: v1` and `x-restate-jwt-v1: <valid jwt signed with one of these keys>`. If not called,
+   *
+   */
+  withIdentityV1(...keys: string[]): E;
+  /**
+   * Set default service options that will be used by all services bind to this endpoint.
+   *
+   * Options can be overridden on each service/handler.
+   *
+   * @param options
+   */
+  defaultServiceOptions(options: DefaultServiceOptions): E;
+  /**
+   * Replace the default console-based {@link LoggerTransport}
+   * @param logger
+   * @example
+   * Using console:
+   * ```ts
+   * restate.setLogger((meta, message, ...o) => {console.log(`${meta.level}: `, message, ...o)})
+   * ```
+   * @example
+   * Using winston:
+   * ```ts
+   * const logger = createLogger({ ... })
+   * restate.setLogger((meta, message, ...o) => {logger.log(meta.level, {invocationId: meta.context?.invocationId}, [message, ...o].join(' '))})
+   * ```
+   * @example
+   * Using pino:
+   * ```ts
+   * const logger = pino()
+   * restate.setLogger((meta, message, ...o) => {logger[meta.level]({invocationId: meta.context?.invocationId}, [message, ...o].join(' '))})
+   * ```
+   */
+  setLogger(logger: LoggerTransport): E;
+  /**
+   * Provider for the codec to use for journal values. One codec will be instantiated globally for this endpoint.
+   * Check {@link JournalValueCodec} for more details
+   *
+   * @experimental
+   */
+  journalValueCodecProvider(codecProvider: () => Promise<JournalValueCodec>): 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}.
+ *
+ * For Lambda, check {@link LambdaEndpoint}
+ *
+ * @example
+ * A typical endpoint served as HTTP server would look like this:
+ * ```
+ * import * as restate from "@restatedev/restate-sdk";
+ *
+ * restate
+ *   .endpoint()
+ *   .bind(myService)
+ *   .listen(8000);
+ * ```
+ */
+interface RestateEndpoint extends RestateEndpointBase<RestateEndpoint> {
+  /**
+   * Serve this Restate Endpoint as HTTP2 server, listening to the given port.
+   *
+   * If the port is undefined, this method will use the port set in the `PORT`
+   * environment variable. If that variable is undefined as well, the method will
+   * default to port 9080.
+   *
+   * The returned promise resolves with the bound port when the server starts listening, or rejects with a failure otherwise.
+   *
+   * This method is a shorthand for:
+   *
+   * @example
+   * ```
+   * const httpServer = http2.createServer(endpoint.http2Handler());
+   * httpServer.listen(port);
+   * ```
+   *
+   * If you need to manually control the server lifecycle, we suggest to manually instantiate the http2 server and use {@link RestateEndpoint.http2Handler}.
+   *
+   * @param port The port to listen at. May be undefined (see above).
+   * @returns a Promise that resolves with the bound port, or rejects with a failure otherwise.
+   */
+  listen(port?: number): Promise<number>;
+  /**
+   * Returns an http2 server handler. See {@link RestateEndpoint.listen} for more details.
+   */
+  http2Handler(): (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+}
+//#endregion
+export { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase };
+//# sourceMappingURL=endpoint.d.ts.map

package/dist/endpoint.d.ts.map

@@ -0,0 +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"}

package/dist/endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint.js","sourceRoot":"","sources":["../src/endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/fetch.cjs

@@ -0,0 +1,83 @@
+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_context = require('./context.cjs');
+const require_common_api = require('./common_api.cjs');
+const require_fetch_endpoint = require('./endpoint/fetch_endpoint.cjs');
+const require_withOptions = require('./endpoint/withOptions.cjs');
+let __restatedev_restate_sdk_core = require("@restatedev/restate-sdk-core");
+__restatedev_restate_sdk_core = require_rolldown_runtime.__toESM(__restatedev_restate_sdk_core);
+
+//#region src/fetch.ts
+/**
+* Create a new {@link RestateEndpoint} in request response protocol mode.
+* Bidirectional mode (must be served over http2) can be enabled with .enableHttp2()
+* @deprecated Please use {@link createEndpointHandler}
+*/
+function endpoint() {
+	return new require_fetch_endpoint.FetchEndpointImpl("REQUEST_RESPONSE");
+}
+/**
+* Creates a Fetch handler that encapsulates all the Restate services served by this endpoint.
+*
+* @param {FetchEndpointOptions} options - Configuration options for the endpoint handler.
+* @returns A fetch handler function.
+*
+* @example
+* A typical request-response handler would look like this:
+* ```
+* import { createEndpointHandler } from "@restatedev/restate-sdk/fetch";
+*
+* export const handler = createEndpointHandler({ services: [myService] })
+*
+* @example
+* A typical bidirectional handler (works with http2 and some http1.1 servers) would look like this:
+* ```
+* import { createEndpointHandler } from "@restatedev/restate-sdk/fetch";
+*
+* export const handler = createEndpointHandler({ services: [myService], bidirectional: true })
+*
+*/
+function createEndpointHandler(options) {
+	return require_withOptions.withOptions(new require_fetch_endpoint.FetchEndpointImpl(options.bidirectional ? "BIDI_STREAM" : "REQUEST_RESPONSE"), options).handler().fetch;
+}
+
+//#endregion
+exports.CancelledError = require_errors.CancelledError;
+exports.CombineablePromise = require_common_api.CombineablePromise;
+exports.InvocationIdParser = require_context.InvocationIdParser;
+exports.Opts = require_rpc.Opts;
+exports.RestateError = require_errors.RestateError;
+exports.RestatePromise = require_context.RestatePromise;
+exports.RetryableError = require_errors.RetryableError;
+exports.SendOpts = require_rpc.SendOpts;
+exports.TerminalError = require_errors.TerminalError;
+exports.TimeoutError = require_errors.TimeoutError;
+exports.createEndpointHandler = createEndpointHandler;
+exports.createObjectHandler = require_common_api.createObjectHandler;
+exports.createObjectSharedHandler = require_common_api.createObjectSharedHandler;
+exports.createServiceHandler = require_common_api.createServiceHandler;
+exports.createWorkflowHandler = require_common_api.createWorkflowHandler;
+exports.createWorkflowSharedHandler = require_common_api.createWorkflowSharedHandler;
+exports.endpoint = endpoint;
+Object.defineProperty(exports, 'handlers', {
+  enumerable: true,
+  get: function () {
+    return require_rpc.handlers;
+  }
+});
+exports.object = require_rpc.object;
+Object.defineProperty(exports, 'rpc', {
+  enumerable: true,
+  get: function () {
+    return require_rpc.rpc;
+  }
+});
+Object.defineProperty(exports, 'serde', {
+  enumerable: true,
+  get: function () {
+    return __restatedev_restate_sdk_core.serde;
+  }
+});
+exports.service = require_rpc.service;
+exports.workflow = require_rpc.workflow;

package/dist/fetch.d.cts

@@ -0,0 +1,52 @@
+import { CancelledError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.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 { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.cjs";
+import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.cjs";
+import { EndpointOptions } from "./endpoint/types.cjs";
+import { CombineablePromise, Duration, JournalValueCodec, ObjectHandler, RestateContext, RestateObjectContext, RestateObjectSharedContext, RestateWorkflowContext, RestateWorkflowSharedContext, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowSharedHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, serde } from "./common_api.cjs";
+import { FetchEndpoint } from "./endpoint/fetch_endpoint.cjs";
+
+//#region src/fetch.d.ts
+/**
+ * Create a new {@link RestateEndpoint} in request response protocol mode.
+ * Bidirectional mode (must be served over http2) can be enabled with .enableHttp2()
+ * @deprecated Please use {@link createEndpointHandler}
+ */
+declare function endpoint(): FetchEndpoint;
+interface FetchEndpointOptions extends EndpointOptions {
+  /**
+   * Enables bidirectional communication for the handler.
+   *
+   * When set to `true`, the handler supports bidirectional streaming (e.g., via HTTP/2 or compatible HTTP/1.1 servers).
+   * When `false`, the handler operates in request-response mode only.
+   *
+   * @default false
+   */
+  bidirectional?: boolean;
+}
+/**
+ * Creates a Fetch handler that encapsulates all the Restate services served by this endpoint.
+ *
+ * @param {FetchEndpointOptions} options - Configuration options for the endpoint handler.
+ * @returns A fetch handler function.
+ *
+ * @example
+ * A typical request-response handler would look like this:
+ * ```
+ * import { createEndpointHandler } from "@restatedev/restate-sdk/fetch";
+ *
+ * export const handler = createEndpointHandler({ services: [myService] })
+ *
+ * @example
+ * A typical bidirectional handler (works with http2 and some http1.1 servers) would look like this:
+ * ```
+ * import { createEndpointHandler } from "@restatedev/restate-sdk/fetch";
+ *
+ * export const handler = createEndpointHandler({ services: [myService], bidirectional: true })
+ *
+ */
+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, object, rpc, serde, service, workflow };
+//# sourceMappingURL=fetch.d.cts.map

package/dist/fetch.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.cts","names":[],"sources":["../src/fetch.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBAyBgB,QAAA,CAAA,GAAY;UAIX,oBAAA,SAA6B;EAJ9B;AAIhB;AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,UAA+B,iCAAoB,qCAAA,QAAA"}

package/dist/fetch.d.ts

@@ -0,0 +1,52 @@
+import { CancelledError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError } from "./types/errors.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 { LogMetadata, LogSource, LoggerContext, LoggerTransport, RestateLogLevel } from "./logging/logger_transport.js";
+import { DefaultServiceOptions, RestateEndpoint, RestateEndpointBase } from "./endpoint.js";
+import { EndpointOptions } from "./endpoint/types.js";
+import { CombineablePromise, Duration, JournalValueCodec, ObjectHandler, RestateContext, RestateObjectContext, RestateObjectSharedContext, RestateWorkflowContext, RestateWorkflowSharedContext, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowSharedHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, serde } from "./common_api.js";
+import { FetchEndpoint } from "./endpoint/fetch_endpoint.js";
+
+//#region src/fetch.d.ts
+/**
+ * Create a new {@link RestateEndpoint} in request response protocol mode.
+ * Bidirectional mode (must be served over http2) can be enabled with .enableHttp2()
+ * @deprecated Please use {@link createEndpointHandler}
+ */
+declare function endpoint(): FetchEndpoint;
+interface FetchEndpointOptions extends EndpointOptions {
+  /**
+   * Enables bidirectional communication for the handler.
+   *
+   * When set to `true`, the handler supports bidirectional streaming (e.g., via HTTP/2 or compatible HTTP/1.1 servers).
+   * When `false`, the handler operates in request-response mode only.
+   *
+   * @default false
+   */
+  bidirectional?: boolean;
+}
+/**
+ * Creates a Fetch handler that encapsulates all the Restate services served by this endpoint.
+ *
+ * @param {FetchEndpointOptions} options - Configuration options for the endpoint handler.
+ * @returns A fetch handler function.
+ *
+ * @example
+ * A typical request-response handler would look like this:
+ * ```
+ * import { createEndpointHandler } from "@restatedev/restate-sdk/fetch";
+ *
+ * export const handler = createEndpointHandler({ services: [myService] })
+ *
+ * @example
+ * A typical bidirectional handler (works with http2 and some http1.1 servers) would look like this:
+ * ```
+ * import { createEndpointHandler } from "@restatedev/restate-sdk/fetch";
+ *
+ * export const handler = createEndpointHandler({ services: [myService], bidirectional: true })
+ *
+ */
+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, object, rpc, serde, service, workflow };
+//# sourceMappingURL=fetch.d.ts.map

package/dist/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","names":[],"sources":["../src/fetch.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBAyBgB,QAAA,CAAA,GAAY;UAIX,oBAAA,SAA6B;EAJ9B;AAIhB;AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,qBAAA,UAA+B,iCAAoB,qCAAA,QAAA"}

package/dist/fetch.js

@@ -0,0 +1,44 @@
+import { CancelledError, RestateError, RetryableError, TerminalError, TimeoutError } from "./types/errors.js";
+import { Opts, SendOpts, handlers, object, rpc, service, workflow } from "./types/rpc.js";
+import { InvocationIdParser, RestatePromise } from "./context.js";
+import { CombineablePromise, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, serde } from "./common_api.js";
+import { FetchEndpointImpl } from "./endpoint/fetch_endpoint.js";
+import { withOptions } from "./endpoint/withOptions.js";
+
+//#region src/fetch.ts
+/**
+* Create a new {@link RestateEndpoint} in request response protocol mode.
+* Bidirectional mode (must be served over http2) can be enabled with .enableHttp2()
+* @deprecated Please use {@link createEndpointHandler}
+*/
+function endpoint() {
+	return new FetchEndpointImpl("REQUEST_RESPONSE");
+}
+/**
+* Creates a Fetch handler that encapsulates all the Restate services served by this endpoint.
+*
+* @param {FetchEndpointOptions} options - Configuration options for the endpoint handler.
+* @returns A fetch handler function.
+*
+* @example
+* A typical request-response handler would look like this:
+* ```
+* import { createEndpointHandler } from "@restatedev/restate-sdk/fetch";
+*
+* export const handler = createEndpointHandler({ services: [myService] })
+*
+* @example
+* A typical bidirectional handler (works with http2 and some http1.1 servers) would look like this:
+* ```
+* import { createEndpointHandler } from "@restatedev/restate-sdk/fetch";
+*
+* export const handler = createEndpointHandler({ services: [myService], bidirectional: true })
+*
+*/
+function createEndpointHandler(options) {
+	return withOptions(new FetchEndpointImpl(options.bidirectional ? "BIDI_STREAM" : "REQUEST_RESPONSE"), options).handler().fetch;
+}
+
+//#endregion
+export { CancelledError, CombineablePromise, InvocationIdParser, Opts, RestateError, RestatePromise, RetryableError, SendOpts, TerminalError, TimeoutError, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, object, rpc, serde, service, workflow };
+//# sourceMappingURL=fetch.js.map

package/dist/fetch.js.map

@@ -0,0 +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"}

package/dist/index.cjs

@@ -0,0 +1,48 @@
+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_context = require('./context.cjs');
+const require_common_api = require('./common_api.cjs');
+const require_node = require('./node.cjs');
+let __restatedev_restate_sdk_core = require("@restatedev/restate-sdk-core");
+__restatedev_restate_sdk_core = require_rolldown_runtime.__toESM(__restatedev_restate_sdk_core);
+
+exports.CancelledError = require_errors.CancelledError;
+exports.CombineablePromise = require_common_api.CombineablePromise;
+exports.InvocationIdParser = require_context.InvocationIdParser;
+exports.Opts = require_rpc.Opts;
+exports.RestateError = require_errors.RestateError;
+exports.RestatePromise = require_context.RestatePromise;
+exports.RetryableError = require_errors.RetryableError;
+exports.SendOpts = require_rpc.SendOpts;
+exports.TerminalError = require_errors.TerminalError;
+exports.TimeoutError = require_errors.TimeoutError;
+exports.createEndpointHandler = require_node.createEndpointHandler;
+exports.createObjectHandler = require_common_api.createObjectHandler;
+exports.createObjectSharedHandler = require_common_api.createObjectSharedHandler;
+exports.createServiceHandler = require_common_api.createServiceHandler;
+exports.createWorkflowHandler = require_common_api.createWorkflowHandler;
+exports.createWorkflowSharedHandler = require_common_api.createWorkflowSharedHandler;
+exports.endpoint = require_node.endpoint;
+Object.defineProperty(exports, 'handlers', {
+  enumerable: true,
+  get: function () {
+    return require_rpc.handlers;
+  }
+});
+exports.object = require_rpc.object;
+Object.defineProperty(exports, 'rpc', {
+  enumerable: true,
+  get: function () {
+    return require_rpc.rpc;
+  }
+});
+Object.defineProperty(exports, 'serde', {
+  enumerable: true,
+  get: function () {
+    return __restatedev_restate_sdk_core.serde;
+  }
+});
+exports.serve = require_node.serve;
+exports.service = require_rpc.service;
+exports.workflow = require_rpc.workflow;

package/dist/index.d.cts

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

package/dist/index.d.ts

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

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,cAAc,WAAW,CAAC"}

package/dist/index.js

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

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,WAAW,CAAC"}

package/dist/io.cjs

@@ -0,0 +1,48 @@
+const require_promises = require('./promises.cjs');
+
+//#region src/io.ts
+/**
+* Adapter between input stream and vm. It moves forward when [awaitNextProgress] is invoked.
+*/
+var InputPump = class {
+	currentRead;
+	constructor(coreVm, inputReader, errorCallback) {
+		this.coreVm = coreVm;
+		this.inputReader = inputReader;
+		this.errorCallback = errorCallback;
+	}
+	awaitNextProgress() {
+		if (this.currentRead === void 0) this.currentRead = this.readNext().finally(() => {
+			this.currentRead = void 0;
+		});
+		return new Promise((resolve) => this.currentRead?.finally(resolve));
+	}
+	async readNext() {
+		let nextValue;
+		try {
+			nextValue = await this.inputReader.read();
+		} catch (e) {
+			this.errorCallback(e);
+			return require_promises.pendingPromise();
+		}
+		if (nextValue.value !== void 0) this.coreVm.notify_input(nextValue.value);
+		if (nextValue.done) this.coreVm.notify_input_closed();
+	}
+};
+/**
+* Adapter between output stream and vm. It moves forward when [awaitNextProgress] is invoked.
+*/
+var OutputPump = class {
+	constructor(coreVm, outputWriter) {
+		this.coreVm = coreVm;
+		this.outputWriter = outputWriter;
+	}
+	async awaitNextProgress() {
+		const nextOutput = this.coreVm.take_output();
+		if (nextOutput instanceof Uint8Array) await this.outputWriter.write(nextOutput);
+	}
+};
+
+//#endregion
+exports.InputPump = InputPump;
+exports.OutputPump = OutputPump;

package/dist/io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.d.ts","sourceRoot":"","sources":["../src/io.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,EAAE,MAAM,yDAAyD,CAAC;AACnF,OAAO,KAAK,EACV,2BAA2B,EAC3B,2BAA2B,EAC5B,MAAM,iBAAiB,CAAC;AAIzB;;GAEG;AACH,qBAAa,SAAS;IAIlB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IALhC,OAAO,CAAC,WAAW,CAAC,CAAgB;gBAGjB,MAAM,EAAE,EAAE,CAAC,MAAM,EACjB,WAAW,EAAE,2BAA2B,CAAC,UAAU,CAAC,EACpD,aAAa,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI;IAMlD,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;YAYpB,QAAQ;CAgBvB;AAED;;GAEG;AACH,qBAAa,UAAU;IAEnB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADZ,MAAM,EAAE,EAAE,CAAC,MAAM,EACjB,YAAY,EAAE,2BAA2B,CAAC,UAAU,CAAC;IAGlE,iBAAiB;CASxB"}