@noego/wood 0.4.9 → 0.5.0

package/dist/automation/scenario.js

@@ -0,0 +1,660 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { executeAction } from "./actions_executor.js";
+import { automationError, automationOk } from "./errors.js";
+import { discoverTargets, selectTarget } from "./target_registry.js";
+import { awaitCondition } from "./waits_executor.js";
+const EXPECT_TIMEOUT_MS = 2e3;
+const ACTION_KINDS = [
+  "click",
+  "double_click",
+  "fill",
+  "type",
+  "press",
+  "select",
+  "toggle",
+  "scroll",
+  "back",
+  "forward",
+  "reload",
+  "wait"
+];
+const WAIT_KINDS = [
+  "route",
+  "url",
+  "target",
+  "visible",
+  "hidden",
+  "attached",
+  "detached",
+  "enabled",
+  "trace",
+  "scroll_edge",
+  "visual_stable",
+  "app_idle"
+];
+function valid(value) {
+  return { ok: true, value };
+}
+function invalid(message) {
+  return { ok: false, message };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireRecord(value, at) {
+  return isRecord(value) ? valid(value) : invalid(`${at} must be an object.`);
+}
+function requireString(value, at) {
+  return typeof value === "string" && value.length > 0 ? valid(value) : invalid(`${at} must be a non-empty string.`);
+}
+function optionalBoolean(value, at) {
+  return value === void 0 || typeof value === "boolean" ? valid(value) : invalid(`${at} must be a boolean when provided.`);
+}
+function optionalNumber(value, at) {
+  return value === void 0 || typeof value === "number" && Number.isFinite(value) ? valid(value) : invalid(`${at} must be a finite number when provided.`);
+}
+function stringRecord(value, at) {
+  if (value === void 0) return valid(void 0);
+  if (!isRecord(value)) return invalid(`${at} must be an object of string values.`);
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item !== "string") return invalid(`${at}.${key} must be a string.`);
+    result[key] = item;
+  }
+  return valid(result);
+}
+function parseLocator(value, at) {
+  const object = requireRecord(value, at);
+  if (!object.ok) return object;
+  const kind = object.value.kind;
+  if (kind === "role") {
+    const role = requireString(object.value.role, `${at}.role`);
+    if (!role.ok) return role;
+    if (object.value.name !== void 0 && typeof object.value.name !== "string") {
+      return invalid(`${at}.name must be a string when provided.`);
+    }
+    const exact2 = optionalBoolean(object.value.exact, `${at}.exact`);
+    if (!exact2.ok) return exact2;
+    return valid({
+      kind,
+      role: role.value,
+      ...object.value.name !== void 0 ? { name: object.value.name } : {},
+      ...exact2.value !== void 0 ? { exact: exact2.value } : {}
+    });
+  }
+  if (!["test_id", "label", "placeholder", "text", "css"].includes(String(kind))) {
+    return invalid(`${at}.kind must be one of test_id, role, label, placeholder, text, css.`);
+  }
+  const text = requireString(object.value.value, `${at}.value`);
+  if (!text.ok) return text;
+  if (kind === "css" || kind === "test_id") return valid({ kind, value: text.value });
+  const exact = optionalBoolean(object.value.exact, `${at}.exact`);
+  if (!exact.ok) return exact;
+  return valid({
+    kind,
+    value: text.value,
+    ...exact.value !== void 0 ? { exact: exact.value } : {}
+  });
+}
+function parseContainer(value, at) {
+  const object = requireRecord(value, at);
+  if (!object.ok) return object;
+  if (object.value.kind === "viewport") return valid({ kind: "viewport" });
+  if (object.value.kind !== "locator") {
+    return invalid(`${at}.kind must be viewport or locator.`);
+  }
+  const target = parseLocator(object.value.target, `${at}.target`);
+  return target.ok ? valid({ kind: "locator", target: target.value }) : target;
+}
+function parseScroll(value, at) {
+  const object = requireRecord(value, at);
+  if (!object.ok) return object;
+  const mode = object.value.mode;
+  if (mode === "into_view") {
+    const target2 = parseLocator(object.value.target, `${at}.target`);
+    if (!target2.ok) return target2;
+    const block = object.value.block;
+    if (block !== void 0 && !["start", "center", "end", "nearest"].includes(String(block))) {
+      return invalid(`${at}.block must be start, center, end, or nearest.`);
+    }
+    return valid({
+      mode,
+      target: target2.value,
+      ...block !== void 0 ? { block } : {}
+    });
+  }
+  if (!["wheel", "position", "until"].includes(String(mode))) {
+    return invalid(`${at}.mode must be wheel, position, into_view, or until.`);
+  }
+  const container = parseContainer(object.value.container, `${at}.container`);
+  if (!container.ok) return container;
+  if (mode === "wheel") {
+    const deltaX = optionalNumber(object.value.deltaX, `${at}.deltaX`);
+    if (!deltaX.ok) return deltaX;
+    const deltaY = optionalNumber(object.value.deltaY, `${at}.deltaY`);
+    if (!deltaY.ok) return deltaY;
+    return valid({
+      mode,
+      container: container.value,
+      ...deltaX.value !== void 0 ? { deltaX: deltaX.value } : {},
+      ...deltaY.value !== void 0 ? { deltaY: deltaY.value } : {}
+    });
+  }
+  if (mode === "position") {
+    const x = optionalNumber(object.value.x, `${at}.x`);
+    if (!x.ok) return x;
+    const y = optionalNumber(object.value.y, `${at}.y`);
+    if (!y.ok) return y;
+    const edge = object.value.edge;
+    if (edge !== void 0 && !["top", "bottom", "left", "right"].includes(String(edge))) {
+      return invalid(`${at}.edge must be top, bottom, left, or right.`);
+    }
+    return valid({
+      mode,
+      container: container.value,
+      ...x.value !== void 0 ? { x: x.value } : {},
+      ...y.value !== void 0 ? { y: y.value } : {},
+      ...edge !== void 0 ? { edge } : {}
+    });
+  }
+  const target = parseLocator(object.value.target, `${at}.target`);
+  if (!target.ok) return target;
+  const direction = object.value.direction;
+  if (!["up", "down", "left", "right"].includes(String(direction))) {
+    return invalid(`${at}.direction must be up, down, left, or right.`);
+  }
+  const stepPx = object.value.stepPx;
+  if (typeof stepPx !== "number" || !Number.isFinite(stepPx) || stepPx <= 0) {
+    return invalid(`${at}.stepPx must be a positive number.`);
+  }
+  const maxSteps = object.value.maxSteps;
+  if (!Number.isInteger(maxSteps) || maxSteps <= 0) {
+    return invalid(`${at}.maxSteps must be a positive integer.`);
+  }
+  return valid({
+    mode: "until",
+    container: container.value,
+    target: target.value,
+    direction,
+    stepPx,
+    maxSteps
+  });
+}
+function parseWait(value, at) {
+  const object = requireRecord(value, at);
+  if (!object.ok) return object;
+  const kind = object.value.kind;
+  if (!WAIT_KINDS.includes(kind)) {
+    return invalid(`${at}.kind must be one of ${WAIT_KINDS.join(", ")}.`);
+  }
+  if (kind === "route") {
+    const page = requireString(object.value.page, `${at}.page`);
+    if (!page.ok) return page;
+    const params = stringRecord(object.value.params, `${at}.params`);
+    if (!params.ok) return params;
+    const query = stringRecord(object.value.query, `${at}.query`);
+    if (!query.ok) return query;
+    return valid({
+      kind,
+      page: page.value,
+      ...params.value ? { params: params.value } : {},
+      ...query.value ? { query: query.value } : {}
+    });
+  }
+  if (kind === "url") {
+    const text = requireString(object.value.value, `${at}.value`);
+    if (!text.ok) return text;
+    const match = object.value.match;
+    if (match !== void 0 && !["exact", "glob", "regex"].includes(String(match))) {
+      return invalid(`${at}.match must be exact, glob, or regex.`);
+    }
+    return valid({
+      kind,
+      value: text.value,
+      ...match !== void 0 ? { match } : {}
+    });
+  }
+  if (kind === "target") {
+    const windowId = requireString(object.value.windowId, `${at}.windowId`);
+    if (!windowId.ok) return windowId;
+    const state = object.value.state;
+    if (!["present", "active", "closed"].includes(String(state))) {
+      return invalid(`${at}.state must be present, active, or closed.`);
+    }
+    return valid({ kind, windowId: windowId.value, state });
+  }
+  if (["visible", "hidden", "attached", "detached", "enabled"].includes(String(kind))) {
+    const target = parseLocator(object.value.target, `${at}.target`);
+    return target.ok ? valid({ kind, target: target.value }) : target;
+  }
+  if (kind === "trace") {
+    const type = requireString(object.value.type, `${at}.type`);
+    if (!type.ok) return type;
+    if (object.value.source !== void 0 && typeof object.value.source !== "string") {
+      return invalid(`${at}.source must be a string when provided.`);
+    }
+    if (object.value.count !== void 0 && (!Number.isInteger(object.value.count) || object.value.count < 1)) {
+      return invalid(`${at}.count must be a positive integer when provided.`);
+    }
+    return valid({
+      kind,
+      type: type.value,
+      ...object.value.source !== void 0 ? { source: object.value.source } : {},
+      ...object.value.count !== void 0 ? { count: object.value.count } : {}
+    });
+  }
+  if (kind === "scroll_edge") {
+    const container = parseContainer(object.value.container, `${at}.container`);
+    if (!container.ok) return container;
+    const edge = object.value.edge;
+    if (!["top", "bottom", "left", "right"].includes(String(edge))) {
+      return invalid(`${at}.edge must be top, bottom, left, or right.`);
+    }
+    return valid({ kind, container: container.value, edge });
+  }
+  if (kind === "visual_stable") {
+    const target = object.value.target === void 0 ? valid(void 0) : parseLocator(object.value.target, `${at}.target`);
+    if (!target.ok) return target;
+    if (object.value.frames !== void 0 && (!Number.isInteger(object.value.frames) || object.value.frames < 1)) {
+      return invalid(`${at}.frames must be a positive integer when provided.`);
+    }
+    return valid({
+      kind,
+      ...target.value ? { target: target.value } : {},
+      ...object.value.frames !== void 0 ? { frames: object.value.frames } : {}
+    });
+  }
+  return valid({ kind: "app_idle" });
+}
+function parseAction(value, at) {
+  const object = requireRecord(value, at);
+  if (!object.ok) return object;
+  const kind = object.value.kind;
+  if (!ACTION_KINDS.includes(kind)) {
+    return invalid(`${at}.kind must be one of ${ACTION_KINDS.join(", ")}.`);
+  }
+  if (kind === "back" || kind === "forward" || kind === "reload") return valid({ kind });
+  if (kind === "scroll") {
+    const command = parseScroll(object.value.command, `${at}.command`);
+    return command.ok ? valid({ kind, command: command.value }) : command;
+  }
+  if (kind === "wait") {
+    const condition = parseWait(object.value.condition, `${at}.condition`);
+    return condition.ok ? valid({ kind, condition: condition.value }) : condition;
+  }
+  if (kind === "press") {
+    let target2 = valid(void 0);
+    if (object.value.target !== void 0) target2 = parseLocator(object.value.target, `${at}.target`);
+    if (!target2.ok) return target2;
+    if (!Array.isArray(object.value.keys) || object.value.keys.length === 0) {
+      return invalid(`${at}.keys must be a non-empty array of strings.`);
+    }
+    for (let index = 0; index < object.value.keys.length; index += 1) {
+      if (typeof object.value.keys[index] !== "string" || object.value.keys[index].length === 0) {
+        return invalid(`${at}.keys[${index}] must be a non-empty string.`);
+      }
+    }
+    return valid({
+      kind,
+      ...target2.value ? { target: target2.value } : {},
+      keys: object.value.keys
+    });
+  }
+  const target = parseLocator(object.value.target, `${at}.target`);
+  if (!target.ok) return target;
+  if (kind === "click") {
+    const button = object.value.button;
+    if (button !== void 0 && button !== "left" && button !== "middle") {
+      return invalid(`${at}.button must be left or middle when provided.`);
+    }
+    return valid({ kind, target: target.value, ...button ? { button } : {} });
+  }
+  if (kind === "double_click") return valid({ kind, target: target.value });
+  if (kind === "fill" || kind === "type") {
+    if (typeof object.value.value !== "string") return invalid(`${at}.value must be a string.`);
+    if (kind === "type") {
+      const delayMs = optionalNumber(object.value.delayMs, `${at}.delayMs`);
+      if (!delayMs.ok) return delayMs;
+      return valid({
+        kind,
+        target: target.value,
+        value: object.value.value,
+        ...delayMs.value !== void 0 ? { delayMs: delayMs.value } : {}
+      });
+    }
+    return valid({ kind, target: target.value, value: object.value.value });
+  }
+  if (kind === "select") {
+    if (typeof object.value.option !== "string") return invalid(`${at}.option must be a string.`);
+    return valid({ kind, target: target.value, option: object.value.option });
+  }
+  if (typeof object.value.checked !== "boolean") return invalid(`${at}.checked must be a boolean.`);
+  return valid({ kind: "toggle", target: target.value, checked: object.value.checked });
+}
+function parseScenario(json) {
+  const root = requireRecord(json, "$");
+  if (!root.ok) return automationError("ACTION_FAILED", root.message);
+  if (root.value.version !== 1) {
+    return automationError("UNSUPPORTED", "$.version must equal 1.");
+  }
+  if (!Array.isArray(root.value.steps)) {
+    return automationError("ACTION_FAILED", "$.steps must be an array.");
+  }
+  if (root.value.steps.length === 0) {
+    return automationError("ACTION_FAILED", "$.steps must contain at least one step.");
+  }
+  let target;
+  if (root.value.target !== void 0) {
+    const object = requireRecord(root.value.target, "$.target");
+    if (!object.ok) return automationError("ACTION_FAILED", object.message);
+    if (object.value.windowId !== void 0 && (typeof object.value.windowId !== "string" || object.value.windowId.length === 0)) {
+      return automationError("ACTION_FAILED", "$.target.windowId must be a non-empty string when provided.");
+    }
+    target = object.value.windowId === void 0 ? {} : { windowId: object.value.windowId };
+  }
+  let evidence;
+  if (root.value.evidence !== void 0) {
+    const object = requireRecord(root.value.evidence, "$.evidence");
+    if (!object.ok) return automationError("ACTION_FAILED", object.message);
+    const screenshot = object.value.screenshot;
+    if (screenshot !== void 0 && !["on-failure", "always", "off"].includes(String(screenshot))) {
+      return automationError("ACTION_FAILED", "$.evidence.screenshot must be on-failure, always, or off.");
+    }
+    const consoleCapture = optionalBoolean(object.value.console, "$.evidence.console");
+    if (!consoleCapture.ok) return automationError("ACTION_FAILED", consoleCapture.message);
+    evidence = {
+      ...screenshot !== void 0 ? { screenshot } : {},
+      ...consoleCapture.value !== void 0 ? { console: consoleCapture.value } : {}
+    };
+  }
+  const steps = [];
+  for (let index = 0; index < root.value.steps.length; index += 1) {
+    const at = `$.steps[${index}]`;
+    const step = requireRecord(root.value.steps[index], at);
+    if (!step.ok) return automationError("ACTION_FAILED", step.message);
+    if (step.value.name !== void 0 && (typeof step.value.name !== "string" || step.value.name.length === 0)) {
+      return automationError("ACTION_FAILED", `${at}.name must be a non-empty string when provided.`);
+    }
+    const action = parseAction(step.value.action, `${at}.action`);
+    if (!action.ok) return automationError("ACTION_FAILED", action.message);
+    const wait = step.value.wait === void 0 ? valid(void 0) : parseWait(step.value.wait, `${at}.wait`);
+    if (!wait.ok) return automationError("ACTION_FAILED", wait.message);
+    if (step.value.expect !== void 0 && !Array.isArray(step.value.expect)) {
+      return automationError("ACTION_FAILED", `${at}.expect must be an array when provided.`);
+    }
+    const expect = [];
+    for (let expectIndex = 0; expectIndex < step.value.expect?.length; expectIndex += 1) {
+      const condition = parseWait(
+        step.value.expect[expectIndex],
+        `${at}.expect[${expectIndex}]`
+      );
+      if (!condition.ok) return automationError("ACTION_FAILED", condition.message);
+      expect.push(condition.value);
+    }
+    steps.push({
+      ...step.value.name !== void 0 ? { name: step.value.name } : {},
+      action: action.value,
+      ...wait.value ? { wait: wait.value } : {},
+      ...step.value.expect !== void 0 ? { expect } : {}
+    });
+  }
+  return automationOk({
+    version: 1,
+    ...target ? { target } : {},
+    ...evidence ? { evidence } : {},
+    steps
+  });
+}
+function safeEvidenceName(stepIndex, stepName, suffix) {
+  const name = (stepName ?? "step").replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "step";
+  return `${String(stepIndex + 1).padStart(3, "0")}-${name}-${suffix}.png`;
+}
+async function captureScreenshot(page, hooks, stepIndex, stepName, suffix) {
+  if (!hooks.evidenceDir) return void 0;
+  await mkdir(hooks.evidenceDir, { recursive: true });
+  const outputPath = path.join(hooks.evidenceDir, safeEvidenceName(stepIndex, stepName, suffix));
+  await page.screenshot({ path: outputPath });
+  return outputPath;
+}
+function attachConsoleCapture(page, entries) {
+  const add = (type, message) => {
+    entries.push({ type, message, occurredAt: (/* @__PURE__ */ new Date()).toISOString() });
+  };
+  const onConsole = (message) => {
+    if (message.type() === "error") add("console_error", message.text());
+  };
+  const onPageError = (error) => add("page_error", error.message);
+  const onRequestFailed = (request) => {
+    add("request_failed", `${request.method()} ${request.url()}: ${request.failure()?.errorText ?? "request failed"}`);
+  };
+  page.on("console", onConsole);
+  page.on("pageerror", onPageError);
+  page.on("requestfailed", onRequestFailed);
+  return () => {
+    page.off("console", onConsole);
+    page.off("pageerror", onPageError);
+    page.off("requestfailed", onRequestFailed);
+  };
+}
+function emit(hooks, event) {
+  hooks.onEvent(event);
+}
+function classifyThrown(error, message) {
+  return {
+    code: "ACTION_FAILED",
+    message,
+    details: { cause: error instanceof Error ? error.message : String(error) }
+  };
+}
+async function runScenarioOnPage(page, scenario, hooks) {
+  const started = /* @__PURE__ */ new Date();
+  const receipts = [];
+  const steps = [];
+  const evidence = [];
+  const consoleEntries = [];
+  const detach = scenario.evidence?.console === false ? () => void 0 : attachConsoleCapture(page, consoleEntries);
+  emit(hooks, { kind: "scenario_started", startedAt: started.toISOString(), stepCount: scenario.steps.length });
+  try {
+    for (let index = 0; index < scenario.steps.length; index += 1) {
+      const step = scenario.steps[index];
+      const stepStarted = /* @__PURE__ */ new Date();
+      const stepEvidence = [];
+      let receipt;
+      emit(hooks, {
+        kind: "step_started",
+        stepIndex: index,
+        ...step.name ? { stepName: step.name } : {},
+        startedAt: stepStarted.toISOString()
+      });
+      let failure;
+      const action = await executeAction(page, step.action, { wait: step.wait });
+      if (!action.ok) {
+        failure = action.error;
+      } else {
+        receipt = action.value;
+        for (let expectIndex = 0; expectIndex < (step.expect?.length ?? 0); expectIndex += 1) {
+          const condition = step.expect[expectIndex];
+          const result = await awaitCondition(page, condition, { timeoutMs: EXPECT_TIMEOUT_MS });
+          if (!result.ok) {
+            failure = {
+              ...result.error,
+              message: `Step expectation ${expectIndex + 1} (${condition.kind}) failed: ${result.error.message}`,
+              details: {
+                ...result.error.details,
+                condition,
+                expectIndex
+              }
+            };
+            break;
+          }
+        }
+      }
+      if (failure) {
+        if (scenario.evidence?.screenshot !== "off") {
+          try {
+            const screenshot = await captureScreenshot(page, hooks, index, step.name, "failure");
+            if (screenshot) {
+              stepEvidence.push(screenshot);
+              evidence.push(screenshot);
+            }
+          } catch (error) {
+            failure = {
+              ...failure,
+              details: {
+                ...failure.details,
+                screenshotError: error instanceof Error ? error.message : String(error)
+              }
+            };
+          }
+        }
+        const durationMs2 = Date.now() - stepStarted.getTime();
+        emit(hooks, {
+          kind: "step_failed",
+          stepIndex: index,
+          ...step.name ? { stepName: step.name } : {},
+          error: failure,
+          durationMs: durationMs2,
+          evidence: stepEvidence
+        });
+        const completed2 = /* @__PURE__ */ new Date();
+        emit(hooks, {
+          kind: "scenario_completed",
+          stepIndex: index,
+          ...step.name ? { stepName: step.name } : {},
+          ...receipt ? { receipt } : {},
+          error: failure,
+          startedAt: started.toISOString(),
+          completedAt: completed2.toISOString(),
+          durationMs: completed2.getTime() - started.getTime(),
+          success: false
+        });
+        return automationError(failure.code, failure.message, {
+          requiredAction: failure.requiredAction,
+          details: {
+            ...failure.details,
+            stepIndex: index,
+            ...step.name ? { stepName: step.name } : {},
+            receipts,
+            steps,
+            evidence,
+            console: consoleEntries
+          }
+        });
+      }
+      if (scenario.evidence?.screenshot === "always") {
+        try {
+          const screenshot = await captureScreenshot(page, hooks, index, step.name, "completed");
+          if (screenshot) {
+            stepEvidence.push(screenshot);
+            evidence.push(screenshot);
+          }
+        } catch (error) {
+          const screenshotFailure = classifyThrown(error, "Scenario evidence screenshot failed.");
+          emit(hooks, {
+            kind: "step_failed",
+            stepIndex: index,
+            ...step.name ? { stepName: step.name } : {},
+            error: screenshotFailure,
+            durationMs: Date.now() - stepStarted.getTime(),
+            evidence: stepEvidence
+          });
+          const completed2 = /* @__PURE__ */ new Date();
+          emit(hooks, {
+            kind: "scenario_completed",
+            stepIndex: index,
+            ...step.name ? { stepName: step.name } : {},
+            receipt,
+            error: screenshotFailure,
+            startedAt: started.toISOString(),
+            completedAt: completed2.toISOString(),
+            durationMs: completed2.getTime() - started.getTime(),
+            success: false
+          });
+          return automationError(screenshotFailure.code, screenshotFailure.message, {
+            details: {
+              ...screenshotFailure.details,
+              stepIndex: index,
+              receipts,
+              steps,
+              evidence,
+              console: consoleEntries
+            }
+          });
+        }
+      }
+      const durationMs = Date.now() - stepStarted.getTime();
+      receipts.push(receipt);
+      const stepReport = {
+        index,
+        ...step.name ? { name: step.name } : {},
+        startedAt: stepStarted.toISOString(),
+        durationMs,
+        receipt,
+        evidence: stepEvidence
+      };
+      steps.push(stepReport);
+      emit(hooks, {
+        kind: "step_completed",
+        stepIndex: index,
+        ...step.name ? { stepName: step.name } : {},
+        receipt,
+        durationMs,
+        evidence: stepEvidence
+      });
+    }
+    const completed = /* @__PURE__ */ new Date();
+    const report = {
+      startedAt: started.toISOString(),
+      completedAt: completed.toISOString(),
+      durationMs: completed.getTime() - started.getTime(),
+      success: true,
+      receipts,
+      steps,
+      evidence,
+      console: consoleEntries
+    };
+    const lastStep = scenario.steps.at(-1);
+    emit(hooks, {
+      kind: "scenario_completed",
+      ...lastStep ? {
+        stepIndex: scenario.steps.length - 1,
+        ...lastStep.name ? { stepName: lastStep.name } : {},
+        receipt: receipts.at(-1)
+      } : {},
+      startedAt: report.startedAt,
+      completedAt: report.completedAt,
+      durationMs: report.durationMs,
+      success: true
+    });
+    return automationOk(report);
+  } catch (error) {
+    const failure = classifyThrown(error, "Scenario runner failed unexpectedly.");
+    const completed = /* @__PURE__ */ new Date();
+    emit(hooks, {
+      kind: "scenario_completed",
+      error: failure,
+      startedAt: started.toISOString(),
+      completedAt: completed.toISOString(),
+      durationMs: completed.getTime() - started.getTime(),
+      success: false
+    });
+    return automationError(failure.code, failure.message, {
+      details: { ...failure.details, receipts, steps, evidence, console: consoleEntries }
+    });
+  } finally {
+    detach();
+  }
+}
+async function runScenario(connection, scenario, hooks) {
+  const entries = await discoverTargets(connection.browser);
+  const selected = selectTarget(entries, scenario.target?.windowId);
+  if (!selected.ok) return selected;
+  return runScenarioOnPage(selected.value.page, scenario, hooks);
+}
+export {
+  parseScenario,
+  runScenario,
+  runScenarioOnPage
+};
+//# sourceMappingURL=scenario.js.map