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

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAoCA;;;;AAyCmC,UAzClB,OAAA,CAyCkB;EAAW;AAI9C;AACA;AAKA;EAA8C,SAAA,EAAA,EAAA,MAAA;EAYb;;;;EAEf,SAAA,OAAA,EAtDE,WAsDF,CAAA,MAAA,EAAA,MAAA,CAAA;EAAe;;;;;EACnB,SAAA,cAAA,EAhDa,WAgDb,CAAA,MAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA,CAAA;EAAe;;;EAA+B,SAAA,IAAA,EA3C3C,UA2C2C;EAAvD;;;;;;;;;EAiBoC,SAAA,SAAA,EAAA,OAAA,EAAA;EAAS;;;;;EACO,SAAA,sBAAA,EA3CtB,WA2CsB;;AAA7C,KAvCA,UAAA,GAAa,MAuCb,CAAA,MAAA,EAAA,GAAA,CAAA;AAUe,KAhDf,YAAA,GAgDe;EACjB,CAAA,EAAA,KAAA;CAAe;;;AAezB;AAOiB,UAlEA,aAsER,CAAA,eAtEqC,UA0E3B,CAAA,CAAA;EAMP;;;;;AAEZ;;;;;;EAoD6B,GAAA,CAAA,MAAA,EAAA,aAAA,MA1HI,MA0HJ,GAAA,MAAA,CAAA,CAAA,IAAA,EAzHnB,MAyHmB,SAzHJ,YAyHI,GAAA,MAAA,GAzHoB,IAyHpB,EAAA,KAAA,CAAA,EAxHjB,KAwHiB,CAxHX,MAwHW,SAxHI,YAwHJ,GAxHmB,MAwHnB,GAxH4B,MAwH5B,CAxHmC,IAwHnC,CAAA,CAAA,CAAA,EAvHxB,OAuHwB,CAAA,CAvHf,MAuHe,SAvHA,YAuHA,GAvHe,MAuHf,GAvHwB,MAuHxB,CAvH+B,IAuH/B,CAAA,CAAA,GAAA,IAAA,CAAA;EAejB,SAAA,EAAA,EApIG,OAoIQ,CApIA,KAoIA,CAAA,MAAA,CAAA,CAAA;EAGV;;;;;;;AAab;;;;EAMe,GAAA,CAAA,MAAA,EAAA,aAAA,MA7IkB,MA6IlB,GAAA,MAAA,CAAA,CAAA,IAAA,EA5IL,MA4IK,SA5IU,YA4IV,GAAA,MAAA,GA5IkC,IA4IlC,EAAA,KAAA,EA3IJ,MA2II,SA3IW,YA2IX,GA3I0B,MA2I1B,GA3ImC,MA2InC,CA3I0C,IA2I1C,CAAA,EAAA,KAAA,CAAA,EA1IH,KA0IG,CA1IG,MA0IH,SA1IkB,YA0IlB,GA1IiC,MA0IjC,GA1I0C,MA0I1C,CA1IiD,IA0IjD,CAAA,CAAA,CAAA,EAAA,IAAA;EACL;;AAeV;;;;;EAyFiB,KAAA,CAAA,aAAA,MAzOU,MAyOV,CAAA,CAAA,IAAA,EAxOP,MAwOO,SAxOQ,YAwOR,GAAA,MAAA,GAxOgC,IAwOhC,CAAA,EAAA,IAAA;EAA8B;;;;;;EAYzB,QAAA,EAAA,EAAA,IAAA;;;;;AAEjB,UAvOY,WAAA,CAuOZ;EAoBwB;;;EAEhB,KAAA,CAAA,EAAA,MAAA;;AAcgD,UApQ5C,WAAA,CAoQ4C;EAAN;;;EAgER,GAAA,EAAA,EAhUtC,OAgUsC,CAAA,MAAA,CAAA;EAAtB;;;EAA2B,MAAA,EAAA,EA5TxC,OA4TwC,CAAA,MAAA,CAAA;;;;;AAW/C,KAjUO,SAiUP,CAAA,CAAA,CAAA,GAAA,CAAA,GAAA,GAjU6B,OAiU7B,CAjUqC,CAiUrC,CAAA,CAAA,GAAA,CAAA,GAAA,GAjUkD,CAiUlD,CAAA;AAS4B,KAxUrB,UAwUqB,CAAA,CAAA,CAAA,GAAA;EAAvB,KAAA,CAAA,EAvUA,KAuUA,CAvUM,CAuUN,CAAA;EAEW;;;;;EAWI,gBAAA,CAAA,EAAA,MAAA;EAAT;;;EA4CH,sBAAA,CAAA,EAAA,MAAA;EACF;;;;;;;EAcmB,gBAAA,CAAA,EA1XT,QA0XS,GAAA,MAAA;EAAd;;;EAEsB,0BAAA,CAAA,EAAA,MAAA;EAChB;;;;;;;;EAGmC,oBAAA,CAAA,EAjXhC,QAiXgC,GAAA,MAAA;EAM5C;;;EAeyC,sBAAA,CAAA,EAAA,MAAA;EAAN;;;;;AAehD;;;EACiC,gBAAA,CAAA,EAvYZ,QAuYY,GAAA,MAAA;EAAvB;;;;AAeV;EAAoD,mBAAA,CAAA,EAAA,MAAA;CAAa;;;;;;AAiBhC,KAxZrB,WAwZqB,CAAA,GAAA,EAAA,GAAA,CAAA,GAAA;EAAe,OAAA,EAAA,MAAA;EAAS,MAAA,EAAA,MAAA;EAAO,SAAA,EArZnD,GAqZmD;EAApD,GAAA,CAAA,EAAA,MAAA;EACE,OAAA,CAAA,EApZF,MAoZE,CAAA,MAAA,EAAA,MAAA,CAAA;EAAe,UAAA,CAAA,EAnZd,KAmZc,CAnZR,GAmZQ,CAAA;EAAe,WAAA,CAAA,EAlZ5B,KAkZ4B,CAlZtB,GAkZsB,CAAA;EAAS,cAAA,CAAA,EAAA,MAAA;CAAO;;;;;;AAjBf,KAxXjC,WAwXiC,CAAA,GAAA,CAAA,GAAA;EAyB5B,OAAI,EAAA,MAAA;EAiBT,MAAA,EAAA,MAAA;EAA4B,SAAA,EA/Z3B,GA+Z2B;EAAR,GAAA,CAAA,EAAA,MAAA;EAQZ,OAAA,CAAA,EAraR,MAqaQ,CAAA,MAAA,EAAA,MAAA,CAAA;EAAmC,UAAA,CAAA,EApaxC,KAoawC,CApalC,GAoakC,CAAA;EAAf,KAAA,CAAA,EAna9B,QAma8B,GAAA,MAAA;EAgBd,cAAA,CAAA,EAAA,MAAA;CAAa;;;;;AAOvC;AAEA;AAeA;AAKA;;;;AAAuE,UAjctD,OAAA,SAAgB,cAicsC,CAAA;EAE1D;;;;;;;;;EAoCD,IAAA,EA7dJ,IA6dI;EACgB;;;;EAuBhB,OAAA,EA/eD,OA+eC;EACgB;;;EAqBU,IAAA,EAhgB9B,WAggB8B;EAC1B;;;;;;;;AAuBZ;;;;;;;;;;;AAwBA;;;;;;;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAxgBiB,UAAU,KAAK,eAAe;;;;+BAKhB,UAAU,KAAK,eAAe;;;;+BAOjD,UAAU,aACT,WAAW,KACnB,eAAe;;;;;;;;;;;;;;;;;;;uBAoBG,MAAM;;aAEhB,eAAe;;;;;;;;;;;;;4CAcgB,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;kBAuB3C,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAyC5B,sBAAsB,KAAK,OAAO,QAAQ;;;;;;;wBASzD,4BAA4B,kBAEjC,OAAO,cAAc;;;;;;;0BAShB,uBAAuB,kBAE5B,OAAO,SAAS;;;;;;;8BASX,uBAAuB,kBAE5B,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4CZ,sBAAsB,WACxB,cACN,WAAW,QAAQ;;;;;;;;2BAUf,4BAA4B,wBAE1B,cACN,WAAW,cAAc;oBAEV,kBAAkB,kBAC5B,YAAY,KAAK,OACtB,kBAAkB;oBAEH,kBAAkB,YAAY,OAAO;;;;;aAM5C;;;;;;uBAOU;;;;;;;0BAQG,sBAAsB,MAAM,KAAK,eAAe;;;;;;;;;;;;;;UAezD,6BAA6B,aAAa,sBACjD,SAAS,cAAc,SAAS;;;;;;;;;;;;;;UAezB,mCAAmC,aAAa,sBACvD,SAAS;;;;;;;;;;;;;iCAcc,uBACvB,eAAe,wBAAwB,cACrC,MAAM,eAAe,eAAe,SAAS,OAAO,SAC3D,SAAS,eAAe,eAAe,SAAS,OAAO;;;;eAK7C,QAAQ;;UAGN,IAAA;;;;;;;;;;;;;;;KAiBL,oBAAoB,QAAQ;;;;;;;;oBAQpB,oBAAoB,eAAe;;;;;;;;;;;;;;;0BAgB7B,aAAa,kBAAkB,IAAI,eAAe;;;;;;KAOhE,YAAA;;;cAEC;;;;;0BAKa;;KAUd,gBAAA;yBAEa,QAAQ;;KAGrB,uBAAuB,eAAe,KAAK;cAE1C;;;;;;;;;;+BAUkB,mCACnB,IACP,uCAAuC,IAAI,QAAQ,EAAE;;;;;;;;;;gCAuB1B,mCACpB,IACP,eAAe,QAAQ;;;;;;;;;;;+BAsBG,mCACnB,IACP,eAAe,QAAQ;;;;;;;;;;sCAqBU,mCAC1B,IACP,uCACqB,IAAI,qBAAqB,QAAQ,EAAE;;;;;;;KAqBjD,oBAAoB,QAAQ;;;;UAI9B,QAAQ;;;;;kBAMA,IAAI;;;;;4BAMM;;;;SAKnB,eAAe;;UAGP,qCAAqC,aAAa,sBACzD,oBAAoB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;mCAwBJ,MAAM,KAAK,eAAe;;UAG5C,+BAA+B,aAAa,sBAEzD,sBAAsB,SACtB,cAAc,SACd"}

