@startsimpli/funnels 0.1.2

package/dist/index.cjs

@@ -0,0 +1,4499 @@
+'use strict';
+
+var zustand = require('zustand');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var react$1 = require('@xyflow/react');
+require('@xyflow/react/dist/style.css');
+var core = require('@dnd-kit/core');
+var sortable = require('@dnd-kit/sortable');
+var utilities = require('@dnd-kit/utilities');
+
+// src/types/index.ts
+function isFunnel(value) {
+  const f = value;
+  return typeof f === "object" && f !== null && typeof f.id === "string" && typeof f.name === "string" && ["draft", "active", "paused", "archived"].includes(f.status) && Array.isArray(f.stages);
+}
+function isStage(value) {
+  const s = value;
+  return typeof s === "object" && s !== null && typeof s.id === "string" && typeof s.name === "string" && typeof s.order === "number" && ["AND", "OR"].includes(s.filter_logic) && Array.isArray(s.rules);
+}
+function isFilterRule(value) {
+  const r = value;
+  return typeof r === "object" && r !== null && typeof r.field_path === "string" && typeof r.operator === "string" && r.value !== void 0;
+}
+function isFunnelRun(value) {
+  const r = value;
+  return typeof r === "object" && r !== null && typeof r.id === "string" && typeof r.funnel_id === "string" && ["pending", "running", "completed", "failed", "cancelled"].includes(r.status);
+}
+function isFunnelResult(value) {
+  const r = value;
+  return typeof r === "object" && r !== null && r.entity !== void 0 && typeof r.matched === "boolean" && Array.isArray(r.accumulated_tags);
+}
+function isFieldDefinition(value) {
+  const f = value;
+  return typeof f === "object" && f !== null && typeof f.name === "string" && typeof f.label === "string" && typeof f.type === "string" && Array.isArray(f.operators);
+}
+function getValidOperators(fieldType) {
+  switch (fieldType) {
+    case "string":
+      return [
+        "eq",
+        "ne",
+        "contains",
+        "not_contains",
+        "startswith",
+        "endswith",
+        "matches",
+        "in",
+        "not_in",
+        "isnull",
+        "isnotnull"
+      ];
+    case "number":
+      return [
+        "eq",
+        "ne",
+        "gt",
+        "lt",
+        "gte",
+        "lte",
+        "in",
+        "not_in",
+        "isnull",
+        "isnotnull"
+      ];
+    case "boolean":
+      return ["eq", "ne", "is_true", "is_false", "isnull", "isnotnull"];
+    case "date":
+      return [
+        "eq",
+        "ne",
+        "gt",
+        "lt",
+        "gte",
+        "lte",
+        "isnull",
+        "isnotnull"
+      ];
+    case "array":
+      return [
+        "in",
+        "not_in",
+        "has_any",
+        "has_all",
+        "isnull",
+        "isnotnull"
+      ];
+    case "tag":
+      return ["has_tag", "not_has_tag"];
+    case "object":
+      return ["isnull", "isnotnull"];
+    case "any":
+    default:
+      return [
+        "eq",
+        "ne",
+        "gt",
+        "lt",
+        "gte",
+        "lte",
+        "contains",
+        "not_contains",
+        "startswith",
+        "endswith",
+        "in",
+        "not_in",
+        "isnull",
+        "isnotnull"
+      ];
+  }
+}
+function isValidOperator(operator, fieldType) {
+  const validOps = getValidOperators(fieldType);
+  return validOps.includes(operator);
+}
+function validateFilterRule(rule) {
+  const errors = [];
+  if (!rule.field_path) {
+    errors.push("field_path is required");
+  }
+  if (!rule.operator) {
+    errors.push("operator is required");
+  }
+  const nullOps = ["isnull", "isnotnull", "is_true", "is_false"];
+  if (!nullOps.includes(rule.operator) && rule.value === void 0) {
+    errors.push(`value is required for operator '${rule.operator}'`);
+  }
+  return errors;
+}
+function validateStage(stage) {
+  const errors = [];
+  if (!stage.name) {
+    errors.push("name is required");
+  }
+  if (typeof stage.order !== "number") {
+    errors.push("order must be a number");
+  }
+  if (!["AND", "OR"].includes(stage.filter_logic)) {
+    errors.push("filter_logic must be AND or OR");
+  }
+  if (!Array.isArray(stage.rules)) {
+    errors.push("rules must be an array");
+  } else {
+    stage.rules.forEach((rule, i) => {
+      const ruleErrors = validateFilterRule(rule);
+      ruleErrors.forEach((err) => errors.push(`rules[${i}]: ${err}`));
+    });
+  }
+  return errors;
+}
+function validateFunnel(funnel) {
+  const errors = [];
+  if (!funnel.name) {
+    errors.push("name is required");
+  }
+  if (!["draft", "active", "paused", "archived"].includes(funnel.status)) {
+    errors.push("status must be draft, active, paused, or archived");
+  }
+  if (!Array.isArray(funnel.stages)) {
+    errors.push("stages must be an array");
+  } else {
+    funnel.stages.forEach((stage, i) => {
+      const stageErrors = validateStage(stage);
+      stageErrors.forEach((err) => errors.push(`stages[${i}]: ${err}`));
+    });
+    const orders = funnel.stages.map((s) => s.order).sort((a, b) => a - b);
+    const expectedOrders = Array.from({ length: orders.length }, (_, i) => i);
+    if (JSON.stringify(orders) !== JSON.stringify(expectedOrders)) {
+      errors.push("stage orders must be sequential starting from 0");
+    }
+  }
+  return errors;
+}
+
+// src/core/field-resolver.ts
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function parseFieldPath(fieldPath) {
+  const segments = [];
+  let current = "";
+  let inBracket = false;
+  for (let i = 0; i < fieldPath.length; i++) {
+    const char = fieldPath[i];
+    if (char === "[") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+      inBracket = true;
+    } else if (char === "]") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+      inBracket = false;
+    } else if (char === "." && !inBracket) {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    segments.push(current);
+  }
+  return segments;
+}
+function resolveField(entity, fieldPath) {
+  if (entity == null) {
+    return void 0;
+  }
+  if (!fieldPath || fieldPath.trim() === "") {
+    return void 0;
+  }
+  const segments = parseFieldPath(fieldPath);
+  let current = entity;
+  for (const segment of segments) {
+    if (current == null) {
+      return void 0;
+    }
+    if (DANGEROUS_KEYS.has(segment)) {
+      return void 0;
+    }
+    if (typeof current === "object" && segment in current) {
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setField(entity, fieldPath, value) {
+  if (entity == null) {
+    throw new Error("Cannot set field on null or undefined entity");
+  }
+  if (!fieldPath || fieldPath.trim() === "") {
+    throw new Error("Field path cannot be empty");
+  }
+  const segments = parseFieldPath(fieldPath);
+  let current = entity;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = segments[i];
+    const nextSegment = segments[i + 1];
+    if (DANGEROUS_KEYS.has(segment)) {
+      throw new Error(`Dangerous field path segment: "${segment}"`);
+    }
+    if (!(segment in current)) {
+      const isNextArray = /^\d+$/.test(nextSegment);
+      current[segment] = isNextArray ? [] : {};
+    }
+    current = current[segment];
+  }
+  const lastSegment = segments[segments.length - 1];
+  if (DANGEROUS_KEYS.has(lastSegment)) {
+    throw new Error(`Dangerous field path segment: "${lastSegment}"`);
+  }
+  current[lastSegment] = value;
+}
+function hasField(entity, fieldPath) {
+  const value = resolveField(entity, fieldPath);
+  return value !== void 0;
+}
+function getFields(entity, fieldPaths) {
+  const result = {};
+  for (const path of fieldPaths) {
+    result[path] = resolveField(entity, path);
+  }
+  return result;
+}
+
+// src/core/operators.ts
+function applyOperator(operator, actual, expected) {
+  switch (operator) {
+    // ========================================================================
+    // Equality
+    // ========================================================================
+    case "eq":
+      return compareValues(actual, expected, (a, e) => a === e);
+    case "ne":
+      return compareValues(actual, expected, (a, e) => a !== e);
+    // ========================================================================
+    // Comparison (numbers, dates, strings)
+    // ========================================================================
+    case "gt":
+      return compareValues(actual, expected, (a, e) => a > e);
+    case "lt":
+      return compareValues(actual, expected, (a, e) => a < e);
+    case "gte":
+      return compareValues(actual, expected, (a, e) => a >= e);
+    case "lte":
+      return compareValues(actual, expected, (a, e) => a <= e);
+    // ========================================================================
+    // String operations (case-insensitive)
+    // ========================================================================
+    case "contains":
+      if (actual == null) return false;
+      if (expected == null) return false;
+      return String(actual).toLowerCase().includes(String(expected).toLowerCase());
+    case "not_contains":
+      if (actual == null) return true;
+      if (expected == null) return true;
+      return !String(actual).toLowerCase().includes(String(expected).toLowerCase());
+    case "startswith":
+      if (actual == null) return false;
+      if (expected == null) return false;
+      return String(actual).toLowerCase().startsWith(String(expected).toLowerCase());
+    case "endswith":
+      if (actual == null) return false;
+      if (expected == null) return false;
+      return String(actual).toLowerCase().endsWith(String(expected).toLowerCase());
+    case "matches":
+      if (actual == null) return false;
+      if (expected == null) return false;
+      try {
+        const regex = new RegExp(String(expected));
+        return regex.test(String(actual));
+      } catch {
+        return false;
+      }
+    // ========================================================================
+    // Array/Set operations
+    // ========================================================================
+    case "in":
+      if (!Array.isArray(expected)) return false;
+      return expected.some((item) => compareValues(actual, item, (a, e) => a === e));
+    case "not_in":
+      if (!Array.isArray(expected)) return true;
+      return !expected.some((item) => compareValues(actual, item, (a, e) => a === e));
+    case "has_any":
+      if (!Array.isArray(actual)) return false;
+      if (!Array.isArray(expected)) return false;
+      return expected.some(
+        (expectedItem) => actual.some((actualItem) => compareValues(actualItem, expectedItem, (a, e) => a === e))
+      );
+    case "has_all":
+      if (!Array.isArray(actual)) return false;
+      if (!Array.isArray(expected)) return false;
+      return expected.every(
+        (expectedItem) => actual.some((actualItem) => compareValues(actualItem, expectedItem, (a, e) => a === e))
+      );
+    // ========================================================================
+    // Null checks
+    // ========================================================================
+    case "isnull":
+      return actual === null || actual === void 0;
+    case "isnotnull":
+      return actual !== null && actual !== void 0;
+    // ========================================================================
+    // Tag operations (tags are arrays of strings)
+    // ========================================================================
+    case "has_tag":
+      if (!Array.isArray(actual)) return false;
+      if (expected == null) return false;
+      const expectedTag = String(expected).toLowerCase();
+      return actual.some((tag) => String(tag).toLowerCase() === expectedTag);
+    case "not_has_tag":
+      if (!Array.isArray(actual)) return true;
+      if (expected == null) return true;
+      const expectedTagNot = String(expected).toLowerCase();
+      return !actual.some((tag) => String(tag).toLowerCase() === expectedTagNot);
+    // ========================================================================
+    // Boolean
+    // ========================================================================
+    case "is_true":
+      return actual === true;
+    case "is_false":
+      return actual === false;
+    default:
+      throw new Error(`Unknown operator: ${operator}`);
+  }
+}
+function compareValues(actual, expected, compare) {
+  if (actual === null || actual === void 0) {
+    return expected === null || expected === void 0;
+  }
+  if (expected === null || expected === void 0) {
+    return false;
+  }
+  if (isDate(actual) && isDate(expected)) {
+    const actualTs = toTimestamp(actual);
+    const expectedTs = toTimestamp(expected);
+    if (actualTs === null || expectedTs === null) return false;
+    return compare(actualTs, expectedTs);
+  }
+  if (isDate(actual) || isDate(expected)) {
+    const actualTs = toTimestamp(actual);
+    const expectedTs = toTimestamp(expected);
+    if (actualTs === null || expectedTs === null) return false;
+    return compare(actualTs, expectedTs);
+  }
+  if (typeof actual === "number" && typeof expected === "number") {
+    return compare(actual, expected);
+  }
+  if (isNumeric(actual) && isNumeric(expected)) {
+    return compare(Number(actual), Number(expected));
+  }
+  return compare(actual, expected);
+}
+function isDate(value) {
+  if (value instanceof Date) return true;
+  if (typeof value !== "string") return false;
+  const datePattern = /^\d{4}-\d{2}-\d{2}|^\d{1,2}\/\d{1,2}\/\d{4}/;
+  return datePattern.test(value);
+}
+function toTimestamp(value) {
+  if (value instanceof Date) {
+    const ts = value.getTime();
+    return isNaN(ts) ? null : ts;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    const date = new Date(value);
+    const ts = date.getTime();
+    return isNaN(ts) ? null : ts;
+  }
+  return null;
+}
+function isNumeric(value) {
+  if (typeof value === "number") return !isNaN(value);
+  if (typeof value !== "string") return false;
+  return !isNaN(Number(value)) && value.trim() !== "";
+}
+
+// src/core/evaluator.ts
+function evaluateRule(entity, rule) {
+  const actualValue = resolveField(entity, rule.field_path);
+  const result = applyOperator(rule.operator, actualValue, rule.value);
+  return rule.negate ? !result : result;
+}
+function evaluateRuleWithResult(entity, rule) {
+  try {
+    const actualValue = resolveField(entity, rule.field_path);
+    const operatorResult = applyOperator(rule.operator, actualValue, rule.value);
+    const matched = rule.negate ? !operatorResult : operatorResult;
+    return {
+      field_path: rule.field_path,
+      operator: rule.operator,
+      value: rule.value,
+      actual_value: actualValue,
+      matched
+    };
+  } catch (error) {
+    return {
+      field_path: rule.field_path,
+      operator: rule.operator,
+      value: rule.value,
+      actual_value: void 0,
+      matched: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function evaluateRulesAND(entity, rules) {
+  if (!rules || rules.length === 0) return true;
+  return rules.every((rule) => evaluateRule(entity, rule));
+}
+function evaluateRulesOR(entity, rules) {
+  if (!rules || rules.length === 0) return true;
+  return rules.some((rule) => evaluateRule(entity, rule));
+}
+function evaluateRules(entity, rules, logic = "AND") {
+  return logic === "AND" ? evaluateRulesAND(entity, rules) : evaluateRulesOR(entity, rules);
+}
+function evaluateRulesWithResults(entity, rules, logic = "AND") {
+  const ruleResults = rules.map((rule) => evaluateRuleWithResult(entity, rule));
+  const matched = logic === "AND" ? ruleResults.every((r) => r.matched) : ruleResults.some((r) => r.matched);
+  return {
+    matched,
+    logic,
+    rule_results: ruleResults
+  };
+}
+function filterEntities(entities, rules, logic = "AND") {
+  if (!entities || entities.length === 0) return [];
+  if (!rules || rules.length === 0) return entities;
+  return entities.filter((entity) => evaluateRules(entity, rules, logic));
+}
+
+// src/core/engine.ts
+function evaluateRule2(_entity, _rule) {
+  throw new Error("Not implemented - BEAD: fund-your-startup-a0b8. evaluateRule must import from rule evaluator.");
+}
+var FunnelEngine = class {
+  /**
+   * Execute a funnel on a set of entities
+   *
+   * @param funnel - The funnel definition to execute
+   * @param entities - Input entities to process
+   * @returns ExecutionResult with matched/excluded entities and stats
+   */
+  execute(funnel, entities) {
+    const startTime = Date.now();
+    const results = entities.map((entity) => ({
+      entity,
+      matched: true,
+      // Start as matched, exclude as needed
+      accumulated_tags: [],
+      context: {},
+      stage_results: []
+    }));
+    const stageStats = {};
+    const errors = [];
+    const sortedStages = [...funnel.stages].sort((a, b) => a.order - b.order);
+    for (const stage of sortedStages) {
+      const stageStartTime = Date.now();
+      const inputEntities = results.filter((r) => r.matched && !r.excluded_at_stage);
+      const stats = {
+        stage_id: stage.id,
+        stage_name: stage.name,
+        input_count: inputEntities.length,
+        matched_count: 0,
+        not_matched_count: 0,
+        excluded_count: 0,
+        tagged_count: 0,
+        continued_count: 0,
+        error_count: 0
+      };
+      for (const result of inputEntities) {
+        try {
+          const stageResult = this.processStage(stage, result.entity);
+          result.stage_results.push(stageResult);
+          if (stageResult.matched) {
+            stats.matched_count++;
+          } else {
+            stats.not_matched_count++;
+          }
+          if (stageResult.tags_added && stageResult.tags_added.length > 0) {
+            result.accumulated_tags.push(...stageResult.tags_added);
+            stats.tagged_count++;
+          }
+          if (stageResult.context_added) {
+            result.context = { ...result.context, ...stageResult.context_added };
+          }
+          if (stageResult.excluded) {
+            result.matched = false;
+            result.excluded_at_stage = stage.id;
+            stats.excluded_count++;
+          } else if (stageResult.continued) {
+            stats.continued_count++;
+          }
+        } catch (error) {
+          stats.error_count++;
+          errors.push(`Stage ${stage.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      stats.duration_ms = Date.now() - stageStartTime;
+      stageStats[stage.id] = stats;
+    }
+    if (funnel.completion_tags && funnel.completion_tags.length > 0) {
+      for (const result of results) {
+        if (result.matched) {
+          result.accumulated_tags.push(...funnel.completion_tags);
+        }
+      }
+    }
+    const matched = results.filter((r) => r.matched);
+    const excluded = results.filter((r) => !r.matched);
+    const totalTagged = results.filter((r) => r.accumulated_tags.length > 0).length;
+    return {
+      matched,
+      excluded,
+      total_input: entities.length,
+      total_matched: matched.length,
+      total_excluded: excluded.length,
+      total_tagged: totalTagged,
+      stage_stats: stageStats,
+      duration_ms: Date.now() - startTime,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+  /**
+   * Process a single entity through a stage
+   *
+   * @param stage - The stage to process
+   * @param entity - The entity to evaluate
+   * @returns StageResult with match status and actions taken
+   */
+  processStage(stage, entity) {
+    const ruleResults = [];
+    let matched = false;
+    if (stage.custom_evaluator) {
+      try {
+        matched = stage.custom_evaluator(entity);
+      } catch (error) {
+        matched = false;
+      }
+    } else if (stage.rules.length === 0) {
+      matched = true;
+    } else {
+      for (const rule of stage.rules) {
+        const ruleResult = evaluateRule2();
+        ruleResults.push(ruleResult);
+      }
+      if (stage.filter_logic === "AND") {
+        matched = ruleResults.every((r) => r.matched);
+      } else {
+        matched = ruleResults.some((r) => r.matched);
+      }
+    }
+    let action;
+    let tagsAdded = [];
+    let contextAdded;
+    let excluded = false;
+    let continued = false;
+    if (matched) {
+      action = stage.match_action;
+      if (stage.match_tags && stage.match_tags.length > 0) {
+        tagsAdded = [...stage.match_tags];
+      }
+      if (stage.match_context) {
+        contextAdded = stage.match_context;
+      }
+      switch (stage.match_action) {
+        case "continue":
+          continued = true;
+          break;
+        case "tag":
+          excluded = true;
+          break;
+        case "tag_continue":
+          continued = true;
+          break;
+        case "output":
+          continued = false;
+          break;
+      }
+    } else {
+      action = stage.no_match_action;
+      if (stage.no_match_tags && stage.no_match_tags.length > 0) {
+        tagsAdded = [...stage.no_match_tags];
+      }
+      switch (stage.no_match_action) {
+        case "continue":
+          continued = true;
+          break;
+        case "exclude":
+          excluded = true;
+          break;
+        case "tag_exclude":
+          excluded = true;
+          break;
+      }
+    }
+    return {
+      stage_id: stage.id,
+      stage_name: stage.name,
+      matched,
+      rule_results: ruleResults.length > 0 ? ruleResults : void 0,
+      action,
+      tags_added: tagsAdded.length > 0 ? tagsAdded : void 0,
+      context_added: contextAdded,
+      excluded,
+      continued
+    };
+  }
+};
+
+// src/api/adapter.ts
+function createApiError(message, status, response, cause) {
+  const error = new Error(message);
+  error.name = "ApiError";
+  error.status = status;
+  error.response = response;
+  error.cause = cause;
+  if (response?.code) {
+    error.code = response.code;
+  }
+  return error;
+}
+function isApiError(error) {
+  return error instanceof Error && error.name === "ApiError";
+}
+
+// src/api/default-adapter.ts
+var FetchAdapter = class {
+  constructor(config = {}) {
+    this.config = {
+      headers: config.headers || {},
+      timeout: config.timeout || 3e4,
+      parseResponse: config.parseResponse || ((res) => res.json()),
+      onError: config.onError || (() => {
+      })
+    };
+  }
+  /**
+   * Build fetch options
+   */
+  buildOptions(method, data, params) {
+    const options = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.config.headers
+      }
+    };
+    if (data !== void 0) {
+      options.body = JSON.stringify(data);
+    }
+    return options;
+  }
+  /**
+   * Build URL with query params
+   */
+  buildUrl(url, params) {
+    if (!params || Object.keys(params).length === 0) {
+      return url;
+    }
+    const searchParams = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        if (Array.isArray(value)) {
+          value.forEach((v) => searchParams.append(key, String(v)));
+        } else {
+          searchParams.append(key, String(value));
+        }
+      }
+    });
+    const queryString = searchParams.toString();
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  /**
+   * Fetch with timeout
+   */
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw createApiError(
+          `Request timeout after ${this.config.timeout}ms`,
+          void 0,
+          void 0,
+          error
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Handle response
+   */
+  async handleResponse(response) {
+    if (response.ok) {
+      if (response.status === 204) {
+        return void 0;
+      }
+      try {
+        return await this.config.parseResponse(response);
+      } catch (error2) {
+        throw createApiError(
+          "Failed to parse response",
+          response.status,
+          void 0,
+          error2
+        );
+      }
+    }
+    let errorBody;
+    try {
+      errorBody = await response.json();
+    } catch {
+      errorBody = { detail: response.statusText };
+    }
+    const error = createApiError(
+      errorBody.detail || errorBody.message || `HTTP ${response.status}`,
+      response.status,
+      errorBody
+    );
+    this.config.onError(error);
+    throw error;
+  }
+  /**
+   * Execute request
+   */
+  async request(method, url, data, params) {
+    const fullUrl = this.buildUrl(url, params);
+    const options = this.buildOptions(method, data, params);
+    try {
+      const response = await this.fetchWithTimeout(fullUrl, options);
+      return await this.handleResponse(response);
+    } catch (error) {
+      if (error.name === "ApiError") {
+        throw error;
+      }
+      const apiError = createApiError(
+        "Network request failed",
+        void 0,
+        void 0,
+        error
+      );
+      this.config.onError(apiError);
+      throw apiError;
+    }
+  }
+  /**
+   * HTTP GET
+   */
+  async get(url, params) {
+    return this.request("GET", url, void 0, params);
+  }
+  /**
+   * HTTP POST
+   */
+  async post(url, data) {
+    return this.request("POST", url, data);
+  }
+  /**
+   * HTTP PATCH
+   */
+  async patch(url, data) {
+    return this.request("PATCH", url, data);
+  }
+  /**
+   * HTTP DELETE
+   */
+  async delete(url) {
+    return this.request("DELETE", url);
+  }
+};
+
+// src/api/client.ts
+var FunnelApiClient = class {
+  constructor(adapter, baseUrl) {
+    this.adapter = adapter;
+    this.baseUrl = baseUrl;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Build full URL for endpoint
+   */
+  url(path) {
+    return `${this.baseUrl}${path}`;
+  }
+  // ============================================================================
+  // Funnel CRUD
+  // ============================================================================
+  /**
+   * List funnels with optional filters
+   *
+   * @param filters - Optional filters (status, owner, pagination, etc)
+   * @returns Paginated list of funnels
+   */
+  async listFunnels(filters) {
+    return this.adapter.get(
+      this.url("/api/v1/funnels/"),
+      filters
+    );
+  }
+  /**
+   * Get single funnel by ID
+   *
+   * @param id - Funnel ID
+   * @returns Funnel detail
+   * @throws ApiError with status 404 if not found
+   */
+  async getFunnel(id) {
+    return this.adapter.get(this.url(`/api/v1/funnels/${id}/`));
+  }
+  /**
+   * Create new funnel
+   *
+   * @param data - Funnel creation data
+   * @returns Created funnel
+   * @throws ApiError with status 400 if validation fails
+   */
+  async createFunnel(data) {
+    return this.adapter.post(this.url("/api/v1/funnels/"), data);
+  }
+  /**
+   * Update existing funnel
+   *
+   * @param id - Funnel ID
+   * @param data - Funnel update data
+   * @returns Updated funnel
+   * @throws ApiError with status 404 if not found, 400 if validation fails
+   */
+  async updateFunnel(id, data) {
+    return this.adapter.patch(
+      this.url(`/api/v1/funnels/${id}/`),
+      data
+    );
+  }
+  /**
+   * Delete funnel
+   *
+   * @param id - Funnel ID
+   * @throws ApiError with status 404 if not found
+   */
+  async deleteFunnel(id) {
+    return this.adapter.delete(this.url(`/api/v1/funnels/${id}/`));
+  }
+  // ============================================================================
+  // Stage CRUD
+  // ============================================================================
+  /**
+   * Create stage in funnel
+   *
+   * @param funnelId - Funnel ID
+   * @param data - Stage creation data
+   * @returns Created stage
+   * @throws ApiError with status 404 if funnel not found, 400 if validation fails
+   */
+  async createStage(funnelId, data) {
+    return this.adapter.post(
+      this.url(`/api/v1/funnels/${funnelId}/stages/`),
+      data
+    );
+  }
+  /**
+   * Update stage
+   *
+   * @param funnelId - Funnel ID
+   * @param stageId - Stage ID
+   * @param data - Stage update data
+   * @returns Updated stage
+   * @throws ApiError with status 404 if not found, 400 if validation fails
+   */
+  async updateStage(funnelId, stageId, data) {
+    return this.adapter.patch(
+      this.url(`/api/v1/funnels/${funnelId}/stages/${stageId}/`),
+      data
+    );
+  }
+  /**
+   * Delete stage
+   *
+   * @param funnelId - Funnel ID
+   * @param stageId - Stage ID
+   * @throws ApiError with status 404 if not found
+   */
+  async deleteStage(funnelId, stageId) {
+    return this.adapter.delete(
+      this.url(`/api/v1/funnels/${funnelId}/stages/${stageId}/`)
+    );
+  }
+  // ============================================================================
+  // Run Operations
+  // ============================================================================
+  /**
+   * Trigger funnel run
+   *
+   * @param funnelId - Funnel ID
+   * @param options - Optional run configuration (trigger_type, metadata, etc)
+   * @returns Created funnel run (status: pending or running)
+   * @throws ApiError with status 404 if funnel not found, 400 if validation fails
+   */
+  async runFunnel(funnelId, options) {
+    return this.adapter.post(
+      this.url(`/api/v1/funnels/${funnelId}/run/`),
+      options || {}
+    );
+  }
+  /**
+   * Get funnel run history
+   *
+   * @param funnelId - Funnel ID
+   * @param filters - Optional filters (status, pagination, etc)
+   * @returns List of funnel runs
+   * @throws ApiError with status 404 if funnel not found
+   */
+  async getFunnelRuns(funnelId, filters) {
+    return this.adapter.get(
+      this.url(`/api/v1/funnels/${funnelId}/runs/`),
+      filters
+    );
+  }
+  /**
+   * Get single run detail
+   *
+   * @param runId - Run ID
+   * @returns Funnel run detail
+   * @throws ApiError with status 404 if not found
+   */
+  async getFunnelRun(runId) {
+    return this.adapter.get(this.url(`/api/v1/funnel-runs/${runId}/`));
+  }
+  /**
+   * Get run results (entities that were processed)
+   *
+   * @param runId - Run ID
+   * @param filters - Optional filters (matched, pagination, etc)
+   * @returns Paginated list of results
+   * @throws ApiError with status 404 if run not found
+   */
+  async getFunnelResults(runId, filters) {
+    return this.adapter.get(
+      this.url(`/api/v1/funnel-runs/${runId}/results/`),
+      filters
+    );
+  }
+  /**
+   * Cancel running funnel
+   *
+   * @param runId - Run ID
+   * @returns Updated run with status 'cancelled'
+   * @throws ApiError with status 404 if not found, 400 if already completed
+   */
+  async cancelFunnelRun(runId) {
+    return this.adapter.post(
+      this.url(`/api/v1/funnel-runs/${runId}/cancel/`),
+      {}
+    );
+  }
+  // ============================================================================
+  // Client-Side Preview (Local Evaluation)
+  // ============================================================================
+  /**
+   * Preview funnel with sample entities (client-side evaluation)
+   *
+   * Useful for testing funnel logic before running on full dataset.
+   * Does NOT hit the server - evaluates locally.
+   *
+   * Note: This requires the evaluation engine to be available client-side.
+   * If not available, this will throw an error.
+   *
+   * @param funnel - Funnel definition
+   * @param sampleEntities - Sample entities to test
+   * @returns Preview results showing which entities would match/exclude
+   */
+  async previewFunnel(funnel, sampleEntities) {
+    throw new Error(
+      "Client-side preview requires evaluation engine. Use server-side preview endpoint instead: POST /api/v1/funnels/{id}/preview/"
+    );
+  }
+  /**
+   * Server-side preview (recommended)
+   *
+   * Send sample entities to server for evaluation.
+   * Useful for testing funnel logic before running on full dataset.
+   *
+   * @param funnelId - Funnel ID
+   * @param sampleEntities - Sample entities to test
+   * @returns Preview results
+   * @throws ApiError with status 404 if funnel not found
+   */
+  async previewFunnelServer(funnelId, sampleEntities) {
+    return this.adapter.post(
+      this.url(`/api/v1/funnels/${funnelId}/preview/`),
+      { entities: sampleEntities }
+    );
+  }
+};
+
+// src/store/types.ts
+var createInitialState = () => ({
+  funnels: [],
+  selectedFunnel: null,
+  selectedStage: null,
+  runs: [],
+  pagination: {
+    count: 0,
+    next: null,
+    previous: null,
+    currentPage: 1,
+    pageSize: 20
+  },
+  isLoading: false,
+  error: null,
+  isDirty: false,
+  rollbackState: null
+});
+
+// src/store/create-funnel-store.ts
+function createFunnelStore(apiClient) {
+  return zustand.create((set, get) => ({
+    // Initialize state
+    ...createInitialState(),
+    // =========================================================================
+    // Funnel Actions
+    // =========================================================================
+    loadFunnels: async (filters) => {
+      set({ isLoading: true, error: null });
+      try {
+        const response = await apiClient.listFunnels(filters);
+        set({
+          funnels: response.results,
+          pagination: {
+            count: response.count,
+            next: response.next,
+            previous: response.previous,
+            currentPage: filters?.page || 1,
+            pageSize: filters?.page_size || 20
+          },
+          isLoading: false
+        });
+      } catch (error) {
+        set({
+          error,
+          isLoading: false
+        });
+        throw error;
+      }
+    },
+    selectFunnel: (id) => {
+      const { funnels } = get();
+      if (id === null) {
+        set({ selectedFunnel: null, selectedStage: null });
+        return;
+      }
+      const funnel = funnels.find((f) => f.id === id);
+      set({
+        selectedFunnel: funnel || null,
+        selectedStage: null
+        // Clear stage selection when changing funnels
+      });
+    },
+    createFunnel: async (data) => {
+      set({ isLoading: true, error: null });
+      try {
+        const funnel = await apiClient.createFunnel(data);
+        set((state) => ({
+          funnels: [...state.funnels, funnel],
+          pagination: {
+            ...state.pagination,
+            count: state.pagination.count + 1
+          },
+          isLoading: false
+        }));
+        return funnel;
+      } catch (error) {
+        set({
+          error,
+          isLoading: false
+        });
+        throw error;
+      }
+    },
+    updateFunnel: async (id, data) => {
+      get()._saveRollbackState();
+      set((state) => ({
+        funnels: state.funnels.map(
+          (f) => f.id === id ? { ...f, ...data } : f
+        ),
+        selectedFunnel: state.selectedFunnel?.id === id ? { ...state.selectedFunnel, ...data } : state.selectedFunnel,
+        isDirty: false
+        // Clear dirty flag on save
+      }));
+      try {
+        const updated = await apiClient.updateFunnel(id, data);
+        set((state) => ({
+          funnels: state.funnels.map((f) => f.id === id ? updated : f),
+          selectedFunnel: state.selectedFunnel?.id === id ? updated : state.selectedFunnel
+        }));
+        get()._clearRollback();
+        return updated;
+      } catch (error) {
+        get()._rollback();
+        set({ error });
+        throw error;
+      }
+    },
+    deleteFunnel: async (id) => {
+      get()._saveRollbackState();
+      set((state) => ({
+        funnels: state.funnels.filter((f) => f.id !== id),
+        selectedFunnel: state.selectedFunnel?.id === id ? null : state.selectedFunnel,
+        pagination: {
+          ...state.pagination,
+          count: state.pagination.count - 1
+        }
+      }));
+      try {
+        await apiClient.deleteFunnel(id);
+        get()._clearRollback();
+      } catch (error) {
+        get()._rollback();
+        set({ error });
+        throw error;
+      }
+    },
+    duplicateFunnel: async (id) => {
+      const { funnels } = get();
+      const funnel = funnels.find((f) => f.id === id);
+      if (!funnel) {
+        throw new Error(`Funnel ${id} not found`);
+      }
+      const copy = {
+        name: `${funnel.name} (Copy)`,
+        description: funnel.description,
+        status: "draft",
+        // Always create as draft
+        input_type: funnel.input_type,
+        stages: funnel.stages.map((stage, index) => ({
+          ...stage,
+          order: index
+          // Preserve order
+        })),
+        completion_tags: funnel.completion_tags,
+        metadata: funnel.metadata
+      };
+      return get().createFunnel(copy);
+    },
+    // =========================================================================
+    // Stage Actions
+    // =========================================================================
+    selectStage: (stageId) => {
+      const { selectedFunnel } = get();
+      if (!selectedFunnel) {
+        set({ selectedStage: null });
+        return;
+      }
+      if (stageId === null) {
+        set({ selectedStage: null });
+        return;
+      }
+      const stage = selectedFunnel.stages.find((s) => s.id === stageId);
+      set({ selectedStage: stage || null });
+    },
+    createStage: async (funnelId, data) => {
+      set({ isLoading: true, error: null });
+      try {
+        const stage = await apiClient.createStage(funnelId, data);
+        set((state) => ({
+          funnels: state.funnels.map(
+            (f) => f.id === funnelId ? { ...f, stages: [...f.stages, stage] } : f
+          ),
+          selectedFunnel: state.selectedFunnel?.id === funnelId ? { ...state.selectedFunnel, stages: [...state.selectedFunnel.stages, stage] } : state.selectedFunnel,
+          isLoading: false
+        }));
+        return stage;
+      } catch (error) {
+        set({
+          error,
+          isLoading: false
+        });
+        throw error;
+      }
+    },
+    updateStage: async (funnelId, stageId, data) => {
+      get()._saveRollbackState();
+      set((state) => ({
+        funnels: state.funnels.map(
+          (f) => f.id === funnelId ? {
+            ...f,
+            stages: f.stages.map(
+              (s) => s.id === stageId ? { ...s, ...data } : s
+            )
+          } : f
+        ),
+        selectedFunnel: state.selectedFunnel?.id === funnelId ? {
+          ...state.selectedFunnel,
+          stages: state.selectedFunnel.stages.map(
+            (s) => s.id === stageId ? { ...s, ...data } : s
+          )
+        } : state.selectedFunnel,
+        selectedStage: state.selectedStage?.id === stageId ? { ...state.selectedStage, ...data } : state.selectedStage,
+        isDirty: false
+      }));
+      try {
+        const updated = await apiClient.updateStage(
+          funnelId,
+          stageId,
+          data
+        );
+        set((state) => ({
+          funnels: state.funnels.map(
+            (f) => f.id === funnelId ? {
+              ...f,
+              stages: f.stages.map((s) => s.id === stageId ? updated : s)
+            } : f
+          ),
+          selectedFunnel: state.selectedFunnel?.id === funnelId ? {
+            ...state.selectedFunnel,
+            stages: state.selectedFunnel.stages.map(
+              (s) => s.id === stageId ? updated : s
+            )
+          } : state.selectedFunnel,
+          selectedStage: state.selectedStage?.id === stageId ? updated : state.selectedStage
+        }));
+        get()._clearRollback();
+        return updated;
+      } catch (error) {
+        get()._rollback();
+        set({ error });
+        throw error;
+      }
+    },
+    deleteStage: async (funnelId, stageId) => {
+      get()._saveRollbackState();
+      set((state) => ({
+        funnels: state.funnels.map(
+          (f) => f.id === funnelId ? {
+            ...f,
+            stages: f.stages.filter((s) => s.id !== stageId)
+          } : f
+        ),
+        selectedFunnel: state.selectedFunnel?.id === funnelId ? {
+          ...state.selectedFunnel,
+          stages: state.selectedFunnel.stages.filter((s) => s.id !== stageId)
+        } : state.selectedFunnel,
+        selectedStage: state.selectedStage?.id === stageId ? null : state.selectedStage
+      }));
+      try {
+        await apiClient.deleteStage(funnelId, stageId);
+        get()._clearRollback();
+      } catch (error) {
+        get()._rollback();
+        set({ error });
+        throw error;
+      }
+    },
+    reorderStages: async (funnelId, stageIds) => {
+      const { selectedFunnel } = get();
+      if (!selectedFunnel || selectedFunnel.id !== funnelId) {
+        throw new Error("Funnel must be selected to reorder stages");
+      }
+      get()._saveRollbackState();
+      const reorderedStages = stageIds.map((id, index) => {
+        const stage = selectedFunnel.stages.find((s) => s.id === id);
+        return stage ? { ...stage, order: index } : null;
+      }).filter((s) => s !== null);
+      set((state) => ({
+        funnels: state.funnels.map(
+          (f) => f.id === funnelId ? { ...f, stages: reorderedStages } : f
+        ),
+        selectedFunnel: { ...selectedFunnel, stages: reorderedStages },
+        isDirty: false
+      }));
+      try {
+        await Promise.all(
+          reorderedStages.map(
+            (stage) => apiClient.updateStage(funnelId, stage.id, { order: stage.order })
+          )
+        );
+        get()._clearRollback();
+      } catch (error) {
+        get()._rollback();
+        set({ error });
+        throw error;
+      }
+    },
+    // =========================================================================
+    // Run Actions
+    // =========================================================================
+    runFunnel: async (id, options) => {
+      set({ isLoading: true, error: null });
+      try {
+        const run = await apiClient.runFunnel(id, options);
+        set((state) => ({
+          runs: [run, ...state.runs],
+          isLoading: false
+        }));
+        return run;
+      } catch (error) {
+        set({
+          error,
+          isLoading: false
+        });
+        throw error;
+      }
+    },
+    loadRuns: async (funnelId, filters) => {
+      set({ isLoading: true, error: null });
+      try {
+        const response = await apiClient.getFunnelRuns(funnelId, filters);
+        set({
+          runs: response.results,
+          isLoading: false
+        });
+      } catch (error) {
+        set({
+          error,
+          isLoading: false
+        });
+        throw error;
+      }
+    },
+    cancelRun: async (runId) => {
+      set({ isLoading: true, error: null });
+      try {
+        const run = await apiClient.cancelFunnelRun(runId);
+        set((state) => ({
+          runs: state.runs.map((r) => r.id === runId ? run : r),
+          isLoading: false
+        }));
+        return run;
+      } catch (error) {
+        set({
+          error,
+          isLoading: false
+        });
+        throw error;
+      }
+    },
+    // =========================================================================
+    // UI State Actions
+    // =========================================================================
+    setDirty: (dirty) => {
+      set({ isDirty: dirty });
+    },
+    clearError: () => {
+      set({ error: null });
+    },
+    reset: () => {
+      set(createInitialState());
+    },
+    // =========================================================================
+    // Internal Actions (Optimistic Updates)
+    // =========================================================================
+    _saveRollbackState: () => {
+      const { funnels, selectedFunnel } = get();
+      set({
+        rollbackState: {
+          funnels: JSON.parse(JSON.stringify(funnels)),
+          selectedFunnel: selectedFunnel ? JSON.parse(JSON.stringify(selectedFunnel)) : null
+        }
+      });
+    },
+    _rollback: () => {
+      const { rollbackState } = get();
+      if (rollbackState) {
+        set({
+          funnels: rollbackState.funnels,
+          selectedFunnel: rollbackState.selectedFunnel,
+          rollbackState: null
+        });
+      }
+    },
+    _clearRollback: () => {
+      set({ rollbackState: null });
+    }
+  }));
+}
+function useDebouncedValue(value, delay = 300) {
+  const [debouncedValue, setDebouncedValue] = react.useState(value);
+  react.useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+function PreviewStats({
+  totalMatched,
+  totalExcluded,
+  matchPercentage,
+  className = ""
+}) {
+  const total = totalMatched + totalExcluded;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `space-y-2 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative h-8 bg-gray-200 rounded-lg overflow-hidden", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "absolute inset-y-0 left-0 bg-gradient-to-r from-green-500 to-green-600 transition-all duration-300 flex items-center justify-center",
+          style: { width: `${matchPercentage}%` },
+          role: "progressbar",
+          "aria-valuenow": matchPercentage,
+          "aria-valuemin": 0,
+          "aria-valuemax": 100,
+          "aria-label": `${totalMatched} of ${total} matched (${matchPercentage}%)`,
+          children: matchPercentage > 15 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs font-semibold text-white", children: [
+            totalMatched.toLocaleString(),
+            "/",
+            total.toLocaleString(),
+            " (",
+            matchPercentage,
+            "%)"
+          ] })
+        }
+      ),
+      matchPercentage <= 15 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-0 flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs font-semibold text-gray-600", children: [
+        totalMatched.toLocaleString(),
+        "/",
+        total.toLocaleString(),
+        " (",
+        matchPercentage,
+        "%)"
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between text-sm", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-3 h-3 rounded-sm bg-green-500" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-medium text-gray-700", children: [
+          totalMatched.toLocaleString(),
+          " Matched"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-3 h-3 rounded-sm bg-gray-300" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-medium text-gray-700", children: [
+          totalExcluded.toLocaleString(),
+          " Excluded"
+        ] })
+      ] })
+    ] })
+  ] });
+}
+function StageBreakdown({
+  stageStats,
+  stages,
+  className = ""
+}) {
+  const sortedStages = [...stages].sort((a, b) => a.order - b.order);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-sm font-semibold text-gray-700 mb-3", children: "Stage Breakdown" }),
+    /* @__PURE__ */ jsxRuntime.jsx("ol", { className: "space-y-2", children: sortedStages.map((stage, index) => {
+      const stats = stageStats[stage.id];
+      if (!stats) return null;
+      const isLast = index === sortedStages.length - 1;
+      const excludedCount = stats.excluded_count;
+      const remainingCount = stats.remaining_count;
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "li",
+        {
+          className: "flex items-center justify-between py-2 px-3 bg-gray-50 rounded-lg",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 flex-1 min-w-0", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex-shrink-0 w-6 h-6 flex items-center justify-center bg-blue-100 text-blue-700 rounded-full text-xs font-bold", children: index + 1 }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium text-gray-900 truncate", children: stage.name })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3 text-sm", children: [
+              excludedCount > 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-red-600 font-medium", children: [
+                "-",
+                excludedCount.toLocaleString()
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs(
+                "span",
+                {
+                  className: `font-semibold ${isLast ? "text-green-600" : "text-gray-700"}`,
+                  children: [
+                    remainingCount.toLocaleString(),
+                    " ",
+                    isLast ? "final" : "left"
+                  ]
+                }
+              )
+            ] })
+          ]
+        },
+        stage.id
+      );
+    }) })
+  ] });
+}
+function defaultEntityRenderer(entity) {
+  if (entity.name) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-medium text-gray-900", children: entity.name }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-gray-600 mt-1", children: Object.keys(entity).filter((key) => key !== "name").slice(0, 3).map((key) => /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "mr-2", children: [
+        key,
+        ": ",
+        String(entity[key]).slice(0, 20)
+      ] }, key)) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-gray-700 font-mono", children: /* @__PURE__ */ jsxRuntime.jsxs("pre", { className: "whitespace-pre-wrap break-all", children: [
+    JSON.stringify(entity, null, 2).slice(0, 150),
+    JSON.stringify(entity, null, 2).length > 150 ? "..." : ""
+  ] }) });
+}
+function EntityCard({
+  entity,
+  renderEntity = defaultEntityRenderer,
+  className = ""
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "article",
+    {
+      className: `p-3 bg-white border border-gray-200 rounded-lg shadow-sm hover:border-gray-300 transition-colors ${className}`,
+      children: renderEntity(entity)
+    }
+  );
+}
+function LoadingPreview() {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "animate-pulse", role: "status", "aria-live": "polite", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sr-only", children: "Loading preview..." }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2 mb-6", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-8 bg-gray-200 rounded-lg" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-4 w-32 bg-gray-200 rounded" }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-4 w-32 bg-gray-200 rounded" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mb-6", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-5 w-40 bg-gray-200 rounded mb-3" }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2", children: [1, 2, 3].map((i) => /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          className: "h-12 bg-gray-100 rounded-lg flex items-center px-3 gap-3",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-6 h-6 bg-gray-200 rounded-full" }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-4 bg-gray-200 rounded flex-1" }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-4 w-16 bg-gray-200 rounded" })
+          ]
+        },
+        i
+      )) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-5 w-48 bg-gray-200 rounded mb-3" }),
+      [1, 2, 3].map((i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "h-20 bg-gray-100 border border-gray-200 rounded-lg p-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-4 bg-gray-200 rounded w-3/4 mb-2" }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-3 bg-gray-200 rounded w-1/2" })
+      ] }, i))
+    ] })
+  ] });
+}
+function convertToPreviewResult(execResult, maxEntities = 10) {
+  const { matched, total_matched, total_excluded, stage_stats } = execResult;
+  const total = total_matched + total_excluded;
+  const matchPercentage = total > 0 ? Math.round(total_matched / total * 100) : 0;
+  const previewEntities = matched.slice(0, maxEntities).map((r) => r.entity);
+  const previewStageStats = {};
+  Object.entries(stage_stats).forEach(([stageId, stats]) => {
+    previewStageStats[stageId] = {
+      stage_id: stats.stage_id,
+      stage_name: stats.stage_name,
+      input_count: stats.input_count,
+      excluded_count: stats.excluded_count,
+      remaining_count: stats.input_count - stats.excluded_count
+    };
+  });
+  return {
+    totalMatched: total_matched,
+    totalExcluded: total_excluded,
+    matchPercentage,
+    previewEntities,
+    stageStats: previewStageStats
+  };
+}
+function FunnelPreview({
+  funnel,
+  sampleEntities,
+  onPreview,
+  renderEntity,
+  maxPreviewEntities = 10,
+  className = ""
+}) {
+  const [result, setResult] = react.useState(null);
+  const [isComputing, setIsComputing] = react.useState(false);
+  const debouncedFunnel = useDebouncedValue(funnel, 300);
+  react.useEffect(() => {
+    async function compute() {
+      setIsComputing(true);
+      try {
+        const engine = new FunnelEngine();
+        const execResult = engine.execute(debouncedFunnel, sampleEntities);
+        const previewResult = convertToPreviewResult(
+          execResult,
+          maxPreviewEntities
+        );
+        setResult(previewResult);
+        if (onPreview) {
+          onPreview(previewResult);
+        }
+      } catch (error) {
+        console.error("Preview computation failed:", error);
+        setResult({
+          totalMatched: 0,
+          totalExcluded: sampleEntities.length,
+          matchPercentage: 0,
+          previewEntities: [],
+          stageStats: {}
+        });
+      } finally {
+        setIsComputing(false);
+      }
+    }
+    compute();
+  }, [debouncedFunnel, sampleEntities, maxPreviewEntities, onPreview]);
+  if (isComputing && !result) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className, children: /* @__PURE__ */ jsxRuntime.jsx(LoadingPreview, {}) });
+  }
+  if (!result) {
+    return null;
+  }
+  const { totalMatched, totalExcluded, matchPercentage, previewEntities, stageStats } = result;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, role: "region", "aria-label": "Funnel preview", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "text-lg font-semibold text-gray-900 mb-4", children: "Preview Results" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      PreviewStats,
+      {
+        totalMatched,
+        totalExcluded,
+        matchPercentage,
+        className: "mb-6"
+      }
+    ),
+    funnel.stages.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+      StageBreakdown,
+      {
+        stageStats,
+        stages: funnel.stages,
+        className: "mb-6"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("h3", { className: "text-sm font-semibold text-gray-700 mb-3", children: [
+        "Sample Matches (",
+        Math.min(previewEntities.length, maxPreviewEntities),
+        " of",
+        " ",
+        totalMatched.toLocaleString(),
+        ")"
+      ] }),
+      previewEntities.length === 0 ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-8 text-center bg-gray-50 rounded-lg border-2 border-dashed border-gray-300", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-gray-600", children: "No entities matched this funnel" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-500 mt-1", children: "Try adjusting your filter rules" })
+      ] }) : /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
+        previewEntities.map((entity, index) => /* @__PURE__ */ jsxRuntime.jsx(
+          EntityCard,
+          {
+            entity,
+            renderEntity
+          },
+          index
+        )),
+        totalMatched > maxPreviewEntities && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-center py-2 text-sm text-gray-500", children: [
+          "+ ",
+          (totalMatched - maxPreviewEntities).toLocaleString(),
+          " more..."
+        ] })
+      ] })
+    ] }),
+    isComputing && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-0 bg-white bg-opacity-75 flex items-center justify-center rounded-lg", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-gray-600", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-5 h-5 border-2 border-gray-300 border-t-blue-600 rounded-full animate-spin" }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium", children: "Updating preview..." })
+    ] }) })
+  ] });
+}
+var statusConfig = {
+  active: {
+    color: "text-green-800",
+    bgColor: "bg-green-100",
+    label: "ACTIVE"
+  },
+  draft: {
+    color: "text-yellow-800",
+    bgColor: "bg-yellow-100",
+    label: "DRAFT"
+  },
+  paused: {
+    color: "text-gray-800",
+    bgColor: "bg-gray-100",
+    label: "PAUSED"
+  },
+  archived: {
+    color: "text-red-800",
+    bgColor: "bg-red-100",
+    label: "ARCHIVED"
+  }
+};
+function StatusBadge({ status, className = "" }) {
+  const config = statusConfig[status];
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "span",
+    {
+      className: `inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ${config.bgColor} ${config.color} ${className}`,
+      children: config.label
+    }
+  );
+}
+function StageIndicator({
+  order,
+  name,
+  ruleCount,
+  isLast = false,
+  className = ""
+}) {
+  const circledNumber = order < 20 ? String.fromCharCode(9312 + order) : `(${order + 1})`;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex items-start gap-2 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-shrink-0 w-6 h-6 rounded-full bg-blue-100 text-blue-800 flex items-center justify-center text-sm font-medium", children: circledNumber }),
+      !isLast && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-0.5 h-6 bg-gray-200 mt-1" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 pt-0.5 min-w-0", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-baseline justify-between gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium text-gray-900 truncate", children: name }),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs text-gray-500 whitespace-nowrap", children: [
+        ruleCount,
+        " ",
+        ruleCount === 1 ? "rule" : "rules"
+      ] })
+    ] }) })
+  ] });
+}
+function MatchBar({ matched, total, className = "" }) {
+  const percentage = total > 0 ? Math.round(matched / total * 100) : 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `space-y-1 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative h-6 bg-gray-200 rounded-md overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: "absolute inset-y-0 left-0 bg-gradient-to-r from-green-500 to-green-600 transition-all duration-300",
+        style: { width: `${percentage}%` },
+        role: "progressbar",
+        "aria-valuenow": percentage,
+        "aria-valuemin": 0,
+        "aria-valuemax": 100,
+        "aria-label": `${matched} of ${total} matched`
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-right", children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-sm font-medium text-gray-700", children: [
+      matched.toLocaleString(),
+      " matched"
+    ] }) })
+  ] });
+}
+function FunnelStats({
+  input,
+  matched,
+  excluded,
+  className = ""
+}) {
+  const stats = [
+    {
+      label: "INPUT",
+      value: input,
+      color: "text-blue-600",
+      bgColor: "bg-blue-50"
+    },
+    {
+      label: "MATCHED",
+      value: matched,
+      color: "text-green-600",
+      bgColor: "bg-green-50"
+    },
+    {
+      label: "EXCLUDED",
+      value: excluded,
+      color: "text-red-600",
+      bgColor: "bg-red-50"
+    }
+  ];
+  return /* @__PURE__ */ jsxRuntime.jsx("dl", { className: `grid grid-cols-3 gap-2 ${className}`, children: stats.map(({ label, value, color, bgColor }) => /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: `${bgColor} rounded-lg px-3 py-2.5 text-center`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("dt", { className: "text-xs font-medium text-gray-600 mb-1", children: label }),
+        /* @__PURE__ */ jsxRuntime.jsx("dd", { className: `text-lg font-bold ${color}`, children: value.toLocaleString() })
+      ]
+    },
+    label
+  )) });
+}
+function FunnelCard({
+  funnel,
+  latestRun,
+  onViewFlow,
+  onEdit,
+  className = ""
+}) {
+  const stats = latestRun ? {
+    input: latestRun.total_input,
+    matched: latestRun.total_matched,
+    excluded: latestRun.total_excluded
+  } : {
+    input: 0,
+    matched: 0,
+    excluded: 0
+  };
+  const handleViewFlow = () => {
+    if (onViewFlow) {
+      onViewFlow(funnel);
+    }
+  };
+  const hasRun = latestRun && latestRun.status === "completed";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "article",
+    {
+      className: `bg-white rounded-lg border border-gray-200 shadow-sm hover:shadow-md transition-shadow duration-200 ${className}`,
+      "aria-label": `Funnel: ${funnel.name}`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("header", { className: "px-6 pt-5 pb-3 border-b border-gray-100", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start justify-between gap-3", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-semibold text-gray-900 flex-1 min-w-0", children: funnel.name }),
+            /* @__PURE__ */ jsxRuntime.jsx(StatusBadge, { status: funnel.status })
+          ] }),
+          funnel.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-2 text-sm text-gray-600 line-clamp-2", children: funnel.description })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "section",
+          {
+            className: "px-6 py-4 space-y-0",
+            "aria-label": "Funnel stages",
+            children: funnel.stages.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-gray-500 italic py-4 text-center", children: "No stages defined" }) : funnel.stages.map((stage, index) => /* @__PURE__ */ jsxRuntime.jsx(
+              StageIndicator,
+              {
+                order: index,
+                name: stage.name,
+                ruleCount: stage.rules.length,
+                isLast: index === funnel.stages.length - 1
+              },
+              stage.id
+            ))
+          }
+        ),
+        hasRun && /* @__PURE__ */ jsxRuntime.jsx(
+          "section",
+          {
+            className: "px-6 py-4 border-t border-gray-100",
+            "aria-label": "Match results",
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              MatchBar,
+              {
+                matched: stats.matched,
+                total: stats.input
+              }
+            )
+          }
+        ),
+        hasRun && /* @__PURE__ */ jsxRuntime.jsx(
+          "section",
+          {
+            className: "px-6 py-4 border-t border-gray-100",
+            "aria-label": "Funnel statistics",
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              FunnelStats,
+              {
+                input: stats.input,
+                matched: stats.matched,
+                excluded: stats.excluded
+              }
+            )
+          }
+        ),
+        !hasRun && /* @__PURE__ */ jsxRuntime.jsx(
+          "section",
+          {
+            className: "px-6 py-4 border-t border-gray-100 text-center",
+            "aria-label": "Funnel status",
+            children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-500", children: latestRun?.status === "failed" ? "Last run failed" : latestRun?.status === "running" ? "Running..." : "No runs yet" })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("footer", { className: "px-6 py-4 border-t border-gray-100", children: /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            onClick: handleViewFlow,
+            className: "w-full inline-flex items-center justify-center gap-2 px-4 py-2.5 bg-gray-50 hover:bg-gray-100 text-gray-900 text-sm font-medium rounded-md transition-colors duration-200 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500",
+            "aria-label": `View flow details for ${funnel.name}`,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { children: "View Flow" }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "svg",
+                {
+                  className: "w-4 h-4 transition-transform group-hover:translate-x-0.5",
+                  fill: "none",
+                  viewBox: "0 0 24 24",
+                  stroke: "currentColor",
+                  "aria-hidden": "true",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(
+                    "path",
+                    {
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round",
+                      strokeWidth: 2,
+                      d: "M13 7l5 5m0 0l-5 5m5-5H6"
+                    }
+                  )
+                }
+              )
+            ]
+          }
+        ) })
+      ]
+    }
+  );
+}
+function getStageColor(stage) {
+  const matchAction = stage.match_action;
+  const noMatchAction = stage.no_match_action;
+  if (matchAction === "output") {
+    return "#22c55e";
+  }
+  if (noMatchAction === "exclude" || noMatchAction === "tag_exclude") {
+    return "#ef4444";
+  }
+  if (matchAction === "tag" || matchAction === "tag_continue") {
+    return "#eab308";
+  }
+  return "#3b82f6";
+}
+function getActionLabel(stage) {
+  const matchAction = stage.match_action;
+  const noMatchAction = stage.no_match_action;
+  if (matchAction === "output") return "Output";
+  if (noMatchAction === "exclude") return "Exclude Non-Matches";
+  if (noMatchAction === "tag_exclude") return "Tag & Exclude";
+  if (matchAction === "tag") return "Tag Matches";
+  if (matchAction === "tag_continue") return "Tag & Continue";
+  return "Continue";
+}
+function StageNode({ data }) {
+  const { stage, stats, onStageClick } = data;
+  const color = getStageColor(stage);
+  const actionLabel = getActionLabel(stage);
+  const handleClick = () => {
+    if (onStageClick) {
+      onStageClick(stage);
+    }
+  };
+  const handleKeyDown = (event) => {
+    if (event.key === "Enter" || event.key === " ") {
+      event.preventDefault();
+      handleClick();
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react$1.Handle,
+      {
+        type: "target",
+        position: react$1.Position.Top,
+        style: { background: color, opacity: 0 },
+        isConnectable: false
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: "stage-node",
+        onClick: handleClick,
+        onKeyDown: handleKeyDown,
+        role: "button",
+        tabIndex: 0,
+        "aria-label": `Stage ${stage.order + 1}: ${stage.name}`,
+        style: {
+          borderColor: color,
+          borderWidth: "2px",
+          borderStyle: "solid"
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "stage-number", style: { color }, children: getCircledNumber(stage.order + 1) }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "stage-name", title: stage.name, children: stage.name }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stage-rules", children: [
+            stage.rules.length,
+            " ",
+            stage.rules.length === 1 ? "rule" : "rules"
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "stage-action", style: { color }, children: actionLabel }),
+          stats && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stage-stats", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stat-row", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stat-label", children: "Input:" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stat-value", children: stats.input_count })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stat-row", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stat-label", children: "Matched:" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stat-value text-green-600", children: stats.matched_count })
+            ] }),
+            stats.excluded_count > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stat-row", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stat-label", children: "Excluded:" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stat-value text-red-600", children: stats.excluded_count })
+            ] })
+          ] }),
+          stage.description && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "stage-description", title: stage.description, children: stage.description.length > 50 ? `${stage.description.substring(0, 50)}...` : stage.description })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react$1.Handle,
+      {
+        type: "source",
+        position: react$1.Position.Bottom,
+        style: { background: color, opacity: 0 },
+        isConnectable: false
+      }
+    )
+  ] });
+}
+function FlowLegend() {
+  const [isExpanded, setIsExpanded] = react.useState(true);
+  const legendItems = [
+    { color: "#3b82f6", label: "Continue" },
+    { color: "#ef4444", label: "Exclude" },
+    { color: "#eab308", label: "Tag" },
+    { color: "#22c55e", label: "Output" }
+  ];
+  return /* @__PURE__ */ jsxRuntime.jsx(react$1.Panel, { position: "bottom-right", className: "flow-legend-panel", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flow-legend", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        className: "legend-toggle",
+        onClick: () => setIsExpanded(!isExpanded),
+        "aria-label": isExpanded ? "Collapse legend" : "Expand legend",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "legend-title", children: "Legend" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "svg",
+            {
+              className: `legend-chevron ${isExpanded ? "expanded" : ""}`,
+              width: "12",
+              height: "12",
+              viewBox: "0 0 12 12",
+              fill: "none",
+              xmlns: "http://www.w3.org/2000/svg",
+              children: /* @__PURE__ */ jsxRuntime.jsx(
+                "path",
+                {
+                  d: "M3 4.5L6 7.5L9 4.5",
+                  stroke: "currentColor",
+                  strokeWidth: "1.5",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round"
+                }
+              )
+            }
+          )
+        ]
+      }
+    ),
+    isExpanded && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "legend-items", children: legendItems.map((item) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "legend-item", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "legend-color",
+          style: {
+            backgroundColor: item.color,
+            border: `2px solid ${item.color}`
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "legend-label", children: item.label })
+    ] }, item.label)) })
+  ] }) });
+}
+function getExcludedCount(runData, fromStageId, toStageId) {
+  const fromStats = runData.stage_stats[fromStageId];
+  const toStats = runData.stage_stats[toStageId];
+  if (!fromStats || !toStats) return 0;
+  return fromStats.continued_count - toStats.input_count;
+}
+function getCircledNumber(num) {
+  const circledNumbers = ["\u2460", "\u2461", "\u2462", "\u2463", "\u2464", "\u2465", "\u2466", "\u2467", "\u2468", "\u2469"];
+  return num <= 10 ? circledNumbers[num - 1] : `${num}`;
+}
+var VERTICAL_SPACING = 180;
+var HORIZONTAL_CENTER = 250;
+function FunnelVisualFlow({
+  funnel,
+  runData,
+  onStageClick,
+  onEdgeClick,
+  className = "",
+  height = 600
+}) {
+  const nodeTypes = react.useMemo(
+    () => ({
+      stageNode: StageNode
+    }),
+    []
+  );
+  const initialNodes = react.useMemo(() => {
+    return funnel.stages.map((stage, index) => {
+      const stats = runData?.stage_stats?.[stage.id];
+      return {
+        id: stage.id,
+        type: "stageNode",
+        position: { x: HORIZONTAL_CENTER, y: index * VERTICAL_SPACING },
+        data: {
+          stage,
+          stats,
+          onStageClick
+        }
+      };
+    });
+  }, [funnel.stages, runData, onStageClick]);
+  const initialEdges = react.useMemo(() => {
+    if (funnel.stages.length < 2) return [];
+    return funnel.stages.slice(0, -1).map((stage, index) => {
+      const nextStage = funnel.stages[index + 1];
+      const excludedCount = runData ? getExcludedCount(runData, stage.id, nextStage.id) : void 0;
+      return {
+        id: `${stage.id}-${nextStage.id}`,
+        source: stage.id,
+        target: nextStage.id,
+        label: excludedCount !== void 0 ? `-${excludedCount}` : "",
+        animated: true,
+        style: { stroke: "#94a3b8", strokeWidth: 2 },
+        labelStyle: { fill: "#ef4444", fontWeight: 600 },
+        labelBgStyle: { fill: "#fef2f2", fillOpacity: 0.9 }
+      };
+    });
+  }, [funnel.stages, runData]);
+  const [nodes, , onNodesChange] = react$1.useNodesState(initialNodes);
+  const [edges, , onEdgesChange] = react$1.useEdgesState(initialEdges);
+  const handleEdgeClick = react.useCallback(
+    (event, edge) => {
+      if (onEdgeClick) {
+        onEdgeClick(edge.source, edge.target);
+      }
+    },
+    [onEdgeClick]
+  );
+  if (funnel.stages.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: `funnel-visual-flow-empty ${className}`,
+        style: { height },
+        children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "empty-state", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-gray-500 text-sm", children: "No stages to visualize" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-gray-400 text-xs mt-1", children: "Add stages to see the funnel flow" })
+        ] })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `funnel-visual-flow ${className}`, style: { height }, children: /* @__PURE__ */ jsxRuntime.jsxs(
+    react$1.ReactFlow,
+    {
+      nodes,
+      edges,
+      onNodesChange,
+      onEdgesChange,
+      onEdgeClick: handleEdgeClick,
+      nodeTypes,
+      fitView: true,
+      fitViewOptions: {
+        padding: 0.2,
+        includeHiddenNodes: false
+      },
+      minZoom: 0.5,
+      maxZoom: 1.5,
+      defaultViewport: { x: 0, y: 0, zoom: 1 },
+      nodesDraggable: false,
+      nodesConnectable: false,
+      elementsSelectable: true,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(react$1.Background, { variant: react$1.BackgroundVariant.Dots, gap: 16, size: 1 }),
+        /* @__PURE__ */ jsxRuntime.jsx(react$1.Controls, { showInteractive: false }),
+        /* @__PURE__ */ jsxRuntime.jsx(FlowLegend, {})
+      ]
+    }
+  ) });
+}
+function LogicToggle({ logic, onChange, className = "" }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex items-center gap-4 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium text-gray-700", children: "Logic:" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex items-center gap-2 cursor-pointer", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "radio",
+          name: "filter-logic",
+          value: "AND",
+          checked: logic === "AND",
+          onChange: (e) => onChange(e.target.value),
+          className: "w-4 h-4 text-blue-600 border-gray-300 focus:ring-blue-500"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-sm text-gray-700", children: [
+        "AND ",
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-gray-500", children: "(all must match)" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex items-center gap-2 cursor-pointer", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "radio",
+          name: "filter-logic",
+          value: "OR",
+          checked: logic === "OR",
+          onChange: (e) => onChange(e.target.value),
+          className: "w-4 h-4 text-blue-600 border-gray-300 focus:ring-blue-500"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-sm text-gray-700", children: [
+        "OR ",
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-gray-500", children: "(any can match)" })
+      ] })
+    ] })
+  ] });
+}
+function FieldSelector({
+  fields,
+  value,
+  onChange,
+  error,
+  className = ""
+}) {
+  const grouped = fields.reduce((acc, field) => {
+    const category = field.category || "Other";
+    if (!acc[category]) {
+      acc[category] = [];
+    }
+    acc[category].push(field);
+    return acc;
+  }, {});
+  const categories = Object.keys(grouped).sort();
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-1 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "field-selector", className: "text-xs font-medium text-gray-700", children: "Field" }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "select",
+      {
+        id: "field-selector",
+        value,
+        onChange: (e) => onChange(e.target.value),
+        className: `
+          w-full px-3 py-2 text-sm border rounded-md
+          bg-white
+          focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent
+          ${error ? "border-red-500" : "border-gray-300"}
+        `,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: "Select a field..." }),
+          categories.map((category) => /* @__PURE__ */ jsxRuntime.jsx("optgroup", { label: category, children: grouped[category].map((field) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: field.name, children: field.label }, field.name)) }, category))
+        ]
+      }
+    ),
+    error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-red-600", children: error })
+  ] });
+}
+
+// src/components/FilterRuleEditor/constants.ts
+var OPERATOR_LABELS = {
+  // Equality
+  eq: "equals",
+  ne: "not equals",
+  // Comparison
+  gt: "greater than",
+  lt: "less than",
+  gte: "greater or equal",
+  lte: "less or equal",
+  // String operations
+  contains: "contains",
+  not_contains: "does not contain",
+  startswith: "starts with",
+  endswith: "ends with",
+  matches: "matches regex",
+  // Array/Set operations
+  in: "is one of",
+  not_in: "is not one of",
+  has_any: "has any of",
+  has_all: "has all of",
+  // Null checks
+  isnull: "is empty",
+  isnotnull: "is not empty",
+  // Tag operations
+  has_tag: "has tag",
+  not_has_tag: "does not have tag",
+  // Boolean
+  is_true: "is true",
+  is_false: "is false"
+};
+var NULL_VALUE_OPERATORS = [
+  "isnull",
+  "isnotnull",
+  "is_true",
+  "is_false"
+];
+var MULTI_VALUE_OPERATORS = [
+  "in",
+  "not_in",
+  "has_any",
+  "has_all"
+];
+function OperatorSelector({
+  operators,
+  value,
+  onChange,
+  disabled = false,
+  error,
+  className = ""
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-1 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "operator-selector", className: "text-xs font-medium text-gray-700", children: "Operator" }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "select",
+      {
+        id: "operator-selector",
+        value,
+        onChange: (e) => onChange(e.target.value),
+        disabled,
+        className: `
+          w-full px-3 py-2 text-sm border rounded-md
+          bg-white
+          focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent
+          disabled:bg-gray-100 disabled:cursor-not-allowed disabled:text-gray-500
+          ${error ? "border-red-500" : "border-gray-300"}
+        `,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: "Select operator..." }),
+          operators.map((op) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: op, children: OPERATOR_LABELS[op] }, op))
+        ]
+      }
+    ),
+    error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-red-600", children: error })
+  ] });
+}
+function TextValueInput({
+  value,
+  onChange,
+  placeholder = "Enter text...",
+  error,
+  className = ""
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-1 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "text-value", className: "text-xs font-medium text-gray-700", children: "Value" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        id: "text-value",
+        type: "text",
+        value: value || "",
+        onChange: (e) => onChange(e.target.value),
+        placeholder,
+        className: `
+          w-full px-3 py-2 text-sm border rounded-md
+          focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent
+          ${error ? "border-red-500" : "border-gray-300"}
+        `
+      }
+    ),
+    error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-red-600", children: error })
+  ] });
+}
+function NumberValueInput({
+  value,
+  onChange,
+  min,
+  max,
+  placeholder = "Enter number...",
+  error,
+  className = ""
+}) {
+  const handleChange = (e) => {
+    const val = e.target.value;
+    if (val === "") {
+      onChange(null);
+    } else {
+      const num = parseFloat(val);
+      if (!isNaN(num)) {
+        onChange(num);
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-1 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "number-value", className: "text-xs font-medium text-gray-700", children: "Value" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        id: "number-value",
+        type: "number",
+        value: value ?? "",
+        onChange: handleChange,
+        min,
+        max,
+        placeholder,
+        className: `
+          w-full px-3 py-2 text-sm border rounded-md
+          focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent
+          ${error ? "border-red-500" : "border-gray-300"}
+        `
+      }
+    ),
+    error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-red-600", children: error })
+  ] });
+}
+function DateValueInput({
+  value,
+  onChange,
+  min,
+  max,
+  placeholder = "Select date...",
+  error,
+  className = ""
+}) {
+  const handleChange = (e) => {
+    const val = e.target.value;
+    onChange(val || null);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-1 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "date-value", className: "text-xs font-medium text-gray-700", children: "Value" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        id: "date-value",
+        type: "date",
+        value: value || "",
+        onChange: handleChange,
+        min,
+        max,
+        placeholder,
+        className: `
+          w-full px-3 py-2 text-sm border rounded-md
+          focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent
+          ${error ? "border-red-500" : "border-gray-300"}
+        `
+      }
+    ),
+    error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-red-600", children: error })
+  ] });
+}
+function BooleanValueInput({
+  value,
+  onChange,
+  label = "True",
+  error,
+  className = ""
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-1 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("label", { className: "text-xs font-medium text-gray-700", children: "Value" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex items-center gap-2 cursor-pointer", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "checkbox",
+          checked: value,
+          onChange: (e) => onChange(e.target.checked),
+          className: "w-4 h-4 text-blue-600 border-gray-300 rounded focus:ring-blue-500"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-gray-700", children: label })
+    ] }),
+    error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-red-600", children: error })
+  ] });
+}
+function ChoiceValueInput({
+  value,
+  onChange,
+  choices,
+  placeholder = "Select option...",
+  error,
+  className = ""
+}) {
+  const getChoiceValue = (choice) => {
+    if (typeof choice === "string") return choice;
+    return choice.value || choice;
+  };
+  const getChoiceLabel = (choice) => {
+    if (typeof choice === "string") return choice;
+    return choice.label || choice.value || String(choice);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-1 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "choice-value", className: "text-xs font-medium text-gray-700", children: "Value" }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "select",
+      {
+        id: "choice-value",
+        value: value || "",
+        onChange: (e) => onChange(e.target.value),
+        className: `
+          w-full px-3 py-2 text-sm border rounded-md
+          bg-white
+          focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent
+          ${error ? "border-red-500" : "border-gray-300"}
+        `,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: placeholder }),
+          choices.map((choice, index) => {
+            const val = getChoiceValue(choice);
+            const label = getChoiceLabel(choice);
+            return /* @__PURE__ */ jsxRuntime.jsx("option", { value: val, children: label }, `${val}-${index}`);
+          })
+        ]
+      }
+    ),
+    error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-red-600", children: error })
+  ] });
+}
+function MultiChoiceValueInput({
+  value = [],
+  onChange,
+  choices,
+  placeholder = "Select options...",
+  error,
+  className = ""
+}) {
+  const getChoiceValue = (choice) => {
+    if (typeof choice === "string") return choice;
+    return choice.value || choice;
+  };
+  const getChoiceLabel = (choice) => {
+    if (typeof choice === "string") return choice;
+    return choice.label || choice.value || String(choice);
+  };
+  const handleAdd = (newValue) => {
+    if (newValue && !value.includes(newValue)) {
+      onChange([...value, newValue]);
+    }
+  };
+  const handleRemove = (removeValue) => {
+    onChange(value.filter((v) => v !== removeValue));
+  };
+  const getValueLabel = (val) => {
+    const choice = choices.find((c) => getChoiceValue(c) === val);
+    return choice ? getChoiceLabel(choice) : val;
+  };
+  const availableChoices = choices.filter(
+    (choice) => !value.includes(getChoiceValue(choice))
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-2 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "multi-choice-value", className: "text-xs font-medium text-gray-700", children: "Values" }),
+    value.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-wrap gap-1.5", children: value.map((val) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "span",
+      {
+        className: "inline-flex items-center gap-1 px-2 py-1 text-xs font-medium text-blue-800 bg-blue-100 rounded",
+        children: [
+          getValueLabel(val),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => handleRemove(val),
+              className: "hover:text-blue-900 focus:outline-none",
+              "aria-label": `Remove ${getValueLabel(val)}`,
+              children: "\xD7"
+            }
+          )
+        ]
+      },
+      val
+    )) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "select",
+      {
+        id: "multi-choice-value",
+        value: "",
+        onChange: (e) => handleAdd(e.target.value),
+        className: `
+          w-full px-3 py-2 text-sm border rounded-md
+          bg-white
+          focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent
+          ${error ? "border-red-500" : "border-gray-300"}
+        `,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: placeholder }),
+          availableChoices.map((choice, index) => {
+            const val = getChoiceValue(choice);
+            const label = getChoiceLabel(choice);
+            return /* @__PURE__ */ jsxRuntime.jsx("option", { value: val, children: label }, `${val}-${index}`);
+          })
+        ]
+      }
+    ),
+    error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-red-600", children: error })
+  ] });
+}
+function RuleRow({
+  rule,
+  onChange,
+  onRemove,
+  fieldRegistry,
+  className = ""
+}) {
+  const selectedField = fieldRegistry.find((f) => f.name === rule.field_path);
+  const availableOperators = selectedField?.operators || [];
+  const needsValue = rule.operator && !NULL_VALUE_OPERATORS.includes(rule.operator);
+  const needsMultiValue = rule.operator && MULTI_VALUE_OPERATORS.includes(rule.operator);
+  const handleFieldChange = (fieldName) => {
+    const field = fieldRegistry.find((f) => f.name === fieldName);
+    onChange({
+      ...rule,
+      field_path: fieldName,
+      operator: field?.operators[0] || "",
+      value: null
+    });
+  };
+  const handleOperatorChange = (operator) => {
+    onChange({
+      ...rule,
+      operator,
+      value: MULTI_VALUE_OPERATORS.includes(operator) ? [] : null
+    });
+  };
+  const handleValueChange = (value) => {
+    onChange({
+      ...rule,
+      value
+    });
+  };
+  const renderValueInput = () => {
+    if (!needsValue) return null;
+    if (!selectedField) return null;
+    const { type, constraints } = selectedField;
+    if (needsMultiValue) {
+      if (constraints?.choices) {
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          MultiChoiceValueInput,
+          {
+            value: Array.isArray(rule.value) ? rule.value : [],
+            onChange: handleValueChange,
+            choices: constraints.choices
+          }
+        );
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        TextValueInput,
+        {
+          value: Array.isArray(rule.value) ? rule.value.join(", ") : "",
+          onChange: (val) => handleValueChange(val.split(",").map((v) => v.trim())),
+          placeholder: "Enter values, comma-separated..."
+        }
+      );
+    }
+    switch (type) {
+      case "string":
+        if (constraints?.choices && rule.operator === "eq") {
+          return /* @__PURE__ */ jsxRuntime.jsx(
+            ChoiceValueInput,
+            {
+              value: rule.value || "",
+              onChange: handleValueChange,
+              choices: constraints.choices
+            }
+          );
+        }
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          TextValueInput,
+          {
+            value: rule.value || "",
+            onChange: handleValueChange
+          }
+        );
+      case "number":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          NumberValueInput,
+          {
+            value: rule.value,
+            onChange: handleValueChange,
+            min: constraints?.min_value,
+            max: constraints?.max_value
+          }
+        );
+      case "date":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DateValueInput,
+          {
+            value: rule.value || null,
+            onChange: handleValueChange,
+            min: constraints?.min_value,
+            max: constraints?.max_value
+          }
+        );
+      case "boolean":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          BooleanValueInput,
+          {
+            value: rule.value || false,
+            onChange: handleValueChange
+          }
+        );
+      case "tag":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          TextValueInput,
+          {
+            value: rule.value || "",
+            onChange: handleValueChange,
+            placeholder: "Enter tag name..."
+          }
+        );
+      default:
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          TextValueInput,
+          {
+            value: rule.value || "",
+            onChange: handleValueChange
+          }
+        );
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: `
+        relative group
+        border border-gray-200 rounded-lg p-4
+        bg-white hover:shadow-sm transition-shadow
+        ${className}
+      `,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: onRemove,
+            className: "\n          absolute top-2 right-2\n          w-6 h-6 flex items-center justify-center\n          text-gray-400 hover:text-red-600 hover:bg-red-50\n          rounded transition-colors\n          focus:outline-none focus:ring-2 focus:ring-red-500\n        ",
+            "aria-label": "Remove rule",
+            children: "\xD7"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-3 pr-8", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            FieldSelector,
+            {
+              fields: fieldRegistry,
+              value: rule.field_path,
+              onChange: handleFieldChange
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            OperatorSelector,
+            {
+              operators: availableOperators,
+              value: rule.operator || "",
+              onChange: handleOperatorChange,
+              disabled: !rule.field_path
+            }
+          ),
+          needsValue && renderValueInput()
+        ] })
+      ]
+    }
+  );
+}
+function FilterRuleEditor({
+  rules,
+  onChange,
+  fieldRegistry,
+  logic = "AND",
+  onLogicChange,
+  className = ""
+}) {
+  const handleAddRule = () => {
+    const newRule = {
+      field_path: "",
+      operator: "eq",
+      value: null
+    };
+    onChange([...rules, newRule]);
+  };
+  const handleUpdateRule = (index, updatedRule) => {
+    const newRules = [...rules];
+    newRules[index] = updatedRule;
+    onChange(newRules);
+  };
+  const handleRemoveRule = (index) => {
+    const newRules = rules.filter((_, i) => i !== index);
+    onChange(newRules);
+  };
+  const ruleErrors = rules.map((rule) => validateFilterRule(rule));
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-4 ${className}`, children: [
+    onLogicChange && /* @__PURE__ */ jsxRuntime.jsx(LogicToggle, { logic, onChange: onLogicChange }),
+    rules.length === 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center justify-center py-12 border-2 border-dashed border-gray-300 rounded-lg bg-gray-50", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "svg",
+        {
+          className: "w-12 h-12 text-gray-400 mb-3",
+          fill: "none",
+          viewBox: "0 0 24 24",
+          stroke: "currentColor",
+          children: /* @__PURE__ */ jsxRuntime.jsx(
+            "path",
+            {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: 2,
+              d: "M3 4a1 1 0 011-1h16a1 1 0 011 1v2.586a1 1 0 01-.293.707l-6.414 6.414a1 1 0 00-.293.707V17l-4 4v-6.586a1 1 0 00-.293-.707L3.293 7.293A1 1 0 013 6.586V4z"
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-gray-600 mb-4", children: "No filter rules yet" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: handleAddRule,
+          className: "\n              inline-flex items-center gap-2\n              px-4 py-2\n              text-sm font-medium text-white\n              bg-blue-600 hover:bg-blue-700\n              rounded-md\n              focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2\n              transition-colors\n            ",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-lg", children: "+" }),
+            "Add First Rule"
+          ]
+        }
+      )
+    ] }),
+    rules.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col gap-3", children: rules.map((rule, index) => /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        RuleRow,
+        {
+          rule,
+          onChange: (updatedRule) => handleUpdateRule(index, updatedRule),
+          onRemove: () => handleRemoveRule(index),
+          fieldRegistry
+        }
+      ),
+      index < rules.length - 1 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center py-2", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "px-3 py-1 text-xs font-semibold text-gray-700 bg-gray-100 border border-gray-300 rounded-full", children: logic }) }),
+      ruleErrors[index].length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 px-4 py-2 bg-red-50 border border-red-200 rounded text-sm text-red-700", children: ruleErrors[index].map((error, i) => /* @__PURE__ */ jsxRuntime.jsx("div", { children: error }, i)) })
+    ] }, index)) }),
+    rules.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: handleAddRule,
+        className: "\n            w-full\n            flex items-center justify-center gap-2\n            px-4 py-3\n            text-sm font-medium text-blue-600\n            bg-white hover:bg-blue-50\n            border-2 border-dashed border-blue-300 hover:border-blue-400\n            rounded-lg\n            focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2\n            transition-colors\n          ",
+        "aria-label": `Add rule ${rules.length + 1}`,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xl", children: "+" }),
+          "Add Rule"
+        ]
+      }
+    ),
+    rules.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between text-xs text-gray-500", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+        rules.length,
+        " ",
+        rules.length === 1 ? "rule" : "rules"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: logic === "AND" ? "All rules must match" : "Any rule can match" })
+    ] })
+  ] });
+}
+var MATCH_ACTIONS = [
+  {
+    value: "continue",
+    label: "Continue",
+    description: "Continue to next stage without tagging"
+  },
+  {
+    value: "tag",
+    label: "Tag & Stop",
+    description: "Add tags and stop processing"
+  },
+  {
+    value: "tag_continue",
+    label: "Tag & Continue",
+    description: "Add tags and continue to next stage"
+  },
+  {
+    value: "output",
+    label: "Output",
+    description: "Add to output and stop processing"
+  }
+];
+var NO_MATCH_ACTIONS = [
+  {
+    value: "continue",
+    label: "Continue",
+    description: "Continue to next stage"
+  },
+  {
+    value: "exclude",
+    label: "Exclude",
+    description: "Exclude from output and stop processing"
+  },
+  {
+    value: "tag_exclude",
+    label: "Tag & Exclude",
+    description: "Add tags, exclude from output, and stop"
+  }
+];
+function StageActions({
+  stage,
+  onMatchActionChange,
+  onNoMatchActionChange
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stage-actions", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-group", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: `match-action-${stage.id}`, className: "form-label", children: "Action on Match" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "select",
+        {
+          id: `match-action-${stage.id}`,
+          value: stage.match_action,
+          onChange: (e) => onMatchActionChange(e.target.value),
+          className: "form-select",
+          children: MATCH_ACTIONS.map((option) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: option.value, children: option.label }, option.value))
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "form-hint", children: MATCH_ACTIONS.find((a) => a.value === stage.match_action)?.description })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-group", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: `no-match-action-${stage.id}`, className: "form-label", children: "Action on No Match" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "select",
+        {
+          id: `no-match-action-${stage.id}`,
+          value: stage.no_match_action,
+          onChange: (e) => onNoMatchActionChange(e.target.value),
+          className: "form-select",
+          children: NO_MATCH_ACTIONS.map((option) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: option.value, children: option.label }, option.value))
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "form-hint", children: NO_MATCH_ACTIONS.find((a) => a.value === stage.no_match_action)?.description })
+    ] })
+  ] });
+}
+function TagInput({
+  tags,
+  onChange,
+  placeholder = "Add tag...",
+  className = ""
+}) {
+  const [inputValue, setInputValue] = react.useState("");
+  const addTag = react.useCallback((tag) => {
+    const trimmed = tag.trim().toLowerCase();
+    if (!trimmed) {
+      return;
+    }
+    if (tags.includes(trimmed)) {
+      return;
+    }
+    onChange([...tags, trimmed]);
+    setInputValue("");
+  }, [tags, onChange]);
+  const removeTag = react.useCallback((index) => {
+    onChange(tags.filter((_, i) => i !== index));
+  }, [tags, onChange]);
+  const handleKeyDown = react.useCallback((e) => {
+    if (e.key === "Enter" || e.key === ",") {
+      e.preventDefault();
+      addTag(inputValue);
+    } else if (e.key === "Backspace" && !inputValue && tags.length > 0) {
+      removeTag(tags.length - 1);
+    }
+  }, [inputValue, tags, addTag, removeTag]);
+  const handleBlur = react.useCallback(() => {
+    if (inputValue) {
+      addTag(inputValue);
+    }
+  }, [inputValue, addTag]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `tag-input ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "tag-input-container", children: [
+      tags.map((tag, index) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "tag-chip", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "tag-text", children: tag }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => removeTag(index),
+            className: "tag-remove",
+            "aria-label": `Remove tag ${tag}`,
+            children: /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "14", height: "14", viewBox: "0 0 14 14", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+              "path",
+              {
+                d: "M4 4l6 6M10 4l-6 6",
+                stroke: "currentColor",
+                strokeWidth: "1.5",
+                strokeLinecap: "round"
+              }
+            ) })
+          }
+        )
+      ] }, index)),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "text",
+          value: inputValue,
+          onChange: (e) => setInputValue(e.target.value),
+          onKeyDown: handleKeyDown,
+          onBlur: handleBlur,
+          placeholder: tags.length === 0 ? placeholder : "",
+          className: "tag-input-field"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "tag-input-hint", children: "Press Enter or comma to add tags" })
+  ] });
+}
+function useDebounce(callback, delay) {
+  const [timeoutId, setTimeoutId] = react.useState(null);
+  return react.useCallback(
+    ((...args) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      const newTimeoutId = setTimeout(() => {
+        callback(...args);
+      }, delay);
+      setTimeoutId(newTimeoutId);
+    }),
+    [callback, delay, timeoutId]
+  );
+}
+function StageForm({
+  stage,
+  onUpdate,
+  fieldRegistry
+}) {
+  const [name, setName] = react.useState(stage.name);
+  const [description, setDescription] = react.useState(stage.description || "");
+  const debouncedUpdateName = useDebounce((value) => {
+    onUpdate({ ...stage, name: value });
+  }, 300);
+  const debouncedUpdateDescription = useDebounce((value) => {
+    onUpdate({ ...stage, description: value });
+  }, 500);
+  const handleNameChange = react.useCallback((e) => {
+    const value = e.target.value;
+    setName(value);
+    debouncedUpdateName(value);
+  }, [debouncedUpdateName]);
+  const handleDescriptionChange = react.useCallback((e) => {
+    const value = e.target.value;
+    setDescription(value);
+    debouncedUpdateDescription(value);
+  }, [debouncedUpdateDescription]);
+  const handleFilterLogicChange = react.useCallback((logic) => {
+    onUpdate({ ...stage, filter_logic: logic });
+  }, [stage, onUpdate]);
+  const handleMatchActionChange = react.useCallback((action) => {
+    onUpdate({ ...stage, match_action: action });
+  }, [stage, onUpdate]);
+  const handleNoMatchActionChange = react.useCallback((action) => {
+    onUpdate({ ...stage, no_match_action: action });
+  }, [stage, onUpdate]);
+  const handleMatchTagsChange = react.useCallback((tags) => {
+    onUpdate({ ...stage, match_tags: tags });
+  }, [stage, onUpdate]);
+  const handleNoMatchTagsChange = react.useCallback((tags) => {
+    onUpdate({ ...stage, no_match_tags: tags });
+  }, [stage, onUpdate]);
+  const handleRulesChange = react.useCallback((rules) => {
+    onUpdate({ ...stage, rules });
+  }, [stage, onUpdate]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stage-form", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-group", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: `stage-name-${stage.id}`, className: "form-label", children: "Stage Name" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          id: `stage-name-${stage.id}`,
+          type: "text",
+          value: name,
+          onChange: handleNameChange,
+          className: "form-input",
+          placeholder: "e.g., High ICP Score",
+          required: true
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-group", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: `stage-desc-${stage.id}`, className: "form-label", children: "Description" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "textarea",
+        {
+          id: `stage-desc-${stage.id}`,
+          value: description,
+          onChange: handleDescriptionChange,
+          className: "form-textarea",
+          placeholder: "Describe the purpose of this stage...",
+          rows: 3
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-group", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { className: "form-label", children: "Filter Logic" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "filter-logic-toggle", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => handleFilterLogicChange("AND"),
+            className: `toggle-button ${stage.filter_logic === "AND" ? "active" : ""}`,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "input",
+                {
+                  type: "radio",
+                  name: `filter-logic-${stage.id}`,
+                  value: "AND",
+                  checked: stage.filter_logic === "AND",
+                  onChange: () => handleFilterLogicChange("AND"),
+                  className: "sr-only"
+                }
+              ),
+              "AND"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => handleFilterLogicChange("OR"),
+            className: `toggle-button ${stage.filter_logic === "OR" ? "active" : ""}`,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "input",
+                {
+                  type: "radio",
+                  name: `filter-logic-${stage.id}`,
+                  value: "OR",
+                  checked: stage.filter_logic === "OR",
+                  onChange: () => handleFilterLogicChange("OR"),
+                  className: "sr-only"
+                }
+              ),
+              "OR"
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "form-hint", children: stage.filter_logic === "AND" ? "All rules must match for this stage to pass" : "At least one rule must match for this stage to pass" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      StageActions,
+      {
+        stage,
+        onMatchActionChange: handleMatchActionChange,
+        onNoMatchActionChange: handleNoMatchActionChange
+      }
+    ),
+    (stage.match_action === "tag" || stage.match_action === "tag_continue") && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-group", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { className: "form-label", children: "Tags on Match" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        TagInput,
+        {
+          tags: stage.match_tags || [],
+          onChange: handleMatchTagsChange,
+          placeholder: "Add tag..."
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "form-hint", children: "Tags to add when rules match" })
+    ] }),
+    stage.no_match_action === "tag_exclude" && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-group", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { className: "form-label", children: "Tags on No Match" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        TagInput,
+        {
+          tags: stage.no_match_tags || [],
+          onChange: handleNoMatchTagsChange,
+          placeholder: "Add tag..."
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "form-hint", children: "Tags to add when rules don't match" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "form-group", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rules-header", children: /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "form-label", children: [
+        "Filter Rules (",
+        stage.rules.length,
+        ")"
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        FilterRuleEditor,
+        {
+          rules: stage.rules,
+          onChange: handleRulesChange,
+          fieldRegistry
+        }
+      )
+    ] })
+  ] });
+}
+function StageCard({
+  stage,
+  expanded,
+  onToggleExpanded,
+  onUpdate,
+  onRemove,
+  fieldRegistry,
+  error,
+  showWarnings = false
+}) {
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    transform,
+    transition,
+    isDragging
+  } = sortable.useSortable({ id: stage.id });
+  const style = {
+    transform: utilities.CSS.Transform.toString(transform),
+    transition,
+    opacity: isDragging ? 0.5 : 1
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref: setNodeRef,
+      style,
+      className: `stage-card ${isDragging ? "dragging" : ""} ${error ? "error" : ""}`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stage-header", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              ...attributes,
+              ...listeners,
+              className: "drag-handle",
+              "aria-label": "Drag to reorder",
+              children: /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "20", height: "20", viewBox: "0 0 20 20", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+                "path",
+                {
+                  d: "M7 4h6M7 10h6M7 16h6",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  strokeLinecap: "round"
+                }
+              ) })
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              onClick: onToggleExpanded,
+              className: "stage-title-button",
+              "aria-expanded": expanded,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "stage-number", children: [
+                  "Stage ",
+                  stage.order + 1,
+                  ":"
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stage-name", children: stage.name || "Untitled Stage" }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "svg",
+                  {
+                    width: "20",
+                    height: "20",
+                    viewBox: "0 0 20 20",
+                    fill: "none",
+                    className: `expand-icon ${expanded ? "expanded" : ""}`,
+                    children: /* @__PURE__ */ jsxRuntime.jsx(
+                      "path",
+                      {
+                        d: "M6 8l4 4 4-4",
+                        stroke: "currentColor",
+                        strokeWidth: "2",
+                        strokeLinecap: "round",
+                        strokeLinejoin: "round"
+                      }
+                    )
+                  }
+                )
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: onRemove,
+              className: "delete-button",
+              "aria-label": "Delete stage",
+              children: /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "20", height: "20", viewBox: "0 0 20 20", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+                "path",
+                {
+                  d: "M6 6l8 8M14 6l-8 8",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  strokeLinecap: "round"
+                }
+              ) })
+            }
+          )
+        ] }),
+        error && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "error-message", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "path",
+              {
+                d: "M8 1l7 13H1L8 1z",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinejoin: "round"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8 6v3M8 11h.01", stroke: "currentColor", strokeWidth: "2" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: error })
+        ] }),
+        showWarnings && !error && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "warning-message", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "8", cy: "8", r: "7", stroke: "currentColor", strokeWidth: "2" }),
+            /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8 5v3M8 10h.01", stroke: "currentColor", strokeWidth: "2" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Stage has no filter rules" })
+        ] }),
+        !expanded && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stage-summary", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "summary-item", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "summary-label", children: "Rules:" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "summary-value", children: stage.rules.length })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "summary-item", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "summary-label", children: "Logic:" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "summary-value", children: stage.filter_logic })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "summary-item", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "summary-label", children: "On Match:" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "summary-value", children: stage.match_action })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "summary-item", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "summary-label", children: "On No Match:" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "summary-value", children: stage.no_match_action })
+          ] })
+        ] }),
+        expanded && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "stage-form-wrapper", children: /* @__PURE__ */ jsxRuntime.jsx(
+          StageForm,
+          {
+            stage,
+            onUpdate,
+            fieldRegistry
+          }
+        ) })
+      ]
+    }
+  );
+}
+function AddStageButton({
+  onClick,
+  position,
+  className = ""
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "button",
+    {
+      type: "button",
+      onClick,
+      className: `add-stage-button ${position} ${className}`,
+      "aria-label": `Add stage ${position === "top" ? "at top" : position === "bottom" ? "at bottom" : "below"}`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "20", height: "20", viewBox: "0 0 20 20", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M10 5v10M5 10h10",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round"
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+          position === "top" && "Add Stage",
+          position === "bottom" && "Add Stage Below",
+          position === "inline" && "Add Stage"
+        ] })
+      ]
+    }
+  );
+}
+function generateStageId() {
+  return `stage-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function createEmptyStage(order) {
+  return {
+    id: generateStageId(),
+    order,
+    name: `Stage ${order + 1}`,
+    description: "",
+    filter_logic: "AND",
+    rules: [],
+    match_action: "continue",
+    no_match_action: "continue",
+    match_tags: [],
+    no_match_tags: []
+  };
+}
+function validateStageName(name, stages, currentStageId) {
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    return "Stage name is required";
+  }
+  const duplicate = stages.find(
+    (s) => s.id !== currentStageId && s.name.trim().toLowerCase() === trimmedName.toLowerCase()
+  );
+  if (duplicate) {
+    return "Stage name must be unique";
+  }
+  return null;
+}
+function FunnelStageBuilder({
+  funnel,
+  onUpdate,
+  fieldRegistry,
+  className = ""
+}) {
+  const [expandedStages, setExpandedStages] = react.useState(
+    new Set(funnel.stages.map((s) => s.id))
+  );
+  const [errors, setErrors] = react.useState(/* @__PURE__ */ new Map());
+  const sensors = core.useSensors(
+    core.useSensor(core.PointerSensor),
+    core.useSensor(core.KeyboardSensor, {
+      coordinateGetter: sortable.sortableKeyboardCoordinates
+    })
+  );
+  const toggleExpanded = react.useCallback((stageId) => {
+    setExpandedStages((prev) => {
+      const next = new Set(prev);
+      if (next.has(stageId)) {
+        next.delete(stageId);
+      } else {
+        next.add(stageId);
+      }
+      return next;
+    });
+  }, []);
+  const handleAddStage = react.useCallback((insertAfterIndex) => {
+    const newOrder = insertAfterIndex !== void 0 ? insertAfterIndex + 1 : funnel.stages.length;
+    const newStage = createEmptyStage(newOrder);
+    const updatedStages = funnel.stages.map((stage) => {
+      if (stage.order >= newOrder) {
+        return { ...stage, order: stage.order + 1 };
+      }
+      return stage;
+    });
+    updatedStages.splice(newOrder, 0, newStage);
+    setExpandedStages((prev) => new Set(prev).add(newStage.id));
+    onUpdate({
+      ...funnel,
+      stages: updatedStages
+    });
+  }, [funnel, onUpdate]);
+  const handleRemoveStage = react.useCallback((stageId) => {
+    const stageIndex = funnel.stages.findIndex((s) => s.id === stageId);
+    if (stageIndex === -1) return;
+    const updatedStages = funnel.stages.filter((s) => s.id !== stageId);
+    updatedStages.forEach((stage, index) => {
+      stage.order = index;
+    });
+    setExpandedStages((prev) => {
+      const next = new Set(prev);
+      next.delete(stageId);
+      return next;
+    });
+    setErrors((prev) => {
+      const next = new Map(prev);
+      next.delete(stageId);
+      return next;
+    });
+    onUpdate({
+      ...funnel,
+      stages: updatedStages
+    });
+  }, [funnel, onUpdate]);
+  const handleUpdateStage = react.useCallback((updatedStage) => {
+    const nameError = validateStageName(updatedStage.name, funnel.stages, updatedStage.id);
+    setErrors((prev) => {
+      const next = new Map(prev);
+      if (nameError) {
+        next.set(updatedStage.id, nameError);
+      } else {
+        next.delete(updatedStage.id);
+      }
+      return next;
+    });
+    const updatedStages = funnel.stages.map(
+      (stage) => stage.id === updatedStage.id ? updatedStage : stage
+    );
+    onUpdate({
+      ...funnel,
+      stages: updatedStages
+    });
+  }, [funnel, onUpdate]);
+  const handleDragEnd = react.useCallback((event) => {
+    const { active, over } = event;
+    if (!over || active.id === over.id) {
+      return;
+    }
+    const oldIndex = funnel.stages.findIndex((s) => s.id === active.id);
+    const newIndex = funnel.stages.findIndex((s) => s.id === over.id);
+    if (oldIndex === -1 || newIndex === -1) {
+      return;
+    }
+    const reorderedStages = sortable.arrayMove(funnel.stages, oldIndex, newIndex);
+    reorderedStages.forEach((stage, index) => {
+      stage.order = index;
+    });
+    onUpdate({
+      ...funnel,
+      stages: reorderedStages
+    });
+  }, [funnel, onUpdate]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `funnel-stage-builder ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mb-4", children: /* @__PURE__ */ jsxRuntime.jsx(AddStageButton, { onClick: () => handleAddStage(), position: "top" }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      core.DndContext,
+      {
+        sensors,
+        collisionDetection: core.closestCenter,
+        onDragEnd: handleDragEnd,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          sortable.SortableContext,
+          {
+            items: funnel.stages.map((s) => s.id),
+            strategy: sortable.verticalListSortingStrategy,
+            children: funnel.stages.map((stage, index) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stage-wrapper", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                StageCard,
+                {
+                  stage,
+                  expanded: expandedStages.has(stage.id),
+                  onToggleExpanded: () => toggleExpanded(stage.id),
+                  onUpdate: handleUpdateStage,
+                  onRemove: () => handleRemoveStage(stage.id),
+                  fieldRegistry,
+                  error: errors.get(stage.id),
+                  showWarnings: stage.rules.length === 0
+                }
+              ),
+              index < funnel.stages.length - 1 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "stage-arrow", children: /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+                "path",
+                {
+                  d: "M12 5v14m0 0l-4-4m4 4l4-4",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round"
+                }
+              ) }) })
+            ] }, stage.id))
+          }
+        )
+      }
+    ),
+    funnel.stages.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-4", children: /* @__PURE__ */ jsxRuntime.jsx(
+      AddStageButton,
+      {
+        onClick: () => handleAddStage(funnel.stages.length - 1),
+        position: "bottom"
+      }
+    ) }),
+    funnel.stages.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "empty-state", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-gray-500 text-center py-8", children: "No stages yet. Add your first stage to get started." }) })
+  ] });
+}
+function RunFilters({
+  filters,
+  onFiltersChange,
+  className = ""
+}) {
+  const updateFilter = (key, value) => {
+    onFiltersChange({ ...filters, [key]: value });
+  };
+  const clearFilters = () => {
+    onFiltersChange({
+      status: "all",
+      trigger_type: "all",
+      date_range: "month"
+    });
+  };
+  const hasActiveFilters = filters.status !== "all" || filters.trigger_type !== "all" || filters.date_range !== "month";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: `flex items-center gap-3 p-3 bg-gray-50 border-b border-gray-200 ${className}`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "status-filter", className: "text-sm font-medium text-gray-700", children: "Status:" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "select",
+            {
+              id: "status-filter",
+              value: filters.status || "all",
+              onChange: (e) => updateFilter("status", e.target.value),
+              className: "px-2 py-1 text-sm border border-gray-300 rounded-md bg-white focus:outline-none focus:ring-2 focus:ring-blue-500",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "all", children: "All" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "completed", children: "Complete" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "running", children: "Running" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "failed", children: "Failed" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "pending", children: "Pending" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "cancelled", children: "Cancelled" })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "trigger-filter", className: "text-sm font-medium text-gray-700", children: "Trigger:" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "select",
+            {
+              id: "trigger-filter",
+              value: filters.trigger_type || "all",
+              onChange: (e) => updateFilter("trigger_type", e.target.value),
+              className: "px-2 py-1 text-sm border border-gray-300 rounded-md bg-white focus:outline-none focus:ring-2 focus:ring-blue-500",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "all", children: "All" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "manual", children: "Manual" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "scheduled", children: "Scheduled" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "webhook", children: "Webhook" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "api", children: "API" })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: "date-filter", className: "text-sm font-medium text-gray-700", children: "Date:" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "select",
+            {
+              id: "date-filter",
+              value: filters.date_range || "month",
+              onChange: (e) => updateFilter("date_range", e.target.value),
+              className: "px-2 py-1 text-sm border border-gray-300 rounded-md bg-white focus:outline-none focus:ring-2 focus:ring-blue-500",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "all", children: "All time" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "today", children: "Today" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "week", children: "Last 7 days" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "month", children: "Last 30 days" })
+              ]
+            }
+          )
+        ] }),
+        hasActiveFilters && /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: clearFilters,
+            className: "ml-auto px-3 py-1 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-md hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-blue-500",
+            children: "Clear filters"
+          }
+        )
+      ]
+    }
+  );
+}
+var statusConfig2 = {
+  completed: {
+    icon: "\u2713",
+    label: "Complete",
+    color: "text-green-800",
+    bgColor: "bg-green-100"
+  },
+  running: {
+    icon: "\u23F8",
+    label: "Running",
+    color: "text-blue-800",
+    bgColor: "bg-blue-100",
+    spinning: true
+  },
+  failed: {
+    icon: "\u2717",
+    label: "Failed",
+    color: "text-red-800",
+    bgColor: "bg-red-100"
+  },
+  pending: {
+    icon: "\u25CB",
+    label: "Pending",
+    color: "text-yellow-800",
+    bgColor: "bg-yellow-100"
+  },
+  cancelled: {
+    icon: "\xD7",
+    label: "Cancelled",
+    color: "text-gray-800",
+    bgColor: "bg-gray-100"
+  }
+};
+function RunStatusBadge({ status, className = "" }) {
+  const config = statusConfig2[status];
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "span",
+    {
+      className: `inline-flex items-center gap-1.5 px-2.5 py-0.5 rounded-full text-xs font-medium ${config.bgColor} ${config.color} ${className}`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: config.spinning ? "animate-spin" : "", "aria-hidden": "true", children: config.icon }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { children: config.label })
+      ]
+    }
+  );
+}
+function RunActions({
+  run,
+  onViewDetails,
+  onViewResults,
+  onReRun,
+  onCancel,
+  className = ""
+}) {
+  const [isOpen, setIsOpen] = react.useState(false);
+  const dropdownRef = react.useRef(null);
+  react.useEffect(() => {
+    const handleClickOutside = (event) => {
+      if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
+        setIsOpen(false);
+      }
+    };
+    if (isOpen) {
+      document.addEventListener("mousedown", handleClickOutside);
+      return () => document.removeEventListener("mousedown", handleClickOutside);
+    }
+  }, [isOpen]);
+  react.useEffect(() => {
+    const handleEscape = (event) => {
+      if (event.key === "Escape" && isOpen) {
+        setIsOpen(false);
+      }
+    };
+    if (isOpen) {
+      document.addEventListener("keydown", handleEscape);
+      return () => document.removeEventListener("keydown", handleEscape);
+    }
+  }, [isOpen]);
+  const canCancel = run.status === "pending" || run.status === "running";
+  const canViewResults = run.status === "completed";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `relative ${className}`, ref: dropdownRef, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        onClick: () => setIsOpen(!isOpen),
+        className: "p-1 text-gray-500 hover:text-gray-700 hover:bg-gray-100 rounded focus:outline-none focus:ring-2 focus:ring-blue-500",
+        "aria-label": "Run actions",
+        "aria-haspopup": "true",
+        "aria-expanded": isOpen,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          "svg",
+          {
+            className: "w-5 h-5",
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "path",
+              {
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeWidth: 2,
+                d: "M12 5v.01M12 12v.01M12 19v.01M12 6a1 1 0 110-2 1 1 0 010 2zm0 7a1 1 0 110-2 1 1 0 010 2zm0 7a1 1 0 110-2 1 1 0 010 2z"
+              }
+            )
+          }
+        )
+      }
+    ),
+    isOpen && /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: "absolute right-0 mt-1 w-48 bg-white rounded-md shadow-lg border border-gray-200 z-10",
+        role: "menu",
+        children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "py-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              onClick: () => {
+                onViewDetails(run);
+                setIsOpen(false);
+              },
+              className: "w-full px-4 py-2 text-left text-sm text-gray-700 hover:bg-gray-100 flex items-center gap-2",
+              role: "menuitem",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", children: "\u{1F441}" }),
+                "View Details"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              onClick: () => {
+                onViewResults(run);
+                setIsOpen(false);
+              },
+              disabled: !canViewResults,
+              className: "w-full px-4 py-2 text-left text-sm text-gray-700 hover:bg-gray-100 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed disabled:hover:bg-white",
+              role: "menuitem",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", children: "\u{1F4CA}" }),
+                "View Results"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              onClick: () => {
+                onReRun(run);
+                setIsOpen(false);
+              },
+              className: "w-full px-4 py-2 text-left text-sm text-gray-700 hover:bg-gray-100 flex items-center gap-2",
+              role: "menuitem",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", children: "\u21BB" }),
+                "Re-run"
+              ]
+            }
+          ),
+          canCancel && onCancel && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-t border-gray-200 my-1" }),
+            /* @__PURE__ */ jsxRuntime.jsxs(
+              "button",
+              {
+                onClick: () => {
+                  if (confirm("Are you sure you want to cancel this run?")) {
+                    onCancel(run);
+                    setIsOpen(false);
+                  }
+                },
+                className: "w-full px-4 py-2 text-left text-sm text-red-600 hover:bg-red-50 flex items-center gap-2",
+                role: "menuitem",
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", children: "\xD7" }),
+                  "Cancel Run"
+                ]
+              }
+            )
+          ] })
+        ] })
+      }
+    )
+  ] });
+}
+
+// src/components/FunnelRunHistory/utils.ts
+function formatDuration(ms) {
+  if (ms === void 0 || ms === null) return "-";
+  if (ms === 0) return "0ms";
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+  }
+  if (minutes > 0) {
+    const remainingSeconds = seconds % 60;
+    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+  }
+  if (seconds > 0) {
+    return `${seconds}s`;
+  }
+  return `${ms}ms`;
+}
+function formatRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const then = new Date(date);
+  const diffMs = now.getTime() - then.getTime();
+  const diffSeconds = Math.floor(diffMs / 1e3);
+  const diffMinutes = Math.floor(diffSeconds / 60);
+  const diffHours = Math.floor(diffMinutes / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffDays > 0) {
+    return `${diffDays}d ago`;
+  }
+  if (diffHours > 0) {
+    return `${diffHours}h ago`;
+  }
+  if (diffMinutes > 0) {
+    return `${diffMinutes}m ago`;
+  }
+  return "Just now";
+}
+function calculateMatchRate(matched, total) {
+  if (total === 0) return 0;
+  return Math.round(matched / total * 100);
+}
+function formatNumber(num) {
+  return num.toLocaleString();
+}
+function formatFullTimestamp(date) {
+  const d = new Date(date);
+  return d.toLocaleString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+}
+function RunRow({
+  run,
+  onViewDetails,
+  onViewResults,
+  onReRun,
+  onCancel
+}) {
+  const matchRate = run.status === "completed" ? calculateMatchRate(run.total_matched, run.total_input) : null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "tr",
+    {
+      onClick: () => onViewDetails(run),
+      onKeyDown: (e) => {
+        if (e.key === "Enter") {
+          onViewDetails(run);
+        }
+      },
+      tabIndex: 0,
+      className: "border-b border-gray-200 hover:bg-gray-50 cursor-pointer transition-colors focus:outline-none focus:ring-2 focus:ring-inset focus:ring-blue-500",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-4 py-3", children: /* @__PURE__ */ jsxRuntime.jsx(
+          "span",
+          {
+            className: "text-sm text-gray-900",
+            title: formatFullTimestamp(run.started_at),
+            children: formatRelativeTime(run.started_at)
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-4 py-3", children: /* @__PURE__ */ jsxRuntime.jsx(RunStatusBadge, { status: run.status }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-4 py-3", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-gray-700 capitalize", children: run.trigger_type }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-4 py-3", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-gray-900", children: formatDuration(run.duration_ms) }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-4 py-3 text-right", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium text-gray-900", children: formatNumber(run.total_input) }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-4 py-3 text-right", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium text-green-600", children: run.status === "completed" ? formatNumber(run.total_matched) : "-" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-4 py-3 text-right", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium text-gray-900", children: matchRate !== null ? `${matchRate}%` : "-" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("td", { className: "px-4 py-3", onClick: (e) => e.stopPropagation(), children: /* @__PURE__ */ jsxRuntime.jsx(
+          RunActions,
+          {
+            run,
+            onViewDetails,
+            onViewResults,
+            onReRun,
+            onCancel
+          }
+        ) })
+      ]
+    }
+  );
+}
+function StageBreakdownList({
+  stages,
+  className = ""
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `space-y-3 ${className}`, children: stages.map((stage, index) => {
+    const delta = stage.matched_count - stage.input_count;
+    const matchRate = stage.input_count > 0 ? Math.round(stage.matched_count / stage.input_count * 100) : 0;
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: "p-3 bg-gray-50 rounded-lg border border-gray-200",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 mb-2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex items-center justify-center w-6 h-6 text-xs font-bold text-white bg-blue-600 rounded-full", children: index + 1 }),
+            /* @__PURE__ */ jsxRuntime.jsx("h4", { className: "text-sm font-semibold text-gray-900", children: stage.stage_name })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-3 gap-2 text-center", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-gray-600 mb-1", children: "Input" }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-lg font-bold text-blue-600", children: formatNumber(stage.input_count) })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-gray-600 mb-1", children: "Matched" }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-lg font-bold text-green-600", children: formatNumber(stage.matched_count) })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-gray-600 mb-1", children: "Rate" }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-lg font-bold text-gray-700", children: [
+                matchRate,
+                "%"
+              ] })
+            ] })
+          ] }),
+          delta !== 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 pt-2 border-t border-gray-200", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-center gap-1 text-sm", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(
+              "span",
+              {
+                className: `font-medium ${delta > 0 ? "text-green-600" : "text-red-600"}`,
+                children: [
+                  delta > 0 ? "\u25B2" : "\u25BC",
+                  " ",
+                  formatNumber(Math.abs(delta))
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-500", children: delta > 0 ? "added" : "excluded" })
+          ] }) }),
+          stage.error_count && stage.error_count > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 pt-2 border-t border-gray-200", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-sm text-red-600 text-center", children: [
+            "\u26A0 ",
+            formatNumber(stage.error_count),
+            " errors"
+          ] }) })
+        ]
+      },
+      stage.stage_id
+    );
+  }) });
+}
+function RunDetailsModal({
+  run,
+  onClose,
+  onViewResults,
+  onReRun
+}) {
+  const modalRef = react.useRef(null);
+  react.useEffect(() => {
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        onClose();
+      }
+    };
+    if (run) {
+      document.addEventListener("keydown", handleEscape);
+      document.body.style.overflow = "hidden";
+      return () => {
+        document.removeEventListener("keydown", handleEscape);
+        document.body.style.overflow = "unset";
+      };
+    }
+  }, [run, onClose]);
+  react.useEffect(() => {
+    if (run && modalRef.current) {
+      const focusableElements = modalRef.current.querySelectorAll(
+        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+      );
+      const firstElement = focusableElements[0];
+      const lastElement = focusableElements[focusableElements.length - 1];
+      firstElement?.focus();
+      const handleTab = (e) => {
+        if (e.key !== "Tab") return;
+        if (e.shiftKey && document.activeElement === firstElement) {
+          e.preventDefault();
+          lastElement?.focus();
+        } else if (!e.shiftKey && document.activeElement === lastElement) {
+          e.preventDefault();
+          firstElement?.focus();
+        }
+      };
+      document.addEventListener("keydown", handleTab);
+      return () => document.removeEventListener("keydown", handleTab);
+    }
+  }, [run]);
+  if (!run) return null;
+  const stageStatsArray = Object.values(run.stage_stats);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: "fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-50",
+      onClick: onClose,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": "modal-title",
+      children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          ref: modalRef,
+          onClick: (e) => e.stopPropagation(),
+          className: "bg-white rounded-lg shadow-xl max-w-2xl w-full max-h-[90vh] overflow-hidden flex flex-col",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-6 py-4 border-b border-gray-200", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("h2", { id: "modal-title", className: "text-lg font-semibold text-gray-900", children: "Run Details" }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  onClick: onClose,
+                  className: "p-1 text-gray-400 hover:text-gray-600 rounded focus:outline-none focus:ring-2 focus:ring-blue-500",
+                  "aria-label": "Close modal",
+                  children: /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "w-5 h-5", fill: "currentColor", viewBox: "0 0 20 20", children: /* @__PURE__ */ jsxRuntime.jsx(
+                    "path",
+                    {
+                      fillRule: "evenodd",
+                      d: "M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z",
+                      clipRule: "evenodd"
+                    }
+                  ) })
+                }
+              )
+            ] }) }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "px-6 py-4 overflow-y-auto flex-1", children: [
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mb-6", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-2 gap-4 mb-4", children: [
+                  /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-gray-600 mb-1", children: "Status" }),
+                    /* @__PURE__ */ jsxRuntime.jsx(RunStatusBadge, { status: run.status })
+                  ] }),
+                  /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-gray-600 mb-1", children: "Duration" }),
+                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm font-medium text-gray-900", children: formatDuration(run.duration_ms) })
+                  ] }),
+                  /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-gray-600 mb-1", children: "Started" }),
+                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm font-medium text-gray-900", children: /* @__PURE__ */ jsxRuntime.jsx("span", { title: formatFullTimestamp(run.started_at), children: formatRelativeTime(run.started_at) }) })
+                  ] }),
+                  /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs text-gray-600 mb-1", children: "Triggered by" }),
+                    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-sm font-medium text-gray-900", children: [
+                      run.triggered_by || "System",
+                      " (",
+                      run.trigger_type,
+                      ")"
+                    ] })
+                  ] })
+                ] }),
+                run.status === "failed" && run.error && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-3 bg-red-50 border border-red-200 rounded-lg", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm font-medium text-red-800 mb-1", children: "Error" }),
+                  /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-red-700", children: run.error })
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+                /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-sm font-semibold text-gray-900 mb-3", children: "Stage Breakdown" }),
+                stageStatsArray.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(StageBreakdownList, { stages: stageStatsArray }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-gray-500 text-center py-4", children: "No stage data available" })
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "px-6 py-4 border-t border-gray-200 flex items-center justify-end gap-3", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  onClick: onClose,
+                  className: "px-4 py-2 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-md hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-blue-500",
+                  children: "Close"
+                }
+              ),
+              onReRun && /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  onClick: () => {
+                    onReRun(run);
+                    onClose();
+                  },
+                  className: "px-4 py-2 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-md hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-blue-500",
+                  children: "\u21BB Re-run"
+                }
+              ),
+              onViewResults && run.status === "completed" && /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  onClick: () => {
+                    onViewResults(run);
+                    onClose();
+                  },
+                  className: "px-4 py-2 text-sm font-medium text-white bg-blue-600 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500",
+                  children: "View Results"
+                }
+              )
+            ] })
+          ]
+        }
+      )
+    }
+  );
+}
+function FunnelRunHistory({
+  funnelId,
+  apiClient,
+  onViewResults,
+  className = ""
+}) {
+  const [runs, setRuns] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [selectedRun, setSelectedRun] = react.useState(null);
+  const [filters, setFilters] = react.useState({
+    status: "all",
+    trigger_type: "all",
+    date_range: "month"
+  });
+  const [pagination, setPagination] = react.useState({
+    page: 1,
+    page_size: 10,
+    total: 0
+  });
+  const [isRefreshing, setIsRefreshing] = react.useState(false);
+  const loadRuns = react.useCallback(async () => {
+    try {
+      setError(null);
+      const params = {
+        page: pagination.page,
+        page_size: pagination.page_size,
+        ordering: "-started_at"
+        // Most recent first
+      };
+      if (filters.status && filters.status !== "all") {
+        params.status = filters.status;
+      }
+      if (filters.trigger_type && filters.trigger_type !== "all") {
+        params.trigger_type = filters.trigger_type;
+      }
+      const response = await apiClient.getFunnelRuns(funnelId, params);
+      setRuns(response.results);
+      setPagination((prev) => ({
+        ...prev,
+        total: response.count
+      }));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load runs");
+      console.error("Failed to load funnel runs:", err);
+    } finally {
+      setIsLoading(false);
+      setIsRefreshing(false);
+    }
+  }, [funnelId, apiClient, pagination.page, pagination.page_size, filters]);
+  react.useEffect(() => {
+    loadRuns();
+  }, [loadRuns]);
+  react.useEffect(() => {
+    const hasActiveRuns = runs.some(
+      (r) => r.status === "pending" || r.status === "running"
+    );
+    if (hasActiveRuns) {
+      const interval = setInterval(() => {
+        setIsRefreshing(true);
+        loadRuns();
+      }, 5e3);
+      return () => clearInterval(interval);
+    }
+  }, [runs, loadRuns]);
+  const handleRefresh = () => {
+    setIsRefreshing(true);
+    loadRuns();
+  };
+  const handleReRun = async (run) => {
+    try {
+      await apiClient.runFunnel(funnelId, {
+        trigger_type: "manual",
+        metadata: { re_run_of: run.id }
+      });
+      loadRuns();
+    } catch (err) {
+      console.error("Failed to re-run funnel:", err);
+      alert("Failed to re-run funnel. Please try again.");
+    }
+  };
+  const handleCancel = async (run) => {
+    try {
+      await apiClient.cancelFunnelRun(run.id);
+      loadRuns();
+    } catch (err) {
+      console.error("Failed to cancel run:", err);
+      alert("Failed to cancel run. Please try again.");
+    }
+  };
+  const handleViewResults = (run) => {
+    if (onViewResults) {
+      onViewResults(run);
+    } else {
+      setSelectedRun(run);
+    }
+  };
+  const totalPages = Math.ceil(pagination.total / pagination.page_size);
+  const canGoBack = pagination.page > 1;
+  const canGoForward = pagination.page < totalPages;
+  const handlePreviousPage = () => {
+    if (canGoBack) {
+      setPagination((prev) => ({ ...prev, page: prev.page - 1 }));
+    }
+  };
+  const handleNextPage = () => {
+    if (canGoForward) {
+      setPagination((prev) => ({ ...prev, page: prev.page + 1 }));
+    }
+  };
+  const startIndex = (pagination.page - 1) * pagination.page_size + 1;
+  const endIndex = Math.min(
+    pagination.page * pagination.page_size,
+    pagination.total
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `bg-white rounded-lg border border-gray-200 ${className}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "px-6 py-4 border-b border-gray-200 flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "text-lg font-semibold text-gray-900", children: "Funnel Run History" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          onClick: handleRefresh,
+          disabled: isRefreshing,
+          className: "px-3 py-1.5 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-md hover:bg-gray-50 disabled:opacity-50 disabled:cursor-not-allowed focus:outline-none focus:ring-2 focus:ring-blue-500",
+          "aria-label": "Refresh run history",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: isRefreshing ? "animate-spin inline-block" : "", children: "\u21BB" }),
+            " ",
+            "Refresh"
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(RunFilters, { filters, onFiltersChange: setFilters }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "overflow-x-auto", children: /* @__PURE__ */ jsxRuntime.jsxs("table", { className: "w-full", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("thead", { className: "bg-gray-50 border-b border-gray-200", children: /* @__PURE__ */ jsxRuntime.jsxs("tr", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-4 py-3 text-left text-xs font-medium text-gray-600 uppercase tracking-wider", children: "Date" }),
+        /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-4 py-3 text-left text-xs font-medium text-gray-600 uppercase tracking-wider", children: "Status" }),
+        /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-4 py-3 text-left text-xs font-medium text-gray-600 uppercase tracking-wider", children: "Trigger" }),
+        /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-4 py-3 text-left text-xs font-medium text-gray-600 uppercase tracking-wider", children: "Duration" }),
+        /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-600 uppercase tracking-wider", children: "Input" }),
+        /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-600 uppercase tracking-wider", children: "Matched" }),
+        /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-600 uppercase tracking-wider", children: "%" }),
+        /* @__PURE__ */ jsxRuntime.jsx("th", { className: "px-4 py-3 text-right text-xs font-medium text-gray-600 uppercase tracking-wider", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sr-only", children: "Actions" }) })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx("tbody", { children: isLoading && runs.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("tr", { children: /* @__PURE__ */ jsxRuntime.jsx("td", { colSpan: 8, className: "px-4 py-12 text-center", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-gray-500", children: "Loading runs..." }) }) }) : error ? /* @__PURE__ */ jsxRuntime.jsx("tr", { children: /* @__PURE__ */ jsxRuntime.jsxs("td", { colSpan: 8, className: "px-4 py-12 text-center", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-red-600", children: [
+          "Error: ",
+          error
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: loadRuns,
+            className: "mt-2 text-sm text-blue-600 hover:text-blue-700 underline",
+            children: "Try again"
+          }
+        )
+      ] }) }) : runs.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("tr", { children: /* @__PURE__ */ jsxRuntime.jsx("td", { colSpan: 8, className: "px-4 py-12 text-center", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-gray-500", children: "No runs found. Run this funnel to see history." }) }) }) : runs.map((run) => /* @__PURE__ */ jsxRuntime.jsx(
+        RunRow,
+        {
+          run,
+          onViewDetails: setSelectedRun,
+          onViewResults: handleViewResults,
+          onReRun: handleReRun,
+          onCancel: handleCancel
+        },
+        run.id
+      )) })
+    ] }) }),
+    runs.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "px-6 py-3 border-t border-gray-200 flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-sm text-gray-600", children: [
+        "Showing ",
+        startIndex,
+        "-",
+        endIndex,
+        " of ",
+        pagination.total
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: handlePreviousPage,
+            disabled: !canGoBack,
+            className: "px-3 py-1 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-md hover:bg-gray-50 disabled:opacity-50 disabled:cursor-not-allowed focus:outline-none focus:ring-2 focus:ring-blue-500",
+            "aria-label": "Previous page",
+            children: "\u2039"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-sm text-gray-600", children: [
+          "Page ",
+          pagination.page,
+          " of ",
+          totalPages
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: handleNextPage,
+            disabled: !canGoForward,
+            className: "px-3 py-1 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-md hover:bg-gray-50 disabled:opacity-50 disabled:cursor-not-allowed focus:outline-none focus:ring-2 focus:ring-blue-500",
+            "aria-label": "Next page",
+            children: "\u203A"
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      RunDetailsModal,
+      {
+        run: selectedRun,
+        onClose: () => setSelectedRun(null),
+        onViewResults,
+        onReRun: handleReRun
+      }
+    )
+  ] });
+}
+
+exports.AddStageButton = AddStageButton;
+exports.BooleanValueInput = BooleanValueInput;
+exports.ChoiceValueInput = ChoiceValueInput;
+exports.DateValueInput = DateValueInput;
+exports.EntityCard = EntityCard;
+exports.FetchAdapter = FetchAdapter;
+exports.FieldSelector = FieldSelector;
+exports.FilterRuleEditor = FilterRuleEditor;
+exports.FlowLegend = FlowLegend;
+exports.FunnelApiClient = FunnelApiClient;
+exports.FunnelCard = FunnelCard;
+exports.FunnelEngine = FunnelEngine;
+exports.FunnelPreview = FunnelPreview;
+exports.FunnelRunHistory = FunnelRunHistory;
+exports.FunnelStageBuilder = FunnelStageBuilder;
+exports.FunnelStats = FunnelStats;
+exports.FunnelVisualFlow = FunnelVisualFlow;
+exports.LoadingPreview = LoadingPreview;
+exports.LogicToggle = LogicToggle;
+exports.MULTI_VALUE_OPERATORS = MULTI_VALUE_OPERATORS;
+exports.MatchBar = MatchBar;
+exports.MultiChoiceValueInput = MultiChoiceValueInput;
+exports.NULL_VALUE_OPERATORS = NULL_VALUE_OPERATORS;
+exports.NumberValueInput = NumberValueInput;
+exports.OPERATOR_LABELS = OPERATOR_LABELS;
+exports.OperatorSelector = OperatorSelector;
+exports.PreviewStats = PreviewStats;
+exports.RuleRow = RuleRow;
+exports.RunActions = RunActions;
+exports.RunDetailsModal = RunDetailsModal;
+exports.RunFilters = RunFilters;
+exports.RunRow = RunRow;
+exports.RunStatusBadge = RunStatusBadge;
+exports.StageActions = StageActions;
+exports.StageBreakdown = StageBreakdown;
+exports.StageBreakdownList = StageBreakdownList;
+exports.StageCard = StageCard;
+exports.StageForm = StageForm;
+exports.StageIndicator = StageIndicator;
+exports.StageNode = StageNode;
+exports.StatusBadge = StatusBadge;
+exports.TagInput = TagInput;
+exports.TextValueInput = TextValueInput;
+exports.applyOperator = applyOperator;
+exports.calculateMatchRate = calculateMatchRate;
+exports.createApiError = createApiError;
+exports.createFunnelStore = createFunnelStore;
+exports.createInitialState = createInitialState;
+exports.evaluateRule = evaluateRule;
+exports.evaluateRuleWithResult = evaluateRuleWithResult;
+exports.evaluateRules = evaluateRules;
+exports.evaluateRulesAND = evaluateRulesAND;
+exports.evaluateRulesOR = evaluateRulesOR;
+exports.evaluateRulesWithResults = evaluateRulesWithResults;
+exports.filterEntities = filterEntities;
+exports.formatDuration = formatDuration;
+exports.formatFullTimestamp = formatFullTimestamp;
+exports.formatNumber = formatNumber;
+exports.formatRelativeTime = formatRelativeTime;
+exports.getCircledNumber = getCircledNumber;
+exports.getFields = getFields;
+exports.getValidOperators = getValidOperators;
+exports.hasField = hasField;
+exports.isApiError = isApiError;
+exports.isFieldDefinition = isFieldDefinition;
+exports.isFilterRule = isFilterRule;
+exports.isFunnel = isFunnel;
+exports.isFunnelResult = isFunnelResult;
+exports.isFunnelRun = isFunnelRun;
+exports.isStage = isStage;
+exports.isValidOperator = isValidOperator;
+exports.resolveField = resolveField;
+exports.setField = setField;
+exports.useDebouncedValue = useDebouncedValue;
+exports.validateFilterRule = validateFilterRule;
+exports.validateFunnel = validateFunnel;
+exports.validateStage = validateStage;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map