executeStep function test exported

export async function executeStep(
  payload: ExecuteStepPayload,
): Promise<StepResult> {
  const { step, resolvedValue, replayConfig } = payload;

  try {
    let result: StepResult;

    const selector =
      step.smartSelectors?.[0]?.value ?? step.selector ?? undefined;

    // Partition effects by timing (respecting per-kind defaults)
    const allEffects: StepEffect[] = step.effects ?? [];
    const byTiming = (t: "before" | "during" | "after") =>
      allEffects.filter(
        (e) => (e.timing ?? DEFAULT_EFFECT_TIMING[e.kind]) === t,
      );

    const beforeEffects = byTiming("before");
    const duringEffects = byTiming("during");
    const afterEffects = byTiming("after");

    // 1. "before" effects complete fully before the action starts
    if (beforeEffects.length) await applyStepEffects(beforeEffects, selector);

    // 2. "during" effects start concurrently with the action
    const duringPromise = duringEffects.length
      ? applyStepEffects(duringEffects, selector)
      : Promise.resolve();

    switch (step.action) {
      case "navigate":
        result = handleNavigate(step);
        break;
      case "fill":
        result = await handleFill(step, resolvedValue, replayConfig);
        break;
      case "click":
        result = handleClick(step);
        break;
      case "select":
        result = handleSelect(step);
        break;
      case "check":
        result = handleCheck(step, true);
        break;
      case "uncheck":
        result = handleCheck(step, false);
        break;
      case "clear":
        result = handleClear(step);
        break;
      case "wait":
        result = await handleWait(step);
        break;
      case "scroll":
        result = handleScroll(step);
        break;
      case "press-key":
        result = handlePressKey(step);
        break;
      case "assert":
        result = handleAssert(step);
        break;
      case "caption":
        result = await handleCaption(step);
        break;
      default:
        return { status: "skipped", reason: `Unknown action: ${step.action}` };
    }

    // Wait for "during" effects (they run in parallel with the action)
    await duringPromise;

    // Check if any "during" zoom effect was indefinite (duration 0 or Infinity)
    // If so, cancel it now that the action is complete
    const hasIndefiniteZoom = duringEffects.some(
      (e) => e.kind === "zoom" && (e.duration === 0 || e.duration === Infinity),
    );
    if (hasIndefiniteZoom) {
      cancelActiveZoom();
    }

    // 3. "after" effects run once the action has finished successfully
    if (result.status === "success" && afterEffects.length) {
      await applyStepEffects(afterEffects, selector);
    }

    return result;
  } catch (err) {
    const message = err instanceof Error ? err.message : String(err);
    log.warn(`Step ${step.id} failed:`, message);

    if (step.optional) {
      return { status: "skipped", reason: message };
    }
    return { status: "failed", error: message };
  }
}