@mastra/playground-ui 51.2.0 → 51.3.0-alpha.1

package/dist/domains/traces/hooks/use-trace-light-spans.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-trace-light-spans.cjs.js","sources":["../../../../src/domains/traces/hooks/use-trace-light-spans.ts"],"sourcesContent":["import type { LightSpanRecord } from '@mastra/core/storage';\nimport { useMastraClient } from '@mastra/react';\nimport { useQuery } from '@tanstack/react-query';\nimport type { UseQueryResult } from '@tanstack/react-query';\n\nconst IMMUTABLE_CACHE_TIME = 1000 * 60 * 60 * 24 * 30; // 30 days, massive cache, span data is immutable\n\nexport function useTraceLightSpans(\n  traceId: string | null | undefined,\n): UseQueryResult<{ traceId: string; spans: LightSpanRecord[] } | null> {\n  const client = useMastraClient();\n\n  return useQuery({\n    queryKey: ['trace-light-spans', traceId],\n    queryFn: async () => {\n      if (!traceId) {\n        throw new Error('Trace ID is required');\n      }\n      const res = await client.getTraceLight(traceId);\n      return res;\n    },\n    enabled: !!traceId,\n    staleTime: query => {\n      const data = query.state.data;\n\n      const isFinished = data?.spans.every(d => Boolean(d.endedAt));\n\n      if (isFinished) {\n        return IMMUTABLE_CACHE_TIME;\n      }\n\n      return 0;\n    },\n  });\n}\n"],"names":["useMastraClient","useQuery"],"mappings":";;;;;;;AAKA,MAAM,oBAAA,GAAuB,GAAA,GAAO,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA;AAE5C,SAAS,mBACd,OAAA,EACsE;AACtE,EAAA,MAAM,SAASA,qBAAA,EAAgB;AAE/B,EAAA,OAAOC,mBAAA,CAAS;AAAA,IACd,QAAA,EAAU,CAAC,mBAAA,EAAqB,OAAO,CAAA;AAAA,IACvC,SAAS,YAAY;AACnB,MAAA,IAAI,CAAC,OAAA,EAAS;AACZ,QAAA,MAAM,IAAI,MAAM,sBAAsB,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,aAAA,CAAc,OAAO,CAAA;AAC9C,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA,IACA,OAAA,EAAS,CAAC,CAAC,OAAA;AAAA,IACX,WAAW,CAAA,KAAA,KAAS;AAClB,MAAA,MAAM,IAAA,GAAO,MAAM,KAAA,CAAM,IAAA;AAEzB,MAAA,MAAM,UAAA,GAAa,MAAM,KAAA,CAAM,KAAA,CAAM,OAAK,OAAA,CAAQ,CAAA,CAAE,OAAO,CAAC,CAAA;AAE5D,MAAA,IAAI,UAAA,EAAY;AACd,QAAA,OAAO,oBAAA;AAAA,MACT;AAEA,MAAA,OAAO,CAAA;AAAA,IACT;AAAA,GACD,CAAA;AACH;;;;"}
+{"version":3,"file":"use-trace-light-spans.cjs.js","sources":["../../../../src/domains/traces/hooks/use-trace-light-spans.ts"],"sourcesContent":["import { useMastraClient } from '@mastra/react';\nimport { useQuery } from '@tanstack/react-query';\nimport type { UseQueryResult } from '@tanstack/react-query';\nimport type { SearchableSpan } from '../types';\nimport { selectSearchableSpans } from '../utils';\n\nconst IMMUTABLE_CACHE_TIME = 1000 * 60 * 60 * 24 * 30; // 30 days, massive cache, span data is immutable\n\nexport function useTraceLightSpans(\n  traceId: string | null | undefined,\n): UseQueryResult<{ traceId: string; spans: SearchableSpan[] } | null> {\n  const client = useMastraClient();\n\n  return useQuery({\n    queryKey: ['trace-light-spans', traceId],\n    queryFn: async () => {\n      if (!traceId) {\n        throw new Error('Trace ID is required');\n      }\n      const res = await client.getTraceLight(traceId);\n      return res;\n    },\n    // Builds each span's search haystack once per fetch, cached with the query.\n    select: selectSearchableSpans,\n    enabled: !!traceId,\n    staleTime: query => {\n      const data = query.state.data;\n\n      const isFinished = data?.spans.every(d => Boolean(d.endedAt));\n\n      if (isFinished) {\n        return IMMUTABLE_CACHE_TIME;\n      }\n\n      return 0;\n    },\n  });\n}\n"],"names":["useMastraClient","useQuery","selectSearchableSpans"],"mappings":";;;;;;;;;AAMA,MAAM,oBAAA,GAAuB,GAAA,GAAO,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA;AAE5C,SAAS,mBACd,OAAA,EACqE;AACrE,EAAA,MAAM,SAASA,qBAAA,EAAgB;AAE/B,EAAA,OAAOC,mBAAA,CAAS;AAAA,IACd,QAAA,EAAU,CAAC,mBAAA,EAAqB,OAAO,CAAA;AAAA,IACvC,SAAS,YAAY;AACnB,MAAA,IAAI,CAAC,OAAA,EAAS;AACZ,QAAA,MAAM,IAAI,MAAM,sBAAsB,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,aAAA,CAAc,OAAO,CAAA;AAC9C,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA;AAAA,IAEA,MAAA,EAAQC,4DAAA;AAAA,IACR,OAAA,EAAS,CAAC,CAAC,OAAA;AAAA,IACX,WAAW,CAAA,KAAA,KAAS;AAClB,MAAA,MAAM,IAAA,GAAO,MAAM,KAAA,CAAM,IAAA;AAEzB,MAAA,MAAM,UAAA,GAAa,MAAM,KAAA,CAAM,KAAA,CAAM,OAAK,OAAA,CAAQ,CAAA,CAAE,OAAO,CAAC,CAAA;AAE5D,MAAA,IAAI,UAAA,EAAY;AACd,QAAA,OAAO,oBAAA;AAAA,MACT;AAEA,MAAA,OAAO,CAAA;AAAA,IACT;AAAA,GACD,CAAA;AACH;;;;"}

package/dist/domains/traces/hooks/use-trace-light-spans.es.js

@@ -1,5 +1,7 @@
 import { useMastraClient } from '@mastra/react';
 import { useQuery } from '@tanstack/react-query';
