browser-pilot 0.0.16 → 0.0.17

package/dist/{chunk-V3VLBQAM.mjs → chunk-ZDODXEBD.mjs}

@@ -2,6 +2,333 @@ import {
   CDPError
 } from "./chunk-JXAUPHZM.mjs";
 
+// src/utils/strings.ts
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readStringOr(value, fallback = "") {
+  return readString(value) ?? fallback;
+}
+function formatConsoleArg(entry) {
+  return readString(entry["value"]) ?? readString(entry["description"]) ?? "";
+}
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const withWildcards = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${withWildcards}$`);
+}
+
+// src/actions/conditions.ts
+var NetworkResponseTracker = class {
+  responses = [];
+  listening = false;
+  handler = null;
+  start(cdp) {
+    if (this.listening) return;
+    this.listening = true;
+    this.handler = (params) => {
+      const response = params["response"];
+      if (response) {
+        this.responses.push({ url: response.url, status: response.status });
+      }
+    };
+    cdp.on("Network.responseReceived", this.handler);
+  }
+  stop(cdp) {
+    if (this.handler) {
+      cdp.off("Network.responseReceived", this.handler);
+      this.handler = null;
+    }
+    this.listening = false;
+  }
+  getResponses() {
+    return this.responses;
+  }
+  reset() {
+    this.responses = [];
+  }
+};
+async function captureStateSignature(page) {
+  try {
+    const url = await page.url();
+    const text = await page.text();
+    const truncated = text.slice(0, 2e3);
+    return `${url}|${simpleHash(truncated)}`;
+  } catch {
+    return "";
+  }
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char | 0;
+  }
+  return hash.toString(36);
+}
+async function evaluateCondition(condition, page, context = {}) {
+  switch (condition.kind) {
+    case "urlMatches": {
+      try {
+        const currentUrl = await page.url();
+        const regex = globToRegex(condition.pattern);
+        const matched = regex.test(currentUrl);
+        return {
+          condition,
+          matched,
+          detail: matched ? `URL "${currentUrl}" matches "${condition.pattern}"` : `URL "${currentUrl}" does not match "${condition.pattern}"`
+        };
+      } catch {
+        return { condition, matched: false, detail: "Failed to get current URL" };
+      }
+    }
+    case "elementVisible": {
+      try {
+        const selectors = Array.isArray(condition.selector) ? condition.selector : [condition.selector];
+        for (const sel of selectors) {
+          const visible = await page.waitFor(sel, {
+            timeout: 2e3,
+            optional: true,
+            state: "visible"
+          });
+          if (visible) {
+            return { condition, matched: true, detail: `Element "${sel}" is visible` };
+          }
+        }
+        return { condition, matched: false, detail: "No matching visible element found" };
+      } catch {
+        return { condition, matched: false, detail: "Visibility check failed" };
+      }
+    }
+    case "elementHidden": {
+      try {
+        const selectors = Array.isArray(condition.selector) ? condition.selector : [condition.selector];
+        for (const sel of selectors) {
+          const visible = await page.waitFor(sel, {
+            timeout: 500,
+            optional: true,
+            state: "visible"
+          });
+          if (visible) {
+            return { condition, matched: false, detail: `Element "${sel}" is still visible` };
+          }
+        }
+        return { condition, matched: true, detail: "Element is hidden or not found" };
+      } catch {
+        return { condition, matched: true, detail: "Element is hidden (check threw)" };
+      }
+    }
+    case "textAppears": {
+      try {
+        const selector = Array.isArray(condition.selector) ? condition.selector[0] : condition.selector;
+        const text = await page.text(selector);
+        const matched = text.includes(condition.text);
+        return {
+          condition,
+          matched,
+          detail: matched ? `Text "${condition.text}" found` : `Text "${condition.text}" not found in page content`
+        };
+      } catch {
+        return { condition, matched: false, detail: "Failed to get page text" };
+      }
+    }
+    case "textChanges": {
+      try {
+        const selector = Array.isArray(condition.selector) ? condition.selector[0] : condition.selector;
+        const text = await page.text(selector);
+        if (condition.to !== void 0) {
+          const matched = text.includes(condition.to);
+          return {
+            condition,
+            matched,
+            detail: matched ? `Text changed to include "${condition.to}"` : `Text does not include "${condition.to}"`
+          };
+        }
+        return { condition, matched: true, detail: "textChanges without `to` defaults to true" };
+      } catch {
+        return { condition, matched: false, detail: "Failed to get text for change detection" };
+      }
+    }
+    case "networkResponse": {
+      const tracker = context.networkTracker;
+      if (!tracker) {
+        return { condition, matched: false, detail: "No network tracker active" };
+      }
+      const regex = globToRegex(condition.urlPattern);
+      const responses = tracker.getResponses();
+      for (const resp of responses) {
+        if (regex.test(resp.url)) {
+          if (condition.status !== void 0 && resp.status !== condition.status) {
+            continue;
+          }
+          return {
+            condition,
+            matched: true,
+            detail: `Network response ${resp.url} (${resp.status}) matches pattern "${condition.urlPattern}"`
+          };
+        }
+      }
+      return {
+        condition,
+        matched: false,
+        detail: `No network response matching "${condition.urlPattern}" (saw ${responses.length} responses)`
+      };
+    }
+    case "stateSignatureChanges": {
+      if (!context.beforeSignature) {
+        return { condition, matched: false, detail: "No before-signature captured" };
+      }
+      const afterSignature = await captureStateSignature(page);
+      const matched = afterSignature !== context.beforeSignature;
+      return {
+        condition,
+        matched,
+        detail: matched ? "Page state changed" : "Page state unchanged"
+      };
+    }
+    default: {
+      const _exhaustive = condition;
+      return { condition: _exhaustive, matched: false, detail: "Unknown condition kind" };
+    }
+  }
+}
+async function evaluateOutcome(page, options) {
+  const {
+    expectAny,
+    expectAll,
+    failIf,
+    dangerous = false,
+    networkTracker,
+    beforeSignature
+  } = options;
+  const allMatched = [];
+  const context = { networkTracker, beforeSignature };
+  if (failIf && failIf.length > 0) {
+    for (const condition of failIf) {
+      const result = await evaluateCondition(condition, page, context);
+      allMatched.push(result);
+      if (result.matched) {
+        return {
+          outcomeStatus: "failed",
+          matchedConditions: allMatched,
+          retrySafe: !dangerous
+        };
+      }
+    }
+  }
+  if (expectAll && expectAll.length > 0) {
+    let allPassed = true;
+    for (const condition of expectAll) {
+      const result = await evaluateCondition(condition, page, context);
+      allMatched.push(result);
+      if (!result.matched) {
+        allPassed = false;
+      }
+    }
+    if (!allPassed) {
+      const status = dangerous ? "unsafe_to_retry" : "ambiguous";
+      return {
+        outcomeStatus: status,
+        matchedConditions: allMatched,
+        retrySafe: !dangerous
+      };
+    }
+    if (!expectAny || expectAny.length === 0) {
+      return {
+        outcomeStatus: "success",
+        matchedConditions: allMatched,
+        retrySafe: true
+      };
+    }
+  }
+  if (expectAny && expectAny.length > 0) {
+    let anyPassed = false;
+    for (const condition of expectAny) {
+      const result = await evaluateCondition(condition, page, context);
+      allMatched.push(result);
+      if (result.matched) {
+        anyPassed = true;
+      }
+    }
+    if (anyPassed) {
+      return {
+        outcomeStatus: "success",
+        matchedConditions: allMatched,
+        retrySafe: true
+      };
+    }
+    const status = dangerous ? "unsafe_to_retry" : "ambiguous";
+    return {
+      outcomeStatus: status,
+      matchedConditions: allMatched,
+      retrySafe: !dangerous
+    };
+  }
+  return {
+    outcomeStatus: "success",
+    matchedConditions: allMatched,
+    retrySafe: true
+  };
+}
+
+// src/actions/combinators.ts
+async function conditionAny(conditions, page, context) {
+  const results = [];
+  let winnerIndex;
+  for (let i = 0; i < conditions.length; i++) {
+    const result = await evaluateCondition(conditions[i], page, context);
+    results.push(result);
+    if (result.matched && winnerIndex === void 0) {
+      winnerIndex = i;
+    }
+  }
+  return {
+    matched: winnerIndex !== void 0,
+    matchedConditions: results,
+    winnerIndex
+  };
+}
+async function conditionAll(conditions, page, context) {
+  const results = [];
+  let allMatched = true;
+  for (const condition of conditions) {
+    const result = await evaluateCondition(condition, page, context);
+    results.push(result);
+    if (!result.matched) allMatched = false;
+  }
+  return {
+    matched: allMatched,
+    matchedConditions: results
+  };
+}
+async function conditionNot(condition, page, context) {
+  const result = await evaluateCondition(condition, page, context);
+  return {
+    matched: !result.matched,
+    matchedConditions: [
+      {
+        condition: result.condition,
+        matched: !result.matched,
+        detail: result.matched ? `NOT: condition was true (inverted to false): ${result.detail}` : `NOT: condition was false (inverted to true): ${result.detail}`
+      }
+    ]
+  };
+}
+async function conditionRace(conditions, page, options = {}) {
+  const { timeout = 1e4, pollInterval = 200, networkTracker, beforeSignature } = options;
+  const context = { networkTracker, beforeSignature };
+  const startTime = Date.now();
+  const deadline = startTime + timeout;
+  const immediate = await conditionAny(conditions, page, context);
+  if (immediate.matched) return immediate;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    const result = await conditionAny(conditions, page, context);
+    if (result.matched) return result;
+  }
+  return await conditionAny(conditions, page, context);
+}
+
 // src/actions/executor.ts
 import * as fs from "fs";
 import { join } from "path";
@@ -1449,13 +1776,6 @@ var TRACE_SCRIPT = `
 })();
 `;
 
-// src/trace/live.ts
-function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  const withWildcards = escaped.replace(/\*/g, ".*");
-  return new RegExp(`^${withWildcards}$`);
-}
-
 // src/actions/executor.ts
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_RECORDING_SKIP_ACTIONS = [
@@ -1465,15 +1785,6 @@ var DEFAULT_RECORDING_SKIP_ACTIONS = [
   "text",
   "screenshot"
 ];
-function readString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function readStringOr(value, fallback = "") {
-  return readString(value) ?? fallback;
-}
-function formatConsoleArg(entry) {
-  return readString(entry["value"]) ?? readString(entry["description"]) ?? "";
-}
 function loadExistingRecording(manifestPath) {
   try {
     const raw = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
@@ -1587,6 +1898,25 @@ function getSuggestion(reason) {
     }
   }
 }
+function hasOutcomeConditions(step) {
+  return step.expectAny !== void 0 && step.expectAny.length > 0 || step.expectAll !== void 0 && step.expectAll.length > 0 || step.failIf !== void 0 && step.failIf.length > 0;
+}
+function needsNetworkTracking(step) {
+  const allConditions = [
+    ...step.expectAny ?? [],
+    ...step.expectAll ?? [],
+    ...step.failIf ?? []
+  ];
+  return allConditions.some((c) => c.kind === "networkResponse");
+}
+function needsStateSignature(step) {
+  const allConditions = [
+    ...step.expectAny ?? [],
+    ...step.expectAll ?? [],
+    ...step.failIf ?? []
+  ];
+  return allConditions.some((c) => c.kind === "stateSignatureChanges");
+}
 var BatchExecutor = class {
   page;
   constructor(page) {
@@ -1632,9 +1962,25 @@ var BatchExecutor = class {
           })
         );
       }
+      const hasOutcome = hasOutcomeConditions(step);
+      let networkTracker;
+      let beforeSignature;
+      if (hasOutcome) {
+        if (needsNetworkTracking(step)) {
+          networkTracker = new NetworkResponseTracker();
+          networkTracker.start(this.page.cdpClient);
+        }
+        if (needsStateSignature(step)) {
+          beforeSignature = await captureStateSignature(this.page);
+        }
+      }
       for (let attempt = 0; attempt < maxAttempts; attempt++) {
         if (attempt > 0) {
           await new Promise((resolve) => setTimeout(resolve, retryDelay));
+          if (networkTracker) networkTracker.reset();
+          if (hasOutcome && needsStateSignature(step)) {
+            beforeSignature = await captureStateSignature(this.page);
+          }
         }
         try {
           this.page.resetLastActionPosition();
@@ -1652,6 +1998,28 @@ var BatchExecutor = class {
             coordinates: this.page.getLastActionCoordinates() ?? void 0,
             boundingBox: this.page.getLastActionBoundingBox() ?? void 0
           };
+          if (hasOutcome) {
+            if (networkTracker) networkTracker.stop(this.page.cdpClient);
+            const outcome = await evaluateOutcome(this.page, {
+              expectAny: step.expectAny,
+              expectAll: step.expectAll,
+              failIf: step.failIf,
+              dangerous: step.dangerous,
+              networkTracker,
+              beforeSignature
+            });
+            stepResult.outcomeStatus = outcome.outcomeStatus;
+            stepResult.matchedConditions = outcome.matchedConditions;
+            stepResult.retrySafe = outcome.retrySafe;
+            if (outcome.outcomeStatus !== "success") {
+              stepResult.success = false;
+              stepResult.error = `Outcome: ${outcome.outcomeStatus}`;
+              const failedDetails = outcome.matchedConditions.filter((mc) => outcome.outcomeStatus === "failed" ? mc.matched : !mc.matched).map((mc) => mc.detail).filter(Boolean);
+              if (failedDetails.length > 0) {
+                stepResult.suggestion = failedDetails.join("; ");
+              }
+            }
+          }
           if (recording && !recording.skipActions.has(step.action)) {
             await this.captureRecordingFrame(step, stepResult, recording);
           }
@@ -1661,13 +2029,14 @@ var BatchExecutor = class {
                 traceId: createTraceId("action"),
                 elapsedMs: Date.now() - startTime,
                 channel: "action",
-                event: "action.succeeded",
-                summary: `${step.action} succeeded`,
+                event: stepResult.success ? "action.succeeded" : "action.outcome_failed",
+                summary: stepResult.success ? `${step.action} succeeded` : `${step.action} outcome: ${stepResult.outcomeStatus}`,
                 data: {
                   action: step.action,
                   selector: step.selector ?? null,
                   selectorUsed: result.selectorUsed ?? null,
-                  durationMs: Date.now() - stepStart
+                  durationMs: Date.now() - stepStart,
+                  outcomeStatus: stepResult.outcomeStatus ?? null
                 },
                 actionId: `action-${i + 1}`,
                 stepIndex: i,
@@ -1677,6 +2046,18 @@ var BatchExecutor = class {
               })
             );
           }
+          if (hasOutcome && !stepResult.success) {
+            if (step.dangerous) {
+              results.push(stepResult);
+              break;
+            }
+            if (attempt < maxAttempts - 1) {
+              lastError = new Error(stepResult.error ?? "Outcome failed");
+              continue;
+            }
+            results.push(stepResult);
+            break;
+          }
           results.push(stepResult);
           succeeded = true;
           break;
@@ -1684,59 +2065,63 @@ var BatchExecutor = class {
           lastError = error instanceof Error ? error : new Error(String(error));
         }
       }
+      if (networkTracker) networkTracker.stop(this.page.cdpClient);
       if (!succeeded) {
-        const errorMessage = lastError?.message ?? "Unknown error";
-        let hints = lastError instanceof ElementNotFoundError ? lastError.hints : void 0;
-        const { reason, coveringElement } = classifyFailure(lastError);
-        if (step.selector && !step.optional && ["missing", "hidden", "covered", "disabled", "detached", "replaced"].includes(reason)) {
-          try {
-            const selectors = Array.isArray(step.selector) ? step.selector : [step.selector];
-            const autoHints = await generateHints(this.page, selectors, step.action, 3);
-            if (autoHints.length > 0) {
-              hints = autoHints;
+        const resultAlreadyPushed = results.length > 0 && results[results.length - 1].index === i;
+        if (!resultAlreadyPushed) {
+          const errorMessage = lastError?.message ?? "Unknown error";
+          let hints = lastError instanceof ElementNotFoundError ? lastError.hints : void 0;
+          const { reason, coveringElement } = classifyFailure(lastError);
+          if (step.selector && !step.optional && ["missing", "hidden", "covered", "disabled", "detached", "replaced"].includes(reason)) {
+            try {
+              const selectors = Array.isArray(step.selector) ? step.selector : [step.selector];
+              const autoHints = await generateHints(this.page, selectors, step.action, 3);
+              if (autoHints.length > 0) {
+                hints = autoHints;
+              }
+            } catch {
             }
-          } catch {
           }
+          const failedResult = {
+            index: i,
+            action: step.action,
+            selector: step.selector,
+            success: false,
+            durationMs: Date.now() - stepStart,
+            error: errorMessage,
+            hints,
+            failureReason: reason,
+            coveringElement,
+            suggestion: getSuggestion(reason),
+            timestamp: Date.now()
+          };
+          if (recording && !recording.skipActions.has(step.action)) {
+            await this.captureRecordingFrame(step, failedResult, recording);
+          }
+          if (recording) {
+            recording.traceEvents.push(
+              normalizeTraceEvent({
+                traceId: createTraceId("action"),
+                elapsedMs: Date.now() - startTime,
+                channel: "action",
+                event: "action.failed",
+                severity: "error",
+                summary: `${step.action} failed: ${errorMessage}`,
+                data: {
+                  action: step.action,
+                  selector: step.selector ?? null,
+                  error: errorMessage,
+                  reason
+                },
+                actionId: `action-${i + 1}`,
+                stepIndex: i,
+                selector: step.selector,
+                url: step.url
+              })
+            );
+          }
+          results.push(failedResult);
         }
-        const failedResult = {
-          index: i,
-          action: step.action,
-          selector: step.selector,
-          success: false,
-          durationMs: Date.now() - stepStart,
-          error: errorMessage,
-          hints,
-          failureReason: reason,
-          coveringElement,
-          suggestion: getSuggestion(reason),
-          timestamp: Date.now()
-        };
-        if (recording && !recording.skipActions.has(step.action)) {
-          await this.captureRecordingFrame(step, failedResult, recording);
-        }
-        if (recording) {
-          recording.traceEvents.push(
-            normalizeTraceEvent({
-              traceId: createTraceId("action"),
-              elapsedMs: Date.now() - startTime,
-              channel: "action",
-              event: "action.failed",
-              severity: "error",
-              summary: `${step.action} failed: ${errorMessage}`,
-              data: {
-                action: step.action,
-                selector: step.selector ?? null,
-                error: errorMessage,
-                reason
-              },
-              actionId: `action-${i + 1}`,
-              stepIndex: i,
-              selector: step.selector,
-              url: step.url
-            })
-          );
-        }
-        results.push(failedResult);
         if (onFail === "stop" && !step.optional) {
           stoppedAtIndex = i;
           break;
@@ -2047,6 +2432,14 @@ var BatchExecutor = class {
       case "forms": {
         return { value: await this.page.forms() };
       }
+      case "delta": {
+        const review = await this.page.review();
+        return { value: review };
+      }
+      case "review": {
+        const review = await this.page.review();
+        return { value: review };
+      }
       case "screenshot": {
         const data = await this.page.screenshot({
           format: step.format,
@@ -2197,6 +2590,35 @@ var BatchExecutor = class {
         const media = await this.assertMediaTrackLive(step.kind);
         return { value: media };
       }
+      case "chooseOption": {
+        const { chooseOption } = await import("./combobox-RAKBA2BW.mjs");
+        if (!step.value) throw new Error("chooseOption requires value");
+        const result = await chooseOption(this.page, {
+          trigger: step.trigger ?? step.selector ?? "",
+          listbox: step.option ? Array.isArray(step.option) ? step.option : [step.option] : void 0,
+          value: typeof step.value === "string" ? step.value : step.value[0] ?? "",
+          match: step.match,
+          timeout: step.timeout ?? timeout
+        });
+        if (!result.success) {
+          throw new Error(result.error ?? `chooseOption failed at ${result.failedAt}`);
+        }
+        return { value: result };
+      }
+      case "upload": {
+        const { uploadFiles } = await import("./upload-E6MCC2OF.mjs");
+        if (!step.selector) throw new Error("upload requires selector");
+        if (!step.files || step.files.length === 0) throw new Error("upload requires files");
+        const result = await uploadFiles(this.page, {
+          selector: step.selector,
+          files: step.files,
+          timeout: step.timeout ?? timeout
+        });
+        if (!result.accepted) {
+          throw new Error(result.error ?? "Upload was not accepted");
+        }
+        return { value: result };
+      }
       default: {
         const action = step.action;
         const aliases = {
@@ -2790,6 +3212,30 @@ var ACTION_RULES = {
       kind: { type: "string", enum: ["audio", "video"] }
     },
     optional: {}
+  },
+  delta: {
+    required: {},
+    optional: {}
+  },
+  review: {
+    required: {},
+    optional: {}
+  },
+  chooseOption: {
+    required: { value: { type: "string|string[]" } },
+    optional: {
+      trigger: { type: "string|string[]" },
+      selector: { type: "string|string[]" },
+      option: { type: "string|string[]" },
+      match: { type: "string", enum: ["exact", "contains", "startsWith"] }
+    }
+  },
+  upload: {
+    required: {
+      selector: { type: "string|string[]" },
+      files: { type: "string|string[]" }
+    },
+    optional: {}
   }
 };
 var VALID_ACTIONS = Object.keys(ACTION_RULES);
@@ -2829,7 +3275,12 @@ var KNOWN_STEP_FIELDS = /* @__PURE__ */ new Set([
   "name",
   "state",
   "kind",
-  "windowMs"
+  "windowMs",
+  "expectAny",
+  "expectAll",
+  "failIf",
+  "dangerous",
+  "files"
 ]);
 function resolveAction(name) {
   if (VALID_ACTIONS.includes(name)) {
@@ -3049,6 +3500,64 @@ function validateSteps(steps) {
         });
       }
     }
+    if ("dangerous" in obj && obj["dangerous"] !== void 0) {
+      if (typeof obj["dangerous"] !== "boolean") {
+        errors.push({
+          stepIndex: i,
+          field: "dangerous",
+          message: `"dangerous" expected boolean, got ${typeof obj["dangerous"]}.`
+        });
+      }
+    }
+    for (const condField of ["expectAny", "expectAll", "failIf"]) {
+      if (condField in obj && obj[condField] !== void 0) {
+        if (!Array.isArray(obj[condField])) {
+          errors.push({
+            stepIndex: i,
+            field: condField,
+            message: `"${condField}" expected array, got ${typeof obj[condField]}.`
+          });
+        } else {
+          const conditions = obj[condField];
+          for (let ci = 0; ci < conditions.length; ci++) {
+            const cond = conditions[ci];
+            if (!cond || typeof cond !== "object" || Array.isArray(cond)) {
+              errors.push({
+                stepIndex: i,
+                field: condField,
+                message: `"${condField}[${ci}]" must be a condition object.`
+              });
+              continue;
+            }
+            const condObj = cond;
+            if (!("kind" in condObj) || typeof condObj["kind"] !== "string") {
+              errors.push({
+                stepIndex: i,
+                field: condField,
+                message: `"${condField}[${ci}]" missing required "kind" field.`
+              });
+            } else {
+              const validKinds = [
+                "urlMatches",
+                "elementVisible",
+                "elementHidden",
+                "textAppears",
+                "textChanges",
+                "networkResponse",
+                "stateSignatureChanges"
+              ];
+              if (!validKinds.includes(condObj["kind"])) {
+                errors.push({
+                  stepIndex: i,
+                  field: condField,
+                  message: `"${condField}[${ci}].kind" must be one of: ${validKinds.join(", ")}. Got "${condObj["kind"]}".`
+                });
+              }
+            }
+          }
+        }
+      }
+    }
     if (action === "assertText") {
       if (!("expect" in obj) && !("value" in obj)) {
         errors.push({
@@ -3125,6 +3634,14 @@ function validateSteps(steps) {
 }
 
 export {
+  NetworkResponseTracker,
+  captureStateSignature,
+  evaluateCondition,
+  evaluateOutcome,
+  conditionAny,
+  conditionAll,
+  conditionNot,
+  conditionRace,
   ActionabilityError,
   ensureActionable,
   generateHints,