@mastra/clickhouse 1.26.0-alpha.4 → 1.26.0

package/dist/index.js

@@ -1587,6 +1587,7 @@ var MemoryStorageClickhouse = class extends MemoryStorage {
 					metadataIndex++;
 				}
 			}
+			const idScope = filter?.resourceId ? `WHERE id IN (SELECT id FROM ${TABLE_THREADS} WHERE resourceId = {resourceId:String})` : "";
 			const latestThreads = `
         latest_threads AS (
           SELECT
@@ -1597,7 +1598,7 @@ var MemoryStorageClickhouse = class extends MemoryStorage {
             toDateTime64(createdAt, 3) as createdAt,
             toDateTime64(updatedAt, 3) as updatedAt
           FROM ${TABLE_THREADS}
-          ${filter?.resourceId ? `WHERE id IN (SELECT id FROM ${TABLE_THREADS} WHERE resourceId = {resourceId:String})` : ""}
+          ${idScope}
           ORDER BY updatedAt DESC
           LIMIT 1 BY id
         )`;
@@ -2418,9 +2419,7 @@ var ObservabilityStorageClickhouse = class extends ObservabilityStorage {
 					case TraceStatus.RUNNING:
 						conditions.push(`endedAt IS NULL AND (error IS NULL OR error = '')`);
 						break;
-					case TraceStatus.SUCCESS:
-						conditions.push(`endedAt IS NOT NULL AND (error IS NULL OR error = '')`);
-						break;
+					case TraceStatus.SUCCESS: conditions.push(`endedAt IS NOT NULL AND (error IS NULL OR error = '')`);
 				}
 				if (filters.hasChildError !== void 0) {
 					const finalClause = (TABLE_ENGINES[TABLE_SPANS] ?? "MergeTree()").startsWith("ReplacingMergeTree") ? "FINAL" : "";
@@ -5261,7 +5260,8 @@ async function getFeedbackAggregate(client, args) {
 	const aggSql = getAggregationSql$2(args.aggregation);
 	const identity = buildFeedbackIdentityFilter(args);
 	const combined = mergeFilters$2(identity, buildFeedbackFilterConditions(args.filters));
-	const result = await queryJson$2(client, `SELECT ${aggSql} AS value FROM ${TABLE_FEEDBACK_EVENTS} FINAL ${toWhereClause$2(combined)}`, combined.params);
+	const whereClause = toWhereClause$2(combined);
+	const result = await queryJson$2(client, `SELECT ${aggSql} AS value FROM ${TABLE_FEEDBACK_EVENTS} FINAL ${whereClause}`, combined.params);
 	const value = result[0]?.value == null ? null : Number(result[0]?.value);
 	if (args.comparePeriod && args.filters?.timestamp) {
 		const ts = args.filters.timestamp;
@@ -5295,7 +5295,8 @@ async function getFeedbackAggregate(client, args) {
 					endExclusive: ts.endExclusive
 				}
 			}));
-			const prevResult = await queryJson$2(client, `SELECT ${aggSql} AS value FROM ${TABLE_FEEDBACK_EVENTS} FINAL ${toWhereClause$2(prevCombined)}`, prevCombined.params);
+			const prevWhereClause = toWhereClause$2(prevCombined);
+			const prevResult = await queryJson$2(client, `SELECT ${aggSql} AS value FROM ${TABLE_FEEDBACK_EVENTS} FINAL ${prevWhereClause}`, prevCombined.params);
 			const previousValue = prevResult[0]?.value == null ? null : Number(prevResult[0]?.value);
 			let changePercent = null;
 			if (previousValue !== null && previousValue !== 0 && value !== null) changePercent = (value - previousValue) / Math.abs(previousValue) * 100;
