@restatedev/restate-sdk-cloudflare-workers 1.9.1 → 1.10.1

package/dist/endpoint/types.d.cts

@@ -0,0 +1,61 @@
+import { LoggerTransport } from "../logging/logger_transport.cjs";
+import { DefaultServiceOptions } from "../endpoint.cjs";
+import { JournalValueCodec, ServiceDefinition, VirtualObjectDefinition, WorkflowDefinition } from "../common_api.cjs";
+
+//#region src/endpoint/types.d.ts
+/**
+ * Options for creating an endpoint handler for Node.js HTTP/2 servers.
+ */
+interface EndpointOptions {
+  /**
+   * A list of Restate services, virtual objects, or workflows that will be exposed via the endpoint.
+   */
+  services: Array<ServiceDefinition<string, unknown> | VirtualObjectDefinition<string, unknown> | WorkflowDefinition<string, unknown>>;
+  /**
+   * 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,
+   *
+   */
+  identityKeys?: string[];
+  /**
+   * Default service options that will be used by all services bind to this endpoint.
+   *
+   * Options can be overridden on each service/handler.
+   */
+  defaultServiceOptions?: DefaultServiceOptions;
+  /**
+   * Replace the default console-based {@link LoggerTransport}
+   * @example
+   * Using console:
+   * ```ts
+   * createEndpointHandler({ logger: (meta, message, ...o) => {console.log(`${meta.level}: `, message, ...o)}})
+   * ```
+   * @example
+   * Using winston:
+   * ```ts
+   * const logger = createLogger({ ... })
+   * createEndpointHandler({ logger: (meta, message, ...o) => {logger.log(meta.level, {invocationId: meta.context?.invocationId}, [message, ...o].join(' '))} })
+   * ```
+   * @example
+   * Using pino:
+   * ```ts
+   * const logger = pino()
+   * createEndpointHandler({ logger: (meta, message, ...o) => {logger[meta.level]({invocationId: meta.context?.invocationId}, [message, ...o].join(' '))}} )
+   * ```
+   */
+  logger?: LoggerTransport;
+  /**
+   * 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?: () => Promise<JournalValueCodec>;
+}
+//#endregion
+export { EndpointOptions };
+//# sourceMappingURL=types.d.cts.map

package/dist/endpoint/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/endpoint/types.ts"],"sourcesContent":[],"mappings":";;;;;;;;UAYiB,eAAA;EAAA;;;EAOX,QAAA,EAHM,KAGN,CAFA,iBAEA,CAAA,MAAA,EAAA,OAAA,CAAA,GADA,uBACA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,kBAAA,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAHM;;;;;;;;;;;;;;;0BAoBc;;;;;;;;;;;;;;;;;;;;;WAqBf;;;;;;;oCAQyB,QAAQ"}

package/dist/endpoint/types.d.ts

@@ -0,0 +1,61 @@
+import { LoggerTransport } from "../logging/logger_transport.js";
+import { DefaultServiceOptions } from "../endpoint.js";
+import { JournalValueCodec, ServiceDefinition, VirtualObjectDefinition, WorkflowDefinition } from "../common_api.js";
+
+//#region src/endpoint/types.d.ts
+/**
+ * Options for creating an endpoint handler for Node.js HTTP/2 servers.
+ */
+interface EndpointOptions {
+  /**
+   * A list of Restate services, virtual objects, or workflows that will be exposed via the endpoint.
+   */
+  services: Array<ServiceDefinition<string, unknown> | VirtualObjectDefinition<string, unknown> | WorkflowDefinition<string, unknown>>;
+  /**
+   * 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,
+   *
+   */
+  identityKeys?: string[];
+  /**
+   * Default service options that will be used by all services bind to this endpoint.
+   *
+   * Options can be overridden on each service/handler.
+   */
+  defaultServiceOptions?: DefaultServiceOptions;
+  /**
+   * Replace the default console-based {@link LoggerTransport}
+   * @example
+   * Using console:
+   * ```ts
+   * createEndpointHandler({ logger: (meta, message, ...o) => {console.log(`${meta.level}: `, message, ...o)}})
+   * ```
+   * @example
+   * Using winston:
+   * ```ts
+   * const logger = createLogger({ ... })
+   * createEndpointHandler({ logger: (meta, message, ...o) => {logger.log(meta.level, {invocationId: meta.context?.invocationId}, [message, ...o].join(' '))} })
+   * ```
+   * @example
+   * Using pino:
+   * ```ts
+   * const logger = pino()
+   * createEndpointHandler({ logger: (meta, message, ...o) => {logger[meta.level]({invocationId: meta.context?.invocationId}, [message, ...o].join(' '))}} )
+   * ```
+   */
+  logger?: LoggerTransport;
+  /**
+   * 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?: () => Promise<JournalValueCodec>;
+}
+//#endregion
+export { EndpointOptions };
+//# sourceMappingURL=types.d.ts.map

package/dist/endpoint/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/endpoint/types.ts"],"sourcesContent":[],"mappings":";;;;;;;;UAYiB,eAAA;EAAA;;;EAOX,QAAA,EAHM,KAGN,CAFA,iBAEA,CAAA,MAAA,EAAA,OAAA,CAAA,GADA,uBACA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,kBAAA,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAHM;;;;;;;;;;;;;;;0BAoBc;;;;;;;;;;;;;;;;;;;;;WAqBf;;;;;;;oCAQyB,QAAQ"}

package/dist/endpoint/withOptions.cjs

@@ -0,0 +1,15 @@
+
+//#region src/endpoint/withOptions.ts
+function withOptions(endpoint, { identityKeys, defaultServiceOptions, logger, services, journalValueCodecProvider }) {
+	let endpointWithOptions = endpoint;
+	if (identityKeys && identityKeys.length > 0) endpointWithOptions = endpointWithOptions.withIdentityV1(...identityKeys);
+	if (defaultServiceOptions) endpointWithOptions = endpointWithOptions.defaultServiceOptions(defaultServiceOptions);
+	if (journalValueCodecProvider) endpointWithOptions = endpointWithOptions.journalValueCodecProvider(journalValueCodecProvider);
+	if (logger) endpointWithOptions = endpointWithOptions.setLogger(logger);
+	return services.reduce((results, service) => {
+		return results.bind(service);
+	}, endpointWithOptions);
+}
+
+//#endregion
+exports.withOptions = withOptions;

package/dist/endpoint/withOptions.js

@@ -0,0 +1,15 @@
+//#region src/endpoint/withOptions.ts
+function withOptions(endpoint, { identityKeys, defaultServiceOptions, logger, services, journalValueCodecProvider }) {
+	let endpointWithOptions = endpoint;
+	if (identityKeys && identityKeys.length > 0) endpointWithOptions = endpointWithOptions.withIdentityV1(...identityKeys);
+	if (defaultServiceOptions) endpointWithOptions = endpointWithOptions.defaultServiceOptions(defaultServiceOptions);
+	if (journalValueCodecProvider) endpointWithOptions = endpointWithOptions.journalValueCodecProvider(journalValueCodecProvider);
+	if (logger) endpointWithOptions = endpointWithOptions.setLogger(logger);
+	return services.reduce((results, service) => {
+		return results.bind(service);
+	}, endpointWithOptions);
+}
+
+//#endregion
+export { withOptions };
+//# sourceMappingURL=withOptions.js.map

package/dist/endpoint/withOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withOptions.js","names":[],"sources":["../../src/endpoint/withOptions.ts"],"sourcesContent":["import type { RestateEndpointBase } from \"../endpoint.js\";\nimport type { EndpointOptions } from \"./types.js\";\n\nexport function withOptions<E extends RestateEndpointBase<E>>(\n  endpoint: E,\n  {\n    identityKeys,\n    defaultServiceOptions,\n    logger,\n    services,\n    journalValueCodecProvider,\n  }: EndpointOptions\n): E {\n  let endpointWithOptions = endpoint;\n  if (identityKeys && identityKeys.length > 0) {\n    endpointWithOptions = endpointWithOptions.withIdentityV1(...identityKeys);\n  }\n  if (defaultServiceOptions) {\n    endpointWithOptions = endpointWithOptions.defaultServiceOptions(\n      defaultServiceOptions\n    );\n  }\n  if (journalValueCodecProvider) {\n    endpointWithOptions = endpointWithOptions.journalValueCodecProvider(\n      journalValueCodecProvider\n    );\n  }\n  if (logger) {\n    endpointWithOptions = endpointWithOptions.setLogger(logger);\n  }\n\n  return services.reduce((results, service) => {\n    return results.bind(service);\n  }, endpointWithOptions);\n}\n"],"mappings":";AAGA,SAAgB,YACd,UACA,EACE,cACA,uBACA,QACA,UACA,6BAEC;CACH,IAAI,sBAAsB;AAC1B,KAAI,gBAAgB,aAAa,SAAS,EACxC,uBAAsB,oBAAoB,eAAe,GAAG,aAAa;AAE3E,KAAI,sBACF,uBAAsB,oBAAoB,sBACxC,sBACD;AAEH,KAAI,0BACF,uBAAsB,oBAAoB,0BACxC,0BACD;AAEH,KAAI,OACF,uBAAsB,oBAAoB,UAAU,OAAO;AAG7D,QAAO,SAAS,QAAQ,SAAS,YAAY;AAC3C,SAAO,QAAQ,KAAK,QAAQ;IAC3B,oBAAoB"}

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/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"}