@mastra/duckdb 1.13.0-alpha.0 → 1.13.0-alpha.2

package/dist/{observability-TpgAucZM.js → observability-DINJlR_a.js}

@@ -1,4 +1,4 @@
-import { t as DuckDBConnection } from "./db-BWgrbB_u.js";
+import { n as DuckDBConnection, r as DuckDBQueryTimeoutError, t as spanQueryFeatures } from "./features-D3sUOsCL.js";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
 import * as coreStorage from "@mastra/core/storage";
 import { BRANCH_SPAN_TYPES, METRIC_DISTINCT_COLUMNS, ObservabilityStorage, buildInputPreview, computeTraceStatus, createStorageErrorId, executeRetentionPrune, feedbackRecordSchema, listBranchesArgsSchema, listFeedbackArgsSchema, listLogsArgsSchema, listMetricsArgsSchema, listScoresArgsSchema, listTracesArgsSchema, resolveRetentionTargets, retentionCutoffMs, toTraceSpans } from "@mastra/core/storage";
@@ -688,6 +688,33 @@ function jsonV(val) {
 	return DuckDBConnection.sqlValue(JSON.stringify(val));
 }
 /**
+* `span_events` JSON columns that can hold large payloads. Missing values are
+* stored as the JSON literal `null` instead of SQL NULL.
+*
+* DuckDB only reads the selected rows of a large-string column when the
+* column's validity mask is constant (no NULLs in the row group). Any SQL NULL
+* makes it fall back to reading the whole 2,048-row vector, which loads every
+* large string in it even when the query needs one row. Keeping these columns
+* NULL-free lets point lookups and page reads load only what they return.
+*/
+const SPAN_PAYLOAD_COLUMNS = [
+	"attributes",
+	"input",
+	"output",
+	"requestContext"
+];
+/** Stored in {@link SPAN_PAYLOAD_COLUMNS} in place of SQL NULL; read back as missing. */
+const JSON_NULL_PLACEHOLDER = "null";
+/** Like {@link jsonV}, but writes the JSON `null` placeholder instead of SQL NULL. */
+function payloadJsonV(val) {
+	if (val === null || val === void 0) return `'${JSON_NULL_PLACEHOLDER}'`;
+	return jsonV(val);
+}
+/** SQL for a payload column that maps the JSON `null` placeholder back to SQL NULL. */
+function payloadColumnSql(column) {
+	return `NULLIF(${column}, '${JSON_NULL_PLACEHOLDER}')`;
+}
+/**
 * Trim, drop blank, and dedupe tags before they are written, matching the
 * PostgreSQL and ClickHouse stores so tag predicates and discovery agree.
 */
