@mastra/playground-ui 61.0.0 → 62.0.0-alpha.0

package/dist/domains/traces/trace-filters.cjs.js

@@ -3,657 +3,62 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const traces = require('@mastra/react/hooks/traces');
-const lucideReact = require('lucide-react');
-const domains_traces_traceQueryFilters = require('./trace-query-filters.cjs.js');
-const types = require('../../types-Ns4ZNp-g.cjs');
-const utils_colors = require('../../utils/colors.cjs.js');
+require('lucide-react');
+const domains_traces_traceQueryFilters = require('../../trace-filters-Cvo41yor.cjs');
+require('../../types-Ns4ZNp-g.cjs');
+require('../../utils/colors.cjs.js');
+
 
-const ROOT_ENTITY_TYPE_OPTIONS = [
-  { label: "Agent", entityType: traces.ROOT_ENTITY_TYPES.AGENT },
-  { label: "Workflow", entityType: traces.ROOT_ENTITY_TYPES.WORKFLOW },
-  { label: "Scorer", entityType: traces.ROOT_ENTITY_TYPES.SCORER },
-  { label: "Ingest", entityType: traces.ROOT_ENTITY_TYPES.INGEST }
-];
-const TRACE_STATUS_OPTIONS = [
-  { label: "Running", value: "running" },
-  { label: "Success", value: "success" },
-  { label: "Error", value: "error" }
-];
-const TRACE_SYNTHETIC_FILTER_FIELD_IDS = ["rootEntityType", "status"];
-const TRACE_METADATA_FILTER_FIELD_PREFIX = "metadata.";
-const TRACE_METADATA_FILTER_PARAM_PREFIX = "filterMetadata.";
-const isTraceMetadataFieldId = (fieldId) => fieldId.startsWith(TRACE_METADATA_FILTER_FIELD_PREFIX) && fieldId.length > TRACE_METADATA_FILTER_FIELD_PREFIX.length;
-const isTraceMetadataParam = (param) => param.startsWith(TRACE_METADATA_FILTER_PARAM_PREFIX) && param.length > TRACE_METADATA_FILTER_PARAM_PREFIX.length;
-const metadataFieldIdToParam = (fieldId) => TRACE_METADATA_FILTER_PARAM_PREFIX + fieldId.slice(TRACE_METADATA_FILTER_FIELD_PREFIX.length);
-const metadataParamToFieldId = (param) => TRACE_METADATA_FILTER_FIELD_PREFIX + param.slice(TRACE_METADATA_FILTER_PARAM_PREFIX.length);
-const TRACE_ROOT_ENTITY_TYPE_PARAM = "rootEntityType";
-const TRACE_STATUS_PARAM = "status";
-const TRACE_LIST_MODE_PARAM = "listMode";
-const TRACE_ANCHOR_SPAN_ID_PARAM = "anchorSpanId";
-const TRACE_LIST_MODE_VALUES = /* @__PURE__ */ new Set(["traces", "branches"]);
-const TRACE_LIST_MODE_OPTIONS = [
-  { label: "Traces (default)", value: "traces" },
-  { label: "Branches", value: "branches" }
-];
-const TRACE_DATE_PRESET_PARAM = "datePreset";
-const TRACE_DATE_FROM_PARAM = "dateFrom";
-const TRACE_DATE_TO_PARAM = "dateTo";
-const TRACE_DATE_PRESET_VALUES = /* @__PURE__ */ new Set([
-  "all",
-  "last-24h",
-  "last-3d",
-  "last-7d",
-  "last-14d",
-  "last-30d",
-  "custom"
-]);
-const TRACE_PROPERTY_FILTER_PARAM_BY_FIELD = {
-  tags: "filterTags",
-  entityId: "filterEntityId",
-  entityName: "filterEntityName",
-  traceId: "filterTraceId",
-  runId: "filterRunId",
-  threadId: "filterThreadId",
-  sessionId: "filterSessionId",
-  requestId: "filterRequestId",
-  resourceId: "filterResourceId",
-  userId: "filterUserId",
-  organizationId: "filterOrganizationId",
-  serviceName: "filterServiceName",
-  environment: "filterEnvironment",
-  experimentId: "filterExperimentId",
-  "spans.name": "filterSpanName",
-  "spans.spanType": "filterSpanType",
-  "spans.model": "filterSpanModel",
-  "spans.provider": "filterSpanProvider",
-  "spans.durationMs": "filterSpanDurationMs",
-  "spans.error": "filterSpanError",
-  "scores.scorerId": "filterScorerId",
-  "scores.score": "filterScore",
-  "feedback.feedbackType": "filterFeedbackType",
-  "feedback.value": "filterFeedbackValue",
-  "feedback.comment": "filterFeedbackComment"
-};
-const TRACE_PROPERTY_FILTER_FIELD_IDS = Object.keys(TRACE_PROPERTY_FILTER_PARAM_BY_FIELD);
-const TRACE_FILTER_OPERATOR_PARAM_SUFFIX = ".op";
-const traceFilterOperatorParam = (valueParam) => valueParam + TRACE_FILTER_OPERATOR_PARAM_SUFFIX;
-const isTraceFilterOperatorParam = (param) => param.endsWith(TRACE_FILTER_OPERATOR_PARAM_SUFFIX);
-const isPresenceOperator = (operatorId) => operatorId === "exists" || operatorId === "notExists";
-const isManyOperator = (operatorId) => operatorId === "in" || operatorId === "notIn";
-const traceFilterTokenOperator = (token) => token.operatorId ?? (Array.isArray(token.value) ? "in" : "is");
-const readTraceFilterOperator = (searchParams, valueParam) => {
-  const raw = searchParams.get(traceFilterOperatorParam(valueParam));
-  return raw !== null && domains_traces_traceQueryFilters.isTraceFilterOperatorId(raw) ? raw : void 0;
-};
-const TRACE_STATUS_VALUES = /* @__PURE__ */ new Set(["running", "success", "error"]);
-const DEFAULT_TRACE_FILTERS_STORAGE_KEY = "mastra:traces:saved-filters";
-function saveTraceFiltersToStorage(params, storageKey = DEFAULT_TRACE_FILTERS_STORAGE_KEY) {
-  const serialized = getPreservedTraceFilterParams(params);
-  const preset = params.get(TRACE_DATE_PRESET_PARAM);
-  if (preset && preset !== "custom") serialized.set(TRACE_DATE_PRESET_PARAM, preset);
-  const groups = getTraceFilterGroups(serialized).filter((group) => group.nodes.length > 0);
-  serialized.delete(TRACE_FILTER_GROUP_PARAM);
-  for (const group of groups) serialized.append(TRACE_FILTER_GROUP_PARAM, serializeTraceFilterGroup(group));
-  if (!serialized.toString()) {
-    clearSavedTraceFilters(storageKey);
-    return;
-  }
-  try {
-    localStorage.setItem(storageKey, serialized.toString());
-  } catch {
-  }
-}
-function clearSavedTraceFilters(storageKey = DEFAULT_TRACE_FILTERS_STORAGE_KEY) {
-  try {
-    localStorage.removeItem(storageKey);
-  } catch {
-  }
-}
-function loadTraceFiltersFromStorage(storageKey = DEFAULT_TRACE_FILTERS_STORAGE_KEY) {
-  try {
-    const raw = localStorage.getItem(storageKey);
-    if (!raw) return null;
-    const parsed = new URLSearchParams(raw);
-    return parsed.toString() ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function hasAnyTraceFilterParams(params) {
-  if (params.has(TRACE_DATE_PRESET_PARAM)) return true;
-  if (params.has(TRACE_DATE_FROM_PARAM)) return true;
-  if (params.has(TRACE_DATE_TO_PARAM)) return true;
-  if (params.has(TRACE_ROOT_ENTITY_TYPE_PARAM)) return true;
-  if (params.has(TRACE_STATUS_PARAM)) return true;
-  if (params.has(TRACE_LIST_MODE_PARAM)) return true;
-  if (params.has(TRACE_FILTER_GROUP_PARAM)) return true;
-  for (const fieldId of TRACE_PROPERTY_FILTER_FIELD_IDS) {
-    if (params.has(TRACE_PROPERTY_FILTER_PARAM_BY_FIELD[fieldId])) return true;
-  }
-  for (const param of params.keys()) {
-    if (isTraceMetadataParam(param)) return true;
-  }
-  return false;
-}
-const TRACE_FILTER_BAR_OPERATORS = [
-  { id: "is", label: "is" },
-  { id: "isNot", label: "is not" },
-  { id: "in", label: "is any of", arity: "many" },
-  { id: "notIn", label: "is none of", arity: "many" },
-  { id: "exists", label: "exists", arity: "none" },
-  { id: "notExists", label: "does not exist", arity: "none" },
-  { id: "gt", label: "greater than" },
-  { id: "gte", label: "at least" },
-  { id: "lt", label: "less than" },
-  { id: "lte", label: "at most" }
-];
-const TRACE_STRING_OPERATORS = ["is", "isNot", "in", "notIn", "exists", "notExists"];
-const TRACE_REQUIRED_STRING_OPERATORS = ["is", "isNot", "in", "notIn"];
-const TRACE_NUMBER_OPERATORS = [
-  "is",
-  "isNot",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "exists",
-  "notExists"
-];
-const TRACE_PRESENCE_OPERATORS = ["exists", "notExists"];
-const TRACE_SYNTHETIC_OPERATORS = ["is", "in"];
-const TRACE_LEGACY_OPERATORS = ["is"];
-const TRACE_FILTER_BAR_LABELS = {
-  rootEntityType: "Primitive type",
-  entityName: "Primitive name",
-  entityId: "Primitive ID",
-  status: "Status",
-  tags: "Tags",
-  serviceName: "Service Name",
-  environment: "Environment",
-  traceId: "Trace ID",
-  runId: "Run ID",
-  threadId: "Thread ID",
-  sessionId: "Session ID",
-  requestId: "Request ID",
-  resourceId: "Resource ID",
-  userId: "User ID",
-  organizationId: "Organization ID",
-  experimentId: "Experiment ID",
-  "spans.name": "Span name",
-  "spans.spanType": "Span type",
-  "spans.model": "Model",
-  "spans.provider": "Provider",
-  "spans.durationMs": "Span duration (ms)",
-  "spans.error": "Span error",
-  "scores.scorerId": "Scorer",
-  "scores.score": "Score",
-  "feedback.feedbackType": "Feedback type",
-  "feedback.value": "Feedback value",
-  "feedback.comment": "Feedback comment"
-};
-const TRACE_FILTER_BAR_FIELD_META = {
-  timeRange: { icon: lucideReact.ClockIcon, color: utils_colors.hueAccentColor("amber") },
-  rootEntityType: { icon: lucideReact.BoxIcon, color: utils_colors.hueAccentColor("purple") },
-  entityName: { icon: lucideReact.TagIcon, color: utils_colors.hueAccentColor("cyan") },
-  entityId: { icon: lucideReact.FingerprintIcon, color: utils_colors.hueAccentColor("pink") },
-  status: { icon: lucideReact.ActivityIcon, color: utils_colors.hueAccentColor("orange") },
-  tags: { icon: lucideReact.TagsIcon, color: utils_colors.hueAccentColor("pink") },
-  serviceName: { icon: lucideReact.ServerIcon, color: utils_colors.hueAccentColor("cyan") },
-  environment: { icon: lucideReact.GlobeIcon, color: utils_colors.hueAccentColor("green") },
-  traceId: { icon: lucideReact.WaypointsIcon, color: utils_colors.hueAccentColor("blue") },
-  runId: { icon: lucideReact.PlayIcon, color: utils_colors.hueAccentColor("purple") },
-  threadId: { icon: lucideReact.MessageSquareIcon, color: utils_colors.hueAccentColor("blue") },
-  sessionId: { icon: lucideReact.LayersIcon, color: utils_colors.hueAccentColor("orange") },
-  requestId: { icon: lucideReact.RadioIcon, color: utils_colors.hueAccentColor("amber") },
-  resourceId: { icon: lucideReact.HashIcon, color: utils_colors.hueAccentColor("green") },
-  userId: { icon: lucideReact.UserIcon, color: utils_colors.hueAccentColor("orange") },
-  organizationId: { icon: lucideReact.BuildingIcon, color: utils_colors.hueAccentColor("cyan") },
-  experimentId: { icon: lucideReact.FlaskConicalIcon, color: utils_colors.hueAccentColor("pink") },
-  "spans.name": { icon: lucideReact.GitBranchIcon, color: utils_colors.hueAccentColor("blue") },
-  "spans.spanType": { icon: lucideReact.ShapesIcon, color: utils_colors.hueAccentColor("purple") },
-  "spans.model": { icon: lucideReact.CpuIcon, color: utils_colors.hueAccentColor("green") },
-  "spans.provider": { icon: lucideReact.CloudIcon, color: utils_colors.hueAccentColor("cyan") },
-  "spans.durationMs": { icon: lucideReact.TimerIcon, color: utils_colors.hueAccentColor("orange") },
-  "spans.error": { icon: lucideReact.TriangleAlertIcon, color: "var(--destructive-foreground)" },
-  "scores.scorerId": { icon: lucideReact.GaugeIcon, color: utils_colors.hueAccentColor("green") },
-  "scores.score": { icon: lucideReact.PercentIcon, color: utils_colors.hueAccentColor("amber") },
-  "feedback.feedbackType": { icon: lucideReact.ThumbsUpIcon, color: utils_colors.hueAccentColor("purple") },
-  "feedback.value": { icon: lucideReact.StarIcon, color: utils_colors.hueAccentColor("amber") },
-  "feedback.comment": { icon: lucideReact.MessageCircleIcon, color: utils_colors.hueAccentColor("blue") }
-};
-const traceFilterFieldIcon = (fieldId) => TRACE_FILTER_BAR_FIELD_META[fieldId]?.icon;
-const traceFilterFieldColor = (fieldId) => {
-  return TRACE_FILTER_BAR_FIELD_META[fieldId]?.color ?? utils_colors.hueAccentColor(utils_colors.hueForName(fieldId));
-};
-const traceFieldBase = (id) => ({
-  id,
-  label: TRACE_FILTER_BAR_LABELS[id] ?? id,
-  icon: traceFilterFieldIcon(id),
-  color: traceFilterFieldColor(id)
-});
-const TRACE_FILTER_BAR_TEXT_FIELD_IDS = [
-  "entityId",
-  "traceId",
-  "runId",
-  "threadId",
-  "sessionId",
-  "requestId",
-  "resourceId",
-  "userId",
-  "organizationId",
-  "experimentId"
-];
-const TRACE_FILTER_BAR_RELATED_FIELD_IDS = [
-  "spans.name",
-  "spans.spanType",
-  "spans.model",
-  "spans.provider",
-  "spans.durationMs",
-  "spans.error",
-  "scores.scorerId",
-  "scores.score",
-  "feedback.feedbackType",
-  "feedback.value",
-  "feedback.comment"
-];
-const TRACE_FILTER_BAR_PRESENCE_FIELD_IDS = /* @__PURE__ */ new Set(["spans.error", "feedback.comment"]);
-const byLabel = (a, b) => a.label.localeCompare(b.label);
-function createTraceFilterBarFields({
-  availableRootEntityNames,
-  availableEnvironments,
-  hiddenFieldIds = [],
-  metadataFields = [],
-  valueSuggestions,
-  withQueryTrace = true
-}) {
-  const pick = (id, suggestions, operators = TRACE_STRING_OPERATORS) => ({
-    ...traceFieldBase(id),
-    operators,
-    strict: true,
-    suggestions
-  });
-  const text = (id) => ({
-    ...traceFieldBase(id),
-    operators: id === "traceId" ? TRACE_REQUIRED_STRING_OPERATORS : TRACE_STRING_OPERATORS
-  });
-  const relatedPick = (id) => {
-    const [scope, path] = id.split(".");
-    const resolver = valueSuggestions?.(scope, path);
-    return {
-      ...traceFieldBase(id),
-      operators: TRACE_STRING_OPERATORS,
-      ...resolver ? { strict: true, suggestions: resolver } : {}
-    };
-  };
-  const number = (id) => ({
-    ...traceFieldBase(id),
-    type: "number",
-    operators: TRACE_NUMBER_OPERATORS
-  });
-  const presence = (id) => ({ ...traceFieldBase(id), operators: TRACE_PRESENCE_OPERATORS });
-  const pickFields = [
-    pick(
-      "rootEntityType",
-      ROOT_ENTITY_TYPE_OPTIONS.map((o) => ({ value: o.entityType, label: o.label })),
-      TRACE_SYNTHETIC_OPERATORS
-    ),
-    pick(
-      "entityName",
-      availableRootEntityNames.map((name) => ({ value: name })),
-      TRACE_REQUIRED_STRING_OPERATORS
-    ),
-    pick(
-      "status",
-      TRACE_STATUS_OPTIONS.filter((o) => o.value !== "running").map((o) => ({ value: o.value, label: o.label })),
-      TRACE_SYNTHETIC_OPERATORS
-    ),
-    pick(
-      "environment",
-      availableEnvironments.map((env) => ({ value: env }))
-    )
-  ];
-  const textFields = TRACE_FILTER_BAR_TEXT_FIELD_IDS.map(text);
-  const relatedFields = ["spans", "scores", "feedback"].flatMap(
-    (scope) => TRACE_FILTER_BAR_RELATED_FIELD_IDS.filter((id) => id.startsWith(`${scope}.`)).map((id) => {
-      if (domains_traces_traceQueryFilters.TRACE_QUERY_NUMERIC_FIELD_IDS.has(id)) return number(id);
-      if (TRACE_FILTER_BAR_PRESENCE_FIELD_IDS.has(id)) return presence(id);
-      return relatedPick(id);
-    }).sort(byLabel)
-  );
-  const metadataBarFields = metadataFields.filter(({ path }) => isTraceMetadataFieldId(path)).map(({ path, suggestions }) => ({
-    id: path,
-    label: path.slice(TRACE_METADATA_FILTER_FIELD_PREFIX.length),
-    icon: lucideReact.BracesIcon,
-    color: utils_colors.hueAccentColor(utils_colors.hueForName(path)),
-    operators: TRACE_STRING_OPERATORS,
-    suggestions
-  }));
-  const hidden = new Set(hiddenFieldIds);
-  if (!withQueryTrace) {
-    return [...pickFields.sort(byLabel), ...textFields.sort(byLabel)].map((field) => ({
-      ...field,
-      operators: TRACE_LEGACY_OPERATORS,
-      ...hidden.has(field.id) ? { hidden: true } : {}
-    }));
-  }
-  return [
-    ...pickFields.sort(byLabel),
-    ...textFields.sort(byLabel),
-    ...relatedFields,
-    ...metadataBarFields.sort(byLabel)
-  ].filter((field) => !domains_traces_traceQueryFilters.TRACE_QUERY_UNSUPPORTED_FILTER_FIELDS.has(field.id)).map((field) => hidden.has(field.id) ? { ...field, hidden: true } : field);
-}
-function traceTokensToFilterBarItems(tokens) {
-  return tokens.map((token) => ({
-    id: token.fieldId,
-    fieldId: token.fieldId,
-    operatorId: traceFilterTokenOperator(token),
-    value: token.value === "Any" ? "" : token.value
-  }));
-}
-function filterBarItemsToTraceTokens(items) {
-  return items.map(filterBarItemToTraceToken);
-}
-function filterBarItemToTraceToken(item) {
-  const token = {
-    fieldId: item.fieldId,
-    value: Array.isArray(item.value) ? item.value.map(String) : String(item.value)
-  };
-  if (domains_traces_traceQueryFilters.isTraceFilterOperatorId(item.operatorId) && item.operatorId !== traceFilterTokenOperator(token)) {
-    token.operatorId = item.operatorId;
-  }
-  return token;
-}
-function traceFiltersToFilterBarExpression(tokens, groups) {
-  return { logic: "and", nodes: [...traceTokensToFilterBarItems(tokens), ...groups.map(traceGroupToFilterBarGroup)] };
-}
-function traceGroupToFilterBarGroup(group) {
-  return {
-    id: group.id,
-    kind: "group",
-    logic: group.logic,
-    nodes: group.nodes.map(
-      (node) => domains_traces_traceQueryFilters.isTraceFilterGroup(node) ? traceGroupToFilterBarGroup(node) : {
-        id: node.id ?? node.fieldId,
-        fieldId: node.fieldId,
-        operatorId: traceFilterTokenOperator(node),
-        value: node.value === "Any" ? "" : node.value
-      }
-    )
-  };
-}
-function filterBarExpressionToTraceFilters(expression) {
-  const items = expression.nodes.filter((node) => !types.isFilterBarGroup(node));
-  const groups = expression.nodes.filter(types.isFilterBarGroup).map(filterBarGroupToTraceGroup);
-  return { tokens: filterBarItemsToTraceTokens(items), groups };
-}
-function filterBarGroupToTraceGroup(group) {
-  const nodes = group.nodes.map(
-    (node) => types.isFilterBarGroup(node) ? filterBarGroupToTraceGroup(node) : { id: node.id, ...filterBarItemToTraceToken(node) }
-  );
-  return { id: group.id, logic: group.logic, nodes };
-}
-function getTracePropertyFilterTokens(searchParams) {
-  const tokens = [];
-  const paramToFieldId = /* @__PURE__ */ new Map([
-    [TRACE_ROOT_ENTITY_TYPE_PARAM, "rootEntityType"],
-    [TRACE_STATUS_PARAM, "status"]
-  ]);
-  for (const fieldId of TRACE_PROPERTY_FILTER_FIELD_IDS) {
-    paramToFieldId.set(TRACE_PROPERTY_FILTER_PARAM_BY_FIELD[fieldId], fieldId);
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const [paramName] of searchParams.entries()) {
-    if (isTraceFilterOperatorParam(paramName)) continue;
-    const fieldId = isTraceMetadataParam(paramName) ? metadataParamToFieldId(paramName) : paramToFieldId.get(paramName);
-    if (!fieldId || seen.has(fieldId)) continue;
-    seen.add(fieldId);
-    const operatorId = readTraceFilterOperator(searchParams, paramName);
-    const raw = searchParams.getAll(paramName);
-    if (fieldId === "tags" || isManyOperator(operatorId)) {
-      tokens.push({ fieldId, value: raw.filter(Boolean), ...operatorId ? { operatorId } : {} });
-      continue;
-    }
-    const value = raw[0];
-    if (value !== void 0) tokens.push({ fieldId, value, ...operatorId ? { operatorId } : {} });
-  }
-  return tokens;
-}
-function getPreservedTraceFilterParams(searchParams) {
-  const next = new URLSearchParams();
-  const rootEntityType = searchParams.get(TRACE_ROOT_ENTITY_TYPE_PARAM);
-  if (rootEntityType) next.set(TRACE_ROOT_ENTITY_TYPE_PARAM, rootEntityType);
-  const status = searchParams.get(TRACE_STATUS_PARAM);
-  if (status) next.set(TRACE_STATUS_PARAM, status);
-  const listMode = searchParams.get(TRACE_LIST_MODE_PARAM);
-  if (listMode) next.set(TRACE_LIST_MODE_PARAM, listMode);
-  const preserve = (param) => {
-    const operatorId = readTraceFilterOperator(searchParams, param);
-    const values = searchParams.getAll(param).filter((value) => value || isPresenceOperator(operatorId));
-    if (!values.length) return;
-    for (const value of values) next.append(param, value);
-    if (operatorId) next.set(traceFilterOperatorParam(param), operatorId);
-  };
-  for (const fieldId of TRACE_PROPERTY_FILTER_FIELD_IDS) {
-    const param = TRACE_PROPERTY_FILTER_PARAM_BY_FIELD[fieldId];
-    if (fieldId === "tags") {
-      for (const value of searchParams.getAll(param)) {
-        next.append(param, value);
-      }
-      continue;
-    }
-    preserve(param);
-  }
-  const seenMetadata = /* @__PURE__ */ new Set();
-  for (const param of searchParams.keys()) {
-    if (!isTraceMetadataParam(param) || isTraceFilterOperatorParam(param) || seenMetadata.has(param)) continue;
-    seenMetadata.add(param);
-    preserve(param);
-  }
-  for (const group of getTraceFilterGroups(searchParams)) {
-    next.append(TRACE_FILTER_GROUP_PARAM, serializeTraceFilterGroup(group));
-  }
-  return next;
-}
-function applyTracePropertyFilterTokens(params, tokens, groups = []) {
-  params.delete(TRACE_ROOT_ENTITY_TYPE_PARAM);
-  params.delete(TRACE_STATUS_PARAM);
-  params.delete(TRACE_FILTER_GROUP_PARAM);
-  for (const fieldId of TRACE_PROPERTY_FILTER_FIELD_IDS) {
-    const param = TRACE_PROPERTY_FILTER_PARAM_BY_FIELD[fieldId];
-    params.delete(param);
-    params.delete(traceFilterOperatorParam(param));
-  }
-  for (const param of Array.from(params.keys())) {
-    if (isTraceMetadataParam(param)) params.delete(param);
-  }
-  for (const token of tokens) {
-    if (token.fieldId === "rootEntityType" && typeof token.value === "string") {
-      params.set(TRACE_ROOT_ENTITY_TYPE_PARAM, token.value);
-      continue;
-    }
-    if (token.fieldId === "status" && typeof token.value === "string") {
-      params.set(TRACE_STATUS_PARAM, token.value);
-      continue;
-    }
-    const param = isTraceMetadataFieldId(token.fieldId) ? metadataFieldIdToParam(token.fieldId) : TRACE_PROPERTY_FILTER_PARAM_BY_FIELD[token.fieldId];
-    if (!param) continue;
-    if (Array.isArray(token.value)) {
-      if (token.value.length === 0) {
-        params.append(param, "");
-      } else {
-        for (const value of token.value) {
-          params.append(param, value);
-        }
-      }
-    } else {
-      params.set(param, token.value.trim());
-    }
-    const operatorId = traceFilterTokenOperator(token);
-    const implicit = token.fieldId === "tags" ? "in" : "is";
-    if (operatorId !== implicit) params.set(traceFilterOperatorParam(param), operatorId);
-  }
-  for (const group of groups) {
-    params.append(TRACE_FILTER_GROUP_PARAM, serializeTraceFilterGroup(group));
-  }
-}
-const TRACE_FILTER_GROUP_PARAM = "filterGroup";
-const serializeTraceFilterGroup = (group) => JSON.stringify(group);
-function getTraceFilterGroups(searchParams) {
-  return searchParams.getAll(TRACE_FILTER_GROUP_PARAM).map(parseTraceFilterGroupParam).filter((group) => group !== void 0);
-}
-function parseTraceFilterGroupParam(raw) {
-  try {
-    return parseTraceFilterGroup(JSON.parse(raw));
-  } catch {
-    return void 0;
-  }
-}
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
-function parseTraceFilterGroup(input) {
-  if (!isRecord(input) || typeof input.id !== "string") return void 0;
-  if (input.logic !== "and" && input.logic !== "or") return void 0;
-  if (!Array.isArray(input.nodes)) return void 0;
-  const nodes = input.nodes.map(parseTraceFilterNode).filter((node) => node !== void 0);
-  return { id: input.id, logic: input.logic, nodes };
-}
-function parseTraceFilterNode(input) {
-  if (!isRecord(input)) return void 0;
-  if ("nodes" in input) return parseTraceFilterGroup(input);
-  if (typeof input.id !== "string" || typeof input.fieldId !== "string") return void 0;
-  if (typeof input.value !== "string" && !isStringArray(input.value)) return void 0;
-  const token = { id: input.id, fieldId: input.fieldId, value: input.value };
-  if (typeof input.operatorId === "string" && domains_traces_traceQueryFilters.isTraceFilterOperatorId(input.operatorId)) {
-    token.operatorId = input.operatorId;
-  }
-  return token;
-}
-function buildTraceListFilters({
-  rootEntityType,
-  status,
-  dateFrom,
-  dateTo,
-  tokens
-}) {
-  const filters = {};
-  if (rootEntityType) {
-    filters.entityType = rootEntityType;
-  }
-  if (status) {
-    filters.status = status;
-  }
-  if (dateFrom) {
-    filters.startedAt = { start: dateFrom };
-  }
-  if (dateTo) {
-    filters.endedAt = { end: dateTo };
-  }
-  for (const token of tokens) {
-    if (token.fieldId === "tags") {
-      if (Array.isArray(token.value) && token.value.length > 0) {
-        filters.tags = token.value;
-      } else if (typeof token.value === "string" && token.value.trim()) {
-        filters.tags = [token.value.trim()];
-      }
-      continue;
-    }
-    if (typeof token.value !== "string") continue;
-    if (!token.value.trim()) continue;
-    if (token.value === "Any") continue;
-    switch (token.fieldId) {
-      case "entityId":
-        filters.entityId = token.value;
-        break;
-      case "entityName":
-        filters.entityName = token.value;
-        break;
-      case "traceId":
-        filters.traceId = token.value;
-        break;
-      case "runId":
-        filters.runId = token.value;
-        break;
-      case "threadId":
-        filters.threadId = token.value;
-        break;
-      case "sessionId":
-        filters.sessionId = token.value;
-        break;
-      case "requestId":
-        filters.requestId = token.value;
-        break;
-      case "resourceId":
-        filters.resourceId = token.value;
-        break;
-      case "userId":
-        filters.userId = token.value;
-        break;
-      case "organizationId":
-        filters.organizationId = token.value;
-        break;
-      case "serviceName":
-        filters.serviceName = token.value;
-        break;
-      case "environment":
-        filters.environment = token.value;
-        break;
-      case "experimentId":
-        filters.experimentId = token.value;
-        break;
-    }
-  }
-  return filters;
-}
 
 Object.defineProperty(exports, "ROOT_ENTITY_TYPES", {
-  enumerable: true,
-  get: () => traces.ROOT_ENTITY_TYPES
+	enumerable: true,
+	get: () => traces.ROOT_ENTITY_TYPES
 });
+exports.DEFAULT_TRACE_FILTERS_STORAGE_KEY = domains_traces_traceQueryFilters.DEFAULT_TRACE_FILTERS_STORAGE_KEY;
+exports.ROOT_ENTITY_TYPE_OPTIONS = domains_traces_traceQueryFilters.ROOT_ENTITY_TYPE_OPTIONS;
+exports.TRACE_ANCHOR_SPAN_ID_PARAM = domains_traces_traceQueryFilters.TRACE_ANCHOR_SPAN_ID_PARAM;
+exports.TRACE_DATE_FROM_PARAM = domains_traces_traceQueryFilters.TRACE_DATE_FROM_PARAM;
+exports.TRACE_DATE_PRESET_PARAM = domains_traces_traceQueryFilters.TRACE_DATE_PRESET_PARAM;
+exports.TRACE_DATE_PRESET_VALUES = domains_traces_traceQueryFilters.TRACE_DATE_PRESET_VALUES;
+exports.TRACE_DATE_TO_PARAM = domains_traces_traceQueryFilters.TRACE_DATE_TO_PARAM;
+exports.TRACE_FILTER_BAR_OPERATORS = domains_traces_traceQueryFilters.TRACE_FILTER_BAR_OPERATORS;
+exports.TRACE_FILTER_GROUP_PARAM = domains_traces_traceQueryFilters.TRACE_FILTER_GROUP_PARAM;
+exports.TRACE_FILTER_OPERATOR_PARAM_SUFFIX = domains_traces_traceQueryFilters.TRACE_FILTER_OPERATOR_PARAM_SUFFIX;
+exports.TRACE_LIST_MODE_OPTIONS = domains_traces_traceQueryFilters.TRACE_LIST_MODE_OPTIONS;
+exports.TRACE_LIST_MODE_PARAM = domains_traces_traceQueryFilters.TRACE_LIST_MODE_PARAM;
+exports.TRACE_LIST_MODE_VALUES = domains_traces_traceQueryFilters.TRACE_LIST_MODE_VALUES;
+exports.TRACE_METADATA_FILTER_FIELD_PREFIX = domains_traces_traceQueryFilters.TRACE_METADATA_FILTER_FIELD_PREFIX;
+exports.TRACE_METADATA_FILTER_PARAM_PREFIX = domains_traces_traceQueryFilters.TRACE_METADATA_FILTER_PARAM_PREFIX;
+exports.TRACE_PROPERTY_FILTER_FIELD_IDS = domains_traces_traceQueryFilters.TRACE_PROPERTY_FILTER_FIELD_IDS;
+exports.TRACE_PROPERTY_FILTER_PARAM_BY_FIELD = domains_traces_traceQueryFilters.TRACE_PROPERTY_FILTER_PARAM_BY_FIELD;
+exports.TRACE_ROOT_ENTITY_TYPE_PARAM = domains_traces_traceQueryFilters.TRACE_ROOT_ENTITY_TYPE_PARAM;
+exports.TRACE_STATUS_OPTIONS = domains_traces_traceQueryFilters.TRACE_STATUS_OPTIONS;
+exports.TRACE_STATUS_PARAM = domains_traces_traceQueryFilters.TRACE_STATUS_PARAM;
+exports.TRACE_STATUS_VALUES = domains_traces_traceQueryFilters.TRACE_STATUS_VALUES;
+exports.TRACE_SYNTHETIC_FILTER_FIELD_IDS = domains_traces_traceQueryFilters.TRACE_SYNTHETIC_FILTER_FIELD_IDS;
+exports.applyTracePropertyFilterTokens = domains_traces_traceQueryFilters.applyTracePropertyFilterTokens;
+exports.buildTraceListFilters = domains_traces_traceQueryFilters.buildTraceListFilters;
+exports.clearSavedTraceFilters = domains_traces_traceQueryFilters.clearSavedTraceFilters;
+exports.createTraceFilterBarFields = domains_traces_traceQueryFilters.createTraceFilterBarFields;
+exports.filterBarExpressionToTraceFilters = domains_traces_traceQueryFilters.filterBarExpressionToTraceFilters;
+exports.filterBarItemsToTraceTokens = domains_traces_traceQueryFilters.filterBarItemsToTraceTokens;
+exports.getPreservedTraceFilterParams = domains_traces_traceQueryFilters.getPreservedTraceFilterParams;
+exports.getTraceFilterGroups = domains_traces_traceQueryFilters.getTraceFilterGroups;
+exports.getTracePropertyFilterTokens = domains_traces_traceQueryFilters.getTracePropertyFilterTokens;
+exports.hasAnyTraceFilterParams = domains_traces_traceQueryFilters.hasAnyTraceFilterParams;
+exports.isLegacyAnyValue = domains_traces_traceQueryFilters.isLegacyAnyValue;
 exports.isTraceFilterGroup = domains_traces_traceQueryFilters.isTraceFilterGroup;
-exports.DEFAULT_TRACE_FILTERS_STORAGE_KEY = DEFAULT_TRACE_FILTERS_STORAGE_KEY;
-exports.ROOT_ENTITY_TYPE_OPTIONS = ROOT_ENTITY_TYPE_OPTIONS;
-exports.TRACE_ANCHOR_SPAN_ID_PARAM = TRACE_ANCHOR_SPAN_ID_PARAM;
-exports.TRACE_DATE_FROM_PARAM = TRACE_DATE_FROM_PARAM;
-exports.TRACE_DATE_PRESET_PARAM = TRACE_DATE_PRESET_PARAM;
-exports.TRACE_DATE_PRESET_VALUES = TRACE_DATE_PRESET_VALUES;
-exports.TRACE_DATE_TO_PARAM = TRACE_DATE_TO_PARAM;
-exports.TRACE_FILTER_BAR_OPERATORS = TRACE_FILTER_BAR_OPERATORS;
-exports.TRACE_FILTER_GROUP_PARAM = TRACE_FILTER_GROUP_PARAM;
-exports.TRACE_FILTER_OPERATOR_PARAM_SUFFIX = TRACE_FILTER_OPERATOR_PARAM_SUFFIX;
-exports.TRACE_LIST_MODE_OPTIONS = TRACE_LIST_MODE_OPTIONS;
-exports.TRACE_LIST_MODE_PARAM = TRACE_LIST_MODE_PARAM;
-exports.TRACE_LIST_MODE_VALUES = TRACE_LIST_MODE_VALUES;
-exports.TRACE_METADATA_FILTER_FIELD_PREFIX = TRACE_METADATA_FILTER_FIELD_PREFIX;
-exports.TRACE_METADATA_FILTER_PARAM_PREFIX = TRACE_METADATA_FILTER_PARAM_PREFIX;
-exports.TRACE_PROPERTY_FILTER_FIELD_IDS = TRACE_PROPERTY_FILTER_FIELD_IDS;
-exports.TRACE_PROPERTY_FILTER_PARAM_BY_FIELD = TRACE_PROPERTY_FILTER_PARAM_BY_FIELD;
-exports.TRACE_ROOT_ENTITY_TYPE_PARAM = TRACE_ROOT_ENTITY_TYPE_PARAM;
-exports.TRACE_STATUS_OPTIONS = TRACE_STATUS_OPTIONS;
-exports.TRACE_STATUS_PARAM = TRACE_STATUS_PARAM;
-exports.TRACE_STATUS_VALUES = TRACE_STATUS_VALUES;
-exports.TRACE_SYNTHETIC_FILTER_FIELD_IDS = TRACE_SYNTHETIC_FILTER_FIELD_IDS;
-exports.applyTracePropertyFilterTokens = applyTracePropertyFilterTokens;
-exports.buildTraceListFilters = buildTraceListFilters;
-exports.clearSavedTraceFilters = clearSavedTraceFilters;
-exports.createTraceFilterBarFields = createTraceFilterBarFields;
-exports.filterBarExpressionToTraceFilters = filterBarExpressionToTraceFilters;
-exports.filterBarItemsToTraceTokens = filterBarItemsToTraceTokens;
-exports.getPreservedTraceFilterParams = getPreservedTraceFilterParams;
-exports.getTraceFilterGroups = getTraceFilterGroups;
-exports.getTracePropertyFilterTokens = getTracePropertyFilterTokens;
-exports.hasAnyTraceFilterParams = hasAnyTraceFilterParams;
-exports.isTraceMetadataFieldId = isTraceMetadataFieldId;
-exports.loadTraceFiltersFromStorage = loadTraceFiltersFromStorage;
-exports.metadataFieldIdToParam = metadataFieldIdToParam;
-exports.metadataParamToFieldId = metadataParamToFieldId;
-exports.parseTraceFilterGroupParam = parseTraceFilterGroupParam;
-exports.saveTraceFiltersToStorage = saveTraceFiltersToStorage;
-exports.serializeTraceFilterGroup = serializeTraceFilterGroup;
-exports.traceFilterFieldColor = traceFilterFieldColor;
-exports.traceFilterFieldIcon = traceFilterFieldIcon;
-exports.traceFilterOperatorParam = traceFilterOperatorParam;
-exports.traceFilterTokenOperator = traceFilterTokenOperator;
-exports.traceFiltersToFilterBarExpression = traceFiltersToFilterBarExpression;
-exports.traceTokensToFilterBarItems = traceTokensToFilterBarItems;
+exports.isTraceMetadataFieldId = domains_traces_traceQueryFilters.isTraceMetadataFieldId;
+exports.loadTraceFiltersFromStorage = domains_traces_traceQueryFilters.loadTraceFiltersFromStorage;
+exports.metadataFieldIdToParam = domains_traces_traceQueryFilters.metadataFieldIdToParam;
+exports.metadataParamToFieldId = domains_traces_traceQueryFilters.metadataParamToFieldId;
+exports.parseTraceFilterGroupParam = domains_traces_traceQueryFilters.parseTraceFilterGroupParam;
+exports.saveTraceFiltersToStorage = domains_traces_traceQueryFilters.saveTraceFiltersToStorage;
+exports.serializeTraceFilterGroup = domains_traces_traceQueryFilters.serializeTraceFilterGroup;
+exports.traceFilterFieldColor = domains_traces_traceQueryFilters.traceFilterFieldColor;
+exports.traceFilterFieldIcon = domains_traces_traceQueryFilters.traceFilterFieldIcon;
+exports.traceFilterOperatorParam = domains_traces_traceQueryFilters.traceFilterOperatorParam;
+exports.traceFilterTokenOperator = domains_traces_traceQueryFilters.traceFilterTokenOperator;
+exports.traceFiltersToFilterBarExpression = domains_traces_traceQueryFilters.traceFiltersToFilterBarExpression;
+exports.traceTokensToFilterBarItems = domains_traces_traceQueryFilters.traceTokensToFilterBarItems;
 //# sourceMappingURL=trace-filters.cjs.js.map