@lostgradient/weft 0.2.1 → 0.4.0

package/dist/core/checkpoint/lifecycle.js

@@ -6,7 +6,6 @@ export function createCheckpoint(workflowId, version, now) {
     step: 0,
     locals: {},
     accumulatedResults: [],
-    pendingSignals: [],
     searchAttributes: {},
     version,
     schemaVersion: CURRENT_CHECKPOINT_SCHEMA_VERSION,
@@ -19,9 +18,15 @@ export function advanceCheckpoint(checkpoint, locals, options) {
     step: checkpoint.step + 1,
     locals,
     accumulatedResults: options?.accumulatedResults ?? checkpoint.accumulatedResults,
-    ...checkpoint.workerReplaySignatures === void 0 ? {} : { workerReplaySignatures: checkpoint.workerReplaySignatures },
-    ...checkpoint.workerReplayFailures === void 0 ? {} : { workerReplayFailures: checkpoint.workerReplayFailures },
-    pendingSignals: checkpoint.pendingSignals,
+    ...(options?.accumulatedResultReplayWatermark ?? checkpoint.accumulatedResultReplayWatermark) === void 0 ? {} : {
+      accumulatedResultReplayWatermark: options?.accumulatedResultReplayWatermark ?? checkpoint.accumulatedResultReplayWatermark
+    },
+    ...(options?.workerReplaySignatures ?? checkpoint.workerReplaySignatures) === void 0 ? {} : {
+      workerReplaySignatures: options?.workerReplaySignatures ?? checkpoint.workerReplaySignatures
+    },
+    ...(options?.workerReplayFailures ?? checkpoint.workerReplayFailures) === void 0 ? {} : {
+      workerReplayFailures: options?.workerReplayFailures ?? checkpoint.workerReplayFailures
+    },
     searchAttributes: {
       ...checkpoint.searchAttributes,
       ...options?.searchAttributes

package/dist/core/checkpoint/serialization.js

@@ -26,9 +26,10 @@ export function validateCheckpointShape(value) {
   assertRecordField(record, "locals");
   validateSessionStateLocals(record.locals);
   normalizeAccumulatedResults(record);
+  validateAccumulatedResultReplayWatermark(record);
   validateWorkerReplaySignatures(record);
   validateWorkerReplayFailures(record);
-  assertArrayField(record, "pendingSignals");
+  dropLegacyPendingSignals(record);
   assertRecordField(record, "searchAttributes");
   assertStringField(record, "version");
   assertNumberField(record, "createdAt");
@@ -132,10 +133,6 @@ function assertRecordField(record, field) {
   if (typeof record[field] !== "object" || record[field] === null)
     throw Error(`Invalid checkpoint: missing or invalid "${field}" (expected object)`);
 }
-function assertArrayField(record, field) {
-  if (!Array.isArray(record[field]))
-    throw Error(`Invalid checkpoint: missing or invalid "${field}" (expected array)`);
-}
 function normalizeAccumulatedResults(record) {
   if (!("accumulatedResults" in record)) {
     record.accumulatedResults = [];
@@ -144,6 +141,16 @@ function normalizeAccumulatedResults(record) {
   if (!Array.isArray(record.accumulatedResults))
     throw Error('Invalid checkpoint: invalid "accumulatedResults" (expected array)');
 }
+function validateAccumulatedResultReplayWatermark(record) {
+  const watermark = record.accumulatedResultReplayWatermark;
+  if (watermark === void 0)
+    return;
+  if (typeof watermark !== "number" || !Number.isSafeInteger(watermark) || watermark < 0)
+    throw Error('Invalid checkpoint: invalid "accumulatedResultReplayWatermark" (expected non-negative safe integer)');
+}
+function dropLegacyPendingSignals(record) {
+  delete record.pendingSignals;
+}
 function assertCurrentSchemaVersion(record) {
   const schemaVersion = record.schemaVersion;
   if (schemaVersion === void 0)

package/dist/core/codec/extension-codec.d.ts

@@ -1,7 +1,23 @@
 import { ExtensionCodec } from '@msgpack/msgpack';
+import { WeftError } from '../weft-error.ts';
+declare const EXTENSION_TYPE_REGEXP = 2;
+export declare class RegExpExtensionDecodeError extends WeftError<'RegExpExtensionDecodeError'> {
+    readonly extensionType: typeof EXTENSION_TYPE_REGEXP;
+    readonly source: string;
+    readonly flags: string;
+    readonly sourceByteLength: number;
+    constructor(parameters: {
+        source: string;
+        flags: string;
+        sourceByteLength: number;
+        reason: string;
+        cause?: unknown;
+    });
+}
 export declare const extensionCodec: ExtensionCodec<undefined>;
 /**
  * Recursively replace `undefined` with the sentinel so msgpack's encoder
  * routes it through the extension codec instead of encoding it as null.
  */
 export declare function replaceUndefined(value: unknown, visited: Set<object>): unknown;
+export {};

package/dist/core/codec/extension-codec.js

@@ -5,8 +5,52 @@ import {
   decodeCodecDate,
   encodeCodecDate
 } from "../codec-helpers.js";
-const EXTENSION_TYPE_DATE = 1, EXTENSION_TYPE_REGEXP = 2, EXTENSION_TYPE_MAP = 3, EXTENSION_TYPE_SET = 4, EXTENSION_TYPE_UNDEFINED = 5, EXTENSION_TYPE_ERROR = 6;
+import { WeftError } from "../weft-error.js";
+import { bindSerializerRegistryToCodec, hasRegisteredSerializer } from "./serializer-registry.js";
+const EXTENSION_TYPE_DATE = 1, EXTENSION_TYPE_REGEXP = 2, EXTENSION_TYPE_MAP = 3, EXTENSION_TYPE_SET = 4, EXTENSION_TYPE_UNDEFINED = 5, EXTENSION_TYPE_ERROR = 6, REGEXP_SOURCE_MAX_BYTES = 65535, regexpSourceTextEncoder = new TextEncoder;
+
+export class RegExpExtensionDecodeError extends WeftError {
+  extensionType;
+  source;
+  flags;
+  sourceByteLength;
+  constructor(parameters) {
+    super("RegExpExtensionDecodeError", `RegExp extension type ${EXTENSION_TYPE_REGEXP} could not be decoded: source=${formatRegExpSourceForMessage(parameters.source, parameters.sourceByteLength)} flags=${JSON.stringify(parameters.flags)} ${parameters.reason}`, parameters.cause === void 0 ? void 0 : { cause: parameters.cause });
+    this.extensionType = EXTENSION_TYPE_REGEXP;
+    this.source = parameters.source;
+    this.flags = parameters.flags;
+    this.sourceByteLength = parameters.sourceByteLength;
+  }
+}
+function formatRegExpSourceForMessage(source, sourceByteLength) {
+  if (sourceByteLength <= 200)
+    return JSON.stringify(source);
+  return `${sourceByteLength}-byte string starting ${JSON.stringify(source.slice(0, 120))}`;
+}
+function decodeRegExpExtension(source, flags) {
+  const sourceByteLength = regexpSourceTextEncoder.encode(source).byteLength;
+  if (sourceByteLength > REGEXP_SOURCE_MAX_BYTES)
+    throw new RegExpExtensionDecodeError({
+      source,
+      flags,
+      sourceByteLength,
+      reason: `because source exceeds the ${REGEXP_SOURCE_MAX_BYTES}-byte limit.`
+    });
+  try {
+    return new RegExp(source, flags);
+  } catch (cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    throw new RegExpExtensionDecodeError({
+      source,
+      flags,
+      sourceByteLength,
+      reason: `because ${reason}`,
+      cause
+    });
+  }
+}
 export const extensionCodec = new ExtensionCodec;
+bindSerializerRegistryToCodec(extensionCodec, replaceUndefined);
 extensionCodec.register({
   type: EXTENSION_TYPE_DATE,
   encode: encodeCodecDate,
@@ -21,7 +65,7 @@ extensionCodec.register({
   },
   decode(data) {
     const decoded = coerceCodecRecord(msgpackDecode(data)), source = typeof decoded.source === "string" ? decoded.source : "", flags = typeof decoded.flags === "string" ? decoded.flags : "";
-    return new RegExp(source, flags);
+    return decodeRegExpExtension(source, flags);
   }
 });
 extensionCodec.register({
@@ -75,7 +119,7 @@ extensionCodec.register({
 extensionCodec.register({
   type: EXTENSION_TYPE_ERROR,
   encode(value) {
-    if (value instanceof Error)
+    if (value instanceof Error && !hasRegisteredSerializer(value))
       return msgpackEncode({
         name: value.name,
         message: value.message,
@@ -92,6 +136,11 @@ extensionCodec.register({
   }
 });
 export function replaceUndefined(value, visited) {
+  if (!containsUndefined(value, visited))
+    return value;
+  return replaceUndefinedDeep(value, new Set);
+}
+function replaceUndefinedDeep(value, visited) {
   if (value === void 0)
     return undefinedSentinel;
   if (value === null || typeof value !== "object")
@@ -119,27 +168,74 @@ function replaceObjectUndefined(value, visited) {
 function replaceArrayUndefined(value, visited) {
   const result = Array.from({ length: value.length });
   for (let index = 0;index < value.length; index++)
-    result[index] = replaceUndefined(value[index], visited);
+    result[index] = replaceUndefinedDeep(value[index], visited);
   return result;
 }
 function replaceMapUndefined(value, visited) {
   const result = new Map;
   for (const [key, mapValue] of value)
-    result.set(replaceUndefined(key, visited), replaceUndefined(mapValue, visited));
+    result.set(replaceUndefinedDeep(key, visited), replaceUndefinedDeep(mapValue, visited));
   return result;
 }
 function replaceSetUndefined(value, visited) {
   const result = new Set;
   for (const setValue of value)
-    result.add(replaceUndefined(setValue, visited));
+    result.add(replaceUndefinedDeep(setValue, visited));
   return result;
 }
 function isNestedValueFree(value) {
-  return value instanceof Date || value instanceof RegExp || value instanceof Error || value instanceof Uint8Array || value instanceof ArrayBuffer;
+  return value instanceof Date || value instanceof RegExp || value instanceof Error || value instanceof Uint8Array || value instanceof ArrayBuffer || hasRegisteredSerializer(value);
 }
 function replaceRecordUndefined(value, visited) {
   const record = value, result = {};
   for (const key of Object.keys(record))
-    result[key] = replaceUndefined(record[key], visited);
+    result[key] = replaceUndefinedDeep(record[key], visited);
   return result;
 }
+function containsUndefined(value, visited) {
+  if (value === void 0)
+    return !0;
+  if (value === null || typeof value !== "object")
+    return !1;
+  if (visited.has(value))
+    return !1;
+  if (isNestedValueFree(value))
+    return !1;
+  visited.add(value);
+  try {
+    if (Array.isArray(value))
+      return arrayContainsUndefined(value, visited);
+    if (value instanceof Map)
+      return mapContainsUndefined(value, visited);
+    if (value instanceof Set)
+      return setContainsUndefined(value, visited);
+    return recordContainsUndefined(value, visited);
+  } finally {
+    visited.delete(value);
+  }
+}
+function arrayContainsUndefined(value, visited) {
+  for (let index = 0;index < value.length; index++)
+    if (containsUndefined(value[index], visited))
+      return !0;
+  return !1;
+}
+function mapContainsUndefined(value, visited) {
+  for (const [key, mapValue] of value)
+    if (containsUndefined(key, visited) || containsUndefined(mapValue, visited))
+      return !0;
+  return !1;
+}
+function setContainsUndefined(value, visited) {
+  for (const setValue of value)
+    if (containsUndefined(setValue, visited))
+      return !0;
+  return !1;
+}
+function recordContainsUndefined(value, visited) {
+  const record = value;
+  for (const key of Object.keys(record))
+    if (containsUndefined(record[key], visited))
+      return !0;
+  return !1;
+}

package/dist/core/codec/index.d.ts

@@ -1,3 +1,4 @@
 export { decode, encode } from './api.ts';
+export { registerSerializer, type SerializerHandlers } from './serializer-registry.ts';
 export { validateCloneable } from './validation.ts';
 export type { CloneValidationError, CloneValidationResult } from './validation.ts';

package/dist/core/codec/index.js

@@ -1,2 +1,3 @@
 export { decode, encode } from "./api.js";
+export { registerSerializer } from "./serializer-registry.js";
 export { validateCloneable } from "./validation.js";

package/dist/core/codec/serializer-registry.d.ts

@@ -0,0 +1,122 @@
+import { ExtensionCodec } from '@msgpack/msgpack';
+/**
+ * Encode/decode handlers for a custom structured type that crosses Weft's
+ * checkpoint codec. `toJSON` reduces an instance to a plain, msgpack-encodable
+ * value; `fromJSON` rebuilds the instance from that value on the far side.
+ *
+ * The handlers must round-trip deterministically: a value encoded and then
+ * decoded must reconstruct an equivalent instance, with field order and content
+ * stable across calls (the codec backs replay-deterministic checkpoints).
+ *
+ * @example
+ * ```ts
+ * import { type SerializerHandlers } from '@lostgradient/weft';
+ *
+ * class ValidationError extends Error {
+ *   constructor(
+ *     message: string,
+ *     readonly issues: string[],
+ *   ) {
+ *     super(message);
+ *     this.name = 'ValidationError';
+ *   }
+ * }
+ *
+ * const handlers: SerializerHandlers<ValidationError> = {
+ *   toJSON: (error) => ({ message: error.message, issues: error.issues }),
+ *   fromJSON: (data) => {
+ *     const record = data as { message: string; issues: string[] };
+ *     return new ValidationError(record.message, record.issues);
+ *   },
+ * };
+ * void handlers;
+ * ```
+ */
+export type SerializerHandlers<T> = {
+    toJSON(value: T): unknown;
+    fromJSON(data: unknown): T;
+};
+/**
+ * Constructor of a registrable type. Uses a `never[]`-rest abstract constructor
+ * so it accepts any class (a concrete class is assignable to an abstract
+ * constructor whose parameters are `never[]`) without an `any`. The handlers,
+ * not the constructor signature, own (de)serialization; the constructor is used
+ * only for instance-identity matching.
+ */
+type RegistrableConstructor<T> = abstract new (...args: never[]) => T;
+/**
+ * Register a custom (de)serializer for `constructor` on Weft's checkpoint codec.
+ * Once registered, any instance of `constructor` that crosses the codec — an
+ * activity result, workflow input, signal payload, or error — round-trips
+ * through `handlers` instead of the generic structured-clone fallback (which,
+ * for errors, would otherwise drop subclass fields like a `ZodError`'s
+ * `.issues`).
+ *
+ * `options.tag` is a stable, developer-chosen discriminant stored inside each
+ * encoded value. Decode resolves the handler by this tag, so registration order
+ * and count are irrelevant and a checkpoint stays decodable across deploys.
+ * Choose an explicit, durable string — do NOT rely on `constructor.name`, which
+ * a minified build mangles, silently breaking cross-build decode.
+ *
+ * Matching is by exact constructor identity, and the built-in `Error` encoder
+ * defers to a registered serializer. The other built-in extension types
+ * (`Date`, `RegExp`, `Map`, `Set`) do NOT defer: registering a serializer for a
+ * subclass of one of those built-ins has no effect, because the built-in
+ * encoder matches the instance first. Register serializers for your own classes
+ * (or `Error` subclasses), not for built-in-collection subclasses.
+ *
+ * Registration is process-global and one-shot per constructor and per tag: call
+ * it once at module load, before constructing any engine. Re-registering the
+ * same constructor, or reusing a `tag` already taken by another constructor,
+ * throws. A checkpoint written with a registered serializer is decodable by any
+ * process that registered the same tag → handler.
+ *
+ * @example
+ * ```ts
+ * import { registerSerializer } from '@lostgradient/weft';
+ *
+ * class RateLimitError extends Error {
+ *   constructor(readonly retryAfterMs: number) {
+ *     super('rate limited');
+ *     this.name = 'RateLimitError';
+ *   }
+ * }
+ *
+ * registerSerializer(
+ *   RateLimitError,
+ *   {
+ *     toJSON: (error) => ({ retryAfterMs: error.retryAfterMs }),
+ *     fromJSON: (data) => new RateLimitError((data as { retryAfterMs: number }).retryAfterMs),
+ *   },
+ *   { tag: 'RateLimitError' },
+ * );
+ * ```
+ */
+export declare function registerSerializer<T>(constructor: RegistrableConstructor<T>, handlers: SerializerHandlers<T>, options: {
+    tag: string;
+}): void;
+/**
+ * Whether `value` is an instance of a registered constructor. The built-in
+ * Error extension encoder consults this to defer to a registered serializer
+ * (so a registered Error subclass uses its custom handler, not the generic
+ * Error encoding), regardless of extension-encoder registration order.
+ */
+export declare function hasRegisteredSerializer(value: object): boolean;
+/**
+ * Wire the shared extensionCodec so the single custom-serializer extension type
+ * is registered on the live codec, along with the codec's `replaceUndefined`
+ * preprocessor so custom-serializer output is encoded with the same `undefined`
+ * semantics as the public `encode()`. Called once at codec construction.
+ * `replaceUndefined` is passed in rather than imported to avoid a static cycle:
+ * extension-codec.ts imports this module for `hasRegisteredSerializer`.
+ */
+export declare function bindSerializerRegistryToCodec(codec: ExtensionCodec, replaceUndefined: (value: unknown, visited: Set<object>) => unknown): void;
+/**
+ * Test-only reset of the global registry. Production code never unregisters —
+ * a stale serializer could misread a checkpoint — but tests need isolation
+ * between registration cases. Clears both tag and constructor maps; the single
+ * extension-type decoder stays bound to the codec and simply finds an empty
+ * registry until the next registration.
+ */
+export declare function resetSerializerRegistryForTesting(): void;
+export {};

package/dist/core/codec/serializer-registry.js

@@ -0,0 +1,51 @@
+import { ExtensionCodec, decode as msgpackDecode, encode as msgpackEncode } from "@msgpack/msgpack";
+const CUSTOM_SERIALIZER_EXTENSION_TYPE = 100, registryByConstructor = new Map, registryByTag = new Map;
+export function registerSerializer(constructor, handlers, options) {
+  const key = constructor, { tag } = options;
+  if (typeof tag !== "string" || tag.length === 0)
+    throw Error("registerSerializer requires a non-empty string options.tag.");
+  if (registryByConstructor.has(key))
+    throw Error(`A serializer is already registered for ${constructor.name || "an anonymous constructor"}; registerSerializer is one-shot per constructor.`);
+  if (registryByTag.has(tag))
+    throw Error(`A serializer is already registered with tag "${tag}"; serializer tags must be unique.`);
+  const entry = {
+    tag,
+    constructor: key,
+    handlers
+  };
+  registryByConstructor.set(key, entry);
+  registryByTag.set(tag, entry);
+}
+export function hasRegisteredSerializer(value) {
+  return registryByConstructor.has(value.constructor);
+}
+export function bindSerializerRegistryToCodec(codec, replaceUndefined) {
+  codec.register({
+    type: CUSTOM_SERIALIZER_EXTENSION_TYPE,
+    encode(value) {
+      if (typeof value !== "object" || value === null)
+        return null;
+      const entry = registryByConstructor.get(value.constructor);
+      if (entry === void 0)
+        return null;
+      const data = replaceUndefined(entry.handlers.toJSON(value), new Set);
+      return msgpackEncode({ tag: entry.tag, data }, { extensionCodec: codec });
+    },
+    decode(bytes) {
+      const payload = msgpackDecode(bytes, { extensionCodec: codec });
+      if (typeof payload !== "object" || payload === null || !("tag" in payload))
+        throw Error("Corrupt custom-serializer payload: missing tag.");
+      const { tag, data } = payload;
+      if (typeof tag !== "string")
+        throw Error("Corrupt custom-serializer payload: tag is not a string.");
+      const entry = registryByTag.get(tag);
+      if (entry === void 0)
+        throw Error(`No serializer registered for tag "${tag}". Register it (with the same tag) before decoding a checkpoint that used it.`);
+      return entry.handlers.fromJSON(data);
+    }
+  });
+}
+export function resetSerializerRegistryForTesting() {
+  registryByConstructor.clear();
+  registryByTag.clear();
+}

package/dist/core/context/activity-retry-state.d.ts

@@ -0,0 +1,38 @@
+import type { ContextInternals } from './internals.ts';
+/**
+ * Durable per-step retry bookkeeping for `ctx.run`, stored in the workflow's
+ * `checkpointLocals` so it survives crash/replay. One slot holds, per step: the
+ * current attempt number, how many backoff sleeps already completed, and the
+ * first-dispatch timestamp anchoring `scheduleToCloseTimeout`. Every mutator
+ * rebuilds the slot through {@link writeRetryStateSlot} so no sub-map is silently
+ * erased when another is updated.
+ */
+export declare const ACTIVITY_RETRY_STATE_LOCAL_KEY = "__weftActivityRetryState";
+declare const ACTIVITY_RETRY_STATE_VERSION = 1;
+export declare const MAX_CHECKPOINTED_RETRY_ATTEMPT = 10000;
+export interface ActivityRetryState {
+    version: typeof ACTIVITY_RETRY_STATE_VERSION;
+    attempts: Record<string, number>;
+    completedRetrySleeps?: Record<string, number>;
+    /**
+     * First-dispatch engine-clock timestamp per step, the anchor for
+     * `scheduleToCloseTimeout`. Written ONCE on the first dispatch of a step and
+     * never overwritten, so the wall-clock budget is measured from the original
+     * dispatch even across crash/replay. Like `completedRetrySleeps`, it must be
+     * preserved whenever the retry-state slot is rebuilt.
+     */
+    dispatchedAt?: Record<string, number>;
+}
+export declare function isActivityRetryState(value: unknown): value is ActivityRetryState;
+export declare function readActivityRetryAttempt(internals: ContextInternals, step: number): number | undefined;
+export declare function readCompletedRetrySleepCount(internals: ContextInternals, step: number): number;
+export declare function writeActivityRetryAttempt(internals: ContextInternals, step: number, attempt: number): void;
+export declare function completeActivityRetryAttempt(internals: ContextInternals, step: number, completedRetrySleepCount: number): void;
+/**
+ * Read the first-dispatch anchor for a step's `scheduleToCloseTimeout`, writing
+ * `now` on the first dispatch. Read-first so a crash/replay never resets the
+ * window: the budget is measured from the original dispatch, and the anchor
+ * lands in the checkpoint committed at the dispatch `yield` that follows.
+ */
+export declare function readOrInitActivityDispatchedAt(internals: ContextInternals, step: number, now: number): number;
+export {};

package/dist/core/context/activity-retry-state.js

@@ -0,0 +1,89 @@
+export const ACTIVITY_RETRY_STATE_LOCAL_KEY = "__weftActivityRetryState";
+const ACTIVITY_RETRY_STATE_VERSION = 1;
+export const MAX_CHECKPOINTED_RETRY_ATTEMPT = 1e4;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isActivityRetryState(value) {
+  return isRecord(value) && value.version === ACTIVITY_RETRY_STATE_VERSION && isRecord(value.attempts) && (value.completedRetrySleeps === void 0 || isRecord(value.completedRetrySleeps)) && (value.dispatchedAt === void 0 || isRecord(value.dispatchedAt));
+}
+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)}`);
+}
+export 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;
+}
+export 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 currentRetryState(internals) {
+  const current = internals.checkpointLocals[ACTIVITY_RETRY_STATE_LOCAL_KEY];
+  return isActivityRetryState(current) ? current : void 0;
+}
+function writeRetryStateSlot(internals, attempts, completedRetrySleeps, dispatchedAt) {
+  const { [ACTIVITY_RETRY_STATE_LOCAL_KEY]: _removed, ...remainingLocals } = internals.checkpointLocals, hasAttempts = Object.keys(attempts).length > 0, hasSleeps = completedRetrySleeps !== void 0 && Object.keys(completedRetrySleeps).length > 0, hasDispatched = dispatchedAt !== void 0 && Object.keys(dispatchedAt).length > 0;
+  if (!hasAttempts && !hasSleeps && !hasDispatched) {
+    internals.checkpointLocals = remainingLocals;
+    return;
+  }
+  internals.checkpointLocals = {
+    ...remainingLocals,
+    [ACTIVITY_RETRY_STATE_LOCAL_KEY]: {
+      version: ACTIVITY_RETRY_STATE_VERSION,
+      attempts,
+      ...hasSleeps ? { completedRetrySleeps } : {},
+      ...hasDispatched ? { dispatchedAt } : {}
+    }
+  };
+}
+export function writeActivityRetryAttempt(internals, step, attempt) {
+  assertValidRetryAttempt(attempt, step);
+  const current = currentRetryState(internals), attempts = current ? { ...current.attempts } : {};
+  attempts[String(step)] = attempt;
+  writeRetryStateSlot(internals, attempts, current?.completedRetrySleeps, current?.dispatchedAt);
+}
+function clearActivityRetryAttempt(internals, step) {
+  const current = currentRetryState(internals);
+  if (!current)
+    return;
+  const attempts = { ...current.attempts };
+  delete attempts[String(step)];
+  writeRetryStateSlot(internals, attempts, current.completedRetrySleeps, current.dispatchedAt);
+}
+export 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 = currentRetryState(internals), attempts = current ? { ...current.attempts } : {}, completedRetrySleeps = current ? { ...current.completedRetrySleeps } : {};
+  completedRetrySleeps[String(step)] = completedRetrySleepCount;
+  writeRetryStateSlot(internals, attempts, completedRetrySleeps, current?.dispatchedAt);
+}
+export function readOrInitActivityDispatchedAt(internals, step, now) {
+  const current = currentRetryState(internals), existing = current?.dispatchedAt?.[String(step)];
+  if (typeof existing === "number" && Number.isFinite(existing))
+    return existing;
+  if (existing !== void 0)
+    throw Error(`Invalid checkpointed activity dispatch anchor ${String(existing)} for step ${String(step)}`);
+  const attempts = current ? { ...current.attempts } : {}, dispatchedAt = current?.dispatchedAt ? { ...current.dispatchedAt } : {};
+  dispatchedAt[String(step)] = now;
+  writeRetryStateSlot(internals, attempts, current?.completedRetrySleeps, dispatchedAt);
+  return now;
+}