@@ -2935,7 +2962,7 @@ const TRACE_SELECT = `
   r.entityId AS entityId,
   r.parentSpanId AS parentSpanId,
   r.metadata AS metadata,
-  r.input AS input,
+  ${payloadColumnSql("r.input")} AS input,
   r.threadId AS threadId,
   r.resourceId AS resourceId,
   r.startedAt AS startedAt,
@@ -3218,6 +3245,11 @@ function compileDuckDBTraceScope(relatedCollections, scope, timeRange, rootPredi
       GROUP BY r.traceId
       HAVING bool_or(r.timestamp >= CAST(? AS TIMESTAMP) AND r.timestamp < CAST(? AS TIMESTAMP))
         AND bool_or(${rowConditions.join("\n          AND ")})
+    )`,
+		`root_bounds AS (
+      SELECT min(timestamp) AS minTs, max(timestamp) AS maxTs
+      FROM span_events
+      WHERE parentSpanId IS NULL AND traceId IN (SELECT traceId FROM root_trace_ids)
     )`,
 		`root_events AS (
       SELECT
@@ -3228,6 +3260,8 @@ function compileDuckDBTraceScope(relatedCollections, scope, timeRange, rootPredi
         END AS startedAt
       FROM span_events
       WHERE parentSpanId IS NULL
+        AND timestamp >= (SELECT minTs FROM root_bounds)
+        AND timestamp <= (SELECT maxTs FROM root_bounds)
         AND traceId IN (SELECT traceId FROM root_trace_ids)
     )`,
 		`current_roots AS (
@@ -3250,7 +3284,15 @@ function compileDuckDBTraceScope(relatedCollections, scope, timeRange, rootPredi
     )`
 	];
 	if (relatedCollections.has("spans")) {
-		ctes.push(`current_span_rows AS (
+		ctes.push(`span_bounds AS (
+      -- Exact event-time range of the in-scope traces, from a narrow
+      -- (traceId, timestamp) pass. The join below cannot be pushed into the
+      -- scan, so the range keeps it from decompressing every span row.
+      SELECT min(timestamp) AS minTs, max(timestamp) AS maxTs
+      FROM span_events
+      WHERE traceId IN (SELECT traceId FROM root_scope)
+    ),
+    current_span_rows AS (
       SELECT
         e.*,
         coalesce(
@@ -3262,7 +3304,9 @@ function compileDuckDBTraceScope(relatedCollections, scope, timeRange, rootPredi
           ORDER BY CASE WHEN e.endedAt IS NULL THEN 1 ELSE 0 END ASC, e.cursorId DESC
         ) AS currentRank
       FROM span_events e
-      INNER JOIN root_scope roots ON roots.traceId = e.traceId${tenantWhere("e")}
+      INNER JOIN root_scope roots ON roots.traceId = e.traceId
+      WHERE e.timestamp >= (SELECT minTs FROM span_bounds)
+        AND e.timestamp <= (SELECT maxTs FROM span_bounds)${tenantConditions("e").map((condition) => `\n        AND ${condition}`).join("")}
     ),
     current_spans AS (
       SELECT
@@ -3666,6 +3710,164 @@ async function queryThreads(db, plan) {
 		}) : null }
 	});
 }