package/dist/context.js

@@ -0,0 +1,29 @@
+import { ContextImpl } from "./context_impl.js";
+
+//#region src/context.ts
+const InvocationIdParser = { fromString(id) {
+	if (!id.startsWith("inv")) throw new Error(`Expected invocation id to start with 'inv' but got ${id}`);
+	return id;
+} };
+const RestatePromise = {
+	all(values) {
+		if (values.length === 0) throw new Error("Expected combineable promise to have at least one promise");
+		return ContextImpl.createCombinator((p) => Promise.all(p), values);
+	},
+	race(values) {
+		if (values.length === 0) throw new Error("Expected combineable promise to have at least one promise");
+		return ContextImpl.createCombinator((p) => Promise.race(p), values);
+	},
+	any(values) {
+		if (values.length === 0) throw new Error("Expected combineable promise to have at least one promise");
+		return ContextImpl.createCombinator((p) => Promise.any(p), values);
+	},
+	allSettled(values) {
+		if (values.length === 0) throw new Error("Expected combineable promise to have at least one promise");
+		return ContextImpl.createCombinator((p) => Promise.allSettled(p), values);
+	}
+};
+
+//#endregion
+export { InvocationIdParser, RestatePromise };
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","names":[],"sources":["../src/context.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\nimport type { Client, SendClient } from \"./types/rpc.js\";\nimport type {\n  RestateContext,\n  RestateObjectContext,\n  RestateObjectSharedContext,\n  RestateWorkflowContext,\n  RestateWorkflowSharedContext,\n  Service,\n  ServiceDefinitionFrom,\n  VirtualObject,\n  VirtualObjectDefinitionFrom,\n  Workflow,\n  WorkflowDefinitionFrom,\n  Serde,\n  Duration,\n} from \"@restatedev/restate-sdk-core\";\nimport { ContextImpl } from \"./context_impl.js\";\nimport type { TerminalError } from \"./types/errors.js\";\n\n/**\n * Represents the original request as sent to this handler.\n *\n * A request object includes the request headers, and the raw unparsed\n * request body.\n */\nexport interface Request {\n  /**\n   * The unique id that identifies the current function invocation. This id is guaranteed to be\n   * unique across invocations, but constant across reties and suspensions.\n   */\n  readonly id: string;\n\n  /**\n   * Request headers - the following headers capture the original invocation headers, as provided to\n   * the ingress.\n   */\n  readonly headers: ReadonlyMap<string, string>;\n\n  /**\n   * Attempt headers - the following headers are sent by the restate runtime.\n   * These headers are attempt specific, generated by the restate runtime uniquely for each attempt.\n   * These headers might contain information such as the W3C trace context, and attempt specific information.\n   */\n  readonly attemptHeaders: ReadonlyMap<string, string | string[] | undefined>;\n\n  /**\n   * Raw unparsed request body\n   */\n  readonly body: Uint8Array;\n\n  /**\n   * Extra arguments provided to the request handler:\n   * Lambda: [Context]\n   * Cloudflare workers: [Env, ExecutionContext]\n   * Deno: [ConnInfo]\n   * Bun: [Server]\n   * These arguments can contain request-specific values that could change after a suspension.\n   * Care should be taken to use them deterministically.\n   */\n  readonly extraArgs: unknown[];\n\n  /**\n   * This is a signal that is aborted when the current attempt has been completed either successful or unsuccessfully.\n   * When the signal is aborted, the current attempt has been completed and the handler should not perform any more work, other\n   * than cleanup any external resources that might be shared across attempts (e.g. database connections).\n   */\n  readonly attemptCompletedSignal: AbortSignal;\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\nexport type TypedState = Record<string, any>;\nexport type UntypedState = { _: never };\n\n/**\n * Key value store operations. Only keyed services have an attached key-value store.\n */\nexport interface KeyValueStore<TState extends TypedState> {\n  /**\n   * Get/retrieve state from the Restate runtime.\n   * Note that state objects are serialized with `Buffer.from(JSON.stringify(theObject))`\n   * and deserialized with `JSON.parse(value.toString()) as T`.\n   *\n   * @param name key of the state to retrieve\n   * @returns a Promise that is resolved with the value of the state key\n   *\n   * @example\n   * const state = await ctx.get<string>(\"STATE\");\n   */\n  get<TValue, TKey extends keyof TState = string>(\n    name: TState extends UntypedState ? string : TKey,\n    serde?: Serde<TState extends UntypedState ? TValue : TState[TKey]>\n  ): Promise<(TState extends UntypedState ? TValue : TState[TKey]) | null>;\n\n  stateKeys(): Promise<Array<string>>;\n\n  /**\n   * Set/store state in the Restate runtime.\n   * Note that state objects are serialized with `Buffer.from(JSON.stringify(theObject))`\n   * and deserialized with `JSON.parse(value.toString()) as T`.\n   *\n   * @param name key of the state to set\n   * @param value value to set\n   *\n   * @example\n   * ctx.set(\"STATE\", \"Hello\");\n   */\n  set<TValue, TKey extends keyof TState = string>(\n    name: TState extends UntypedState ? string : TKey,\n    value: TState extends UntypedState ? TValue : TState[TKey],\n    serde?: Serde<TState extends UntypedState ? TValue : TState[TKey]>\n  ): void;\n\n  /**\n   * Clear/delete state in the Restate runtime.\n   * @param name key of the state to delete\n   *\n   * @example\n   * ctx.clear(\"STATE\");\n   */\n  clear<TKey extends keyof TState>(\n    name: TState extends UntypedState ? string : TKey\n  ): void;\n\n  /**\n   * Clear/delete all the state entries in the Restate runtime.\n   *\n   * @example\n   * ctx.clearAll();\n   */\n  clearAll(): void;\n}\n\n/**\n * @deprecated SendOptions on the client factory are deprecated, please use `restate.rpc.sendOpts` instead\n */\nexport interface SendOptions {\n  /**\n   * @deprecated SendOptions on the client factory are deprecated, please use `restate.rpc.sendOpts` instead\n   */\n  delay?: number;\n}\n\nexport interface ContextDate {\n  /** Returns the number of milliseconds elapsed since midnight, January 1, 1970 Universal Coordinated Time (UTC).\n   *  This is equivalent to Date.now()\n   */\n  now(): Promise<number>;\n  /** Returns the JSON representation of the current date.\n   * This is equivalent to new Date().toJSON()\n   **/\n  toJSON(): Promise<string>;\n}\n\n/**\n * A function that can be run and its result durably persisted by Restate.\n */\nexport type RunAction<T> = (() => Promise<T>) | (() => T);\n\nexport type RunOptions<T> = {\n  serde?: Serde<T>;\n\n  /**\n   * Max number of attempts (including the initial), before giving up.\n   *\n   * When giving up, `ctx.run` will throw a `TerminalError` wrapping the original error message.\n   */\n  maxRetryAttempts?: number;\n\n  /**\n   * @deprecated Use `maxRetryDuration` instead.\n   */\n  maxRetryDurationMillis?: number;\n\n  /**\n   * Max duration of retries, before giving up.\n   *\n   * When giving up, `ctx.run` will throw a `TerminalError` wrapping the original error message.\n   *\n   * If a number is provided, it will be interpreted as milliseconds.\n   */\n  maxRetryDuration?: Duration | number;\n\n  /**\n   * @deprecated Use `initialRetryInterval` instead.\n   */\n  initialRetryIntervalMillis?: number;\n\n  /**\n   * Initial interval for the first retry attempt.\n   * Retry interval will grow by a factor specified in `retryIntervalFactor`.\n   *\n   * The default is 50 milliseconds.\n   *\n   * If a number is provided, it will be interpreted as milliseconds.\n   */\n  initialRetryInterval?: Duration | number;\n\n  /**\n   * @deprecated Use `maxRetryInterval` instead.\n   */\n  maxRetryIntervalMillis?: number;\n\n  /**\n   * Max interval between retries.\n   * Retry interval will grow by a factor specified in `retryIntervalFactor`.\n   *\n   * The default is 10 seconds.\n   *\n   * If a number is provided, it will be interpreted as milliseconds.\n   */\n  maxRetryInterval?: Duration | number;\n\n  /**\n   * Exponentiation factor to use when computing the next retry delay.\n   *\n   * The default value is `2`, meaning retry interval will double at each attempt.\n   */\n  retryIntervalFactor?: number;\n};\n\n/**\n * Call a handler directly avoiding restate's type safety checks.\n * This is a generic mechanism to invoke handlers directly by only knowing\n * the service and handler name, (or key in the case of objects or workflows)\n */\nexport type GenericCall<REQ, RES> = {\n  service: string;\n  method: string;\n  parameter: REQ;\n  key?: string;\n  headers?: Record<string, string>;\n  inputSerde?: Serde<REQ>;\n  outputSerde?: Serde<RES>;\n  idempotencyKey?: string;\n};\n\n/**\n * Send a message to an handler directly avoiding restate's type safety checks.\n * This is a generic mechanism to invoke handlers directly by only knowing\n * the service and handler name, (or key in the case of objects or workflows)\n */\nexport type GenericSend<REQ> = {\n  service: string;\n  method: string;\n  parameter: REQ;\n  key?: string;\n  headers?: Record<string, string>;\n  inputSerde?: Serde<REQ>;\n  delay?: Duration | number;\n  idempotencyKey?: string;\n};\n\n/**\n * The context that gives access to all Restate-backed operations, for example\n *   - sending reliable messages / RPC through Restate\n *   - execute non-deterministic closures and memoize their result\n *   - sleeps and delayed calls\n *   - awakeables\n *   - ...\n *\n * Virtual objects can also access their key-value store using the {@link ObjectContext}.\n *\n */\nexport interface Context extends RestateContext {\n  /**\n   * Deterministic random methods; these are inherently predictable (seeded on the invocation ID, which is not secret)\n   * and so should not be used for any cryptographic purposes. They are useful for identifiers, idempotency keys,\n   * and for uniform sampling from a set of options. If a cryptographically secure value is needed, please generate that\n   * externally and capture the result with a side effect.\n   *\n   * Calls to these methods from inside `ctx.run` are disallowed and will fail - side effects must be idempotent, and\n   * these calls are not.\n   */\n  rand: Rand;\n\n  /**\n   * Console to use for logging. It attaches to each log message some contextual information,\n   * such as invoked service method and invocation id, and automatically excludes logs during replay.\n   */\n  console: Console;\n\n  /**\n   * Deterministic date.\n   */\n  date: ContextDate;\n\n  /**\n   * Run an operation and store the result in Restate. The operation will thus not\n   * be re-run during a later replay, but take the durable result from Restate.\n   *\n   * This let you capture potentially non-deterministic computation and interaction\n   * with external systems in a safe way.\n   *\n   * Failure semantics are:\n   *   - If an operation has run and persisted before, the result (value or Error) will be\n   *     taken from the Restate journal.\n   *   - There is a small window where an action may be re-run, if a failure\n   *     occurred between a successful run and persisting the result.\n   *   - No second action will be run while a previous run's result is not\n   *     yet durable. That way, effects that build on top of each other can assume\n   *     deterministic results from previous runs, and at most one run will be\n   *     re-executed on replay (the latest, if the failure happened in the small windows\n   *     described above).\n   *\n   * You can customize retry options by either:\n   *\n   * - Providing retry policy options in {@link RunOptions}\n   * - Throwing {@link RetryableError}, providing `retryAfter` option. This can be especially useful when interacting with HTTP requests returning the `Retry-After` header. You can combine the usage of throwing {@link RetryableError} with the `maxRetryAttempts`/`maxRetryDuration` from {@link RunOptions}.\n   *\n   * @example Run some external action and persist its result\n   * ```ts\n   * const result = await ctx.run(someExternalAction)\n   *```\n   * @example Add some retry options\n   * ```ts\n   * const result = await ctx.run(\"my action\", someExternalAction, { maxRetryAttempts: 10 })\n   * ```\n   * @example Terminal errors and retryable errors\n   * ```ts\n   * await ctx.run(\"payment action\", async () => {\n   *   const result = await paymentProvider.charge(txId, paymentInfo);\n   *   if (result.paymentRejected) {\n   *     // this action will not be retried anymore\n   *     throw new TerminalError(\"Payment failed\");\n   *   } else if (result.paymentGatewayBusy) {\n   *     // restate will retry automatically\n   *     // to bound retries, use RunOptions\n   *     throw new Error(\"Payment gateway busy\");\n   *   } else {\n   *     // success!\n   *   }\n   * });\n   * ```\n   * @example Retryable error with custom retry delay\n   * ```ts\n   * await ctx.run(\"payment action\", async () => {\n   *   const res = fetch(...);\n   *   if (!res.ok) {\n   *     // Read Retry-After header\n   *     const retryAfterHeader = res.headers['Retry-After']\n   *\n   *     // Use RetryableError to customize in how long to retry\n   *     throw RetryableError.from(cause, { retryAfter: { seconds: retryAfterHeader } })\n   *   }\n   * }, {\n   *   // Retry at most ten times\n   *   maxRetryAttempts: 10\n   * });\n   * ```\n   *\n   * @param action The function to run.\n   */\n  run<T>(action: RunAction<T>): RestatePromise<T>;\n\n  /**\n   * Same as {@link run}, but providing a name, used for observability purposes.\n   */\n  run<T>(name: string, action: RunAction<T>): RestatePromise<T>;\n\n  /**\n   * See {@link run}\n   */\n  run<T>(\n    name: string,\n    action: RunAction<T>,\n    options: RunOptions<T>\n  ): RestatePromise<T>;\n\n  /**\n   * Register an awakeable and pause the processing until the awakeable ID (and optional payload) have been returned to the service\n   * (via ctx.completeAwakeable(...)). The SDK deserializes the payload with `JSON.parse(result.toString()) as T`.\n   * @returns\n   * - id: the string ID that has to be used to complete the awakaeble by some external service\n   * - promise: the Promise that needs to be awaited and that is resolved with the payload that was supplied by the service which completed the awakeable\n   * @example Retryable errors and terminal errors\n   * const awakeable = ctx.awakeable<string>();\n   *\n   * // send the awakeable ID to some external service that will wake this one back up\n   * // The ID can be retrieved by:\n   * const id = awakeable.id;\n   *\n   * // ... send to external service ...\n   *\n   * // Wait for the external service to wake this service back up\n   * const result = await awakeable.promise;\n   */\n  awakeable<T>(serde?: Serde<T>): {\n    id: string;\n    promise: RestatePromise<T>;\n  };\n\n  /**\n   * Resolve an awakeable.\n   * @param id the string ID of the awakeable.\n   * This is supplied by the service that needs to be woken up.\n   * @param payload the payload to pass to the service that is woken up.\n   * The SDK serializes the payload with `Buffer.from(JSON.stringify(payload))`\n   * and deserializes it in the receiving service with `JSON.parse(result.toString()) as T`.\n   * @example Retryable error with custom retry delay\n   * // The sleeping service should have sent the awakeableIdentifier string to this service.\n   * ctx.resolveAwakeable(awakeableIdentifier, \"hello\");\n   */\n  resolveAwakeable<T>(id: string, payload?: T, serde?: Serde<T>): void;\n\n  /**\n   * Reject an awakeable. When rejecting, the service waiting on this awakeable will be woken up with a terminal error with the provided reason.\n   * @param id the string ID of the awakeable.\n   * This is supplied by the service that needs to be woken up.\n   * @param reason the reason of the rejection.\n   *\n   * @example\n   * // The sleeping service should have sent the awakeableIdentifier string to this service.\n   * ctx.rejectAwakeable(awakeableIdentifier, \"super bad error\");\n   */\n  rejectAwakeable(id: string, reason: string): void;\n\n  /**\n   * Sleep until a timeout has passed.\n   * @param duration either Duration type or milliseconds.\n   * @param name Observability name. This will be shown in the UI.\n   * This is a lower-bound.\n   *\n   * @example\n   * await ctx.sleep(1000);\n   */\n  sleep(duration: Duration | number, name?: string): RestatePromise<void>;\n\n  /**\n   * Makes a type-safe request/response RPC to the specified target service.\n   *\n   * The RPC goes through Restate and is guaranteed to be reliably delivered. The RPC is also\n   * journaled for durable execution and will thus not be duplicated when the handler is re-invoked\n   * for retries or after suspending.\n   *\n   * This call will return the result produced by the target handler, or the Error, if the target\n   * handler finishes with a Terminal Error.\n   *\n   * This call is a suspension point: The handler might suspend while awaiting the response and\n   * resume once the response is available.\n   *\n   * @example\n   * *Service Side:*\n   * ```ts\n   * const service = restate.service(\n   *   name: \"myservice\",\n   *   handlers: {\n   *    someAction:    async(ctx: restate.Context, req: string) => { ... },\n   *    anotherAction: async(ctx: restate.Context, count: number) => { ... }\n   * });\n   *\n   * // option 1: export only the type signature\n   * export type Service = typeof service;\n   *\n   *\n   * restate.serve({ services: [service], port: 9080 });\n   * ```\n   * *Client side:*\n   * ```ts\n   * // option 1: use only types and supply service name separately\n   * const result1 = await ctx.serviceClient<Service>({name: \"myservice\"}).someAction(\"hello!\");\n   *\n   * // option 2: use full API spec\n   * type MyService: Service = { name: \"myservice\" };\n   * const result2 = await ctx.serviceClient(Service).anotherAction(1337);\n   * ```\n   */\n  serviceClient<D>(opts: ServiceDefinitionFrom<D>): Client<Service<D>>;\n\n  /**\n   * Same as {@link serviceClient} but for virtual objects.\n   *\n   * @param opts\n   * @param key the virtual object key\n   */\n  objectClient<D>(\n    opts: VirtualObjectDefinitionFrom<D>,\n    key: string\n  ): Client<VirtualObject<D>>;\n\n  /**\n   * Same as {@link serviceClient} but for workflows.\n   *\n   * @param opts\n   * @param key the workflow key\n   */\n  workflowClient<D>(\n    opts: WorkflowDefinitionFrom<D>,\n    key: string\n  ): Client<Workflow<D>>;\n\n  /**\n   * Same as {@link objectSendClient} but for workflows.\n   *\n   * @param opts\n   * @param key the workflow key\n   */\n  workflowSendClient<D>(\n    opts: WorkflowDefinitionFrom<D>,\n    key: string\n  ): SendClient<Workflow<D>>;\n\n  /**\n   * Makes a type-safe one-way RPC to the specified target service. This method effectively behaves\n   * like enqueuing the message in a message queue.\n   *\n   * The message goes through Restate and is guaranteed to be reliably delivered. The RPC is also\n   * journaled for durable execution and will thus not be duplicated when the handler is re-invoked\n   * for retries or after suspending.\n   *\n   * This call will return immediately; the message sending happens asynchronously in the background.\n   * Despite that, the message is guaranteed to be sent, because the completion of the invocation that\n   * triggers the send (calls this function) happens logically after the sending. That means that any\n   * failure where the message does not reach Restate also cannot complete this invocation, and will\n   * hence recover this handler and (through the durable execution) recover the message to be sent.\n   *\n   * @example\n   * *Service Side:*\n   * ```ts\n   * const service = restate.service(\n   *   name: \"myservice\",\n   *   handlers: {\n   *    someAction:    async(ctx: restate.Context, req: string) => { ... },\n   *    anotherAction: async(ctx: restate.Context, count: number) => { ... }\n   * });\n   *\n   * // option 1: export only the type signature of the router\n   * export type MyApi = typeof service;\n   *\n   * // option 2: export the API definition with type and name (name)\n   * const MyService: MyApi = { name: \"myservice\" };\n   *\n   * restate.serve({ services: [service], port: 9080 });\n   * ```\n   * *Client side:*\n   * ```ts\n   * // option 1: use only types and supply service name separately\n   * ctx.serviceSendClient<MyApi>({name: \"myservice\"}).someAction(\"hello!\");\n   *\n   * // option 2: use full API spec\n   * ctx.serviceSendClient(MyService).anotherAction(1337);\n   * ```\n   */\n  serviceSendClient<D>(\n    service: ServiceDefinitionFrom<D>,\n    opts?: SendOptions\n  ): SendClient<Service<D>>;\n\n  /**\n   * Same as {@link serviceSendClient} but for virtual objects.\n   *\n   * @param obj\n   * @param key the virtual object key\n   * @param opts Send options\n   */\n  objectSendClient<D>(\n    obj: VirtualObjectDefinitionFrom<D>,\n    key: string,\n    opts?: SendOptions\n  ): SendClient<VirtualObject<D>>;\n\n  genericCall<REQ = Uint8Array, RES = Uint8Array>(\n    call: GenericCall<REQ, RES>\n  ): InvocationPromise<RES>;\n\n  genericSend<REQ = Uint8Array>(call: GenericSend<REQ>): InvocationHandle;\n\n  /**\n   * Returns the raw request that triggered that handler.\n   * Use that object to inspect the original request headers\n   */\n  request(): Request;\n\n  /**\n   * Cancel an invocation\n   *\n   * @param invocationId the invocation id to cancel\n   */\n  cancel(invocationId: InvocationId): void;\n\n  /**\n   * Attach to an invocation\n   *\n   * @param invocationId the invocation id to attach to\n   * @param serde the serde to use for the result, default to JSON serde.\n   */\n  attach<T>(invocationId: InvocationId, serde?: Serde<T>): RestatePromise<T>;\n}\n\n/**\n * The context that gives access to all Restate-backed operations, for example\n *   - sending reliable messages / RPC through Restate\n *   - access/update state\n *   - execute non-deterministic closures and memoize their result\n *   - sleeps and delayed calls\n *   - awakeables\n *   - ...\n *\n * This context can be used only within virtual objects.\n *\n */\nexport interface ObjectContext<TState extends TypedState = UntypedState>\n  extends Context, KeyValueStore<TState>, RestateObjectContext {\n  key: string;\n}\n\n/**\n * The context that gives access to all Restate-backed operations, for example\n *   - sending reliable messages / RPC through Restate\n *   - execute non-deterministic closures and memoize their result\n *   - sleeps and delayed calls\n *   - awakeables\n *   - ...\n *\n * This context can be used only within a shared virtual objects.\n *\n */\nexport interface ObjectSharedContext<TState extends TypedState = UntypedState>\n  extends Context, RestateObjectSharedContext {\n  key: string;\n\n  /**\n   * Get/retrieve state from the Restate runtime.\n   * Note that state objects are serialized with `Buffer.from(JSON.stringify(theObject))`\n   * and deserialized with `JSON.parse(value.toString()) as T`.\n   *\n   * @param name key of the state to retrieve\n   * @returns a Promise that is resolved with the value of the state key\n   *\n   * @example\n   * const state = await ctx.get<string>(\"STATE\");\n   */\n  get<TValue, TKey extends keyof TState = string>(\n    name: TState extends UntypedState ? string : TKey,\n    serde?: Serde<TState extends UntypedState ? TValue : TState[TKey]>\n  ): Promise<(TState extends UntypedState ? TValue : TState[TKey]) | null>;\n\n  /**\n   * Retrieve all the state keys for this object.\n   */\n  stateKeys(): Promise<Array<string>>;\n}\n\nexport interface Rand {\n  /**\n   * Equivalent of JS `Math.random()` but deterministic; seeded by the invocation ID of the current invocation,\n   * each call will return a new pseudorandom float within the range [0,1)\n   */\n  random(): number;\n\n  /**\n   * Using the same random source and seed as random(), produce a UUID version 4 string. This is inherently predictable\n   * based on the invocation ID and should not be used in cryptographic contexts\n   */\n  uuidv4(): string;\n}\n\n/**\n * A promise that can be combined using Promise combinators in RestateContext.\n */\nexport type RestatePromise<T> = Promise<T> & {\n  /**\n   * Creates a promise that awaits for the current promise up to the specified timeout duration.\n   * If the timeout is fired, this Promise will be rejected with a {@link TimeoutError}.\n   *\n   * @param millis duration of the sleep in millis.\n   * This is a lower-bound.\n   */\n  orTimeout(millis: Duration | number): RestatePromise<T>;\n\n  /**\n   * Creates a new {@link RestatePromise} that maps the result of this promise with\n   * the provided `mapper`, once this promise is fulfilled.\n   *\n   * **NOTE**: You **MUST** use this API when you need to map the result of a\n   * {@link RestatePromise} without `await`ing it, rather than using {@link Promise.then}.\n   * {@link Promise.then} is used by Restate to distinguish when awaiting an asynchronous operation,\n   * thus calling `.then` on several Restate promises can lead to concurrency issues.\n   *\n   * @param mapper the function to execute when this promise is fulfilled.\n   * If the promise completed successfully, `value` is provided as input, otherwise `failure` is provided as input.\n   * If this mapper returns a value, this value will be used to resolve the returned {@link RestatePromise}.\n   * If the mapper throws a {@link TerminalError}, this error will be used to reject the returned {@link RestatePromise}.\n   */\n  map<U>(mapper: (value?: T, failure?: TerminalError) => U): RestatePromise<U>;\n};\n\n/**\n * Represents an invocation id.\n * @see {@link InvocationIdParser}\n */\nexport type InvocationId = string & { __brand: \"InvocationId\" };\n\nexport const InvocationIdParser = {\n  /**\n   * Creates an invocation id from a string.\n   * @param id the string to use as invocation id.\n   */\n  fromString(id: string): InvocationId {\n    if (!id.startsWith(\"inv\")) {\n      throw new Error(\n        `Expected invocation id to start with 'inv' but got ${id}`\n      );\n    }\n    return id as InvocationId;\n  },\n};\n\nexport type InvocationHandle = {\n  // The invocation id of the call\n  readonly invocationId: Promise<InvocationId>;\n};\n\nexport type InvocationPromise<T> = RestatePromise<T> & InvocationHandle;\n\nexport const RestatePromise = {\n  /**\n   * Creates a Promise that is resolved with an array of results when all of the provided Promises\n   * resolve, or rejected when any Promise is rejected.\n   *\n   * See {@link Promise.all} for more details.\n   *\n   * @param values An iterable of Promises.\n   * @returns A new Promise.\n   */\n  all<const T extends readonly RestatePromise<unknown>[]>(\n    values: T\n  ): RestatePromise<{ -readonly [P in keyof T]: Awaited<T[P]> }> {\n    if (values.length === 0) {\n      throw new Error(\n        \"Expected combineable promise to have at least one promise\"\n      );\n    }\n    return ContextImpl.createCombinator(\n      (p) => Promise.all(p),\n      values\n    ) as RestatePromise<{\n      -readonly [P in keyof T]: Awaited<T[P]>;\n    }>;\n  },\n\n  /**\n   * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved\n   * or rejected.\n   *\n   * See {@link Promise.race} for more details.\n   *\n   * @param values An iterable of Promises.\n   * @returns A new Promise.\n   */\n  race<const T extends readonly RestatePromise<unknown>[]>(\n    values: T\n  ): RestatePromise<Awaited<T[number]>> {\n    if (values.length === 0) {\n      throw new Error(\n        \"Expected combineable promise to have at least one promise\"\n      );\n    }\n    return ContextImpl.createCombinator(\n      (p) => Promise.race(p),\n      values\n    ) as RestatePromise<Awaited<T[number]>>;\n  },\n\n  /**\n   * Creates a promise that fulfills when any of the input's promises fulfills, with this first fulfillment value.\n   * It rejects when all the input's promises reject (including when an empty iterable is passed),\n   * with an AggregateError containing an array of rejection reasons.\n   *\n   * See {@link Promise.any} for more details.\n   *\n   * @param values An iterable of Promises.\n   * @returns A new Promise.\n   */\n  any<const T extends readonly RestatePromise<unknown>[]>(\n    values: T\n  ): RestatePromise<Awaited<T[number]>> {\n    if (values.length === 0) {\n      throw new Error(\n        \"Expected combineable promise to have at least one promise\"\n      );\n    }\n    return ContextImpl.createCombinator(\n      (p) => Promise.any(p),\n      values\n    ) as RestatePromise<Awaited<T[number]>>;\n  },\n\n  /**\n   * Creates a promise that fulfills when all the input's promises settle (including when an empty iterable is passed),\n   * with an array of objects that describe the outcome of each promise.\n   *\n   * See {@link Promise.allSettled} for more details.\n   *\n   * @param values An iterable of Promises.\n   * @returns A new Promise.\n   */\n  allSettled<const T extends readonly RestatePromise<unknown>[]>(\n    values: T\n  ): RestatePromise<{\n    -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>;\n  }> {\n    if (values.length === 0) {\n      throw new Error(\n        \"Expected combineable promise to have at least one promise\"\n      );\n    }\n    return ContextImpl.createCombinator(\n      (p) => Promise.allSettled(p),\n      values\n    ) as RestatePromise<{\n      -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>;\n    }>;\n  },\n};\n\n/**\n * Workflow bound durable promise\n *\n * See {@link WorkflowSharedContext} promise..\n */\nexport type DurablePromise<T> = Promise<T> & {\n  /**\n   * Returns the value of the promise, if it has been resolved.\n   */\n  peek(): Promise<T | undefined>;\n\n  /**\n   * Resolve the promise with the given value.\n   * @param value the value to resolve the promise with\n   */\n  resolve(value?: T): Promise<void>;\n\n  /**\n   * Reject the promise with the given error message.\n   * @param errorMsg the error message to use for rejection.\n   */\n  reject(errorMsg: string): Promise<void>;\n\n  /**\n   * Obtain a {@link RestatePromise} variant of this promise.\n   */\n  get(): RestatePromise<T>;\n};\n\nexport interface WorkflowSharedContext<TState extends TypedState = UntypedState>\n  extends ObjectSharedContext<TState>, RestateWorkflowSharedContext {\n  /**\n   * Create a durable promise that can be resolved or rejected during the workflow execution.\n   * The promise is bound to the workflow and will be persisted across suspensions and retries.\n   * @example Add some retry options\n   * ```ts\n   * const wf = restate.workflow({\n   *   name: \"myWorkflow\",\n   *   handlers: {\n   *     run: async (ctx: restate.WorkflowContext) => {\n   *       // ... do some work ...\n   *       const payment = await ctx.promise<Payment>(\"payment.succeeded\");\n   *       // ... do some more work ...\n   *     },\n   *\n   *     onPaymentSucceeded: async (ctx: restate.WorkflowContext, payment) => {\n   *       // ... handle payment succeeded ...\n   *       await ctx.promise(\"payment.succeeded\").resolve(payment);\n   *     }\n   * });\n   * ```\n   *\n   * @param name the name of the durable promise\n   */\n  promise<T>(name: string, serde?: Serde<T>): DurablePromise<T>;\n}\n\nexport interface WorkflowContext<TState extends TypedState = UntypedState>\n  extends\n    WorkflowSharedContext<TState>,\n    ObjectContext<TState>,\n    RestateWorkflowContext {}\n"],"mappings":";;;AA+rBA,MAAa,qBAAqB,EAKhC,WAAW,IAA0B;AACnC,KAAI,CAAC,GAAG,WAAW,MAAM,CACvB,OAAM,IAAI,MACR,sDAAsD,KACvD;AAEH,QAAO;GAEV;AASD,MAAa,iBAAiB;CAU5B,IACE,QAC6D;AAC7D,MAAI,OAAO,WAAW,EACpB,OAAM,IAAI,MACR,4DACD;AAEH,SAAO,YAAY,kBAChB,MAAM,QAAQ,IAAI,EAAE,EACrB,OACD;;CAcH,KACE,QACoC;AACpC,MAAI,OAAO,WAAW,EACpB,OAAM,IAAI,MACR,4DACD;AAEH,SAAO,YAAY,kBAChB,MAAM,QAAQ,KAAK,EAAE,EACtB,OACD;;CAaH,IACE,QACoC;AACpC,MAAI,OAAO,WAAW,EACpB,OAAM,IAAI,MACR,4DACD;AAEH,SAAO,YAAY,kBAChB,MAAM,QAAQ,IAAI,EAAE,EACrB,OACD;;CAYH,WACE,QAGC;AACD,MAAI,OAAO,WAAW,EACpB,OAAM,IAAI,MACR,4DACD;AAEH,SAAO,YAAY,kBAChB,MAAM,QAAQ,WAAW,EAAE,EAC5B,OACD;;CAIJ"}

