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

package/dist/{esm/src/fetch.js → fetch.js}

@@ -1,25 +1,20 @@
-/*
- * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
- *
- * This file is part of the Restate SDK for Node.js/TypeScript,
- * which is released under the MIT license.
- *
- * You can find a copy of the license in file LICENSE in the root
- * directory of this repository or package, or at
- * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
- */
-export * from "./common_api.js";
+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";
 import { cloudflareWorkersBundlerPatch } from "./endpoint/handlers/vm/sdk_shared_core_wasm_bindings.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}
- */
-export function endpoint() {
+* 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() {
   cloudflareWorkersBundlerPatch();
-  return new FetchEndpointImpl("REQUEST_RESPONSE");
+	return new FetchEndpointImpl("REQUEST_RESPONSE");
 }
 
 /**
@@ -43,7 +38,7 @@ export function endpoint() {
  * export const handler = createEndpointHandler({ services: [myService], bidirectional: true })
  *
  */
-export function createEndpointHandler(options) {
+function createEndpointHandler(options) {
   cloudflareWorkersBundlerPatch();
   return withOptions(
     new FetchEndpointImpl(
@@ -53,4 +48,6 @@ export function createEndpointHandler(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.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/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.js

@@ -0,0 +1,48 @@
+import { pendingPromise } from "./promises.js";
+
+//#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 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
+export { InputPump, OutputPump };
+//# sourceMappingURL=io.js.map

package/dist/io.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.js","names":["coreVm: vm.WasmVM","inputReader: ReadableStreamDefaultReader<Uint8Array>","errorCallback: (e: any) => void","nextValue: ReadableStreamReadResult<Uint8Array>","outputWriter: WritableStreamDefaultWriter<Uint8Array>"],"sources":["../src/io.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2025 - 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\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type * as vm from \"./endpoint/handlers/vm/sdk_shared_core_wasm_bindings.js\";\nimport type {\n  ReadableStreamDefaultReader,\n  WritableStreamDefaultWriter,\n} from \"node:stream/web\";\nimport type { ReadableStreamReadResult } from \"stream/web\";\nimport { pendingPromise } from \"./promises.js\";\n\n/**\n * Adapter between input stream and vm. It moves forward when [awaitNextProgress] is invoked.\n */\nexport class InputPump {\n  private currentRead?: Promise<void>;\n\n  constructor(\n    private readonly coreVm: vm.WasmVM,\n    private readonly inputReader: ReadableStreamDefaultReader<Uint8Array>,\n    private readonly errorCallback: (e: any) => void\n  ) {}\n\n  // This function triggers a read on the input reader,\n  // and will notify the caller that a read was executed\n  // and the result was piped in the state machine.\n  awaitNextProgress(): Promise<void> {\n    if (this.currentRead === undefined) {\n      // Register a new read\n      this.currentRead = this.readNext().finally(() => {\n        this.currentRead = undefined;\n      });\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    return new Promise<void>((resolve) => this.currentRead?.finally(resolve));\n  }\n\n  private async readNext(): Promise<void> {\n    // Take input, and notify it to the vm\n    let nextValue: ReadableStreamReadResult<Uint8Array>;\n    try {\n      nextValue = await this.inputReader.read();\n    } catch (e) {\n      this.errorCallback(e);\n      return pendingPromise<void>();\n    }\n    if (nextValue.value !== undefined) {\n      this.coreVm.notify_input(nextValue.value);\n    }\n    if (nextValue.done) {\n      this.coreVm.notify_input_closed();\n    }\n  }\n}\n\n/**\n * Adapter between output stream and vm. It moves forward when [awaitNextProgress] is invoked.\n */\nexport class OutputPump {\n  constructor(\n    private readonly coreVm: vm.WasmVM,\n    private readonly outputWriter: WritableStreamDefaultWriter<Uint8Array>\n  ) {}\n\n  async awaitNextProgress() {\n    const nextOutput = this.coreVm.take_output() as\n      | Uint8Array\n      | null\n      | undefined;\n    if (nextOutput instanceof Uint8Array) {\n      await this.outputWriter.write(nextOutput);\n    }\n  }\n}\n"],"mappings":";;;;;;AAwBA,IAAa,YAAb,MAAuB;CACrB,AAAQ;CAER,YACE,AAAiBA,QACjB,AAAiBC,aACjB,AAAiBC,eACjB;EAHiB;EACA;EACA;;CAMnB,oBAAmC;AACjC,MAAI,KAAK,gBAAgB,OAEvB,MAAK,cAAc,KAAK,UAAU,CAAC,cAAc;AAC/C,QAAK,cAAc;IACnB;AAIJ,SAAO,IAAI,SAAe,YAAY,KAAK,aAAa,QAAQ,QAAQ,CAAC;;CAG3E,MAAc,WAA0B;EAEtC,IAAIC;AACJ,MAAI;AACF,eAAY,MAAM,KAAK,YAAY,MAAM;WAClC,GAAG;AACV,QAAK,cAAc,EAAE;AACrB,UAAO,gBAAsB;;AAE/B,MAAI,UAAU,UAAU,OACtB,MAAK,OAAO,aAAa,UAAU,MAAM;AAE3C,MAAI,UAAU,KACZ,MAAK,OAAO,qBAAqB;;;;;;AAQvC,IAAa,aAAb,MAAwB;CACtB,YACE,AAAiBH,QACjB,AAAiBI,cACjB;EAFiB;EACA;;CAGnB,MAAM,oBAAoB;EACxB,MAAM,aAAa,KAAK,OAAO,aAAa;AAI5C,MAAI,sBAAsB,WACxB,OAAM,KAAK,aAAa,MAAM,WAAW"}

package/dist/lambda.cjs

@@ -0,0 +1,74 @@
+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_withOptions = require('./endpoint/withOptions.cjs');
+const require_lambda_endpoint = require('./endpoint/lambda_endpoint.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/lambda.ts
+/**
+* Create a new {@link LambdaEndpoint}.
+* @deprecated Please use {@link createEndpointHandler}
+*/
+function endpoint() {
+	return new require_lambda_endpoint.LambdaEndpointImpl();
+}
+/**
+* Creates a Lambda handler that encapsulates all the Restate services served by this endpoint.
+*
+* @param {EndpointOptions} options - Configuration options for the endpoint handler.
+* @returns A Lambda handler function.
+*
+* @example
+* A typical endpoint served as Lambda would look like this:
+* ```
+* import { createEndpointHandler } from "@restatedev/restate-sdk/lambda";
+*
+* export const handler = createEndpointHandler({ services: [myService] })
+*/
+function createEndpointHandler(options) {
+	return require_withOptions.withOptions(new require_lambda_endpoint.LambdaEndpointImpl(), options).handler();
+}
+
+//#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/lambda.d.cts

@@ -0,0 +1,32 @@
+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 { LambdaEndpoint } from "./endpoint/lambda_endpoint.cjs";
+
+//#region src/lambda.d.ts
+/**
+ * Create a new {@link LambdaEndpoint}.
+ * @deprecated Please use {@link createEndpointHandler}
+ */
+declare function endpoint(): LambdaEndpoint;
+/**
+ * Creates a Lambda handler that encapsulates all the Restate services served by this endpoint.
+ *
+ * @param {EndpointOptions} options - Configuration options for the endpoint handler.
+ * @returns A Lambda handler function.
+ *
+ * @example
+ * A typical endpoint served as Lambda would look like this:
+ * ```
+ * import { createEndpointHandler } from "@restatedev/restate-sdk/lambda";
+ *
+ * export const handler = createEndpointHandler({ services: [myService] })
+ */
+declare function createEndpointHandler(options: EndpointOptions): (event: any, ctx: any) => Promise<any>;
+//#endregion
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, InferArg, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOptions, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, object, rpc, serde, service, workflow };
+//# sourceMappingURL=lambda.d.cts.map

package/dist/lambda.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambda.d.cts","names":[],"sources":["../src/lambda.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBAwBgB,QAAA,CAAA,GAAY;;;AAA5B;AAiBA;;;;;;;;;;iBAAgB,qBAAA,UAA+B,4CAAe"}

package/dist/lambda.d.ts

@@ -0,0 +1,32 @@
+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 { LambdaEndpoint } from "./endpoint/lambda_endpoint.js";
+
+//#region src/lambda.d.ts
+/**
+ * Create a new {@link LambdaEndpoint}.
+ * @deprecated Please use {@link createEndpointHandler}
+ */
+declare function endpoint(): LambdaEndpoint;
+/**
+ * Creates a Lambda handler that encapsulates all the Restate services served by this endpoint.
+ *
+ * @param {EndpointOptions} options - Configuration options for the endpoint handler.
+ * @returns A Lambda handler function.
+ *
+ * @example
+ * A typical endpoint served as Lambda would look like this:
+ * ```
+ * import { createEndpointHandler } from "@restatedev/restate-sdk/lambda";
+ *
+ * export const handler = createEndpointHandler({ services: [myService] })
+ */
+declare function createEndpointHandler(options: EndpointOptions): (event: any, ctx: any) => Promise<any>;
+//#endregion
+export { CancelledError, Client, ClientCallOptions, ClientSendOptions, CombineablePromise, Context, ContextDate, DefaultServiceOptions, DurablePromise, Duration, EndpointOptions, GenericCall, GenericSend, InferArg, InvocationHandle, InvocationId, InvocationIdParser, InvocationPromise, JournalValueCodec, KeyValueStore, type LambdaEndpoint, LogMetadata, LogSource, LoggerContext, LoggerTransport, ObjectContext, ObjectHandler, ObjectHandlerOpts, ObjectOptions, ObjectOpts, ObjectSharedContext, Opts, Rand, RemoveVoidArgument, Request, RestateContext, RestateEndpoint, RestateEndpointBase, RestateError, RestateLogLevel, RestateObjectContext, RestateObjectSharedContext, RestatePromise, RestateWorkflowContext, RestateWorkflowSharedContext, RetryPolicy, RetryableError, RetryableErrorOptions, RunAction, RunOptions, SendClient, SendOptions, SendOpts, Serde, Service, ServiceDefinition, ServiceDefinitionFrom, ServiceHandler, ServiceHandlerOpts, ServiceOptions, ServiceOpts, TerminalError, TimeoutError, TypedState, UntypedState, VirtualObject, VirtualObjectDefinition, VirtualObjectDefinitionFrom, Workflow, WorkflowContext, WorkflowDefinition, WorkflowDefinitionFrom, WorkflowHandler, WorkflowHandlerOpts, WorkflowOptions, WorkflowOpts, WorkflowSharedContext, WorkflowSharedHandler, createEndpointHandler, createObjectHandler, createObjectSharedHandler, createServiceHandler, createWorkflowHandler, createWorkflowSharedHandler, endpoint, handlers, object, rpc, serde, service, workflow };
+//# sourceMappingURL=lambda.d.ts.map

package/dist/lambda.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambda.d.ts","names":[],"sources":["../src/lambda.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBAwBgB,QAAA,CAAA,GAAY;;;AAA5B;AAiBA;;;;;;;;;;iBAAgB,qBAAA,UAA+B,4CAAe"}

package/dist/lambda.js

@@ -0,0 +1,35 @@
+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 { withOptions } from "./endpoint/withOptions.js";
+import { LambdaEndpointImpl } from "./endpoint/lambda_endpoint.js";
+
+//#region src/lambda.ts
+/**
+* Create a new {@link LambdaEndpoint}.
+* @deprecated Please use {@link createEndpointHandler}
+*/
+function endpoint() {
+	return new LambdaEndpointImpl();
+}
+/**
+* Creates a Lambda handler that encapsulates all the Restate services served by this endpoint.
+*
+* @param {EndpointOptions} options - Configuration options for the endpoint handler.
+* @returns A Lambda handler function.
+*
+* @example
+* A typical endpoint served as Lambda would look like this:
+* ```
+* import { createEndpointHandler } from "@restatedev/restate-sdk/lambda";
+*
+* export const handler = createEndpointHandler({ services: [myService] })
+*/
+function createEndpointHandler(options) {
+	return withOptions(new LambdaEndpointImpl(), options).handler();
+}
+
+//#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=lambda.js.map

package/dist/lambda.js.map

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

package/dist/logging/console_logger_transport.cjs

@@ -0,0 +1,54 @@
+const require_logger_transport = require('./logger_transport.cjs');
+
+//#region src/logging/console_logger_transport.ts
+const defaultLoggerTransport = (params, message, ...optionalParams) => {
+	if (params.replaying) return;
+	if (logLevel(params.level) < logLevel(DEFAULT_CONSOLE_LOGGER_LOG_LEVEL)) return;
+	const p = `${formatLogPrefix(params.context)} ${params.level.toUpperCase()}:`;
+	switch (params.level) {
+		case require_logger_transport.RestateLogLevel.TRACE: return console.trace(p, message, ...optionalParams);
+		case require_logger_transport.RestateLogLevel.DEBUG: return console.debug(p, message, ...optionalParams);
+		case require_logger_transport.RestateLogLevel.INFO: return console.info(p, message, ...optionalParams);
+		case require_logger_transport.RestateLogLevel.WARN: return console.warn(p, message, ...optionalParams);
+		case require_logger_transport.RestateLogLevel.ERROR: return console.error(p, message, ...optionalParams);
+		default: throw new TypeError(`unset or unknown log level ${params.level}`);
+	}
+};
+const DEFAULT_CONSOLE_LOGGER_LOG_LEVEL = readRestateLogLevel();
+function readRestateLogLevel() {
+	const env = globalThis.process?.env?.RESTATE_LOGGING;
+	const level = logLevelFromName(env);
+	if (level !== null) return level;
+	return require_logger_transport.RestateLogLevel.INFO;
+}
+function logLevelFromName(name) {
+	if (!name) return null;
+	switch (name.toUpperCase()) {
+		case "TRACE": return require_logger_transport.RestateLogLevel.TRACE;
+		case "DEBUG": return require_logger_transport.RestateLogLevel.DEBUG;
+		case "INFO": return require_logger_transport.RestateLogLevel.INFO;
+		case "WARN": return require_logger_transport.RestateLogLevel.WARN;
+		case "ERROR": return require_logger_transport.RestateLogLevel.ERROR;
+		default: throw new TypeError(`unknown name ${name}`);
+	}
+}
+function logLevel(level) {
+	switch (level) {
+		case require_logger_transport.RestateLogLevel.TRACE: return 1;
+		case require_logger_transport.RestateLogLevel.DEBUG: return 2;
+		case require_logger_transport.RestateLogLevel.INFO: return 3;
+		case require_logger_transport.RestateLogLevel.WARN: return 4;
+		case require_logger_transport.RestateLogLevel.ERROR: return 5;
+	}
+}
+function formatLogPrefix(context) {
+	let prefix = `[restate][${(/* @__PURE__ */ new Date()).toISOString()}]`;
+	if (context === void 0) return prefix;
+	prefix = `${prefix}[${context.invocationTarget}][${context.invocationId}]`;
+	if (context.additionalContext !== void 0) for (const [k, v] of Object.entries(context.additionalContext)) prefix = prefix + `[${k}: ${v}]`;
+	return prefix;
+}
+
+//#endregion
+exports.DEFAULT_CONSOLE_LOGGER_LOG_LEVEL = DEFAULT_CONSOLE_LOGGER_LOG_LEVEL;
+exports.defaultLoggerTransport = defaultLoggerTransport;

package/dist/logging/console_logger_transport.js

@@ -0,0 +1,54 @@
+import { RestateLogLevel } from "./logger_transport.js";
+
+//#region src/logging/console_logger_transport.ts
+const defaultLoggerTransport = (params, message, ...optionalParams) => {
+	if (params.replaying) return;
+	if (logLevel(params.level) < logLevel(DEFAULT_CONSOLE_LOGGER_LOG_LEVEL)) return;
+	const p = `${formatLogPrefix(params.context)} ${params.level.toUpperCase()}:`;
+	switch (params.level) {
+		case RestateLogLevel.TRACE: return console.trace(p, message, ...optionalParams);
+		case RestateLogLevel.DEBUG: return console.debug(p, message, ...optionalParams);
+		case RestateLogLevel.INFO: return console.info(p, message, ...optionalParams);
+		case RestateLogLevel.WARN: return console.warn(p, message, ...optionalParams);
+		case RestateLogLevel.ERROR: return console.error(p, message, ...optionalParams);
+		default: throw new TypeError(`unset or unknown log level ${params.level}`);
+	}
+};
+const DEFAULT_CONSOLE_LOGGER_LOG_LEVEL = readRestateLogLevel();
+function readRestateLogLevel() {
+	const env = globalThis.process?.env?.RESTATE_LOGGING;
+	const level = logLevelFromName(env);
+	if (level !== null) return level;
+	return RestateLogLevel.INFO;
+}
+function logLevelFromName(name) {
+	if (!name) return null;
+	switch (name.toUpperCase()) {
+		case "TRACE": return RestateLogLevel.TRACE;
+		case "DEBUG": return RestateLogLevel.DEBUG;
+		case "INFO": return RestateLogLevel.INFO;
+		case "WARN": return RestateLogLevel.WARN;
+		case "ERROR": return RestateLogLevel.ERROR;
+		default: throw new TypeError(`unknown name ${name}`);
+	}
+}
+function logLevel(level) {
+	switch (level) {
+		case RestateLogLevel.TRACE: return 1;
+		case RestateLogLevel.DEBUG: return 2;
+		case RestateLogLevel.INFO: return 3;
+		case RestateLogLevel.WARN: return 4;
+		case RestateLogLevel.ERROR: return 5;
+	}
+}
+function formatLogPrefix(context) {
+	let prefix = `[restate][${(/* @__PURE__ */ new Date()).toISOString()}]`;
+	if (context === void 0) return prefix;
+	prefix = `${prefix}[${context.invocationTarget}][${context.invocationId}]`;
+	if (context.additionalContext !== void 0) for (const [k, v] of Object.entries(context.additionalContext)) prefix = prefix + `[${k}: ${v}]`;
+	return prefix;
+}
+
+//#endregion
+export { DEFAULT_CONSOLE_LOGGER_LOG_LEVEL, defaultLoggerTransport };
+//# sourceMappingURL=console_logger_transport.js.map

package/dist/logging/console_logger_transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console_logger_transport.js","names":["defaultLoggerTransport: LoggerTransport"],"sources":["../../src/logging/console_logger_transport.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\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-unsafe-argument */\n/* eslint-disable no-console */\n\nimport type {\n  LogMetadata,\n  LoggerTransport,\n  LoggerContext,\n} from \"./logger_transport.js\";\nimport { RestateLogLevel } from \"./logger_transport.js\";\n\nexport const defaultLoggerTransport: LoggerTransport = (\n  params: LogMetadata,\n  message?: any,\n  ...optionalParams: any[]\n) => {\n  if (params.replaying) {\n    return;\n  }\n  if (logLevel(params.level) < logLevel(DEFAULT_CONSOLE_LOGGER_LOG_LEVEL)) {\n    return;\n  }\n  const p = `${formatLogPrefix(params.context)} ${params.level.toUpperCase()}:`;\n  switch (params.level) {\n    case RestateLogLevel.TRACE:\n      return console.trace(p, message, ...optionalParams);\n    case RestateLogLevel.DEBUG:\n      return console.debug(p, message, ...optionalParams);\n    case RestateLogLevel.INFO:\n      return console.info(p, message, ...optionalParams);\n    case RestateLogLevel.WARN:\n      return console.warn(p, message, ...optionalParams);\n    case RestateLogLevel.ERROR:\n      return console.error(p, message, ...optionalParams);\n    default:\n      throw new TypeError(`unset or unknown log level ${params.level}`);\n  }\n};\n\n// this is the log level as provided by the environment variable RESTATE_LOG_LEVEL,\n// but it only affects the default logger - custom loggers get all log events and\n// should use their own filtering mechanism\nexport const DEFAULT_CONSOLE_LOGGER_LOG_LEVEL = readRestateLogLevel();\n\nfunction readRestateLogLevel(): RestateLogLevel {\n  const env = globalThis.process?.env?.RESTATE_LOGGING;\n  const level = logLevelFromName(env);\n  if (level !== null) {\n    return level;\n  }\n  return RestateLogLevel.INFO;\n}\n\nfunction logLevelFromName(name?: string): RestateLogLevel | null {\n  if (!name) {\n    return null;\n  }\n  const n = name.toUpperCase();\n  switch (n) {\n    case \"TRACE\":\n      return RestateLogLevel.TRACE;\n    case \"DEBUG\":\n      return RestateLogLevel.DEBUG;\n    case \"INFO\":\n      return RestateLogLevel.INFO;\n    case \"WARN\":\n      return RestateLogLevel.WARN;\n    case \"ERROR\":\n      return RestateLogLevel.ERROR;\n    default:\n      throw new TypeError(`unknown name ${name}`);\n  }\n}\n\nfunction logLevel(level: RestateLogLevel): number {\n  switch (level) {\n    case RestateLogLevel.TRACE:\n      return 1;\n    case RestateLogLevel.DEBUG:\n      return 2;\n    case RestateLogLevel.INFO:\n      return 3;\n    case RestateLogLevel.WARN:\n      return 4;\n    case RestateLogLevel.ERROR:\n      return 5;\n  }\n}\n\nfunction formatLogPrefix(context?: LoggerContext): string {\n  let prefix = `[restate][${new Date().toISOString()}]`;\n  if (context === undefined) {\n    return prefix;\n  }\n  prefix = `${prefix}[${context.invocationTarget}][${context.invocationId}]`;\n  if (context.additionalContext !== undefined) {\n    for (const [k, v] of Object.entries(context.additionalContext)) {\n      prefix = prefix + `[${k}: ${v}]`;\n    }\n  }\n  return prefix;\n}\n"],"mappings":";;;AAsBA,MAAaA,0BACX,QACA,SACA,GAAG,mBACA;AACH,KAAI,OAAO,UACT;AAEF,KAAI,SAAS,OAAO,MAAM,GAAG,SAAS,iCAAiC,CACrE;CAEF,MAAM,IAAI,GAAG,gBAAgB,OAAO,QAAQ,CAAC,GAAG,OAAO,MAAM,aAAa,CAAC;AAC3E,SAAQ,OAAO,OAAf;EACE,KAAK,gBAAgB,MACnB,QAAO,QAAQ,MAAM,GAAG,SAAS,GAAG,eAAe;EACrD,KAAK,gBAAgB,MACnB,QAAO,QAAQ,MAAM,GAAG,SAAS,GAAG,eAAe;EACrD,KAAK,gBAAgB,KACnB,QAAO,QAAQ,KAAK,GAAG,SAAS,GAAG,eAAe;EACpD,KAAK,gBAAgB,KACnB,QAAO,QAAQ,KAAK,GAAG,SAAS,GAAG,eAAe;EACpD,KAAK,gBAAgB,MACnB,QAAO,QAAQ,MAAM,GAAG,SAAS,GAAG,eAAe;EACrD,QACE,OAAM,IAAI,UAAU,8BAA8B,OAAO,QAAQ;;;AAOvE,MAAa,mCAAmC,qBAAqB;AAErE,SAAS,sBAAuC;CAC9C,MAAM,MAAM,WAAW,SAAS,KAAK;CACrC,MAAM,QAAQ,iBAAiB,IAAI;AACnC,KAAI,UAAU,KACZ,QAAO;AAET,QAAO,gBAAgB;;AAGzB,SAAS,iBAAiB,MAAuC;AAC/D,KAAI,CAAC,KACH,QAAO;AAGT,SADU,KAAK,aAAa,EAC5B;EACE,KAAK,QACH,QAAO,gBAAgB;EACzB,KAAK,QACH,QAAO,gBAAgB;EACzB,KAAK,OACH,QAAO,gBAAgB;EACzB,KAAK,OACH,QAAO,gBAAgB;EACzB,KAAK,QACH,QAAO,gBAAgB;EACzB,QACE,OAAM,IAAI,UAAU,gBAAgB,OAAO;;;AAIjD,SAAS,SAAS,OAAgC;AAChD,SAAQ,OAAR;EACE,KAAK,gBAAgB,MACnB,QAAO;EACT,KAAK,gBAAgB,MACnB,QAAO;EACT,KAAK,gBAAgB,KACnB,QAAO;EACT,KAAK,gBAAgB,KACnB,QAAO;EACT,KAAK,gBAAgB,MACnB,QAAO;;;AAIb,SAAS,gBAAgB,SAAiC;CACxD,IAAI,SAAS,8BAAa,IAAI,MAAM,EAAC,aAAa,CAAC;AACnD,KAAI,YAAY,OACd,QAAO;AAET,UAAS,GAAG,OAAO,GAAG,QAAQ,iBAAiB,IAAI,QAAQ,aAAa;AACxE,KAAI,QAAQ,sBAAsB,OAChC,MAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,QAAQ,kBAAkB,CAC5D,UAAS,SAAS,IAAI,EAAE,IAAI,EAAE;AAGlC,QAAO"}

package/dist/logging/logger.cjs

@@ -0,0 +1,43 @@
+const require_logger_transport = require('./logger_transport.cjs');
+
+//#region src/logging/logger.ts
+function createLogger(loggerTransport, source, context, isReplaying = () => false) {
+	function loggerForLevel(loggerTransport$1, source$1, level, isReplaying$1, context$1) {
+		return { get: () => {
+			return loggerTransport$1.bind(null, {
+				source: source$1,
+				level,
+				replaying: isReplaying$1(),
+				context: context$1
+			});
+		} };
+	}
+	const info = loggerForLevel(loggerTransport, source, require_logger_transport.RestateLogLevel.INFO, isReplaying, context);
+	return Object.create(console, {
+		trace: loggerForLevel(loggerTransport, source, require_logger_transport.RestateLogLevel.TRACE, isReplaying, context),
+		debug: loggerForLevel(loggerTransport, source, require_logger_transport.RestateLogLevel.DEBUG, isReplaying, context),
+		info,
+		log: info,
+		warn: loggerForLevel(loggerTransport, source, require_logger_transport.RestateLogLevel.WARN, isReplaying, context),
+		error: loggerForLevel(loggerTransport, source, require_logger_transport.RestateLogLevel.ERROR, isReplaying, context),
+		logForLevel: { get() {
+			return (level, message, ...optionalParams) => {
+				if (optionalParams?.length === 0 || optionalParams === void 0) loggerTransport.bind(null)({
+					source,
+					level,
+					replaying: isReplaying(),
+					context
+				}, message);
+				else loggerTransport.bind(null)({
+					source,
+					level,
+					replaying: isReplaying(),
+					context
+				}, message, optionalParams);
+			};
+		} }
+	});
+}
+
+//#endregion
+exports.createLogger = createLogger;