+/** Compile a span-row filter with exactly the same rules as trace span predicates. */
+function compileSpanQueryPredicate(predicate) {
+	return compileScalarPredicate(predicate, SPAN_FIELDS);
+}
+//#endregion
+//#region src/storage/domains/observability/span-query.ts
+const identityFields = [
+	"organizationId",
+	"resourceId",
+	"traceId",
+	"spanId"
+];
+const identities = identityFields.join(", ");
+const fields = [
+	...identityFields,
+	"parentSpanId",
+	"name",
+	"spanType",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"parentEntityVersionId",
+	"rootEntityVersionId",
+	"runId",
+	"sessionId",
+	"userId"
+];
+function keys(rows, values, alias = "") {
+	return rows.map((row) => `(${identityFields.map((field) => {
+		values.push(row[field]);
+		return `${alias}${field} IS NOT DISTINCT FROM ?`;
+	}).join(" AND ")})`).join(" OR ");
+}
+function afterCursor(plan) {
+	if (!plan.cursor) return {
+		sql: "TRUE",
+		values: []
+	};
+	const cursor = plan.cursor;
+	const comparisons = [`s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? ">" : "<"} CAST(? AS TIMESTAMP)`];
+	const values = [cursor.sortValue];
+	for (let i = 0; i < identityFields.length; i++) {
+		const field = identityFields[i];
+		if (cursor[field] === null) continue;
+		const equal = [`s.${plan.orderBy.field} = CAST(? AS TIMESTAMP)`];
+		values.push(cursor.sortValue);
+		for (const prior of identityFields.slice(0, i)) {
+			equal.push(`s.${prior} IS NOT DISTINCT FROM ?`);
+			values.push(cursor[prior]);
+		}
+		values.push(cursor[field]);
+		comparisons.push(`(${equal.join(" AND ")} AND (s.${field} > ? OR s.${field} IS NULL))`);
+	}
+	return {
+		sql: `(${comparisons.join(" OR ")})`,
+		values
+	};
+}
+function compileDuckDBSpanQuery(plan) {
+	const values = [plan.timeRange.from, plan.timeRange.to];
+	const scope = [];
+	if (plan.scope) {
+		scope.push("organizationId = ?");
+		values.push(plan.scope.organizationId);
+		if (plan.scope.resourceId !== void 0) {
+			scope.push("resourceId = ?");
+			values.push(plan.scope.resourceId);
+		}
+	}
+	const predicate = plan.where ? compileSpanQueryPredicate(plan.where) : {
+		sql: "TRUE",
+		values: []
+	};
+	const after = afterCursor(plan);
+	values.push(plan.timeRange.from, plan.timeRange.to, ...predicate.values, ...after.values, plan.limit + 1);
+	const join = identityFields.map((field) => `e.${field} IS NOT DISTINCT FROM c.${field}`).join(" AND ");
+	return {
+		sql: `WITH candidates AS MATERIALIZED (
+    SELECT ${identities} FROM span_events
+    WHERE eventType = 'start' AND timestamp >= CAST(? AS TIMESTAMP) AND timestamp < CAST(? AS TIMESTAMP)
+      ${scope.length ? `AND ${scope.join(" AND ")}` : ""}
+    GROUP BY ${identities}
+  ), ranked AS (
+    SELECT ${fields.map((field) => `e.${field}`).join(", ")},
+      min(e.timestamp) FILTER (WHERE e.eventType = 'start') OVER (PARTITION BY ${identityFields.map((field) => `e.${field}`).join(", ")}) AS startedAt, e.endedAt, e.cursorId,
+      CASE WHEN json_type(e.attributes, '$.model') = 'VARCHAR' THEN json_extract_string(e.attributes, '$.model') END AS model,
+      CASE WHEN json_type(e.attributes, '$.provider') = 'VARCHAR' THEN json_extract_string(e.attributes, '$.provider') END AS provider,
+      date_diff('millisecond', min(e.timestamp) FILTER (WHERE e.eventType = 'start') OVER (PARTITION BY ${identityFields.map((field) => `e.${field}`).join(", ")}), e.endedAt) AS durationMs,
+      CASE WHEN e.error IS NULL THEN 'success' ELSE 'error' END AS status,
+      CASE WHEN e.error IS NULL THEN NULL ELSE 'error' END AS error,
+      row_number() OVER (PARTITION BY ${identityFields.map((field) => `e.${field}`).join(", ")}
+        ORDER BY CASE WHEN e.endedAt IS NULL THEN 1 ELSE 0 END, e.cursorId DESC NULLS LAST, e.endedAt DESC) AS rank
+    FROM span_events e INNER JOIN candidates c ON ${join}
+  )
+  SELECT ${[
+			...identityFields,
+			"parentSpanId",
+			"name",
+			"spanType",
+			"entityType",
+			"entityId",
+			"entityName",
+			"model",
+			"provider",
+			"startedAt",
+			"endedAt",
+			"durationMs",
+			"status",
+			"cursorId"
+		].map((field) => `s.${field}`).join(", ")}
+  FROM ranked s WHERE rank = 1 AND endedAt IS NOT NULL AND startedAt >= CAST(? AS TIMESTAMP) AND startedAt < CAST(? AS TIMESTAMP) AND (${predicate.sql}) AND ${after.sql}
+  ORDER BY s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? "ASC" : "DESC"}, ${identityFields.map((field) => `s.${field} ASC NULLS LAST`).join(", ")}
+  LIMIT ?`,
+		values
+	};
+}
+async function querySpans(db, plan) {
+	const deadline = performance.now() + coreStorage.TRACE_QUERY_DEFAULT_TIMEOUT_MS;
+	const query = async (sql, values) => {
+		const remaining = Math.floor(deadline - performance.now());
+		if (remaining <= 0) throw new coreStorage.TraceQueryExecutionError();
+		try {
+			return await db.query(sql, values, remaining);
+		} catch (error) {
+			if (error instanceof DuckDBQueryTimeoutError) throw new coreStorage.TraceQueryExecutionError();
+			if (error instanceof Error && /out of memory/i.test(error.message)) throw new coreStorage.TraceQueryResourceLimitError();
+			throw error;
+		}
+	};
+	const compiled = compileDuckDBSpanQuery(plan);
+	const rows = await query(compiled.sql, compiled.values);
+	const selected = rows.map(({ cursorId: _cursorId, startedAt, endedAt, ...row }) => ({
+		...row,
+		startedAt: startedAt.toISOString(),
+		endedAt: endedAt.toISOString()
+	}));
+	const page = rows.slice(0, plan.limit);
+	if (!page.length) return coreStorage.buildSpanQueryResponse(plan, selected, [], []);
+	const payloadValues = [];
+	const payloadWhere = page.map((row) => {
+		const key = keys([row], payloadValues);
+		payloadValues.push(row.cursorId, row.endedAt);
+		return `(${key} AND cursorId IS NOT DISTINCT FROM ? AND endedAt = ?)`;
+	}).join(" OR ");
+	const payloads = await query(`SELECT DISTINCT ${identities},
+    substring(CAST(${payloadColumnSql("input")} AS VARCHAR), 1, ${coreStorage.SPAN_QUERY_MAX_PREVIEW_CHARACTERS + 1}) AS inputPreview, substring(CAST(${payloadColumnSql("output")} AS VARCHAR), 1, ${coreStorage.SPAN_QUERY_MAX_PREVIEW_CHARACTERS + 1}) AS outputPreview
+    FROM span_events WHERE ${payloadWhere}`, payloadValues);
+	const metricValues = [];
+	const metricWhere = keys(page, metricValues);
+	const metrics = await query(`SELECT ${identities}, name, estimatedCost, costUnit,
+    json_extract_string(costMetadata, '$.allocation') AS allocation,
+    COALESCE(json_exists(costMetadata, '$.error'), false) AS costError
+    FROM metric_events WHERE (${metricWhere}) AND name LIKE 'mastra_model_%'
+    LIMIT ${coreStorage.SPAN_QUERY_MAX_COST_METRICS + 1}`, metricValues);
+	if (metrics.length > coreStorage.SPAN_QUERY_MAX_COST_METRICS) throw new coreStorage.TraceQueryResourceLimitError();
+	return coreStorage.buildSpanQueryResponse(plan, selected, payloads, metrics);
+}
 //#endregion
 //#region src/storage/domains/observability/trace-aggregate.ts
 /** Trace-root column expressions (alias `r`) for each groupable dimension; same values `where` sees. */
