@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/chunk-ABFZWYHT.js

@@ -0,0 +1,612 @@
+import { PHASE_C_COMMANDS, PHASE_B_CORE_COMMANDS, PHASE_B_PARITY_COMMANDS, TERMINAL_COMMANDS, isInputEvent, isCommandEvent } from './chunk-DJYMDLV5.js';
+import { isActivityNodeTypeAllowed } from './chunk-BO6OVILK.js';
+
+// src/history/commands.ts
+function isCommandEnabled(type, enabled = "core") {
+  if (PHASE_C_COMMANDS.has(type)) return false;
+  if (PHASE_B_CORE_COMMANDS.has(type)) return true;
+  return enabled === "parity" && PHASE_B_PARITY_COMMANDS.has(type);
+}
+function isWorkflowCommandEnabled(command, enabled = "core") {
+  if (command.type === "REQUEST_CANCEL_EXTERNAL_RUN" && "childId" in command.target) return true;
+  return isCommandEnabled(command.type, enabled);
+}
+
+// src/history/activation.ts
+function timeOf(event) {
+  const startedAt = event.payload["startedAt"];
+  const text = typeof startedAt === "string" ? startedAt : event.createdAt;
+  const ms = Date.parse(text);
+  return Number.isFinite(ms) ? ms : 0;
+}
+function cutoffOf(event) {
+  const leased = event.payload["historyLength"];
+  return typeof leased === "number" && leased < event.seq ? leased : event.seq;
+}
+function walk(history) {
+  const activations = [];
+  let pending = [];
+  let started;
+  let afterStarted = [];
+  let last;
+  for (const event of history) {
+    switch (event.type) {
+      case "WORKFLOW_TASK_STARTED":
+        if (started) pending.push(...afterStarted);
+        started = event;
+        afterStarted = [];
+        continue;
+      case "WORKFLOW_TASK_FAILED":
+      case "WORKFLOW_TASK_TIMED_OUT":
+        if (started) pending.push(...afterStarted);
+        started = void 0;
+        afterStarted = [];
+        continue;
+      case "WORKFLOW_TASK_COMPLETED": {
+        const taskId = typeof event.payload["taskId"] === "string" ? event.payload["taskId"] : "";
+        const boundary = started !== void 0 && started.payload["taskId"] === event.payload["taskId"] ? started : event;
+        const cutoff = boundary === event ? event.seq : cutoffOf(boundary);
+        const seen = pending.filter((input) => input.seq <= cutoff);
+        const later = pending.filter((input) => input.seq > cutoff);
+        last = {
+          inputs: seen,
+          recorded: [],
+          timeMs: timeOf(boundary),
+          taskId,
+          historyLength: cutoff
+        };
+        activations.push(last);
+        pending = [...later, ...afterStarted];
+        started = void 0;
+        afterStarted = [];
+        continue;
+      }
+    }
+    if (isInputEvent(event)) {
+      if (started) afterStarted.push(event);
+      else pending.push(event);
+    } else if (isCommandEvent(event) && last?.recorded) {
+      last.recorded.push(event);
+    }
+  }
+  return { activations, pending, started, afterStarted };
+}
+function splitActivations(history, nowMs, includeOpen) {
+  const { activations, pending, started } = walk(history);
+  if (includeOpen) {
+    const cutoff = started ? cutoffOf(started) : history.length;
+    const inputs = pending.filter((input) => input.seq <= cutoff);
+    activations.push({ inputs, recorded: void 0, timeMs: nowMs, historyLength: cutoff });
+  }
+  return activations;
+}
+function unseenInputs(history) {
+  const { pending, afterStarted } = walk(history);
+  return [...pending, ...afterStarted].sort((a, b) => a.seq - b.seq);
+}
+
+// src/history/apply.ts
+var HistoryStateError = class extends Error {
+  constructor(message, seq) {
+    super(message);
+    this.seq = seq;
+    this.name = "HistoryStateError";
+  }
+  seq;
+};
+function initialRunState() {
+  return {
+    status: "RUNNING",
+    historyLength: 0,
+    historyBytes: 0,
+    cancelRequested: false,
+    task: { state: "NONE", attempt: 0 },
+    completedTasks: 0,
+    taskFailures: 0,
+    activities: {},
+    timers: {},
+    children: {},
+    externals: {},
+    sideEffects: {},
+    markers: {},
+    signalsReceived: 0,
+    context: {}
+  };
+}
+function utf8Bytes(text) {
+  let bytes = 0;
+  for (let index = 0; index < text.length; index++) {
+    const unit = text.charCodeAt(index);
+    if (unit < 128) bytes += 1;
+    else if (unit < 2048) bytes += 2;
+    else if (unit >= 55296 && unit <= 56319 && index + 1 < text.length) {
+      const next = text.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index++;
+      } else bytes += 3;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function str(payload, key) {
+  const value = payload[key];
+  return typeof value === "string" ? value : "";
+}
+function failureOf(payload) {
+  const value = payload["failure"];
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return value;
+}
+var OPEN_ACTIVITY = /* @__PURE__ */ new Set([
+  "SCHEDULED",
+  "STARTED",
+  "CANCEL_REQUESTED"
+]);
+function isActivityOpen(activity2) {
+  return OPEN_ACTIVITY.has(activity2.status);
+}
+function isChildOpen(child2) {
+  return child2.status === "INITIATED" || child2.status === "STARTED";
+}
+function activity(state, event) {
+  const id = str(event.payload, "activityId");
+  const found = state.activities[id];
+  if (!found) throw new HistoryStateError(`${event.type} for unknown activity "${id}"`, event.seq);
+  return found;
+}
+function child(state, event) {
+  const id = str(event.payload, "childId");
+  const found = state.children[id];
+  if (!found) throw new HistoryStateError(`${event.type} for unknown child "${id}"`, event.seq);
+  return found;
+}
+function timer(state, event) {
+  const id = str(event.payload, "timerId");
+  const found = state.timers[id];
+  if (!found) throw new HistoryStateError(`${event.type} for unknown timer "${id}"`, event.seq);
+  return found;
+}
+function applyEvent(state, event) {
+  if (event.seq !== state.historyLength + 1)
+    throw new HistoryStateError(
+      `Event seq ${event.seq} follows ${state.historyLength}; history must be gapless`,
+      event.seq
+    );
+  if (state.status !== "RUNNING" && event.type !== "WORKFLOW_TASK_FAILED")
+    throw new HistoryStateError(`${event.type} after the run ended (${state.status})`, event.seq);
+  state.historyLength = event.seq;
+  state.historyBytes += utf8Bytes(JSON.stringify(event.payload));
+  state.lastEventAt = event.createdAt;
+  const p = event.payload;
+  switch (event.type) {
+    case "WORKFLOW_STARTED":
+      if (event.seq !== 1)
+        throw new HistoryStateError("WORKFLOW_STARTED must be the first event", event.seq);
+      state.workflowFn = str(p, "workflowFn");
+      state.input = p["input"] ?? null;
+      if (typeof p["context"] === "object" && p["context"] !== null && !Array.isArray(p["context"]))
+        state.context = { ...p["context"] };
+      break;
+    case "WORKFLOW_TASK_SCHEDULED":
+      state.task = { state: "SCHEDULED", taskId: str(p, "taskId"), attempt: state.task.attempt };
+      break;
+    case "WORKFLOW_TASK_STARTED": {
+      const attempt = typeof p["attempt"] === "number" ? p["attempt"] : 1;
+      state.task = { state: "STARTED", taskId: str(p, "taskId"), attempt };
+      break;
+    }
+    case "WORKFLOW_TASK_COMPLETED":
+      state.task = { state: "NONE", attempt: 0 };
+      state.completedTasks += 1;
+      state.taskFailures = 0;
+      break;
+    case "WORKFLOW_TASK_FAILED":
+    case "WORKFLOW_TASK_TIMED_OUT":
+      state.taskFailures += 1;
+      if (state.status === "RUNNING")
+        state.task = { state: "SCHEDULED", taskId: str(p, "taskId"), attempt: state.task.attempt };
+      break;
+    case "ACTIVITY_SCHEDULED": {
+      const id = str(p, "activityId");
+      if (state.activities[id])
+        throw new HistoryStateError(`Activity "${id}" is scheduled twice`, event.seq);
+      state.activities[id] = {
+        status: "SCHEDULED",
+        attempt: 0,
+        nodeType: str(p, "nodeType"),
+        operation: str(p, "operation"),
+        scheduledSeq: event.seq,
+        ...typeof p["cancellationType"] === "string" ? { cancellationType: p["cancellationType"] } : {},
+        ...typeof p["summary"] === "string" ? { summary: p["summary"] } : {}
+      };
+      break;
+    }
+    case "ACTIVITY_STARTED": {
+      const found = activity(state, event);
+      if (found.status === "SCHEDULED") found.status = "STARTED";
+      found.attempt = typeof p["attempt"] === "number" ? p["attempt"] : found.attempt + 1;
+      break;
+    }
+    case "ACTIVITY_HEARTBEAT":
+    case "ACTIVITY_PAUSED":
+    case "ACTIVITY_UNPAUSED":
+    case "ACTIVITY_RESET":
+    case "ACTIVITY_OPTIONS_UPDATED":
+      activity(state, event);
+      break;
+    case "ACTIVITY_COMPLETED":
+    case "ACTIVITY_FAILED":
+    case "ACTIVITY_TIMED_OUT":
+    case "ACTIVITY_CANCELLED": {
+      const found = activity(state, event);
+      if (!isActivityOpen(found))
+        throw new HistoryStateError(
+          `${event.type} for activity "${str(p, "activityId")}" that is already ${found.status}`,
+          event.seq
+        );
+      found.status = event.type === "ACTIVITY_COMPLETED" ? "COMPLETED" : event.type === "ACTIVITY_FAILED" ? "FAILED" : event.type === "ACTIVITY_TIMED_OUT" ? "TIMED_OUT" : "CANCELLED";
+      if (typeof p["attempt"] === "number") found.attempt = p["attempt"];
+      const failure = failureOf(p);
+      if (failure) found.lastFailure = failure;
+      break;
+    }
+    case "ACTIVITY_CANCEL_REQUESTED": {
+      const found = activity(state, event);
+      if (isActivityOpen(found)) found.status = "CANCEL_REQUESTED";
+      break;
+    }
+    case "TIMER_STARTED": {
+      const id = str(p, "timerId");
+      if (state.timers[id])
+        throw new HistoryStateError(`Timer "${id}" is started twice`, event.seq);
+      state.timers[id] = {
+        status: "PENDING",
+        durationMs: typeof p["durationMs"] === "number" ? p["durationMs"] : 0,
+        fireAt: str(p, "fireAt"),
+        startedSeq: event.seq,
+        ...typeof p["summary"] === "string" ? { summary: p["summary"] } : {}
+      };
+      break;
+    }
+    case "TIMER_FIRED":
+    case "TIMER_CANCELLED": {
+      const found = timer(state, event);
+      if (found.status !== "PENDING")
+        throw new HistoryStateError(
+          `${event.type} for timer "${str(p, "timerId")}" that is already ${found.status}`,
+          event.seq
+        );
+      found.status = event.type === "TIMER_FIRED" ? "FIRED" : "CANCELLED";
+      break;
+    }
+    case "SIGNAL_RECEIVED":
+      state.signalsReceived += 1;
+      break;
+    case "CHILD_RUN_INITIATED": {
+      const id = str(p, "childId");
+      if (state.children[id])
+        throw new HistoryStateError(`Child "${id}" is started twice`, event.seq);
+      const options = p["options"];
+      const policy = typeof options === "object" && options !== null && !Array.isArray(options) ? options["parentClosePolicy"] : void 0;
+      state.children[id] = {
+        status: "INITIATED",
+        parentClosePolicy: policy === "ABANDON" || policy === "REQUEST_CANCEL" ? policy : "TERMINATE",
+        initiatedSeq: event.seq,
+        ...typeof p["workflowKey"] === "string" ? { workflowKey: p["workflowKey"] } : {},
+        ...typeof p["workflowFn"] === "string" ? { workflowFn: p["workflowFn"] } : {},
+        ...typeof p["childRunId"] === "string" ? { childRunId: p["childRunId"] } : {}
+      };
+      break;
+    }
+    case "CHILD_RUN_STARTED": {
+      const found = child(state, event);
+      if (found.status !== "INITIATED")
+        throw new HistoryStateError(`Child "${str(p, "childId")}" started twice`, event.seq);
+      found.status = "STARTED";
+      found.childRunId = str(p, "childRunId");
+      break;
+    }
+    case "CHILD_RUN_COMPLETED":
+    case "CHILD_RUN_FAILED":
+    case "CHILD_RUN_CANCELLED":
+    case "CHILD_RUN_TERMINATED":
+    case "CHILD_RUN_TIMED_OUT": {
+      const found = child(state, event);
+      if (!isChildOpen(found))
+        throw new HistoryStateError(
+          `${event.type} for child "${str(p, "childId")}" that is already ${found.status}`,
+          event.seq
+        );
+      found.status = event.type.slice("CHILD_RUN_".length);
+      if (typeof p["childRunId"] === "string") found.childRunId = p["childRunId"];
+      break;
+    }
+    case "EXTERNAL_RUN_SIGNALED":
+    case "EXTERNAL_RUN_CANCEL_REQUESTED":
+    case "EXTERNAL_RUN_CANCEL_RESOLVED": {
+      const id = str(p, "externalId");
+      const resolving = event.type === "EXTERNAL_RUN_CANCEL_RESOLVED" || event.type === "EXTERNAL_RUN_SIGNALED" && p["resolved"] === true;
+      if (resolving) {
+        const found = state.externals[id];
+        if (!found || found.status !== "PENDING")
+          throw new HistoryStateError(`${event.type} for unknown or resolved "${id}"`, event.seq);
+        found.status = "RESOLVED";
+        found.ok = p["ok"] === true;
+      } else {
+        if (state.externals[id])
+          throw new HistoryStateError(`External operation "${id}" is issued twice`, event.seq);
+        state.externals[id] = {
+          kind: event.type === "EXTERNAL_RUN_SIGNALED" ? "signal" : "cancel",
+          status: "PENDING"
+        };
+      }
+      break;
+    }
+    case "SIDE_EFFECT_RECORDED":
+      state.sideEffects[str(p, "sideEffectId")] = p["value"] ?? null;
+      break;
+    case "MARKER_RECORDED":
+      state.markers[str(p, "markerId")] = p["data"] ?? null;
+      break;
+    case "CONTEXT_UPSERTED": {
+      const entries = p["entries"];
+      if (typeof entries === "object" && entries !== null && !Array.isArray(entries))
+        state.context = { ...state.context, ...entries };
+      break;
+    }
+    case "WORKFLOW_CANCEL_REQUESTED":
+      state.cancelRequested = true;
+      break;
+    case "WORKFLOW_COMPLETED":
+      state.status = "COMPLETED";
+      state.output = p["output"] ?? null;
+      break;
+    case "WORKFLOW_FAILED": {
+      state.status = "FAILED";
+      const failure = failureOf(p);
+      if (failure) state.failure = failure;
+      break;
+    }
+    case "WORKFLOW_CANCELLED":
+      state.status = "CANCELLED";
+      break;
+    case "WORKFLOW_TERMINATED":
+      state.status = "TERMINATED";
+      break;
+    case "WORKFLOW_TIMED_OUT":
+      state.status = "TIMED_OUT";
+      break;
+    case "WORKFLOW_CONTINUED_AS_NEW":
+      state.status = "CONTINUED_AS_NEW";
+      break;
+  }
+  if (state.status !== "RUNNING") state.task = { state: "NONE", attempt: 0 };
+  return state;
+}
+function projectRunState(history) {
+  const state = initialRunState();
+  for (const event of history) applyEvent(state, event);
+  return state;
+}
+function pendingCounts(state) {
+  return {
+    activities: Object.values(state.activities).filter(isActivityOpen).length,
+    timers: Object.values(state.timers).filter((t) => t.status === "PENDING").length,
+    children: Object.values(state.children).filter(isChildOpen).length
+  };
+}
+function payloadOf(command) {
+  const out = {};
+  for (const [key, value] of Object.entries(command)) {
+    if (key === "type" || value === void 0) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function eventsForCommands(state, commands, context) {
+  const issues = [];
+  const events = [];
+  const reject = (index, code, message) => {
+    issues.push({ index, code, message });
+  };
+  if (state.status !== "RUNNING" && commands.length > 0)
+    return {
+      ok: false,
+      cause: "INVALID_REQUEST",
+      issues: [{ index: 0, code: "run.closed", message: `The run is ${state.status}` }]
+    };
+  const activities = new Map(Object.entries(state.activities).map(([id, a]) => [id, a.status]));
+  const timers = new Map(Object.entries(state.timers).map(([id, t]) => [id, t.status]));
+  const children = new Set(Object.keys(state.children));
+  const externals = new Set(Object.keys(state.externals));
+  const sideEffects = new Set(Object.keys(state.sideEffects));
+  let unsupported = false;
+  commands.forEach((command, index) => {
+    if (!isWorkflowCommandEnabled(command, context.enabled)) {
+      unsupported = true;
+      reject(index, "commands.unsupported", `${command.type} is not supported in this release`);
+      return;
+    }
+    if (TERMINAL_COMMANDS.has(command.type) && index !== commands.length - 1)
+      reject(index, "commands.terminalNotLast", `${command.type} must be last`);
+    const base = { taskId: context.taskId };
+    switch (command.type) {
+      case "SCHEDULE_ACTIVITY":
+        if (activities.has(command.activityId))
+          reject(index, "activity.duplicate", `Activity "${command.activityId}" already exists`);
+        if (!isActivityNodeTypeAllowed(command.nodeType))
+          reject(
+            index,
+            "durable.activityTypeNotAllowed",
+            `${command.nodeType} cannot run as a durable activity`
+          );
+        activities.set(command.activityId, "SCHEDULED");
+        events.push({ ...base, type: "ACTIVITY_SCHEDULED", payload: payloadOf(command) });
+        break;
+      case "REQUEST_CANCEL_ACTIVITY": {
+        const status = activities.get(command.activityId);
+        if (status === void 0 || !OPEN_ACTIVITY.has(status))
+          reject(index, "activity.notOpen", `Activity "${command.activityId}" is not open`);
+        activities.set(command.activityId, "CANCEL_REQUESTED");
+        events.push({ ...base, type: "ACTIVITY_CANCEL_REQUESTED", payload: payloadOf(command) });
+        break;
+      }
+      case "START_TIMER":
+        if (timers.has(command.timerId))
+          reject(index, "timer.duplicate", `Timer "${command.timerId}" already exists`);
+        timers.set(command.timerId, "PENDING");
+        events.push({
+          ...base,
+          type: "TIMER_STARTED",
+          payload: {
+            ...payloadOf(command),
+            fireAt: new Date(context.nowMs + command.durationMs).toISOString()
+          }
+        });
+        break;
+      case "CANCEL_TIMER":
+        if (timers.get(command.timerId) !== "PENDING")
+          reject(index, "timer.notPending", `Timer "${command.timerId}" is not pending`);
+        timers.set(command.timerId, "CANCELLED");
+        events.push({ ...base, type: "TIMER_CANCELLED", payload: payloadOf(command) });
+        break;
+      case "START_CHILD_RUN":
+        if (children.has(command.childId))
+          reject(index, "child.duplicate", `Child "${command.childId}" already exists`);
+        children.add(command.childId);
+        events.push({ ...base, type: "CHILD_RUN_INITIATED", payload: payloadOf(command) });
+        break;
+      case "SIGNAL_RUN":
+      case "REQUEST_CANCEL_EXTERNAL_RUN":
+        if (externals.has(command.externalId))
+          reject(index, "external.duplicate", `"${command.externalId}" already exists`);
+        if ("childId" in command.target && !children.has(command.target.childId))
+          reject(index, "external.unknownChild", `Unknown child "${command.target.childId}"`);
+        externals.add(command.externalId);
+        events.push({
+          ...base,
+          type: command.type === "SIGNAL_RUN" ? "EXTERNAL_RUN_SIGNALED" : "EXTERNAL_RUN_CANCEL_REQUESTED",
+          payload: payloadOf(command)
+        });
+        break;
+      case "RECORD_SIDE_EFFECT":
+        if (sideEffects.has(command.sideEffectId))
+          reject(index, "sideEffect.duplicate", `"${command.sideEffectId}" is already recorded`);
+        sideEffects.add(command.sideEffectId);
+        events.push({ ...base, type: "SIDE_EFFECT_RECORDED", payload: payloadOf(command) });
+        break;
+      case "RECORD_MARKER":
+        events.push({ ...base, type: "MARKER_RECORDED", payload: payloadOf(command) });
+        break;
+      case "COMPLETE_WORKFLOW":
+        events.push({
+          ...base,
+          type: "WORKFLOW_COMPLETED",
+          payload: { output: command.output ?? null }
+        });
+        break;
+      case "FAIL_WORKFLOW":
+        events.push({ ...base, type: "WORKFLOW_FAILED", payload: payloadOf(command) });
+        break;
+      case "CANCEL_WORKFLOW":
+        events.push({ ...base, type: "WORKFLOW_CANCELLED", payload: {} });
+        break;
+      case "UPSERT_CONTEXT":
+        events.push({ ...base, type: "CONTEXT_UPSERTED", payload: payloadOf(command) });
+        break;
+      case "RECORD_LOCAL_ACTIVITY":
+        events.push({
+          ...base,
+          type: command.failure ? "LOCAL_ACTIVITY_FAILED" : "LOCAL_ACTIVITY_COMPLETED",
+          payload: payloadOf(command)
+        });
+        break;
+      case "CONTINUE_AS_NEW":
+        events.push({ ...base, type: "WORKFLOW_CONTINUED_AS_NEW", payload: payloadOf(command) });
+        break;
+    }
+  });
+  if (issues.length > 0)
+    return { ok: false, cause: unsupported ? "UNSUPPORTED_COMMAND" : "INVALID_REQUEST", issues };
+  return { ok: true, events };
+}
+function taskCompletedEvents(options) {
+  const extra = {};
+  if (options.buildId !== void 0) extra["buildId"] = options.buildId;
+  if (options.workerId !== void 0) extra["workerId"] = options.workerId;
+  const events = [];
+  if (options.transient)
+    events.push({
+      type: "WORKFLOW_TASK_STARTED",
+      taskId: options.taskId,
+      payload: {
+        taskId: options.taskId,
+        attempt: options.attempt,
+        startedAt: options.startedAt,
+        historyLength: options.historyLength,
+        ...extra
+      }
+    });
+  events.push({
+    type: "WORKFLOW_TASK_COMPLETED",
+    taskId: options.taskId,
+    payload: { taskId: options.taskId, ...extra }
+  });
+  return events;
+}
+function hasUnprocessedInput(history) {
+  return unseenInputs(history).length > 0;
+}
+
+// src/history/retry.ts
+var DEFAULT_ACTIVITY_RETRY = Object.freeze({
+  retryDelay: 1e3,
+  backoffMultiplier: 2,
+  maxDelay: 1e5
+});
+var FINAL_TIMEOUTS = /* @__PURE__ */ new Set(["SCHEDULE_TO_START", "SCHEDULE_TO_CLOSE"]);
+function computeRetryDelay(policy, attempt, failure) {
+  if (failure?.nonRetryable === true) return { retry: false, reason: "nonRetryable" };
+  if (failure?.timeoutType !== void 0 && FINAL_TIMEOUTS.has(failure.timeoutType))
+    return { retry: false, reason: "finalTimeout" };
+  if (failure?.type !== void 0 && policy.nonRetryableErrorTypes !== void 0 && policy.nonRetryableErrorTypes.includes(failure.type))
+    return { retry: false, reason: "typeDenied" };
+  if (failure !== void 0 && policy.retryOnErrorTypes !== void 0 && policy.retryOnErrorTypes.length > 0 && !policy.retryOnErrorTypes.includes(failure.errorType))
+    return { retry: false, reason: "errorTypeNotListed" };
+  if (policy.maxRetries !== void 0 && attempt > policy.maxRetries)
+    return { retry: false, reason: "maxRetries" };
+  if (failure?.nextRetryDelayMs !== void 0)
+    return { retry: true, delayMs: Math.max(0, Math.round(failure.nextRetryDelayMs)) };
+  const base = Math.max(0, policy.retryDelay);
+  const multiplier = policy.backoffMultiplier ?? 2;
+  const cap = policy.maxDelay ?? base * 100;
+  const exponent = Math.max(0, attempt - 1);
+  const delay = Math.min(base * Math.pow(multiplier, exponent), cap);
+  return { retry: true, delayMs: Math.round(Number.isFinite(delay) ? delay : cap) };
+}
+function explicitRetryPolicy(policy) {
+  const retryDelay = policy?.retryDelay ?? DEFAULT_ACTIVITY_RETRY.retryDelay;
+  const out = {
+    retryDelay,
+    backoffMultiplier: policy?.backoffMultiplier ?? DEFAULT_ACTIVITY_RETRY.backoffMultiplier ?? 2,
+    maxDelay: policy?.maxDelay ?? (policy?.retryDelay === void 0 ? 1e5 : Math.max(retryDelay, retryDelay * 100))
+  };
+  if (policy?.maxRetries !== void 0) out.maxRetries = policy.maxRetries;
+  if (policy?.retryOnErrorTypes !== void 0)
+    out.retryOnErrorTypes = [...policy.retryOnErrorTypes];
+  if (policy?.nonRetryableErrorTypes !== void 0)
+    out.nonRetryableErrorTypes = [...policy.nonRetryableErrorTypes];
+  return out;
+}
+
+// src/history/defaults.ts
+function codeWorkflowParentClosePolicy(state) {
+  const policy = state.parentClosePolicy;
+  if (policy === "TERMINATE" || policy === "ABANDON" || policy === "REQUEST_CANCEL") return policy;
+  return state.waitForCompletion === false ? "ABANDON" : "TERMINATE";
+}
+var CHILD_DEFAULT_PARENT_CLOSE_POLICY = Object.freeze({ child: "TERMINATE", startChild: "ABANDON" });
+var CHILD_DEFAULT_CANCELLATION_TYPE = "WAIT_CANCELLATION_COMPLETED";
+
+export { CHILD_DEFAULT_CANCELLATION_TYPE, CHILD_DEFAULT_PARENT_CLOSE_POLICY, DEFAULT_ACTIVITY_RETRY, HistoryStateError, applyEvent, codeWorkflowParentClosePolicy, computeRetryDelay, eventsForCommands, explicitRetryPolicy, hasUnprocessedInput, initialRunState, isActivityOpen, isChildOpen, isCommandEnabled, isWorkflowCommandEnabled, pendingCounts, projectRunState, splitActivations, taskCompletedEvents, unseenInputs, utf8Bytes };

package/dist/{chunk-SS4LT2IP.js → chunk-BD7ZPG53.js}

@@ -1,6 +1,6 @@
 import { autoLayout } from './chunk-5LUIDMF4.js';
-import { sha256Tagged, canonicalJson } from './chunk-X4HKU3MX.js';
-import { isRecord, cloneJson, deepEqual } from './chunk-REV7ZOA4.js';
+import { sha256Tagged, canonicalJson } from './chunk-E2VK7J2C.js';
+import { isRecord, cloneJson, deepEqual, setOwn } from './chunk-PMCM2OH4.js';
 
 // src/ir/node-types.ts
 var EXECUTOR_INTERNAL_TYPES = /* @__PURE__ */ new Set([
@@ -97,16 +97,11 @@ function normalizeOperation(node, data) {
   if (!isNonEmptyString(node["operation_name"]) && isNonEmptyString(data["operation_name"])) {
     node["operation_name"] = data["operation_name"];
   }
-  if (data["operation_name"] !== void 0 && deepEqual(data["operation_name"], node["operation_name"])) {
-    delete data["operation_name"];
-  }
 }
 function normalizeVersion(node, data, merged) {
   if (merged) return;
   const effective = firstTruthy(data["version"], node["version"]);
   if (typeof effective === "string") node["version"] = effective;
-  if (data["version"] !== void 0 && deepEqual(data["version"], node["version"]))
-    delete data["version"];
   if (data["nodeVersion"] !== void 0 && deepEqual(data["nodeVersion"], node["version"])) {
     delete data["nodeVersion"];
   }
@@ -114,7 +109,7 @@ function normalizeVersion(node, data, merged) {
 function normalizeExternalState(node, data) {
   const args = isRecord(node["args"]) ? node["args"] : void 0;
   const dataArgs = isRecord(data["args"]) ? data["args"] : void 0;
-  const effective = firstTruthy(args?.["state"], dataArgs?.["state"], data["state"]);
+  const effective = firstTruthy(args?.["state"], dataArgs?.["state"]);
   if (effective !== void 0 && args?.["state"] === void 0) {
     const nextArgs = args ?? {};
     nextArgs["state"] = effective;
@@ -124,7 +119,6 @@ function normalizeExternalState(node, data) {
   if (dataArgs && dataArgs["state"] !== void 0 && deepEqual(dataArgs["state"], rootState)) {
     delete dataArgs["state"];
   }
-  if (data["state"] !== void 0 && deepEqual(data["state"], rootState)) delete data["state"];
 }
 function normalizeMergedState(node, data) {
   const args = isRecord(node["args"]) ? node["args"] : {};
@@ -163,6 +157,7 @@ function normalizeErrorConfig(node, data) {
   const dataState = isRecord(dataArgs?.["state"]) ? dataArgs["state"] : void 0;
   const effective = node["errorConfig"] ?? data["errorConfig"] ?? dataState?.["errorConfig"];
   if (effective !== void 0 && effective !== null) node["errorConfig"] = effective;
+  else if (node["errorConfig"] === null) delete node["errorConfig"];
   if (data["errorConfig"] !== void 0 && deepEqual(data["errorConfig"], node["errorConfig"])) {
     delete data["errorConfig"];
   }
@@ -173,7 +168,7 @@ function normalizeExecutionSettings(node, data) {
   if (!root && !mirror) return;
   const merged = { ...root };
   for (const [key, value] of Object.entries(mirror ?? {}))
-    if (!Object.hasOwn(merged, key)) merged[key] = value;
+    if (!Object.hasOwn(merged, key)) setOwn(merged, key, value);
   if (root?.["executeOnce"] === true || mirror?.["executeOnce"] === true)
     merged["executeOnce"] = true;
   if (mirror && Object.hasOwn(mirror, "runOn")) {