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

package/dist/trace-filters-Cvo41yor.cjs

@@ -0,0 +1,909 @@
+'use strict';
+
+const traces = require('@mastra/react/hooks/traces');
+const lucideReact = require('lucide-react');
+const types = require('./types-Ns4ZNp-g.cjs');
+const utils_colors = require('./utils/colors.cjs.js');
+
+const TRACE_QUERY_UNSUPPORTED_FILTER_FIELDS = /* @__PURE__ */ new Set([
+  "runId",
+  "sessionId",
+  "requestId",
+  "userId",
+  "organizationId",
+  "serviceName",
+  "experimentId"
+]);
+const TRACE_FILTER_OPERATOR_IDS = [
+  "is",
+  "isNot",
+  "in",
+  "notIn",
+  "exists",
+  "notExists",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "matches",
+  "notMatches"
+];
+const isTraceFilterOperatorId = (value) => TRACE_FILTER_OPERATOR_IDS.includes(value);
+const isTraceFilterGroup = (node) => "nodes" in node;
+const TRACE_FILTER_OPERATOR_TO_QUERY_OP = {
+  is: "eq",
+  isNot: "ne",
+  in: "in",
+  notIn: "notIn",
+  exists: "exists",
+  notExists: "notExists",
+  gt: "gt",
+  gte: "gte",
+  lt: "lt",
+  lte: "lte",
+  matches: "matches",
+  notMatches: "notMatches"
+};
+const TRACE_QUERY_NUMERIC_FIELD_IDS = /* @__PURE__ */ new Set(["spans.durationMs", "scores.score", "feedback.value"]);
+const TRACE_QUERY_TRACE_FIELD_IDS = /* @__PURE__ */ new Set([
+  "entityType",
+  "status",
+  "entityName",
+  "environment",
+  "traceId",
+  "threadId",
+  "resourceId"
+]);
+const TRACE_QUERY_OPTIONAL_TRACE_FIELD_IDS = /* @__PURE__ */ new Set(["threadId", "resourceId", "environment"]);
+const NEGATIVE_TO_POSITIVE = {
+  isNot: "is",
+  notIn: "in",
+  notExists: "exists",
+  notMatches: "matches"
+};
+const isNegativeOperator = (op) => op in NEGATIVE_TO_POSITIVE;
+const TRACE_QUERY_RELATED_SCOPES = ["spans", "scores", "feedback"];
+function resolveTraceQueryPath(fieldId) {
+  if (fieldId === "entityId") return { scope: "spans", path: "entityId" };
+  for (const scope of TRACE_QUERY_RELATED_SCOPES) {
+    if (fieldId.startsWith(`${scope}.`) && fieldId.length > scope.length + 1) {
+      return { scope, path: fieldId.slice(scope.length + 1) };
+    }
+  }
+  return { path: fieldId };
+}
+function scalarPredicate(op, path, values) {
+  const queryOp = TRACE_FILTER_OPERATOR_TO_QUERY_OP[op];
+  switch (queryOp) {
+    case "exists":
+    case "notExists":
+      return { op: queryOp, path };
+    case "in":
+    case "notIn":
+      return values.length ? { op: queryOp, value: { path }, set: values } : void 0;
+    case "matches":
+    case "notMatches": {
+      const [literal] = values;
+      return typeof literal === "string" ? { op: queryOp, left: { path }, right: { literal } } : void 0;
+    }
+    default: {
+      if (!values.length) return void 0;
+      if (values.length > 1) {
+        if (queryOp === "eq") return { op: "in", value: { path }, set: values };
+        if (queryOp === "ne") return { op: "notIn", value: { path }, set: values };
+      }
+      const [literal] = values;
+      return literal === void 0 ? void 0 : { op: queryOp, left: { path }, right: { literal } };
+    }
+  }
+}
+function tagsPredicate(operatorId, tags) {
+  if (operatorId === "exists" || operatorId === "notExists") return { op: operatorId, path: "tags" };
+  const negative = operatorId === "notIn" || operatorId === "isNot";
+  const args = tags.map((value) => ({
+    op: negative ? "notIncludes" : "includes",
+    path: "tags",
+    value
+  }));
+  const combined = args.length <= 1 ? args[0] : { op: negative ? "and" : "or", args };
+  if (!combined || !negative) return combined;
+  return { op: "or", args: [combined, { op: "notExists", path: "tags" }] };
+}
+const TRACE_QUERY_PRESENCE_ONLY_FIELD_IDS = /* @__PURE__ */ new Set(["spans.error", "feedback.comment"]);
+function tokenToTraceQueryPredicate(token) {
+  if (TRACE_QUERY_UNSUPPORTED_FILTER_FIELDS.has(token.fieldId)) return void 0;
+  const operatorId = token.operatorId ?? (token.fieldId === "tags" ? "in" : "is");
+  const isPresence = operatorId === "exists" || operatorId === "notExists";
+  if (TRACE_QUERY_PRESENCE_ONLY_FIELD_IDS.has(token.fieldId) && !isPresence) return void 0;
+  const rawValues = (Array.isArray(token.value) ? token.value : [token.value]).filter(
+    (value) => typeof value === "string" && Boolean(value.trim()) && !isLegacyAnyValue(value, operatorId)
+  );
+  if (!rawValues.length && !isPresence) return void 0;
+  if (token.fieldId === "tags") {
+    const predicate2 = tagsPredicate(operatorId, rawValues);
+    return predicate2 ? { predicate: predicate2 } : void 0;
+  }
+  let fieldId = token.fieldId;
+  let values = rawValues;
+  if (fieldId.startsWith("metadata.")) {
+    if (fieldId.length === "metadata.".length) return void 0;
+  } else if (fieldId === "rootEntityType" || fieldId === "entityType") {
+    fieldId = "entityType";
+  } else if (fieldId === "status") {
+    values = rawValues.filter((value) => value !== "running");
+    if (!values.length && !isPresence) return void 0;
+  } else if (TRACE_QUERY_NUMERIC_FIELD_IDS.has(fieldId)) {
+    values = rawValues.map(Number).filter((value) => !Number.isNaN(value));
+    if (!values.length && !isPresence) return void 0;
+  }
+  if (operatorId === "matches" || operatorId === "notMatches") {
+    values = values.filter((value) => /[\p{L}\p{M}\p{N}]/u.test(String(value)));
+    if (!values.length) return void 0;
+  }
+  const { scope, path } = resolveTraceQueryPath(fieldId);
+  const isMetadata = fieldId.startsWith("metadata.");
+  if (!scope && !isMetadata && !TRACE_QUERY_TRACE_FIELD_IDS.has(fieldId)) return void 0;
+  if (scope && isNegativeOperator(operatorId)) {
+    const positive = scalarPredicate(NEGATIVE_TO_POSITIVE[operatorId], path, values);
+    return positive ? { predicate: { [scope]: { none: positive } } } : void 0;
+  }
+  const predicate = scalarPredicate(operatorId, path, values);
+  if (!predicate) return void 0;
+  if (scope) return { scope, predicate };
+  if ((operatorId === "isNot" || operatorId === "notIn") && (isMetadata || TRACE_QUERY_OPTIONAL_TRACE_FIELD_IDS.has(fieldId))) {
+    return { predicate: { op: "or", args: [predicate, { op: "notExists", path }] } };
+  }
+  return { predicate };
+}
+function predicatesForTokens(tokens, { mergeRelated }) {
+  const args = [];
+  const related = { spans: [], scores: [], feedback: [] };
+  for (const token of tokens) {
+    const result = tokenToTraceQueryPredicate(token);
+    if (!result) continue;
+    if (!("scope" in result)) {
+      args.push(result.predicate);
+    } else if (mergeRelated) {
+      related[result.scope].push(result.predicate);
+    } else {
+      args.push({ [result.scope]: { some: result.predicate } });
+    }
+  }
+  for (const scope of TRACE_QUERY_RELATED_SCOPES) {
+    const [first, ...rest] = related[scope];
+    if (!first) continue;
+    const some = rest.length ? { op: "and", args: [first, ...rest] } : first;
+    args.push({ [scope]: { some } });
+  }
+  return args;
+}
+function groupToTraceQueryPredicate(group) {
+  const tokens = group.nodes.filter((node) => !isTraceFilterGroup(node));
+  const args = predicatesForTokens(tokens, { mergeRelated: group.logic === "and" });
+  for (const node of group.nodes) {
+    if (!isTraceFilterGroup(node)) continue;
+    const predicate = groupToTraceQueryPredicate(node);
+    if (predicate) args.push(predicate);
+  }
+  if (args.length === 0) return void 0;
+  return args.length === 1 ? args[0] : { op: group.logic, args };
+}
+function buildTraceQueryRequest({
+  rootEntityType,
+  status,
+  dateFrom,
+  dateTo,
+  tokens,
+  groups = [],
+  now
+}) {
+  const args = [];
+  if (rootEntityType) args.push({ op: "eq", left: { path: "entityType" }, right: { literal: rootEntityType } });
+  if (status && status !== "running") args.push({ op: "eq", left: { path: "status" }, right: { literal: status } });
+  args.push(...predicatesForTokens(tokens, { mergeRelated: true }));
+  for (const group of groups) {
+    const predicate = groupToTraceQueryPredicate(group);
+    if (predicate) args.push(predicate);
+  }
+  return {
+    timeRange: {
+      from: (dateFrom ?? new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3)).toISOString(),
+      to: (dateTo ?? now).toISOString()
+    },
+    ...args.length ? { where: { op: "and", args } } : {}
+  };
+}
+const TRACE_QUERY_DISCOVERY_MAX_RANGE_MS = 31 * 24 * 60 * 60 * 1e3;
+function clampTraceDiscoveryTimeRange(timeRange) {
+  const to = new Date(timeRange.to).getTime();
+  const from = new Date(timeRange.from).getTime();
+  const minFrom = to - TRACE_QUERY_DISCOVERY_MAX_RANGE_MS;
+  if (from >= minFrom && from < to) return timeRange;
+  return { from: new Date(minFrom).toISOString(), to: timeRange.to };
+}
+
+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 isLegacyAnyValue = (value, operatorId) => value === "Any" && operatorId !== "matches" && operatorId !== "notMatches";
+const readTraceFilterOperator = (searchParams, valueParam) => {
+  const raw = searchParams.get(traceFilterOperatorParam(valueParam));
+  return raw !== null && 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" },
+  { id: "matches", label: "matches", freeText: true },
+  { id: "notMatches", label: "does not match", freeText: true }
+];
+const TRACE_STRING_OPERATORS = ["is", "isNot", "in", "notIn", "exists", "notExists"];
+const TRACE_TEXT_OPERATORS = [...TRACE_STRING_OPERATORS, "matches", "notMatches"];
+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_TAGS_OPERATORS = ["in", "notIn", "exists", "notExists"];
+const TRACE_TAGS_OPERATOR_TO_QUERY_OP = {
+  in: "includes",
+  notIn: "notIncludes",
+  exists: "exists",
+  notExists: "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"]);
+const TRACE_FILTER_BAR_TEXT_MATCH_FIELD_IDS = /* @__PURE__ */ new Set(["spans.name", "feedback.comment"]);
+const TRACE_FILTER_BAR_FREE_TEXT_RELATED_FIELD_IDS = /* @__PURE__ */ new Set(["feedback.comment"]);
+const byLabel = (a, b) => a.label.localeCompare(b.label);
+function createTagsFilterBarField(canonicalTraceFields, valueSuggestions) {
+  const descriptor = canonicalTraceFields.find((field) => field.path === "tags");
+  if (!descriptor) return void 0;
+  const operators = TRACE_TAGS_OPERATORS.filter(
+    (op) => descriptor.operators.includes(TRACE_TAGS_OPERATOR_TO_QUERY_OP[op] ?? "")
+  );
+  if (operators.length === 0) return void 0;
+  const suggestions = descriptor.valueSuggestions ? valueSuggestions?.("trace", "tags") : void 0;
+  return { ...traceFieldBase("tags"), operators, ...suggestions ? { suggestions } : {} };
+}
+function createTraceFilterBarFields({
+  availableRootEntityNames,
+  availableEnvironments,
+  hiddenFieldIds = [],
+  metadataFields = [],
+  canonicalTraceFields = [],
+  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 = TRACE_FILTER_BAR_FREE_TEXT_RELATED_FIELD_IDS.has(id) ? void 0 : valueSuggestions?.(scope, path);
+    return {
+      ...traceFieldBase(id),
+      operators: TRACE_FILTER_BAR_TEXT_MATCH_FIELD_IDS.has(id) ? TRACE_TEXT_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 (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 tagsField = createTagsFilterBarField(canonicalTraceFields, valueSuggestions);
+  const tagsFields = tagsField ? [tagsField] : [];
+  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, ...tagsFields].sort(byLabel),
+    ...textFields.sort(byLabel),
+    ...relatedFields,
+    ...metadataBarFields.sort(byLabel)
+  ].filter((field) => !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: isLegacyAnyValue(token.value, traceFilterTokenOperator(token)) ? "" : 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 (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) => isTraceFilterGroup(node) ? traceGroupToFilterBarGroup(node) : {
+        id: node.id ?? node.fieldId,
+        fieldId: node.fieldId,
+        operatorId: traceFilterTokenOperator(node),
+        value: isLegacyAnyValue(node.value, traceFilterTokenOperator(node)) ? "" : 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 (TRACE_FILTER_BAR_PRESENCE_FIELD_IDS.has(fieldId)) {
+      if (operatorId ? !isPresenceOperator(operatorId) : Boolean(raw[0])) continue;
+    }
+    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);
+      }
+      const operatorId = readTraceFilterOperator(searchParams, param);
+      if (operatorId && searchParams.has(param)) next.set(traceFilterOperatorParam(param), operatorId);
+      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" && 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;
+}
+
+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_IDS = TRACE_FILTER_OPERATOR_IDS;
+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_QUERY_DISCOVERY_MAX_RANGE_MS = TRACE_QUERY_DISCOVERY_MAX_RANGE_MS;
+exports.TRACE_QUERY_NUMERIC_FIELD_IDS = TRACE_QUERY_NUMERIC_FIELD_IDS;
+exports.TRACE_QUERY_OPTIONAL_TRACE_FIELD_IDS = TRACE_QUERY_OPTIONAL_TRACE_FIELD_IDS;
+exports.TRACE_QUERY_UNSUPPORTED_FILTER_FIELDS = TRACE_QUERY_UNSUPPORTED_FILTER_FIELDS;
+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.buildTraceQueryRequest = buildTraceQueryRequest;
+exports.clampTraceDiscoveryTimeRange = clampTraceDiscoveryTimeRange;
+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.isLegacyAnyValue = isLegacyAnyValue;
+exports.isTraceFilterGroup = isTraceFilterGroup;
+exports.isTraceFilterOperatorId = isTraceFilterOperatorId;
+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;
+//# sourceMappingURL=trace-filters-Cvo41yor.cjs.map