Introduce the invoke function to resonate and the context.

lib/core/errors.ts

@@ -20,6 +20,9 @@ export enum ErrorCodes {
   STORE_ALREADY_EXISTS = 45,
   STORE_INVALID_STATE = 46,
   STORE_ENCODER = 47,
+
+  // error in user function
+  USER = 60,
 }
 
 export class ResonateError extends Error {

lib/core/options.ts

@@ -133,6 +133,13 @@ export type Options = {
 
 export type PartialOptions = Partial<Options> & { __resonate: true };
 
+/**
+ * A subset of configuration options for overriding when invocating a top level function.
+ */
+export type InvocationOverrides = Partial<
+  Pick<Options, "eidFn" | "idempotencyKeyFn" | "retryPolicy" | "tags" | "timeout" | "version">
+> & { __resonate: true };
+
 export function isOptions(o: unknown): o is PartialOptions {
   return typeof o === "object" && o !== null && (o as PartialOptions).__resonate === true;
 }

lib/core/promises/promises.ts

@@ -201,7 +201,7 @@ export class DurablePromise<T> {
     id: string,
     timeout: number,
     opts: Partial<CreateOptions> = {},
-  ) {
+  ): Promise<DurablePromise<T>> {
     const storedPromise = await store.create(
       id,
       opts.idempotencyKey,

lib/core/retry.ts

@@ -127,6 +127,29 @@ export function retryIterator<T extends { retryPolicy: RetryPolicy; attempt: num
   };
 }
 
+export async function runWithRetry<T>(func: () => Promise<T>, retryPolicy: RetryPolicy, timeout: number) {
+  let error;
+
+  const ctx = { attempt: 0, retryPolicy, timeout };
+
+  // invoke the function according to the retry policy
+  for (const delay of retryIterator(ctx)) {
+    await new Promise((resolve) => setTimeout(resolve, delay));
+
+    try {
+      return await func();
+    } catch (e) {
+      error = e;
+
+      // bump the attempt count
+      ctx.attempt++;
+    }
+  }
+
+  // if all attempts fail throw the last error
+  throw error;
+}
+
 function retryDefaults(retryPolicy: RetryPolicy): {
   initialDelay: number;
   backoffFactor: number;

lib/core/utils.ts

@@ -52,3 +52,32 @@ export function mergeObjects<T extends object, U extends object>(obj1: T, obj2:
     return acc;
   }, {} as any);
 }
+
+/**
+ * Creates a promise that resolves after a specified delay.
+ *
+ * @param ms - The delay in milliseconds.
+ * @returns A promise that resolves after the specified delay.
+ *
+ * @example
+ * // Basic usage
+ * await sleep(1000); // Pauses execution for 1 second
+ *
+ * @example
+ * // Using in an async function
+ * async function example() {
+ *   console.log('Start');
+ *   await sleep(2000);
+ *   console.log('2 seconds later');
+ * }
+ *
+ * @example
+ * // Using with .then()
+ * sleep(3000).then(() => console.log('3 seconds have passed'));
+ */
+export async function sleep(ms: number): Promise<void> {
+  if (ms < 0) {
+    throw new Error("ms should be a positive integer");
+  }
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

lib/index.ts

@@ -4,6 +4,9 @@ export * from "./resonate";
 // async
 export * from "./async";
 
+// invok
+export * as invok from "./resonate_invok";
+
 // errors
 export * from "./core/errors";