@yieldstar/core 0.4.6 → 0.6.0

package/dist/index.js

@@ -1,4 +1,1828 @@
-// @bun
+// src/base/invoker.ts
+var WORKER_EXITED = Symbol.for("yieldstar.workerExited");
+
+class WorkerExitedError extends Error {
+  [WORKER_EXITED] = true;
+  constructor(message) {
+    super(message);
+    this.name = "WorkerExitedError";
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && value[WORKER_EXITED] === true;
+  }
+}
+// src/base/runtime.ts
+class Runtime {
+}
+// src/base/execution.ts
+function isLeaseLost(value) {
+  return typeof value === "object" && value !== null && value.status === "lost";
+}
+
+class LeaseLostError extends Error {
+  executionId;
+  constructor(executionId) {
+    super(`Lease on execution "${executionId}" was lost`);
+    this.name = "LeaseLostError";
+    this.executionId = executionId;
+  }
+}
+
+class StepConflictError extends Error {
+  executionId;
+  stepKey;
+  constructor(executionId, stepKey) {
+    super(`Step "${stepKey}" of execution "${executionId}" is already recorded with a different value`);
+    this.name = "StepConflictError";
+    this.executionId = executionId;
+    this.stepKey = stepKey;
+  }
+}
+
+class ExecutionAdmissionError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ExecutionAdmissionError";
+    this.code = code;
+  }
+}
+
+class WorkflowStartError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "WorkflowStartError";
+    this.code = code;
+  }
+}
+var INFRASTRUCTURE_ERROR = Symbol.for("yieldstar.infrastructureError");
+
+class InfrastructureError extends Error {
+  [INFRASTRUCTURE_ERROR] = true;
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.name = "InfrastructureError";
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && value[INFRASTRUCTURE_ERROR] === true;
+  }
+}
+function isTerminalExecutionStatus(status) {
+  return status === "completed" || status === "failed";
+}
+// src/base/effect.ts
+class EffectClientInvariantError extends Error {
+  code = "EFFECT_RUNTIME_INVARIANT";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "EffectClientInvariantError";
+  }
+}
+
+class EffectDeliveryError extends Error {
+  code;
+  effectId;
+  stepKey;
+  constructor(code, params, options) {
+    super(params.message, options);
+    this.name = "EffectDeliveryError";
+    this.code = code;
+    this.effectId = params.effectId;
+    this.stepKey = params.stepKey;
+  }
+}
+
+class WorkflowEffectError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "WorkflowEffectError";
+    this.code = code;
+  }
+}
+// src/base/errors.ts
+var WORKFLOW_RESULT_STEP_KEY = "$$workflow-result$$";
+
+class WorkflowValueError extends Error {
+  code;
+  stepKey;
+  constructor(code, stepKey, message) {
+    super(message);
+    this.name = "WorkflowValueError";
+    this.code = code;
+    this.stepKey = stepKey;
+  }
+}
+var errorClasses = new Map;
+function registerErrorClass(name, errorClass) {
+  if (typeof name !== "string" || name === "") {
+    throw new TypeError("Error class name must be a non-empty string");
+  }
+  if (typeof errorClass !== "function" || !(errorClass.prototype instanceof Error || errorClass === Error)) {
+    throw new TypeError(`Error class "${name}" must extend Error`);
+  }
+  errorClasses.set(name, errorClass);
+}
+function registeredErrorClass(name) {
+  return errorClasses.get(name);
+}
+var defaults = [
+  ["TypeError", TypeError],
+  ["RangeError", RangeError],
+  ["SyntaxError", SyntaxError],
+  ["ReferenceError", ReferenceError],
+  ["EvalError", EvalError],
+  ["URIError", URIError],
+  ["AggregateError", AggregateError],
+  ["WorkflowStartError", WorkflowStartError],
+  ["WorkflowValueError", WorkflowValueError],
+  ["WorkflowEffectError", WorkflowEffectError],
+  ["EffectClientInvariantError", EffectClientInvariantError],
+  ["EffectDeliveryError", EffectDeliveryError]
+];
+for (const [name, errorClass] of defaults)
+  registerErrorClass(name, errorClass);
+
+// src/base/durable-value.ts
+class DurableValueError extends Error {
+}
+var durableValueCodec = {
+  encode(value) {
+    try {
+      return { status: "encoded", canonical: encodeValue(value, "$", new Set) };
+    } catch (err) {
+      if (!(err instanceof DurableValueError))
+        throw err;
+      return { status: "invalid", message: err.message };
+    }
+  },
+  decode(canonical) {
+    let parsed;
+    try {
+      parsed = JSON.parse(canonical);
+    } catch (err) {
+      return { status: "invalid", message: `not JSON: ${err.message}` };
+    }
+    try {
+      return { status: "decoded", value: decodeParsedValue(parsed) };
+    } catch (err) {
+      if (!(err instanceof DurableValueError))
+        throw err;
+      return { status: "invalid", message: err.message };
+    }
+  }
+};
+function encodeThrownValue(value) {
+  const encoding = durableValueCodec.encode(value);
+  if (encoding.status === "encoded")
+    return encoding.canonical;
+  let message;
+  try {
+    message = String(value);
+  } catch {
+    message = "Thrown value is not a durable value";
+  }
+  return encodeValue(new Error(message), "$", new Set);
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var UNDEFINED_TAG = '{"$type":"undefined"}';
+var ERROR_KEYS = new Set(["name", "message", "stack", "code", "cause"]);
+function encodeValue(value, path, ancestors) {
+  if (value === null)
+    return "null";
+  switch (typeof value) {
+    case "undefined":
+      return UNDEFINED_TAG;
+    case "boolean":
+      return value ? "true" : "false";
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw new DurableValueError(`${path}: ${value} is not a finite number`);
+      }
+      return JSON.stringify(value);
+    case "object":
+      break;
+    default:
+      throw new DurableValueError(`${path}: ${typeof value} is not a durable value`);
+  }
+  if (ancestors.has(value)) {
+    throw new DurableValueError(`${path}: reference cycle`);
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value))
+      return encodeArray(value, path, ancestors);
+    if (value instanceof Error)
+      return encodeError(value, path, ancestors);
+    return encodeObject(value, path, ancestors);
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function encodeArray(value, path, ancestors) {
+  if (Object.getPrototypeOf(value) !== Array.prototype) {
+    throw new DurableValueError(`${path}: arrays must not be subclassed`);
+  }
+  const items = [];
+  for (const key of Reflect.ownKeys(value)) {
+    if (key === "length")
+      continue;
+    if (typeof key === "symbol") {
+      throw new DurableValueError(`${path}: symbol properties are not durable`);
+    }
+    if (!isArrayIndex(key, value.length)) {
+      throw new DurableValueError(`${path}.${key}: arrays must only have items`);
+    }
+  }
+  for (let i = 0;i < value.length; i++) {
+    const itemPath = `${path}[${i}]`;
+    const descriptor = Object.getOwnPropertyDescriptor(value, i);
+    if (!descriptor) {
+      throw new DurableValueError(`${itemPath}: missing array item`);
+    }
+    items.push(encodeValue(dataValue(descriptor, itemPath), itemPath, ancestors));
+  }
+  return `[${items.join(",")}]`;
+}
+function encodeObject(value, path, ancestors) {
+  if (!isPlainObject(value)) {
+    const name = Object.getPrototypeOf(value)?.constructor?.name ?? "object";
+    throw new DurableValueError(`${path}: ${name} instances are not plain objects`);
+  }
+  const entries = [];
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key === "symbol") {
+      throw new DurableValueError(`${path}: symbol properties are not durable`);
+    }
+    const keyPath = `${path}[${JSON.stringify(key)}]`;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    entries.push([key, encodeValue(dataValue(descriptor, keyPath), keyPath, ancestors)]);
+  }
+  return objectLiteral(entries);
+}
+function objectLiteral(entries) {
+  const literal = sortedLiteral(entries);
+  return entries.some(([key]) => key === "$type") ? `{"$type":"object","value":${literal}}` : literal;
+}
+function sortedLiteral(entries) {
+  const sorted = [...entries].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${sorted.map(([key, value]) => `${JSON.stringify(key)}:${value}`).join(",")}}`;
+}
+function encodeError(error, path, ancestors) {
+  const name = readProperty(error, "name");
+  const message = readProperty(error, "message");
+  const stack = readProperty(error, "stack");
+  const code = readProperty(error, "code");
+  const tag = [
+    ["$type", '"error"'],
+    ["name", JSON.stringify(typeof name === "string" ? name : "Error")],
+    ["message", JSON.stringify(typeof message === "string" ? message : "")]
+  ];
+  if (typeof stack === "string")
+    tag.push(["stack", JSON.stringify(stack)]);
+  if (typeof code === "string")
+    tag.push(["code", JSON.stringify(code)]);
+  if (Object.hasOwn(error, "cause")) {
+    const cause = encodeOptional(readProperty(error, "cause"), `${path}.cause`, ancestors);
+    if (cause !== undefined)
+      tag.push(["cause", cause]);
+  }
+  const errors = Object.getOwnPropertyDescriptor(error, "errors");
+  if (errors && !errors.enumerable && Array.isArray(errors.value)) {
+    const encoded = encodeOptional(errors.value, `${path}.errors`, ancestors);
+    if (encoded !== undefined)
+      tag.push(["errors", encoded]);
+  }
+  const fields = [];
+  for (const key of Object.keys(error)) {
+    if (ERROR_KEYS.has(key))
+      continue;
+    const descriptor = Object.getOwnPropertyDescriptor(error, key);
+    if (!("value" in descriptor))
+      continue;
+    const encoded = encodeOptional(descriptor.value, `${path}.${key}`, ancestors);
+    if (encoded !== undefined)
+      fields.push([key, encoded]);
+  }
+  if (fields.length > 0)
+    tag.push(["fields", objectLiteral(fields)]);
+  return sortedLiteral(tag);
+}
+function encodeOptional(value, path, ancestors) {
+  try {
+    return encodeValue(value, path, ancestors);
+  } catch (err) {
+    if (!(err instanceof DurableValueError))
+      throw err;
+    return;
+  }
+}
+function readProperty(error, key) {
+  try {
+    return error[key];
+  } catch {
+    return;
+  }
+}
+function dataValue(descriptor, path) {
+  if (!("value" in descriptor)) {
+    throw new DurableValueError(`${path}: accessor properties are not durable`);
+  }
+  if (!descriptor.enumerable) {
+    throw new DurableValueError(`${path}: non-enumerable properties are not durable`);
+  }
+  return descriptor.value;
+}
+function isArrayIndex(key, length) {
+  const index = Number(key);
+  return Number.isInteger(index) && index >= 0 && index < length && String(index) === key;
+}
+function decodeParsedValue(parsed, path = "$") {
+  if (parsed === null)
+    return null;
+  switch (typeof parsed) {
+    case "boolean":
+    case "string":
+      return parsed;
+    case "number":
+      if (!Number.isFinite(parsed)) {
+        throw new DurableValueError(`${path}: ${parsed} is not a finite number`);
+      }
+      return parsed;
+    case "object":
+      break;
+    default:
+      throw new DurableValueError(`${path}: ${typeof parsed} is not a durable value`);
+  }
+  if (Array.isArray(parsed)) {
+    return parsed.map((item, i) => decodeParsedValue(item, `${path}[${i}]`));
+  }
+  const object = parsed;
+  if (!Object.hasOwn(object, "$type"))
+    return decodeObject(object, path);
+  switch (object.$type) {
+    case "undefined":
+      expectKeys(object, path, ["$type"], []);
+      return;
+    case "object": {
+      expectKeys(object, path, ["$type", "value"], []);
+      const value = object.value;
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new DurableValueError(`${path}.value: a wrapped object must be an object`);
+      }
+      return decodeObject(value, `${path}.value`);
+    }
+    case "error":
+      return decodeError(object, path);
+    default:
+      throw new DurableValueError(`${path}: unknown $type ${JSON.stringify(object.$type)}`);
+  }
+}
+function decodeObject(object, path) {
+  const decoded = {};
+  for (const key of Object.keys(object)) {
+    Object.defineProperty(decoded, key, {
+      value: decodeParsedValue(object[key], `${path}[${JSON.stringify(key)}]`),
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  return decoded;
+}
+function decodeError(tag, path) {
+  expectKeys(tag, path, ["$type", "name", "message"], ["stack", "code", "cause", "errors", "fields"]);
+  const { name, message, stack, code } = tag;
+  for (const [key, value, optional] of [
+    ["name", name, false],
+    ["message", message, false],
+    ["stack", stack, true],
+    ["code", code, true]
+  ]) {
+    if (typeof value !== "string" && !(optional && value === undefined)) {
+      throw new DurableValueError(`${path}.${key}: must be a string`);
+    }
+  }
+  const errorClass = registeredErrorClass(name) ?? Error;
+  const error = Reflect.construct(Error, [], errorClass);
+  const hidden = (key, value) => Object.defineProperty(error, key, {
+    value,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+  const visible = (key, value) => Object.defineProperty(error, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+  if (error.name !== name)
+    visible("name", name);
+  hidden("message", message);
+  if (stack !== undefined)
+    hidden("stack", stack);
+  else
+    delete error.stack;
+  if (code !== undefined)
+    visible("code", code);
+  if (Object.hasOwn(tag, "cause")) {
+    hidden("cause", decodeParsedValue(tag.cause, `${path}.cause`));
+  }
+  if (Object.hasOwn(tag, "errors")) {
+    if (!Array.isArray(tag.errors)) {
+      throw new DurableValueError(`${path}.errors: must be an array`);
+    }
+    hidden("errors", decodeParsedValue(tag.errors, `${path}.errors`));
+  }
+  if (Object.hasOwn(tag, "fields")) {
+    const fields = decodeParsedValue(tag.fields, `${path}.fields`);
+    if (!isPlainObject(fields)) {
+      throw new DurableValueError(`${path}.fields: must be an object`);
+    }
+    for (const key of Object.keys(fields))
+      visible(key, fields[key]);
+  }
+  return error;
+}
+function expectKeys(object, path, required, optional) {
+  for (const key of required) {
+    if (!Object.hasOwn(object, key)) {
+      throw new DurableValueError(`${path}: tag is missing ${key}`);
+    }
+  }
+  for (const key of Object.keys(object)) {
+    if (!required.includes(key) && !optional.includes(key)) {
+      throw new DurableValueError(`${path}: unexpected tag key ${JSON.stringify(key)}`);
+    }
+  }
+}
+
+// src/lib/effect-state.ts
+function validateEffectRequest(request) {
+  if (!isNonEmptyString(request.effectId)) {
+    return { ok: false, message: "effectId must be a non-empty string" };
+  }
+  if (!isNonEmptyString(request.operation)) {
+    return { ok: false, message: "operation must be a non-empty string" };
+  }
+  if (!isPlainObject(request.input)) {
+    return { ok: false, message: "input must be a plain object" };
+  }
+  const encoding = durableValueCodec.encode(request.input);
+  if (encoding.status === "invalid") {
+    return { ok: false, message: `input: ${encoding.message}` };
+  }
+  return { ok: true, input: encoding.canonical };
+}
+function prepareEffectBegin(request) {
+  const validated = validateEffectRequest(request);
+  if (!validated.ok)
+    throw invariant(`Invalid effect request: ${validated.message}`);
+  assertStepId(request);
+  return {
+    effectId: request.effectId,
+    operation: request.operation,
+    input: validated.input,
+    executionId: request.executionId,
+    stepKey: request.stepKey
+  };
+}
+function prepareEffectSettle(request) {
+  if (!isNonEmptyString(request.effectId)) {
+    throw invariant("Invalid effect settlement: effectId must be a non-empty string");
+  }
+  if (!isNonEmptyString(request.operation)) {
+    throw invariant("Invalid effect settlement: operation must be a non-empty string");
+  }
+  const encoding = durableValueCodec.encode(request.result);
+  if (encoding.status === "invalid") {
+    throw invariant(`Invalid effect settlement: result: ${encoding.message}`);
+  }
+  return {
+    effectId: request.effectId,
+    operation: request.operation,
+    result: encoding.canonical
+  };
+}
+function prepareEffectWatch(request) {
+  if (!isNonEmptyString(request.effectId)) {
+    throw invariant("Invalid effect watch: effectId must be a non-empty string");
+  }
+  assertStepId(request);
+  return {
+    effectId: request.effectId,
+    executionId: request.executionId,
+    stepKey: request.stepKey
+  };
+}
+function createEffectState(begin) {
+  return {
+    effectId: begin.effectId,
+    operation: begin.operation,
+    input: begin.input,
+    status: "pending",
+    conflicts: []
+  };
+}
+function matchEffectBegin(state, begin) {
+  if (state.operation !== begin.operation || state.input !== begin.input) {
+    return { status: "rejected", code: "EFFECT_REQUEST_MISMATCH" };
+  }
+  if (state.status === "pending")
+    return { status: "pending" };
+  return { status: "settled", result: decodeSettledResult(state) };
+}
+function settleEffect(state, settle, now) {
+  if (state.operation !== settle.operation) {
+    throw invariant(`Cannot settle effect "${state.effectId}" as operation "${settle.operation}": it was begun as "${state.operation}"`);
+  }
+  if (state.status === "pending") {
+    return {
+      state: { ...state, status: "settled", result: settle.result },
+      result: { status: "settled", result: decodeValue(settle.result, state.effectId) },
+      wake: true
+    };
+  }
+  const result = decodeSettledResult(state);
+  if (state.result === settle.result) {
+    return { state, result: { status: "settled", result }, wake: false };
+  }
+  const conflictingResult = decodeValue(settle.result, state.effectId);
+  const reported = state.conflicts.some((conflict) => conflict.conflictingResult === settle.result);
+  return {
+    state: reported ? state : {
+      ...state,
+      conflicts: [
+        ...state.conflicts,
+        { result: state.result, conflictingResult: settle.result, reportedAt: now }
+      ]
+    },
+    result: { status: "conflict", result, conflictingResult },
+    wake: false
+  };
+}
+function toEffectRecord(state) {
+  const record = {
+    effectId: state.effectId,
+    operation: state.operation,
+    input: decodeInput(state),
+    status: state.status,
+    conflicts: state.conflicts.map((conflict) => ({
+      result: decodeValue(conflict.result, state.effectId),
+      conflictingResult: decodeValue(conflict.conflictingResult, state.effectId),
+      reportedAt: conflict.reportedAt
+    }))
+  };
+  if (state.status === "settled")
+    record.result = decodeSettledResult(state);
+  return record;
+}
+function effectNotFound(effectId) {
+  return invariant(`Effect "${effectId}" does not exist: begin it first`);
+}
+function decodeSettledResult(state) {
+  if (state.result === undefined) {
+    throw invariant(`Settled effect "${state.effectId}" has no stored result`);
+  }
+  return decodeValue(state.result, state.effectId);
+}
+function decodeInput(state) {
+  const input = decodeValue(state.input, state.effectId);
+  if (!isPlainObject(input)) {
+    throw invariant(`Stored input of effect "${state.effectId}" is not an object`);
+  }
+  return input;
+}
+function decodeValue(canonical, effectId) {
+  const decoded = durableValueCodec.decode(canonical);
+  if (decoded.status === "invalid") {
+    throw invariant(`Stored value of effect "${effectId}" is invalid: ${decoded.message}`);
+  }
+  return decoded.value;
+}
+function assertStepId(request) {
+  if (!isNonEmptyString(request.executionId)) {
+    throw invariant("Invalid effect request: executionId must be a non-empty string");
+  }
+  if (!isNonEmptyString(request.stepKey)) {
+    throw invariant("Invalid effect request: stepKey must be a non-empty string");
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value !== "";
+}
+function invariant(message) {
+  return new EffectClientInvariantError(message);
+}
+// src/utils/error.ts
+function errorWithOriginalStack(error, fn) {
+  const err = new Error(error.message);
+  Error.captureStackTrace(err, fn);
+  err.stack = error.stack;
+  throw err;
+}
+
+// src/utils/map.ts
+class ReadOnlyMap {
+  sourceMap;
+  constructor(sourceMap) {
+    if (sourceMap instanceof Map) {
+      this.sourceMap = sourceMap;
+    } else if (typeof sourceMap === "object" && sourceMap !== null) {
+      this.sourceMap = new Map(Object.entries(sourceMap));
+    } else {
+      this.sourceMap = new Map;
+    }
+  }
+  get(key) {
+    return this.sourceMap.get(key);
+  }
+  has(key) {
+    return this.sourceMap.has(key);
+  }
+  get size() {
+    return this.sourceMap.size;
+  }
+  entries() {
+    return this.sourceMap.entries();
+  }
+  keys() {
+    return this.sourceMap.keys();
+  }
+  values() {
+    return this.sourceMap.values();
+  }
+  forEach(callbackfn, thisArg) {
+    return this.sourceMap.forEach(callbackfn, thisArg);
+  }
+  [Symbol.iterator]() {
+    return this.sourceMap[Symbol.iterator]();
+  }
+}
+
+class FreezableMap extends Map {
+  frozen = false;
+  freeze() {
+    this.frozen = true;
+  }
+  isFrozen() {
+    return this.frozen;
+  }
+  set(key, value) {
+    if (this.frozen) {
+      const error = new Error("Cannot call set on a frozen map");
+      throw errorWithOriginalStack(error, this.set);
+    }
+    return super.set(key, value);
+  }
+  delete(key) {
+    if (this.frozen) {
+      const error = new Error("Cannot call delete on a frozen map");
+      throw errorWithOriginalStack(error, this.delete);
+    }
+    return super.delete(key);
+  }
+  clear() {
+    if (this.frozen) {
+      const error = new Error("Cannot call clear on a frozen map");
+      throw errorWithOriginalStack(error, this.clear);
+    }
+    return super.clear();
+  }
+}
+
+// src/lib/execution-state.ts
+var DEFAULT_LEASE_DURATION = 30000;
+var REDELIVERY_DELAY_BASE = 1000;
+var REDELIVERY_DELAY_MAX = 300000;
+function redeliveryDelay(unacknowledgedDeliveryCount) {
+  if (unacknowledgedDeliveryCount <= 0)
+    return 0;
+  const exponent = Math.min(unacknowledgedDeliveryCount - 1, 30);
+  return Math.min(REDELIVERY_DELAY_BASE * 2 ** exponent, REDELIVERY_DELAY_MAX);
+}
+
+class ExecutionEventEncodingError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExecutionEventEncodingError";
+  }
+}
+function encodeExecutionEvent(event) {
+  const params = durableValueCodec.encode(event.params);
+  if (params.status === "invalid") {
+    throw new ExecutionEventEncodingError(`params${params.message.slice(1)}`);
+  }
+  const entries = [];
+  for (const [key, value] of event.context?.entries() ?? []) {
+    if (typeof key !== "string") {
+      throw new ExecutionEventEncodingError(`context: keys must be strings, got ${typeof key}`);
+    }
+    entries.push([key, value]);
+  }
+  const context = durableValueCodec.encode(entries);
+  if (context.status === "invalid") {
+    throw new ExecutionEventEncodingError(`context${context.message.slice(1)}`);
+  }
+  return { params: params.canonical, context: context.canonical };
+}
+function decodeExecutionEvent(encoded) {
+  const entries = decodeOrThrow(encoded.context, "context");
+  if (!Array.isArray(entries) || !entries.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string")) {
+    throw new Error("Invalid execution context encoding: expected [key, value] entries");
+  }
+  return {
+    params: decodeOrThrow(encoded.params, "params"),
+    context: new ReadOnlyMap(new Map(entries))
+  };
+}
+function encodeExecutionOutcome(outcome) {
+  if (outcome.status === "completed") {
+    const result = durableValueCodec.encode(outcome.result);
+    if (result.status === "encoded") {
+      return `{"result":${result.canonical},"status":"completed"}`;
+    }
+    return encodeFailedOutcome(new WorkflowValueError("INVALID_STEP_VALUE", WORKFLOW_RESULT_STEP_KEY, `Workflow result is not a durable value: ${result.message}`));
+  }
+  return encodeFailedOutcome(outcome.error);
+}
+function encodeFailedOutcome(error) {
+  const encoded = encodeThrownValue(error instanceof Error ? error : new Error(safeString(error)));
+  return `{"error":${encoded},"status":"failed"}`;
+}
+function decodeExecutionOutcome(encoded) {
+  const parsed = JSON.parse(encoded);
+  if (parsed.status === "completed") {
+    return { status: "completed", result: decodeParsedValue(parsed.result, "result") };
+  }
+  const error = decodeParsedValue(parsed.error, "error");
+  if (!(error instanceof Error)) {
+    throw new Error("Invalid failed outcome encoding: expected an error");
+  }
+  return { status: "failed", error };
+}
+function decodeOrThrow(canonical, label) {
+  const decoding = durableValueCodec.decode(canonical);
+  if (decoding.status === "invalid") {
+    throw new Error(`Invalid ${label} encoding: ${decoding.message}`);
+  }
+  return decoding.value;
+}
+function safeString(value) {
+  try {
+    return String(value);
+  } catch {
+    return "Thrown value is not a durable value";
+  }
+}
+function createExecutionState(params) {
+  return {
+    executionId: params.executionId,
+    workflowId: params.workflowId,
+    params: params.encoded.params,
+    context: params.encoded.context,
+    status: "admitted",
+    outcome: null,
+    admittedAt: params.now,
+    updatedAt: params.now,
+    dueAt: params.now,
+    claimedDueAt: null,
+    leaseToken: 0,
+    leaseExpiresAt: null,
+    unacknowledgedDeliveryCount: 0,
+    redeliverAt: null,
+    parent: params.parent ?? null
+  };
+}
+function hasExpiredLease(state, now) {
+  return state.leaseExpiresAt !== null && state.leaseExpiresAt <= now;
+}
+function executionStatusAt(state, now) {
+  if (state.leaseExpiresAt !== null && state.leaseExpiresAt > now) {
+    return "running";
+  }
+  return state.status;
+}
+function unacknowledgedDeliveryCountAt(state, now) {
+  return state.unacknowledgedDeliveryCount + (hasExpiredLease(state, now) ? 1 : 0);
+}
+function toExecutionRecord(state, now) {
+  const event = decodeExecutionEvent(state);
+  return {
+    executionId: state.executionId,
+    workflowId: state.workflowId,
+    params: event.params,
+    context: event.context,
+    status: executionStatusAt(state, now),
+    ...state.outcome !== null ? { outcome: decodeExecutionOutcome(state.outcome) } : {},
+    admittedAt: state.admittedAt,
+    updatedAt: state.updatedAt,
+    unacknowledgedDeliveryCount: unacknowledgedDeliveryCountAt(state, now),
+    ...state.parent !== null ? { parent: { ...state.parent } } : {}
+  };
+}
+function nextClaimAt(state) {
+  if (isTerminalExecutionStatus(state.status))
+    return null;
+  if (state.leaseExpiresAt !== null) {
+    const due = earliest(state.dueAt, state.claimedDueAt);
+    if (due === null)
+      return null;
+    return Math.max(due, state.leaseExpiresAt + redeliveryDelay(state.unacknowledgedDeliveryCount + 1));
+  }
+  if (state.dueAt === null)
+    return null;
+  return state.redeliverAt === null ? state.dueAt : Math.max(state.dueAt, state.redeliverAt);
+}
+function isExecutionClaimable(state, now) {
+  const at = nextClaimAt(state);
+  return at !== null && at <= now;
+}
+function isLeaseCurrent(state, lease) {
+  return state.executionId === lease.executionId && state.leaseExpiresAt !== null && state.leaseToken === lease.token;
+}
+var LOST = { status: "lost" };
+function requestExecutionWake(state, wakeAt, now) {
+  if (isTerminalExecutionStatus(state.status))
+    return null;
+  return { ...state, dueAt: earliest(state.dueAt, wakeAt), updatedAt: now };
+}
+function claimExecution(state, params) {
+  const lease = {
+    executionId: state.executionId,
+    token: state.leaseToken + 1,
+    expiresAt: params.now + params.duration
+  };
+  return {
+    state: {
+      ...state,
+      unacknowledgedDeliveryCount: state.unacknowledgedDeliveryCount + (state.leaseExpiresAt !== null ? 1 : 0),
+      claimedDueAt: earliest(state.dueAt, state.claimedDueAt),
+      dueAt: null,
+      leaseToken: lease.token,
+      leaseExpiresAt: lease.expiresAt,
+      redeliverAt: null
+    },
+    lease
+  };
+}
+function renewExecutionLease(state, params) {
+  if (!isLeaseCurrent(state, params.lease))
+    return { state, result: LOST };
+  const lease = {
+    ...params.lease,
+    expiresAt: params.now + params.duration
+  };
+  return {
+    state: { ...state, leaseExpiresAt: lease.expiresAt },
+    result: { status: "renewed", lease }
+  };
+}
+function releaseExecutionLease(state, params) {
+  if (!isLeaseCurrent(state, params.lease))
+    return { state, result: LOST };
+  const unacknowledgedDeliveryCount = state.unacknowledgedDeliveryCount + 1;
+  return {
+    state: {
+      ...state,
+      dueAt: earliest(state.dueAt, state.claimedDueAt),
+      claimedDueAt: null,
+      leaseExpiresAt: null,
+      unacknowledgedDeliveryCount,
+      redeliverAt: params.now + redeliveryDelay(unacknowledgedDeliveryCount)
+    },
+    result: { status: "released" }
+  };
+}
+function acknowledgeExecution(state, params) {
+  if (!isLeaseCurrent(state, params.lease))
+    return { state, result: LOST };
+  if (isTerminalExecutionStatus(state.status)) {
+    return { state, result: decodeExecutionOutcome(state.outcome) };
+  }
+  const { outcome, now } = params;
+  const ended = {
+    claimedDueAt: null,
+    leaseExpiresAt: null,
+    unacknowledgedDeliveryCount: 0,
+    redeliverAt: null,
+    updatedAt: now
+  };
+  if (outcome.status !== "suspended") {
+    const encoded = encodeExecutionOutcome(outcome.status === "completed" ? { status: "completed", result: outcome.result } : { status: "failed", error: outcome.error });
+    const terminal = decodeExecutionOutcome(encoded);
+    return {
+      state: {
+        ...state,
+        ...ended,
+        status: terminal.status,
+        outcome: encoded,
+        dueAt: null
+      },
+      result: terminal
+    };
+  }
+  return {
+    state: {
+      ...state,
+      ...ended,
+      status: "suspended",
+      dueAt: earliest(state.dueAt, outcome.wakeAt ?? null)
+    },
+    result: { status: "suspended" }
+  };
+}
+function earliest(a, b) {
+  if (a === null)
+    return b;
+  if (b === null)
+    return a;
+  return Math.min(a, b);
+}
+function prepareExecutionAdmission(request) {
+  if (typeof request.workflowId !== "string" || request.workflowId === "") {
+    return {
+      ok: false,
+      code: "INVALID_EXECUTION_EVENT",
+      message: "workflowId must be a non-empty string"
+    };
+  }
+  if (request.executionId !== undefined && (typeof request.executionId !== "string" || request.executionId === "")) {
+    return {
+      ok: false,
+      code: "INVALID_EXECUTION_EVENT",
+      message: "executionId must be a non-empty string"
+    };
+  }
+  try {
+    return {
+      ok: true,
+      executionId: request.executionId ?? crypto.randomUUID(),
+      encoded: encodeExecutionEvent(request)
+    };
+  } catch (err) {
+    if (!(err instanceof ExecutionEventEncodingError))
+      throw err;
+    return { ok: false, code: "INVALID_EXECUTION_EVENT", message: err.message };
+  }
+}
+function executionIdConflict(executionId) {
+  return {
+    status: "rejected",
+    code: "EXECUTION_ID_CONFLICT",
+    message: `Execution "${executionId}" already exists`
+  };
+}
+function executionNotFound(executionId) {
+  return {
+    status: "rejected",
+    code: "EXECUTION_NOT_FOUND",
+    message: `Execution "${executionId}" does not exist`
+  };
+}
+function prepareExecutionStart(request) {
+  const invalid = (message) => ({
+    ok: false,
+    result: {
+      status: "rejected",
+      code: "INVALID_START_PARAMETERS",
+      message
+    }
+  });
+  if (typeof request.workflowId !== "string" || request.workflowId === "") {
+    return invalid("workflowId must be a non-empty string");
+  }
+  let params = null;
+  if (request.params !== undefined) {
+    if (!isPlainObject(request.params)) {
+      return invalid("params must be a plain object");
+    }
+    const encoding = durableValueCodec.encode(request.params);
+    if (encoding.status === "invalid") {
+      return invalid(`params: ${encoding.message}`);
+    }
+    params = encoding.canonical;
+  }
+  return {
+    ok: true,
+    start: {
+      callerExecutionId: request.requestId.executionId,
+      stepKey: request.requestId.stepKey,
+      workflowId: request.workflowId,
+      params
+    }
+  };
+}
+function matchStartRequest(recorded, start) {
+  if (recorded.workflowId === start.workflowId && recorded.params === start.params) {
+    return { status: "accepted", executionId: recorded.executionId };
+  }
+  return {
+    status: "rejected",
+    code: "START_REQUEST_MISMATCH",
+    message: `Step "${start.stepKey}" of execution "${start.callerExecutionId}" already started workflow "${recorded.workflowId}" with different parameters or workflow ID`
+  };
+}
+function createStartedExecution(params) {
+  const { start, caller, now } = params;
+  const executionId = params.executionId ?? crypto.randomUUID();
+  const target = createExecutionState({
+    executionId,
+    workflowId: start.workflowId,
+    encoded: {
+      params: start.params ?? encodeExecutionEvent({ params: undefined, context: undefined }).params,
+      context: caller.context
+    },
+    now,
+    parent: { executionId: start.callerExecutionId, stepKey: start.stepKey }
+  });
+  return {
+    target,
+    startRequest: {
+      callerExecutionId: start.callerExecutionId,
+      stepKey: start.stepKey,
+      workflowId: start.workflowId,
+      params: start.params,
+      executionId
+    }
+  };
+}
+// src/lib/execution-dispatcher.ts
+var DEFAULT_DISPATCHER_CONCURRENCY = 10;
+var DEFAULT_ABORT_GRACE_PERIOD = 1000;
+var ABANDONED = Symbol("abandoned");
+
+class ExecutionDispatcher {
+  runtime;
+  invoker;
+  logger;
+  pollInterval;
+  keepAlive;
+  concurrency;
+  leaseDuration;
+  renewInterval;
+  abortGracePeriod;
+  running = false;
+  looping = false;
+  timer;
+  inFlight = new Set;
+  claiming = 0;
+  constructor(runtime, options) {
+    this.runtime = runtime;
+    this.invoker = options.invoker;
+    this.logger = options.logger;
+    this.pollInterval = options.pollInterval ?? 10;
+    this.keepAlive = options.keepAlive ?? true;
+    this.concurrency = options.concurrency ?? DEFAULT_DISPATCHER_CONCURRENCY;
+    this.leaseDuration = options.leaseDuration ?? DEFAULT_LEASE_DURATION;
+    this.renewInterval = options.renewInterval ?? this.leaseDuration / 3;
+    this.abortGracePeriod = options.abortGracePeriod ?? DEFAULT_ABORT_GRACE_PERIOD;
+    if (!Number.isInteger(this.concurrency) || this.concurrency < 1) {
+      throw new RangeError("concurrency must be a positive integer");
+    }
+    if (!(this.leaseDuration > 0)) {
+      throw new RangeError("leaseDuration must be positive");
+    }
+    if (!(this.renewInterval > 0 && this.renewInterval < this.leaseDuration)) {
+      throw new RangeError("renewInterval must be positive and shorter than leaseDuration");
+    }
+    if (!(this.abortGracePeriod >= 0)) {
+      throw new RangeError("abortGracePeriod must not be negative");
+    }
+  }
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.loop();
+  }
+  async stop() {
+    this.running = false;
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = undefined;
+    await this.drain();
+  }
+  get activeDeliveries() {
+    return this.inFlight.size;
+  }
+  async tick() {
+    const slots = this.concurrency - this.inFlight.size - this.claiming;
+    if (slots <= 0)
+      return 0;
+    this.claiming += slots;
+    let leases;
+    try {
+      leases = await this.runtime.executions.claimDue({
+        limit: slots,
+        duration: this.leaseDuration
+      });
+    } finally {
+      this.claiming -= slots;
+    }
+    for (const lease of leases) {
+      const task = this.dispatch(lease).finally(() => {
+        this.inFlight.delete(task);
+        if (this.running && !this.looping)
+          this.schedule(0);
+      });
+      this.inFlight.add(task);
+    }
+    return leases.length;
+  }
+  async drain() {
+    while (this.inFlight.size > 0) {
+      await Promise.allSettled([...this.inFlight]);
+    }
+  }
+  schedule(delay) {
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      this.loop();
+    }, delay);
+    if (!this.keepAlive)
+      this.timer.unref?.();
+  }
+  async loop() {
+    if (!this.running || this.looping)
+      return;
+    this.looping = true;
+    let claimed = 0;
+    try {
+      claimed = await this.tick();
+    } catch (err) {
+      this.logger.error({ err }, "Failed to claim due executions");
+    } finally {
+      this.looping = false;
+    }
+    if (!this.running)
+      return;
+    if (this.inFlight.size + this.claiming >= this.concurrency)
+      return;
+    this.schedule(claimed > 0 ? 0 : this.pollInterval);
+  }
+  async dispatch(lease) {
+    const { executionId } = lease;
+    const { executions } = this.runtime;
+    const renewal = this.renew(lease);
+    try {
+      const record = await executions.get(executionId);
+      if (!record) {
+        this.logger.error({ executionId }, "Claimed execution has no record");
+        return;
+      }
+      if (isTerminalExecutionStatus(record.status)) {
+        this.emit(executionId, record.outcome);
+        return;
+      }
+      let outcome;
+      try {
+        outcome = await this.abandonAfterAbort(this.invoker.deliver({
+          workflowId: record.workflowId,
+          executionId,
+          params: record.params,
+          context: record.context
+        }, { lease, signal: renewal.signal }), lease, renewal.signal);
+      } catch (err) {
+        const current = await renewal.stop();
+        if (!current)
+          return;
+        if (WorkerExitedError.is(err)) {
+          this.logger.error({ executionId, err }, "Worker exited without replying; the lease will expire and the execution will be redelivered");
+          return;
+        }
+        this.logger.error({ executionId, err }, "Delivery failed without an outcome; releasing its lease for redelivery");
+        const released = await executions.release({ lease: current });
+        if (released.status === "lost")
+          this.warnLost(lease);
+        return;
+      }
+      if (outcome === ABANDONED)
+        return;
+      const current = await renewal.stop();
+      if (!current)
+        return;
+      const result = await executions.acknowledge({ lease: current, outcome });
+      if (result.status === "lost") {
+        this.warnLost(lease);
+        return;
+      }
+      this.emit(executionId, result);
+    } catch (err) {
+      this.logger.error({ executionId, err }, "Failed to dispatch execution; the lease will expire and the execution will be redelivered");
+    } finally {
+      await renewal.stop();
+    }
+  }
+  abandonAfterAbort(delivery, lease, signal) {
+    return new Promise((resolve, reject) => {
+      let abandoned = false;
+      let timer;
+      const onAbort = () => {
+        timer = setTimeout(() => {
+          abandoned = true;
+          this.logger.warn({ executionId: lease.executionId, token: lease.token }, "Delivery did not stop within the abort grace period after its lease was lost; abandoning it");
+          resolve(ABANDONED);
+        }, this.abortGracePeriod);
+        if (!this.keepAlive)
+          timer.unref?.();
+      };
+      const settle = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+      };
+      if (signal.aborted)
+        onAbort();
+      else
+        signal.addEventListener("abort", onAbort, { once: true });
+      delivery.then((value) => {
+        settle();
+        if (abandoned) {
+          this.logger.warn({ executionId: lease.executionId, token: lease.token }, "Abandoned delivery settled late; its outcome is ignored");
+        } else
+          resolve(value);
+      }, (err) => {
+        settle();
+        if (abandoned) {
+          this.logger.warn({ executionId: lease.executionId, token: lease.token, err }, "Abandoned delivery rejected late; ignored");
+        } else
+          reject(err);
+      });
+    });
+  }
+  renew(lease) {
+    const controller = new AbortController;
+    let current = lease;
+    let pending;
+    let stopped = false;
+    const { executions } = this.runtime;
+    const timer = setInterval(() => {
+      if (stopped || pending || !current)
+        return;
+      const renewing = current;
+      pending = executions.renew({ lease: renewing, duration: this.leaseDuration }).then((result) => {
+        if (result.status === "lost") {
+          current = undefined;
+          clearInterval(timer);
+          this.warnLost(lease);
+          controller.abort(new LeaseLostError(lease.executionId));
+        } else if (current) {
+          current = result.lease;
+        }
+      }, (err) => {
+        this.logger.error({ executionId: lease.executionId, err }, "Failed to renew lease");
+      }).finally(() => {
+        pending = undefined;
+      });
+    }, this.renewInterval);
+    if (!this.keepAlive)
+      timer.unref?.();
+    return {
+      signal: controller.signal,
+      async stop() {
+        stopped = true;
+        clearInterval(timer);
+        await pending;
+        return current;
+      }
+    };
+  }
+  warnLost(lease) {
+    this.logger.warn({ executionId: lease.executionId, token: lease.token }, "Lease was lost to another claim; this delivery stops without an outcome");
+  }
+  emit(executionId, result) {
+    if (result.status === "completed") {
+      this.invoker.workflowEndEmitter.emit(executionId, result.result);
+    } else if (result.status === "failed") {
+      this.invoker.workflowEndEmitter.emit(executionId, result.error);
+    }
+  }
+}
+// src/lib/wait-for-outcome.ts
+async function waitForExecutionOutcome(executions, executionId, options) {
+  const pollInterval = options?.pollInterval ?? 25;
+  const emitter = options?.emitter;
+  let wake;
+  const nudge = () => wake?.();
+  emitter?.on(executionId, nudge);
+  try {
+    while (true) {
+      options?.signal?.throwIfAborted();
+      const record = await executions.get(executionId);
+      if (!record)
+        return;
+      if (isTerminalExecutionStatus(record.status))
+        return record.outcome;
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, pollInterval);
+        wake = () => {
+          clearTimeout(timer);
+          resolve();
+        };
+      });
+      wake = undefined;
+    }
+  } finally {
+    emitter?.off(executionId, nudge);
+  }
+}
+// src/base/store.ts
+class StoreValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StoreValidationError";
+  }
+}
+registerErrorClass("StoreValidationError", StoreValidationError);
+function defineStore(name, schema, options) {
+  return {
+    name,
+    schema,
+    initial: options.initial
+  };
+}
+
+class StoreClient {
+  store(definition, id) {
+    return {
+      get: () => this.getStore({
+        definition,
+        id
+      }),
+      update: (updater) => this.updateStore({
+        definition,
+        id,
+        updater
+      }),
+      updateFrom: (snapshot, updater) => this.updateStoreFrom({
+        definition,
+        id,
+        snapshot,
+        updater
+      }),
+      deleteFrom: (snapshot) => this.deleteStoreFrom({
+        definition,
+        id,
+        snapshot
+      })
+    };
+  }
+}
+
+class CasStoreClient extends StoreClient {
+  createInstanceId() {
+    return crypto.randomUUID();
+  }
+  async getStore(params) {
+    return this.getOrInsertStore(params.definition, params.id);
+  }
+  async updateStore(params) {
+    const applied = await this.getAppliedResult(params);
+    if (applied) {
+      return applied.result;
+    }
+    const stepKey = params.stepId?.stepKey;
+    let snapshot = await this.readOrInitialize(params.definition, params.id, stepKey);
+    while (true) {
+      const prepared = await prepareStoreUpdate(params.definition, snapshot, params.updater, stepKey);
+      const result = {
+        state: cloneStoreState(prepared.nextState),
+        previousVersion: snapshot.version,
+        version: snapshot.version + 1
+      };
+      const committed = await this.commitStoreMutation({
+        definition: params.definition,
+        id: params.id,
+        expected: snapshot,
+        nextState: prepared.nextState,
+        changedPaths: prepared.changedPaths,
+        stepId: params.stepId,
+        result
+      });
+      if (committed.status === "committed")
+        return result;
+      if (committed.status === "already-applied") {
+        return committed.result;
+      }
+      snapshot = committed.status === "conflict" ? existing(committed.snapshot) : await this.readOrInitialize(params.definition, params.id, stepKey);
+    }
+  }
+  async updateStoreFrom(params) {
+    const applied = await this.getAppliedResult(params);
+    if (applied) {
+      return applied.result;
+    }
+    assertStoreSnapshotInstanceId(params.snapshot);
+    const stepKey = params.stepId?.stepKey;
+    const current = await this.getOrInsertStore(params.definition, params.id, stepKey);
+    if (!sameStoreVersion(current, params.snapshot)) {
+      return storeUpdateConflict(params.snapshot, current);
+    }
+    const prepared = await prepareStoreUpdate(params.definition, params.snapshot, params.updater, stepKey);
+    const result = {
+      updated: true,
+      state: cloneStoreState(prepared.nextState),
+      previousVersion: params.snapshot.version,
+      version: params.snapshot.version + 1
+    };
+    const committed = await this.commitStoreMutation({
+      definition: params.definition,
+      id: params.id,
+      expected: existing(params.snapshot),
+      nextState: prepared.nextState,
+      changedPaths: prepared.changedPaths,
+      stepId: params.stepId,
+      result
+    });
+    if (committed.status === "committed")
+      return result;
+    if (committed.status === "already-applied") {
+      return committed.result;
+    }
+    return storeUpdateConflict(params.snapshot, committed.status === "conflict" ? committed.snapshot : await this.getOrInsertStore(params.definition, params.id, stepKey));
+  }
+  async deleteStoreFrom(params) {
+    const applied = await this.getAppliedResult(params);
+    if (applied)
+      return applied.result;
+    assertStoreSnapshotInstanceId(params.snapshot);
+    const stepKey = params.stepId?.stepKey;
+    let current = await this.getOrInsertStore(params.definition, params.id, stepKey);
+    while (sameStoreVersion(current, params.snapshot)) {
+      const result = { deleted: true };
+      const committed = await this.commitStoreDeletion({
+        definition: params.definition,
+        id: params.id,
+        expected: params.snapshot,
+        stepId: params.stepId,
+        result
+      });
+      if (committed.status === "committed")
+        return result;
+      if (committed.status === "already-applied") {
+        return committed.result;
+      }
+      current = committed.status === "conflict" ? committed.snapshot : await this.getOrInsertStore(params.definition, params.id, stepKey);
+    }
+    return {
+      deleted: false,
+      reason: "conflict",
+      expectedInstanceId: params.snapshot.instanceId,
+      actualInstanceId: current.instanceId,
+      expectedVersion: params.snapshot.version,
+      actualVersion: current.version
+    };
+  }
+  async takeFromStore(params) {
+    const applied = await this.getAppliedResult(params);
+    if (applied)
+      return applied.result;
+    const stepKey = params.stepId?.stepKey;
+    let snapshot = await this.readOrInitialize(params.definition, params.id, stepKey);
+    while (true) {
+      const previousState = cloneStoreState(snapshot.state);
+      const draft = cloneStoreState(previousState);
+      const tracked = trackStoreUpdater(draft);
+      const { result: selectedResult, readPaths } = trackStoreSelector(tracked.draft, params.selector);
+      if (!isStoreSelectorMatch(selectedResult)) {
+        if (snapshot.created) {
+          const stored = await this.insertStore({
+            definition: params.definition,
+            id: params.id,
+            snapshot: detach(snapshot)
+          });
+          if (stored.instanceId !== snapshot.instanceId) {
+            snapshot = existing(stored);
+            continue;
+          }
+        }
+        return {
+          matched: false,
+          instanceId: snapshot.instanceId,
+          version: snapshot.version,
+          readPaths
+        };
+      }
+      const selected = unwrapTrackedValue(selectedResult);
+      assertSynchronousClaim(params.claim(tracked.draft, selected));
+      const prepared = await finalizeStoreMutation({
+        definition: params.definition,
+        previousState,
+        draft,
+        tracked,
+        stepKey
+      });
+      assertDurableStoreValue(selected, stepKey ?? "", `Store take selection for "${params.definition.name}"`);
+      const selectedSnapshot = cloneStoreState(selected);
+      const result = {
+        matched: true,
+        selected: selectedSnapshot,
+        instanceId: snapshot.instanceId,
+        version: snapshot.version + 1
+      };
+      const committed = await this.commitStoreMutation({
+        definition: params.definition,
+        id: params.id,
+        expected: snapshot,
+        nextState: prepared.nextState,
+        changedPaths: prepared.changedPaths,
+        stepId: params.stepId,
+        result
+      });
+      if (committed.status === "committed")
+        return result;
+      if (committed.status === "already-applied") {
+        return committed.result;
+      }
+      snapshot = committed.status === "conflict" ? existing(committed.snapshot) : await this.readOrInitialize(params.definition, params.id, stepKey);
+    }
+  }
+  async readOrInitialize(definition, id, stepKey) {
+    const snapshot = await this.readStore({ definition, id });
+    if (snapshot)
+      return existing(snapshot);
+    const state = await validateStoreState(definition, definition.initial(id), stepKey);
+    return {
+      state,
+      instanceId: this.createInstanceId(),
+      version: 0,
+      created: true
+    };
+  }
+  async getOrInsertStore(definition, id, stepKey) {
+    const snapshot = await this.readOrInitialize(definition, id, stepKey);
+    if (!snapshot.created)
+      return detach(snapshot);
+    return await this.insertStore({
+      definition,
+      id,
+      snapshot: detach(snapshot)
+    });
+  }
+  getAppliedResult(params) {
+    return params.stepId ? this.getAppliedStoreStep({
+      definition: params.definition,
+      id: params.id,
+      stepId: params.stepId
+    }) : Promise.resolve(undefined);
+  }
+}
+function existing(snapshot) {
+  return {
+    state: snapshot.state,
+    instanceId: snapshot.instanceId,
+    version: snapshot.version,
+    created: false
+  };
+}
+function detach(snapshot) {
+  return {
+    state: snapshot.state,
+    instanceId: snapshot.instanceId,
+    version: snapshot.version
+  };
+}
+async function prepareStoreUpdate(definition, snapshot, updater, stepKey) {
+  const previousState = cloneStoreState(snapshot.state);
+  const draft = cloneStoreState(previousState);
+  const tracked = trackStoreUpdater(draft);
+  const updated = updater(tracked.draft);
+  assertSynchronousUpdater(updated);
+  const returned = updated === undefined ? undefined : unwrapTrackedValue(updated);
+  return finalizeStoreMutation({
+    definition,
+    previousState,
+    draft,
+    tracked,
+    replacement: returned,
+    stepKey
+  });
+}
+async function finalizeStoreMutation(params) {
+  const isReplacement = params.replacement !== undefined && params.replacement !== params.draft;
+  const nextState = await validateStoreState(params.definition, isReplacement ? params.replacement : params.draft, params.stepKey);
+  const changedPaths = !isReplacement && nextState === params.draft ? params.tracked.writePaths() : diffStorePaths(params.previousState, nextState);
+  return { nextState, changedPaths };
+}
+function sameStoreVersion(left, right) {
+  return left.instanceId === right.instanceId && left.version === right.version;
+}
+function assertStoreSnapshotInstanceId(snapshot) {
+  if (!snapshot.instanceId) {
+    throw new Error("Store snapshot is missing instanceId; read a fresh snapshot");
+  }
+}
+function storeUpdateConflict(expected, actual) {
+  return {
+    updated: false,
+    expectedInstanceId: expected.instanceId,
+    actualInstanceId: actual.instanceId,
+    expectedVersion: expected.version,
+    actualVersion: actual.version
+  };
+}
+function isStoreSelectorMatch(result) {
+  return result !== undefined && result !== null && result !== false;
+}
+function assertSynchronousClaim(claimResult) {
+  if (claimResult && typeof claimResult.then === "function") {
+    throw new Error("Store take claims must be synchronous");
+  }
+}
+function assertSynchronousUpdater(updaterResult) {
+  if (updaterResult && typeof updaterResult.then === "function") {
+    throw new Error("Store updaters must be synchronous");
+  }
+}
+async function validateStoreState(definition, state, stepKey = "") {
+  const result = await definition.schema["~standard"].validate(state);
+  if ("issues" in result && result.issues) {
+    const messages = result.issues.map((issue) => issue.message).join("; ");
+    throw new StoreValidationError(`Invalid store state for "${definition.name}": ${messages}`);
+  }
+  assertDurableStoreValue(result.value, stepKey, `Store state for "${definition.name}"`);
+  return result.value;
+}
+function assertDurableStoreValue(value, stepKey, label) {
+  const encoding = durableValueCodec.encode(value);
+  if (encoding.status === "invalid") {
+    throw new WorkflowValueError("INVALID_STEP_VALUE", stepKey, `${label} is not a durable value: ${encoding.message}`);
+  }
+}
+function encodeStoreValue(value) {
+  const encoding = durableValueCodec.encode(value);
+  if (encoding.status === "invalid") {
+    throw new Error(`Store value is not a durable value: ${encoding.message}`);
+  }
+  return encoding.canonical;
+}
+function decodeStoreValue(canonical) {
+  const decoding = durableValueCodec.decode(canonical);
+  if (decoding.status === "invalid") {
+    throw new Error(`Invalid store value encoding: ${decoding.message}`);
+  }
+  return decoding.value;
+}
+function cloneStoreState(state) {
+  const encoding = durableValueCodec.encode(state);
+  if (encoding.status === "encoded") {
+    const decoding = durableValueCodec.decode(encoding.canonical);
+    if (decoding.status === "decoded")
+      return decoding.value;
+  }
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(state);
+    } catch {}
+  }
+  return JSON.parse(JSON.stringify(state));
+}
+function diffStorePaths(previous, next) {
+  const paths = [];
+  function visit(left, right, path) {
+    if (Object.is(left, right))
+      return;
+    if (!isDiffableObject(left) || !isDiffableObject(right)) {
+      paths.push(path);
+      return;
+    }
+    const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+    for (const key of keys) {
+      visit(left[key], right[key], [...path, arrayKeyToPathSegment(key)]);
+    }
+  }
+  visit(previous, next, []);
+  return collapseStorePaths(paths);
+}
+var TRACKING_TARGET = Symbol("yieldstar.trackingTarget");
+function unwrapTrackedValue(value) {
+  if (isDiffableObject(value)) {
+    const target = value[TRACKING_TARGET];
+    if (target !== undefined)
+      return target;
+  }
+  return value;
+}
+function trackStoreSelector(state, selector) {
+  const paths = [];
+  const proxies = new WeakMap;
+  function track(value, path) {
+    if (!isDiffableObject(value))
+      return value;
+    const cached = proxies.get(value);
+    if (cached)
+      return cached;
+    const proxy = new Proxy(value, {
+      get(target, property, receiver) {
+        if (typeof property === "symbol") {
+          if (property === TRACKING_TARGET)
+            return target;
+          return Reflect.get(target, property, receiver);
+        }
+        const nextPath = [...path, arrayKeyToPathSegment(property)];
+        if (nextPath.length > 0) {
+          paths.push(nextPath);
+        }
+        const child = Reflect.get(target, property, receiver);
+        return track(child, nextPath);
+      },
+      set() {
+        throw new Error("Store selectors must not mutate state");
+      },
+      deleteProperty() {
+        throw new Error("Store selectors must not mutate state");
+      }
+    });
+    proxies.set(value, proxy);
+    return proxy;
+  }
+  const result = selector(track(state, []));
+  return {
+    result,
+    readPaths: collapseStorePaths(paths)
+  };
+}
+function trackStoreUpdater(target) {
+  const paths = [];
+  const proxies = new WeakMap;
+  function record(path, property) {
+    if (typeof property === "symbol") {
+      paths.push(path);
+      return;
+    }
+    paths.push([...path, arrayKeyToPathSegment(String(property))]);
+  }
+  function track(value, path) {
+    if (!isDiffableObject(value))
+      return value;
+    const cached = proxies.get(value);
+    if (cached)
+      return cached;
+    const proxy = new Proxy(value, {
+      get(target, property, receiver) {
+        if (typeof property === "symbol") {
+          if (property === TRACKING_TARGET)
+            return target;
+          return Reflect.get(target, property, receiver);
+        }
+        const child = Reflect.get(target, property);
+        return track(child, [...path, arrayKeyToPathSegment(property)]);
+      },
+      set(target, property, value) {
+        record(path, property);
+        return Reflect.set(target, property, unwrapTrackedValue(value));
+      },
+      deleteProperty(target, property) {
+        record(path, property);
+        return Reflect.deleteProperty(target, property);
+      },
+      defineProperty(target, property, descriptor) {
+        record(path, property);
+        if ("value" in descriptor) {
+          descriptor = { ...descriptor, value: unwrapTrackedValue(descriptor.value) };
+        }
+        return Reflect.defineProperty(target, property, descriptor);
+      }
+    });
+    proxies.set(value, proxy);
+    return proxy;
+  }
+  return {
+    draft: track(target, []),
+    writePaths: () => collapseStorePaths(paths)
+  };
+}
+function storePathsIntersect(readPaths, writePaths) {
+  return readPaths.some((readPath) => writePaths.some((writePath) => isPathPrefix(readPath, writePath) || isPathPrefix(writePath, readPath)));
+}
+function collapseStorePaths(paths) {
+  const unique = new Map(paths.map((path) => [path.join("\x00"), path]));
+  return [...unique.values()];
+}
+function isPathPrefix(prefix, path) {
+  if (prefix.length > path.length)
+    return false;
+  return prefix.every((segment, index) => segment === path[index]);
+}
+function isDiffableObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function arrayKeyToPathSegment(key) {
+  if (/^(0|[1-9]\d*)$/.test(key))
+    return Number(key);
+  return key;
+}
 // src/base/step.ts
 class StepResponse {
 }
@@ -27,9 +1851,12 @@ class StepResult extends StepResponse {
   static type = "step-result";
   type = "step-result";
   result;
-  constructor(result) {
+  schema;
+  constructor(result, schema) {
     super();
     this.result = result;
+    if (schema !== undefined)
+      this.schema = schema;
   }
 }
 
@@ -46,10 +1873,28 @@ class WorkflowResult extends StepResponse {
 class WorkflowDelay extends StepResponse {
   static type = "workflow-delay";
   type = "workflow-delay";
-  resumeIn;
-  constructor(resumeIn) {
+  wakeAt;
+  constructor(wakeAt) {
+    super();
+    this.wakeAt = wakeAt;
+  }
+}
+
+class StepStoreWait extends StepResponse {
+  static type = "store-wait";
+  type = "store-wait";
+  constructor() {
+    super();
+  }
+}
+
+class StepEffectWait extends StepResponse {
+  static type = "effect-wait";
+  type = "effect-wait";
+  wakeAt;
+  constructor(wakeAt) {
     super();
-    this.resumeIn = resumeIn;
+    this.wakeAt = wakeAt;
   }
 }
 
@@ -80,49 +1925,66 @@ class StepError extends StepResponse {
 class StepDelay extends StepResponse {
   static type = "step-delay";
   type = "step-delay";
-  resumeIn;
-  constructor(resumeIn) {
+  wakeAt;
+  constructor(wakeAt) {
     super();
-    this.resumeIn = resumeIn;
+    this.wakeAt = wakeAt;
   }
 }
 // src/lib/workflow-runner.ts
 class WorkflowRunner {
-  heapClient;
-  schedulerClient;
+  runtime;
   router;
-  constructor(params) {
-    this.heapClient = params.heapClient;
-    this.schedulerClient = params.schedulerClient;
-    this.router = params.router;
+  logger;
+  constructor(runtime, options) {
+    this.runtime = runtime;
+    this.router = options.router;
+    this.logger = options.logger;
   }
-  run = async (event, logger) => {
+  run = async (event, options) => {
+    const { lease, signal, logger = this.logger } = options;
     const workflow = this.router[event.workflowId];
     if (!workflow) {
-      throw new Error(`No workflow registered for "${event.workflowId}"`);
+      return {
+        status: "failed",
+        error: new Error(`No workflow registered for "${event.workflowId}"`)
+      };
     }
+    let response;
     try {
-      const response = await this.runWorkflows({
+      response = await this.runWorkflows({
         workflow,
         logger,
-        event
+        event,
+        lease,
+        signal
       });
-      switch (response.type) {
-        case "workflow-result":
-          return response;
-        case "workflow-delay":
-          this.schedulerClient.requestWakeUp(event, response.resumeIn);
-          break;
-      }
     } catch (err) {
-      throw err;
+      if (InfrastructureError.is(err))
+        throw err;
+      return { status: "failed", error: toError(err) };
+    }
+    switch (response.type) {
+      case "workflow-result":
+        return { status: "completed", result: response.result };
+      case "step-delay":
+      case "effect-wait":
+        return { status: "suspended", wakeAt: response.wakeAt };
+      case "store-wait":
+        return { status: "suspended" };
     }
   };
   async runWorkflows(params) {
-    const { workflow, event, logger } = params;
+    const { workflow, event, lease, signal, logger } = params;
     const workflowIterator = workflow({
       event,
-      heapClient: this.heapClient,
+      lease,
+      signal,
+      heapClient: this.runtime.heap,
+      storeClient: this.runtime.stores,
+      executionClient: this.runtime.executions,
+      effectClient: this.runtime.effects,
+      clock: this.runtime.clock,
       logger
     });
     const iteratorResult = await workflowIterator.next();
@@ -131,94 +1993,107 @@ class WorkflowRunner {
       return stageResponse;
     }
     if (stageResponse instanceof StepDelay) {
-      return new WorkflowDelay(stageResponse.resumeIn - Date.now());
+      return stageResponse;
+    }
+    if (stageResponse instanceof StepEffectWait || stageResponse instanceof StepStoreWait) {
+      return stageResponse;
     }
     throw new Error("Workflow runner critical error. This is likely because your worklow and worker are referencing different versions of @yieldstar/core.");
   }
 }
-// src/utils/error.ts
-function errorWithOriginalStack(error, fn) {
-  const err = new Error(error.message);
-  Error.captureStackTrace(err, fn);
-  err.stack = error.stack;
-  throw err;
-}
-
-// src/utils/map.ts
-class ReadOnlyMap {
-  sourceMap;
-  constructor(sourceMap) {
-    this.sourceMap = sourceMap;
-  }
-  get(key) {
-    return this.sourceMap.get(key);
-  }
-  has(key) {
-    return this.sourceMap.has(key);
-  }
-  get size() {
-    return this.sourceMap.size;
-  }
-  entries() {
-    return this.sourceMap.entries();
-  }
-  keys() {
-    return this.sourceMap.keys();
-  }
-  values() {
-    return this.sourceMap.values();
-  }
-  forEach(callbackfn, thisArg) {
-    return this.sourceMap.forEach(callbackfn, thisArg);
-  }
-  [Symbol.iterator]() {
-    return this.sourceMap[Symbol.iterator]();
-  }
-}
-
-class FreezableMap extends Map {
-  frozen = false;
-  freeze() {
-    this.frozen = true;
-  }
-  isFrozen() {
-    return this.frozen;
-  }
-  set(key, value) {
-    if (this.frozen) {
-      const error = new Error("Cannot call set on a frozen map");
-      throw errorWithOriginalStack(error, this.set);
-    }
-    return super.set(key, value);
-  }
-  delete(key) {
-    if (this.frozen) {
-      const error = new Error("Cannot call delete on a frozen map");
-      throw errorWithOriginalStack(error, this.delete);
-    }
-    return super.delete(key);
-  }
-  clear() {
-    if (this.frozen) {
-      const error = new Error("Cannot call clear on a frozen map");
-      throw errorWithOriginalStack(error, this.clear);
-    }
-    return super.clear();
-  }
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
 }
 export {
-  errorWithOriginalStack,
-  WorkflowRunner,
-  WorkflowResult,
-  WorkflowRestart,
-  WorkflowDelay,
-  StepResult,
-  StepResponse,
-  StepKey,
-  StepInvalid,
-  StepError,
-  StepDelay,
-  StepCacheCheck,
+  CasStoreClient,
+  DEFAULT_ABORT_GRACE_PERIOD,
+  DEFAULT_DISPATCHER_CONCURRENCY,
+  DEFAULT_LEASE_DURATION,
+  DurableValueError,
+  EffectClientInvariantError,
+  EffectDeliveryError,
+  ExecutionAdmissionError,
+  ExecutionDispatcher,
+  ExecutionEventEncodingError,
+  FreezableMap,
+  InfrastructureError,
+  LeaseLostError,
+  REDELIVERY_DELAY_BASE,
+  REDELIVERY_DELAY_MAX,
   ReadOnlyMap,
-  FreezableMap
+  Runtime,
+  StepCacheCheck,
+  StepConflictError,
+  StepDelay,
+  StepEffectWait,
+  StepError,
+  StepInvalid,
+  StepKey,
+  StepResponse,
+  StepResult,
+  StepStoreWait,
+  StoreClient,
+  StoreValidationError,
+  WORKFLOW_RESULT_STEP_KEY,
+  WorkerExitedError,
+  WorkflowDelay,
+  WorkflowEffectError,
+  WorkflowRestart,
+  WorkflowResult,
+  WorkflowRunner,
+  WorkflowStartError,
+  WorkflowValueError,
+  acknowledgeExecution,
+  assertSynchronousClaim,
+  assertSynchronousUpdater,
+  claimExecution,
+  cloneStoreState,
+  createEffectState,
+  createExecutionState,
+  createStartedExecution,
+  decodeExecutionEvent,
+  decodeExecutionOutcome,
+  decodeParsedValue,
+  decodeStoreValue,
+  defineStore,
+  diffStorePaths,
+  durableValueCodec,
+  effectNotFound,
+  encodeExecutionEvent,
+  encodeExecutionOutcome,
+  encodeStoreValue,
+  encodeThrownValue,
+  errorWithOriginalStack,
+  executionIdConflict,
+  executionNotFound,
+  executionStatusAt,
+  isExecutionClaimable,
+  isLeaseCurrent,
+  isLeaseLost,
+  isStoreSelectorMatch,
+  isTerminalExecutionStatus,
+  matchEffectBegin,
+  matchStartRequest,
+  nextClaimAt,
+  prepareEffectBegin,
+  prepareEffectSettle,
+  prepareEffectWatch,
+  prepareExecutionAdmission,
+  prepareExecutionStart,
+  redeliveryDelay,
+  registerErrorClass,
+  releaseExecutionLease,
+  renewExecutionLease,
+  requestExecutionWake,
+  settleEffect,
+  storePathsIntersect,
+  toEffectRecord,
+  toExecutionRecord,
+  trackStoreSelector,
+  trackStoreUpdater,
+  unacknowledgedDeliveryCountAt,
+  unwrapTrackedValue,
+  validateEffectRequest,
+  validateStoreState,
+  waitForExecutionOutcome
 };