@@ -3909,13 +4111,15 @@ const COLUMNS_SQL = [
 	"error",
 	"requestContext"
 ].join(", ");
+const PAYLOAD_COLUMN_SET = new Set(SPAN_PAYLOAD_COLUMNS);
 /**
 * Reconstruction query uses `arg_max(field, timestamp) FILTER (WHERE field IS NOT NULL)`
 * so that the final end event supplies the terminal span fields without wiping
-* stable values emitted on the start event.
+* stable values emitted on the start event. Payload columns also skip the JSON
+* `null` placeholder, which stands in for a missing value.
 */
 function argMaxNonNull(col) {
-	return `arg_max(${col}, timestamp) FILTER (WHERE ${col} IS NOT NULL) as ${col}`;
+	return `arg_max(${col}, timestamp) FILTER (WHERE ${col} IS NOT NULL${PAYLOAD_COLUMN_SET.has(col) ? ` AND ${col} <> '${JSON_NULL_PLACEHOLDER}'` : ""}) as ${col}`;
 }
 const SPAN_RECONSTRUCT_SELECT = `
   SELECT
@@ -4026,28 +4230,55 @@ function buildPostAggReconstructSelect(postAgg, orderByField) {
 `;
 }
 /**
-* Reconstruct spans for the `(traceId, spanId)` pairs selected by `anchorCte`,
-* scanning only events at/after the CTE's earliest `anchorStartedAt`.
+* Reconstruct the spans of one list page, reading payload columns only for
+* the page's own events.
 *
-* The `(traceId, spanId) IN (subquery)` semi-join alone cannot be pushed into
-* the table scan, so without a bound DuckDB decompresses every column of the
-* entire table just to emit one page of spans. The time bound is a plain range
-* predicate that zone maps can prune on (insertion order tracks event time).
+* Two queries:
+*   1. `anchorSql` (a `WITH ...` prefix defining `anchorCte`) picks the page's
+*      `(traceId, spanId)` anchors, and a narrow pass over `traceId`, `spanId`
+*      and `timestamp` finds the exact time range of their events.
+*   2. Reconstruction scans only that range for exactly those anchors.
 *
-* Correctness: span events are only 'start' (timestamp = startedAt) and 'end'
-* (timestamp = endedAt >= startedAt), so every event of an anchored span has
-* timestamp >= its start-row timestamp >= min(anchorStartedAt). An empty
-* anchor set makes the bound NULL, which matches the empty IN-list result.
+* The `(traceId, spanId) IN (...)` semi-join cannot be pushed into the table
+* scan, so without a range DuckDB decompresses every payload column of every
+* row it reads. A lower bound alone (the earliest anchor) prunes nothing for
+* the oldest pages, which then read the whole table and can run out of memory.
+* Both bounds are passed as literal parameters so they always reach the scan
+* as plain range filters that zone maps can prune on.
+*
+* Anchors and bounds are frozen after the first query, so spans written in
+* between cannot change which rows are on the page. An event a page span
+* receives in between is left for the next read, as if the page had been
+* read a moment earlier.
 */