@@ -6202,8 +6203,10 @@ function buildLegacySpanSelectExprs(legacyColumnTypes) {
 	const promotedIn = PROMOTED_METADATA_KEYS.map((k) => `'${k}'`).join(", ");
 	const metadataSearchExpr = has("metadata") ? `CAST(arrayFilter(x -> x.1 NOT IN (${promotedIn}) AND trim(BOTH ' ' FROM x.2) != '', arrayMap(x -> (x.1, trim(BOTH ' ' FROM x.2)), JSONExtractKeysAndValues(COALESCE("metadata", '{}'), 'String'))), 'Map(String, String)')` : `CAST(map(), 'Map(String, String)')`;
 	let tagsExpr = "[]";
-	if (has("tags")) if (legacyColumnTypes.get("tags").includes("Array")) tagsExpr = `arrayFilter(x -> x != '', arrayDistinct(arrayMap(x -> trim(BOTH ' ' FROM x), "tags")))`;
-	else tagsExpr = `arrayFilter(x -> x != '', arrayDistinct(arrayMap(x -> trim(BOTH ' ' FROM x), JSONExtract(COALESCE("tags", '[]'), 'Array(String)'))))`;
+	if (has("tags")) {
+		if (legacyColumnTypes.get("tags").includes("Array")) tagsExpr = `arrayFilter(x -> x != '', arrayDistinct(arrayMap(x -> trim(BOTH ' ' FROM x), "tags")))`;
+		else tagsExpr = `arrayFilter(x -> x != '', arrayDistinct(arrayMap(x -> trim(BOTH ' ' FROM x), JSONExtract(COALESCE("tags", '[]'), 'Array(String)'))))`;
+	}
 	const exprs = {
 		dedupeKey: `concat("traceId", ':', "spanId")`,
 		traceId: `"traceId"`,
@@ -6450,10 +6453,11 @@ function toWhereClause(filter) {
 	return filter.conditions.length ? `WHERE ${filter.conditions.join(" AND ")}` : "";
 }
 function currentScoresRelation(sourcePredicate) {
+	const whereClause = sourcePredicate ? `WHERE ${sourcePredicate}` : "";
 	return `(
     SELECT *
     FROM ${TABLE_SCORE_EVENTS_CURRENT} FINAL
-    ${sourcePredicate ? `WHERE ${sourcePredicate}` : ""}
+    ${whereClause}
   )`;
 }
 /**
@@ -6901,6 +6905,10 @@ const TRACE_FIELDS = {
 		sql: "r.timeToFirstChunkMs",
 		parameterType: "Float64"
 	},
+	entityId: {
+		sql: "r.entityId",
+		parameterType: "String"
+	},
 	entityName: {
 		sql: "r.entityName",
 		parameterType: "String"
@@ -7299,6 +7307,28 @@ function compileTenantScope(scope, parameters) {
 	if (scope.resourceId !== void 0) sql += `\n      AND resourceId = ${parameters.add(scope.resourceId, "String")}`;
 	return sql;
 }
+/**
+* Order of the versions of one root span, current version first. `mastra_trace_roots` has no
+* version column, so until a background merge runs, every export of a root is its own row with the
+* same sort key, and merges never meet versions that ended on different days (it is partitioned by
+* `endedAt`). The version that ended last is current, as a resumed or completed root is exported
+* again with a later `endedAt`; a pending copy stores `endedAt = startedAt` and can lack `threadId`,
+* so a copy with a thread wins an equal-time tie. Remaining ties are broken by insertion order, last
+* insert first: the part's first block number, then the row's offset in the part. Tied versions
+* share a partition and sort key, so a merge meets them and keeps the last insert too, and reads
+* pick the same version before and after it. Both are virtual columns, so the order reads nothing
+* beyond `endedAt` and `threadId`.
+*
+* Merges don't follow this order across `endedAt`: within one day's partition a merge keeps the last
+* insert, not the version that ended last. If an outdated export of a root is redelivered after its
+* current version, on the same day, reads pick the current version until a merge, and the outdated
+* one afterwards (last write wins, as in the PG and DuckDB stores). Making merges keep the version
+* that ended last needs `ReplacingMergeTree(endedAt)`, a schema change.
+*
+* Every root collapse uses this order: trace rows, aggregates, thread rows and the discovery reads.
+*/
+const ROOT_VERSION_ORDER = `endedAt DESC, isNotNull(threadId) DESC, toUInt64(splitByChar('_', _part)[2]) DESC,
+      _part_offset DESC`;
 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')");
@@ -7322,7 +7352,15 @@ function compileClickHouseTraceScope(selection, relationCollections, parameters,
     SELECT *
     FROM ${TABLE_TRACE_ROOTS} r
     WHERE startedAt >= ${from}
-      AND startedAt < ${to}${tenant}${seedFilter}${bound}
+      AND startedAt < ${to}${tenant}${bound}${seedFilter ? `
+      AND traceId IN (
+        SELECT traceId
+        FROM ${TABLE_TRACE_ROOTS} r
+        WHERE startedAt >= ${from}
+          AND startedAt < ${to}${tenant}${seedFilter}
+      )` : ""}
+    ORDER BY startedAt, traceId, spanId, ${ROOT_VERSION_ORDER}
+    LIMIT 1 BY traceId
   )`] : [`current_roots AS (
     SELECT *
     FROM ${TABLE_TRACE_ROOTS}
@@ -7332,7 +7370,7 @@ function compileClickHouseTraceScope(selection, relationCollections, parameters,
       WHERE startedAt >= ${from}
         AND startedAt < ${to}${tenant}${seedFilter}
     )${tenant}
-    ORDER BY traceId, dedupeKey
+    ORDER BY traceId, startedAt, spanId, ${ROOT_VERSION_ORDER}
     LIMIT 1 BY traceId
   )`, `root_scope AS (
     SELECT *
@@ -7462,11 +7500,7 @@ function traceOrder(plan) {
 		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.
-*/
+/** Keyset cursor on a trace's sort value (the current root's), with traceId breaking ties. */
 function keysetCursorCondition(plan, order, parameters) {
 	if (plan.paginationMode !== "keyset" || !plan.cursor) return "";
 	if (plan.cursor.sortValue === null) return `(isNull(sortValue) AND traceId > ${parameters.add(plan.cursor.traceId, "String")})`;
@@ -7477,9 +7511,8 @@ function keysetCursorCondition(plan, order, parameters) {
 }
 /**
 * 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.
+* for keyset mode, `perPage` at the page offset for page mode) as keys of their current roots, and
+* the number of matching traces on every row. No blob columns are read.
 */
 function compileClickHouseTraceQueryKeys(plan) {
 	if (plan.paginationMode === "delta") throw new Error("Delta trace queries have no keys statement");
@@ -7487,19 +7520,12 @@ function compileClickHouseTraceQueryKeys(plan) {
 	const order = traceOrder(plan);
 	const ctes = compileClickHouseTraceCandidates(plan, "r.traceId AS traceId, r.dedupeKey AS dedupeKey, r.startedAt AS startedAt, r.endedAt AS endedAt, r.timeToFirstChunkMs AS timeToFirstChunkMs", parameters, QUERY_TRACES_SCOPE);
 	const cursor = keysetCursorCondition(plan, order, parameters);
-	const pick = order.direction === "DESC" ? "max" : "min";
-	const rootOrder = order.field === "timeToFirstChunkMs" ? `ifNull(${order.field}, ${pick === "max" ? "-inf" : "inf"})` : order.field;
 	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), ${rootOrder}) 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
+		query: `WITH ${ctes.join(",\n")}
+SELECT traceId, dedupeKey, ${order.field} AS sortValue, startedAt AS rootStartedAt, endedAt AS rootEndedAt,
+  count() OVER () AS __total
+FROM candidates${cursor ? `\nWHERE ${cursor}` : ""}
 ORDER BY sortValue ${order.direction} NULLS LAST, traceId ASC
 ${limit}`,
 		query_params: parameters.params,
@@ -7507,27 +7533,28 @@ ${limit}`,
 	};
 }
 /**
-* 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.
+* Second statement of keyset and page mode: the rows of the keyed roots, with `metadata` and the
+* stored previews, read by sort key and `endedAt`, so only the keyed version's rows match. Versions
+* that end at the same instant are ordered as in the keys statement (ROOT_VERSION_ORDER). The
+* relation-free `where` conjuncts are re-applied, so a version written between the two statements
+* that doesn't match isn't returned.
+*
+* Trade-off of matching on `endedAt`: if a newer version is written between the two statements and
+* a same-day merge then drops the keyed version, the trace has no row and drops off the page. Without
+* `endedAt` the lookup would find the replacement, but could also return a version other than the
+* keyed one whenever both are unmerged. The window is the gap between the two statements.
 */
 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(key.rootStartedAt);
-		const id = `${parameters.add(key.traceId, "String")}, ${parameters.add(key.dedupeKey, "String")}`;
-		return byEnd ? `(${started}, ${id}, ${ts(String(key.sortValue))})` : `(${started}, ${id})`;
-	});
+	const tuples = keys.map((key) => `(${ts(key.rootStartedAt)}, ${parameters.add(key.traceId, "String")}, ${parameters.add(key.dedupeKey, "String")}, ${ts(key.rootEndedAt)})`);
 	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} NULLS LAST, traceId ASC
+WHERE (r.startedAt, r.traceId, r.dedupeKey, r.endedAt) IN (${tuples.join(", ")})${compileTenantScope(plan.scope, parameters)}${predicate}
+ORDER BY ${order.field} ${order.direction} NULLS LAST, traceId ASC, ${ROOT_VERSION_ORDER}
 LIMIT 1 BY traceId`,
 		query_params: parameters.params
 	};
@@ -7546,9 +7573,7 @@ FROM candidates`,
 /**
 * 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.
+* Candidates hold one current root per trace, as in the keys statement.
 */
 function compileClickHouseTraceQuery(plan, deltaHead) {
 	const parameters = new ParameterBuilder();
@@ -7569,7 +7594,6 @@ LIMIT ${limit}`,
 		};
 	}
 	if (plan.paginationMode !== "delta") throw new Error("Keyset and page trace queries use compileClickHouseTraceQueryKeys and compileClickHouseTraceRowsByKey");
-	const order = traceOrder(plan);
 	const watermark = coreStorage.getTraceQueryDeltaWatermark(plan, "clickhouse");
 	const after = watermark ? parseDeltaWatermark(watermark) : {
 		cursorId: "0",
@@ -7588,8 +7612,7 @@ LIMIT ${limit}`,
 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
+ORDER BY d.latestCursorId ASC, c.traceId ASC
 LIMIT ${limit}`,
 		query_params: parameters.params,
 		sharedSnapshot: true
@@ -7633,6 +7656,7 @@ function compileClickHouseTraceRootPayloads(keys, scope, columns = "payload") {
 		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, dedupeKey, endedAt, ifNull(organizationId, ''), isNull(organizationId), ifNull(resourceId, ''), isNull(resourceId)) IN (${tuples.join(", ")})${compileTenantScope(scope, parameters)}
+ORDER BY ${ROOT_VERSION_ORDER}
 LIMIT 1 BY traceId, dedupeKey, organizationId, resourceId`,
 		query_params: parameters.params
 	};
@@ -7929,7 +7953,8 @@ async function queryTraces(client, plan, timeoutMs, strategy = null) {
 		traceId: String(key.traceId),
 		dedupeKey: String(key.dedupeKey),
 		sortValue: sortValue(key.sortValue),
-		rootStartedAt: asIsoTimestamp(key.rootStartedAt)
+		rootStartedAt: asIsoTimestamp(key.rootStartedAt),
+		rootEndedAt: asIsoTimestamp(key.rootEndedAt)
 	})))) : [];
 	if (plan.paginationMode === "page") return coreStorage.traceQueryResponseSchema.parse({
 		traces: await toTraceRecords(rows),
@@ -8137,7 +8162,7 @@ async function querySpans(client, plan, timeoutMs) {
 		if (remaining <= 0) throw new coreStorage.TraceQueryExecutionError();
 		return await runWithClickHouseTraceQueryTimeout(client, {
 			timeoutMs: remaining,
-			memoryLimitBytes: 512 * 1024 * 1024
+			memoryLimitBytes: 536870912
 		}, compiled);
 	};
 	const selected = (await run(compileClickHouseSpanQuery(plan))).map((row) => ({
@@ -8254,14 +8279,14 @@ function afterCursor(plan, parameters) {
 	return `(${terms.join(" OR ")})`;
 }
 const THREAD_QUERY_EXECUTION_LIMITS = {
-	memoryLimitBytes: 512 * 1024 * 1024,
+	memoryLimitBytes: 536870912,
 	maxThreads: 2,
 	maxBlockSize: 4096,
-	spillThresholdBytes: 32 * 1024 * 1024
+	spillThresholdBytes: 33554432
 };
 const MAX_CANDIDATE_THREADS = 16384;
 const MAX_CANDIDATE_TRACES = 1e5;
-const MAX_CANDIDATE_ID_BYTES = 4 * 1024 * 1024;
+const MAX_CANDIDATE_ID_BYTES = 4194304;
 const MAX_FULL_HISTORY_ROOTS = 25e4;
 function canUseThreadCandidates(probe) {
 	return Number(probe.threadCount) <= MAX_CANDIDATE_THREADS && Number(probe.traceCount) <= MAX_CANDIDATE_TRACES && Number(probe.threadBytes) + Number(probe.traceBytes) <= MAX_CANDIDATE_ID_BYTES;
@@ -8338,7 +8363,7 @@ function compileClickHouseThreadRowsQuery(plan, strategy = "full") {
 	const sortedRoots = `roots AS (
     SELECT organizationId, traceId, ${rootDataFields.map((field) => `${rootExpression(field)} AS ${field}`).join(", ")}
     FROM ${TABLE_TRACE_ROOTS} ${scope.length || strategy === "candidates" ? `WHERE ${[...scope, ...strategy === "candidates" ? [candidateTracesFilter] : []].join(" AND ")}` : ""}
-    ORDER BY organizationId, traceId, startedAt ASC, spanId, endedAt DESC, isNotNull(threadId) DESC, dedupeKey
+    ORDER BY organizationId, traceId, startedAt ASC, spanId, ${ROOT_VERSION_ORDER}
     LIMIT 1 BY organizationId, traceId
   )`;
 	return {
@@ -8371,7 +8396,7 @@ function* batches(rows, maxRows = 256) {
 	let bytes = 0;
 	for (const row of rows) {
 		const size = Buffer.byteLength(JSON.stringify(row), "utf8") * 2;
-		if (batch.length && (batch.length >= maxRows || bytes + size > 48 * 1024)) {
+		if (batch.length && (batch.length >= maxRows || bytes + size > 49152)) {
 			yield batch;
 			batch = [];
 			bytes = 0;
@@ -8440,7 +8465,7 @@ async function queryThreadRows(client, plan, timeoutMs, strategy = "auto") {
       ${contextFields.join(", ")}, if(spanType = 'agent_run', timeToFirstChunkMs, NULL) AS timeToFirstChunkMs,
       if(isNull(error), 'success', 'error') AS status, ${PREVIEW_COLUMNS.join(", ")}
       FROM ${TABLE_TRACE_ROOTS} WHERE ${rootWhere}
-      ORDER BY isNotNull(threadId) DESC LIMIT 1 BY organizationId, traceId, spanId`,
+      ORDER BY ${ROOT_VERSION_ORDER} LIMIT 1 BY organizationId, traceId, spanId`,
 		query_params: { roots: keys(batch) }
 	}));
 	const byRoot = new Map(stored.map((row) => [rootKey(row), row]));
@@ -8448,7 +8473,7 @@ async function queryThreadRows(client, plan, timeoutMs, strategy = "auto") {
 	for (const batch of batches(missing, 32)) {
 		const payloads = await run({
 			query: `SELECT organizationId, traceId, spanId, input, output, error FROM ${TABLE_TRACE_ROOTS}
-        WHERE ${rootWhere} ORDER BY isNotNull(threadId) DESC LIMIT 1 BY organizationId, traceId, spanId`,
+        WHERE ${rootWhere} ORDER BY ${ROOT_VERSION_ORDER} LIMIT 1 BY organizationId, traceId, spanId`,
 			query_params: { roots: keys(batch) }
 		});
 		for (const payload of payloads) {
@@ -8517,6 +8542,7 @@ const DIMENSION_SQL = {
 	entityName: "r.entityName",
 	name: "r.name",
 	spanType: "r.spanType",
+	entityId: "r.entityId",
 	environment: "r.environment",
 	status: TRACE_STATUS_SQL,
 	serviceName: "r.serviceName",
@@ -8555,12 +8581,6 @@ const COMPARISON_SQL = {
 function compileClickHouseTraceAggregate(plan) {
 	const parameters = new ParameterBuilder();
 	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;
@@ -8594,7 +8614,7 @@ function compileClickHouseTraceAggregate(plan) {
 	}
 	ctes.push(`facts AS (
     SELECT ${factColumns.join(",\n      ")}
-    FROM trace_roots r${usageJoin}
+    FROM candidates r${usageJoin}
   )`);
 	const mixedUnitsSql = "minOrNull(unitMin) != maxOrNull(unitMax)";
 	const measureSql = (name) => {
@@ -9946,7 +9966,7 @@ async function detectExistingDeltaCursorStrategy(client) {
 	}
 }
 const TRACE_QUERY_DISCOVERY_DEFAULT_TIMEOUT_MS = 5e3;
-const TRACE_QUERY_DISCOVERY_DEFAULT_MEMORY_LIMIT_BYTES = 256 * 1024 * 1024;
+const TRACE_QUERY_DISCOVERY_DEFAULT_MEMORY_LIMIT_BYTES = 268435456;
 function resolveTraceQueryDiscoveryMemoryLimitBytes(memoryLimitBytes = TRACE_QUERY_DISCOVERY_DEFAULT_MEMORY_LIMIT_BYTES) {
 	if (!Number.isSafeInteger(memoryLimitBytes) || memoryLimitBytes <= 0) throw new RangeError("traceQuery.discovery.memoryLimitBytes must be a positive safe integer");
 	return memoryLimitBytes;
@@ -10100,6 +10120,7 @@ var ObservabilityStorageClickhouseVNext = class extends ObservabilityStorage {
 			"trace-query-context-ids",
 			...timeToFirstChunkFeatures,
 			"trace-query-root-span-fields",
+			"trace-query-root-entity-id",
 			"trace-aggregate",
 			...spanQueryFeatures,
 			...threadQueryFeatures
@@ -10123,6 +10144,7 @@ var ObservabilityStorageClickhouseVNext = class extends ObservabilityStorage {
 			"trace-query-context-ids",
 			...timeToFirstChunkFeatures,
 			"trace-query-root-span-fields",
+			"trace-query-root-entity-id",
 			"trace-aggregate",
 			...spanQueryFeatures,
 			...threadQueryFeatures
@@ -11337,10 +11359,12 @@ var WorkflowsStorageClickhouse = class extends WorkflowsStorage {
 				conditions.push(`JSONExtractString(snapshot, 'status') = {var_status:String}`);
 				values.var_status = status;
 			}
-			if (resourceId) if (await this.#db.hasColumn(TABLE_WORKFLOW_SNAPSHOT, "resourceId")) {
-				conditions.push(`resourceId = {var_resourceId:String}`);
-				values.var_resourceId = resourceId;
-			} else this.logger.warn(`[${TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+			if (resourceId) {
+				if (await this.#db.hasColumn(TABLE_WORKFLOW_SNAPSHOT, "resourceId")) {
+					conditions.push(`resourceId = {var_resourceId:String}`);
+					values.var_resourceId = resourceId;
+				} else this.logger.warn(`[${TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+			}
 			if (fromDate) {
 				conditions.push(`createdAt >= {var_from_date:DateTime64(3)}`);
 				values.var_from_date = fromDate.getTime() / 1e3;