@mastra/clickhouse 1.25.1-alpha.0 → 1.25.1-alpha.2

package/dist/index.cjs

@@ -2756,7 +2756,14 @@ CREATE TABLE IF NOT EXISTS ${TABLE_SPAN_EVENTS} (
   output             Nullable(String),
   error              Nullable(String),
   metadataRaw        Nullable(String),
-  requestContext     Nullable(String)
+  requestContext     Nullable(String),
+
+  -- Previews of \`input\` / \`output\` / \`error\` in core's \`buildPreview\` format, written
+  -- on every span ('' when there is nothing to preview). NULL on rows written before
+  -- the columns existed; readers build those from the payload columns.
+  inputPreview       Nullable(String),
+  outputPreview      Nullable(String),
+  errorPreview       Nullable(String)
 )
 ENGINE = ReplacingMergeTree
 PARTITION BY toDate(endedAt)
@@ -2824,6 +2831,12 @@ CREATE TABLE IF NOT EXISTS ${TABLE_TRACE_ROOTS} (
   metadataRaw        Nullable(String),
   requestContext     Nullable(String),
 
+  -- Previews of \`input\` / \`output\` / \`error\` ('' when there is nothing to preview).
+  -- NULL on rows written before the columns existed.
+  inputPreview       Nullable(String),
+  outputPreview      Nullable(String),
+  errorPreview       Nullable(String),
+
   -- traceId is second in the sort key, behind startedAt, so point lookups by
   -- traceId (getRootSpan, trace deletes, trace-query root dedupe) need a skip
   -- index to avoid scanning every granule.
@@ -2902,6 +2915,9 @@ CREATE TABLE IF NOT EXISTS ${TABLE_TRACE_BRANCHES} (
   error              Nullable(String),
   metadataRaw        Nullable(String),
   requestContext     Nullable(String),
+  inputPreview       Nullable(String),
+  outputPreview      Nullable(String),
+  errorPreview       Nullable(String),
 
   INDEX idx_traceId traceId TYPE bloom_filter(0.01) GRANULARITY 1
 )
@@ -3633,7 +3649,26 @@ const addBloomIndex = (table, name, column, granularity = 2) => ({
 	name,
 	sql: `ALTER TABLE ${table} ADD INDEX IF NOT EXISTS ${name} ${column} TYPE bloom_filter(0.01) GRANULARITY ${granularity}`
 });
+const LOG_SKIP_INDEX_COLUMNS = [
+	"traceId",
+	"threadId",
+	"resourceId",
+	"userId",
+	"organizationId",
+	"experimentId",
+	"runId",
+	"sessionId",
+	"requestId"
+];
 const ALL_MIGRATIONS = [
+	...[
+		"inputPreview",
+		"outputPreview",
+		"errorPreview"
+	].flatMap((column) => [addColumn(TABLE_TRACE_ROOTS, column, "Nullable(String)"), addColumn(TABLE_TRACE_BRANCHES, column, "Nullable(String)")]),
+	addColumn(TABLE_SPAN_EVENTS, "inputPreview", "Nullable(String)"),
+	addColumn(TABLE_SPAN_EVENTS, "outputPreview", "Nullable(String)"),
+	addColumn(TABLE_SPAN_EVENTS, "errorPreview", "Nullable(String)"),
 	addColumn(TABLE_SPAN_EVENTS, "entityVersionId", "Nullable(String)"),
 	addColumn(TABLE_SPAN_EVENTS, "parentEntityVersionId", "Nullable(String)"),
 	addColumn(TABLE_SPAN_EVENTS, "rootEntityVersionId", "Nullable(String)"),
@@ -3670,17 +3705,7 @@ const ALL_MIGRATIONS = [
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_runId", "runId"),
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_sessionId", "sessionId"),
 	addBloomIndex(TABLE_METRIC_EVENTS, "idx_requestId", "requestId"),
-	...[
-		"traceId",
-		"threadId",
-		"resourceId",
-		"userId",
-		"organizationId",
-		"experimentId",
-		"runId",
-		"sessionId",
-		"requestId"
-	].map((column) => addBloomIndex(TABLE_LOG_EVENTS, `idx_${column}`, column)),
+	...LOG_SKIP_INDEX_COLUMNS.map((column) => addBloomIndex(TABLE_LOG_EVENTS, `idx_${column}`, column)),
 	addBloomIndex(TABLE_DELETION_REQUESTS, "idx_predicateValues", "predicateValues")
 ];
 const ALL_TABLE_NAMES = [
@@ -3790,6 +3815,78 @@ function parseTtlExpression(expr) {
 	};
 }
 //#endregion
+//#region src/storage/domains/observability/v-next/preview-compat.ts
+const generator = _mastra_core_storage.buildStoredPreview;
+const canGeneratePreviews = typeof generator === "function";
+function needsPreview(value) {
+	return canGeneratePreviews && value == null;
+}
+function storedPreview(preview, value, serialized) {
+	return canGeneratePreviews ? generator(preview, value, serialized) : preview ?? null;
+}
+function readPreview(preview, payload, jsonEncoded = false) {
+	const supplied = preview;
+	if (!canGeneratePreviews) return supplied ?? null;
+	if (supplied != null) return supplied.trim() || null;
+	let value = payload;
+	if (needsPreview(preview) && jsonEncoded && typeof payload === "string") try {
+		value = JSON.parse(payload);
+	} catch {
+		value = null;
+	}
+	return storedPreview(supplied, value, jsonEncoded && typeof payload === "string" ? payload : void 0) || null;
+}
+/** Older response builders may shorten previews or turn empty strings into null. */
+function buildSpanQueryResponse(...args) {
+	if (canGeneratePreviews) return _mastra_core_storage.buildSpanQueryResponse(...args);
+	const [plan, selected, payloads, metrics] = args;
+	const response = _mastra_core_storage.buildSpanQueryResponse(plan, selected, [], metrics);
+	const byIdentity = new Map(payloads.map((payload) => [_mastra_core_storage.spanQueryIdentityKey(payload), payload]));
+	for (const span of response.spans) {
+		const payload = byIdentity.get(_mastra_core_storage.spanQueryIdentityKey(span));
+		span.inputPreview = payload?.inputPreview ?? null;
+		span.outputPreview = payload?.outputPreview ?? null;
+		span.errorPreview = payload?.errorPreview ?? null;
+	}
+	return response;
+}
+//#endregion
+//#region src/storage/domains/observability/v-next/previews.ts
+/**
+* Stored span previews (`inputPreview` / `outputPreview` / `errorPreview`).
+*
+* The writer stores each preview in core's `buildPreview` format, `''` when there is nothing to
+* preview. A NULL preview means the row was written before the columns existed; readers fetch the
+* payload columns for just those rows and build the same preview from them.
+*/
+const PREVIEW_COLUMNS = [
+	"inputPreview",
+	"outputPreview",
+	"errorPreview"
+];
+/** Payload column each preview is built from. */
+const PREVIEW_PAYLOAD_COLUMNS = {
+	inputPreview: "input",
+	outputPreview: "output",
+	errorPreview: "error"
+};
+/** Whether a row was written before previews were stored, so it needs its payload columns. */
+function needsPreviewPayloads(row) {
+	return PREVIEW_COLUMNS.some((column) => needsPreview(row[column]));
+}
+/**
+* The previews a list returns for a row: the stored ones (`''` becomes `null`), or for a row written
+* before they were stored, built from the payload columns on `payloads` (default: the row itself).
+*/
+function resolveStoredPreviews(row, payloads = row) {
+	const previews = {};
+	for (const column of PREVIEW_COLUMNS) {
+		const stored = row[column];
+		previews[column] = readPreview(stored, payloads?.[PREVIEW_PAYLOAD_COLUMNS[column]], true);
+	}
+	return previews;
+}
+//#endregion
 //#region src/storage/domains/observability/v-next/review-status.ts
 const FEEDBACK_REVIEW_STATUSES = ["needs-review", "reviewed"];
 function isFeedbackReviewStatus(value) {
@@ -3996,7 +4093,7 @@ function rowToLightSpanRecord(row) {
 			endedAt
 		}),
 		metadata: parseJson(row.metadataRaw) ?? void 0,
-		inputPreview: (0, _mastra_core_storage.buildInputPreview)(row.input ?? null),
+		...resolveStoredPreviews(row),
 		createdAt: startedAt,
 		updatedAt: null
 	};
@@ -4004,6 +4101,9 @@ function rowToLightSpanRecord(row) {
 function spanRecordToRow(span) {
 	const endedAt = span.isEvent ? span.startedAt : span.endedAt ?? span.startedAt;
 	const metadata = span.metadata ?? null;
+	const input = jsonEncode(span.input);
+	const output = jsonEncode(span.output);
+	const error = jsonEncode(span.error);
 	return {
 		dedupeKey: buildDedupeKey(span.traceId, span.spanId),
 		traceId: span.traceId,
@@ -4043,10 +4143,13 @@ function spanRecordToRow(span) {
 		scope: jsonEncode(span.scope),
 		attributes: jsonEncode(span.attributes),
 		links: jsonEncode(span.links),
-		input: jsonEncode(span.input),
-		output: jsonEncode(span.output),
-		error: jsonEncode(span.error),
-		requestContext: jsonEncode(span.requestContext)
+		input,
+		output,
+		error,
+		requestContext: jsonEncode(span.requestContext),
+		inputPreview: storedPreview(span.inputPreview, span.input, input),
+		outputPreview: storedPreview(span.outputPreview, span.output, output),
+		errorPreview: storedPreview(span.errorPreview, span.error, error)
 	};
 }
 function rowToLogRecord(row) {
@@ -6961,11 +7064,15 @@ const FEEDBACK_FIELDS = {
 const TRACE_SELECT = `
   r.traceId AS traceId,
   r.spanId AS rootSpanId,
+  r.dedupeKey AS dedupeKey,
+  r.organizationId AS organizationId,
   r.name AS name,
   r.entityId AS entityId,
   r.parentSpanId AS parentSpanId,
   r.metadataRaw AS metadata,
-  r.input AS input,
+  r.inputPreview AS inputPreview,
+  r.outputPreview AS outputPreview,
+  r.errorPreview AS errorPreview,
   r.threadId AS threadId,
   r.resourceId AS resourceId,
   r.startedAt AS startedAt,
@@ -6974,22 +7081,6 @@ const TRACE_SELECT = `
   r.entityType AS entityType,
   r.environment AS environment,
   ${TRACE_STATUS_SQL} AS status`;
-/** Candidate columns carried through the page-mode window sort (no payload blobs). */
-const TRACE_PAGE_COLUMNS = [
-	"traceId",
-	"rootSpanId",
-	"name",
-	"entityId",
-	"parentSpanId",
-	"threadId",
-	"resourceId",
-	"startedAt",
-	"endedAt",
-	"entityName",
-	"entityType",
-	"environment",
-	"status"
-];
 var ParameterBuilder = class {
 	params = {};
 	#next = 1;
@@ -7113,18 +7204,38 @@ function compileTenantScope(scope, parameters) {
 	if (scope.resourceId !== void 0) sql += `\n      AND resourceId = ${parameters.add(scope.resourceId, "String")}`;
 	return sql;
 }
-function compileClickHouseTraceScope(selection, relationCollections, parameters, scope, seedConjuncts = []) {
+function compileClickHouseTraceScope(selection, relationCollections, parameters, scope, seedConjuncts = [], options = {}) {
 	const from = parameters.add(selection.timeRange.from, "DateTime64(3, 'UTC')");
 	const to = parameters.add(selection.timeRange.to, "DateTime64(3, 'UTC')");
 	const tenant = compileTenantScope(scope, parameters);
-	const ctes = [`current_roots AS (
+	const seedFilter = seedConjuncts.map((conjunct) => `\n          AND (${compilePredicate(conjunct, parameters)})`).join("");
+	const bound = options.delta ? `\n          AND (traceId IN (SELECT traceId FROM delta_candidates))` : "";
+	const windowTraces = (more) => `
+        SELECT traceId
+        FROM ${TABLE_TRACE_ROOTS} w
+        WHERE startedAt >= ${from}
+          AND startedAt < ${to}${tenant}${more}
+      `;
+	const delta = options.delta ? [`delta_candidates AS (
+    SELECT traceId, max(cursorId) AS latestCursorId
+    FROM ${TABLE_TRACE_ROOTS_DELTA}
+    WHERE ${options.delta}
+      AND traceId IN (${windowTraces("")})
+    GROUP BY traceId
+  )`] : [];
+	const ctes = options.oneRootPerTrace ? [...delta, `root_scope AS (
+    SELECT *
+    FROM ${TABLE_TRACE_ROOTS} r
+    WHERE startedAt >= ${from}
+      AND startedAt < ${to}${tenant}${seedFilter}${bound}
+  )`] : [`current_roots AS (
     SELECT *
     FROM ${TABLE_TRACE_ROOTS}
     WHERE traceId IN (
       SELECT traceId
       FROM ${TABLE_TRACE_ROOTS} r
       WHERE startedAt >= ${from}
-        AND startedAt < ${to}${tenant}${seedConjuncts.map((conjunct) => `\n          AND (${compilePredicate(conjunct, parameters)})`).join("")}
+        AND startedAt < ${to}${tenant}${seedFilter}
     )${tenant}
     ORDER BY traceId, dedupeKey
     LIMIT 1 BY traceId
@@ -7158,9 +7269,9 @@ function compileClickHouseTraceScope(selection, relationCollections, parameters,
       organizationId
     FROM ${TABLE_SPAN_EVENTS}
     WHERE isNotNull(traceId)
-      AND traceId IN (SELECT traceId FROM root_scope)${tenant}
+      AND traceId IN (${options.spanExistence && options.oneRootPerTrace ? windowTraces(bound) : "SELECT traceId FROM root_scope"})${tenant}${options.spanExistence ? "" : `
     ORDER BY dedupeKey
-    LIMIT 1 BY dedupeKey
+    LIMIT 1 BY dedupeKey`}
   )`);
 	if (relationCollections.has("scores")) ctes.push(`current_scores AS (
     SELECT
@@ -7228,9 +7339,9 @@ function parseDeltaWatermark(value) {
 * selection's time range and tenant scope that match its `where` predicate. Trace queries and
 * trace aggregates both select from this CTE so they always see the same population.
 */
-function compileClickHouseTraceCandidates(selection, columns, parameters) {
+function compileClickHouseTraceCandidates(selection, columns, parameters, options = {}) {
 	const rootConjuncts = selection.where ? (selection.where.type === "boolean" && selection.where.operator === "and" ? selection.where.args : [selection.where]).filter((conjunct) => collectRelationCollections(conjunct).size === 0) : [];
-	const ctes = compileClickHouseTraceScope(selection, collectRelationCollections(selection.where), parameters, selection.scope, rootConjuncts);
+	const ctes = compileClickHouseTraceScope(selection, collectRelationCollections(selection.where), parameters, selection.scope, rootConjuncts, options);
 	const predicate = selection.where ? compilePredicate(selection.where, parameters) : "1";
 	ctes.push(`candidates AS (
     SELECT ${columns}
@@ -7239,94 +7350,191 @@ function compileClickHouseTraceCandidates(selection, columns, parameters) {
   )`);
 	return ctes;
 }
+/**
+* `queryTraces()` statements read one root per trace and only test spans for existence
+* (TraceScopeOptions). The list statements carry narrow columns; `metadata` and the previews are fetched
+* for the returned rows afterwards (compileClickHouseTraceRootPayloads).
+*/
+const QUERY_TRACES_SCOPE = {
+	oneRootPerTrace: true,
+	spanExistence: true
+};
+const TRACE_LIST_SELECT = TRACE_SELECT.split("\n").filter((line) => !/ AS (metadata|inputPreview|outputPreview|errorPreview),$/.test(line)).join("\n");
+function traceOrder(plan) {
+	return {
+		field: resolveOrderField(plan.orderBy.field),
+		direction: plan.orderBy.direction === "asc" ? "ASC" : "DESC"
+	};
+}
+/**
+* Keyset cursor on a trace's sort value. Applied after each trace is reduced to one sort value:
+* filtering root rows first would let a trace with several roots (or unmerged copies with
+* different `endedAt`) come back on a later page under a root that sorts after the cursor.
+*/
+function keysetCursorCondition(plan, order, parameters) {
+	if (plan.paginationMode !== "keyset" || !plan.cursor) return "";
+	const comparison = order.direction === "ASC" ? ">" : "<";
+	const sortValue = parameters.add(plan.cursor.sortValue, "DateTime64(3, 'UTC')");
+	return `(sortValue ${comparison} ${sortValue} OR (sortValue = ${sortValue} AND traceId > ${parameters.add(plan.cursor.traceId, "String")}))`;
+}
+/**
+* First statement of keyset and page mode: the page's traces (after the keyset cursor, `limit + 1`
+* for keyset mode, `perPage` at the page offset for page mode) as root keys, and the
+* number of matching traces on every row. Per trace, the root row that sorts first gives the sort
+* value and the key, so the key always names a row with that sort value. No blob columns are read.
+*/
+function compileClickHouseTraceQueryKeys(plan) {
+	if (plan.paginationMode === "delta") throw new Error("Delta trace queries have no keys statement");
+	const parameters = new ParameterBuilder();
+	const order = traceOrder(plan);
+	const ctes = compileClickHouseTraceCandidates(plan, "r.traceId AS traceId, r.dedupeKey AS dedupeKey, r.startedAt AS startedAt, r.endedAt AS endedAt", parameters, QUERY_TRACES_SCOPE);
+	const cursor = keysetCursorCondition(plan, order, parameters);
+	const pick = order.direction === "DESC" ? "max" : "min";
+	const limit = plan.paginationMode === "page" ? `LIMIT ${parameters.add(plan.perPage, "UInt64")} OFFSET ${parameters.add(plan.page * plan.perPage, "UInt64")}` : `LIMIT ${parameters.add(plan.limit + 1, "UInt64")}`;
+	return {
+		query: `WITH ${ctes.join(",\n")},
+per_trace AS (
+  SELECT traceId, ${pick}(${order.field}) AS sortValue,
+    ${pick === "max" ? "argMax" : "argMin"}((dedupeKey, startedAt), ${order.field}) AS root
+  FROM candidates
+  GROUP BY traceId${cursor ? `\n  HAVING ${cursor}` : ""}
+)
+SELECT traceId, root.1 AS dedupeKey, sortValue, root.2 AS rootStartedAt, count() OVER () AS __total
+FROM per_trace
+ORDER BY sortValue ${order.direction}, traceId ASC
+${limit}`,
+		query_params: parameters.params,
+		sharedSnapshot: true
+	};
+}
+/**
+* Second statement of keyset and page mode: the rows of the keyed roots, with `metadata`
+* and the stored previews, read by sort-key tuple. Unmerged copies of a root key are redeliveries of one
+* span; the relation-free `where` conjuncts are re-applied so a copy that doesn't match isn't
+* returned, and the copy that sorts first is kept, as in the keys statement.
+*/
+function compileClickHouseTraceRowsByKey(plan, keys) {
+	const parameters = new ParameterBuilder();
+	const order = traceOrder(plan);
+	const ts = (value) => parameters.add(value, "DateTime64(3, 'UTC')");
+	const byEnd = order.field === "endedAt";
+	const tuples = keys.map((key) => {
+		const started = ts(byEnd ? key.rootStartedAt : key.sortValue);
+		const id = `${parameters.add(key.traceId, "String")}, ${parameters.add(key.dedupeKey, "String")}`;
+		return byEnd ? `(${started}, ${id}, ${ts(key.sortValue)})` : `(${started}, ${id})`;
+	});
+	const predicate = (plan.where ? (plan.where.type === "boolean" && plan.where.operator === "and" ? plan.where.args : [plan.where]).filter((conjunct) => collectRelationCollections(conjunct).size === 0) : []).map((conjunct) => `\n  AND (${compilePredicate(conjunct, parameters)})`).join("");
+	return {
+		query: `SELECT ${TRACE_SELECT}
+FROM ${TABLE_TRACE_ROOTS} r
+WHERE (r.startedAt, r.traceId, r.dedupeKey${byEnd ? ", r.endedAt" : ""}) IN (${tuples.join(", ")})${compileTenantScope(plan.scope, parameters)}${predicate}
+ORDER BY ${order.field} ${order.direction}, traceId ASC
+LIMIT 1 BY traceId`,
+		query_params: parameters.params
+	};
+}
+/** Number of matching traces, for numbered pages past the last one (the keys statement returns no rows). */
+function compileClickHouseTraceQueryTotal(plan) {
+	const parameters = new ParameterBuilder();
+	return {
+		query: `WITH ${compileClickHouseTraceCandidates(plan, "r.traceId AS traceId", parameters, QUERY_TRACES_SCOPE).join(",\n")}
+SELECT uniqExact(traceId) AS traces
+FROM candidates`,
+		query_params: parameters.params,
+		sharedSnapshot: true
+	};
+}
+/**
+* The list statement of groups and delta mode (rows without `metadata` and the previews). Keyset
+* and page mode list with compileClickHouseTraceQueryKeys and compileClickHouseTraceRowsByKey.
+* A trace with several candidate rows (several roots, or unmerged copies of one) is listed in delta
+* mode under the row that sorts first in the list order, as in the keys statement; ties go to the
+* lowest dedupeKey, then the latest endedAt, so every poll picks the same row.
+*/
 function compileClickHouseTraceQuery(plan, deltaHead) {
 	const parameters = new ParameterBuilder();
-	const candidates = `WITH ${compileClickHouseTraceCandidates(plan, TRACE_SELECT, parameters).join(",\n")}`;
-	if (plan.result === "groups") return {
-		query: `${candidates}
+	if (plan.result === "groups") {
+		const ctes = compileClickHouseTraceCandidates(plan, TRACE_LIST_SELECT, parameters, QUERY_TRACES_SCOPE);
+		const pageCondition = plan.cursor ? `AND threadId > ${parameters.add(plan.cursor.threadId, "String")}` : "";
+		const limit = parameters.add(plan.limit + 1, "UInt64");
+		return {
+			query: `WITH ${ctes.join(",\n")}
 SELECT threadId
 FROM candidates
-WHERE isNotNull(threadId) ${plan.cursor ? `AND threadId > ${parameters.add(plan.cursor.threadId, "String")}` : ""}
+WHERE isNotNull(threadId) ${pageCondition}
 GROUP BY threadId
 ORDER BY threadId ASC
-LIMIT ${parameters.add(plan.limit + 1, "UInt64")}`,
-		query_params: parameters.params
-	};
-	if (plan.paginationMode === "delta") {
-		const watermark = _mastra_core_storage.getTraceQueryDeltaWatermark(plan, "clickhouse");
-		const after = watermark ? parseDeltaWatermark(watermark) : {
-			cursorId: "0",
-			traceId: ""
-		};
-		const lowerCursor = parameters.add(after.cursorId, "UInt64");
-		return {
-			query: `${candidates}, delta_candidates AS (
-  SELECT traceId, max(cursorId) AS latestCursorId
-  FROM ${TABLE_TRACE_ROOTS_DELTA}
-  WHERE cursorId >= ${lowerCursor} AND tuple(cursorId, traceId) > ${`tuple(${lowerCursor}, ${parameters.add(after.traceId, "String")})`} ${deltaHead ? `AND tuple(cursorId, traceId) <= tuple(${parameters.add(deltaHead.cursorId, "UInt64")}, ${parameters.add(deltaHead.traceId, "String")})` : ""}
-  GROUP BY traceId
-)
-SELECT c.*, toString(d.latestCursorId) AS __delta_cursor
-FROM candidates c
-INNER JOIN delta_candidates d ON c.traceId = d.traceId
-ORDER BY d.latestCursorId ASC, c.traceId ASC
-LIMIT ${parameters.add(plan.limit + 1, "UInt64")}`,
-			query_params: parameters.params,
-			sharedSnapshot: true
-		};
-	}
-	const orderField = resolveOrderField(plan.orderBy.field);
-	const direction = plan.orderBy.direction === "asc" ? "ASC" : "DESC";
-	if (plan.paginationMode === "page") {
-		const onPage = `__row_position > ${parameters.add(plan.page * plan.perPage, "UInt64")} AND __row_position <= ${parameters.add((plan.page + 1) * plan.perPage, "UInt64")}`;
-		return {
-			query: `${candidates},
-page_rows AS (
-  SELECT
-    ${TRACE_PAGE_COLUMNS.join(",\n    ")},
-    row_number() OVER (ORDER BY ${orderField} ${direction}, traceId ASC) AS __row_position,
-    count() OVER () AS total
-  FROM candidates
-)
-SELECT *, if(${onPage}, 0, 1) AS __metadata
-FROM page_rows
-WHERE (${onPage}) OR __row_position = 1
-ORDER BY __metadata ASC, __row_position ASC`,
+LIMIT ${limit}`,
 			query_params: parameters.params,
 			sharedSnapshot: true
 		};
 	}
-	let pageCondition = "";
-	if (plan.cursor) {
-		const comparison = plan.orderBy.direction === "asc" ? ">" : "<";
-		const sortValue = parameters.add(plan.cursor.sortValue, "DateTime64(3, 'UTC')");
-		pageCondition = `WHERE (${orderField} ${comparison} ${sortValue} OR (${orderField} = ${sortValue} AND traceId > ${parameters.add(plan.cursor.traceId, "String")}))`;
-	}
+	if (plan.paginationMode !== "delta") throw new Error("Keyset and page trace queries use compileClickHouseTraceQueryKeys and compileClickHouseTraceRowsByKey");
+	const order = traceOrder(plan);
+	const watermark = _mastra_core_storage.getTraceQueryDeltaWatermark(plan, "clickhouse");
+	const after = watermark ? parseDeltaWatermark(watermark) : {
+		cursorId: "0",
+		traceId: ""
+	};
+	const lowerCursor = parameters.add(after.cursorId, "UInt64");
+	const lower = `tuple(${lowerCursor}, ${parameters.add(after.traceId, "String")})`;
+	const upper = deltaHead ? `AND tuple(cursorId, traceId) <= tuple(${parameters.add(deltaHead.cursorId, "UInt64")}, ${parameters.add(deltaHead.traceId, "String")})` : "";
+	const ctes = compileClickHouseTraceCandidates(plan, TRACE_LIST_SELECT, parameters, {
+		...QUERY_TRACES_SCOPE,
+		delta: `cursorId >= ${lowerCursor} AND tuple(cursorId, traceId) > ${lower} ${upper}`
+	});
 	const limit = parameters.add(plan.limit + 1, "UInt64");
 	return {
-		query: `${candidates}
-SELECT *
-FROM candidates
-${pageCondition}
-ORDER BY ${orderField} ${direction}, traceId ASC
+		query: `WITH ${ctes.join(",\n")}
+SELECT c.*, toString(d.latestCursorId) AS __delta_cursor
+FROM candidates c
+INNER JOIN delta_candidates d ON c.traceId = d.traceId
+ORDER BY d.latestCursorId ASC, c.traceId ASC, c.${order.field} ${order.direction}, c.dedupeKey ASC, c.endedAt DESC
+LIMIT 1 BY c.traceId
 LIMIT ${limit}`,
-		query_params: parameters.params
+		query_params: parameters.params,
+		sharedSnapshot: true
+	};
+}
+/** Map key matching a payload row to the listed row it was read for. */
+function traceRootRowKey(row) {
+	return JSON.stringify([
+		String(row.traceId),
+		String(row.dedupeKey),
+		row.organizationId == null ? null : String(row.organizationId),
+		row.resourceId == null ? null : String(row.resourceId)
+	]);
+}
+/** A listed row's {@link ClickHouseTraceRootRowKey}. */
+function toTraceRootRowKey(row) {
+	return {
+		traceId: String(row.traceId),
+		dedupeKey: String(row.dedupeKey),
+		startedAt: asIsoTimestamp(row.startedAt),
+		endedAt: asIsoTimestamp(row.endedAt),
+		organizationId: row.organizationId == null ? null : String(row.organizationId),
+		resourceId: row.resourceId == null ? null : String(row.resourceId)
 	};
 }
 /**
-* Fetches the metadata/input payloads for page-mode rows. Looks rows up by the
-* trace_roots sort-key prefix `(startedAt, traceId)`, so only the page's
-* granules are read. A root can have unmerged versions in different `endedAt`
-* partitions, so `endedAt` is part of the key: the payload comes from the same
-* version as the candidate row.
+* Fetches payloads for listed rows: `metadata` and the stored previews, or `input` / `output` /
+* `error` alone for rows written before the previews were stored. Each row is looked up by its
+* own identity: the trace_roots sort key `(startedAt, traceId, dedupeKey)`, so only the page's
+* granules are read; `endedAt`, so the payload comes from the same version as the listed row (a
+* root can have unmerged versions in different `endedAt` partitions); and its own
+* `organizationId` / `resourceId`, so a page holding several tenants' rows that share a trace and
+* span id never takes another tenant's payload. NULL tenant columns match only NULL. Callers
+* match the returned rows back with {@link traceRootRowKey}.
 */
-function compileClickHouseTraceRootPayloads(keys) {
+function compileClickHouseTraceRootPayloads(keys, scope, columns = "payload") {
 	const parameters = new ParameterBuilder();
+	const tenant = (value) => `${parameters.add(value ?? "", "String")}, ${value === null ? 1 : 0}`;
+	const tuples = keys.map((key) => `(${parameters.add(key.startedAt, "DateTime64(3, 'UTC')")}, ${parameters.add(key.traceId, "String")}, ${parameters.add(key.dedupeKey, "String")}, ${parameters.add(key.endedAt, "DateTime64(3, 'UTC')")}, ${tenant(key.organizationId)}, ${tenant(key.resourceId)})`);
 	return {
-		query: `SELECT traceId, spanId AS rootSpanId, metadataRaw AS metadata, input
+		query: `SELECT traceId, spanId AS rootSpanId, dedupeKey, organizationId, resourceId, ${columns === "payload" ? `metadataRaw AS metadata, ${PREVIEW_COLUMNS.join(", ")}` : "input, output, error"}
 FROM ${TABLE_TRACE_ROOTS}
-WHERE (startedAt, traceId, spanId, endedAt) IN (${keys.map((key) => `(${parameters.add(key.startedAt, "DateTime64(3, 'UTC')")}, ${parameters.add(key.traceId, "String")}, ${parameters.add(key.rootSpanId, "String")}, ${parameters.add(key.endedAt, "DateTime64(3, 'UTC')")})`).join(", ")})
-LIMIT 1 BY traceId, spanId`,
+WHERE (startedAt, traceId, dedupeKey, endedAt, ifNull(organizationId, ''), isNull(organizationId), ifNull(resourceId, ''), isNull(resourceId)) IN (${tuples.join(", ")})${compileTenantScope(scope, parameters)}
+LIMIT 1 BY traceId, dedupeKey, organizationId, resourceId`,
 		query_params: parameters.params
 	};
 }
@@ -7520,56 +7728,15 @@ async function queryTraces(client, plan, timeoutMs, strategy = null) {
 			deltaCursor: _mastra_core_storage.encodeTraceQueryDeltaCursor(plan, "clickhouse", JSON.stringify(deltaHead))
 		});
 	}
-	if (plan.paginationMode === "page") {
-		const rows = await runWithClickHouseTraceQueryTimeout(client, { timeoutMs: deltaHead ? remaining() : timeoutMs }, compileClickHouseTraceQuery(plan, deltaHead));
-		const total = Number(rows.at(-1)?.total ?? 0);
-		const pageRows = rows.filter((row) => Number(row.__metadata) === 0);
-		const payloads = /* @__PURE__ */ new Map();
-		if (pageRows.length > 0) {
-			const payloadRows = await runWithClickHouseTraceQueryTimeout(client, { timeoutMs: remaining() }, compileClickHouseTraceRootPayloads(pageRows.map((row) => ({
-				traceId: String(row.traceId),
-				rootSpanId: String(row.rootSpanId),
-				startedAt: asIsoTimestamp(row.startedAt),
-				endedAt: asIsoTimestamp(row.endedAt)
-			}))));
-			for (const payload of payloadRows) payloads.set(`${payload.traceId}\u0000${payload.rootSpanId}`, payload);
-		}
-		const traces = pageRows.map((row) => ({
-			...row,
-			...payloads.get(`${row.traceId}\u0000${row.rootSpanId}`)
-		})).map((row) => ({
-			traceId: String(row.traceId),
-			rootSpanId: String(row.rootSpanId),
-			name: row.name,
-			entityId: row.entityId ?? null,
-			parentSpanId: row.parentSpanId ?? null,
-			createdAt: asIsoTimestamp(row.startedAt),
-			metadata: parseJson(row.metadata) ?? null,
-			inputPreview: _mastra_core_storage.buildInputPreview(row.input) ?? null,
-			threadId: row.threadId == null ? null : String(row.threadId),
-			resourceId: row.resourceId == null ? null : String(row.resourceId),
-			startedAt: asIsoTimestamp(row.startedAt),
-			endedAt: asIsoTimestamp(row.endedAt),
-			entityName: row.entityName == null ? null : String(row.entityName),
-			entityType: row.entityType == null ? null : String(row.entityType),
-			environment: row.environment == null ? null : String(row.environment),
-			status: row.status
-		}));
-		return _mastra_core_storage.traceQueryResponseSchema.parse({
-			traces,
-			...deltaHead ? { deltaCursor: _mastra_core_storage.encodeTraceQueryDeltaCursor(plan, "clickhouse", JSON.stringify(deltaHead)) } : {},
-			pagination: {
-				total,
-				page: plan.page,
-				perPage: plan.perPage,
-				hasMore: (plan.page + 1) * plan.perPage < total
-			}
-		});
-	}
-	const rows = await runWithClickHouseTraceQueryTimeout(client, { timeoutMs: deltaHead ? remaining() : timeoutMs }, compileClickHouseTraceQuery(plan, deltaHead));
-	const visibleRows = rows.slice(0, plan.limit);
+	let first = !deltaHead;
+	const run = (compiled) => {
+		const budget = first ? timeoutMs : remaining();
+		first = false;
+		return runWithClickHouseTraceQueryTimeout(client, { timeoutMs: budget }, compiled);
+	};
 	if (plan.result === "groups") {
-		const groups = visibleRows.map((row) => ({ threadId: String(row.threadId) }));
+		const rows = await run(compileClickHouseTraceQuery(plan));
+		const groups = rows.slice(0, plan.limit).map((row) => ({ threadId: String(row.threadId) }));
 		const last = groups.at(-1);
 		return _mastra_core_storage.traceQueryResponseSchema.parse({
 			groups,
@@ -7579,7 +7746,32 @@ async function queryTraces(client, plan, timeoutMs, strategy = null) {
 			}) : null }
 		});
 	}
-	const traces = visibleRows.map((row) => ({
+	/** Rows written before the previews were stored have none; theirs are built from the payloads. */
+	const toTraceRecords = async (rows) => {
+		const missing = rows.filter(needsPreviewPayloads);
+		const payloads = /* @__PURE__ */ new Map();
+		if (missing.length > 0) {
+			const payloadRows = await run(compileClickHouseTraceRootPayloads(missing.map(toTraceRootRowKey), plan.scope, "previewPayloads"));
+			for (const row of payloadRows) payloads.set(traceRootRowKey(row), row);
+		}
+		return rows.map((row) => toTraceRecord({
+			...row,
+			...resolveStoredPreviews(row, payloads.get(traceRootRowKey(row)))
+		}));
+	};
+	/** Lists rows, then fetches `metadata` and the previews for the rows that are returned. */
+	const listTraces = async (rows) => {
+		const payloads = /* @__PURE__ */ new Map();
+		if (rows.length > 0) {
+			const payloadRows = await run(compileClickHouseTraceRootPayloads(rows.map(toTraceRootRowKey), plan.scope));
+			for (const payload of payloadRows) payloads.set(traceRootRowKey(payload), payload);
+		}
+		return toTraceRecords(rows.map((row) => ({
+			...row,
+			...payloads.get(traceRootRowKey(row))
+		})));
+	};
+	const toTraceRecord = (row) => ({
 		traceId: String(row.traceId),
 		rootSpanId: String(row.rootSpanId),
 		name: row.name,
@@ -7587,7 +7779,9 @@ async function queryTraces(client, plan, timeoutMs, strategy = null) {
 		parentSpanId: row.parentSpanId ?? null,
 		createdAt: asIsoTimestamp(row.startedAt),
 		metadata: parseJson(row.metadata) ?? null,
-		inputPreview: _mastra_core_storage.buildInputPreview(row.input) ?? null,
+		inputPreview: row.inputPreview ?? null,
+		outputPreview: row.outputPreview ?? null,
+		errorPreview: row.errorPreview ?? null,
 		threadId: row.threadId == null ? null : String(row.threadId),
 		resourceId: row.resourceId == null ? null : String(row.resourceId),
 		startedAt: asIsoTimestamp(row.startedAt),
@@ -7596,9 +7790,11 @@ async function queryTraces(client, plan, timeoutMs, strategy = null) {
 		entityType: row.entityType == null ? null : String(row.entityType),
 		environment: row.environment == null ? null : String(row.environment),
 		status: row.status
-	}));
-	const last = traces.at(-1);
+	});
 	if (plan.paginationMode === "delta") {
+		const rows = await run(compileClickHouseTraceQuery(plan, deltaHead));
+		const visibleRows = rows.slice(0, plan.limit);
+		const traces = await listTraces(visibleRows);
 		const lastRow = visibleRows.at(-1);
 		let watermark = lastRow ? {
 			cursorId: String(lastRow.__delta_cursor),
@@ -7615,12 +7811,36 @@ async function queryTraces(client, plan, timeoutMs, strategy = null) {
 			deltaCursor: _mastra_core_storage.encodeTraceQueryDeltaCursor(plan, "clickhouse", JSON.stringify(watermark))
 		});
 	}
+	const keys = await run(compileClickHouseTraceQueryKeys(plan));
+	let total = Number(keys[0]?.__total ?? 0);
+	if (plan.paginationMode === "page" && keys.length === 0 && plan.page > 0) {
+		const [stats] = await run(compileClickHouseTraceQueryTotal(plan));
+		total = Number(stats?.traces ?? 0);
+	}
+	const visible = plan.paginationMode === "page" ? keys : keys.slice(0, plan.limit);
+	const rows = visible.length > 0 ? await run(compileClickHouseTraceRowsByKey(plan, visible.map((key) => ({
+		traceId: String(key.traceId),
+		dedupeKey: String(key.dedupeKey),
+		sortValue: asIsoTimestamp(key.sortValue),
+		rootStartedAt: asIsoTimestamp(key.rootStartedAt)
+	})))) : [];
+	if (plan.paginationMode === "page") return _mastra_core_storage.traceQueryResponseSchema.parse({
+		traces: await toTraceRecords(rows),
+		...deltaHead ? { deltaCursor: _mastra_core_storage.encodeTraceQueryDeltaCursor(plan, "clickhouse", JSON.stringify(deltaHead)) } : {},
+		pagination: {
+			total,
+			page: plan.page,
+			perPage: plan.perPage,
+			hasMore: (plan.page + 1) * plan.perPage < total
+		}
+	});
+	const lastKey = visible.at(-1);
 	return _mastra_core_storage.traceQueryResponseSchema.parse({
-		traces,
-		page: { next: rows.length > plan.limit && last ? _mastra_core_storage.encodeTraceQueryCursor(plan, {
+		traces: await toTraceRecords(rows),
+		page: { next: keys.length > plan.limit && lastKey ? _mastra_core_storage.encodeTraceQueryCursor(plan, {
 			result: "traces",
-			sortValue: last[plan.orderBy.field],
-			traceId: last.traceId
+			sortValue: asIsoTimestamp(lastKey.sortValue),
+			traceId: String(lastKey.traceId)
 		}) : null }
 	});
 }
@@ -7790,13 +8010,29 @@ async function querySpans(client, plan, timeoutMs) {
 		page: { next: null }
 	};
 	const payloadWhere = `tuple(${identitySetColumns}, endedAt) IN {page:Array(Tuple(UInt8, String, UInt8, String, String, String, DateTime64(3, 'UTC')))}`;
-	const payloads = await run({
-		query: `SELECT ${identities}, ${displayFields.map((field, index) => `data.${index + 1} AS ${field}`).join(", ")},
-      data.${displayFields.length + 1} AS inputPreview, data.${displayFields.length + 2} AS outputPreview
-    FROM (SELECT ${identities}, any(tuple(${displayFields.map(fieldExpression).join(", ")}, substringUTF8(input, 1, ${_mastra_core_storage.SPAN_QUERY_MAX_PREVIEW_CHARACTERS + 1}), substringUTF8(output, 1, ${_mastra_core_storage.SPAN_QUERY_MAX_PREVIEW_CHARACTERS + 1}))) AS data
+	const pageParameter = (rows) => rows.map((row) => new _clickhouse_client.TupleParam([...identityValues(row), row.endedAt.replace("T", " ").replace(/Z$/, "")]));
+	const rowsWithPreviews = await run({
+		query: `SELECT ${identities}, ${[...displayFields, ...PREVIEW_COLUMNS].map((field, index) => `data.${index + 1} AS ${field}`).join(", ")}
+    FROM (SELECT ${identities}, any(tuple(${[...displayFields.map(fieldExpression), ...PREVIEW_COLUMNS].join(", ")})) AS data
       FROM ${TABLE_SPAN_EVENTS} e WHERE ${payloadWhere} GROUP BY ${identities})`,
-		query_params: { page: page.map((row) => new _clickhouse_client.TupleParam([...identityValues(row), row.endedAt.replace("T", " ").replace(/Z$/, "")])) }
+		query_params: { page: pageParameter(page) }
 	});
+	const missingKeys = new Set(rowsWithPreviews.filter(needsPreviewPayloads).map(_mastra_core_storage.spanQueryIdentityKey));
+	const missing = page.filter((row) => missingKeys.has(_mastra_core_storage.spanQueryIdentityKey(row)));
+	const previewPayloads = /* @__PURE__ */ new Map();
+	if (missing.length) {
+		const rows = await run({
+			query: `SELECT ${identities}, data.1 AS input, data.2 AS output, data.3 AS error
+      FROM (SELECT ${identities}, any(tuple(input, output, error)) AS data
+        FROM ${TABLE_SPAN_EVENTS} e WHERE ${payloadWhere} GROUP BY ${identities})`,
+			query_params: { page: pageParameter(missing) }
+		});
+		for (const row of rows) previewPayloads.set(_mastra_core_storage.spanQueryIdentityKey(row), row);
+	}
+	const payloads = rowsWithPreviews.map((row) => ({
+		...row,
+		...resolveStoredPreviews(row, previewPayloads.get(_mastra_core_storage.spanQueryIdentityKey(row)))
+	}));
 	const metricWhere = `${identitySetKey} IN {page:Array(Tuple(UInt8, String, UInt8, String, String, String))}`;
 	const metrics = await run({
 		query: `SELECT ${identities}, data.1 AS name, data.2 AS estimatedCost,
@@ -7810,17 +8046,16 @@ async function querySpans(client, plan, timeoutMs) {
 	});
 	if (metrics.length > _mastra_core_storage.SPAN_QUERY_MAX_COST_METRICS) throw new _mastra_core_storage.TraceQueryResourceLimitError();
 	const byIdentity = new Map(payloads.map((row) => [_mastra_core_storage.spanQueryIdentityKey(row), row]));
-	const hydrated = page.flatMap((identity) => {
+	const result = buildSpanQueryResponse(plan, page.flatMap((identity) => {
 		const row = byIdentity.get(_mastra_core_storage.spanQueryIdentityKey(identity));
 		if (!row) return [];
-		const { inputPreview: _input, outputPreview: _output, ...metadata } = row;
+		const { inputPreview: _input, outputPreview: _output, errorPreview: _error, ...metadata } = row;
 		return [{
 			...metadata,
 			...identity,
 			durationMs: Number(row.durationMs)
 		}];
-	});
-	const result = _mastra_core_storage.buildSpanQueryResponse(plan, hydrated, payloads, metrics);
+	}), payloads, metrics);
 	const last = page.at(-1);
 	result.page.next = selected.length > plan.limit ? _mastra_core_storage.encodeSpanQueryCursor(plan, {
 		organizationId: last.organizationId,
@@ -7874,7 +8109,13 @@ const COMPARISON_SQL = {
 */
 function compileClickHouseTraceAggregate(plan) {
 	const parameters = new ParameterBuilder();
-	const ctes = compileClickHouseTraceCandidates(plan, "*", parameters);
+	const ctes = compileClickHouseTraceCandidates(plan, "*", parameters, { oneRootPerTrace: true });
+	ctes.push(`trace_roots AS (
+    SELECT *
+    FROM candidates
+    ORDER BY traceId, dedupeKey
+    LIMIT 1 BY traceId
+  )`);
 	const dimensionSql = (field) => {
 		if (field.startsWith("metadata.")) return traceMetadataValueSql(parameters.add(field.slice(9), "String"));
 		const sql = Object.hasOwn(DIMENSION_SQL, field) ? DIMENSION_SQL[field] : void 0;
@@ -7908,7 +8149,7 @@ function compileClickHouseTraceAggregate(plan) {
 	}
 	ctes.push(`facts AS (
     SELECT ${factColumns.join(",\n      ")}
-    FROM candidates r${usageJoin}
+    FROM trace_roots r${usageJoin}
   )`);
 	const mixedUnitsSql = "minOrNull(unitMin) != maxOrNull(unitMax)";
 	const measureSql = (name) => {
@@ -8124,9 +8365,9 @@ async function getRootSpan(client, args) {
 	return { span: rowToSpanRecord(rows[0]) };
 }
 /**
-* Columns a trace list renders. `input` is selected only so the row mapper can
-* derive a short `inputPreview` at read time (see `rowToLightSpanRecord`); the
-* raw blob itself never leaves the store.
+* Columns a trace list renders. The previews are the stored ones; rows written
+* before they were stored get theirs from the payload columns, fetched for just
+* those rows (see `withPreviewPayloads`).
 */
 const LIGHT_TRACE_ROOT_FIELDS = [
 	"traceId",
@@ -8141,10 +8382,13 @@ const LIGHT_TRACE_ROOT_FIELDS = [
 	"entityId",
 	"entityName",
 	"threadId",
+	"organizationId",
 	"resourceId",
 	"error",
 	"metadataRaw",
-	"input"
+	"inputPreview",
+	"outputPreview",
+	"errorPreview"
 ];
 const FULL_PROJECTION = {
 	innerSelect: "*",
@@ -8153,7 +8397,7 @@ const FULL_PROJECTION = {
 };
 const LIGHT_PROJECTION = {
 	innerSelect: ["dedupeKey", ...LIGHT_TRACE_ROOT_FIELDS].join(", "),
-	outerSelect: LIGHT_TRACE_ROOT_FIELDS.join(", "),
+	outerSelect: ["dedupeKey", ...LIGHT_TRACE_ROOT_FIELDS].join(", "),
 	deltaSelect: LIGHT_TRACE_ROOT_FIELDS.filter((field) => field !== "startedAt" && field !== "traceId").map((field) => `r.${field}`).join(", ")
 };
 /**
@@ -8199,7 +8443,7 @@ async function listTraceRows(client, args, strategy, projection, mapRows) {
 		const rows = await queryTracesAfterCursor(client, projection.deltaSelect, whereClause, params, limit, afterCursor);
 		const visibleRows = rows.slice(0, limit);
 		return {
-			spans: mapRows(visibleRows),
+			spans: await mapRows(visibleRows),
 			delta: {
 				limit,
 				hasMore: rows.length > limit
@@ -8274,7 +8518,7 @@ async function listTraceRows(client, args, strategy, projection, mapRows) {
 			perPage,
 			hasMore: (page + 1) * perPage < total
 		},
-		spans: mapRows(rows),
+		spans: await mapRows(rows),
 		...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
 	};
 }
@@ -8283,12 +8527,32 @@ async function listTraces(client, args, strategy) {
 	return listTraceRows(client, args, strategy, FULL_PROJECTION, (rows) => (0, _mastra_core_storage.toTraceSpans)(rows.map(rowToSpanRecord)));
 }
 /**
+* Adds `input` / `output` / `error` to the rows written before previews were stored, read from
+* the same root row version (same `endedAt`) the list kept. A page can hold several tenants' rows,
+* so each row is looked up by its own identity, tenant included, not by one shared scope.
+*/
+async function withPreviewPayloads(client, rows) {
+	const missing = rows.filter(needsPreviewPayloads);
+	if (missing.length === 0) return rows;
+	const compiled = compileClickHouseTraceRootPayloads(missing.map(toTraceRootRowKey), void 0, "previewPayloads");
+	const result = await client.query({
+		...compiled,
+		format: "JSONEachRow",
+		clickhouse_settings: CH_SETTINGS
+	});
+	const payloads = new Map((await result.json()).map((row) => [traceRootRowKey(row), row]));
+	return rows.map((row) => needsPreviewPayloads(row) ? {
+		...row,
+		...payloads.get(traceRootRowKey(row))
+	} : row);
+}
+/**
 * List traces projecting only the columns a trace list renders.
-* Skips the attributes/output blobs and reduces `input` to a short preview in
-* the mapper, so the response payload stays flat as traces grow.
+* Skips the attributes/input/output blobs and reads the stored previews instead,
+* so the response payload stays flat as traces grow.
 */
 async function listTracesLight(client, args, strategy) {
-	return listTraceRows(client, args, strategy, LIGHT_PROJECTION, (rows) => rows.map(rowToLightSpanRecord));
+	return listTraceRows(client, args, strategy, LIGHT_PROJECTION, async (rows) => (await withPreviewPayloads(client, rows)).map(rowToLightSpanRecord));
 }
 async function queryTracesAfterCursor(client, deltaSelect, whereClause, params, limit, cursorId) {
 	const deltaKeys = `SELECT startedAt, traceId, dedupeKey FROM ${TABLE_TRACE_ROOTS_DELTA} WHERE cursorId > {afterCursor:UInt64}`;