package/dist/context_impl.cjs

@@ -0,0 +1,441 @@
+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_completable_promise = require('./utils/completable_promise.cjs');
+const require_sdk_shared_core_wasm_bindings = require('./endpoint/handlers/vm/sdk_shared_core_wasm_bindings.cjs');
+const require_rand = require('./utils/rand.cjs');
+const require_promises = require('./promises.cjs');
+const require_io = require('./io.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/context_impl.ts
+var ContextImpl = class {
+	rand;
+	date = {
+		now: () => {
+			return this.run(() => Date.now());
+		},
+		toJSON: () => {
+			return this.run(() => (/* @__PURE__ */ new Date()).toJSON());
+		}
+	};
+	outputPump;
+	runClosuresTracker;
+	promisesExecutor;
+	defaultSerde;
+	constructor(coreVm, input, console, handlerKind, vmLogger, invocationRequest, invocationEndPromise, inputReader, outputWriter, journalValueCodec, defaultSerde, asTerminalError) {
+		this.coreVm = coreVm;
+		this.input = input;
+		this.console = console;
+		this.handlerKind = handlerKind;
+		this.vmLogger = vmLogger;
+		this.invocationRequest = invocationRequest;
+		this.invocationEndPromise = invocationEndPromise;
+		this.journalValueCodec = journalValueCodec;
+		this.asTerminalError = asTerminalError;
+		this.rand = new require_rand.RandImpl(input.random_seed, () => {});
+		this.outputPump = new require_io.OutputPump(coreVm, outputWriter);
+		this.runClosuresTracker = new RunClosuresTracker();
+		this.promisesExecutor = new require_promises.PromisesExecutor(coreVm, new require_io.InputPump(coreVm, inputReader, this.handleInvocationEndError.bind(this)), this.outputPump, this.runClosuresTracker, this.promiseExecutorErrorCallback.bind(this));
+		this.defaultSerde = defaultSerde ?? __restatedev_restate_sdk_core.serde.json;
+	}
+	cancel(invocationId) {
+		this.processNonCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.CancelInvocation, () => {}, (vm) => vm.sys_cancel_invocation(invocationId));
+	}
+	attach(invocationId, serde$1) {
+		return this.processCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.AttachInvocation, () => {}, (vm) => vm.sys_attach_invocation(invocationId), SuccessWithSerde(serde$1 ?? this.defaultSerde, this.journalValueCodec), Failure);
+	}
+	get key() {
+		switch (this.handlerKind) {
+			case require_rpc.HandlerKind.EXCLUSIVE:
+			case require_rpc.HandlerKind.SHARED:
+			case require_rpc.HandlerKind.WORKFLOW: return this.input.key;
+			default: throw new require_errors.TerminalError("this handler type doesn't support key()");
+		}
+	}
+	request() {
+		return this.invocationRequest;
+	}
+	get(name, serde$1) {
+		return this.processCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.GetState, () => {}, (vm) => vm.sys_get_state(name), VoidAsNull, SuccessWithSerde(serde$1 ?? this.defaultSerde, this.journalValueCodec));
+	}
+	stateKeys() {
+		return this.processCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.GetStateKeys, () => {}, (vm) => vm.sys_get_state_keys(), StateKeys);
+	}
+	set(name, value, serde$1) {
+		this.processNonCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.SetState, () => this.journalValueCodec.encode((serde$1 ?? this.defaultSerde).serialize(value)), (vm, bytes) => vm.sys_set_state(name, bytes));
+	}
+	clear(name) {
+		this.processNonCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.ClearState, () => {}, (vm) => vm.sys_clear_state(name));
+	}
+	clearAll() {
+		this.processNonCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.ClearAllState, () => {}, (vm) => vm.sys_clear_all_state());
+	}
+	genericCall(call) {
+		const requestSerde = call.inputSerde ?? __restatedev_restate_sdk_core.serde.binary;
+		const responseSerde = call.outputSerde ?? __restatedev_restate_sdk_core.serde.binary;
+		let parameter;
+		try {
+			parameter = this.journalValueCodec.encode(requestSerde.serialize(call.parameter));
+		} catch (e) {
+			this.handleInvocationEndError(e, (vm, error) => vm.notify_error_for_next_command(error.message, error.stack, require_sdk_shared_core_wasm_bindings.WasmCommandType.Call));
+			return new require_promises.InvocationPendingPromise(this);
+		}
+		try {
+			const call_handles = this.coreVm.sys_call(call.service, call.method, parameter, call.key, call.headers ? Object.entries(call.headers).map(([key, value]) => new require_sdk_shared_core_wasm_bindings.WasmHeader(key, value)) : [], call.idempotencyKey);
+			const commandIndex = this.coreVm.last_command_index();
+			const invocationIdPromise = new require_promises.RestateSinglePromise(this, call_handles.invocation_id_completion_id, completeCommandPromiseUsing(require_sdk_shared_core_wasm_bindings.WasmCommandType.Call, commandIndex, InvocationIdCompleter));
+			return new require_promises.RestateInvocationPromise(this, call_handles.call_completion_id, completeCommandPromiseUsing(require_sdk_shared_core_wasm_bindings.WasmCommandType.Call, commandIndex, SuccessWithSerde(responseSerde, this.journalValueCodec), Failure), invocationIdPromise);
+		} catch (e) {
+			this.handleInvocationEndError(e);
+			return new require_promises.InvocationPendingPromise(this);
+		}
+	}
+	genericSend(send) {
+		const requestSerde = send.inputSerde ?? __restatedev_restate_sdk_core.serde.binary;
+		let parameter;
+		try {
+			parameter = this.journalValueCodec.encode(requestSerde.serialize(send.parameter));
+		} catch (e) {
+			this.handleInvocationEndError(e, (vm, error) => vm.notify_error_for_next_command(error.message, error.stack, require_sdk_shared_core_wasm_bindings.WasmCommandType.OneWayCall));
+			return new require_promises.InvocationPendingPromise(this);
+		}
+		try {
+			const delay = send.delay !== void 0 ? (0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(send.delay) : void 0;
+			const handles = this.coreVm.sys_send(send.service, send.method, parameter, send.key, send.headers ? Object.entries(send.headers).map(([key, value]) => new require_sdk_shared_core_wasm_bindings.WasmHeader(key, value)) : [], delay !== void 0 && delay > 0 ? BigInt(delay) : void 0, send.idempotencyKey);
+			const commandIndex = this.coreVm.last_command_index();
+			return { invocationId: new require_promises.RestateSinglePromise(this, handles.invocation_id_completion_id, completeCommandPromiseUsing(require_sdk_shared_core_wasm_bindings.WasmCommandType.OneWayCall, commandIndex, InvocationIdCompleter)) };
+		} catch (e) {
+			this.handleInvocationEndError(e);
+			return { invocationId: require_promises.pendingPromise() };
+		}
+	}
+	serviceClient({ name }) {
+		return require_rpc.makeRpcCallProxy((call) => this.genericCall(call), this.defaultSerde, name);
+	}
+	objectClient({ name }, key) {
+		return require_rpc.makeRpcCallProxy((call) => this.genericCall(call), this.defaultSerde, name, key);
+	}
+	workflowClient({ name }, key) {
+		return require_rpc.makeRpcCallProxy((call) => this.genericCall(call), this.defaultSerde, name, key);
+	}
+	serviceSendClient({ name }, opts) {
+		return require_rpc.makeRpcSendProxy((send) => this.genericSend(send), this.defaultSerde, name, void 0, opts?.delay);
+	}
+	objectSendClient({ name }, key, opts) {
+		return require_rpc.makeRpcSendProxy((send) => this.genericSend(send), this.defaultSerde, name, key, opts?.delay);
+	}
+	workflowSendClient({ name }, key, opts) {
+		return require_rpc.makeRpcSendProxy((send) => this.genericSend(send), this.defaultSerde, name, key, opts?.delay);
+	}
+	run(nameOrAction, actionSecondParameter, options) {
+		const { name, action } = unpackRunParameters(nameOrAction, actionSecondParameter);
+		const serde$1 = options?.serde ?? this.defaultSerde;
+		let handle;
+		try {
+			handle = this.coreVm.sys_run(name ?? "");
+		} catch (e) {
+			this.handleInvocationEndError(e);
+			return new require_promises.RestatePendingPromise(this);
+		}
+		const commandIndex = this.coreVm.last_command_index();
+		const doRun = async () => {
+			const startTime = Date.now();
+			let res;
+			let err;
+			try {
+				res = await action();
+			} catch (e) {
+				err = require_errors.ensureError(e, this.asTerminalError);
+			}
+			const attemptDuration = Date.now() - startTime;
+			try {
+				if (err !== void 0) if (err instanceof require_errors.TerminalError) this.coreVm.propose_run_completion_failure(handle, {
+					code: err.code,
+					message: err.message
+				});
+				else if (err instanceof require_errors.RetryableError) {
+					const maxRetryDuration = options?.maxRetryDuration ?? options?.maxRetryDurationMillis;
+					this.coreVm.propose_run_completion_failure_transient_with_delay_override(handle, err.message, err.stack, BigInt(attemptDuration), err.retryAfter !== void 0 ? BigInt((0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(err.retryAfter)) : void 0, options?.maxRetryAttempts, maxRetryDuration !== void 0 ? BigInt((0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(maxRetryDuration)) : void 0);
+				} else {
+					this.vmLogger.warn(`Error when processing ctx.run '${name}'.\n`, err);
+					let retryPolicy;
+					if (options?.retryIntervalFactor !== void 0 || options?.maxRetryAttempts !== void 0 || options?.initialRetryInterval !== void 0 || options?.initialRetryIntervalMillis !== void 0 || options?.maxRetryDuration !== void 0 || options?.maxRetryDurationMillis !== void 0 || options?.maxRetryInterval !== void 0 || options?.maxRetryIntervalMillis !== void 0) {
+						const maxRetryDuration = options?.maxRetryDuration ?? options?.maxRetryDurationMillis;
+						retryPolicy = {
+							factor: options?.retryIntervalFactor ?? 2,
+							initial_interval: (0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(options?.initialRetryInterval ?? options?.initialRetryIntervalMillis ?? 50),
+							max_attempts: options?.maxRetryAttempts,
+							max_duration: maxRetryDuration === void 0 ? void 0 : (0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(maxRetryDuration),
+							max_interval: (0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(options?.maxRetryInterval ?? options?.maxRetryIntervalMillis ?? { seconds: 10 })
+						};
+					}
+					this.coreVm.propose_run_completion_failure_transient(handle, err.message, err.stack, BigInt(attemptDuration), retryPolicy);
+				}
+				else {
+					const serializedRes = serde$1.serialize(res);
+					const encodedRes = this.journalValueCodec.encode(serializedRes);
+					this.coreVm.propose_run_completion_success(handle, encodedRes);
+				}
+			} catch (e) {
+				this.handleInvocationEndError(e);
+				return require_promises.pendingPromise();
+			}
+			await this.outputPump.awaitNextProgress();
+		};
+		this.runClosuresTracker.registerRunClosure(handle, doRun);
+		return new require_promises.RestateSinglePromise(this, handle, completeCommandPromiseUsing(require_sdk_shared_core_wasm_bindings.WasmCommandType.Run, commandIndex, SuccessWithSerde(serde$1, this.journalValueCodec), Failure));
+	}
+	sleep(duration, name) {
+		return this.processCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.Sleep, () => {
+			if (duration === void 0) throw new Error(`Duration is undefined.`);
+			const millis = (0, __restatedev_restate_sdk_core.millisOrDurationToMillis)(duration);
+			if (millis < 0) throw new Error(`Invalid negative sleep duration: ${millis}ms.\nIf this duration is computed from a desired wake up time, make sure to record 'now' using 'wakeUpTime - ctx.date.now()'.`);
+			return BigInt(millis);
+		}, (vm, millis) => vm.sys_sleep(millis, name), VoidAsUndefined);
+	}
+	awakeable(serde$1) {
+		let awakeable;
+		try {
+			awakeable = this.coreVm.sys_awakeable();
+		} catch (e) {
+			this.handleInvocationEndError(e);
+			return {
+				id: "invalid",
+				promise: new require_promises.RestatePendingPromise(this)
+			};
+		}
+		return {
+			id: awakeable.id,
+			promise: new require_promises.RestateSinglePromise(this, awakeable.handle, completeSignalPromiseUsing(VoidAsUndefined, SuccessWithSerde(serde$1 ?? this.defaultSerde, this.journalValueCodec), Failure))
+		};
+	}
+	resolveAwakeable(id, payload, serde$1) {
+		this.processNonCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.CompleteAwakeable, () => {
+			let value;
+			if (serde$1) value = payload === void 0 ? new Uint8Array() : serde$1.serialize(payload);
+			else value = payload !== void 0 ? this.defaultSerde.serialize(payload) : this.defaultSerde.serialize(null);
+			return this.journalValueCodec.encode(value);
+		}, (vm, bytes) => vm.sys_complete_awakeable_success(id, bytes));
+	}
+	rejectAwakeable(id, reason) {
+		this.processNonCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.CompleteAwakeable, () => {}, (vm) => {
+			vm.sys_complete_awakeable_failure(id, {
+				code: require_errors.UNKNOWN_ERROR_CODE,
+				message: reason
+			});
+		});
+	}
+	promise(name, serde$1) {
+		return new DurablePromiseImpl(this, name, serde$1);
+	}
+	static createCombinator(combinatorConstructor, promises) {
+		const self = require_promises.extractContext(promises[0]);
+		if (!self) throw new Error("Not a combinable promise");
+		const castedPromises = [];
+		for (const promise of promises) {
+			if (require_promises.extractContext(promise) !== self) {
+				self.handleInvocationEndError(/* @__PURE__ */ new Error("You're mixing up RestatePromises from different RestateContext. This is not supported."));
+				return new require_promises.RestatePendingPromise(self);
+			}
+			castedPromises.push(promise);
+		}
+		return new require_promises.RestateCombinatorPromise(self, combinatorConstructor, castedPromises);
+	}
+	processNonCompletableEntry(commandType, prepare, vmCall) {
+		let input;
+		try {
+			input = prepare();
+		} catch (e) {
+			this.handleInvocationEndError(e, (vm, error) => vm.notify_error_for_next_command(error.message, error.stack, commandType));
+			return;
+		}
+		try {
+			vmCall(this.coreVm, input);
+		} catch (e) {
+			this.handleInvocationEndError(e);
+		}
+	}
+	processCompletableEntry(commandType, prepare, vmCall, ...completers) {
+		let input;
+		try {
+			input = prepare();
+		} catch (e) {
+			this.handleInvocationEndError(e, (vm, error) => vm.notify_error_for_next_command(error.message, error.stack, commandType));
+			return new require_promises.RestatePendingPromise(this);
+		}
+		let handle;
+		try {
+			handle = vmCall(this.coreVm, input);
+		} catch (e) {
+			this.handleInvocationEndError(e);
+			return new require_promises.RestatePendingPromise(this);
+		}
+		const commandIndex = this.coreVm.last_command_index();
+		return new require_promises.RestateSinglePromise(this, handle, completeCommandPromiseUsing(commandType, commandIndex, ...completers));
+	}
+	promiseExecutorErrorCallback(e) {
+		if (e instanceof AsyncCompleterError) {
+			const cause = require_errors.ensureError(e.cause);
+			require_errors.logError(this.vmLogger, e.cause);
+			this.coreVm.notify_error_for_specific_command(cause.message, cause.stack, e.commandType, e.commandIndex, null);
+		} else {
+			const error = require_errors.ensureError(e);
+			require_errors.logError(this.vmLogger, error);
+			if (!(error instanceof require_errors.RestateError)) this.coreVm.notify_error(error.message, error.stack);
+		}
+		this.invocationEndPromise.resolve();
+	}
+	handleInvocationEndError(e, notify_vm_error = (vm, error$1) => {
+		vm.notify_error(error$1.message, error$1.stack);
+	}) {
+		const error = require_errors.ensureError(e);
+		require_errors.logError(this.vmLogger, error);
+		notify_vm_error(this.coreVm, error);
+		this.invocationEndPromise.resolve();
+	}
+};
+function unpackRunParameters(a, b) {
+	if (typeof a === "string") {
+		if (typeof b !== "function") throw new TypeError("");
+		return {
+			name: a,
+			action: b
+		};
+	}
+	if (typeof a !== "function") throw new TypeError("unexpected type at the first parameter");
+	if (b) throw new TypeError("unexpected a function as a second parameter.");
+	return { action: a };
+}
+var DurablePromiseImpl = class {
+	serde;
+	constructor(ctx, name, serde$1) {
+		this.ctx = ctx;
+		this.name = name;
+		this.serde = serde$1 ?? this.ctx.defaultSerde;
+	}
+	then(onfulfilled, onrejected) {
+		return this.get().then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		return this.get().catch(onrejected);
+	}
+	finally(onfinally) {
+		return this.get().finally(onfinally);
+	}
+	[Symbol.toStringTag] = "DurablePromise";
+	get() {
+		return this.ctx.processCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.GetPromise, () => {}, (vm) => vm.sys_get_promise(this.name), SuccessWithSerde(this.serde, this.ctx.journalValueCodec), Failure);
+	}
+	peek() {
+		return this.ctx.processCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.PeekPromise, () => {}, (vm) => vm.sys_peek_promise(this.name), VoidAsUndefined, SuccessWithSerde(this.serde, this.ctx.journalValueCodec), Failure);
+	}
+	resolve(value) {
+		return this.ctx.processCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.CompletePromise, () => this.ctx.journalValueCodec.encode(this.serde.serialize(value)), (vm, bytes) => vm.sys_complete_promise_success(this.name, bytes), VoidAsUndefined, Failure);
+	}
+	reject(errorMsg) {
+		return this.ctx.processCompletableEntry(require_sdk_shared_core_wasm_bindings.WasmCommandType.CompletePromise, () => {}, (vm) => vm.sys_complete_promise_failure(this.name, {
+			code: require_errors.INTERNAL_ERROR_CODE,
+			message: errorMsg
+		}), VoidAsUndefined, Failure);
+	}
+};
+var RunClosuresTracker = class {
+	currentRunWaitPoint;
+	runsToExecute = /* @__PURE__ */ new Map();
+	executeRun(handle) {
+		const runClosure = this.runsToExecute.get(handle);
+		if (runClosure === void 0) throw new Error(`Handle ${handle} doesn't exist`);
+		runClosure().finally(() => {
+			this.unblockCurrentRunWaitPoint();
+		}).catch(() => {});
+	}
+	registerRunClosure(handle, runClosure) {
+		this.runsToExecute.set(handle, runClosure);
+	}
+	awaitNextCompletedRun() {
+		if (this.currentRunWaitPoint === void 0) this.currentRunWaitPoint = new require_completable_promise.CompletablePromise();
+		return this.currentRunWaitPoint.promise;
+	}
+	unblockCurrentRunWaitPoint() {
+		if (this.currentRunWaitPoint !== void 0) {
+			const p = this.currentRunWaitPoint;
+			this.currentRunWaitPoint = void 0;
+			p.resolve();
+		}
+	}
+};
+var AsyncCompleterError = class {
+	constructor(cause, commandType, commandIndex) {
+		this.cause = cause;
+		this.commandType = commandType;
+		this.commandIndex = commandIndex;
+	}
+};
+function completeCommandPromiseUsing(commandType, commandIndex, ...completers) {
+	return async (value, prom) => {
+		try {
+			for (const completer of completers) if (await completer(value, prom)) return;
+		} catch (e) {
+			throw new AsyncCompleterError(e, commandType, commandIndex);
+		}
+		throw new Error(`Unexpected variant in async result: ${JSON.stringify(value)}`);
+	};
+}
+function completeSignalPromiseUsing(...completers) {
+	return async (value, prom) => {
+		for (const completer of completers) if (await completer(value, prom)) return;
+		throw new Error(`Unexpected variant in async result: ${JSON.stringify(value)}`);
+	};
+}
+const VoidAsNull = (value, prom) => {
+	if (value === "Empty") {
+		prom.resolve(null);
+		return Promise.resolve(true);
+	}
+	return Promise.resolve(false);
+};
+const VoidAsUndefined = (value, prom) => {
+	if (value === "Empty") {
+		prom.resolve(void 0);
+		return Promise.resolve(true);
+	}
+	return Promise.resolve(false);
+};
+function SuccessWithSerde(serde$1, journalCodec, transform) {
+	return async (value, prom) => {
+		if (typeof value !== "object" || !("Success" in value)) return false;
+		let buffer;
+		if (journalCodec !== void 0) buffer = await journalCodec.decode(value.Success);
+		else buffer = value.Success;
+		let val = serde$1.deserialize(buffer);
+		if (transform) val = transform(val);
+		prom.resolve(val);
+		return true;
+	};
+}
+const Failure = (value, prom) => {
+	if (typeof value === "object" && "Failure" in value) {
+		prom.reject(new require_errors.TerminalError(value.Failure.message, { errorCode: value.Failure.code }));
+		return Promise.resolve(true);
+	}
+	return Promise.resolve(false);
+};
+const StateKeys = (value, prom) => {
+	if (typeof value === "object" && "StateKeys" in value) {
+		prom.resolve(value.StateKeys);
+		return Promise.resolve(true);
+	}
+	return Promise.resolve(false);
+};
+const InvocationIdCompleter = (value, prom) => {
+	if (typeof value === "object" && "InvocationId" in value) {
+		prom.resolve(value.InvocationId);
+		return Promise.resolve(true);
+	}
+	return Promise.resolve(false);
+};
+
+//#endregion
+exports.ContextImpl = ContextImpl;