+import { selectSearchableSpans } from '../utils/to-searchable-spans.es.js';
+import 'date-fns';
 
 const IMMUTABLE_CACHE_TIME = 1e3 * 60 * 60 * 24 * 30;
 function useTraceLightSpans(traceId) {
@@ -13,6 +15,8 @@ function useTraceLightSpans(traceId) {
       const res = await client.getTraceLight(traceId);
       return res;
     },
+    // Builds each span's search haystack once per fetch, cached with the query.
+    select: selectSearchableSpans,
     enabled: !!traceId,
     staleTime: (query) => {
       const data = query.state.data;

package/dist/domains/traces/hooks/use-trace-light-spans.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-trace-light-spans.es.js","sources":["../../../../src/domains/traces/hooks/use-trace-light-spans.ts"],"sourcesContent":["import type { LightSpanRecord } from '@mastra/core/storage';\nimport { useMastraClient } from '@mastra/react';\nimport { useQuery } from '@tanstack/react-query';\nimport type { UseQueryResult } from '@tanstack/react-query';\n\nconst IMMUTABLE_CACHE_TIME = 1000 * 60 * 60 * 24 * 30; // 30 days, massive cache, span data is immutable\n\nexport function useTraceLightSpans(\n  traceId: string | null | undefined,\n): UseQueryResult<{ traceId: string; spans: LightSpanRecord[] } | null> {\n  const client = useMastraClient();\n\n  return useQuery({\n    queryKey: ['trace-light-spans', traceId],\n    queryFn: async () => {\n      if (!traceId) {\n        throw new Error('Trace ID is required');\n      }\n      const res = await client.getTraceLight(traceId);\n      return res;\n    },\n    enabled: !!traceId,\n    staleTime: query => {\n      const data = query.state.data;\n\n      const isFinished = data?.spans.every(d => Boolean(d.endedAt));\n\n      if (isFinished) {\n        return IMMUTABLE_CACHE_TIME;\n      }\n\n      return 0;\n    },\n  });\n}\n"],"names":[],"mappings":";;;AAKA,MAAM,oBAAA,GAAuB,GAAA,GAAO,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA;AAE5C,SAAS,mBACd,OAAA,EACsE;AACtE,EAAA,MAAM,SAAS,eAAA,EAAgB;AAE/B,EAAA,OAAO,QAAA,CAAS;AAAA,IACd,QAAA,EAAU,CAAC,mBAAA,EAAqB,OAAO,CAAA;AAAA,IACvC,SAAS,YAAY;AACnB,MAAA,IAAI,CAAC,OAAA,EAAS;AACZ,QAAA,MAAM,IAAI,MAAM,sBAAsB,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,aAAA,CAAc,OAAO,CAAA;AAC9C,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA,IACA,OAAA,EAAS,CAAC,CAAC,OAAA;AAAA,IACX,WAAW,CAAA,KAAA,KAAS;AAClB,MAAA,MAAM,IAAA,GAAO,MAAM,KAAA,CAAM,IAAA;AAEzB,MAAA,MAAM,UAAA,GAAa,MAAM,KAAA,CAAM,KAAA,CAAM,OAAK,OAAA,CAAQ,CAAA,CAAE,OAAO,CAAC,CAAA;AAE5D,MAAA,IAAI,UAAA,EAAY;AACd,QAAA,OAAO,oBAAA;AAAA,MACT;AAEA,MAAA,OAAO,CAAA;AAAA,IACT;AAAA,GACD,CAAA;AACH;;;;"}
+{"version":3,"file":"use-trace-light-spans.es.js","sources":["../../../../src/domains/traces/hooks/use-trace-light-spans.ts"],"sourcesContent":["import { useMastraClient } from '@mastra/react';\nimport { useQuery } from '@tanstack/react-query';\nimport type { UseQueryResult } from '@tanstack/react-query';\nimport type { SearchableSpan } from '../types';\nimport { selectSearchableSpans } from '../utils';\n\nconst IMMUTABLE_CACHE_TIME = 1000 * 60 * 60 * 24 * 30; // 30 days, massive cache, span data is immutable\n\nexport function useTraceLightSpans(\n  traceId: string | null | undefined,\n): UseQueryResult<{ traceId: string; spans: SearchableSpan[] } | null> {\n  const client = useMastraClient();\n\n  return useQuery({\n    queryKey: ['trace-light-spans', traceId],\n    queryFn: async () => {\n      if (!traceId) {\n        throw new Error('Trace ID is required');\n      }\n      const res = await client.getTraceLight(traceId);\n      return res;\n    },\n    // Builds each span's search haystack once per fetch, cached with the query.\n    select: selectSearchableSpans,\n    enabled: !!traceId,\n    staleTime: query => {\n      const data = query.state.data;\n\n      const isFinished = data?.spans.every(d => Boolean(d.endedAt));\n\n      if (isFinished) {\n        return IMMUTABLE_CACHE_TIME;\n      }\n\n      return 0;\n    },\n  });\n}\n"],"names":[],"mappings":";;;;;AAMA,MAAM,oBAAA,GAAuB,GAAA,GAAO,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA;AAE5C,SAAS,mBACd,OAAA,EACqE;AACrE,EAAA,MAAM,SAAS,eAAA,EAAgB;AAE/B,EAAA,OAAO,QAAA,CAAS;AAAA,IACd,QAAA,EAAU,CAAC,mBAAA,EAAqB,OAAO,CAAA;AAAA,IACvC,SAAS,YAAY;AACnB,MAAA,IAAI,CAAC,OAAA,EAAS;AACZ,QAAA,MAAM,IAAI,MAAM,sBAAsB,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,aAAA,CAAc,OAAO,CAAA;AAC9C,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA;AAAA,IAEA,MAAA,EAAQ,qBAAA;AAAA,IACR,OAAA,EAAS,CAAC,CAAC,OAAA;AAAA,IACX,WAAW,CAAA,KAAA,KAAS;AAClB,MAAA,MAAM,IAAA,GAAO,MAAM,KAAA,CAAM,IAAA;AAEzB,MAAA,MAAM,UAAA,GAAa,MAAM,KAAA,CAAM,KAAA,CAAM,OAAK,OAAA,CAAQ,CAAA,CAAE,OAAO,CAAC,CAAA;AAE5D,MAAA,IAAI,UAAA,EAAY;AACd,QAAA,OAAO,oBAAA;AAAA,MACT;AAEA,MAAA,OAAO,CAAA;AAAA,IACT;AAAA,GACD,CAAA;AACH;;;;"}

package/dist/domains/traces/hooks/use-trace-or-branch-spans.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const domains_traces_hooks_useBranch = require('./use-branch.cjs.js');
-const domains_traces_hooks_useTraceLightSpans = require('./use-trace-light-spans.cjs.js');
+const domains_traces_hooks_useTraceSpans = require('./use-trace-spans.cjs.js');
 
 function useTraceOrBranchSpans({
   traceId,
@@ -12,7 +12,7 @@ function useTraceOrBranchSpans({
   depth
 }) {
   const isBranches = listMode === "branches";
-  const traceQuery = domains_traces_hooks_useTraceLightSpans.useTraceLightSpans(isBranches ? null : traceId);
+  const traceQuery = domains_traces_hooks_useTraceSpans.useTraceSpans(isBranches ? null : traceId);
   const branchQuery = domains_traces_hooks_useBranch.useBranch({
     traceId: isBranches ? traceId : null,
     spanId: isBranches ? anchorSpanId : null,

package/dist/domains/traces/hooks/use-trace-or-branch-spans.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-trace-or-branch-spans.cjs.js","sources":["../../../../src/domains/traces/hooks/use-trace-or-branch-spans.ts"],"sourcesContent":["import type { LightSpanRecord } from '@mastra/core/storage';\nimport type { TraceListMode } from '../trace-filters';\nimport { useBranch } from './use-branch';\nimport { useTraceLightSpans } from './use-trace-light-spans';\n\nexport interface UseTraceOrBranchSpansArgs {\n  traceId: string | null | undefined;\n  /** Required when `listMode === 'branches'` — the anchor span identifying the displayed\n   *  subtree. The hook fetches `getBranch(traceId, anchorSpanId)`. Intra-panel span selection\n   *  is separate (the caller's `spanIdParam`); the anchor stays put while it changes. */\n  anchorSpanId?: string | null;\n  listMode: TraceListMode;\n  depth?: number;\n}\n\nexport interface UseTraceOrBranchSpansResult {\n  spans: LightSpanRecord[] | undefined;\n  /** Set in branches mode; undefined in traces mode (which uses parentSpanId == null). */\n  anchorSpanId: string | undefined;\n  isLoading: boolean;\n  isError: boolean;\n  error: unknown;\n}\n\n/**\n * Unified data source for the trace/span detail panel. Returns trace spans (full tree from the\n * root) in traces mode, or branch spans (subtree rooted at `anchorSpanId`) in branches mode.\n * Only the active query fires; the inactive one is disabled via its `enabled` flag.\n */\nexport function useTraceOrBranchSpans({\n  traceId,\n  anchorSpanId,\n  listMode,\n  depth,\n}: UseTraceOrBranchSpansArgs): UseTraceOrBranchSpansResult {\n  const isBranches = listMode === 'branches';\n\n  const traceQuery = useTraceLightSpans(isBranches ? null : traceId);\n  const branchQuery = useBranch({\n    traceId: isBranches ? traceId : null,\n    spanId: isBranches ? anchorSpanId : null,\n    depth,\n  });\n\n  if (isBranches) {\n    return {\n      spans: branchQuery.data?.spans,\n      anchorSpanId: anchorSpanId ?? undefined,\n      isLoading: branchQuery.isLoading,\n      isError: branchQuery.isError,\n      error: branchQuery.error,\n    };\n  }\n\n  return {\n    spans: traceQuery.data?.spans,\n    anchorSpanId: undefined,\n    isLoading: traceQuery.isLoading,\n    isError: traceQuery.isError,\n    error: traceQuery.error,\n  };\n}\n"],"names":["useTraceLightSpans","useBranch"],"mappings":";;;;;;;AA6BO,SAAS,qBAAA,CAAsB;AAAA,EACpC,OAAA;AAAA,EACA,YAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAA,EAA2D;AACzD,EAAA,MAAM,aAAa,QAAA,KAAa,UAAA;AAEhC,EAAA,MAAM,UAAA,GAAaA,0DAAA,CAAmB,UAAA,GAAa,IAAA,GAAO,OAAO,CAAA;AACjE,EAAA,MAAM,cAAcC,wCAAA,CAAU;AAAA,IAC5B,OAAA,EAAS,aAAa,OAAA,GAAU,IAAA;AAAA,IAChC,MAAA,EAAQ,aAAa,YAAA,GAAe,IAAA;AAAA,IACpC;AAAA,GACD,CAAA;AAED,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,OAAO;AAAA,MACL,KAAA,EAAO,YAAY,IAAA,EAAM,KAAA;AAAA,MACzB,cAAc,YAAA,IAAgB,MAAA;AAAA,MAC9B,WAAW,WAAA,CAAY,SAAA;AAAA,MACvB,SAAS,WAAA,CAAY,OAAA;AAAA,MACrB,OAAO,WAAA,CAAY;AAAA,KACrB;AAAA,EACF;AAEA,EAAA,OAAO;AAAA,IACL,KAAA,EAAO,WAAW,IAAA,EAAM,KAAA;AAAA,IACxB,YAAA,EAAc,MAAA;AAAA,IACd,WAAW,UAAA,CAAW,SAAA;AAAA,IACtB,SAAS,UAAA,CAAW,OAAA;AAAA,IACpB,OAAO,UAAA,CAAW;AAAA,GACpB;AACF;;;;"}
+{"version":3,"file":"use-trace-or-branch-spans.cjs.js","sources":["../../../../src/domains/traces/hooks/use-trace-or-branch-spans.ts"],"sourcesContent":["import type { TraceListMode } from '../trace-filters';\nimport type { SearchableSpan } from '../types';\nimport { useBranch } from './use-branch';\nimport { useTraceSpans } from './use-trace-spans';\n\nexport interface UseTraceOrBranchSpansArgs {\n  traceId: string | null | undefined;\n  /** Required when `listMode === 'branches'` — the anchor span identifying the displayed\n   *  subtree. The hook fetches `getBranch(traceId, anchorSpanId)`. Intra-panel span selection\n   *  is separate (the caller's `spanIdParam`); the anchor stays put while it changes. */\n  anchorSpanId?: string | null;\n  listMode: TraceListMode;\n  depth?: number;\n}\n\nexport interface UseTraceOrBranchSpansResult {\n  spans: SearchableSpan[] | undefined;\n  /** Set in branches mode; undefined in traces mode (which uses parentSpanId == null). */\n  anchorSpanId: string | undefined;\n  isLoading: boolean;\n  isError: boolean;\n  error: unknown;\n}\n\n/**\n * Unified data source for the trace/span detail panel. Returns trace spans (full tree from the\n * root) in traces mode, or branch spans (subtree rooted at `anchorSpanId`) in branches mode.\n * Only the active query fires; the inactive one is disabled via its `enabled` flag.\n *\n * Both modes carry full span payloads: the panel renders and searches them, so a lightweight\n * projection here would hide content from the reader looking straight at it.\n */\nexport function useTraceOrBranchSpans({\n  traceId,\n  anchorSpanId,\n  listMode,\n  depth,\n}: UseTraceOrBranchSpansArgs): UseTraceOrBranchSpansResult {\n  const isBranches = listMode === 'branches';\n\n  const traceQuery = useTraceSpans(isBranches ? null : traceId);\n  const branchQuery = useBranch({\n    traceId: isBranches ? traceId : null,\n    spanId: isBranches ? anchorSpanId : null,\n    depth,\n  });\n\n  if (isBranches) {\n    return {\n      spans: branchQuery.data?.spans,\n      anchorSpanId: anchorSpanId ?? undefined,\n      isLoading: branchQuery.isLoading,\n      isError: branchQuery.isError,\n      error: branchQuery.error,\n    };\n  }\n\n  return {\n    spans: traceQuery.data?.spans,\n    anchorSpanId: undefined,\n    isLoading: traceQuery.isLoading,\n    isError: traceQuery.isError,\n    error: traceQuery.error,\n  };\n}\n"],"names":["useTraceSpans","useBranch"],"mappings":";;;;;;;AAgCO,SAAS,qBAAA,CAAsB;AAAA,EACpC,OAAA;AAAA,EACA,YAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAA,EAA2D;AACzD,EAAA,MAAM,aAAa,QAAA,KAAa,UAAA;AAEhC,EAAA,MAAM,UAAA,GAAaA,gDAAA,CAAc,UAAA,GAAa,IAAA,GAAO,OAAO,CAAA;AAC5D,EAAA,MAAM,cAAcC,wCAAA,CAAU;AAAA,IAC5B,OAAA,EAAS,aAAa,OAAA,GAAU,IAAA;AAAA,IAChC,MAAA,EAAQ,aAAa,YAAA,GAAe,IAAA;AAAA,IACpC;AAAA,GACD,CAAA;AAED,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,OAAO;AAAA,MACL,KAAA,EAAO,YAAY,IAAA,EAAM,KAAA;AAAA,MACzB,cAAc,YAAA,IAAgB,MAAA;AAAA,MAC9B,WAAW,WAAA,CAAY,SAAA;AAAA,MACvB,SAAS,WAAA,CAAY,OAAA;AAAA,MACrB,OAAO,WAAA,CAAY;AAAA,KACrB;AAAA,EACF;AAEA,EAAA,OAAO;AAAA,IACL,KAAA,EAAO,WAAW,IAAA,EAAM,KAAA;AAAA,IACxB,YAAA,EAAc,MAAA;AAAA,IACd,WAAW,UAAA,CAAW,SAAA;AAAA,IACtB,SAAS,UAAA,CAAW,OAAA;AAAA,IACpB,OAAO,UAAA,CAAW;AAAA,GACpB;AACF;;;;"}

package/dist/domains/traces/hooks/use-trace-or-branch-spans.es.js

@@ -1,5 +1,5 @@
 import { useBranch } from './use-branch.es.js';
-import { useTraceLightSpans } from './use-trace-light-spans.es.js';
+import { useTraceSpans } from './use-trace-spans.es.js';
 
 function useTraceOrBranchSpans({
   traceId,
@@ -8,7 +8,7 @@ function useTraceOrBranchSpans({
   depth
 }) {
   const isBranches = listMode === "branches";
-  const traceQuery = useTraceLightSpans(isBranches ? null : traceId);
+  const traceQuery = useTraceSpans(isBranches ? null : traceId);
   const branchQuery = useBranch({
     traceId: isBranches ? traceId : null,
     spanId: isBranches ? anchorSpanId : null,

package/dist/domains/traces/hooks/use-trace-or-branch-spans.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-trace-or-branch-spans.es.js","sources":["../../../../src/domains/traces/hooks/use-trace-or-branch-spans.ts"],"sourcesContent":["import type { LightSpanRecord } from '@mastra/core/storage';\nimport type { TraceListMode } from '../trace-filters';\nimport { useBranch } from './use-branch';\nimport { useTraceLightSpans } from './use-trace-light-spans';\n\nexport interface UseTraceOrBranchSpansArgs {\n  traceId: string | null | undefined;\n  /** Required when `listMode === 'branches'` — the anchor span identifying the displayed\n   *  subtree. The hook fetches `getBranch(traceId, anchorSpanId)`. Intra-panel span selection\n   *  is separate (the caller's `spanIdParam`); the anchor stays put while it changes. */\n  anchorSpanId?: string | null;\n  listMode: TraceListMode;\n  depth?: number;\n}\n\nexport interface UseTraceOrBranchSpansResult {\n  spans: LightSpanRecord[] | undefined;\n  /** Set in branches mode; undefined in traces mode (which uses parentSpanId == null). */\n  anchorSpanId: string | undefined;\n  isLoading: boolean;\n  isError: boolean;\n  error: unknown;\n}\n\n/**\n * Unified data source for the trace/span detail panel. Returns trace spans (full tree from the\n * root) in traces mode, or branch spans (subtree rooted at `anchorSpanId`) in branches mode.\n * Only the active query fires; the inactive one is disabled via its `enabled` flag.\n */\nexport function useTraceOrBranchSpans({\n  traceId,\n  anchorSpanId,\n  listMode,\n  depth,\n}: UseTraceOrBranchSpansArgs): UseTraceOrBranchSpansResult {\n  const isBranches = listMode === 'branches';\n\n  const traceQuery = useTraceLightSpans(isBranches ? null : traceId);\n  const branchQuery = useBranch({\n    traceId: isBranches ? traceId : null,\n    spanId: isBranches ? anchorSpanId : null,\n    depth,\n  });\n\n  if (isBranches) {\n    return {\n      spans: branchQuery.data?.spans,\n      anchorSpanId: anchorSpanId ?? undefined,\n      isLoading: branchQuery.isLoading,\n      isError: branchQuery.isError,\n      error: branchQuery.error,\n    };\n  }\n\n  return {\n    spans: traceQuery.data?.spans,\n    anchorSpanId: undefined,\n    isLoading: traceQuery.isLoading,\n    isError: traceQuery.isError,\n    error: traceQuery.error,\n  };\n}\n"],"names":[],"mappings":";;;AA6BO,SAAS,qBAAA,CAAsB;AAAA,EACpC,OAAA;AAAA,EACA,YAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAA,EAA2D;AACzD,EAAA,MAAM,aAAa,QAAA,KAAa,UAAA;AAEhC,EAAA,MAAM,UAAA,GAAa,kBAAA,CAAmB,UAAA,GAAa,IAAA,GAAO,OAAO,CAAA;AACjE,EAAA,MAAM,cAAc,SAAA,CAAU;AAAA,IAC5B,OAAA,EAAS,aAAa,OAAA,GAAU,IAAA;AAAA,IAChC,MAAA,EAAQ,aAAa,YAAA,GAAe,IAAA;AAAA,IACpC;AAAA,GACD,CAAA;AAED,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,OAAO;AAAA,MACL,KAAA,EAAO,YAAY,IAAA,EAAM,KAAA;AAAA,MACzB,cAAc,YAAA,IAAgB,MAAA;AAAA,MAC9B,WAAW,WAAA,CAAY,SAAA;AAAA,MACvB,SAAS,WAAA,CAAY,OAAA;AAAA,MACrB,OAAO,WAAA,CAAY;AAAA,KACrB;AAAA,EACF;AAEA,EAAA,OAAO;AAAA,IACL,KAAA,EAAO,WAAW,IAAA,EAAM,KAAA;AAAA,IACxB,YAAA,EAAc,MAAA;AAAA,IACd,WAAW,UAAA,CAAW,SAAA;AAAA,IACtB,SAAS,UAAA,CAAW,OAAA;AAAA,IACpB,OAAO,UAAA,CAAW;AAAA,GACpB;AACF;;;;"}
+{"version":3,"file":"use-trace-or-branch-spans.es.js","sources":["../../../../src/domains/traces/hooks/use-trace-or-branch-spans.ts"],"sourcesContent":["import type { TraceListMode } from '../trace-filters';\nimport type { SearchableSpan } from '../types';\nimport { useBranch } from './use-branch';\nimport { useTraceSpans } from './use-trace-spans';\n\nexport interface UseTraceOrBranchSpansArgs {\n  traceId: string | null | undefined;\n  /** Required when `listMode === 'branches'` — the anchor span identifying the displayed\n   *  subtree. The hook fetches `getBranch(traceId, anchorSpanId)`. Intra-panel span selection\n   *  is separate (the caller's `spanIdParam`); the anchor stays put while it changes. */\n  anchorSpanId?: string | null;\n  listMode: TraceListMode;\n  depth?: number;\n}\n\nexport interface UseTraceOrBranchSpansResult {\n  spans: SearchableSpan[] | undefined;\n  /** Set in branches mode; undefined in traces mode (which uses parentSpanId == null). */\n  anchorSpanId: string | undefined;\n  isLoading: boolean;\n  isError: boolean;\n  error: unknown;\n}\n\n/**\n * Unified data source for the trace/span detail panel. Returns trace spans (full tree from the\n * root) in traces mode, or branch spans (subtree rooted at `anchorSpanId`) in branches mode.\n * Only the active query fires; the inactive one is disabled via its `enabled` flag.\n *\n * Both modes carry full span payloads: the panel renders and searches them, so a lightweight\n * projection here would hide content from the reader looking straight at it.\n */\nexport function useTraceOrBranchSpans({\n  traceId,\n  anchorSpanId,\n  listMode,\n  depth,\n}: UseTraceOrBranchSpansArgs): UseTraceOrBranchSpansResult {\n  const isBranches = listMode === 'branches';\n\n  const traceQuery = useTraceSpans(isBranches ? null : traceId);\n  const branchQuery = useBranch({\n    traceId: isBranches ? traceId : null,\n    spanId: isBranches ? anchorSpanId : null,\n    depth,\n  });\n\n  if (isBranches) {\n    return {\n      spans: branchQuery.data?.spans,\n      anchorSpanId: anchorSpanId ?? undefined,\n      isLoading: branchQuery.isLoading,\n      isError: branchQuery.isError,\n      error: branchQuery.error,\n    };\n  }\n\n  return {\n    spans: traceQuery.data?.spans,\n    anchorSpanId: undefined,\n    isLoading: traceQuery.isLoading,\n    isError: traceQuery.isError,\n    error: traceQuery.error,\n  };\n}\n"],"names":[],"mappings":";;;AAgCO,SAAS,qBAAA,CAAsB;AAAA,EACpC,OAAA;AAAA,EACA,YAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAA,EAA2D;AACzD,EAAA,MAAM,aAAa,QAAA,KAAa,UAAA;AAEhC,EAAA,MAAM,UAAA,GAAa,aAAA,CAAc,UAAA,GAAa,IAAA,GAAO,OAAO,CAAA;AAC5D,EAAA,MAAM,cAAc,SAAA,CAAU;AAAA,IAC5B,OAAA,EAAS,aAAa,OAAA,GAAU,IAAA;AAAA,IAChC,MAAA,EAAQ,aAAa,YAAA,GAAe,IAAA;AAAA,IACpC;AAAA,GACD,CAAA;AAED,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,OAAO;AAAA,MACL,KAAA,EAAO,YAAY,IAAA,EAAM,KAAA;AAAA,MACzB,cAAc,YAAA,IAAgB,MAAA;AAAA,MAC9B,WAAW,WAAA,CAAY,SAAA;AAAA,MACvB,SAAS,WAAA,CAAY,OAAA;AAAA,MACrB,OAAO,WAAA,CAAY;AAAA,KACrB;AAAA,EACF;AAEA,EAAA,OAAO;AAAA,IACL,KAAA,EAAO,WAAW,IAAA,EAAM,KAAA;AAAA,IACxB,YAAA,EAAc,MAAA;AAAA,IACd,WAAW,UAAA,CAAW,SAAA;AAAA,IACtB,SAAS,UAAA,CAAW,OAAA;AAAA,IACpB,OAAO,UAAA,CAAW;AAAA,GACpB;AACF;;;;"}

package/dist/domains/traces/hooks/use-trace-search.cjs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const React = require('react');
+const domains_traces_utils_filterSpansKeepingAncestors = require('../utils/filter-spans-keeping-ancestors.cjs.js');
+require('date-fns');
+
+function useTraceSearch(spans) {
+  const [query, setQuery] = React.useState("");
+  const deferredQuery = React.useDeferredValue(query);
+  const results = React.useMemo(() => {
+    const term = deferredQuery.trim().toLowerCase();
+    if (!term) return spans;
+    return domains_traces_utils_filterSpansKeepingAncestors.filterSpansKeepingAncestors(spans, (span) => span.searchText.includes(term));
+  }, [spans, deferredQuery]);
+  return { query, setQuery, results, isPending: query !== deferredQuery };
+}
+
+exports.useTraceSearch = useTraceSearch;
+//# sourceMappingURL=use-trace-search.cjs.js.map

package/dist/domains/traces/hooks/use-trace-search.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-trace-search.cjs.js","sources":["../../../../src/domains/traces/hooks/use-trace-search.ts"],"sourcesContent":["import { useDeferredValue, useMemo, useState } from 'react';\nimport type { SearchableSpan } from '../types';\nimport { filterSpansKeepingAncestors } from '../utils';\n\nexport interface UseTraceSearchResult {\n  /** The immediate, user-facing input value. Bind this to the search field. */\n  query: string;\n  setQuery: (query: string) => void;\n  /** Rows matching the deferred query. An empty query returns the input array reference. */\n  results: SearchableSpan[];\n  /** True while the deferred value is behind `query` (the list is still catching up). */\n  isPending: boolean;\n}\n\n/**\n * Client-side search over a flat span list.\n *\n * Matching is a substring test against `searchText`, the haystack built once per span when\n * the query resolved (see `toSearchableSpans`). That is what makes the open-ended `metadata`\n * and `error` payloads searchable: their shapes are unknown, so no fixed list of fields can\n * read them. Both sides are already lowercased, so the test is a bare `includes`.\n *\n * Filtering is keyed on a deferred copy of the query, so typing stays responsive while a\n * large list re-filters at lower priority — bind the input to `query`, not to the deferred\n * value. A matching span keeps its ancestors and its whole subtree, so the hierarchy stays\n * intact.\n *\n * `spans` is required. Resolving the loading/empty state is the caller's job — a component\n * holding a query result passes `data?.spans ?? []`.\n */\nexport function useTraceSearch(spans: SearchableSpan[]): UseTraceSearchResult {\n  const [query, setQuery] = useState('');\n  const deferredQuery = useDeferredValue(query);\n\n  const results = useMemo(() => {\n    const term = deferredQuery.trim().toLowerCase();\n    if (!term) return spans;\n    return filterSpansKeepingAncestors(spans, span => span.searchText.includes(term));\n  }, [spans, deferredQuery]);\n\n  return { query, setQuery, results, isPending: query !== deferredQuery };\n}\n"],"names":["useState","useDeferredValue","useMemo","filterSpansKeepingAncestors"],"mappings":";;;;;;;;AA8BO,SAAS,eAAe,KAAA,EAA+C;AAC5E,EAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAIA,eAAS,EAAE,CAAA;AACrC,EAAA,MAAM,aAAA,GAAgBC,uBAAiB,KAAK,CAAA;AAE5C,EAAA,MAAM,OAAA,GAAUC,cAAQ,MAAM;AAC5B,IAAA,MAAM,IAAA,GAAO,aAAA,CAAc,IAAA,EAAK,CAAE,WAAA,EAAY;AAC9C,IAAA,IAAI,CAAC,MAAM,OAAO,KAAA;AAClB,IAAA,OAAOC,6EAA4B,KAAA,EAAO,CAAA,IAAA,KAAQ,KAAK,UAAA,CAAW,QAAA,CAAS,IAAI,CAAC,CAAA;AAAA,EAClF,CAAA,EAAG,CAAC,KAAA,EAAO,aAAa,CAAC,CAAA;AAEzB,EAAA,OAAO,EAAE,KAAA,EAAO,QAAA,EAAU,OAAA,EAAS,SAAA,EAAW,UAAU,aAAA,EAAc;AACxE;;;;"}

package/dist/domains/traces/hooks/use-trace-search.d.ts

@@ -0,0 +1,2 @@
+export * from '../../../src/domains/traces/hooks/use-trace-search'
+export {}

package/dist/domains/traces/hooks/use-trace-search.es.js

@@ -0,0 +1,17 @@
+import { useState, useDeferredValue, useMemo } from 'react';
+import { filterSpansKeepingAncestors } from '../utils/filter-spans-keeping-ancestors.es.js';
+import 'date-fns';
+
+function useTraceSearch(spans) {
+  const [query, setQuery] = useState("");
+  const deferredQuery = useDeferredValue(query);
+  const results = useMemo(() => {
+    const term = deferredQuery.trim().toLowerCase();
+    if (!term) return spans;
+    return filterSpansKeepingAncestors(spans, (span) => span.searchText.includes(term));
+  }, [spans, deferredQuery]);
+  return { query, setQuery, results, isPending: query !== deferredQuery };
+}
+
+export { useTraceSearch };
+//# sourceMappingURL=use-trace-search.es.js.map

package/dist/domains/traces/hooks/use-trace-search.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-trace-search.es.js","sources":["../../../../src/domains/traces/hooks/use-trace-search.ts"],"sourcesContent":["import { useDeferredValue, useMemo, useState } from 'react';\nimport type { SearchableSpan } from '../types';\nimport { filterSpansKeepingAncestors } from '../utils';\n\nexport interface UseTraceSearchResult {\n  /** The immediate, user-facing input value. Bind this to the search field. */\n  query: string;\n  setQuery: (query: string) => void;\n  /** Rows matching the deferred query. An empty query returns the input array reference. */\n  results: SearchableSpan[];\n  /** True while the deferred value is behind `query` (the list is still catching up). */\n  isPending: boolean;\n}\n\n/**\n * Client-side search over a flat span list.\n *\n * Matching is a substring test against `searchText`, the haystack built once per span when\n * the query resolved (see `toSearchableSpans`). That is what makes the open-ended `metadata`\n * and `error` payloads searchable: their shapes are unknown, so no fixed list of fields can\n * read them. Both sides are already lowercased, so the test is a bare `includes`.\n *\n * Filtering is keyed on a deferred copy of the query, so typing stays responsive while a\n * large list re-filters at lower priority — bind the input to `query`, not to the deferred\n * value. A matching span keeps its ancestors and its whole subtree, so the hierarchy stays\n * intact.\n *\n * `spans` is required. Resolving the loading/empty state is the caller's job — a component\n * holding a query result passes `data?.spans ?? []`.\n */\nexport function useTraceSearch(spans: SearchableSpan[]): UseTraceSearchResult {\n  const [query, setQuery] = useState('');\n  const deferredQuery = useDeferredValue(query);\n\n  const results = useMemo(() => {\n    const term = deferredQuery.trim().toLowerCase();\n    if (!term) return spans;\n    return filterSpansKeepingAncestors(spans, span => span.searchText.includes(term));\n  }, [spans, deferredQuery]);\n\n  return { query, setQuery, results, isPending: query !== deferredQuery };\n}\n"],"names":[],"mappings":";;;;AA8BO,SAAS,eAAe,KAAA,EAA+C;AAC5E,EAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAI,SAAS,EAAE,CAAA;AACrC,EAAA,MAAM,aAAA,GAAgB,iBAAiB,KAAK,CAAA;AAE5C,EAAA,MAAM,OAAA,GAAU,QAAQ,MAAM;AAC5B,IAAA,MAAM,IAAA,GAAO,aAAA,CAAc,IAAA,EAAK,CAAE,WAAA,EAAY;AAC9C,IAAA,IAAI,CAAC,MAAM,OAAO,KAAA;AAClB,IAAA,OAAO,4BAA4B,KAAA,EAAO,CAAA,IAAA,KAAQ,KAAK,UAAA,CAAW,QAAA,CAAS,IAAI,CAAC,CAAA;AAAA,EAClF,CAAA,EAAG,CAAC,KAAA,EAAO,aAAa,CAAC,CAAA;AAEzB,EAAA,OAAO,EAAE,KAAA,EAAO,QAAA,EAAU,OAAA,EAAS,SAAA,EAAW,UAAU,aAAA,EAAc;AACxE;;;;"}

package/dist/domains/traces/hooks/use-trace-spans.cjs.js

@@ -4,7 +4,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const react = require('@mastra/react');
 const reactQuery = require('@tanstack/react-query');
+const domains_traces_utils_toSearchableSpans = require('../utils/to-searchable-spans.cjs.js');
+require('date-fns');
 
+const IMMUTABLE_CACHE_TIME = 1e3 * 60 * 60 * 24 * 30;
 function useTraceSpans(traceId) {
   const client = react.useMastraClient();
   return reactQuery.useQuery({
@@ -16,7 +19,14 @@ function useTraceSpans(traceId) {
       const res = await client.getTrace(traceId);
       return res;
     },
-    enabled: !!traceId
+    // Builds each span's search haystack once per fetch, cached with the query.
+    select: domains_traces_utils_toSearchableSpans.selectSearchableSpans,
+    enabled: !!traceId,
+    staleTime: (query) => {
+      const data = query.state.data;
+      const isFinished = data?.spans.every((span) => Boolean(span.endedAt));
+      return isFinished ? IMMUTABLE_CACHE_TIME : 0;
+    }
   });
 }
 

package/dist/domains/traces/hooks/use-trace-spans.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-trace-spans.cjs.js","sources":["../../../../src/domains/traces/hooks/use-trace-spans.ts"],"sourcesContent":["import type { LightSpanRecord } from '@mastra/core/storage';\nimport { useMastraClient } from '@mastra/react';\nimport { useQuery } from '@tanstack/react-query';\nimport type { UseQueryResult } from '@tanstack/react-query';\n\nexport function useTraceSpans(\n  traceId: string | null | undefined,\n): UseQueryResult<{ traceId: string; spans: LightSpanRecord[] } | null> {\n  const client = useMastraClient();\n\n  return useQuery({\n    queryKey: ['trace-spans', traceId],\n    queryFn: async () => {\n      if (!traceId) {\n        throw new Error('Trace ID is required');\n      }\n      const res = await client.getTrace(traceId);\n      return res;\n    },\n    enabled: !!traceId,\n  });\n}\n"],"names":["useMastraClient","useQuery"],"mappings":";;;;;;;AAKO,SAAS,cACd,OAAA,EACsE;AACtE,EAAA,MAAM,SAASA,qBAAA,EAAgB;AAE/B,EAAA,OAAOC,mBAAA,CAAS;AAAA,IACd,QAAA,EAAU,CAAC,aAAA,EAAe,OAAO,CAAA;AAAA,IACjC,SAAS,YAAY;AACnB,MAAA,IAAI,CAAC,OAAA,EAAS;AACZ,QAAA,MAAM,IAAI,MAAM,sBAAsB,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,QAAA,CAAS,OAAO,CAAA;AACzC,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA,IACA,OAAA,EAAS,CAAC,CAAC;AAAA,GACZ,CAAA;AACH;;;;"}
+{"version":3,"file":"use-trace-spans.cjs.js","sources":["../../../../src/domains/traces/hooks/use-trace-spans.ts"],"sourcesContent":["import { useMastraClient } from '@mastra/react';\nimport { useQuery } from '@tanstack/react-query';\nimport type { UseQueryResult } from '@tanstack/react-query';\nimport type { SearchableSpan } from '../types';\nimport { selectSearchableSpans } from '../utils';\n\nconst IMMUTABLE_CACHE_TIME = 1000 * 60 * 60 * 24 * 30; // 30 days, massive cache, span data is immutable\n\n/**\n * Every span of a single trace, with its full payload.\n *\n * The lightweight projection exists to keep blob columns off the read path of a\n * *list*, where the cost is paid once per trace on screen. A trace that is open\n * has already narrowed that to one, and the panel both renders and searches\n * these spans -- `input`, `output` and `attributes` included -- so the\n * projection would only hide content the reader is looking at.\n */\nexport function useTraceSpans(\n  traceId: string | null | undefined,\n): UseQueryResult<{ traceId: string; spans: SearchableSpan[] } | null> {\n  const client = useMastraClient();\n\n  return useQuery({\n    queryKey: ['trace-spans', traceId],\n    queryFn: async () => {\n      if (!traceId) {\n        throw new Error('Trace ID is required');\n      }\n      const res = await client.getTrace(traceId);\n      return res;\n    },\n    // Builds each span's search haystack once per fetch, cached with the query.\n    select: selectSearchableSpans,\n    enabled: !!traceId,\n    staleTime: query => {\n      const data = query.state.data;\n      const isFinished = data?.spans.every(span => Boolean(span.endedAt));\n      return isFinished ? IMMUTABLE_CACHE_TIME : 0;\n    },\n  });\n}\n"],"names":["useMastraClient","useQuery","selectSearchableSpans"],"mappings":";;;;;;;;;AAMA,MAAM,oBAAA,GAAuB,GAAA,GAAO,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA;AAW5C,SAAS,cACd,OAAA,EACqE;AACrE,EAAA,MAAM,SAASA,qBAAA,EAAgB;AAE/B,EAAA,OAAOC,mBAAA,CAAS;AAAA,IACd,QAAA,EAAU,CAAC,aAAA,EAAe,OAAO,CAAA;AAAA,IACjC,SAAS,YAAY;AACnB,MAAA,IAAI,CAAC,OAAA,EAAS;AACZ,QAAA,MAAM,IAAI,MAAM,sBAAsB,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,QAAA,CAAS,OAAO,CAAA;AACzC,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA;AAAA,IAEA,MAAA,EAAQC,4DAAA;AAAA,IACR,OAAA,EAAS,CAAC,CAAC,OAAA;AAAA,IACX,WAAW,CAAA,KAAA,KAAS;AAClB,MAAA,MAAM,IAAA,GAAO,MAAM,KAAA,CAAM,IAAA;AACzB,MAAA,MAAM,UAAA,GAAa,MAAM,KAAA,CAAM,KAAA,CAAM,UAAQ,OAAA,CAAQ,IAAA,CAAK,OAAO,CAAC,CAAA;AAClE,MAAA,OAAO,aAAa,oBAAA,GAAuB,CAAA;AAAA,IAC7C;AAAA,GACD,CAAA;AACH;;;;"}

package/dist/domains/traces/hooks/use-trace-spans.es.js

@@ -1,6 +1,9 @@
 import { useMastraClient } from '@mastra/react';
 import { useQuery } from '@tanstack/react-query';
+import { selectSearchableSpans } from '../utils/to-searchable-spans.es.js';
+import 'date-fns';
 
+const IMMUTABLE_CACHE_TIME = 1e3 * 60 * 60 * 24 * 30;
 function useTraceSpans(traceId) {
   const client = useMastraClient();
   return useQuery({
@@ -12,7 +15,14 @@ function useTraceSpans(traceId) {
       const res = await client.getTrace(traceId);
       return res;
     },
-    enabled: !!traceId
+    // Builds each span's search haystack once per fetch, cached with the query.
+    select: selectSearchableSpans,
+    enabled: !!traceId,
+    staleTime: (query) => {
+      const data = query.state.data;
+      const isFinished = data?.spans.every((span) => Boolean(span.endedAt));
+      return isFinished ? IMMUTABLE_CACHE_TIME : 0;
+    }
   });
 }
 

package/dist/domains/traces/hooks/use-trace-spans.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-trace-spans.es.js","sources":["../../../../src/domains/traces/hooks/use-trace-spans.ts"],"sourcesContent":["import type { LightSpanRecord } from '@mastra/core/storage';\nimport { useMastraClient } from '@mastra/react';\nimport { useQuery } from '@tanstack/react-query';\nimport type { UseQueryResult } from '@tanstack/react-query';\n\nexport function useTraceSpans(\n  traceId: string | null | undefined,\n): UseQueryResult<{ traceId: string; spans: LightSpanRecord[] } | null> {\n  const client = useMastraClient();\n\n  return useQuery({\n    queryKey: ['trace-spans', traceId],\n    queryFn: async () => {\n      if (!traceId) {\n        throw new Error('Trace ID is required');\n      }\n      const res = await client.getTrace(traceId);\n      return res;\n    },\n    enabled: !!traceId,\n  });\n}\n"],"names":[],"mappings":";;;AAKO,SAAS,cACd,OAAA,EACsE;AACtE,EAAA,MAAM,SAAS,eAAA,EAAgB;AAE/B,EAAA,OAAO,QAAA,CAAS;AAAA,IACd,QAAA,EAAU,CAAC,aAAA,EAAe,OAAO,CAAA;AAAA,IACjC,SAAS,YAAY;AACnB,MAAA,IAAI,CAAC,OAAA,EAAS;AACZ,QAAA,MAAM,IAAI,MAAM,sBAAsB,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,QAAA,CAAS,OAAO,CAAA;AACzC,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA,IACA,OAAA,EAAS,CAAC,CAAC;AAAA,GACZ,CAAA;AACH;;;;"}
+{"version":3,"file":"use-trace-spans.es.js","sources":["../../../../src/domains/traces/hooks/use-trace-spans.ts"],"sourcesContent":["import { useMastraClient } from '@mastra/react';\nimport { useQuery } from '@tanstack/react-query';\nimport type { UseQueryResult } from '@tanstack/react-query';\nimport type { SearchableSpan } from '../types';\nimport { selectSearchableSpans } from '../utils';\n\nconst IMMUTABLE_CACHE_TIME = 1000 * 60 * 60 * 24 * 30; // 30 days, massive cache, span data is immutable\n\n/**\n * Every span of a single trace, with its full payload.\n *\n * The lightweight projection exists to keep blob columns off the read path of a\n * *list*, where the cost is paid once per trace on screen. A trace that is open\n * has already narrowed that to one, and the panel both renders and searches\n * these spans -- `input`, `output` and `attributes` included -- so the\n * projection would only hide content the reader is looking at.\n */\nexport function useTraceSpans(\n  traceId: string | null | undefined,\n): UseQueryResult<{ traceId: string; spans: SearchableSpan[] } | null> {\n  const client = useMastraClient();\n\n  return useQuery({\n    queryKey: ['trace-spans', traceId],\n    queryFn: async () => {\n      if (!traceId) {\n        throw new Error('Trace ID is required');\n      }\n      const res = await client.getTrace(traceId);\n      return res;\n    },\n    // Builds each span's search haystack once per fetch, cached with the query.\n    select: selectSearchableSpans,\n    enabled: !!traceId,\n    staleTime: query => {\n      const data = query.state.data;\n      const isFinished = data?.spans.every(span => Boolean(span.endedAt));\n      return isFinished ? IMMUTABLE_CACHE_TIME : 0;\n    },\n  });\n}\n"],"names":[],"mappings":";;;;;AAMA,MAAM,oBAAA,GAAuB,GAAA,GAAO,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA;AAW5C,SAAS,cACd,OAAA,EACqE;AACrE,EAAA,MAAM,SAAS,eAAA,EAAgB;AAE/B,EAAA,OAAO,QAAA,CAAS;AAAA,IACd,QAAA,EAAU,CAAC,aAAA,EAAe,OAAO,CAAA;AAAA,IACjC,SAAS,YAAY;AACnB,MAAA,IAAI,CAAC,OAAA,EAAS;AACZ,QAAA,MAAM,IAAI,MAAM,sBAAsB,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,GAAA,GAAM,MAAM,MAAA,CAAO,QAAA,CAAS,OAAO,CAAA;AACzC,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA;AAAA,IAEA,MAAA,EAAQ,qBAAA;AAAA,IACR,OAAA,EAAS,CAAC,CAAC,OAAA;AAAA,IACX,WAAW,CAAA,KAAA,KAAS;AAClB,MAAA,MAAM,IAAA,GAAO,MAAM,KAAA,CAAM,IAAA;AACzB,MAAA,MAAM,UAAA,GAAa,MAAM,KAAA,CAAM,KAAA,CAAM,UAAQ,OAAA,CAAQ,IAAA,CAAK,OAAO,CAAC,CAAA;AAClE,MAAA,OAAO,aAAa,oBAAA,GAAuB,CAAA;AAAA,IAC7C;AAAA,GACD,CAAA;AACH;;;;"}

package/dist/domains/traces/hooks.cjs.js

@@ -8,6 +8,7 @@ const domains_traces_hooks_useDownloadTraceJson = require('./hooks/use-download-
 const domains_traces_hooks_useSpanDetail = require('./hooks/use-span-detail.cjs.js');
 const domains_traces_hooks_useTraceLightSpans = require('./hooks/use-trace-light-spans.cjs.js');
 const domains_traces_hooks_useTraceOrBranchSpans = require('./hooks/use-trace-or-branch-spans.cjs.js');
+const domains_traces_hooks_useTraceSearch = require('./hooks/use-trace-search.cjs.js');
 const domains_traces_hooks_useTraceSpans = require('./hooks/use-trace-spans.cjs.js');
 const domains_traces_hooks_useTraces = require('./hooks/use-traces.cjs.js');
 const domains_traces_hooks_useTags = require('./hooks/use-tags.cjs.js');
@@ -28,6 +29,7 @@ exports.useDownloadTraceJson = domains_traces_hooks_useDownloadTraceJson.useDown
 exports.useSpanDetail = domains_traces_hooks_useSpanDetail.useSpanDetail;
 exports.useTraceLightSpans = domains_traces_hooks_useTraceLightSpans.useTraceLightSpans;
 exports.useTraceOrBranchSpans = domains_traces_hooks_useTraceOrBranchSpans.useTraceOrBranchSpans;
+exports.useTraceSearch = domains_traces_hooks_useTraceSearch.useTraceSearch;
 exports.useTraceSpans = domains_traces_hooks_useTraceSpans.useTraceSpans;
 exports.useTraces = domains_traces_hooks_useTraces.useTraces;
 exports.useTags = domains_traces_hooks_useTags.useTags;

package/dist/domains/traces/hooks.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"hooks.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/domains/traces/hooks.es.js

@@ -4,6 +4,7 @@ export { useDownloadTraceJson } from './hooks/use-download-trace-json.es.js';
 export { useSpanDetail } from './hooks/use-span-detail.es.js';
 export { useTraceLightSpans } from './hooks/use-trace-light-spans.es.js';
 export { useTraceOrBranchSpans } from './hooks/use-trace-or-branch-spans.es.js';
+export { useTraceSearch } from './hooks/use-trace-search.es.js';
 export { useTraceSpans } from './hooks/use-trace-spans.es.js';
 export { useTraces } from './hooks/use-traces.es.js';
 export { useTags } from './hooks/use-tags.es.js';

package/dist/domains/traces/hooks.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}
+{"version":3,"file":"hooks.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/dist/domains/traces/types.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.cjs.js","sources":["../../../src/domains/traces/types.ts"],"sourcesContent":["import type { EntityType } from '@mastra/core/observability';\nimport type { ReactNode } from 'react';\n\nexport type UISpan = {\n  id: string;\n  name: string;\n  type: string;\n  latency: number;\n  startTime: string;\n  endTime?: string;\n  spans?: UISpan[];\n  parentSpanId?: string | null;\n};\n\nexport type UISpanStyle = {\n  icon?: ReactNode;\n  color?: string;\n  label?: string;\n  typePrefix: string;\n};\n\n// -- Trace filtering types ----------------------------------------------------\n\nexport type EntityOptions =\n  | { value: string; label: string; type: EntityType.AGENT }\n  | { value: string; label: string; type: EntityType.WORKFLOW_RUN }\n  | { value: string; label: string; type: 'all' };\n\nexport type TraceDatePreset = 'all' | 'last-24h' | 'last-3d' | 'last-7d' | 'last-14d' | 'last-30d' | 'custom';\n\n/** Tab identifier for SpanDataPanelView. */\nexport type SpanTab = 'details' | 'feedback';\n\n/** Canonical list of context field IDs used for trace filtering and value extraction */\nexport const CONTEXT_FIELD_IDS = [\n  'environment',\n  'serviceName',\n  'source',\n  'scope',\n  'userId',\n  'organizationId',\n  'resourceId',\n  'runId',\n  'sessionId',\n  'threadId',\n  'requestId',\n  'experimentId',\n  'spanType',\n  'entityName',\n  'parentEntityType',\n  'parentEntityId',\n  'parentEntityName',\n  'rootEntityType',\n  'rootEntityId',\n  'rootEntityName',\n] as const;\n"],"names":[],"mappings":";;;;AAkCO,MAAM,iBAAA,GAAoB;AAAA,EAC/B,aAAA;AAAA,EACA,aAAA;AAAA,EACA,QAAA;AAAA,EACA,OAAA;AAAA,EACA,QAAA;AAAA,EACA,gBAAA;AAAA,EACA,YAAA;AAAA,EACA,OAAA;AAAA,EACA,WAAA;AAAA,EACA,UAAA;AAAA,EACA,WAAA;AAAA,EACA,cAAA;AAAA,EACA,UAAA;AAAA,EACA,YAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,cAAA;AAAA,EACA;AACF;;;;"}
+{"version":3,"file":"types.cjs.js","sources":["../../../src/domains/traces/types.ts"],"sourcesContent":["import type { EntityType } from '@mastra/core/observability';\nimport type { LightSpanRecord } from '@mastra/core/storage';\nimport type { ReactNode } from 'react';\n\n/**\n * A light span carrying a precomputed haystack of everything it holds.\n *\n * `LightSpanRecord` exposes searchable content across a fixed set of columns\n * plus open-ended payloads whose shape is unknown, so a search cannot read it\n * field by field. `searchText` is that content flattened once — see\n * `flattenToSearchText` — so filtering is a substring test per span instead of\n * a re-walk of every payload on every keystroke.\n *\n * It holds field names as well as values, so a span is findable by the shape of\n * its payload and not only by its content.\n */\nexport type SearchableSpan = LightSpanRecord & {\n  searchText: string;\n};\n\nexport type UISpan = {\n  id: string;\n  name: string;\n  type: string;\n  latency: number;\n  startTime: string;\n  endTime?: string;\n  spans?: UISpan[];\n  parentSpanId?: string | null;\n};\n\nexport type UISpanStyle = {\n  icon?: ReactNode;\n  color?: string;\n  label?: string;\n  typePrefix: string;\n};\n\n// -- Trace filtering types ----------------------------------------------------\n\nexport type EntityOptions =\n  | { value: string; label: string; type: EntityType.AGENT }\n  | { value: string; label: string; type: EntityType.WORKFLOW_RUN }\n  | { value: string; label: string; type: 'all' };\n\nexport type TraceDatePreset = 'all' | 'last-24h' | 'last-3d' | 'last-7d' | 'last-14d' | 'last-30d' | 'custom';\n\n/** Tab identifier for SpanDataPanelView. */\nexport type SpanTab = 'details' | 'feedback';\n\n/** Canonical list of context field IDs used for trace filtering and value extraction */\nexport const CONTEXT_FIELD_IDS = [\n  'environment',\n  'serviceName',\n  'source',\n  'scope',\n  'userId',\n  'organizationId',\n  'resourceId',\n  'runId',\n  'sessionId',\n  'threadId',\n  'requestId',\n  'experimentId',\n  'spanType',\n  'entityName',\n  'parentEntityType',\n  'parentEntityId',\n  'parentEntityName',\n  'rootEntityType',\n  'rootEntityId',\n  'rootEntityName',\n] as const;\n"],"names":[],"mappings":";;;;AAmDO,MAAM,iBAAA,GAAoB;AAAA,EAC/B,aAAA;AAAA,EACA,aAAA;AAAA,EACA,QAAA;AAAA,EACA,OAAA;AAAA,EACA,QAAA;AAAA,EACA,gBAAA;AAAA,EACA,YAAA;AAAA,EACA,OAAA;AAAA,EACA,WAAA;AAAA,EACA,UAAA;AAAA,EACA,WAAA;AAAA,EACA,cAAA;AAAA,EACA,UAAA;AAAA,EACA,YAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,cAAA;AAAA,EACA;AACF;;;;"}

package/dist/domains/traces/types.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.es.js","sources":["../../../src/domains/traces/types.ts"],"sourcesContent":["import type { EntityType } from '@mastra/core/observability';\nimport type { ReactNode } from 'react';\n\nexport type UISpan = {\n  id: string;\n  name: string;\n  type: string;\n  latency: number;\n  startTime: string;\n  endTime?: string;\n  spans?: UISpan[];\n  parentSpanId?: string | null;\n};\n\nexport type UISpanStyle = {\n  icon?: ReactNode;\n  color?: string;\n  label?: string;\n  typePrefix: string;\n};\n\n// -- Trace filtering types ----------------------------------------------------\n\nexport type EntityOptions =\n  | { value: string; label: string; type: EntityType.AGENT }\n  | { value: string; label: string; type: EntityType.WORKFLOW_RUN }\n  | { value: string; label: string; type: 'all' };\n\nexport type TraceDatePreset = 'all' | 'last-24h' | 'last-3d' | 'last-7d' | 'last-14d' | 'last-30d' | 'custom';\n\n/** Tab identifier for SpanDataPanelView. */\nexport type SpanTab = 'details' | 'feedback';\n\n/** Canonical list of context field IDs used for trace filtering and value extraction */\nexport const CONTEXT_FIELD_IDS = [\n  'environment',\n  'serviceName',\n  'source',\n  'scope',\n  'userId',\n  'organizationId',\n  'resourceId',\n  'runId',\n  'sessionId',\n  'threadId',\n  'requestId',\n  'experimentId',\n  'spanType',\n  'entityName',\n  'parentEntityType',\n  'parentEntityId',\n  'parentEntityName',\n  'rootEntityType',\n  'rootEntityId',\n  'rootEntityName',\n] as const;\n"],"names":[],"mappings":"AAkCO,MAAM,iBAAA,GAAoB;AAAA,EAC/B,aAAA;AAAA,EACA,aAAA;AAAA,EACA,QAAA;AAAA,EACA,OAAA;AAAA,EACA,QAAA;AAAA,EACA,gBAAA;AAAA,EACA,YAAA;AAAA,EACA,OAAA;AAAA,EACA,WAAA;AAAA,EACA,UAAA;AAAA,EACA,WAAA;AAAA,EACA,cAAA;AAAA,EACA,UAAA;AAAA,EACA,YAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,cAAA;AAAA,EACA;AACF;;;;"}
+{"version":3,"file":"types.es.js","sources":["../../../src/domains/traces/types.ts"],"sourcesContent":["import type { EntityType } from '@mastra/core/observability';\nimport type { LightSpanRecord } from '@mastra/core/storage';\nimport type { ReactNode } from 'react';\n\n/**\n * A light span carrying a precomputed haystack of everything it holds.\n *\n * `LightSpanRecord` exposes searchable content across a fixed set of columns\n * plus open-ended payloads whose shape is unknown, so a search cannot read it\n * field by field. `searchText` is that content flattened once — see\n * `flattenToSearchText` — so filtering is a substring test per span instead of\n * a re-walk of every payload on every keystroke.\n *\n * It holds field names as well as values, so a span is findable by the shape of\n * its payload and not only by its content.\n */\nexport type SearchableSpan = LightSpanRecord & {\n  searchText: string;\n};\n\nexport type UISpan = {\n  id: string;\n  name: string;\n  type: string;\n  latency: number;\n  startTime: string;\n  endTime?: string;\n  spans?: UISpan[];\n  parentSpanId?: string | null;\n};\n\nexport type UISpanStyle = {\n  icon?: ReactNode;\n  color?: string;\n  label?: string;\n  typePrefix: string;\n};\n\n// -- Trace filtering types ----------------------------------------------------\n\nexport type EntityOptions =\n  | { value: string; label: string; type: EntityType.AGENT }\n  | { value: string; label: string; type: EntityType.WORKFLOW_RUN }\n  | { value: string; label: string; type: 'all' };\n\nexport type TraceDatePreset = 'all' | 'last-24h' | 'last-3d' | 'last-7d' | 'last-14d' | 'last-30d' | 'custom';\n\n/** Tab identifier for SpanDataPanelView. */\nexport type SpanTab = 'details' | 'feedback';\n\n/** Canonical list of context field IDs used for trace filtering and value extraction */\nexport const CONTEXT_FIELD_IDS = [\n  'environment',\n  'serviceName',\n  'source',\n  'scope',\n  'userId',\n  'organizationId',\n  'resourceId',\n  'runId',\n  'sessionId',\n  'threadId',\n  'requestId',\n  'experimentId',\n  'spanType',\n  'entityName',\n  'parentEntityType',\n  'parentEntityId',\n  'parentEntityName',\n  'rootEntityType',\n  'rootEntityId',\n  'rootEntityName',\n] as const;\n"],"names":[],"mappings":"AAmDO,MAAM,iBAAA,GAAoB;AAAA,EAC/B,aAAA;AAAA,EACA,aAAA;AAAA,EACA,QAAA;AAAA,EACA,OAAA;AAAA,EACA,QAAA;AAAA,EACA,gBAAA;AAAA,EACA,YAAA;AAAA,EACA,OAAA;AAAA,EACA,WAAA;AAAA,EACA,UAAA;AAAA,EACA,WAAA;AAAA,EACA,cAAA;AAAA,EACA,UAAA;AAAA,EACA,YAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,kBAAA;AAAA,EACA,gBAAA;AAAA,EACA,cAAA;AAAA,EACA;AACF;;;;"}

package/dist/domains/traces/utils/filter-spans-keeping-ancestors.cjs.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function filterSpansKeepingAncestors(spans, predicate) {
+  if (!spans || spans.length === 0) {
+    return [];
+  }
+  const byId = /* @__PURE__ */ new Map();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const matches = [];
+  for (const span of spans) {
+    if (!span) continue;
+    byId.set(span.spanId, span);
+    if (span.parentSpanId) {
+      const siblings = childrenByParent.get(span.parentSpanId);
+      if (siblings) siblings.push(span);
+      else childrenByParent.set(span.parentSpanId, [span]);
+    }
+    if (predicate(span)) matches.push(span);
+  }
+  if (matches.length === 0) {
+    return [];
+  }
+  const kept = /* @__PURE__ */ new Set();
+  const stack = [...matches];
+  while (stack.length > 0) {
+    const span = stack.pop();
+    if (!span || kept.has(span.spanId)) continue;
+    kept.add(span.spanId);
+    const children = childrenByParent.get(span.spanId);
+    if (children) stack.push(...children);
+  }
+  for (const match of matches) {
+    let parentSpanId = match.parentSpanId;
+    while (parentSpanId && !kept.has(parentSpanId)) {
+      const parent = byId.get(parentSpanId);
+      if (!parent) break;
+      kept.add(parent.spanId);
+      parentSpanId = parent.parentSpanId;
+    }
+  }
+  return spans.filter((span) => span && kept.has(span.spanId));
+}
+
+exports.filterSpansKeepingAncestors = filterSpansKeepingAncestors;
+//# sourceMappingURL=filter-spans-keeping-ancestors.cjs.js.map

package/dist/domains/traces/utils/filter-spans-keeping-ancestors.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-spans-keeping-ancestors.cjs.js","sources":["../../../../src/domains/traces/utils/filter-spans-keeping-ancestors.ts"],"sourcesContent":["import type { LightSpanRecord } from '@mastra/core/storage';\n\n/**\n * Filter a flat span list down to the spans matching `predicate`, plus every\n * ancestor needed to keep those spans connected to their root, plus the whole\n * subtree below each match — a matching span is shown intact, not truncated.\n *\n * `spans` may arrive in any order. Trace payloads are flat lists sorted by\n * `startedAt` (and the list API defaults to `direction: 'DESC'`), so children\n * routinely precede their parents; the traversal below indexes the list up\n * front rather than assuming a topological order.\n *\n * The output preserves the input's relative order, so it can be fed straight\n * into `formatHierarchicalSpans`. `predicate` is called exactly once per span.\n *\n * Generic over the span type: only `spanId` and `parentSpanId` are read, and the\n * exact input type comes back out, so enriched spans such as `SearchableSpan`\n * survive the filter instead of being widened to `LightSpanRecord`.\n */\nexport function filterSpansKeepingAncestors<T extends Pick<LightSpanRecord, 'spanId' | 'parentSpanId'>>(\n  spans: T[],\n  predicate: (span: T) => boolean,\n): T[] {\n  if (!spans || spans.length === 0) {\n    return [];\n  }\n\n  const byId = new Map<string, T>();\n  const childrenByParent = new Map<string, T[]>();\n  const matches: T[] = [];\n\n  for (const span of spans) {\n    if (!span) continue;\n\n    byId.set(span.spanId, span);\n\n    if (span.parentSpanId) {\n      const siblings = childrenByParent.get(span.parentSpanId);\n      if (siblings) siblings.push(span);\n      else childrenByParent.set(span.parentSpanId, [span]);\n    }\n\n    if (predicate(span)) matches.push(span);\n  }\n\n  if (matches.length === 0) {\n    return [];\n  }\n\n  const kept = new Set<string>();\n\n  // Downwards: every descendant of every match. `kept` doubles as the visited\n  // set, so cycles and self-parented spans terminate.\n  const stack = [...matches];\n  while (stack.length > 0) {\n    const span = stack.pop();\n    if (!span || kept.has(span.spanId)) continue;\n\n    kept.add(span.spanId);\n\n    const children = childrenByParent.get(span.spanId);\n    if (children) stack.push(...children);\n  }\n\n  // Upwards: the ancestor chain of every match, stopping at the first span\n  // already kept or at a parent that isn't in the list (branch boundary).\n  for (const match of matches) {\n    let parentSpanId = match.parentSpanId;\n\n    while (parentSpanId && !kept.has(parentSpanId)) {\n      const parent = byId.get(parentSpanId);\n      if (!parent) break;\n\n      kept.add(parent.spanId);\n      parentSpanId = parent.parentSpanId;\n    }\n  }\n\n  return spans.filter(span => span && kept.has(span.spanId));\n}\n"],"names":[],"mappings":";;;;AAmBO,SAAS,2BAAA,CACd,OACA,SAAA,EACK;AACL,EAAA,IAAI,CAAC,KAAA,IAAS,KAAA,CAAM,MAAA,KAAW,CAAA,EAAG;AAChC,IAAA,OAAO,EAAC;AAAA,EACV;AAEA,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAe;AAChC,EAAA,MAAM,gBAAA,uBAAuB,GAAA,EAAiB;AAC9C,EAAA,MAAM,UAAe,EAAC;AAEtB,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,IAAI,CAAC,IAAA,EAAM;AAEX,IAAA,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,MAAA,EAAQ,IAAI,CAAA;AAE1B,IAAA,IAAI,KAAK,YAAA,EAAc;AACrB,MAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,GAAA,CAAI,IAAA,CAAK,YAAY,CAAA;AACvD,MAAA,IAAI,QAAA,EAAU,QAAA,CAAS,IAAA,CAAK,IAAI,CAAA;AAAA,4BACV,GAAA,CAAI,IAAA,CAAK,YAAA,EAAc,CAAC,IAAI,CAAC,CAAA;AAAA,IACrD;AAEA,IAAA,IAAI,SAAA,CAAU,IAAI,CAAA,EAAG,OAAA,CAAQ,KAAK,IAAI,CAAA;AAAA,EACxC;AAEA,EAAA,IAAI,OAAA,CAAQ,WAAW,CAAA,EAAG;AACxB,IAAA,OAAO,EAAC;AAAA,EACV;AAEA,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAI7B,EAAA,MAAM,KAAA,GAAQ,CAAC,GAAG,OAAO,CAAA;AACzB,EAAA,OAAO,KAAA,CAAM,SAAS,CAAA,EAAG;AACvB,IAAA,MAAM,IAAA,GAAO,MAAM,GAAA,EAAI;AACvB,IAAA,IAAI,CAAC,IAAA,IAAQ,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,MAAM,CAAA,EAAG;AAEpC,IAAA,IAAA,CAAK,GAAA,CAAI,KAAK,MAAM,CAAA;AAEpB,IAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,GAAA,CAAI,IAAA,CAAK,MAAM,CAAA;AACjD,IAAA,IAAI,QAAA,EAAU,KAAA,CAAM,IAAA,CAAK,GAAG,QAAQ,CAAA;AAAA,EACtC;AAIA,EAAA,KAAA,MAAW,SAAS,OAAA,EAAS;AAC3B,IAAA,IAAI,eAAe,KAAA,CAAM,YAAA;AAEzB,IAAA,OAAO,YAAA,IAAgB,CAAC,IAAA,CAAK,GAAA,CAAI,YAAY,CAAA,EAAG;AAC9C,MAAA,MAAM,MAAA,GAAS,IAAA,CAAK,GAAA,CAAI,YAAY,CAAA;AACpC,MAAA,IAAI,CAAC,MAAA,EAAQ;AAEb,MAAA,IAAA,CAAK,GAAA,CAAI,OAAO,MAAM,CAAA;AACtB,MAAA,YAAA,GAAe,MAAA,CAAO,YAAA;AAAA,IACxB;AAAA,EACF;AAEA,EAAA,OAAO,KAAA,CAAM,OAAO,CAAA,IAAA,KAAQ,IAAA,IAAQ,KAAK,GAAA,CAAI,IAAA,CAAK,MAAM,CAAC,CAAA;AAC3D;;;;"}

package/dist/domains/traces/utils/filter-spans-keeping-ancestors.d.ts

@@ -0,0 +1,2 @@
+export * from '../../../src/domains/traces/utils/filter-spans-keeping-ancestors'
+export {}

package/dist/domains/traces/utils/filter-spans-keeping-ancestors.es.js

@@ -0,0 +1,43 @@
+function filterSpansKeepingAncestors(spans, predicate) {
+  if (!spans || spans.length === 0) {
+    return [];
+  }
+  const byId = /* @__PURE__ */ new Map();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const matches = [];
+  for (const span of spans) {
+    if (!span) continue;
+    byId.set(span.spanId, span);
+    if (span.parentSpanId) {
+      const siblings = childrenByParent.get(span.parentSpanId);
+      if (siblings) siblings.push(span);
+      else childrenByParent.set(span.parentSpanId, [span]);
+    }
+    if (predicate(span)) matches.push(span);
+  }
+  if (matches.length === 0) {
+    return [];
+  }
+  const kept = /* @__PURE__ */ new Set();
+  const stack = [...matches];
+  while (stack.length > 0) {
+    const span = stack.pop();
+    if (!span || kept.has(span.spanId)) continue;
+    kept.add(span.spanId);
+    const children = childrenByParent.get(span.spanId);
+    if (children) stack.push(...children);
+  }
+  for (const match of matches) {
+    let parentSpanId = match.parentSpanId;
+    while (parentSpanId && !kept.has(parentSpanId)) {
+      const parent = byId.get(parentSpanId);
+      if (!parent) break;
+      kept.add(parent.spanId);
+      parentSpanId = parent.parentSpanId;
+    }
+  }
+  return spans.filter((span) => span && kept.has(span.spanId));
+}
+
+export { filterSpansKeepingAncestors };
+//# sourceMappingURL=filter-spans-keeping-ancestors.es.js.map

package/dist/domains/traces/utils/filter-spans-keeping-ancestors.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-spans-keeping-ancestors.es.js","sources":["../../../../src/domains/traces/utils/filter-spans-keeping-ancestors.ts"],"sourcesContent":["import type { LightSpanRecord } from '@mastra/core/storage';\n\n/**\n * Filter a flat span list down to the spans matching `predicate`, plus every\n * ancestor needed to keep those spans connected to their root, plus the whole\n * subtree below each match — a matching span is shown intact, not truncated.\n *\n * `spans` may arrive in any order. Trace payloads are flat lists sorted by\n * `startedAt` (and the list API defaults to `direction: 'DESC'`), so children\n * routinely precede their parents; the traversal below indexes the list up\n * front rather than assuming a topological order.\n *\n * The output preserves the input's relative order, so it can be fed straight\n * into `formatHierarchicalSpans`. `predicate` is called exactly once per span.\n *\n * Generic over the span type: only `spanId` and `parentSpanId` are read, and the\n * exact input type comes back out, so enriched spans such as `SearchableSpan`\n * survive the filter instead of being widened to `LightSpanRecord`.\n */\nexport function filterSpansKeepingAncestors<T extends Pick<LightSpanRecord, 'spanId' | 'parentSpanId'>>(\n  spans: T[],\n  predicate: (span: T) => boolean,\n): T[] {\n  if (!spans || spans.length === 0) {\n    return [];\n  }\n\n  const byId = new Map<string, T>();\n  const childrenByParent = new Map<string, T[]>();\n  const matches: T[] = [];\n\n  for (const span of spans) {\n    if (!span) continue;\n\n    byId.set(span.spanId, span);\n\n    if (span.parentSpanId) {\n      const siblings = childrenByParent.get(span.parentSpanId);\n      if (siblings) siblings.push(span);\n      else childrenByParent.set(span.parentSpanId, [span]);\n    }\n\n    if (predicate(span)) matches.push(span);\n  }\n\n  if (matches.length === 0) {\n    return [];\n  }\n\n  const kept = new Set<string>();\n\n  // Downwards: every descendant of every match. `kept` doubles as the visited\n  // set, so cycles and self-parented spans terminate.\n  const stack = [...matches];\n  while (stack.length > 0) {\n    const span = stack.pop();\n    if (!span || kept.has(span.spanId)) continue;\n\n    kept.add(span.spanId);\n\n    const children = childrenByParent.get(span.spanId);\n    if (children) stack.push(...children);\n  }\n\n  // Upwards: the ancestor chain of every match, stopping at the first span\n  // already kept or at a parent that isn't in the list (branch boundary).\n  for (const match of matches) {\n    let parentSpanId = match.parentSpanId;\n\n    while (parentSpanId && !kept.has(parentSpanId)) {\n      const parent = byId.get(parentSpanId);\n      if (!parent) break;\n\n      kept.add(parent.spanId);\n      parentSpanId = parent.parentSpanId;\n    }\n  }\n\n  return spans.filter(span => span && kept.has(span.spanId));\n}\n"],"names":[],"mappings":"AAmBO,SAAS,2BAAA,CACd,OACA,SAAA,EACK;AACL,EAAA,IAAI,CAAC,KAAA,IAAS,KAAA,CAAM,MAAA,KAAW,CAAA,EAAG;AAChC,IAAA,OAAO,EAAC;AAAA,EACV;AAEA,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAe;AAChC,EAAA,MAAM,gBAAA,uBAAuB,GAAA,EAAiB;AAC9C,EAAA,MAAM,UAAe,EAAC;AAEtB,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,IAAI,CAAC,IAAA,EAAM;AAEX,IAAA,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,MAAA,EAAQ,IAAI,CAAA;AAE1B,IAAA,IAAI,KAAK,YAAA,EAAc;AACrB,MAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,GAAA,CAAI,IAAA,CAAK,YAAY,CAAA;AACvD,MAAA,IAAI,QAAA,EAAU,QAAA,CAAS,IAAA,CAAK,IAAI,CAAA;AAAA,4BACV,GAAA,CAAI,IAAA,CAAK,YAAA,EAAc,CAAC,IAAI,CAAC,CAAA;AAAA,IACrD;AAEA,IAAA,IAAI,SAAA,CAAU,IAAI,CAAA,EAAG,OAAA,CAAQ,KAAK,IAAI,CAAA;AAAA,EACxC;AAEA,EAAA,IAAI,OAAA,CAAQ,WAAW,CAAA,EAAG;AACxB,IAAA,OAAO,EAAC;AAAA,EACV;AAEA,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAI7B,EAAA,MAAM,KAAA,GAAQ,CAAC,GAAG,OAAO,CAAA;AACzB,EAAA,OAAO,KAAA,CAAM,SAAS,CAAA,EAAG;AACvB,IAAA,MAAM,IAAA,GAAO,MAAM,GAAA,EAAI;AACvB,IAAA,IAAI,CAAC,IAAA,IAAQ,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,MAAM,CAAA,EAAG;AAEpC,IAAA,IAAA,CAAK,GAAA,CAAI,KAAK,MAAM,CAAA;AAEpB,IAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,GAAA,CAAI,IAAA,CAAK,MAAM,CAAA;AACjD,IAAA,IAAI,QAAA,EAAU,KAAA,CAAM,IAAA,CAAK,GAAG,QAAQ,CAAA;AAAA,EACtC;AAIA,EAAA,KAAA,MAAW,SAAS,OAAA,EAAS;AAC3B,IAAA,IAAI,eAAe,KAAA,CAAM,YAAA;AAEzB,IAAA,OAAO,YAAA,IAAgB,CAAC,IAAA,CAAK,GAAA,CAAI,YAAY,CAAA,EAAG;AAC9C,MAAA,MAAM,MAAA,GAAS,IAAA,CAAK,GAAA,CAAI,YAAY,CAAA;AACpC,MAAA,IAAI,CAAC,MAAA,EAAQ;AAEb,MAAA,IAAA,CAAK,GAAA,CAAI,OAAO,MAAM,CAAA;AACtB,MAAA,YAAA,GAAe,MAAA,CAAO,YAAA;AAAA,IACxB;AAAA,EACF;AAEA,EAAA,OAAO,KAAA,CAAM,OAAO,CAAA,IAAA,KAAQ,IAAA,IAAQ,KAAK,GAAA,CAAI,IAAA,CAAK,MAAM,CAAC,CAAA;AAC3D;;;;"}

package/dist/domains/traces/utils/flatten-to-search-text.cjs.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function flattenToSearchText(value) {
+  const parts = [];
+  const path = /* @__PURE__ */ new Set();
+  collect(value, parts, path);
+  return parts.join(" ");
+}
+function collect(value, parts, path) {
+  if (value === null || value === void 0) return;
+  switch (typeof value) {
+    case "string": {
+      const trimmed = value.trim();
+      if (trimmed) parts.push(trimmed);
+      return;
+    }
+    case "number": {
+      if (Number.isFinite(value)) parts.push(String(value));
+      return;
+    }
+    case "boolean":
+    case "bigint":
+      parts.push(String(value));
+      return;
+    case "function":
+    case "symbol":
+      return;
+  }
+  const object = value;
+  if (path.has(object)) return;
+  path.add(object);
+  try {
+    collectFromObject(object, parts, path);
+  } finally {
+    path.delete(object);
+  }
+}
+function collectFromObject(object, parts, path) {
+  if (object instanceof Date) {
+    const time = object.getTime();
+    if (!Number.isNaN(time)) parts.push(object.toISOString());
+    return;
+  }
+  if (object instanceof Error) {
+    collect(object.message, parts, path);
+    return;
+  }
+  if (Array.isArray(object)) {
+    for (const item of object) collect(item, parts, path);
+    return;
+  }
+  if (object instanceof Map) {
+    for (const [key, item] of object) {
+      collect(key, parts, path);
+      collect(item, parts, path);
+    }
+    return;
+  }
+  if (object instanceof Set) {
+    for (const item of object) collect(item, parts, path);
+    return;
+  }
+  for (const key of Object.keys(object)) {
+    collect(key, parts, path);
+    let item;
+    try {
+      item = object[key];
+    } catch {
+      continue;
+    }
+    collect(item, parts, path);
+  }
+}
+
+exports.flattenToSearchText = flattenToSearchText;
+//# sourceMappingURL=flatten-to-search-text.cjs.js.map

package/dist/domains/traces/utils/flatten-to-search-text.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-to-search-text.cjs.js","sources":["../../../../src/domains/traces/utils/flatten-to-search-text.ts"],"sourcesContent":["/**\n * Flatten an arbitrary value into a single space-separated string containing\n * every searchable token it holds, however deeply nested.\n *\n * Built for span payloads whose shape is not known ahead of time (`attributes`,\n * `output`, `errorInfo`): the caller cannot enumerate fields, so this walks\n * whatever it is handed.\n *\n * **Keys are emitted alongside their values**, so a field name is searchable\n * even when its value is not — `{ error: null }` still answers a search for\n * `error`. The cost is that structural names present on every span (`traceId`,\n * `usage`, …) are searchable too, which makes short generic terms match widely.\n *\n * Values that no one can usefully search for are dropped rather than\n * stringified: `null`, `undefined`, `NaN`, infinities, functions, symbols,\n * invalid dates and whitespace-only strings. Dropping them keeps the output\n * free of noise words like `\"Invalid Date\"` that would produce false hits.\n * Array indices are dropped for the same reason — `0 1 2` is not content.\n *\n * Cycles are detected along the current path, so a self-referencing object\n * terminates while a value referenced twice as a sibling is emitted twice.\n * Only own, string-keyed properties are read, and a getter that throws is\n * skipped instead of taking the whole trace down.\n */\nexport function flattenToSearchText(value: unknown): string {\n  const parts: string[] = [];\n  const path = new Set<object>();\n\n  collect(value, parts, path);\n\n  return parts.join(' ');\n}\n\nfunction collect(value: unknown, parts: string[], path: Set<object>): void {\n  if (value === null || value === undefined) return;\n\n  switch (typeof value) {\n    case 'string': {\n      const trimmed = value.trim();\n      if (trimmed) parts.push(trimmed);\n      return;\n    }\n    case 'number': {\n      // NaN and infinities have no useful search form.\n      if (Number.isFinite(value)) parts.push(String(value));\n      return;\n    }\n    case 'boolean':\n    case 'bigint':\n      parts.push(String(value));\n      return;\n    case 'function':\n    case 'symbol':\n      return;\n  }\n\n  const object = value as object;\n\n  // Guard the current path only: a cycle must terminate, but the same object\n  // referenced twice side by side is legitimately worth emitting twice.\n  if (path.has(object)) return;\n  path.add(object);\n\n  try {\n    collectFromObject(object, parts, path);\n  } finally {\n    path.delete(object);\n  }\n}\n\nfunction collectFromObject(object: object, parts: string[], path: Set<object>): void {\n  if (object instanceof Date) {\n    const time = object.getTime();\n    if (!Number.isNaN(time)) parts.push(object.toISOString());\n    return;\n  }\n\n  if (object instanceof Error) {\n    collect(object.message, parts, path);\n    return;\n  }\n\n  // Indices carry no meaning, so an array contributes only its items.\n  if (Array.isArray(object)) {\n    for (const item of object) collect(item, parts, path);\n    return;\n  }\n\n  if (object instanceof Map) {\n    for (const [key, item] of object) {\n      collect(key, parts, path);\n      collect(item, parts, path);\n    }\n    return;\n  }\n\n  // A Set has members, not fields.\n  if (object instanceof Set) {\n    for (const item of object) collect(item, parts, path);\n    return;\n  }\n\n  // Own string keys only: skips the prototype chain and symbol-keyed entries.\n  for (const key of Object.keys(object)) {\n    // The key is emitted even when the value turns out to be unsearchable, so\n    // the presence of a field is itself findable.\n    collect(key, parts, path);\n\n    let item: unknown;\n    try {\n      item = (object as Record<string, unknown>)[key];\n    } catch {\n      // A getter that throws is not a reason to lose the rest of the payload.\n      continue;\n    }\n    collect(item, parts, path);\n  }\n}\n"],"names":[],"mappings":";;;;AAwBO,SAAS,oBAAoB,KAAA,EAAwB;AAC1D,EAAA,MAAM,QAAkB,EAAC;AACzB,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAE7B,EAAA,OAAA,CAAQ,KAAA,EAAO,OAAO,IAAI,CAAA;AAE1B,EAAA,OAAO,KAAA,CAAM,KAAK,GAAG,CAAA;AACvB;AAEA,SAAS,OAAA,CAAQ,KAAA,EAAgB,KAAA,EAAiB,IAAA,EAAyB;AACzE,EAAA,IAAI,KAAA,KAAU,IAAA,IAAQ,KAAA,KAAU,MAAA,EAAW;AAE3C,EAAA,QAAQ,OAAO,KAAA;AAAO,IACpB,KAAK,QAAA,EAAU;AACb,MAAA,MAAM,OAAA,GAAU,MAAM,IAAA,EAAK;AAC3B,MAAA,IAAI,OAAA,EAAS,KAAA,CAAM,IAAA,CAAK,OAAO,CAAA;AAC/B,MAAA;AAAA,IACF;AAAA,IACA,KAAK,QAAA,EAAU;AAEb,MAAA,IAAI,MAAA,CAAO,SAAS,KAAK,CAAA,QAAS,IAAA,CAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AACpD,MAAA;AAAA,IACF;AAAA,IACA,KAAK,SAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,KAAA,CAAM,IAAA,CAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AACxB,MAAA;AAAA,IACF,KAAK,UAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA;AAAA;AAGJ,EAAA,MAAM,MAAA,GAAS,KAAA;AAIf,EAAA,IAAI,IAAA,CAAK,GAAA,CAAI,MAAM,CAAA,EAAG;AACtB,EAAA,IAAA,CAAK,IAAI,MAAM,CAAA;AAEf,EAAA,IAAI;AACF,IAAA,iBAAA,CAAkB,MAAA,EAAQ,OAAO,IAAI,CAAA;AAAA,EACvC,CAAA,SAAE;AACA,IAAA,IAAA,CAAK,OAAO,MAAM,CAAA;AAAA,EACpB;AACF;AAEA,SAAS,iBAAA,CAAkB,MAAA,EAAgB,KAAA,EAAiB,IAAA,EAAyB;AACnF,EAAA,IAAI,kBAAkB,IAAA,EAAM;AAC1B,IAAA,MAAM,IAAA,GAAO,OAAO,OAAA,EAAQ;AAC5B,IAAA,IAAI,CAAC,OAAO,KAAA,CAAM,IAAI,GAAG,KAAA,CAAM,IAAA,CAAK,MAAA,CAAO,WAAA,EAAa,CAAA;AACxD,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,kBAAkB,KAAA,EAAO;AAC3B,IAAA,OAAA,CAAQ,MAAA,CAAO,OAAA,EAAS,KAAA,EAAO,IAAI,CAAA;AACnC,IAAA;AAAA,EACF;AAGA,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,EAAG;AACzB,IAAA,KAAA,MAAW,IAAA,IAAQ,MAAA,EAAQ,OAAA,CAAQ,IAAA,EAAM,OAAO,IAAI,CAAA;AACpD,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,kBAAkB,GAAA,EAAK;AACzB,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,IAAI,CAAA,IAAK,MAAA,EAAQ;AAChC,MAAA,OAAA,CAAQ,GAAA,EAAK,OAAO,IAAI,CAAA;AACxB,MAAA,OAAA,CAAQ,IAAA,EAAM,OAAO,IAAI,CAAA;AAAA,IAC3B;AACA,IAAA;AAAA,EACF;AAGA,EAAA,IAAI,kBAAkB,GAAA,EAAK;AACzB,IAAA,KAAA,MAAW,IAAA,IAAQ,MAAA,EAAQ,OAAA,CAAQ,IAAA,EAAM,OAAO,IAAI,CAAA;AACpD,IAAA;AAAA,EACF;AAGA,EAAA,KAAA,MAAW,GAAA,IAAO,MAAA,CAAO,IAAA,CAAK,MAAM,CAAA,EAAG;AAGrC,IAAA,OAAA,CAAQ,GAAA,EAAK,OAAO,IAAI,CAAA;AAExB,IAAA,IAAI,IAAA;AACJ,IAAA,IAAI;AACF,MAAA,IAAA,GAAQ,OAAmC,GAAG,CAAA;AAAA,IAChD,CAAA,CAAA,MAAQ;AAEN,MAAA;AAAA,IACF;AACA,IAAA,OAAA,CAAQ,IAAA,EAAM,OAAO,IAAI,CAAA;AAAA,EAC3B;AACF;;;;"}

package/dist/domains/traces/utils/flatten-to-search-text.d.ts

@@ -0,0 +1,2 @@
+export * from '../../../src/domains/traces/utils/flatten-to-search-text'
+export {}

package/dist/domains/traces/utils/flatten-to-search-text.es.js

@@ -0,0 +1,74 @@
+function flattenToSearchText(value) {
+  const parts = [];
+  const path = /* @__PURE__ */ new Set();
+  collect(value, parts, path);
+  return parts.join(" ");
+}
+function collect(value, parts, path) {
+  if (value === null || value === void 0) return;
+  switch (typeof value) {
+    case "string": {
+      const trimmed = value.trim();
+      if (trimmed) parts.push(trimmed);
+      return;
+    }
+    case "number": {
+      if (Number.isFinite(value)) parts.push(String(value));
+      return;
+    }
+    case "boolean":
+    case "bigint":
+      parts.push(String(value));
+      return;
+    case "function":
+    case "symbol":
+      return;
+  }
+  const object = value;
+  if (path.has(object)) return;
+  path.add(object);
+  try {
+    collectFromObject(object, parts, path);
+  } finally {
+    path.delete(object);
+  }
+}
+function collectFromObject(object, parts, path) {
+  if (object instanceof Date) {
+    const time = object.getTime();
+    if (!Number.isNaN(time)) parts.push(object.toISOString());
+    return;
+  }
+  if (object instanceof Error) {
+    collect(object.message, parts, path);
+    return;
+  }
+  if (Array.isArray(object)) {
+    for (const item of object) collect(item, parts, path);
+    return;
+  }
+  if (object instanceof Map) {
+    for (const [key, item] of object) {
+      collect(key, parts, path);
+      collect(item, parts, path);
+    }
+    return;
+  }
+  if (object instanceof Set) {
+    for (const item of object) collect(item, parts, path);
+    return;
+  }
+  for (const key of Object.keys(object)) {
+    collect(key, parts, path);
+    let item;
+    try {
+      item = object[key];
+    } catch {
+      continue;
+    }
+    collect(item, parts, path);
+  }
+}
+
+export { flattenToSearchText };
+//# sourceMappingURL=flatten-to-search-text.es.js.map