@lostgradient/weft 0.2.0

package/dist/core/context/run-operation.js

@@ -0,0 +1,231 @@
+import { calculateBackoff } from "../scheduler.js";
+import { DEFAULT_RETRY_POLICY } from "../types.js";
+import { getInternals } from "./internals.js";
+import { isActivityCallOptions } from "./session-state.js";
+import { captureCallerStack } from "./validation.js";
+const ACTIVITY_RETRY_STATE_LOCAL_KEY = "__weftActivityRetryState", ACTIVITY_RETRY_STATE_VERSION = 1, MAX_CHECKPOINTED_RETRY_ATTEMPT = 1e4;
+function acceptsNoActivityInput(fn) {
+  if (typeof fn !== "function")
+    return !1;
+  if (fn.length === 0)
+    return !0;
+  const execute = fn.execute;
+  return typeof execute === "function" && execute.length === 0;
+}
+function shouldTreatLastArgumentAsOptions(activity, rest) {
+  const lastArgument = rest.at(-1);
+  return rest.length > 0 && isActivityCallOptions(lastArgument) && (rest.length > 1 || typeof activity !== "string" && acceptsNoActivityInput(activity));
+}
+function parseRunArguments(activity, rest) {
+  const values = [...rest], options = shouldTreatLastArgumentAsOptions(activity, values) ? values.pop() : void 0;
+  if (values.length > 1)
+    throw Error("ctx.run() accepts one activity input value plus optional ActivityCallOptions.");
+  return { input: values[0], options };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isActivityRetryState(value) {
+  return isRecord(value) && value.version === ACTIVITY_RETRY_STATE_VERSION && isRecord(value.attempts) && (value.completedRetrySleeps === void 0 || isRecord(value.completedRetrySleeps));
+}
+function assertValidRetryAttempt(attempt, step) {
+  if (!Number.isInteger(attempt) || attempt <= 1 || attempt > MAX_CHECKPOINTED_RETRY_ATTEMPT)
+    throw Error(`Invalid checkpointed activity retry attempt ${String(attempt)} for step ${String(step)}`);
+}
+function readActivityRetryAttempt(internals, step) {
+  const state = internals.checkpointLocals[ACTIVITY_RETRY_STATE_LOCAL_KEY];
+  if (!isActivityRetryState(state))
+    return;
+  const attempt = state.attempts[String(step)];
+  if (attempt === void 0)
+    return;
+  assertValidRetryAttempt(attempt, step);
+  return attempt;
+}
+function readCompletedRetrySleepCount(internals, step) {
+  const state = internals.checkpointLocals[ACTIVITY_RETRY_STATE_LOCAL_KEY];
+  if (!isActivityRetryState(state))
+    return 0;
+  const count = state.completedRetrySleeps?.[String(step)];
+  if (count === void 0)
+    return 0;
+  if (!Number.isInteger(count) || count < 0 || count > MAX_CHECKPOINTED_RETRY_ATTEMPT)
+    throw Error(`Invalid checkpointed activity retry sleep count ${String(count)} for step ${String(step)}`);
+  return count;
+}
+function writeActivityRetryAttempt(internals, step, attempt) {
+  assertValidRetryAttempt(attempt, step);
+  const current = internals.checkpointLocals[ACTIVITY_RETRY_STATE_LOCAL_KEY], attempts = isActivityRetryState(current) ? { ...current.attempts } : {};
+  attempts[String(step)] = attempt;
+  const completedRetrySleeps = isActivityRetryState(current) ? current.completedRetrySleeps : void 0;
+  internals.checkpointLocals = {
+    ...internals.checkpointLocals,
+    [ACTIVITY_RETRY_STATE_LOCAL_KEY]: {
+      version: ACTIVITY_RETRY_STATE_VERSION,
+      attempts,
+      ...completedRetrySleeps === void 0 ? {} : { completedRetrySleeps }
+    }
+  };
+}
+function clearActivityRetryAttempt(internals, step) {
+  const current = internals.checkpointLocals[ACTIVITY_RETRY_STATE_LOCAL_KEY];
+  if (!isActivityRetryState(current))
+    return;
+  const attempts = { ...current.attempts };
+  delete attempts[String(step)];
+  const completedRetrySleeps = current.completedRetrySleeps, { [ACTIVITY_RETRY_STATE_LOCAL_KEY]: _removed, ...remainingLocals } = internals.checkpointLocals;
+  if (Object.keys(attempts).length === 0 && completedRetrySleeps === void 0) {
+    internals.checkpointLocals = remainingLocals;
+    return;
+  }
+  internals.checkpointLocals = {
+    ...remainingLocals,
+    [ACTIVITY_RETRY_STATE_LOCAL_KEY]: {
+      version: ACTIVITY_RETRY_STATE_VERSION,
+      attempts,
+      ...completedRetrySleeps === void 0 ? {} : { completedRetrySleeps }
+    }
+  };
+}
+function completeActivityRetryAttempt(internals, step, completedRetrySleepCount) {
+  if (!Number.isInteger(completedRetrySleepCount) || completedRetrySleepCount < 0 || completedRetrySleepCount > MAX_CHECKPOINTED_RETRY_ATTEMPT)
+    throw Error(`Invalid completed activity retry sleep count ${String(completedRetrySleepCount)} for step ${String(step)}`);
+  clearActivityRetryAttempt(internals, step);
+  if (completedRetrySleepCount === 0)
+    return;
+  const current = internals.checkpointLocals[ACTIVITY_RETRY_STATE_LOCAL_KEY], attempts = isActivityRetryState(current) ? { ...current.attempts } : {}, completedRetrySleeps = isActivityRetryState(current) ? { ...current.completedRetrySleeps } : {};
+  completedRetrySleeps[String(step)] = completedRetrySleepCount;
+  internals.checkpointLocals = {
+    ...internals.checkpointLocals,
+    [ACTIVITY_RETRY_STATE_LOCAL_KEY]: {
+      version: ACTIVITY_RETRY_STATE_VERSION,
+      attempts,
+      completedRetrySleeps
+    }
+  };
+}
+function getActivityName(activity) {
+  return typeof activity === "string" ? activity : activity.name || "anonymous";
+}
+function getActivityFunction(activity) {
+  return typeof activity === "function" ? activity : void 0;
+}
+function getCachedRunActivityRequest(internals, step, activityName, input) {
+  const hasCachedResult = internals.accumulatedResults?.has(step) ?? !1;
+  if (hasCachedResult) {
+    const cachedResult = internals.accumulatedResults?.get(step);
+    internals.stepIndex += readCompletedRetrySleepCount(internals, step);
+    if (internals.explainMode)
+      console.log(`[weft] ctx.run(${activityName}) \u2192 Returning cached result from step ${step}`);
+    return {
+      request: { type: "activity", operationId: "", activityName, input },
+      step,
+      hasCachedResult,
+      cachedResult,
+      retryAttempt: 1
+    };
+  }
+  const retryAttempt = readActivityRetryAttempt(internals, step);
+  if (retryAttempt !== void 0) {
+    internals.stepIndex += retryAttempt - 2;
+    return {
+      request: { type: "activity", operationId: "", activityName, input },
+      step,
+      hasCachedResult: !1,
+      retryAttempt
+    };
+  }
+  return {
+    request: { type: "activity", operationId: "", activityName, input },
+    step,
+    hasCachedResult,
+    retryAttempt: 1
+  };
+}
+function createFreshRunActivityRequest(internals, step, activityName, activityFunction, input, options) {
+  const queue = options?.queue ?? "default";
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.run(${activityName}, ${JSON.stringify(input)})`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log(`  \u2192 Dispatching activity "${activityName}" to queue "${queue}"`);
+  }
+  return {
+    type: "activity",
+    operationId: crypto.randomUUID(),
+    activityName,
+    step,
+    ...activityFunction !== void 0 ? { fn: activityFunction } : {},
+    input,
+    callerStack: captureCallerStack(),
+    ...options !== void 0 ? { options } : {}
+  };
+}
+function resolveActivityRetryPolicy(activity, options) {
+  const activityRetry = typeof activity === "string" ? void 0 : activity.retry, operationRetry = options?.retry;
+  if (activityRetry === void 0 && operationRetry === void 0)
+    return;
+  return {
+    ...DEFAULT_RETRY_POLICY,
+    ...activityRetry,
+    ...operationRetry
+  };
+}
+function isNonRetryableActivityError(error, policy) {
+  const nonRetryableErrors = policy.nonRetryableErrors ?? [];
+  if (nonRetryableErrors.length === 0)
+    return !1;
+  if (error instanceof Error)
+    return nonRetryableErrors.includes(error.name) || nonRetryableErrors.includes(error.message);
+  return nonRetryableErrors.includes(String(error));
+}
+export function shouldRetryActivityError(error, policy, attempt) {
+  return policy !== void 0 && attempt < policy.maxAttempts && !isNonRetryableActivityError(error, policy);
+}
+function prepareActivityRetryRequest(request, attempt) {
+  if (attempt === 1)
+    return request;
+  return {
+    ...request,
+    operationId: crypto.randomUUID(),
+    attempt
+  };
+}
+export function createRunActivityRequest(context, activity, rest) {
+  const { input, options } = parseRunArguments(activity, rest), activityName = getActivityName(activity), activityFunction = getActivityFunction(activity), internals = getInternals(context), step = internals.stepIndex++, cachedRequest = getCachedRunActivityRequest(internals, step, activityName, input);
+  if (cachedRequest.hasCachedResult)
+    return cachedRequest;
+  const retryPolicy = resolveActivityRetryPolicy(activity, options);
+  return {
+    request: createFreshRunActivityRequest(internals, step, activityName, activityFunction, input, options),
+    step,
+    hasCachedResult: !1,
+    retryAttempt: cachedRequest.retryAttempt,
+    ...retryPolicy === void 0 ? {} : { retryPolicy }
+  };
+}
+export function* runActivityWithRetry(context, activity, rest) {
+  const { request, step, hasCachedResult, cachedResult, retryAttempt, retryPolicy } = createRunActivityRequest(context, activity, rest);
+  if (hasCachedResult)
+    return cachedResult;
+  const internals = getInternals(context);
+  let attempt = retryAttempt;
+  if (attempt > 1) {
+    if (retryPolicy === void 0)
+      throw Error(`Missing activity retry policy for checkpointed retry attempt ${attempt}`);
+    yield* context.sleep(calculateBackoff(attempt - 1, retryPolicy));
+  }
+  while (!0)
+    try {
+      const result = yield prepareActivityRetryRequest(request, attempt);
+      context.accumulatedResults.set(step, result);
+      completeActivityRetryAttempt(internals, step, attempt - 1);
+      return result;
+    } catch (error) {
+      if (!shouldRetryActivityError(error, retryPolicy, attempt))
+        throw error;
+      const nextAttempt = attempt + 1;
+      writeActivityRetryAttempt(internals, step, nextAttempt);
+      yield* context.sleep(calculateBackoff(attempt, retryPolicy));
+      attempt = nextAttempt;
+    }
+}

package/dist/core/context/saga.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from './index.ts';
+import type { ContextOperationRequest } from './operation-request.ts';
+import type { ErasedSagaStep } from './types.ts';
+export declare function saga<TFinalOutput = unknown>(context: Context, steps: ErasedSagaStep[]): Generator<ContextOperationRequest, TFinalOutput, unknown>;

package/dist/core/context/saga.js

@@ -0,0 +1,65 @@
+import { getInternals } from "./internals.js";
+export function* saga(context, steps) {
+  const completed = [];
+  let lastOutput, compensationRun = !1, sagaActive = !0;
+  const unregisterCancelHandler = getInternals(context).registerCancelHandler?.(async () => {
+    if (!sagaActive || compensationRun)
+      return;
+    compensationRun = !0;
+    try {
+      await compensateCompleted(completed);
+    } finally {
+      sagaActive = !1;
+      completed.length = 0;
+      unregisterCancelHandler?.();
+    }
+  });
+  for (const step of steps) {
+    const stepDefinition = step.definition;
+    try {
+      const executeActivity = (input, activityContext) => stepDefinition.execute(input, activityContext);
+      Object.defineProperty(executeActivity, "name", {
+        value: stepDefinition.name,
+        configurable: !0
+      });
+      const output = yield* context.run(executeActivity, step.input);
+      completed.push({ definition: stepDefinition, input: step.input, output });
+      lastOutput = output;
+    } catch (stepError) {
+      if (!compensationRun) {
+        compensationRun = !0;
+        for (let index = completed.length - 1;index >= 0; index--) {
+          const completedStep = completed[index];
+          if (completedStep.definition.compensate !== void 0) {
+            const { input: capturedInput, output: capturedOutput, definition: capturedDefinition } = completedStep, compensateActivity = async () => capturedDefinition.compensate?.(capturedInput, capturedOutput);
+            Object.defineProperty(compensateActivity, "name", {
+              value: `compensate:${completedStep.definition.name}`,
+              configurable: !0
+            });
+            try {
+              yield* context.run(compensateActivity);
+            } catch {}
+          }
+        }
+      }
+      finishSaga();
+      throw stepError;
+    }
+  }
+  finishSaga();
+  return lastOutput;
+  function finishSaga() {
+    sagaActive = !1;
+    completed.length = 0;
+    unregisterCancelHandler?.();
+  }
+}
+async function compensateCompleted(completed) {
+  for (let index = completed.length - 1;index >= 0; index--) {
+    const completedStep = completed[index];
+    if (completedStep.definition.compensate !== void 0)
+      try {
+        await completedStep.definition.compensate(completedStep.input, completedStep.output);
+      } catch {}
+  }
+}

package/dist/core/context/session-state.d.ts

@@ -0,0 +1,22 @@
+import type { ActivityCallOptions, WorkflowSessionState, WorkflowSessionStateOptions } from '../types.ts';
+import type { Context } from './index.ts';
+import type { ContextInternals } from './internals.ts';
+/** Detect whether a value is an {@link ActivityCallOptions} object. */
+export declare function isActivityCallOptions(value: unknown): value is ActivityCallOptions;
+export declare function createCheckpointLocals(stateSessionStore: Record<string, unknown> | undefined, existingLocals: Record<string, unknown> | undefined): Record<string, unknown>;
+export declare function commitSessionStateStore(internals: ContextInternals, stateSessionStore: Record<string, unknown> | undefined): void;
+export declare function getSessionStateValue<T>(internals: ContextInternals, key: string, initialValue?: T): T | undefined;
+export declare function setSessionStateValue<T>(internals: ContextInternals, key: string, value: T): T;
+export declare function updateSessionStateValue<T>(internals: ContextInternals, key: string, initialValue: T | undefined, updater: (current: T | undefined) => T): T;
+export declare function clearSessionStateValue(internals: ContextInternals, key: string): void;
+export type SessionStateRunArguments = {
+    readonly hasInput: false;
+    readonly options: ActivityCallOptions;
+} | {
+    readonly hasInput: true;
+    readonly input: unknown;
+    readonly options: ActivityCallOptions;
+};
+export declare function mergeSessionStateRunOptions(rest: readonly unknown[]): SessionStateRunArguments;
+export declare function executeSessionStateOperation<TResult>(internals: ContextInternals, apply: () => TResult): TResult;
+export declare function stateSession<T>(context: Context, internals: ContextInternals, key: string, options?: WorkflowSessionStateOptions<T>): WorkflowSessionState<T>;

package/dist/core/context/session-state.js

@@ -0,0 +1,154 @@
+import {
+  assertValidSessionStateKey,
+  cloneSessionStateStore,
+  cloneSessionStateValue,
+  createSessionStateStore,
+  hasSessionStateKey,
+  LEGACY_SESSION_STATE_LOCAL_KEY,
+  SESSION_STATE_LOCAL_KEY,
+  validateSessionStateStore
+} from "../session-state.js";
+const EMPTY_CHECKPOINT_LOCALS = Object.freeze({}), ACTIVITY_CALL_OPTION_KEYS = new Set([
+  "timeout",
+  "queue",
+  "retry",
+  "idempotencyKey",
+  "sticky",
+  "visibilityTimeout"
+]), DISCRIMINATOR_KEYS = new Set([
+  "queue",
+  "retry",
+  "idempotencyKey",
+  "sticky",
+  "visibilityTimeout"
+]);
+export function isActivityCallOptions(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return !1;
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    return !1;
+  for (const key of keys)
+    if (!ACTIVITY_CALL_OPTION_KEYS.has(key))
+      return !1;
+  for (const key of keys)
+    if (DISCRIMINATOR_KEYS.has(key))
+      return !0;
+  return !1;
+}
+export function createCheckpointLocals(stateSessionStore, existingLocals) {
+  const localEntries = existingLocals === void 0 ? [] : Object.entries(existingLocals).filter(([key]) => key !== SESSION_STATE_LOCAL_KEY && key !== LEGACY_SESSION_STATE_LOCAL_KEY);
+  if (stateSessionStore === void 0) {
+    if (localEntries.length === 0)
+      return EMPTY_CHECKPOINT_LOCALS;
+    return Object.fromEntries(localEntries);
+  }
+  return {
+    ...Object.fromEntries(localEntries),
+    [SESSION_STATE_LOCAL_KEY]: stateSessionStore
+  };
+}
+export function commitSessionStateStore(internals, stateSessionStore) {
+  internals.stateSession = stateSessionStore;
+  internals.checkpointLocals = createCheckpointLocals(stateSessionStore, internals.checkpointLocals);
+}
+export function getSessionStateValue(internals, key, initialValue) {
+  assertValidSessionStateKey(key);
+  if (internals.stateSession && hasSessionStateKey(internals.stateSession, key))
+    return cloneSessionStateValue(internals.stateSession[key]);
+  return initialValue === void 0 ? void 0 : cloneSessionStateValue(initialValue);
+}
+export function setSessionStateValue(internals, key, value) {
+  assertValidSessionStateKey(key);
+  const candidate = cloneSessionStateStore(internals.stateSession) ?? createSessionStateStore();
+  candidate[key] = cloneSessionStateValue(value);
+  validateSessionStateStore(candidate);
+  commitSessionStateStore(internals, candidate);
+  return cloneSessionStateValue(candidate[key]);
+}
+export function updateSessionStateValue(internals, key, initialValue, updater) {
+  return setSessionStateValue(internals, key, updater(getSessionStateValue(internals, key, initialValue)));
+}
+export function clearSessionStateValue(internals, key) {
+  assertValidSessionStateKey(key);
+  if (!internals.stateSession || !hasSessionStateKey(internals.stateSession, key))
+    return;
+  const candidate = cloneSessionStateStore(internals.stateSession);
+  if (!candidate)
+    return;
+  delete candidate[key];
+  commitSessionStateStore(internals, Object.keys(candidate).length === 0 ? void 0 : candidate);
+}
+export function mergeSessionStateRunOptions(rest) {
+  if (rest.length > 2)
+    throw Error("sessionState.run() accepts one activity input value plus optional ActivityCallOptions.");
+  if (rest.length === 0)
+    return { hasInput: !1, options: { sticky: !0 } };
+  if (rest.length === 1 && isActivityCallOptions(rest[0]))
+    return { hasInput: !1, options: { ...rest[0], sticky: !0 } };
+  if (rest.length === 1)
+    return { hasInput: !0, input: rest[0], options: { sticky: !0 } };
+  const options = rest[1];
+  if (!isActivityCallOptions(options))
+    throw Error("sessionState.run() options must be ActivityCallOptions.");
+  return { hasInput: !0, input: rest[0], options: { ...options, sticky: !0 } };
+}
+export function executeSessionStateOperation(internals, apply) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return internals.accumulatedResults.get(step);
+  const result = apply();
+  internals.accumulatedResults ??= new Map;
+  internals.accumulatedResults.set(step, result);
+  return result;
+}
+export function stateSession(context, internals, key, options) {
+  const hasInitialValue = options !== void 0 && "initial" in options, stateSessionInitialValue = hasInitialValue ? cloneSessionStateValue(options.initial) : void 0;
+  return {
+    get: () => executeSessionStateOperation(internals, () => getSessionStateValue(internals, key, hasInitialValue ? stateSessionInitialValue : void 0)),
+    set: (value) => executeSessionStateOperation(internals, () => setSessionStateValue(internals, key, value)),
+    update: (updater) => executeSessionStateOperation(internals, () => updateSessionStateValue(internals, key, hasInitialValue ? stateSessionInitialValue : void 0, updater)),
+    delete: () => {
+      executeSessionStateOperation(internals, () => {
+        clearSessionStateValue(internals, key);
+        return;
+      });
+    },
+    increment(amount = 1) {
+      return this.update((current) => (current ?? 0) + amount);
+    },
+    decrement(amount = 1) {
+      return this.update((current) => (current ?? 0) - amount);
+    },
+    merge(patch) {
+      return this.update((current) => ({ ...current ?? {}, ...patch }));
+    },
+    append(item) {
+      return this.update((current) => [...current ?? [], item]);
+    },
+    removeFirst() {
+      let removed;
+      this.update((current) => {
+        const next = [...current ?? []];
+        removed = next.shift();
+        return next;
+      });
+      return removed;
+    },
+    removeLast() {
+      let removed;
+      this.update((current) => {
+        const next = [...current ?? []];
+        removed = next.pop();
+        return next;
+      });
+      return removed;
+    },
+    run: (fn, ...rest) => {
+      const merged = mergeSessionStateRunOptions(rest);
+      if (!merged.hasInput)
+        return context.run(fn, merged.options);
+      return context.run(fn, merged.input, merged.options);
+    }
+  };
+}

package/dist/core/context/speculate-operations.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from './index.ts';
+import type { ContextInternals } from './internals.ts';
+import type { ContextOperationRequest } from './operation-request.ts';
+export declare function speculate<TResult>(context: Context, internals: ContextInternals, execute: (context: Context) => Generator<ContextOperationRequest, TResult, unknown> | AsyncGenerator<unknown, TResult, unknown>): Generator<ContextOperationRequest, TResult, unknown>;

package/dist/core/context/speculate-operations.js

@@ -0,0 +1,14 @@
+import { captureCallerStack } from "./validation.js";
+export function* speculate(context, internals, execute) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return internals.accumulatedResults.get(step);
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), result = yield {
+    type: "speculate",
+    operationId,
+    execute,
+    callerStack
+  };
+  context.accumulatedResults.set(step, result);
+  return result;
+}

package/dist/core/context/speculative-child.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from './index.ts';
+import type { ContextOptions } from './types.ts';
+type CreateContext = (options: ContextOptions) => Context;
+export declare function createSpeculativeChild(parent: Context, createContext: CreateContext): Context;
+export declare function commitSpeculativeChild(parent: Context, child: Context): void;
+export {};

package/dist/core/context/speculative-child.js

@@ -0,0 +1,67 @@
+import { cloneSessionStateStore } from "../session-state.js";
+import { getInternals } from "./internals.js";
+import { createCheckpointLocals } from "./session-state.js";
+function cloneMap(value) {
+  return value === void 0 ? void 0 : new Map(value);
+}
+function cloneRecord(value) {
+  return value === void 0 ? void 0 : { ...value };
+}
+function assignOptionalContextOptions(options, internals) {
+  if (internals.deadline !== void 0)
+    options.deadline = internals.deadline;
+  if (internals.searchAttributeSchema !== void 0)
+    options.searchAttributeSchema = internals.searchAttributeSchema;
+  if (internals.sleepReferenceTime !== void 0)
+    options.sleepReferenceTime = internals.sleepReferenceTime;
+  if (internals.resolveWorkflowType !== void 0)
+    options.resolveWorkflowType = internals.resolveWorkflowType;
+}
+function createSpeculativeChildOptions(parent, internals) {
+  const options = {
+    workflowId: parent.workflowId,
+    workflowType: parent.workflowType,
+    startedAt: parent.startedAt,
+    abortController: internals.abortController,
+    getNow: internals.getNow,
+    initialStep: internals.stepIndex,
+    locals: internals.checkpointLocals,
+    searchAttributes: internals.searchAttributes,
+    nestingDepth: internals.nestingDepth,
+    executionStateOwnerId: internals.executionStateOwnerId
+  }, accumulatedResults = cloneMap(internals.accumulatedResults);
+  if (accumulatedResults !== void 0)
+    options.accumulatedResults = accumulatedResults;
+  assignOptionalContextOptions(options, internals);
+  return options;
+}
+function cloneSpeculativeRuntimeState(childInternals, parentInternals) {
+  childInternals.pendingAttributeChanges = cloneRecord(parentInternals.pendingAttributeChanges);
+  childInternals.updateHandlers = cloneMap(parentInternals.updateHandlers);
+  childInternals.updateValidators = cloneMap(parentInternals.updateValidators);
+  childInternals.queryHandlers = cloneMap(parentInternals.queryHandlers);
+  childInternals.exposedValues = cloneMap(parentInternals.exposedValues);
+  childInternals.memoCache = cloneMap(parentInternals.memoCache);
+  childInternals.explainMode = parentInternals.explainMode;
+  childInternals.workflowInterceptor = parentInternals.workflowInterceptor;
+}
+export function createSpeculativeChild(parent, createContext) {
+  const internals = getInternals(parent), child = createContext(createSpeculativeChildOptions(parent, internals));
+  cloneSpeculativeRuntimeState(getInternals(child), internals);
+  return child;
+}
+export function commitSpeculativeChild(parent, child) {
+  const internals = getInternals(parent), childInternals = getInternals(child);
+  internals.stepIndex = childInternals.stepIndex;
+  internals.accumulatedResults = cloneMap(childInternals.accumulatedResults);
+  internals.stateSession = cloneSessionStateStore(childInternals.stateSession);
+  internals.checkpointLocals = createCheckpointLocals(internals.stateSession, childInternals.checkpointLocals);
+  internals.searchAttributes = { ...childInternals.searchAttributes };
+  internals.pendingAttributeChanges = cloneRecord(childInternals.pendingAttributeChanges);
+  internals.updateHandlers = cloneMap(childInternals.updateHandlers);
+  internals.updateValidators = cloneMap(childInternals.updateValidators);
+  internals.queryHandlers = cloneMap(childInternals.queryHandlers);
+  internals.exposedValues = cloneMap(childInternals.exposedValues);
+  internals.memoCache = cloneMap(childInternals.memoCache);
+  internals.sleepReferenceTime = childInternals.sleepReferenceTime;
+}

package/dist/core/context/state-namespace.d.ts

@@ -0,0 +1,27 @@
+import { type AtomicStateScope } from '../atomic-state.ts';
+import type { WorkflowAtomicState, WorkflowAtomicStateOptions, WorkflowStateNamespace } from '../types.ts';
+import type { Context } from './index.ts';
+import type { ContextInternals } from './internals.ts';
+import type { ContextOperationRequest } from './operation-request.ts';
+interface WorkflowAtomicStateOperationCache {
+    nextStep(): number;
+    has(step: number): boolean;
+    get<TResult>(step: number): TResult;
+    set(step: number, value: unknown): void;
+}
+export declare function createStateNamespace(context: Context, internals: ContextInternals): WorkflowStateNamespace;
+export declare class WorkflowAtomicStateHandle<T> extends EventTarget implements WorkflowAtomicState<T> {
+    #private;
+    constructor(scope: AtomicStateScope, key: string, options?: WorkflowAtomicStateOptions<T>, operationCache?: WorkflowAtomicStateOperationCache);
+    get(): Generator<ContextOperationRequest, T | undefined, unknown>;
+    set(value: T): Generator<ContextOperationRequest, T, unknown>;
+    update(updater: (current: T | undefined) => T): Generator<ContextOperationRequest, T, unknown>;
+    delete(): Generator<ContextOperationRequest, void, unknown>;
+    increment(this: WorkflowAtomicStateHandle<number>, amount?: number): Generator<ContextOperationRequest, number, unknown>;
+    decrement(this: WorkflowAtomicStateHandle<number>, amount?: number): Generator<ContextOperationRequest, number, unknown>;
+    merge<TObject extends Record<string, unknown>>(this: WorkflowAtomicStateHandle<TObject>, patch: Partial<TObject>): Generator<ContextOperationRequest, TObject, unknown>;
+    append<TItem>(this: WorkflowAtomicStateHandle<TItem[]>, item: TItem): Generator<ContextOperationRequest, TItem[], unknown>;
+    removeFirst<TItem>(this: WorkflowAtomicStateHandle<TItem[]>): Generator<ContextOperationRequest, TItem | undefined, unknown>;
+    removeLast<TItem>(this: WorkflowAtomicStateHandle<TItem[]>): Generator<ContextOperationRequest, TItem | undefined, unknown>;
+}
+export {};