-function reconstructForAnchors(reconstructSelect, anchorCte) {
-	return `
-    ${reconstructSelect}
-    WHERE timestamp >= (SELECT min(anchorStartedAt) FROM ${anchorCte})
-      AND (traceId, spanId) IN (SELECT traceId, spanId FROM ${anchorCte})
-    GROUP BY traceId, spanId`;
+async function reconstructAnchoredPage(db, anchorSql, anchorCte, params, reconstructSelect, orderBySql) {
+	const anchors = await db.query(`
+      ${anchorSql}
+      SELECT anchors.traceId, anchors.spanId, bounds.minTs, bounds.maxTs
+      FROM ${anchorCte} AS anchors,
+        (
+          SELECT min(timestamp) AS minTs, max(timestamp) AS maxTs
+          FROM span_events
+          WHERE (traceId, spanId) IN (SELECT traceId, spanId FROM ${anchorCte})
+        ) AS bounds
+    `, params);
+	if (anchors.length === 0) return [];
+	const { minTs, maxTs } = anchors[0];
+	const anchorValues = anchors.map(() => "(?, ?)").join(", ");
+	return db.query(`
+      ${reconstructSelect}
+      WHERE timestamp >= ? AND timestamp <= ?
+        AND (traceId, spanId) IN (SELECT * FROM (VALUES ${anchorValues}))
+      GROUP BY traceId, spanId
+      ${orderBySql}
+    `, [
+		minTs,
+		maxTs,
+		...anchors.flatMap((anchor) => [anchor.traceId, anchor.spanId])
+	]);
 }
 /**
-* Same time-bound trick as {@link reconstructForAnchors}, but with the bound
+* Same time-bound trick as {@link reconstructAnchoredPage}, but with the bound
 * precomputed in JS and passed as a `?` parameter. The delta-poll query shape
 * references its candidate CTE multiple times, which makes DuckDB materialize
 * it and lose the dynamic-filter pushdown a scalar subquery bound relies on —
@@ -4281,15 +4512,15 @@ function toValuesTuple(row) {
 		v(row.environment),
 		v(row.source),
 		v(row.serviceName),
-		jsonV(row.attributes),
+		payloadJsonV(row.attributes),
 		jsonV(row.metadata),
 		jsonV(row.tags),
 		jsonV(row.scope),
 		jsonV(row.links),
-		jsonV(row.input),
-		jsonV(row.output),
+		payloadJsonV(row.input),
+		payloadJsonV(row.output),
 		jsonV(row.error),
-		jsonV(row.requestContext)
+		payloadJsonV(row.requestContext)
 	].join(", ");
 }
 async function insertSpanEvents(db, rows) {
@@ -4503,7 +4734,7 @@ async function listTraceRows(db, args, reconstructSelect, mapRow, toSpans) {
 			},
 			spans: []
 		};
-		const pageSql = `
+		const spans = (await reconstructAnchoredPage(db, `
       WITH page_roots AS (
         SELECT traceId, spanId, min(timestamp) AS anchorStartedAt
         FROM span_events AS ${outerAlias}
@@ -4512,14 +4743,11 @@ async function listTraceRows(db, args, reconstructSelect, mapRow, toSpans) {
         ${prefilterOrderBy}
         LIMIT ? OFFSET ?
       )
-      ${reconstructForAnchors(reconstructSelect, "page_roots")}
-      ${buildOrderByClause(orderBy)}, traceId, spanId
-    `;
-		const spans = (await db.query(pageSql, [
+    `, "page_roots", [
 			...prefilterParams,
 			perPage,
 			offset
-		])).map((row) => mapRow(row));
+		], reconstructSelect, `${buildOrderByClause(orderBy)}, traceId, spanId`)).map((row) => mapRow(row));
 		return {
 			pagination: {
 				total,
@@ -4568,20 +4796,17 @@ async function listTraceRows(db, args, reconstructSelect, mapRow, toSpans) {
 		},
 		spans: []
 	};
-	const dataSql = `
+	const spans = (await reconstructAnchoredPage(db, `
     ${cteSql},
     page_roots AS (
       SELECT traceId, spanId, startedAt AS anchorStartedAt
       FROM root_spans ${postAggWhere} ${orderByClause} ${paginationClause}
     )
-    ${reconstructForAnchors(reconstructSelect, "page_roots")}
-    ${orderByClause}
-  `;
-	const spans = (await db.query(dataSql, [
+  `, "page_roots", [
 		...prefilterParams,
 		...postAggParams,
 		...paginationParams
-	])).map((row) => mapRow(row));
+	], reconstructSelect, orderByClause)).map((row) => mapRow(row));
 	return {
 		pagination: {
 			total,
@@ -4885,7 +5110,7 @@ async function listBranches(db, args) {
 			branches: [],
 			...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
 		};
-		const pageSql = `
+		const spans = (await reconstructAnchoredPage(db, `
       WITH page_anchors AS (
         SELECT traceId, spanId, min(timestamp) AS anchorStartedAt
         FROM span_events AS ${outerAlias}
@@ -4894,14 +5119,11 @@ async function listBranches(db, args) {
         ${prefilterOrderBy}
         LIMIT ? OFFSET ?
       )
-      ${reconstructForAnchors(SPAN_RECONSTRUCT_SELECT, "page_anchors")}
-      ${buildOrderByClause(orderBy)}, traceId, spanId
-    `;
-		const spans = (await db.query(pageSql, [
+    `, "page_anchors", [
 			...prefilterParams,
 			perPage,
 			offset
-		])).map((row) => rowToSpanRecord(row));
+		], SPAN_RECONSTRUCT_SELECT, `${buildOrderByClause(orderBy)}, traceId, spanId`)).map((row) => rowToSpanRecord(row));
 		return {
 			pagination: {
 				total,
@@ -4948,20 +5170,17 @@ async function listBranches(db, args) {
 		branches: [],
 		...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
 	};
-	const dataSql = `
+	const spans = (await reconstructAnchoredPage(db, `
     ${cteSql},
     page_anchors AS (
       SELECT traceId, spanId, startedAt AS anchorStartedAt
       FROM branch_anchors ${postAggWhere} ${orderByClause} ${paginationClause}
     )
-    ${reconstructForAnchors(SPAN_RECONSTRUCT_SELECT, "page_anchors")}
-    ${orderByClause}
-  `;
-	const spans = (await db.query(dataSql, [
+  `, "page_anchors", [
 		...prefilterParams,
 		...postAggParams,
 		...paginationParams
-	])).map((row) => rowToSpanRecord(row));
+	], SPAN_RECONSTRUCT_SELECT, orderByClause)).map((row) => rowToSpanRecord(row));
 	return {
 		pagination: {
 			total,
@@ -5198,6 +5417,7 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 			"metric-discovery",
 			"trace-query",
 			"trace-aggregate",
+			...spanQueryFeatures,
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
@@ -5217,6 +5437,7 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 			"delta-polling",
 			"trace-query",
 			"trace-aggregate",
+			...spanQueryFeatures,
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
@@ -5252,6 +5473,9 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 	async listTraces(args) {
 		return listTraces(this.db, args);
 	}
+	async querySpans(plan) {
+		return querySpans(this.db, plan);
+	}
 	async queryTraces(plan) {
 		return queryTraces(this.db, plan);
 	}
@@ -5380,4 +5604,4 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 //#endregion
 export { ObservabilityStorageDuckDB };
 
-//# sourceMappingURL=observability-TpgAucZM.js.map
+//# sourceMappingURL=observability-DINJlR_a.js.map