yieldstar 0.4.6 → 0.6.0

package/dist/index.js

@@ -1,57 +1,83 @@
-// @bun
 // src/exports/sdk-local.ts
-import { nanoid } from "nanoid";
-function createLocalSdk(invoker) {
+import {
+  ExecutionAdmissionError,
+  waitForExecutionOutcome
+} from "@yieldstar/core";
+function createLocalSdk(runtime, options) {
+  const { executions } = runtime;
   return {
     async trigger(event) {
-      const executionEvent = {
-        executionId: event.executionId ?? nanoid(),
+      const admission = await executions.admit({
+        executionId: event.executionId,
         workflowId: event.workflowId,
-        params: event.params
-      };
-      await invoker.execute(executionEvent);
-      return { executionId: executionEvent.executionId };
+        params: event.params,
+        context: new Map(Object.entries(event.context ?? {}))
+      });
+      if (admission.status === "rejected") {
+        throw new ExecutionAdmissionError(admission.code, admission.message);
+      }
+      return { executionId: admission.executionId };
     },
     async triggerAndWait(event) {
-      const executionId = event.executionId ?? nanoid();
-      const workflowCompletePromise = new Promise((resolve) => {
-        invoker.workflowEndEmitter.once(executionId, resolve);
+      const { executionId } = await this.trigger(event);
+      const outcome = await waitForExecutionOutcome(executions, executionId, {
+        emitter: options?.invoker?.workflowEndEmitter,
+        pollInterval: options?.pollInterval
       });
-      await this.trigger({ ...event, executionId });
-      return workflowCompletePromise;
+      if (!outcome) {
+        throw new Error(`Execution "${executionId}" has no record`);
+      }
+      if (outcome.status === "failed")
+        throw outcome.error;
+      return outcome.result;
     }
   };
 }
 // src/exports/sdk-http.ts
-import { nanoid as nanoid2 } from "nanoid";
-import { deserializeError } from "serialize-error";
-import { errorWithOriginalStack } from "@yieldstar/core";
+import {
+  ExecutionAdmissionError as ExecutionAdmissionError2,
+  durableValueCodec
+} from "@yieldstar/core";
+var admissionErrorCodes = [
+  "EXECUTION_ID_CONFLICT",
+  "INVALID_EXECUTION_EVENT"
+];
 function createHttpSdkFactory() {
   return (params) => {
     return {
       async trigger(event) {
-        const executionEvent = {
-          executionId: event?.executionId ?? nanoid2(),
-          workflowId: event?.workflowId,
-          params: event?.params,
-          context: event?.context
-        };
+        const request = { workflowId: event?.workflowId };
+        if (event?.executionId !== undefined)
+          request.executionId = event.executionId;
+        if (event && "params" in event)
+          request.params = event.params;
+        if (event?.context !== undefined)
+          request.context = event.context;
+        const encoding = durableValueCodec.encode(request);
+        if (encoding.status === "invalid") {
+          throw new ExecutionAdmissionError2("INVALID_EXECUTION_EVENT", `Event cannot be stored without loss: ${encoding.message}`);
+        }
         const res = await fetch(`${params.url}/trigger`, {
           ...params.fetchOptions,
           method: "POST",
-          body: JSON.stringify(executionEvent)
+          headers: { "content-type": "application/json" },
+          body: encoding.canonical
         });
         if (res.ok) {
+          const ack = await res.json();
           return {
-            executionId: executionEvent.executionId,
-            ack: () => res.json(),
-            waitForResult: () => this.waitForResult({
-              executionId: executionEvent.executionId
-            })
+            executionId: ack.executionId,
+            ack: async () => ack,
+            waitForResult: () => this.waitForResult(ack)
           };
-        } else {
-          throw res.statusText;
         }
+        const body = await res.json().catch(() => {
+          return;
+        });
+        if (body?.code && admissionErrorCodes.includes(body.code)) {
+          throw new ExecutionAdmissionError2(body.code, body.message ?? res.statusText);
+        }
+        throw res.statusText;
       },
       async waitForResult(ack) {
         const res = await fetch(`${params.url}/events`, {
@@ -59,11 +85,18 @@ function createHttpSdkFactory() {
           body: JSON.stringify({ executionId: ack.executionId }),
           ...params.fetchOptions
         });
+        if (res.status !== 500 && !res.ok) {
+          throw res.statusText;
+        }
+        const decoding = durableValueCodec.decode(await res.text());
+        if (decoding.status === "invalid") {
+          throw new Error(`Invalid workflow outcome: ${decoding.message}`);
+        }
         if (res.status === 500) {
-          const error = await res.json();
-          throw errorWithOriginalStack(deserializeError(error), this.waitForResult);
+          const error = decoding.value instanceof Error ? decoding.value : new Error(String(decoding.value));
+          throw error;
         }
-        return res.json();
+        return decoding.value;
       }
     };
   };
@@ -73,6 +106,8 @@ function createWorkflowRouter(workflows) {
   return workflows;
 }
 // src/exports/errors.ts
+import { registerErrorClass } from "@yieldstar/core";
+
 class RetryableError extends Error {
   maxAttempts;
   retryInterval;
@@ -83,129 +118,537 @@ class RetryableError extends Error {
     this.retryInterval = opts.retryInterval;
   }
 }
+registerErrorClass("RetryableError", RetryableError);
+
+// src/index.ts
+import {
+  EffectClientInvariantError as EffectClientInvariantError2,
+  EffectDeliveryError as EffectDeliveryError2,
+  ExecutionAdmissionError as ExecutionAdmissionError3,
+  WORKFLOW_RESULT_STEP_KEY as WORKFLOW_RESULT_STEP_KEY2,
+  WorkflowEffectError as WorkflowEffectError2,
+  WorkflowStartError as WorkflowStartError2,
+  WorkflowValueError as WorkflowValueError4,
+  registerErrorClass as registerErrorClass2
+} from "@yieldstar/core";
+
 // src/internal/utils.ts
 import { createHash } from "crypto";
 var isIterable = (i) => {
   return typeof i === "object" && i != null && Symbol.iterator in i;
 };
 function getCallSiteHash(stepFn) {
-  const originalStack = stepFn.stack;
-  Error.captureStackTrace(stepFn, getCallSiteHash);
-  const stack = stepFn.stack;
-  const stepFnCallSite = stack.split(")")[1];
-  if (originalStack === undefined) {
-    delete stepFn.stack;
-  } else {
-    stepFn.stack = originalStack;
+  const holder = {};
+  Error.captureStackTrace(holder, stepFn);
+  const frames = (holder.stack ?? "").split(`
+`).filter((line) => /^\s*at\s/.test(line));
+  const callSite = frames[0]?.trim();
+  if (!callSite) {
+    throw new Error("Could not derive a cache key from the call site. Pass an explicit key to this step.");
   }
-  return createHash("sha1").update(stepFnCallSite).digest("hex");
+  return createHash("sha1").update(callSite).digest("hex");
 }
 
-// src/internal/serialise.ts
+// src/internal/step-record.ts
 import {
+  DurableValueError,
   StepDelay,
+  StepEffectWait,
   StepError,
+  StepInvalid,
   StepResult,
-  WorkflowResult
+  StepStoreWait,
+  WorkflowResult,
+  WorkflowValueError,
+  decodeParsedValue,
+  durableValueCodec as durableValueCodec2,
+  encodeThrownValue
 } from "@yieldstar/core";
-import { isErrorLike, serializeError, deserializeError as deserializeError2 } from "serialize-error";
-function serializeStepResponse(data) {
-  const replaceErrors = (key, value) => {
-    if (value instanceof Error) {
-      return serializeError(value);
+function encodeStepRecord(response, stepKey) {
+  const json = encodeResponse(response, stepKey);
+  return { json, response: decodeStepRecord(json) };
+}
+function encodeResponse(response, stepKey) {
+  if (response instanceof StepResult || response instanceof WorkflowResult) {
+    const result = durableValueCodec2.encode(response.result);
+    if (result.status === "invalid") {
+      const label = response instanceof WorkflowResult ? "Workflow result" : `Step "${stepKey}" result`;
+      return encodeResponse(new StepError(new WorkflowValueError("INVALID_STEP_VALUE", stepKey, `${label} is not a durable value: ${result.message}`)), stepKey);
     }
-    return value;
-  };
-  return JSON.stringify(data, replaceErrors);
+    const schema = response instanceof StepResult && response.schema !== undefined ? `,"schema":${JSON.stringify(response.schema)}` : "";
+    return `{"result":${result.canonical}${schema},"type":${JSON.stringify(response.type)}}`;
+  }
+  if (response instanceof StepError) {
+    return `{"backOffStrategy":${JSON.stringify(response.backOffStrategy)}` + `,"err":${encodeThrownValue(response.err)}` + `,"maxAttempts":${JSON.stringify(response.maxAttempts)}` + `,"retryInterval":${JSON.stringify(response.retryInterval)}` + `,"type":"step-error"}`;
+  }
+  if (response instanceof StepDelay) {
+    return `{"type":"step-delay","wakeAt":${JSON.stringify(response.wakeAt)}}`;
+  }
+  if (response instanceof StepEffectWait) {
+    return `{"type":"effect-wait","wakeAt":${JSON.stringify(response.wakeAt)}}`;
+  }
+  if (response instanceof StepStoreWait || response instanceof StepInvalid) {
+    return `{"type":${JSON.stringify(response.type)}}`;
+  }
+  throw new Error(`Cannot record a ${response.type} step response`);
 }
-function deserializeStepResponse(jsonString) {
-  const reviveErrors = (key, value) => {
-    if (isErrorLike(value)) {
-      return deserializeError2(value);
+function decodeStepRecord(json) {
+  const record = JSON.parse(json);
+  try {
+    switch (record.type) {
+      case "step-result":
+        return new StepResult(decodeParsedValue(record.result, "result"), record.schema === "accepted" || record.schema === "rejected" ? record.schema : undefined);
+      case "workflow-result":
+        return new WorkflowResult(decodeParsedValue(record.result, "result"));
+      case "step-error":
+        return new StepError(decodeParsedValue(record.err, "err"), {
+          maxAttempts: record.maxAttempts,
+          retryInterval: record.retryInterval,
+          backoffStrategy: record.backOffStrategy
+        });
+      case "step-delay":
+        return new StepDelay(record.wakeAt);
+      case "effect-wait":
+        return new StepEffectWait(record.wakeAt);
+      case "store-wait":
+        return new StepStoreWait;
+      case "step-invalid":
+        return new StepInvalid;
     }
-    return value;
-  };
-  const stepResponse = JSON.parse(jsonString, reviveErrors);
-  switch (stepResponse.type) {
-    case "step-error":
-      const { err, ...params } = stepResponse;
-      return new StepError(stepResponse.err, params);
-    case "step-delay":
-      return new StepDelay(stepResponse.resumeIn);
-    case "step-result":
-      return new StepResult(stepResponse.result);
-    case "workflow-result":
-      return new WorkflowResult(stepResponse.result);
-    default:
-      throw new Error("Unknown step result type: " + stepResponse.type);
+  } catch (err) {
+    if (err instanceof DurableValueError) {
+      throw new Error(`Invalid step record: ${err.message}`);
+    }
+    throw err;
   }
+  throw new Error(`Unknown step record type: ${record.type}`);
 }
 
 // src/internal/step-runner.ts
 import {
+  assertSynchronousClaim,
+  assertSynchronousUpdater,
+  cloneStoreState,
+  defineStore,
+  InfrastructureError as InfrastructureError3,
   StepKey,
   StepError as StepError2,
   StepResult as StepResult2,
   StepDelay as StepDelay2,
-  StepCacheCheck
+  StepCacheCheck,
+  StepStoreWait as StepStoreWait2,
+  trackStoreSelector,
+  durableValueCodec as durableValueCodec4,
+  StepEffectWait as StepEffectWait2,
+  validateEffectRequest,
+  WorkflowEffectError,
+  WorkflowStartError,
+  WorkflowValueError as WorkflowValueError3
 } from "@yieldstar/core";
-var stepRunner = { run, delay, poll };
-async function* run(arg1, arg2) {
-  let key = null;
-  let fn;
-  if (typeof arg1 === "string") {
-    key = arg1;
-    fn = arg2;
-  } else {
-    fn = arg1;
+
+// src/internal/runtime-call.ts
+import {
+  InfrastructureError,
+  StepResponse as StepResponse2,
+  StoreValidationError,
+  WorkflowValueError as WorkflowValueError2
+} from "@yieldstar/core";
+
+class StepRuntimeCall extends StepResponse2 {
+  static type = "runtime-call";
+  type = "runtime-call";
+  call;
+  constructor(call) {
+    super();
+    this.call = call;
   }
-  if (!key)
-    key = getCallSiteHash(run);
-  yield new StepKey(key);
-  const cached = yield new StepCacheCheck;
-  if (cached) {
-    yield cached;
-    if (cached instanceof StepError2) {
-      throw cached.err;
+}
+
+class StepCallbackError extends Error {
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.name = "StepCallbackError";
+  }
+}
+function workflowCallback(fn, assertResult) {
+  return (...args) => {
+    try {
+      const result = fn(...args);
+      assertResult?.(result);
+      return result;
+    } catch (err) {
+      throw new StepCallbackError(err);
     }
-    return cached.result;
+  };
+}
+async function executeRuntimeCall(request, clients) {
+  try {
+    return { ok: true, value: await request.call(clients) };
+  } catch (err) {
+    if (InfrastructureError.is(err))
+      throw err;
+    if (err instanceof StepCallbackError)
+      return { ok: false, error: err.cause };
+    if (isWorkflowFacingError(err))
+      return { ok: false, error: err };
+    throw new InfrastructureError(err);
   }
+}
+function isWorkflowFacingError(err) {
+  return err instanceof StoreValidationError || err instanceof WorkflowValueError2 || err instanceof Error && err.name === "StoreValidationError";
+}
+async function infrastructure(fn) {
   try {
-    const result = await fn();
-    yield new StepResult2(result);
-    return result;
+    return await fn();
   } catch (err) {
-    if (err instanceof RetryableError) {
-      yield new StepError2(err, {
-        maxAttempts: err.maxAttempts,
-        retryInterval: err.retryInterval
-      });
-    } else {
+    throw InfrastructureError.is(err) ? err : new InfrastructureError(err);
+  }
+}
+
+// src/internal/effect-call.ts
+import {
+  EffectClientInvariantError,
+  EffectDeliveryError,
+  InfrastructureError as InfrastructureError2,
+  StepResponse as StepResponse3,
+  durableValueCodec as durableValueCodec3
+} from "@yieldstar/core";
+
+class StepEffectCall extends StepResponse3 {
+  static type = "effect-call";
+  type = "effect-call";
+  request;
+  constructor(request) {
+    super();
+    this.request = request;
+  }
+}
+async function executeEffectCall(request, context) {
+  const { effects, executionId, clock, assertLease, logger } = context;
+  const { stepKey, effectId, operation, input, retryIn } = request;
+  const fail = (code, message, cause) => new InfrastructureError2(new EffectDeliveryError(code, { effectId, stepKey, message }, cause === undefined ? undefined : { cause }));
+  async function client(method, call) {
+    try {
+      return await call();
+    } catch (err) {
+      const message = `EffectClient.${method} failed for effect "${effectId}": ${errorMessage(err)}`;
+      if (isInvariantError(err))
+        throw fail("EFFECT_RUNTIME_INVARIANT", message, err);
+      throw fail("EFFECT_CLIENT_UNAVAILABLE", message, err);
+    }
+  }
+  const malformedClient = (method) => fail("EFFECT_RUNTIME_INVARIANT", `EffectClient.${method} returned a malformed response for effect "${effectId}"`);
+  async function suspend() {
+    await client("watch", () => effects.watch({ effectId, executionId, stepKey }));
+    return { status: "suspended", wakeAt: clock() + retryIn };
+  }
+  async function settle(result) {
+    const encoding = durableValueCodec3.encode(result);
+    if (encoding.status === "invalid") {
+      throw fail("EFFECT_HANDLER_INVALID", `Effect "${effectId}" result is not a durable value: ${encoding.message}`);
+    }
+    const settled = await client("settle", () => effects.settle({ operation, effectId, result }));
+    if (!isObject(settled) || !("result" in settled))
+      throw malformedClient("settle");
+    if (settled.status === "conflict") {
+      logger.warn({
+        executionId,
+        stepKey,
+        effectId,
+        result: settled.result,
+        conflictingResult: settled.conflictingResult
+      }, `Effect "${effectId}" settled with a different result; the first result stands`);
+    } else if (settled.status !== "settled") {
+      throw malformedClient("settle");
+    }
+    return { status: "settled", result: settled.result };
+  }
+  const begun = await client("begin", () => effects.begin({ operation, effectId, input, executionId, stepKey }));
+  if (!isObject(begun))
+    throw malformedClient("begin");
+  let next;
+  switch (begun.status) {
+    case "settled":
+      if (!("result" in begun))
+        throw malformedClient("begin");
+      return { status: "settled", result: begun.result };
+    case "rejected":
+      if (begun.code !== "EFFECT_REQUEST_MISMATCH")
+        throw malformedClient("begin");
+      return { status: "rejected", code: begun.code };
+    case "new":
+      next = "perform";
+      break;
+    case "pending":
+      next = "lookup";
+      break;
+    default:
+      throw malformedClient("begin");
+  }
+  if (next === "lookup") {
+    assertLease();
+    let found;
+    try {
+      found = await request.lookup(effectId);
+    } catch {
+      return suspend();
+    }
+    if (!isObject(found))
+      throw malformedLookup(fail, effectId);
+    switch (found.status) {
+      case "settled":
+        if (!("result" in found))
+          throw malformedLookup(fail, effectId);
+        return settle(found.result);
+      case "unknown":
+        return suspend();
+      case "not-found":
+        break;
+      default:
+        throw malformedLookup(fail, effectId);
+    }
+  }
+  assertLease();
+  let performed;
+  try {
+    performed = await request.perform(effectId);
+  } catch {
+    return suspend();
+  }
+  return settle(performed);
+}
+function malformedLookup(fail, effectId) {
+  return fail("EFFECT_HANDLER_INVALID", `lookup for effect "${effectId}" returned a malformed response: expected { status: "settled", result }, { status: "not-found" } or { status: "unknown" }`);
+}
+function isInvariantError(err) {
+  return err instanceof EffectClientInvariantError || typeof err === "object" && err !== null && err.code === "EFFECT_RUNTIME_INVARIANT";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/internal/step-runner.ts
+function createStepRunner(params) {
+  const { event, clock } = params;
+  function store(definition, params) {
+    return createWorkflowStore({
+      definition,
+      id: params?.id ?? event.executionId,
+      event
+    });
+  }
+  function start(stepKey, target) {
+    if (stepKey === "") {
+      throw new Error("step.start requires a non-empty step key");
+    }
+    const request = {
+      requestId: { executionId: event.executionId, stepKey },
+      workflowId: target.workflowId
+    };
+    if (target.params !== undefined) {
+      request.params = target.params;
+    }
+    return startStep(stepKey, request);
+  }
+  function effect(stepKey, descriptor) {
+    if (typeof stepKey !== "string" || stepKey === "") {
+      throw new Error("step.effect requires a non-empty step key");
+    }
+    return effectStep(stepKey, descriptor);
+  }
+  return { run, delay: createDelay(clock), poll, store, start, effect };
+}
+async function* effectStep(key, descriptor) {
+  yield new StepKey(key);
+  const cached = yield new StepCacheCheck;
+  if (cached)
+    return yield* replay(cached);
+  const { effectId, operation, input, retryIn, lookup, perform } = descriptor ?? {};
+  const invalid = invalidEffectRequest({
+    effectId,
+    operation,
+    input,
+    retryIn,
+    lookup,
+    perform
+  });
+  if (invalid) {
+    const err = new WorkflowEffectError("INVALID_EFFECT_REQUEST", `step.effect "${key}": ${invalid}`);
+    yield new StepError2(err);
+    throw err;
+  }
+  const outcome = yield new StepEffectCall({
+    stepKey: key,
+    effectId,
+    operation,
+    input,
+    retryIn,
+    lookup: (id) => lookup.call(descriptor, id),
+    perform: (id) => perform.call(descriptor, id)
+  });
+  switch (outcome.status) {
+    case "settled":
+      return yield* record(outcome.result);
+    case "rejected": {
+      const err = new WorkflowEffectError(outcome.code, `Effect "${effectId}" was begun with a different operation or input`);
       yield new StepError2(err);
+      throw err;
     }
+    case "suspended":
+      yield new StepEffectWait2(outcome.wakeAt);
+      throw new Error("Effect wait yielded control unexpectedly");
+  }
+}
+function invalidEffectRequest(request) {
+  const validated = validateEffectRequest(request);
+  if (!validated.ok)
+    return validated.message;
+  const { retryIn } = request;
+  if (typeof retryIn !== "number" || !Number.isFinite(retryIn) || retryIn < 0) {
+    return "retryIn must be a finite, non-negative number";
+  }
+  if (typeof request.lookup !== "function")
+    return "lookup must be a function";
+  if (typeof request.perform !== "function")
+    return "perform must be a function";
+  return;
+}
+async function* startStep(key, request) {
+  yield new StepKey(key);
+  const cached = yield new StepCacheCheck;
+  if (cached)
+    return yield* replay(cached);
+  const started = yield new StepRuntimeCall(async ({ executions }) => {
+    try {
+      return await executions.start(request);
+    } catch (err) {
+      throw InfrastructureError3.is(err) ? err : new InfrastructureError3(err);
+    }
+  });
+  if (!started.ok) {
+    throw new Error("ExecutionClient.start failed without an infrastructure error");
+  }
+  const outcome = started.value;
+  if (outcome.status === "rejected") {
+    const err = new WorkflowStartError(outcome.code, outcome.message);
+    yield new StepError2(err);
     throw err;
   }
+  return yield* record({ executionId: outcome.executionId });
 }
-async function* delay(arg1, arg2) {
+function createWorkflowStore(params) {
+  const { id, event } = params;
+  const key = { storeName: params.definition.name, storeId: id };
+  const definition = {
+    ...params.definition,
+    initial: workflowCallback(params.definition.initial)
+  };
+  return {
+    definition: params.definition,
+    id,
+    key,
+    get(stepKey) {
+      return runtimeStep(stepKey ?? getCallSiteHash(this.get), async ({ stores }) => await stores.getStore({ definition, id }));
+    },
+    select(stepKey, selector) {
+      return runtimeStep(stepKey, async ({ stores }) => {
+        const snapshot = await stores.getStore({ definition, id });
+        return workflowCallback(selector)(cloneStoreState(snapshot.state));
+      });
+    },
+    update(stepKey, updater) {
+      return runtimeStep(stepKey, async ({ stores }) => await stores.updateStore({
+        definition,
+        id,
+        updater: workflowCallback(updater, assertSynchronousUpdater),
+        stepId: { executionId: event.executionId, stepKey }
+      }));
+    },
+    updateFrom(stepKey, snapshot, updater) {
+      return runtimeStep(stepKey, async ({ stores }) => await stores.updateStoreFrom({
+        definition,
+        id,
+        snapshot,
+        updater: workflowCallback(updater, assertSynchronousUpdater),
+        stepId: { executionId: event.executionId, stepKey }
+      }));
+    },
+    deleteFrom(stepKey, snapshot) {
+      return runtimeStep(stepKey, ({ stores }) => stores.deleteStoreFrom({
+        definition,
+        id,
+        snapshot,
+        stepId: { executionId: event.executionId, stepKey }
+      }));
+    },
+    when(arg1, arg2) {
+      const stepKey = typeof arg1 === "string" ? arg1 : getCallSiteHash(this.when);
+      const selector = typeof arg1 === "string" ? arg2 : arg1;
+      return whenStep({
+        definition,
+        id,
+        event,
+        stepKey,
+        selector
+      });
+    },
+    take(stepKey, selector, claim) {
+      return takeStep({
+        definition,
+        id,
+        event,
+        stepKey,
+        selector,
+        claim
+      });
+    }
+  };
+}
+function run(arg1, arg2, arg3) {
   let key = null;
-  let retryInterval;
+  let fn;
+  let options;
   if (typeof arg1 === "string") {
     key = arg1;
-    retryInterval = arg2;
+    fn = arg2;
+    options = arg3;
   } else {
-    retryInterval = arg1;
+    fn = arg1;
+    options = arg2;
   }
   if (!key)
-    key = getCallSiteHash(delay);
+    key = getCallSiteHash(run);
+  return durableStep(key, fn, options?.schema);
+}
+function createDelay(clock) {
+  function delay(arg1, arg2) {
+    let key = null;
+    let retryInterval;
+    if (typeof arg1 === "string") {
+      key = arg1;
+      retryInterval = arg2;
+    } else {
+      retryInterval = arg1;
+    }
+    if (!key)
+      key = getCallSiteHash(delay);
+    return delayStep(key, retryInterval, clock);
+  }
+  return delay;
+}
+async function* delayStep(key, retryInterval, clock) {
   yield new StepKey(key);
   const cached = yield new StepCacheCheck;
   if (cached) {
-    yield new StepDelay2(cached.resumeIn);
+    yield new StepDelay2(cached.wakeAt);
   } else {
-    yield new StepDelay2(Date.now() + retryInterval);
+    yield new StepDelay2(clock() + retryInterval);
   }
 }
-async function* poll(arg1, arg2, arg3) {
+function poll(arg1, arg2, arg3) {
   let key = null;
   let opts;
   let predicate;
@@ -227,26 +670,185 @@ async function* poll(arg1, arg2, arg3) {
       });
     }
   };
-  yield* run(key, task);
+  return run(key, task);
+}
+async function* durableStep(key, fn, schema) {
+  yield new StepKey(key);
+  const cached = yield new StepCacheCheck;
+  if (cached) {
+    const value = yield* replay(cached);
+    if (!schema)
+      return value;
+    const validated = await validateStepValue(key, schema, value);
+    if (cached.schema === "rejected" && validated.ok) {
+      throw new WorkflowValueError3("STEP_SCHEMA_INVALID", key, `Step "${key}" schema rejected its value on the first run`);
+    }
+    return unwrapValidated(validated);
+  }
+  let result;
+  try {
+    result = await fn();
+  } catch (err) {
+    if (err instanceof RetryableError) {
+      yield new StepError2(err, {
+        maxAttempts: err.maxAttempts,
+        retryInterval: err.retryInterval
+      });
+    } else {
+      yield new StepError2(err);
+    }
+    throw err;
+  }
+  if (!schema)
+    return yield* record(result);
+  const encoding = durableValueCodec4.encode(result);
+  if (encoding.status === "invalid")
+    return yield* record(result);
+  const decoding = durableValueCodec4.decode(encoding.canonical);
+  if (decoding.status === "invalid")
+    throw new Error(decoding.message);
+  const validated = await validateStepValue(key, schema, decoding.value);
+  yield* record(result, validated.ok ? "accepted" : "rejected");
+  return unwrapValidated(validated);
+}
+async function validateStepValue(key, schema, value) {
+  const result = await schema["~standard"].validate(value);
+  if (result.issues) {
+    const messages = result.issues.map((issue) => issue.message).join("; ");
+    return {
+      ok: false,
+      error: new WorkflowValueError3("STEP_SCHEMA_INVALID", key, `Step "${key}" value failed its schema: ${messages}`)
+    };
+  }
+  return { ok: true, value: result.value };
+}
+function unwrapValidated(validated) {
+  if (!validated.ok)
+    throw validated.error;
+  return validated.value;
+}
+async function* record(result, schema) {
+  const recorded = yield new StepResult2(result, schema);
+  return recorded.result;
+}
+async function* replay(cached) {
+  const recorded = yield cached;
+  return recorded.result;
+}
+async function* fail(key, error) {
+  const err = error instanceof WorkflowValueError3 && error.stepKey !== key ? new WorkflowValueError3(error.code, key, error.message) : error;
+  yield new StepError2(err);
+  throw err;
+}
+async function* runtimeStep(key, call) {
+  yield new StepKey(key);
+  const cached = yield new StepCacheCheck;
+  if (cached)
+    return yield* replay(cached);
+  const outcome = yield new StepRuntimeCall(call);
+  if (!outcome.ok)
+    return yield* fail(key, outcome.error);
+  return yield* record(outcome.value);
+}
+async function* whenStep(params) {
+  const { definition, id, event, stepKey, selector } = params;
+  yield new StepKey(stepKey);
+  const cached = yield new StepCacheCheck;
+  if (cached)
+    return yield* replay(cached);
+  const read = yield new StepRuntimeCall(({ stores }) => stores.getStore({ definition, id }));
+  if (!read.ok)
+    return yield* fail(stepKey, read.error);
+  const snapshot = read.value;
+  const { result, readPaths } = trackStoreSelector(cloneStoreState(snapshot.state), selector);
+  if (result !== undefined && result !== null && result !== false) {
+    return yield* record(result);
+  }
+  yield* registerWaiter({
+    workflowId: event.workflowId,
+    executionId: event.executionId,
+    stepKey,
+    storeName: definition.name,
+    storeId: id,
+    instanceId: snapshot.instanceId,
+    sinceVersion: snapshot.version,
+    readPaths
+  });
+  throw new Error("Store wait yielded control unexpectedly");
+}
+async function* takeStep(params) {
+  const { definition, id, event, stepKey, selector, claim } = params;
+  yield new StepKey(stepKey);
+  const cached = yield new StepCacheCheck;
+  if (cached)
+    return yield* replay(cached);
+  const taken = yield new StepRuntimeCall(({ stores }) => stores.takeFromStore({
+    definition,
+    id,
+    selector: workflowCallback(selector),
+    claim: workflowCallback(claim, assertSynchronousClaim),
+    stepId: { executionId: event.executionId, stepKey }
+  }));
+  if (!taken.ok)
+    return yield* fail(stepKey, taken.error);
+  const outcome = taken.value;
+  if (outcome.matched)
+    return yield* record(outcome.selected);
+  yield* registerWaiter({
+    workflowId: event.workflowId,
+    executionId: event.executionId,
+    stepKey,
+    storeName: definition.name,
+    storeId: id,
+    instanceId: outcome.instanceId,
+    sinceVersion: outcome.version,
+    readPaths: outcome.readPaths
+  });
+  throw new Error("Store take yielded control unexpectedly");
+}
+async function* registerWaiter(waiter) {
+  const registered = yield new StepRuntimeCall(({ stores }) => stores.registerWaiter(waiter));
+  if (!registered.ok)
+    return yield* fail(waiter.stepKey, registered.error);
+  yield new StepStoreWait2;
 }
 
 // src/exports/workflow.ts
 import {
-  StepResponse as StepResponse3,
+  StepResponse as StepResponse5,
   StepKey as StepKey2,
   StepError as StepError3,
   StepResult as StepResult3,
   StepDelay as StepDelay3,
   StepCacheCheck as StepCacheCheck2,
-  StepInvalid,
-  WorkflowResult as WorkflowResult2
+  StepEffectWait as StepEffectWait3,
+  StepInvalid as StepInvalid2,
+  StepStoreWait as StepStoreWait3,
+  WorkflowResult as WorkflowResult2,
+  InfrastructureError as InfrastructureError4,
+  LeaseLostError,
+  StepConflictError,
+  isLeaseLost,
+  WORKFLOW_RESULT_STEP_KEY
 } from "@yieldstar/core";
 function workflow(workflowFn) {
-  return async function* workflowGenerator({ event, heapClient, logger }) {
+  return async function* workflowGenerator({
+    event,
+    lease,
+    signal,
+    heapClient,
+    storeClient,
+    executionClient,
+    effectClient,
+    clock,
+    logger
+  }) {
+    const stepRunner = createStepRunner({ event, clock });
     const workflowIterator = workflowFn(stepRunner, event, logger);
     const { executionId } = event;
     let iteratorResult = null;
     let nextIteratorResult = null;
+    let resumeWith;
     const stepKeys = new Set;
     while (true) {
       let stepAttempt = 0;
@@ -255,10 +857,12 @@ function workflow(workflowFn) {
         iteratorResult = nextIteratorResult;
         nextIteratorResult = null;
       } else {
-        iteratorResult = await workflowIterator.next();
+        stopIfAborted(signal);
+        iteratorResult = await workflowIterator.next(resumeWith);
       }
+      resumeWith = undefined;
       if (iteratorResult.done) {
-        stepKey = "$$workflow-result$$";
+        stepKey = WORKFLOW_RESULT_STEP_KEY;
       } else if (!(iteratorResult.value instanceof StepKey2)) {
         throw new Error("Step runners must yield a StepKey object");
       } else {
@@ -268,10 +872,10 @@ function workflow(workflowFn) {
         }
         stepKeys.add(stepKey);
       }
-      let cached = await heapClient.readStep({
+      let cached = await infrastructure(() => heapClient.readStep({
         executionId,
         stepKey
-      });
+      }));
       if (cached?.meta) {
         stepAttempt = cached.meta.attempt + 1;
       }
@@ -288,62 +892,112 @@ function workflow(workflowFn) {
         stepResponse = iteratorResult.value;
       }
       if (stepResponse instanceof StepCacheCheck2) {
-        const cachedResponse = cached ? deserializeStepResponse(cached.stepResponseJson) : null;
+        const cachedResponse = cached ? decodeStepRecord(cached.stepResponseJson) : null;
+        stopIfAborted(signal);
         iteratorResult = await workflowIterator.next(cachedResponse);
         stepResponse = iteratorResult.value;
+        while (stepResponse instanceof StepRuntimeCall || stepResponse instanceof StepEffectCall) {
+          stopIfAborted(signal);
+          const callResult = stepResponse instanceof StepEffectCall ? await executeEffectCall(stepResponse.request, {
+            effects: effectClient,
+            executionId,
+            clock,
+            assertLease: () => stopIfAborted(signal),
+            logger
+          }) : await executeRuntimeCall(stepResponse, {
+            stores: storeClient,
+            executions: executionClient
+          });
+          iteratorResult = await workflowIterator.next(callResult);
+          stepResponse = iteratorResult.value;
+        }
       } else if (!(stepResponse instanceof WorkflowResult2)) {
         throw new Error("Step runners must yield a CacheCheck object");
       }
       if (isIterable(stepResponse)) {
         console.log(`[ERR] Steps must be yielded using yield*
 `);
-        stepResponse = new StepInvalid;
-      } else if (!(stepResponse instanceof StepResponse3)) {
+        stepResponse = new StepInvalid2;
+      } else if (!(stepResponse instanceof StepResponse5)) {
         console.log(`[ERR] Iterators should yield a StepResponse. Got ${JSON.stringify(stepResponse)}`);
-        stepResponse = new StepInvalid;
+        stepResponse = new StepInvalid2;
+      }
+      let stepResponseJson;
+      if (!cached || stepResponse instanceof WorkflowResult2) {
+        const record = encodeStepRecord(stepResponse, stepKey);
+        stepResponseJson = record.json;
+        stepResponse = record.response;
       }
       const needsRetry = !cached?.meta.done && stepResponse instanceof StepError3 && stepResponse.maxAttempts > stepAttempt + 1;
-      if (!cached) {
-        await heapClient.writeStep({
-          executionId,
+      const needsWake = !cached?.meta.done && (stepResponse instanceof StepStoreWait3 || stepResponse instanceof StepEffectWait3);
+      if (!cached && stepResponseJson !== undefined) {
+        const done = !needsRetry && !needsWake;
+        stopIfAborted(signal);
+        const written = await infrastructure(() => heapClient.writeStep({
+          lease,
           stepKey,
           stepAttempt,
-          stepDone: !needsRetry,
-          stepResponseJson: serializeStepResponse(stepResponse)
-        });
+          done,
+          stepResponseJson
+        }));
+        if (isLeaseLost(written)) {
+          throw new InfrastructureError4(new LeaseLostError(executionId));
+        }
+        if (written.stepResponseJson !== stepResponseJson || written.meta.done !== done) {
+          throw new InfrastructureError4(new StepConflictError(executionId, stepKey));
+        }
       }
       if (stepResponse instanceof WorkflowResult2) {
         return stepResponse;
       }
-      if (stepResponse instanceof StepInvalid) {
+      if (iteratorResult.done && stepResponse instanceof StepError3) {
+        throw stepResponse.err;
+      }
+      if (stepResponse instanceof StepInvalid2) {
         break;
       }
       if (stepResponse instanceof StepError3) {
         if (needsRetry) {
-          yield new StepDelay3(Date.now() + stepResponse.retryInterval);
+          yield new StepDelay3(clock() + stepResponse.retryInterval);
         } else {
+          stopIfAborted(signal);
           nextIteratorResult = await workflowIterator.throw(stepResponse.err);
           continue;
         }
       }
       if (stepResponse instanceof StepDelay3) {
-        if (stepResponse.resumeIn <= Date.now()) {
+        if (stepResponse.wakeAt <= clock()) {
           continue;
         }
       }
-      if (!(stepResponse instanceof StepResult3)) {
+      if (stepResponse instanceof StepResult3) {
+        resumeWith = stepResponse;
+      } else {
         yield stepResponse;
       }
     }
-    throw new Error("Critical error");
+    throw new Error("Workflow yielded an invalid step. Steps must be yielded with yield* from a step runner.");
   };
 }
 var createWorkflow = workflow;
+function stopIfAborted(signal) {
+  if (signal.aborted)
+    throw new InfrastructureError4(signal.reason);
+}
 export {
-  workflow,
-  createWorkflowRouter,
-  createWorkflow,
-  createLocalSdk,
+  EffectClientInvariantError2 as EffectClientInvariantError,
+  EffectDeliveryError2 as EffectDeliveryError,
+  ExecutionAdmissionError3 as ExecutionAdmissionError,
+  RetryableError,
+  WORKFLOW_RESULT_STEP_KEY2 as WORKFLOW_RESULT_STEP_KEY,
+  WorkflowEffectError2 as WorkflowEffectError,
+  WorkflowStartError2 as WorkflowStartError,
+  WorkflowValueError4 as WorkflowValueError,
   createHttpSdkFactory,
-  RetryableError
+  createLocalSdk,
+  createWorkflow,
+  createWorkflowRouter,
+  defineStore,
+  registerErrorClass2 as registerErrorClass,
+  workflow
 };