@mastra/duckdb 1.5.2-alpha.0 → 1.6.0-alpha.0

package/dist/observability-5ro3rotr.js

@@ -0,0 +1,3733 @@
+import { t as DuckDBConnection } from "./db-Dl0fY488.js";
+import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
+import { BRANCH_SPAN_TYPES, METRIC_DISTINCT_COLUMNS, ObservabilityStorage, createStorageErrorId, listBranchesArgsSchema, listFeedbackArgsSchema, listLogsArgsSchema, listMetricsArgsSchema, listScoresArgsSchema, listTracesArgsSchema, toTraceSpans } from "@mastra/core/storage";
+import { coreFeatures } from "@mastra/core/features";
+import { EntityType } from "@mastra/core/observability";
+import { parseFieldKey } from "@mastra/core/utils";
+//#region src/storage/domains/observability/ddl.ts
+/**
+* DDL statements for DuckDB observability tables.
+* All tables use append-only patterns with a single `timestamp` column.
+*
+* Column ordering convention:
+*   1. Event metadata (eventType, timestamp)
+*   2. IDs (trace, span, experiment, resource, run, session, etc.)
+*   3. Entity hierarchy (entity, parent, root)
+*   4. Context (user, org, environment, service, executionSource)
+*   5. Domain-specific scalar fields
+*   6. JSON fields (attributes, metadata, tags, input/output, etc.)
+*/
+const SPAN_EVENTS_CURSOR_SEQUENCE_DDL = `
+CREATE SEQUENCE IF NOT EXISTS span_events_cursor_id_seq START 1
+`;
+const METRIC_EVENTS_CURSOR_SEQUENCE_DDL = `
+CREATE SEQUENCE IF NOT EXISTS metric_events_cursor_id_seq START 1
+`;
+const LOG_EVENTS_CURSOR_SEQUENCE_DDL = `
+CREATE SEQUENCE IF NOT EXISTS log_events_cursor_id_seq START 1
+`;
+const SCORE_EVENTS_CURSOR_SEQUENCE_DDL = `
+CREATE SEQUENCE IF NOT EXISTS score_events_cursor_id_seq START 1
+`;
+const FEEDBACK_EVENTS_CURSOR_SEQUENCE_DDL = `
+CREATE SEQUENCE IF NOT EXISTS feedback_events_cursor_id_seq START 1
+`;
+/** DDL for the span_events append-only table. */
+const SPAN_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS span_events (
+  -- Event metadata
+  eventType VARCHAR NOT NULL,
+  timestamp TIMESTAMP NOT NULL,
+  cursorId BIGINT,
+
+  -- IDs
+  traceId VARCHAR NOT NULL,
+  spanId VARCHAR NOT NULL,
+  parentSpanId VARCHAR,
+  experimentId VARCHAR,
+
+  -- Entity
+  entityType VARCHAR,
+  entityId VARCHAR,
+  entityName VARCHAR,
+  entityVersionId VARCHAR,
+
+  -- Context
+  userId VARCHAR,
+  organizationId VARCHAR,
+  resourceId VARCHAR,
+  runId VARCHAR,
+  sessionId VARCHAR,
+  threadId VARCHAR,
+  requestId VARCHAR,
+  environment VARCHAR,
+  source VARCHAR,
+  serviceName VARCHAR,
+  requestContext JSON,
+
+  -- Span-specific scalars
+  name VARCHAR,
+  spanType VARCHAR,
+  isEvent BOOLEAN,
+  endedAt TIMESTAMP,
+
+  -- JSON fields
+  attributes JSON,
+  metadata JSON,
+  tags JSON,
+  scope JSON,
+  links JSON,
+  input JSON,
+  output JSON,
+  error JSON
+)`;
+/** DDL for the metric_events append-only table. */
+const METRIC_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS metric_events (
+  -- Event metadata
+  timestamp TIMESTAMP NOT NULL,
+  cursorId BIGINT,
+
+  -- IDs
+  metricId VARCHAR NOT NULL PRIMARY KEY,
+  traceId VARCHAR,
+  spanId VARCHAR,
+  experimentId VARCHAR,
+
+  -- Entity hierarchy
+  entityType VARCHAR,
+  entityId VARCHAR,
+  entityName VARCHAR,
+  entityVersionId VARCHAR,
+  parentEntityVersionId VARCHAR,
+  parentEntityType VARCHAR,
+  parentEntityId VARCHAR,
+  parentEntityName VARCHAR,
+  rootEntityVersionId VARCHAR,
+  rootEntityType VARCHAR,
+  rootEntityId VARCHAR,
+  rootEntityName VARCHAR,
+
+  -- Context
+  userId VARCHAR,
+  organizationId VARCHAR,
+  resourceId VARCHAR,
+  runId VARCHAR,
+  sessionId VARCHAR,
+  threadId VARCHAR,
+  requestId VARCHAR,
+  environment VARCHAR,
+  executionSource VARCHAR,
+  serviceName VARCHAR,
+
+  -- Metric-specific scalars
+  name VARCHAR NOT NULL,
+  value DOUBLE NOT NULL,
+  provider VARCHAR,
+  model VARCHAR,
+  estimatedCost DOUBLE,
+  costUnit VARCHAR,
+
+  -- JSON fields
+  tags JSON,
+  labels JSON,
+  costMetadata JSON,
+  metadata JSON,
+  scope JSON
+)`;
+/** DDL for the log_events append-only table. */
+const LOG_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS log_events (
+  -- Event metadata
+  timestamp TIMESTAMP NOT NULL,
+  cursorId BIGINT,
+
+  -- IDs
+  logId VARCHAR NOT NULL PRIMARY KEY,
+  traceId VARCHAR,
+  spanId VARCHAR,
+  experimentId VARCHAR,
+
+  -- Entity hierarchy
+  entityType VARCHAR,
+  entityId VARCHAR,
+  entityName VARCHAR,
+  entityVersionId VARCHAR,
+  parentEntityVersionId VARCHAR,
+  parentEntityType VARCHAR,
+  parentEntityId VARCHAR,
+  parentEntityName VARCHAR,
+  rootEntityVersionId VARCHAR,
+  rootEntityType VARCHAR,
+  rootEntityId VARCHAR,
+  rootEntityName VARCHAR,
+
+  -- Context
+  userId VARCHAR,
+  organizationId VARCHAR,
+  resourceId VARCHAR,
+  runId VARCHAR,
+  sessionId VARCHAR,
+  threadId VARCHAR,
+  requestId VARCHAR,
+  environment VARCHAR,
+  executionSource VARCHAR,
+  serviceName VARCHAR,
+
+  -- Log-specific scalars
+  level VARCHAR NOT NULL,
+  message VARCHAR NOT NULL,
+
+  -- JSON fields
+  data JSON,
+  tags JSON,
+  metadata JSON,
+  scope JSON
+)`;
+/** DDL for the score_events append-only table. */
+const SCORE_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS score_events (
+  -- Event metadata
+  timestamp TIMESTAMP NOT NULL,
+  cursorId BIGINT,
+
+  -- IDs
+  scoreId VARCHAR NOT NULL PRIMARY KEY,
+  traceId VARCHAR,
+  spanId VARCHAR,
+  experimentId VARCHAR,
+  scoreTraceId VARCHAR,
+
+  -- Entity hierarchy
+  entityType VARCHAR,
+  entityId VARCHAR,
+  entityName VARCHAR,
+  entityVersionId VARCHAR,
+  parentEntityVersionId VARCHAR,
+  parentEntityType VARCHAR,
+  parentEntityId VARCHAR,
+  parentEntityName VARCHAR,
+  rootEntityVersionId VARCHAR,
+  rootEntityType VARCHAR,
+  rootEntityId VARCHAR,
+  rootEntityName VARCHAR,
+
+  -- Context
+  userId VARCHAR,
+  organizationId VARCHAR,
+  resourceId VARCHAR,
+  runId VARCHAR,
+  sessionId VARCHAR,
+  threadId VARCHAR,
+  requestId VARCHAR,
+  environment VARCHAR,
+  executionSource VARCHAR,
+  serviceName VARCHAR,
+
+  -- Score-specific scalars
+  scorerId VARCHAR NOT NULL,
+  scorerVersion VARCHAR,
+  source VARCHAR,
+  scoreSource VARCHAR,
+  score DOUBLE NOT NULL,
+  reason VARCHAR,
+
+  -- JSON fields
+  tags JSON,
+  metadata JSON,
+  scope JSON
+)`;
+/** DDL for the feedback_events append-only table. */
+const FEEDBACK_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS feedback_events (
+  -- Event metadata
+  timestamp TIMESTAMP NOT NULL,
+  cursorId BIGINT,
+
+  -- IDs
+  feedbackId VARCHAR NOT NULL PRIMARY KEY,
+  traceId VARCHAR,
+  spanId VARCHAR,
+  experimentId VARCHAR,
+  -- Entity hierarchy
+  entityType VARCHAR,
+  entityId VARCHAR,
+  entityName VARCHAR,
+  entityVersionId VARCHAR,
+  parentEntityVersionId VARCHAR,
+  parentEntityType VARCHAR,
+  parentEntityId VARCHAR,
+  parentEntityName VARCHAR,
+  rootEntityVersionId VARCHAR,
+  rootEntityType VARCHAR,
+  rootEntityId VARCHAR,
+  rootEntityName VARCHAR,
+
+  -- Context
+  userId VARCHAR,
+  organizationId VARCHAR,
+  resourceId VARCHAR,
+  runId VARCHAR,
+  sessionId VARCHAR,
+  threadId VARCHAR,
+  requestId VARCHAR,
+  environment VARCHAR,
+  executionSource VARCHAR,
+  serviceName VARCHAR,
+
+  -- Feedback actor / linkage
+  feedbackUserId VARCHAR,
+  sourceId VARCHAR,
+
+  -- Feedback-specific scalars
+  source VARCHAR,
+  feedbackSource VARCHAR NOT NULL,
+  feedbackType VARCHAR NOT NULL,
+  value VARCHAR NOT NULL,
+  comment VARCHAR,
+
+  -- JSON fields
+  tags JSON,
+  metadata JSON,
+  scope JSON
+)`;
+/** All observability DDL statements, in creation order. */
+const ALL_DDL = [
+	SPAN_EVENTS_CURSOR_SEQUENCE_DDL,
+	METRIC_EVENTS_CURSOR_SEQUENCE_DDL,
+	LOG_EVENTS_CURSOR_SEQUENCE_DDL,
+	SCORE_EVENTS_CURSOR_SEQUENCE_DDL,
+	FEEDBACK_EVENTS_CURSOR_SEQUENCE_DDL,
+	SPAN_EVENTS_DDL,
+	METRIC_EVENTS_DDL,
+	LOG_EVENTS_DDL,
+	SCORE_EVENTS_DDL,
+	FEEDBACK_EVENTS_DDL
+];
+/** Additive migrations for observability tables created by older versions. */
+const ALL_MIGRATIONS = [
+	`CREATE SEQUENCE IF NOT EXISTS span_events_cursor_id_seq START 1`,
+	`CREATE SEQUENCE IF NOT EXISTS metric_events_cursor_id_seq START 1`,
+	`CREATE SEQUENCE IF NOT EXISTS log_events_cursor_id_seq START 1`,
+	`CREATE SEQUENCE IF NOT EXISTS score_events_cursor_id_seq START 1`,
+	`CREATE SEQUENCE IF NOT EXISTS feedback_events_cursor_id_seq START 1`,
+	`ALTER TABLE span_events ADD COLUMN IF NOT EXISTS cursorId BIGINT`,
+	`ALTER TABLE span_events ADD COLUMN IF NOT EXISTS entityVersionId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS cursorId BIGINT`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS entityVersionId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS parentEntityVersionId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS rootEntityVersionId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS experimentId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS parentEntityType VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS parentEntityId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS parentEntityName VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS rootEntityType VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS rootEntityId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS rootEntityName VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS userId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS organizationId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS resourceId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS runId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS sessionId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS threadId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS requestId VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS environment VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS executionSource VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS serviceName VARCHAR`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS costMetadata JSON`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS metadata JSON`,
+	`ALTER TABLE metric_events ADD COLUMN IF NOT EXISTS scope JSON`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS cursorId BIGINT`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS entityVersionId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS parentEntityVersionId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS rootEntityVersionId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS experimentId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS parentEntityType VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS parentEntityId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS parentEntityName VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS rootEntityType VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS rootEntityId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS rootEntityName VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS userId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS organizationId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS resourceId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS runId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS sessionId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS threadId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS requestId VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS environment VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS executionSource VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS serviceName VARCHAR`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS tags JSON`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS metadata JSON`,
+	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS scope JSON`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS cursorId BIGINT`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS entityVersionId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS parentEntityVersionId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS rootEntityVersionId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS entityType VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS entityId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS entityName VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS parentEntityType VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS parentEntityId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS parentEntityName VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS rootEntityType VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS rootEntityId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS rootEntityName VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS userId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS organizationId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS resourceId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS runId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS sessionId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS threadId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS requestId VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS environment VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS executionSource VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS serviceName VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS tags JSON`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS scope JSON`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS source VARCHAR`,
+	`ALTER TABLE score_events ADD COLUMN IF NOT EXISTS scoreSource VARCHAR`,
+	`ALTER TABLE score_events ALTER COLUMN traceId DROP NOT NULL`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS cursorId BIGINT`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS entityVersionId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS parentEntityVersionId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS rootEntityVersionId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS entityType VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS entityId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS entityName VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS parentEntityType VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS parentEntityId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS parentEntityName VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS rootEntityType VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS rootEntityId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS rootEntityName VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS organizationId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS resourceId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS runId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS sessionId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS threadId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS requestId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS environment VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS executionSource VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS serviceName VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS feedbackUserId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS sourceId VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS tags JSON`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS scope JSON`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS source VARCHAR`,
+	`ALTER TABLE feedback_events ADD COLUMN IF NOT EXISTS feedbackSource VARCHAR`,
+	`ALTER TABLE feedback_events ALTER COLUMN traceId DROP NOT NULL`
+];
+//#endregion
+//#region src/storage/domains/observability/discovery.ts
+function unionDistinctQueries(selects, orderBy) {
+	return `${selects.join("\nUNION\n")}\nORDER BY ${orderBy}`;
+}
+/** Return distinct entity types across observability signals that carry them. */
+async function getEntityTypes(db, _args) {
+	const rows = await db.query(unionDistinctQueries([
+		`SELECT entityType FROM span_events WHERE entityType IS NOT NULL`,
+		`SELECT entityType FROM metric_events WHERE entityType IS NOT NULL`,
+		`SELECT entityType FROM log_events WHERE entityType IS NOT NULL`
+	], "entityType"));
+	const validTypes = new Set(Object.values(EntityType));
+	const typeSet = /* @__PURE__ */ new Set();
+	for (const row of rows) if (row.entityType && validTypes.has(row.entityType)) typeSet.add(row.entityType);
+	return { entityTypes: Array.from(typeSet).sort() };
+}
+/** Return distinct entity names across observability signals, optionally filtered by entity type. */
+async function getEntityNames(db, args) {
+	const buildSelect = (table) => {
+		const conditions = [`entityName IS NOT NULL`];
+		if (args.entityType) conditions.push(`entityType = ?`);
+		return `SELECT entityName FROM ${table} WHERE ${conditions.join(" AND ")}`;
+	};
+	const params = args.entityType ? [
+		args.entityType,
+		args.entityType,
+		args.entityType
+	] : [];
+	return { names: (await db.query(unionDistinctQueries([
+		buildSelect("span_events"),
+		buildSelect("metric_events"),
+		buildSelect("log_events")
+	], "entityName"), params)).map((r) => r.entityName) };
+}
+/** Return distinct service names across observability signals. */
+async function getServiceNames(db, _args) {
+	return { serviceNames: (await db.query(unionDistinctQueries([
+		`SELECT serviceName FROM span_events WHERE serviceName IS NOT NULL`,
+		`SELECT serviceName FROM metric_events WHERE serviceName IS NOT NULL`,
+		`SELECT serviceName FROM log_events WHERE serviceName IS NOT NULL`
+	], "serviceName"))).map((r) => r.serviceName) };
+}
+/** Return distinct environment values across observability signals. */
+async function getEnvironments(db, _args) {
+	return { environments: (await db.query(unionDistinctQueries([
+		`SELECT environment FROM span_events WHERE environment IS NOT NULL`,
+		`SELECT environment FROM metric_events WHERE environment IS NOT NULL`,
+		`SELECT environment FROM log_events WHERE environment IS NOT NULL`
+	], "environment"))).map((r) => r.environment) };
+}
+/** Return distinct tags across observability signals, optionally filtered by entity type. */
+async function getTags(db, args) {
+	const buildSelect = (table) => {
+		const conditions = [`tags IS NOT NULL`];
+		if (args.entityType) conditions.push(`entityType = ?`);
+		return `SELECT unnest(CAST(tags AS VARCHAR[])) AS tag FROM ${table} WHERE ${conditions.join(" AND ")}`;
+	};
+	const params = args.entityType ? [
+		args.entityType,
+		args.entityType,
+		args.entityType
+	] : [];
+	return { tags: (await db.query(unionDistinctQueries([
+		buildSelect("span_events"),
+		buildSelect("metric_events"),
+		buildSelect("log_events")
+	], "tag"), params)).map((r) => r.tag) };
+}
+//#endregion
+//#region src/storage/domains/observability/filters.ts
+function buildJsonPath(key) {
+	try {
+		return `$.${parseFieldKey(key)}`;
+	} catch {
+		return `$."${key.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+	}
+}
+function normalizeJsonFilterValue(value) {
+	if (value === void 0) return null;
+	if (typeof value === "string") return value;
+	return JSON.stringify(value) ?? null;
+}
+function sanitizeColumn(column) {
+	return parseFieldKey(column);
+}
+/**
+* Build a WHERE clause from a filter object.
+* Returns { clause, params } for parameterized queries.
+*/
+function buildWhereClause(filters, fieldMappings) {
+	if (!filters) return {
+		clause: "",
+		params: []
+	};
+	const conditions = [];
+	const params = [];
+	for (const [key, value] of Object.entries(filters)) {
+		if (value === void 0 || value === null) continue;
+		const column = sanitizeColumn(fieldMappings?.[key] ?? key);
+		if (key === "timestamp" || key === "startedAt" || key === "endedAt") {
+			const dateRange = value;
+			if (dateRange.start) {
+				const op = dateRange.startExclusive ? ">" : ">=";
+				conditions.push(`${column} ${op} ?`);
+				params.push(dateRange.start);
+			}
+			if (dateRange.end) {
+				const op = dateRange.endExclusive ? "<" : "<=";
+				conditions.push(`${column} ${op} ?`);
+				params.push(dateRange.end);
+			}
+			continue;
+		}
+		if (key === "labels") {
+			const labelsObj = value;
+			for (const [labelKey, labelValue] of Object.entries(labelsObj)) {
+				conditions.push(`json_extract_string(${column}, ?) = ?`);
+				params.push(buildJsonPath(labelKey), labelValue);
+			}
+			continue;
+		}
+		if (key === "tags") {
+			const tags = value;
+			for (const tag of tags) {
+				conditions.push(`list_contains(CAST(${column} AS VARCHAR[]), ?)`);
+				params.push(tag);
+			}
+			continue;
+		}
+		if (key === "status") {
+			const status = value;
+			if (status === "error") conditions.push(`error IS NOT NULL`);
+			else if (status === "running") conditions.push(`endedAt IS NULL AND error IS NULL`);
+			else if (status === "success") conditions.push(`endedAt IS NOT NULL AND error IS NULL`);
+			continue;
+		}
+		if (key === "hasChildError") continue;
+		if (key === "metadata" || key === "scope") {
+			const jsonObj = value;
+			for (const [jsonKey, jsonValue] of Object.entries(jsonObj)) {
+				const normalized = normalizeJsonFilterValue(jsonValue);
+				if (normalized === null) continue;
+				conditions.push(`json_extract_string(${column}, ?) = ?`);
+				params.push(buildJsonPath(jsonKey), normalized);
+			}
+			continue;
+		}
+		if (Array.isArray(value)) {
+			if (value.length === 0) continue;
+			const placeholders = value.map(() => "?").join(", ");
+			conditions.push(`${column} IN (${placeholders})`);
+			params.push(...value);
+			continue;
+		}
+		conditions.push(`${column} = ?`);
+		params.push(value);
+	}
+	return {
+		clause: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+		params
+	};
+}
+/**
+* Build an ORDER BY clause from orderBy config.
+*/
+function buildOrderByClause(orderBy) {
+	if (!orderBy) return "";
+	const dir = orderBy.direction.toUpperCase();
+	if (dir !== "ASC" && dir !== "DESC") throw new Error(`Invalid sort direction: ${orderBy.direction}`);
+	return `ORDER BY ${parseFieldKey(orderBy.field)} ${dir}`;
+}
+/**
+* Build a LIMIT/OFFSET clause from pagination config.
+*/
+function buildPaginationClause(pagination) {
+	if (!pagination) return {
+		clause: "",
+		params: []
+	};
+	if (!Number.isInteger(pagination.page) || pagination.page < 0) throw new Error(`Invalid page: ${pagination.page}`);
+	if (!Number.isInteger(pagination.perPage) || pagination.perPage <= 0) throw new Error(`Invalid perPage: ${pagination.perPage}`);
+	const offset = pagination.page * pagination.perPage;
+	return {
+		clause: `LIMIT ? OFFSET ?`,
+		params: [pagination.perPage, offset]
+	};
+}
+//#endregion
+//#region src/storage/domains/observability/helpers.ts
+/** Shorthand for {@link DuckDBConnection.sqlValue}. */
+const v = DuckDBConnection.sqlValue;
+/** Serialize a value to JSON then SQL-escape it, or return 'NULL'. */
+function jsonV(val) {
+	if (val === null || val === void 0) return "NULL";
+	return DuckDBConnection.sqlValue(JSON.stringify(val));
+}
+/** Coerce a value to a Date. Throws if value is nullish. */
+function toDate(val) {
+	if (val === null || val === void 0) throw new Error("Expected date value but received null/undefined");
+	const date = val instanceof Date ? val : new Date(String(val));
+	if (Number.isNaN(date.getTime())) throw new Error("Expected valid date but received invalid date");
+	return date;
+}
+/** Coerce a value to a Date, returning null for nullish values. */
+function toDateOrNull(val) {
+	if (val === null || val === void 0) return null;
+	return val instanceof Date ? val : new Date(String(val));
+}
+/** Parse a JSON string, returning the original value if parsing fails. */
+function parseJson(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string") try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+	return value;
+}
+/** Parse a JSON string and return the result only if it is an array. */
+function parseJsonArray(value) {
+	if (value === null || value === void 0) return null;
+	const parsed = parseJson(value);
+	return Array.isArray(parsed) ? parsed : null;
+}
+//#endregion
+//#region src/storage/domains/observability/polling.ts
+const OBSERVABILITY_DELTA_POLLING_FEATURE = "observability-delta-polling";
+function deltaPollingFeatureEnabled() {
+	return coreFeatures.has(OBSERVABILITY_DELTA_POLLING_FEATURE);
+}
+function assertDeltaPollingEnabled() {
+	if (deltaPollingFeatureEnabled()) return;
+	throw new MastraError({
+		id: "OBSERVABILITY_DELTA_POLLING_NOT_SUPPORTED",
+		domain: ErrorDomain.MASTRA_OBSERVABILITY,
+		category: ErrorCategory.SYSTEM,
+		text: "This storage provider does not support observability delta polling"
+	});
+}
+function encodeDeltaCursor(value) {
+	return String(value ?? 0);
+}
+function validateCursorId(cursor) {
+	if (!/^\d+$/.test(cursor)) throw new MastraError({
+		id: "OBSERVABILITY_INVALID_DELTA_CURSOR",
+		domain: ErrorDomain.MASTRA_OBSERVABILITY,
+		category: ErrorCategory.USER,
+		text: "Invalid observability delta cursor"
+	});
+	return cursor;
+}
+function extendWhereClause(baseClause, extraConditions) {
+	const conditions = extraConditions.filter(Boolean);
+	if (conditions.length === 0) return baseClause;
+	if (!baseClause) return `WHERE ${conditions.join(" AND ")}`;
+	return `${baseClause} AND ${conditions.join(" AND ")}`;
+}
+//#endregion
+//#region src/storage/domains/observability/feedback.ts
+const FEEDBACK_GROUP_BY_COLUMNS = /* @__PURE__ */ new Set([
+	"timestamp",
+	"traceId",
+	"spanId",
+	"experimentId",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"parentEntityVersionId",
+	"parentEntityType",
+	"parentEntityId",
+	"parentEntityName",
+	"rootEntityVersionId",
+	"rootEntityType",
+	"rootEntityId",
+	"rootEntityName",
+	"userId",
+	"organizationId",
+	"resourceId",
+	"runId",
+	"sessionId",
+	"threadId",
+	"requestId",
+	"environment",
+	"executionSource",
+	"serviceName",
+	"feedbackUserId",
+	"sourceId",
+	"feedbackSource",
+	"feedbackType",
+	"value",
+	"comment"
+]);
+function getAggregationSql$2(aggregation, measure = "TRY_CAST(value AS DOUBLE)") {
+	switch (aggregation) {
+		case "sum": return `SUM(${measure})`;
+		case "avg": return `AVG(${measure})`;
+		case "min": return `MIN(${measure})`;
+		case "max": return `MAX(${measure})`;
+		case "count": return `CAST(COUNT(${measure}) AS DOUBLE)`;
+		case "last": return `arg_max(${measure}, timestamp)`;
+		default: return `SUM(${measure})`;
+	}
+}
+function getIntervalSql$2(interval) {
+	switch (interval) {
+		case "1m": return "1 minute";
+		case "5m": return "5 minutes";
+		case "15m": return "15 minutes";
+		case "1h": return "1 hour";
+		case "1d": return "1 day";
+		default: return "1 hour";
+	}
+}
+function getValidatedPercentiles$1(percentiles) {
+	if (!Array.isArray(percentiles) || percentiles.length === 0) throw new Error("Percentiles must include at least one value between 0 and 1.");
+	return percentiles.map((percentile) => {
+		if (!Number.isFinite(percentile) || percentile < 0 || percentile > 1) throw new Error("Percentiles must be finite numbers between 0 and 1.");
+		return percentile;
+	});
+}
+function buildFeedbackWhereClause(args, includeNumericGuard = false) {
+	const conditions = ["feedbackType = ?"];
+	const params = [args.feedbackType];
+	if (args.feedbackSource !== void 0) {
+		conditions.push("feedbackSource = ?");
+		params.push(args.feedbackSource);
+	}
+	const { clause: filterClause, params: filterParams } = buildWhereClause(args.filters, { source: "feedbackSource" });
+	if (filterClause) {
+		conditions.push(filterClause.replace("WHERE ", ""));
+		params.push(...filterParams);
+	}
+	if (includeNumericGuard) conditions.push("TRY_CAST(value AS DOUBLE) IS NOT NULL");
+	return {
+		clause: `WHERE ${conditions.join(" AND ")}`,
+		params
+	};
+}
+function resolveFeedbackGroupBy(groupBy) {
+	return groupBy.map((key, index) => {
+		const column = parseFieldKey(key);
+		if (!FEEDBACK_GROUP_BY_COLUMNS.has(column)) throw new Error(`Invalid groupBy column(s): ${key}`);
+		const alias = `group_by_${index}`;
+		return {
+			key,
+			selectSql: `${column} AS ${alias}`,
+			groupSql: alias
+		};
+	});
+}
+function toSeriesName$1(values) {
+	return values.map((value) => value === null || value === void 0 ? "" : String(value)).join("|");
+}
+function rowToFeedbackRecord(row) {
+	const rawValue = row.value;
+	let value = rawValue;
+	const numValue = Number(rawValue);
+	if (!isNaN(numValue)) value = numValue;
+	return {
+		feedbackId: row.feedbackId,
+		timestamp: toDate(row.timestamp),
+		traceId: row.traceId ?? null,
+		spanId: row.spanId ?? null,
+		experimentId: row.experimentId ?? null,
+		entityType: row.entityType ?? null,
+		entityId: row.entityId ?? null,
+		entityName: row.entityName ?? null,
+		entityVersionId: row.entityVersionId ?? null,
+		parentEntityVersionId: row.parentEntityVersionId ?? null,
+		parentEntityType: row.parentEntityType ?? null,
+		parentEntityId: row.parentEntityId ?? null,
+		parentEntityName: row.parentEntityName ?? null,
+		rootEntityVersionId: row.rootEntityVersionId ?? null,
+		rootEntityType: row.rootEntityType ?? null,
+		rootEntityId: row.rootEntityId ?? null,
+		rootEntityName: row.rootEntityName ?? null,
+		userId: row.userId ?? null,
+		organizationId: row.organizationId ?? null,
+		resourceId: row.resourceId ?? null,
+		runId: row.runId ?? null,
+		sessionId: row.sessionId ?? null,
+		threadId: row.threadId ?? null,
+		requestId: row.requestId ?? null,
+		environment: row.environment ?? null,
+		executionSource: row.executionSource ?? null,
+		serviceName: row.serviceName ?? null,
+		feedbackUserId: row.feedbackUserId ?? null,
+		sourceId: row.sourceId ?? null,
+		source: row.feedbackSource,
+		feedbackSource: row.feedbackSource,
+		feedbackType: row.feedbackType,
+		value,
+		comment: row.comment ?? null,
+		tags: parseJsonArray(row.tags),
+		metadata: parseJson(row.metadata),
+		scope: parseJson(row.scope)
+	};
+}
+function getComparisonDateRange$1(comparePeriod, timestamp) {
+	if (!timestamp.start || !timestamp.end) return null;
+	const duration = timestamp.end.getTime() - timestamp.start.getTime();
+	switch (comparePeriod) {
+		case "previous_period": return {
+			start: new Date(timestamp.start.getTime() - duration),
+			end: new Date(timestamp.end.getTime() - duration),
+			startExclusive: timestamp.startExclusive,
+			endExclusive: timestamp.endExclusive
+		};
+		case "previous_day": return {
+			start: /* @__PURE__ */ new Date(timestamp.start.getTime() - 864e5),
+			end: /* @__PURE__ */ new Date(timestamp.end.getTime() - 864e5),
+			startExclusive: timestamp.startExclusive,
+			endExclusive: timestamp.endExclusive
+		};
+		case "previous_week": return {
+			start: /* @__PURE__ */ new Date(timestamp.start.getTime() - 6048e5),
+			end: /* @__PURE__ */ new Date(timestamp.end.getTime() - 6048e5),
+			startExclusive: timestamp.startExclusive,
+			endExclusive: timestamp.endExclusive
+		};
+	}
+}
+/** Insert a single feedback event. */
+async function createFeedback(db, args) {
+	const f = args.feedback;
+	const feedbackSource = f.feedbackSource ?? f.source ?? "";
+	const feedbackUserId = f.feedbackUserId ?? f.userId ?? null;
+	await db.execute(`INSERT INTO feedback_events (
+      feedbackId, timestamp, cursorId, traceId, spanId, experimentId,
+      entityType, entityId, entityName, entityVersionId, parentEntityVersionId, parentEntityType, parentEntityId, parentEntityName, rootEntityVersionId, rootEntityType, rootEntityId, rootEntityName,
+      userId, organizationId, resourceId, runId, sessionId, threadId, requestId, environment, executionSource, serviceName,
+      feedbackUserId, sourceId, feedbackSource, feedbackType, value, comment, tags, metadata, scope
+    )
+     VALUES (${[
+		v(f.feedbackId),
+		v(f.timestamp),
+		"nextval('feedback_events_cursor_id_seq')",
+		v(f.traceId),
+		v(f.spanId ?? null),
+		v(f.experimentId ?? null),
+		v(f.entityType ?? null),
+		v(f.entityId ?? null),
+		v(f.entityName ?? null),
+		v(f.entityVersionId ?? null),
+		v(f.parentEntityVersionId ?? null),
+		v(f.parentEntityType ?? null),
+		v(f.parentEntityId ?? null),
+		v(f.parentEntityName ?? null),
+		v(f.rootEntityVersionId ?? null),
+		v(f.rootEntityType ?? null),
+		v(f.rootEntityId ?? null),
+		v(f.rootEntityName ?? null),
+		v(f.userId ?? null),
+		v(f.organizationId ?? null),
+		v(f.resourceId ?? null),
+		v(f.runId ?? null),
+		v(f.sessionId ?? null),
+		v(f.threadId ?? null),
+		v(f.requestId ?? null),
+		v(f.environment ?? null),
+		v(f.executionSource ?? null),
+		v(f.serviceName ?? null),
+		v(feedbackUserId),
+		v(f.sourceId ?? null),
+		v(feedbackSource),
+		v(f.feedbackType),
+		v(String(f.value)),
+		v(f.comment ?? null),
+		jsonV(f.tags ?? null),
+		jsonV(f.metadata),
+		jsonV(f.scope ?? null)
+	].join(", ")})
+     ON CONFLICT DO NOTHING`);
+}
+/** Insert multiple feedback events in a single statement. */
+async function batchCreateFeedback(db, args) {
+	if (args.feedbacks.length === 0) return;
+	const tuples = args.feedbacks.map((f) => {
+		const legacyFeedback = f;
+		const feedbackSource = legacyFeedback.feedbackSource ?? legacyFeedback.source ?? "";
+		const feedbackUserId = legacyFeedback.feedbackUserId ?? legacyFeedback.userId ?? null;
+		return `(${[
+			v(legacyFeedback.feedbackId),
+			v(legacyFeedback.timestamp),
+			"nextval('feedback_events_cursor_id_seq')",
+			v(legacyFeedback.traceId),
+			v(legacyFeedback.spanId ?? null),
+			v(legacyFeedback.experimentId ?? null),
+			v(legacyFeedback.entityType ?? null),
+			v(legacyFeedback.entityId ?? null),
+			v(legacyFeedback.entityName ?? null),
+			v(legacyFeedback.entityVersionId ?? null),
+			v(legacyFeedback.parentEntityVersionId ?? null),
+			v(legacyFeedback.parentEntityType ?? null),
+			v(legacyFeedback.parentEntityId ?? null),
+			v(legacyFeedback.parentEntityName ?? null),
+			v(legacyFeedback.rootEntityVersionId ?? null),
+			v(legacyFeedback.rootEntityType ?? null),
+			v(legacyFeedback.rootEntityId ?? null),
+			v(legacyFeedback.rootEntityName ?? null),
+			v(legacyFeedback.userId ?? null),
+			v(legacyFeedback.organizationId ?? null),
+			v(legacyFeedback.resourceId ?? null),
+			v(legacyFeedback.runId ?? null),
+			v(legacyFeedback.sessionId ?? null),
+			v(legacyFeedback.threadId ?? null),
+			v(legacyFeedback.requestId ?? null),
+			v(legacyFeedback.environment ?? null),
+			v(legacyFeedback.executionSource ?? null),
+			v(legacyFeedback.serviceName ?? null),
+			v(feedbackUserId),
+			v(legacyFeedback.sourceId ?? null),
+			v(feedbackSource),
+			v(legacyFeedback.feedbackType),
+			v(String(legacyFeedback.value)),
+			v(legacyFeedback.comment ?? null),
+			jsonV(legacyFeedback.tags ?? null),
+			jsonV(legacyFeedback.metadata),
+			jsonV(legacyFeedback.scope ?? null)
+		].join(", ")})`;
+	});
+	await db.execute(`INSERT INTO feedback_events (
+      feedbackId, timestamp, cursorId, traceId, spanId, experimentId,
+      entityType, entityId, entityName, entityVersionId, parentEntityVersionId, parentEntityType, parentEntityId, parentEntityName, rootEntityVersionId, rootEntityType, rootEntityId, rootEntityName,
+      userId, organizationId, resourceId, runId, sessionId, threadId, requestId, environment, executionSource, serviceName,
+      feedbackUserId, sourceId, feedbackSource, feedbackType, value, comment, tags, metadata, scope
+    )
+     VALUES ${tuples.join(",\n       ")}
+     ON CONFLICT DO NOTHING`);
+}
+/** Query feedback events with filtering, ordering, and pagination. */
+async function listFeedback(db, args) {
+	const { mode, filters, pagination, orderBy, after, limit } = listFeedbackArgsSchema.parse(args);
+	const page = Number(pagination.page);
+	const perPage = Number(pagination.perPage);
+	const { clause: filterClause, params: filterParams } = buildWhereClause(filters, { source: "feedbackSource" });
+	if (mode === "delta") {
+		assertDeltaPollingEnabled();
+		const streamHeadCursor = await getStreamHeadCursor$3(db);
+		if (after === void 0) return {
+			feedback: [],
+			delta: {
+				limit,
+				hasMore: false
+			},
+			deltaCursor: streamHeadCursor
+		};
+		const afterCursorId = validateCursorId(after);
+		const deltaWhereClause = extendWhereClause(filterClause, ["cursorId IS NOT NULL", `cursorId > CAST(? AS BIGINT)`]);
+		const rows = await db.query(`SELECT * FROM feedback_events ${deltaWhereClause} ORDER BY cursorId ASC LIMIT ?`, [
+			...filterParams,
+			afterCursorId,
+			limit + 1
+		]);
+		const visibleRows = rows.slice(0, limit).map((row) => ({
+			cursorId: row.cursorId,
+			feedback: rowToFeedbackRecord(row)
+		}));
+		return {
+			feedback: visibleRows.map((row) => row.feedback),
+			delta: {
+				limit,
+				hasMore: rows.length > limit
+			},
+			deltaCursor: visibleRows.length > 0 ? encodeDeltaCursor(visibleRows[visibleRows.length - 1]?.cursorId) : streamHeadCursor
+		};
+	}
+	const orderByClause = buildOrderByClause(orderBy);
+	const { clause: paginationClause, params: paginationParams } = buildPaginationClause({
+		page,
+		perPage
+	});
+	const currentDeltaCursor = deltaPollingFeatureEnabled() ? await getDeltaCursor$3(db, filterClause, filterParams) : void 0;
+	const countResult = await db.query(`SELECT COUNT(*) as total FROM feedback_events ${filterClause}`, filterParams);
+	const total = Number(countResult[0]?.total ?? 0);
+	const rows = await db.query(`SELECT * FROM feedback_events ${filterClause} ${orderByClause} ${paginationClause}`, [...filterParams, ...paginationParams]);
+	return {
+		pagination: {
+			total,
+			page,
+			perPage,
+			hasMore: (page + 1) * perPage < total
+		},
+		feedback: rows.map((row) => rowToFeedbackRecord(row)),
+		...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+	};
+}
+async function getDeltaCursor$3(db, filterClause, filterParams) {
+	const cursorId = (await db.query(`SELECT max(cursorId) AS cursorId FROM feedback_events ${filterClause}`, filterParams))[0]?.cursorId;
+	if (cursorId !== null && cursorId !== void 0) return encodeDeltaCursor(cursorId);
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM feedback_events`))[0]?.cursorId);
+}
+async function getStreamHeadCursor$3(db) {
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM feedback_events`))[0]?.cursorId);
+}
+async function getFeedbackAggregate(db, args) {
+	const aggSql = getAggregationSql$2(args.aggregation);
+	const { clause, params } = buildFeedbackWhereClause(args, true);
+	const rows = await db.query(`SELECT ${aggSql} AS value FROM feedback_events ${clause}`, params);
+	const value = rows[0]?.value === null || rows[0]?.value === void 0 ? null : Number(rows[0]?.value);
+	if (args.comparePeriod && args.filters?.timestamp) {
+		const previousTimestamp = getComparisonDateRange$1(args.comparePeriod, args.filters.timestamp);
+		if (previousTimestamp) {
+			const previousWhere = buildFeedbackWhereClause({
+				...args,
+				filters: {
+					...args.filters ?? {},
+					timestamp: previousTimestamp
+				}
+			}, true);
+			const prevRows = await db.query(`SELECT ${aggSql} AS value FROM feedback_events ${previousWhere.clause}`, previousWhere.params);
+			const previousValue = prevRows[0]?.value === null || prevRows[0]?.value === void 0 ? null : Number(prevRows[0]?.value);
+			let changePercent = null;
+			if (previousValue !== null && previousValue !== 0 && value !== null) changePercent = (value - previousValue) / Math.abs(previousValue) * 100;
+			return {
+				value,
+				previousValue,
+				changePercent
+			};
+		}
+	}
+	return { value };
+}
+async function getFeedbackBreakdown(db, args) {
+	const aggSql = getAggregationSql$2(args.aggregation);
+	const { clause, params } = buildFeedbackWhereClause(args, true);
+	const resolvedGroupBy = resolveFeedbackGroupBy(args.groupBy);
+	const sql = `SELECT ${resolvedGroupBy.map((entry) => entry.selectSql).join(", ")}, ${aggSql} AS value FROM feedback_events ${clause} GROUP BY ${resolvedGroupBy.map((entry) => entry.groupSql).join(", ")} ORDER BY value DESC`;
+	return { groups: (await db.query(sql, params)).map((row) => ({
+		dimensions: Object.fromEntries(resolvedGroupBy.map((entry, index) => {
+			const value = row[`group_by_${index}`];
+			return [entry.key, value === null || value === void 0 ? null : String(value)];
+		})),
+		value: Number(row.value ?? 0)
+	})) };
+}
+async function getFeedbackTimeSeries(db, args) {
+	const aggSql = getAggregationSql$2(args.aggregation);
+	const intervalSql = getIntervalSql$2(args.interval);
+	const { clause, params } = buildFeedbackWhereClause(args, true);
+	if (args.groupBy && args.groupBy.length > 0) {
+		const resolvedGroupBy = resolveFeedbackGroupBy(args.groupBy);
+		const sql = `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${resolvedGroupBy.map((entry) => entry.selectSql).join(", ")},
+             ${aggSql} AS value
+      FROM feedback_events ${clause}
+      GROUP BY bucket, ${resolvedGroupBy.map((entry) => entry.groupSql).join(", ")}
+      ORDER BY bucket
+    `;
+		const rows = await db.query(sql, params);
+		const seriesMap = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const groupValues = resolvedGroupBy.map((_, index) => row[`group_by_${index}`]);
+			const key = JSON.stringify(groupValues);
+			if (!seriesMap.has(key)) seriesMap.set(key, {
+				name: toSeriesName$1(groupValues),
+				points: []
+			});
+			seriesMap.get(key).points.push({
+				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+				value: Number(row.value ?? 0)
+			});
+		}
+		return { series: Array.from(seriesMap.values()) };
+	}
+	const rows = await db.query(`
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${aggSql} AS value
+      FROM feedback_events ${clause}
+      GROUP BY bucket
+      ORDER BY bucket
+    `, params);
+	return { series: [{
+		name: args.feedbackSource ? `${args.feedbackType}|${args.feedbackSource}` : args.feedbackType,
+		points: rows.map((row) => ({
+			timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+			value: Number(row.value ?? 0)
+		}))
+	}] };
+}
+async function getFeedbackPercentiles(db, args) {
+	const intervalSql = getIntervalSql$2(args.interval);
+	const { clause, params } = buildFeedbackWhereClause(args, true);
+	const percentiles = getValidatedPercentiles$1(args.percentiles);
+	const series = [];
+	for (const percentile of percentiles) {
+		const rows = await db.query(`
+        SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+               percentile_cont(${percentile}) WITHIN GROUP (ORDER BY TRY_CAST(value AS DOUBLE)) AS pvalue
+        FROM feedback_events ${clause}
+        GROUP BY bucket
+        ORDER BY bucket
+      `, params);
+		series.push({
+			percentile,
+			points: rows.map((row) => ({
+				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+				value: Number(row.pvalue ?? 0)
+			}))
+		});
+	}
+	return { series };
+}
+//#endregion
+//#region src/storage/domains/observability/logs.ts
+const COLUMNS_SQL$1 = [
+	"logId",
+	"timestamp",
+	"cursorId",
+	"level",
+	"message",
+	"data",
+	"traceId",
+	"spanId",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"parentEntityVersionId",
+	"parentEntityType",
+	"parentEntityId",
+	"parentEntityName",
+	"rootEntityVersionId",
+	"rootEntityType",
+	"rootEntityId",
+	"rootEntityName",
+	"userId",
+	"organizationId",
+	"resourceId",
+	"runId",
+	"sessionId",
+	"threadId",
+	"requestId",
+	"environment",
+	"executionSource",
+	"serviceName",
+	"experimentId",
+	"tags",
+	"metadata",
+	"scope"
+].join(", ");
+function rowToLogRecord(row) {
+	return {
+		logId: row.logId,
+		timestamp: toDate(row.timestamp),
+		level: row.level,
+		message: row.message,
+		data: parseJson(row.data),
+		traceId: row.traceId ?? null,
+		spanId: row.spanId ?? null,
+		entityType: row.entityType ?? null,
+		entityId: row.entityId ?? null,
+		entityName: row.entityName ?? null,
+		entityVersionId: row.entityVersionId ?? null,
+		parentEntityVersionId: row.parentEntityVersionId ?? null,
+		parentEntityType: row.parentEntityType ?? null,
+		parentEntityId: row.parentEntityId ?? null,
+		parentEntityName: row.parentEntityName ?? null,
+		rootEntityVersionId: row.rootEntityVersionId ?? null,
+		rootEntityType: row.rootEntityType ?? null,
+		rootEntityId: row.rootEntityId ?? null,
+		rootEntityName: row.rootEntityName ?? null,
+		userId: row.userId ?? null,
+		organizationId: row.organizationId ?? null,
+		resourceId: row.resourceId ?? null,
+		runId: row.runId ?? null,
+		sessionId: row.sessionId ?? null,
+		threadId: row.threadId ?? null,
+		requestId: row.requestId ?? null,
+		environment: row.environment ?? null,
+		executionSource: row.executionSource ?? null,
+		serviceName: row.serviceName ?? null,
+		experimentId: row.experimentId ?? null,
+		tags: parseJsonArray(row.tags),
+		metadata: parseJson(row.metadata),
+		scope: parseJson(row.scope)
+	};
+}
+/** Insert multiple log events in a single statement. */
+async function batchCreateLogs(db, args) {
+	if (args.logs.length === 0) return;
+	const tuples = args.logs.map((log) => {
+		return `(${[
+			v(log.logId),
+			v(log.timestamp),
+			"nextval('log_events_cursor_id_seq')",
+			v(log.level),
+			v(log.message),
+			jsonV(log.data),
+			v(log.traceId ?? null),
+			v(log.spanId ?? null),
+			v(log.entityType ?? null),
+			v(log.entityId ?? null),
+			v(log.entityName ?? null),
+			v(log.entityVersionId ?? null),
+			v(log.parentEntityVersionId ?? null),
+			v(log.parentEntityType ?? null),
+			v(log.parentEntityId ?? null),
+			v(log.parentEntityName ?? null),
+			v(log.rootEntityVersionId ?? null),
+			v(log.rootEntityType ?? null),
+			v(log.rootEntityId ?? null),
+			v(log.rootEntityName ?? null),
+			v(log.userId ?? null),
+			v(log.organizationId ?? null),
+			v(log.resourceId ?? null),
+			v(log.runId ?? null),
+			v(log.sessionId ?? null),
+			v(log.threadId ?? null),
+			v(log.requestId ?? null),
+			v(log.environment ?? null),
+			v(log.executionSource ?? null),
+			v(log.serviceName ?? null),
+			v(log.experimentId ?? null),
+			jsonV(log.tags),
+			jsonV(log.metadata),
+			jsonV(log.scope)
+		].join(", ")})`;
+	});
+	await db.execute(`INSERT INTO log_events (${COLUMNS_SQL$1}) VALUES ${tuples.join(",\n")} ON CONFLICT DO NOTHING`);
+}
+/** Query log events with filtering, ordering, and pagination. */
+async function listLogs(db, args) {
+	const { mode, filters, pagination, orderBy, after, limit } = listLogsArgsSchema.parse(args);
+	const filterRecord = filters;
+	const page = Number(pagination.page);
+	const perPage = Number(pagination.perPage);
+	const { clause: filterClause, params: filterParams } = buildWhereClause(filterRecord);
+	if (mode === "delta") {
+		assertDeltaPollingEnabled();
+		const streamHeadCursor = await getStreamHeadCursor$2(db);
+		if (after === void 0) return {
+			logs: [],
+			delta: {
+				limit,
+				hasMore: false
+			},
+			deltaCursor: streamHeadCursor
+		};
+		const afterCursorId = validateCursorId(after);
+		const deltaWhereClause = extendWhereClause(filterClause, ["cursorId IS NOT NULL", `cursorId > CAST(? AS BIGINT)`]);
+		const rows = await db.query(`SELECT * FROM log_events ${deltaWhereClause} ORDER BY cursorId ASC LIMIT ?`, [
+			...filterParams,
+			afterCursorId,
+			limit + 1
+		]);
+		const visibleRows = rows.slice(0, limit).map((row) => ({
+			cursorId: row.cursorId,
+			log: rowToLogRecord(row)
+		}));
+		return {
+			logs: visibleRows.map((row) => row.log),
+			delta: {
+				limit,
+				hasMore: rows.length > limit
+			},
+			deltaCursor: visibleRows.length > 0 ? encodeDeltaCursor(visibleRows[visibleRows.length - 1]?.cursorId) : streamHeadCursor
+		};
+	}
+	const orderByClause = buildOrderByClause(orderBy);
+	const { clause: paginationClause, params: paginationParams } = buildPaginationClause({
+		page,
+		perPage
+	});
+	const currentDeltaCursor = deltaPollingFeatureEnabled() ? await getDeltaCursor$2(db, filterClause, filterParams) : void 0;
+	const countResult = await db.query(`SELECT COUNT(*) as total FROM log_events ${filterClause}`, filterParams);
+	const total = Number(countResult[0]?.total ?? 0);
+	const logs = (await db.query(`SELECT * FROM log_events ${filterClause} ${orderByClause} ${paginationClause}`, [...filterParams, ...paginationParams])).map((row) => rowToLogRecord(row));
+	return {
+		pagination: {
+			total,
+			page,
+			perPage,
+			hasMore: (page + 1) * perPage < total
+		},
+		logs,
+		...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+	};
+}
+async function getDeltaCursor$2(db, filterClause, filterParams) {
+	const cursorId = (await db.query(`SELECT max(cursorId) AS cursorId FROM log_events ${filterClause}`, filterParams))[0]?.cursorId;
+	if (cursorId !== null && cursorId !== void 0) return encodeDeltaCursor(cursorId);
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM log_events`))[0]?.cursorId);
+}
+async function getStreamHeadCursor$2(db) {
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM log_events`))[0]?.cursorId);
+}
+//#endregion
+//#region src/storage/domains/observability/metrics.ts
+const METRIC_FILTER_FIELD_MAPPINGS = { traceIds: "traceId" };
+function resolveDistinctColumnSql(distinctColumn) {
+	if (!distinctColumn) throw new Error(`count_distinct aggregation requires a 'distinctColumn' argument`);
+	if (!METRIC_DISTINCT_COLUMNS.includes(distinctColumn)) throw new Error(`Invalid distinctColumn: ${distinctColumn}`);
+	return parseFieldKey(distinctColumn);
+}
+function getAggregationSql$1(aggregation, measure = "value", distinctColumn) {
+	switch (aggregation) {
+		case "sum": return `SUM(${measure})`;
+		case "avg": return `AVG(${measure})`;
+		case "min": return `MIN(${measure})`;
+		case "max": return `MAX(${measure})`;
+		case "count": return `CAST(COUNT(${measure}) AS DOUBLE)`;
+		case "count_distinct": return `CAST(approx_count_distinct(${resolveDistinctColumnSql(distinctColumn)}) AS DOUBLE)`;
+		case "last": return `arg_max(${measure}, timestamp)`;
+		default: return `SUM(${measure})`;
+	}
+}
+function getIntervalSql$1(interval) {
+	switch (interval) {
+		case "1m": return "1 minute";
+		case "5m": return "5 minutes";
+		case "15m": return "15 minutes";
+		case "1h": return "1 hour";
+		case "1d": return "1 day";
+		default: return "1 hour";
+	}
+}
+function buildMetricNameFilter(name) {
+	if (Array.isArray(name)) return {
+		clause: `name IN (${name.map(() => "?").join(", ")})`,
+		params: name
+	};
+	return {
+		clause: `name = ?`,
+		params: [name]
+	};
+}
+const METRIC_COLUMNS = [
+	"metricId",
+	"timestamp",
+	"cursorId",
+	"name",
+	"value",
+	"traceId",
+	"spanId",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"parentEntityVersionId",
+	"parentEntityType",
+	"parentEntityId",
+	"parentEntityName",
+	"rootEntityVersionId",
+	"rootEntityType",
+	"rootEntityId",
+	"rootEntityName",
+	"userId",
+	"organizationId",
+	"resourceId",
+	"runId",
+	"sessionId",
+	"threadId",
+	"requestId",
+	"environment",
+	"executionSource",
+	"serviceName",
+	"experimentId",
+	"provider",
+	"model",
+	"estimatedCost",
+	"costUnit",
+	"tags",
+	"labels",
+	"costMetadata",
+	"metadata",
+	"scope"
+];
+const METRIC_COLUMNS_SQL = METRIC_COLUMNS.join(", ");
+const METRIC_COLUMN_SET = new Set(METRIC_COLUMNS);
+const METRIC_LABEL_ONLY_GROUP_BY_EXCLUDED = /* @__PURE__ */ new Set([
+	"metadata",
+	"scope",
+	"costMetadata",
+	"tags"
+]);
+function buildGroupByAlias(index) {
+	return `group_by_${index}`;
+}
+function toSeriesDisplayValue(value) {
+	return value === null || value === void 0 ? "" : String(value);
+}
+function getCostSummarySelect(prefix = "") {
+	const ref = (column) => `${prefix}${column}`;
+	return [
+		`SUM(${ref("estimatedCost")}) FILTER (WHERE ${ref("estimatedCost")} IS NOT NULL) AS estimatedCost`,
+		`,`,
+		`CASE`,
+		`  WHEN COUNT(DISTINCT ${ref("costUnit")}) FILTER (WHERE ${ref("costUnit")} IS NOT NULL) = 1`,
+		`  THEN MIN(${ref("costUnit")}) FILTER (WHERE ${ref("costUnit")} IS NOT NULL)`,
+		`  ELSE NULL`,
+		`END AS costUnit`
+	].join(" ");
+}
+function normalizeCostSummaryRow(row) {
+	return {
+		estimatedCost: row.estimatedCost === null || row.estimatedCost === void 0 ? null : Number(row.estimatedCost),
+		costUnit: row.costUnit === null || row.costUnit === void 0 ? null : String(row.costUnit)
+	};
+}
+function buildCombinedWhereClause(nameClause, nameParams, filterClause, filterParams) {
+	const conditions = [nameClause];
+	const params = [...nameParams];
+	if (filterClause) {
+		conditions.push(filterClause.replace("WHERE ", ""));
+		params.push(...filterParams);
+	}
+	return {
+		clause: `WHERE ${conditions.join(" AND ")}`,
+		params
+	};
+}
+function resolveGroupBy(groupBy) {
+	return groupBy.map((key, index) => {
+		if (METRIC_COLUMN_SET.has(key)) {
+			const parsed = parseFieldKey(key);
+			if (METRIC_LABEL_ONLY_GROUP_BY_EXCLUDED.has(parsed)) throw new Error(`Invalid groupBy column(s): ${key}`);
+			return {
+				kind: "column",
+				key,
+				selectSql: `${parsed} AS "${key}"`,
+				groupSql: parsed,
+				resultKey: key
+			};
+		}
+		const labelExpr = `json_extract_string(labels, '${buildJsonPath(key).replace(/'/g, "''")}')`;
+		const alias = buildGroupByAlias(index);
+		return {
+			kind: "label",
+			key,
+			selectSql: `${labelExpr} AS ${alias}`,
+			groupSql: alias,
+			resultKey: alias
+		};
+	});
+}
+function rowToMetricRecord(row) {
+	return {
+		metricId: row.metricId,
+		timestamp: toDate(row.timestamp),
+		name: row.name,
+		value: Number(row.value),
+		traceId: row.traceId ?? null,
+		spanId: row.spanId ?? null,
+		entityType: row.entityType ?? null,
+		entityId: row.entityId ?? null,
+		entityName: row.entityName ?? null,
+		entityVersionId: row.entityVersionId ?? null,
+		parentEntityVersionId: row.parentEntityVersionId ?? null,
+		parentEntityType: row.parentEntityType ?? null,
+		parentEntityId: row.parentEntityId ?? null,
+		parentEntityName: row.parentEntityName ?? null,
+		rootEntityVersionId: row.rootEntityVersionId ?? null,
+		rootEntityType: row.rootEntityType ?? null,
+		rootEntityId: row.rootEntityId ?? null,
+		rootEntityName: row.rootEntityName ?? null,
+		userId: row.userId ?? null,
+		organizationId: row.organizationId ?? null,
+		resourceId: row.resourceId ?? null,
+		runId: row.runId ?? null,
+		sessionId: row.sessionId ?? null,
+		threadId: row.threadId ?? null,
+		requestId: row.requestId ?? null,
+		environment: row.environment ?? null,
+		executionSource: row.executionSource ?? null,
+		serviceName: row.serviceName ?? null,
+		experimentId: row.experimentId ?? null,
+		provider: row.provider ?? null,
+		model: row.model ?? null,
+		estimatedCost: row.estimatedCost === null || row.estimatedCost === void 0 ? null : Number(row.estimatedCost),
+		costUnit: row.costUnit ?? null,
+		costMetadata: parseJson(row.costMetadata),
+		tags: parseJsonArray(row.tags),
+		labels: parseJson(row.labels) ?? {},
+		metadata: parseJson(row.metadata),
+		scope: parseJson(row.scope)
+	};
+}
+/** Insert multiple metric events in a single statement. */
+async function batchCreateMetrics(db, args) {
+	if (args.metrics.length === 0) return;
+	const tuples = args.metrics.map((m) => {
+		return `(${[
+			v(m.metricId),
+			v(m.timestamp),
+			"nextval('metric_events_cursor_id_seq')",
+			v(m.name),
+			v(m.value),
+			v(m.traceId ?? null),
+			v(m.spanId ?? null),
+			v(m.entityType ?? null),
+			v(m.entityId ?? null),
+			v(m.entityName ?? null),
+			v(m.entityVersionId ?? null),
+			v(m.parentEntityVersionId ?? null),
+			v(m.parentEntityType ?? null),
+			v(m.parentEntityId ?? null),
+			v(m.parentEntityName ?? null),
+			v(m.rootEntityVersionId ?? null),
+			v(m.rootEntityType ?? null),
+			v(m.rootEntityId ?? null),
+			v(m.rootEntityName ?? null),
+			v(m.userId ?? null),
+			v(m.organizationId ?? null),
+			v(m.resourceId ?? null),
+			v(m.runId ?? null),
+			v(m.sessionId ?? null),
+			v(m.threadId ?? null),
+			v(m.requestId ?? null),
+			v(m.environment ?? null),
+			v(m.executionSource ?? null),
+			v(m.serviceName ?? null),
+			v(m.experimentId ?? null),
+			v(m.provider ?? null),
+			v(m.model ?? null),
+			v(m.estimatedCost ?? null),
+			v(m.costUnit ?? null),
+			jsonV(m.tags ?? null),
+			v(JSON.stringify(m.labels ?? {})),
+			jsonV(m.costMetadata ?? null),
+			jsonV(m.metadata ?? null),
+			jsonV(m.scope ?? null)
+		].join(", ")})`;
+	});
+	await db.execute(`INSERT INTO metric_events (${METRIC_COLUMNS_SQL}) VALUES ${tuples.join(",\n")} ON CONFLICT DO NOTHING`);
+}
+/** Query metric events with filtering, ordering, and pagination. */
+async function listMetrics(db, args) {
+	const { mode, filters, pagination, orderBy, after, limit } = listMetricsArgsSchema.parse(args);
+	const filterRecord = filters;
+	const page = Number(pagination.page);
+	const perPage = Number(pagination.perPage);
+	const { clause: filterClause, params: filterParams } = buildWhereClause(filterRecord, METRIC_FILTER_FIELD_MAPPINGS);
+	if (mode === "delta") {
+		assertDeltaPollingEnabled();
+		const streamHeadCursor = await getStreamHeadCursor$1(db);
+		if (after === void 0) return {
+			metrics: [],
+			delta: {
+				limit,
+				hasMore: false
+			},
+			deltaCursor: streamHeadCursor
+		};
+		const afterCursorId = validateCursorId(after);
+		const deltaWhereClause = extendWhereClause(filterClause, ["cursorId IS NOT NULL", `cursorId > CAST(? AS BIGINT)`]);
+		const rows = await db.query(`SELECT * FROM metric_events ${deltaWhereClause} ORDER BY cursorId ASC LIMIT ?`, [
+			...filterParams,
+			afterCursorId,
+			limit + 1
+		]);
+		const visibleRows = rows.slice(0, limit).map((row) => ({
+			cursorId: row.cursorId,
+			metric: rowToMetricRecord(row)
+		}));
+		return {
+			metrics: visibleRows.map((row) => row.metric),
+			delta: {
+				limit,
+				hasMore: rows.length > limit
+			},
+			deltaCursor: visibleRows.length > 0 ? encodeDeltaCursor(visibleRows[visibleRows.length - 1]?.cursorId) : streamHeadCursor
+		};
+	}
+	const orderByClause = buildOrderByClause(orderBy);
+	const { clause: paginationClause, params: paginationParams } = buildPaginationClause({
+		page,
+		perPage
+	});
+	const currentDeltaCursor = deltaPollingFeatureEnabled() ? await getDeltaCursor$1(db, filterClause, filterParams) : void 0;
+	const countResult = await db.query(`SELECT COUNT(*) AS total FROM metric_events ${filterClause}`, filterParams);
+	const total = Number(countResult[0]?.total ?? 0);
+	const rows = await db.query(`SELECT * FROM metric_events ${filterClause} ${orderByClause} ${paginationClause}`, [...filterParams, ...paginationParams]);
+	return {
+		pagination: {
+			total,
+			page,
+			perPage,
+			hasMore: (page + 1) * perPage < total
+		},
+		metrics: rows.map((row) => rowToMetricRecord(row)),
+		...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+	};
+}
+async function getDeltaCursor$1(db, filterClause, filterParams) {
+	const cursorId = (await db.query(`SELECT max(cursorId) AS cursorId FROM metric_events ${filterClause}`, filterParams))[0]?.cursorId;
+	if (cursorId !== null && cursorId !== void 0) return encodeDeltaCursor(cursorId);
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM metric_events`))[0]?.cursorId);
+}
+async function getStreamHeadCursor$1(db) {
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM metric_events`))[0]?.cursorId);
+}
+/** Compute an aggregate value (sum, avg, min, max, etc.) for a metric, with optional period comparison. */
+async function getMetricAggregate(db, args) {
+	const aggSql = getAggregationSql$1(args.aggregation, "value", args.distinctColumn);
+	const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
+	const { clause: filterClause, params: filterParams } = buildWhereClause(args.filters, METRIC_FILTER_FIELD_MAPPINGS);
+	const { clause: whereClause, params: allParams } = buildCombinedWhereClause(nameClause, nameParams, filterClause, filterParams);
+	const sql = `SELECT ${aggSql} AS value, ${getCostSummarySelect()} FROM metric_events ${whereClause}`;
+	const row = (await db.query(sql, allParams))[0] ?? {};
+	const value = row.value === null || row.value === void 0 ? null : Number(row.value);
+	const costSummary = normalizeCostSummaryRow(row);
+	if (args.comparePeriod && args.filters?.timestamp) {
+		const ts = args.filters.timestamp;
+		if (ts.start && ts.end) {
+			const duration = ts.end.getTime() - ts.start.getTime();
+			let prevStart;
+			let prevEnd;
+			switch (args.comparePeriod) {
+				case "previous_period":
+					prevStart = new Date(ts.start.getTime() - duration);
+					prevEnd = new Date(ts.end.getTime() - duration);
+					break;
+				case "previous_day":
+					prevStart = /* @__PURE__ */ new Date(ts.start.getTime() - 864e5);
+					prevEnd = /* @__PURE__ */ new Date(ts.end.getTime() - 864e5);
+					break;
+				case "previous_week":
+					prevStart = /* @__PURE__ */ new Date(ts.start.getTime() - 6048e5);
+					prevEnd = /* @__PURE__ */ new Date(ts.end.getTime() - 6048e5);
+					break;
+				default:
+					prevStart = new Date(ts.start.getTime() - duration);
+					prevEnd = new Date(ts.end.getTime() - duration);
+			}
+			const { clause: prevFilterClause, params: prevFilterParams } = buildWhereClause({
+				...args.filters ?? {},
+				timestamp: {
+					start: prevStart,
+					end: prevEnd,
+					startExclusive: ts.startExclusive,
+					endExclusive: ts.endExclusive
+				}
+			}, METRIC_FILTER_FIELD_MAPPINGS);
+			const { clause: prevWhereClause, params: prevParams } = buildCombinedWhereClause(nameClause, nameParams, prevFilterClause, prevFilterParams);
+			const prevSql = `SELECT ${aggSql} AS value, ${getCostSummarySelect()} FROM metric_events ${prevWhereClause}`;
+			const prevRow = (await db.query(prevSql, prevParams))[0] ?? {};
+			const previousValue = prevRow.value === null || prevRow.value === void 0 ? null : Number(prevRow.value);
+			const previousCostSummary = normalizeCostSummaryRow(prevRow);
+			let changePercent = null;
+			if (previousValue !== null && previousValue !== 0 && value !== null) changePercent = (value - previousValue) / Math.abs(previousValue) * 100;
+			let costChangePercent = null;
+			if (previousCostSummary.estimatedCost !== null && previousCostSummary.estimatedCost !== 0 && costSummary.estimatedCost !== null) costChangePercent = (costSummary.estimatedCost - previousCostSummary.estimatedCost) / Math.abs(previousCostSummary.estimatedCost) * 100;
+			return {
+				value,
+				estimatedCost: costSummary.estimatedCost,
+				costUnit: costSummary.costUnit,
+				previousValue,
+				previousEstimatedCost: previousCostSummary.estimatedCost,
+				changePercent,
+				costChangePercent
+			};
+		}
+	}
+	return {
+		value,
+		estimatedCost: costSummary.estimatedCost,
+		costUnit: costSummary.costUnit
+	};
+}
+/** Aggregate a metric grouped by one or more dimensions. */
+async function getMetricBreakdown(db, args) {
+	const aggSql = getAggregationSql$1(args.aggregation, "value", args.distinctColumn);
+	const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
+	const { clause: filterClause, params: filterParams } = buildWhereClause(args.filters, METRIC_FILTER_FIELD_MAPPINGS);
+	const { clause: whereClause, params: allParams } = buildCombinedWhereClause(nameClause, nameParams, filterClause, filterParams);
+	const resolvedGroupBy = resolveGroupBy(args.groupBy);
+	const selectGroupBy = resolvedGroupBy.map((entry) => entry.selectSql).join(", ");
+	const groupByCols = resolvedGroupBy.map((entry) => entry.groupSql).join(", ");
+	const orderDirection = args.orderDirection === "ASC" ? "ASC" : "DESC";
+	const limitClause = typeof args.limit === "number" ? `LIMIT ?` : "";
+	const limitParams = typeof args.limit === "number" ? [args.limit] : [];
+	const sql = `SELECT ${selectGroupBy}, ${aggSql} AS value, ${getCostSummarySelect()} FROM metric_events ${whereClause} GROUP BY ${groupByCols} ORDER BY value ${orderDirection} ${limitClause}`;
+	return { groups: (await db.query(sql, [...allParams, ...limitParams])).map((row) => {
+		const dimensions = {};
+		for (const entry of resolvedGroupBy) {
+			const value = row[entry.resultKey];
+			dimensions[entry.key] = value === null || value === void 0 ? null : String(value);
+		}
+		const costSummary = normalizeCostSummaryRow(row);
+		return {
+			dimensions,
+			value: Number(row.value ?? 0),
+			estimatedCost: costSummary.estimatedCost,
+			costUnit: costSummary.costUnit
+		};
+	}) };
+}
+/** Aggregate a metric into time-bucketed series, with optional group-by dimensions. */
+async function getMetricTimeSeries(db, args) {
+	const aggSql = getAggregationSql$1(args.aggregation, "value", args.distinctColumn);
+	const intervalSql = getIntervalSql$1(args.interval);
+	const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
+	const { clause: filterClause, params: filterParams } = buildWhereClause(args.filters, METRIC_FILTER_FIELD_MAPPINGS);
+	const { clause: whereClause, params: allParams } = buildCombinedWhereClause(nameClause, nameParams, filterClause, filterParams);
+	if (args.groupBy && args.groupBy.length > 0) {
+		const resolvedGroupBy = resolveGroupBy(args.groupBy);
+		const selectGroupBy = resolvedGroupBy.map((entry) => entry.selectSql).join(", ");
+		const groupByCols = resolvedGroupBy.map((entry) => entry.groupSql).join(", ");
+		const sql = `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${selectGroupBy},
+             ${aggSql} AS value,
+             ${getCostSummarySelect()}
+      FROM metric_events ${whereClause}
+      GROUP BY bucket, ${groupByCols}
+      ORDER BY bucket
+    `;
+		const rows = await db.query(sql, allParams);
+		const seriesMap = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const dimensionValues = resolvedGroupBy.map((entry) => row[entry.resultKey]);
+			const seriesKey = JSON.stringify(dimensionValues);
+			const name = dimensionValues.map(toSeriesDisplayValue).join("|");
+			const costSummary = normalizeCostSummaryRow(row);
+			if (!seriesMap.has(seriesKey)) seriesMap.set(seriesKey, {
+				name,
+				costUnits: /* @__PURE__ */ new Set(),
+				points: []
+			});
+			if (costSummary.costUnit) seriesMap.get(seriesKey).costUnits.add(costSummary.costUnit);
+			seriesMap.get(seriesKey).points.push({
+				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+				value: Number(row.value ?? 0),
+				estimatedCost: costSummary.estimatedCost
+			});
+		}
+		return { series: Array.from(seriesMap.values()).map((series) => ({
+			name: series.name,
+			costUnit: series.costUnits.size === 1 ? Array.from(series.costUnits)[0] : null,
+			points: series.points
+		})) };
+	}
+	const sql = `
+    SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+           ${aggSql} AS value,
+           ${getCostSummarySelect()}
+    FROM metric_events ${whereClause}
+    GROUP BY bucket
+    ORDER BY bucket
+  `;
+	const rows = await db.query(sql, allParams);
+	const metricName = Array.isArray(args.name) ? args.name.join(",") : args.name;
+	const overallCostUnits = new Set(rows.map((row) => row.costUnit).filter((value) => typeof value === "string"));
+	return { series: [{
+		name: metricName,
+		costUnit: overallCostUnits.size === 1 ? Array.from(overallCostUnits)[0] : null,
+		points: rows.map((row) => {
+			const costSummary = normalizeCostSummaryRow(row);
+			return {
+				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+				value: Number(row.value ?? 0),
+				estimatedCost: costSummary.estimatedCost
+			};
+		})
+	}] };
+}
+/** Compute percentile time series for a metric using `percentile_cont`. */
+async function getMetricPercentiles(db, args) {
+	const intervalSql = getIntervalSql$1(args.interval);
+	const { clause: filterClause, params: filterParams } = buildWhereClause(args.filters, METRIC_FILTER_FIELD_MAPPINGS);
+	const allConditions = [`name = ?`];
+	const allParams = [args.name];
+	if (filterClause) {
+		allConditions.push(filterClause.replace("WHERE ", ""));
+		allParams.push(...filterParams);
+	}
+	const whereClause = `WHERE ${allConditions.join(" AND ")}`;
+	const series = [];
+	for (const p of args.percentiles) {
+		const sql = `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             percentile_cont(${p}) WITHIN GROUP (ORDER BY value) AS pvalue
+      FROM metric_events ${whereClause}
+      GROUP BY bucket
+      ORDER BY bucket
+    `;
+		const rows = await db.query(sql, allParams);
+		series.push({
+			percentile: p,
+			points: rows.map((row) => ({
+				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+				value: Number(row.pvalue ?? 0)
+			}))
+		});
+	}
+	return { series };
+}
+/** Return distinct metric names, optionally filtered by prefix. */
+async function getMetricNames(db, args) {
+	const conditions = [];
+	const params = [];
+	if (args.prefix) {
+		conditions.push(`name LIKE ?`);
+		params.push(`${args.prefix}%`);
+	}
+	const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+	const limitClause = args.limit ? `LIMIT ?` : "";
+	if (args.limit) params.push(args.limit);
+	return { names: (await db.query(`SELECT DISTINCT name FROM metric_events ${whereClause} ORDER BY name ${limitClause}`, params)).map((r) => r.name) };
+}
+/** Return distinct label keys for a given metric name. */
+async function getMetricLabelKeys(db, args) {
+	return { keys: (await db.query(`SELECT DISTINCT unnest(json_keys(labels)) AS key FROM metric_events WHERE name = ? AND labels IS NOT NULL`, [args.metricName])).map((r) => r.key) };
+}
+/** Return distinct values for a specific label key on a metric. */
+async function getMetricLabelValues(db, args) {
+	const labelPath = buildJsonPath(args.labelKey);
+	const conditions = [`name = ?`, `json_extract_string(labels, ?) IS NOT NULL`];
+	const params = [args.metricName, labelPath];
+	if (args.prefix) {
+		conditions.push(`json_extract_string(labels, ?) LIKE ?`);
+		params.push(labelPath, `${args.prefix}%`);
+	}
+	const limitClause = args.limit ? `LIMIT ?` : "";
+	if (args.limit) params.push(args.limit);
+	return { values: (await db.query(`SELECT DISTINCT json_extract_string(labels, ?) AS val FROM metric_events WHERE ${conditions.join(" AND ")} ORDER BY val ${limitClause}`, [labelPath, ...params])).map((r) => r.val) };
+}
+//#endregion
+//#region src/storage/domains/observability/migration.ts
+const CURSOR_ID_TABLES = [
+	"span_events",
+	"metric_events",
+	"log_events",
+	"score_events",
+	"feedback_events"
+];
+/**
+* Drop any leftover `DEFAULT nextval(...)` on observability `cursorId` columns.
+*
+* A previous version of the migration set this default via
+* `ALTER COLUMN cursorId SET DEFAULT nextval(...)`. DuckDB WAL replay cannot
+* bind that function expression before the default database is attached, so
+* affected databases fail to reopen. Insert paths now write cursor IDs
+* explicitly, so the catalog default is unnecessary and should be removed.
+*
+* We query `information_schema` first and only emit the `ALTER` for tables that
+* actually carry the bad default; this avoids writing redundant SetDefault
+* entries to the WAL on every startup for healthy databases.
+*/
+async function dropLegacyCursorIdDefaults(db) {
+	const rows = await db.query(`SELECT table_name FROM information_schema.columns
+     WHERE column_name = 'cursorId'
+       AND column_default IS NOT NULL
+       AND table_name IN (${CURSOR_ID_TABLES.map((t) => `'${t}'`).join(", ")})`);
+	if (rows.length === 0) return;
+	await db.executeBatch(rows.map((row) => `ALTER TABLE ${row.table_name} ALTER COLUMN cursorId DROP DEFAULT`));
+}
+const SIGNAL_MIGRATIONS = [
+	{
+		table: "metric_events",
+		createDDL: METRIC_EVENTS_DDL,
+		idColumn: "metricId",
+		cursorSequenceDDL: METRIC_EVENTS_CURSOR_SEQUENCE_DDL
+	},
+	{
+		table: "log_events",
+		createDDL: LOG_EVENTS_DDL,
+		idColumn: "logId",
+		cursorSequenceDDL: LOG_EVENTS_CURSOR_SEQUENCE_DDL
+	},
+	{
+		table: "score_events",
+		createDDL: SCORE_EVENTS_DDL,
+		idColumn: "scoreId",
+		cursorSequenceDDL: SCORE_EVENTS_CURSOR_SEQUENCE_DDL
+	},
+	{
+		table: "feedback_events",
+		createDDL: FEEDBACK_EVENTS_DDL,
+		idColumn: "feedbackId",
+		cursorSequenceDDL: FEEDBACK_EVENTS_CURSOR_SEQUENCE_DDL
+	}
+];
+async function tableExists(db, table) {
+	return (await db.query(`SELECT table_name FROM information_schema.tables WHERE table_name = ?`, [table])).length > 0;
+}
+async function hasPrimaryKey(db, table) {
+	return (await db.query(`SELECT constraint_type FROM information_schema.table_constraints
+     WHERE table_name = ? AND constraint_type = 'PRIMARY KEY'`, [table])).length > 0;
+}
+async function getColumns(db, table) {
+	return (await db.query(`SELECT column_name FROM information_schema.columns WHERE table_name = ?`, [table])).map((r) => r.column_name);
+}
+function buildTemporaryTableDDL(createDDL, table, tempTable) {
+	return createDDL.replace(`CREATE TABLE IF NOT EXISTS ${table}`, `CREATE TABLE ${tempTable}`);
+}
+async function dropTableIfExists(db, table) {
+	if (await tableExists(db, table)) await db.execute(`DROP TABLE ${table}`);
+}
+function createMigrationError(args, error) {
+	return new MastraError({
+		id: createStorageErrorId("DUCKDB", "MIGRATE_SIGNAL_TABLES", "FAILED"),
+		domain: ErrorDomain.STORAGE,
+		category: ErrorCategory.THIRD_PARTY,
+		details: args
+	}, error);
+}
+async function checkSignalTablesMigrationStatus(db) {
+	const tables = [];
+	for (const { table, idColumn } of SIGNAL_MIGRATIONS) {
+		if (!await tableExists(db, table)) continue;
+		if (await hasPrimaryKey(db, table)) continue;
+		tables.push({
+			table,
+			idColumn
+		});
+	}
+	return {
+		needsMigration: tables.length > 0,
+		tables
+	};
+}
+/**
+* Migrate signal tables to a schema with PRIMARY KEY + NOT NULL on the signal ID
+* without dropping data. Copy-and-swap: create temp → INSERT…SELECT
+* (generating IDs) → rename old to backup → rename temp to live → drop backup.
+* The live table is only touched during the final swap step.
+*/
+async function migrateSignalTables(db, logger) {
+	for (const { table, createDDL, idColumn, cursorSequenceDDL } of SIGNAL_MIGRATIONS) {
+		if (!await tableExists(db, table)) continue;
+		if (await hasPrimaryKey(db, table)) continue;
+		logger?.info?.(`Migrating ${table} to schema with ${idColumn} PRIMARY KEY`);
+		const temp = `${table}_migrating_${Date.now()}`;
+		const backup = `${table}_backup_${Date.now()}`;
+		let originalRenamed = false;
+		let swapCompleted = false;
+		try {
+			await db.execute(cursorSequenceDDL);
+			await db.execute(buildTemporaryTableDDL(createDDL, table, temp));
+			const newColumns = await getColumns(db, temp);
+			const currentColumns = new Set(await getColumns(db, table));
+			const columnList = newColumns.map((c) => `"${c}"`).join(", ");
+			const selectExprs = newColumns.map((c) => {
+				if (c === idColumn) return currentColumns.has(c) ? `COALESCE(NULLIF("${c}", ''), CAST(uuid() AS VARCHAR)) AS "${c}"` : `CAST(uuid() AS VARCHAR) AS "${c}"`;
+				return currentColumns.has(c) ? `"${c}"` : `NULL AS "${c}"`;
+			}).join(", ");
+			await db.execute(`INSERT INTO ${temp} (${columnList}) SELECT ${selectExprs} FROM ${table}`);
+			await db.execute(`ALTER TABLE ${table} RENAME TO ${backup}`);
+			originalRenamed = true;
+			await db.execute(`ALTER TABLE ${temp} RENAME TO ${table}`);
+			swapCompleted = true;
+			try {
+				await db.execute(`DROP TABLE ${backup}`);
+			} catch (cleanupError) {
+				logger?.warn?.(`Migration of ${table} completed, but failed to drop backup ${backup}: ${cleanupError.message}`);
+			}
+			logger?.info?.(`Successfully migrated ${table}`);
+		} catch (error) {
+			logger?.error?.(`Migration of ${table} failed: ${error.message}`);
+			try {
+				await dropTableIfExists(db, temp);
+			} catch (restoreError) {
+				logger?.error?.(`Failed to clean up temporary table ${temp}: ${restoreError.message}`);
+			}
+			if (originalRenamed && !swapCompleted) try {
+				await db.execute(`ALTER TABLE ${backup} RENAME TO ${table}`);
+			} catch (restoreError) {
+				logger?.error?.(`Failed to restore original table ${table} from backup ${backup}: ${restoreError.message}`);
+			}
+			throw createMigrationError({
+				table,
+				idColumn
+			}, error);
+		}
+	}
+}
+//#endregion
+//#region src/storage/domains/observability/scores.ts
+const SCORE_GROUP_BY_COLUMNS = /* @__PURE__ */ new Set([
+	"timestamp",
+	"traceId",
+	"spanId",
+	"experimentId",
+	"scoreTraceId",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"parentEntityVersionId",
+	"parentEntityType",
+	"parentEntityId",
+	"parentEntityName",
+	"rootEntityVersionId",
+	"rootEntityType",
+	"rootEntityId",
+	"rootEntityName",
+	"userId",
+	"organizationId",
+	"resourceId",
+	"runId",
+	"sessionId",
+	"threadId",
+	"requestId",
+	"environment",
+	"executionSource",
+	"serviceName",
+	"scorerId",
+	"scorerVersion",
+	"scoreSource",
+	"score",
+	"reason"
+]);
+function getAggregationSql(aggregation, measure = "score") {
+	switch (aggregation) {
+		case "sum": return `SUM(${measure})`;
+		case "avg": return `AVG(${measure})`;
+		case "min": return `MIN(${measure})`;
+		case "max": return `MAX(${measure})`;
+		case "count": return `CAST(COUNT(${measure}) AS DOUBLE)`;
+		case "last": return `arg_max(${measure}, timestamp)`;
+		default: return `SUM(${measure})`;
+	}
+}
+function getIntervalSql(interval) {
+	switch (interval) {
+		case "1m": return "1 minute";
+		case "5m": return "5 minutes";
+		case "15m": return "15 minutes";
+		case "1h": return "1 hour";
+		case "1d": return "1 day";
+		default: return "1 hour";
+	}
+}
+function getValidatedPercentiles(percentiles) {
+	if (!Array.isArray(percentiles) || percentiles.length === 0) throw new Error("Percentiles must include at least one value between 0 and 1.");
+	return percentiles.map((percentile) => {
+		if (!Number.isFinite(percentile) || percentile < 0 || percentile > 1) throw new Error("Percentiles must be finite numbers between 0 and 1.");
+		return percentile;
+	});
+}
+function buildScoreWhereClause(args) {
+	const conditions = ["scorerId = ?"];
+	const params = [args.scorerId];
+	if (args.scoreSource !== void 0) {
+		conditions.push("scoreSource = ?");
+		params.push(args.scoreSource);
+	}
+	const { clause: filterClause, params: filterParams } = buildWhereClause(args.filters, { source: "scoreSource" });
+	if (filterClause) {
+		conditions.push(filterClause.replace("WHERE ", ""));
+		params.push(...filterParams);
+	}
+	return {
+		clause: `WHERE ${conditions.join(" AND ")}`,
+		params
+	};
+}
+function resolveScoreGroupBy(groupBy) {
+	return groupBy.map((key, index) => {
+		const column = parseFieldKey(key);
+		if (!SCORE_GROUP_BY_COLUMNS.has(column)) throw new Error(`Invalid groupBy column(s): ${key}`);
+		const alias = `group_by_${index}`;
+		return {
+			key,
+			selectSql: `${column} AS ${alias}`,
+			groupSql: alias
+		};
+	});
+}
+function toSeriesName(values) {
+	return values.map((value) => value === null || value === void 0 ? "" : String(value)).join("|");
+}
+function rowToScoreRecord(row) {
+	return {
+		scoreId: row.scoreId,
+		timestamp: toDate(row.timestamp),
+		traceId: row.traceId ?? null,
+		spanId: row.spanId ?? null,
+		experimentId: row.experimentId ?? null,
+		scoreTraceId: row.scoreTraceId ?? null,
+		entityType: row.entityType ?? null,
+		entityId: row.entityId ?? null,
+		entityName: row.entityName ?? null,
+		entityVersionId: row.entityVersionId ?? null,
+		parentEntityVersionId: row.parentEntityVersionId ?? null,
+		parentEntityType: row.parentEntityType ?? null,
+		parentEntityId: row.parentEntityId ?? null,
+		parentEntityName: row.parentEntityName ?? null,
+		rootEntityVersionId: row.rootEntityVersionId ?? null,
+		rootEntityType: row.rootEntityType ?? null,
+		rootEntityId: row.rootEntityId ?? null,
+		rootEntityName: row.rootEntityName ?? null,
+		userId: row.userId ?? null,
+		organizationId: row.organizationId ?? null,
+		resourceId: row.resourceId ?? null,
+		runId: row.runId ?? null,
+		sessionId: row.sessionId ?? null,
+		threadId: row.threadId ?? null,
+		requestId: row.requestId ?? null,
+		environment: row.environment ?? null,
+		executionSource: row.executionSource ?? null,
+		serviceName: row.serviceName ?? null,
+		scorerId: row.scorerId,
+		scorerVersion: row.scorerVersion ?? null,
+		source: row.scoreSource ?? null,
+		scoreSource: row.scoreSource ?? null,
+		score: Number(row.score),
+		reason: row.reason ?? null,
+		tags: parseJsonArray(row.tags),
+		metadata: parseJson(row.metadata),
+		scope: parseJson(row.scope)
+	};
+}
+function getComparisonDateRange(comparePeriod, timestamp) {
+	if (!timestamp.start || !timestamp.end) return null;
+	const duration = timestamp.end.getTime() - timestamp.start.getTime();
+	switch (comparePeriod) {
+		case "previous_period": return {
+			start: new Date(timestamp.start.getTime() - duration),
+			end: new Date(timestamp.end.getTime() - duration),
+			startExclusive: timestamp.startExclusive,
+			endExclusive: timestamp.endExclusive
+		};
+		case "previous_day": return {
+			start: /* @__PURE__ */ new Date(timestamp.start.getTime() - 864e5),
+			end: /* @__PURE__ */ new Date(timestamp.end.getTime() - 864e5),
+			startExclusive: timestamp.startExclusive,
+			endExclusive: timestamp.endExclusive
+		};
+		case "previous_week": return {
+			start: /* @__PURE__ */ new Date(timestamp.start.getTime() - 6048e5),
+			end: /* @__PURE__ */ new Date(timestamp.end.getTime() - 6048e5),
+			startExclusive: timestamp.startExclusive,
+			endExclusive: timestamp.endExclusive
+		};
+	}
+}
+/** Insert a single score event. */
+async function createScore(db, args) {
+	const s = args.score;
+	const scoreSource = s.scoreSource ?? s.source ?? null;
+	await db.execute(`INSERT INTO score_events (
+      scoreId, timestamp, cursorId, traceId, spanId, experimentId, scoreTraceId,
+      entityType, entityId, entityName, entityVersionId, parentEntityVersionId, parentEntityType, parentEntityId, parentEntityName, rootEntityVersionId, rootEntityType, rootEntityId, rootEntityName,
+      userId, organizationId, resourceId, runId, sessionId, threadId, requestId, environment, executionSource, serviceName,
+      scorerId, scorerVersion, scoreSource, score, reason, tags, metadata, scope
+    )
+     VALUES (${[
+		v(s.scoreId),
+		v(s.timestamp),
+		"nextval('score_events_cursor_id_seq')",
+		v(s.traceId),
+		v(s.spanId ?? null),
+		v(s.experimentId ?? null),
+		v(s.scoreTraceId ?? null),
+		v(s.entityType ?? null),
+		v(s.entityId ?? null),
+		v(s.entityName ?? null),
+		v(s.entityVersionId ?? null),
+		v(s.parentEntityVersionId ?? null),
+		v(s.parentEntityType ?? null),
+		v(s.parentEntityId ?? null),
+		v(s.parentEntityName ?? null),
+		v(s.rootEntityVersionId ?? null),
+		v(s.rootEntityType ?? null),
+		v(s.rootEntityId ?? null),
+		v(s.rootEntityName ?? null),
+		v(s.userId ?? null),
+		v(s.organizationId ?? null),
+		v(s.resourceId ?? null),
+		v(s.runId ?? null),
+		v(s.sessionId ?? null),
+		v(s.threadId ?? null),
+		v(s.requestId ?? null),
+		v(s.environment ?? null),
+		v(s.executionSource ?? null),
+		v(s.serviceName ?? null),
+		v(s.scorerId),
+		v(s.scorerVersion ?? null),
+		v(scoreSource),
+		v(s.score),
+		v(s.reason ?? null),
+		jsonV(s.tags ?? null),
+		jsonV(s.metadata),
+		jsonV(s.scope ?? null)
+	].join(", ")})
+     ON CONFLICT DO NOTHING`);
+}
+/** Insert multiple score events in a single statement. */
+async function batchCreateScores(db, args) {
+	if (args.scores.length === 0) return;
+	const tuples = args.scores.map((s) => {
+		const legacyScore = s;
+		const scoreSource = legacyScore.scoreSource ?? legacyScore.source ?? null;
+		return `(${[
+			v(legacyScore.scoreId),
+			v(legacyScore.timestamp),
+			"nextval('score_events_cursor_id_seq')",
+			v(legacyScore.traceId),
+			v(legacyScore.spanId ?? null),
+			v(legacyScore.experimentId ?? null),
+			v(legacyScore.scoreTraceId ?? null),
+			v(legacyScore.entityType ?? null),
+			v(legacyScore.entityId ?? null),
+			v(legacyScore.entityName ?? null),
+			v(legacyScore.entityVersionId ?? null),
+			v(legacyScore.parentEntityVersionId ?? null),
+			v(legacyScore.parentEntityType ?? null),
+			v(legacyScore.parentEntityId ?? null),
+			v(legacyScore.parentEntityName ?? null),
+			v(legacyScore.rootEntityVersionId ?? null),
+			v(legacyScore.rootEntityType ?? null),
+			v(legacyScore.rootEntityId ?? null),
+			v(legacyScore.rootEntityName ?? null),
+			v(legacyScore.userId ?? null),
+			v(legacyScore.organizationId ?? null),
+			v(legacyScore.resourceId ?? null),
+			v(legacyScore.runId ?? null),
+			v(legacyScore.sessionId ?? null),
+			v(legacyScore.threadId ?? null),
+			v(legacyScore.requestId ?? null),
+			v(legacyScore.environment ?? null),
+			v(legacyScore.executionSource ?? null),
+			v(legacyScore.serviceName ?? null),
+			v(legacyScore.scorerId),
+			v(legacyScore.scorerVersion ?? null),
+			v(scoreSource),
+			v(legacyScore.score),
+			v(legacyScore.reason ?? null),
+			jsonV(legacyScore.tags ?? null),
+			jsonV(legacyScore.metadata),
+			jsonV(legacyScore.scope ?? null)
+		].join(", ")})`;
+	});
+	await db.execute(`INSERT INTO score_events (
+      scoreId, timestamp, cursorId, traceId, spanId, experimentId, scoreTraceId,
+      entityType, entityId, entityName, entityVersionId, parentEntityVersionId, parentEntityType, parentEntityId, parentEntityName, rootEntityVersionId, rootEntityType, rootEntityId, rootEntityName,
+      userId, organizationId, resourceId, runId, sessionId, threadId, requestId, environment, executionSource, serviceName,
+      scorerId, scorerVersion, scoreSource, score, reason, tags, metadata, scope
+    )
+     VALUES ${tuples.join(",\n       ")}
+     ON CONFLICT DO NOTHING`);
+}
+/** Query score events with filtering, ordering, and pagination. */
+async function listScores(db, args) {
+	const { mode, filters, pagination, orderBy, after, limit } = listScoresArgsSchema.parse(args);
+	const page = Number(pagination.page);
+	const perPage = Number(pagination.perPage);
+	const { clause: filterClause, params: filterParams } = buildWhereClause(filters, { source: "scoreSource" });
+	if (mode === "delta") {
+		assertDeltaPollingEnabled();
+		const streamHeadCursor = await getStreamHeadCursor(db);
+		if (after === void 0) return {
+			scores: [],
+			delta: {
+				limit,
+				hasMore: false
+			},
+			deltaCursor: streamHeadCursor
+		};
+		const afterCursorId = validateCursorId(after);
+		const deltaWhereClause = extendWhereClause(filterClause, ["cursorId IS NOT NULL", `cursorId > CAST(? AS BIGINT)`]);
+		const rows = await db.query(`SELECT * FROM score_events ${deltaWhereClause} ORDER BY cursorId ASC LIMIT ?`, [
+			...filterParams,
+			afterCursorId,
+			limit + 1
+		]);
+		const visibleRows = rows.slice(0, limit).map((row) => ({
+			cursorId: row.cursorId,
+			score: rowToScoreRecord(row)
+		}));
+		return {
+			scores: visibleRows.map((row) => row.score),
+			delta: {
+				limit,
+				hasMore: rows.length > limit
+			},
+			deltaCursor: visibleRows.length > 0 ? encodeDeltaCursor(visibleRows[visibleRows.length - 1]?.cursorId) : streamHeadCursor
+		};
+	}
+	const orderByClause = buildOrderByClause(orderBy);
+	const { clause: paginationClause, params: paginationParams } = buildPaginationClause({
+		page,
+		perPage
+	});
+	const currentDeltaCursor = deltaPollingFeatureEnabled() ? await getDeltaCursor(db, filterClause, filterParams) : void 0;
+	const countResult = await db.query(`SELECT COUNT(*) as total FROM score_events ${filterClause}`, filterParams);
+	const total = Number(countResult[0]?.total ?? 0);
+	const rows = await db.query(`SELECT * FROM score_events ${filterClause} ${orderByClause} ${paginationClause}`, [...filterParams, ...paginationParams]);
+	return {
+		pagination: {
+			total,
+			page,
+			perPage,
+			hasMore: (page + 1) * perPage < total
+		},
+		scores: rows.map((row) => rowToScoreRecord(row)),
+		...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+	};
+}
+async function getDeltaCursor(db, filterClause, filterParams) {
+	const cursorId = (await db.query(`SELECT max(cursorId) AS cursorId FROM score_events ${filterClause}`, filterParams))[0]?.cursorId;
+	if (cursorId !== null && cursorId !== void 0) return encodeDeltaCursor(cursorId);
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM score_events`))[0]?.cursorId);
+}
+async function getStreamHeadCursor(db) {
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM score_events`))[0]?.cursorId);
+}
+async function getScoreById(db, scoreId) {
+	const rows = await db.query(`SELECT * FROM score_events WHERE scoreId = ? LIMIT 1`, [scoreId]);
+	return rows[0] ? rowToScoreRecord(rows[0]) : null;
+}
+async function getScoreAggregate(db, args) {
+	const aggSql = getAggregationSql(args.aggregation);
+	const { clause, params } = buildScoreWhereClause(args);
+	const rows = await db.query(`SELECT ${aggSql} AS value FROM score_events ${clause}`, params);
+	const value = rows[0]?.value === null || rows[0]?.value === void 0 ? null : Number(rows[0]?.value);
+	if (args.comparePeriod && args.filters?.timestamp) {
+		const previousTimestamp = getComparisonDateRange(args.comparePeriod, args.filters.timestamp);
+		if (previousTimestamp) {
+			const prevRows = await db.query(`SELECT ${aggSql} AS value FROM score_events ${buildScoreWhereClause({
+				...args,
+				filters: {
+					...args.filters ?? {},
+					timestamp: previousTimestamp
+				}
+			}).clause}`, buildScoreWhereClause({
+				...args,
+				filters: {
+					...args.filters ?? {},
+					timestamp: previousTimestamp
+				}
+			}).params);
+			const previousValue = prevRows[0]?.value === null || prevRows[0]?.value === void 0 ? null : Number(prevRows[0]?.value);
+			let changePercent = null;
+			if (previousValue !== null && previousValue !== 0 && value !== null) changePercent = (value - previousValue) / Math.abs(previousValue) * 100;
+			return {
+				value,
+				previousValue,
+				changePercent
+			};
+		}
+	}
+	return { value };
+}
+async function getScoreBreakdown(db, args) {
+	const aggSql = getAggregationSql(args.aggregation);
+	const { clause, params } = buildScoreWhereClause(args);
+	const resolvedGroupBy = resolveScoreGroupBy(args.groupBy);
+	const sql = `SELECT ${resolvedGroupBy.map((entry) => entry.selectSql).join(", ")}, ${aggSql} AS value FROM score_events ${clause} GROUP BY ${resolvedGroupBy.map((entry) => entry.groupSql).join(", ")} ORDER BY value DESC`;
+	return { groups: (await db.query(sql, params)).map((row) => ({
+		dimensions: Object.fromEntries(resolvedGroupBy.map((entry, index) => {
+			const value = row[`group_by_${index}`];
+			return [entry.key, value === null || value === void 0 ? null : String(value)];
+		})),
+		value: Number(row.value ?? 0)
+	})) };
+}
+async function getScoreTimeSeries(db, args) {
+	const aggSql = getAggregationSql(args.aggregation);
+	const intervalSql = getIntervalSql(args.interval);
+	const { clause, params } = buildScoreWhereClause(args);
+	if (args.groupBy && args.groupBy.length > 0) {
+		const resolvedGroupBy = resolveScoreGroupBy(args.groupBy);
+		const sql = `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${resolvedGroupBy.map((entry) => entry.selectSql).join(", ")},
+             ${aggSql} AS value
+      FROM score_events ${clause}
+      GROUP BY bucket, ${resolvedGroupBy.map((entry) => entry.groupSql).join(", ")}
+      ORDER BY bucket
+    `;
+		const rows = await db.query(sql, params);
+		const seriesMap = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const groupValues = resolvedGroupBy.map((_, index) => row[`group_by_${index}`]);
+			const key = JSON.stringify(groupValues);
+			if (!seriesMap.has(key)) seriesMap.set(key, {
+				name: toSeriesName(groupValues),
+				points: []
+			});
+			seriesMap.get(key).points.push({
+				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+				value: Number(row.value ?? 0)
+			});
+		}
+		return { series: Array.from(seriesMap.values()) };
+	}
+	const rows = await db.query(`
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${aggSql} AS value
+      FROM score_events ${clause}
+      GROUP BY bucket
+      ORDER BY bucket
+    `, params);
+	return { series: [{
+		name: args.scoreSource ? `${args.scorerId}|${args.scoreSource}` : args.scorerId,
+		points: rows.map((row) => ({
+			timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+			value: Number(row.value ?? 0)
+		}))
+	}] };
+}
+async function getScorePercentiles(db, args) {
+	const intervalSql = getIntervalSql(args.interval);
+	const { clause, params } = buildScoreWhereClause(args);
+	const percentiles = getValidatedPercentiles(args.percentiles);
+	const series = [];
+	for (const percentile of percentiles) {
+		const rows = await db.query(`
+        SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+               percentile_cont(${percentile}) WITHIN GROUP (ORDER BY score) AS pvalue
+        FROM score_events ${clause}
+        GROUP BY bucket
+        ORDER BY bucket
+      `, params);
+		series.push({
+			percentile,
+			points: rows.map((row) => ({
+				timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+				value: Number(row.pvalue ?? 0)
+			}))
+		});
+	}
+	return { series };
+}
+//#endregion
+//#region src/storage/domains/observability/tracing.ts
+const COLUMNS_SQL = [
+	"eventType",
+	"timestamp",
+	"cursorId",
+	"traceId",
+	"spanId",
+	"parentSpanId",
+	"name",
+	"spanType",
+	"isEvent",
+	"endedAt",
+	"experimentId",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"userId",
+	"organizationId",
+	"resourceId",
+	"runId",
+	"sessionId",
+	"threadId",
+	"requestId",
+	"environment",
+	"source",
+	"serviceName",
+	"attributes",
+	"metadata",
+	"tags",
+	"scope",
+	"links",
+	"input",
+	"output",
+	"error",
+	"requestContext"
+].join(", ");
+/**
+* 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.
+*/
+function argMaxNonNull(col) {
+	return `arg_max(${col}, timestamp) FILTER (WHERE ${col} IS NOT NULL) as ${col}`;
+}
+const SPAN_RECONSTRUCT_SELECT = `
+  SELECT
+    traceId, spanId,
+    ${argMaxNonNull("name")},
+    ${argMaxNonNull("spanType")},
+    ${argMaxNonNull("parentSpanId")},
+    ${argMaxNonNull("isEvent")},
+    coalesce(min(timestamp) FILTER (WHERE eventType = 'start'), min(timestamp)) as startedAt,
+    ${argMaxNonNull("endedAt")},
+    ${argMaxNonNull("experimentId")},
+    ${argMaxNonNull("entityType")},
+    ${argMaxNonNull("entityId")},
+    ${argMaxNonNull("entityName")},
+    ${argMaxNonNull("entityVersionId")},
+    ${argMaxNonNull("userId")},
+    ${argMaxNonNull("organizationId")},
+    ${argMaxNonNull("resourceId")},
+    ${argMaxNonNull("runId")},
+    ${argMaxNonNull("sessionId")},
+    ${argMaxNonNull("threadId")},
+    ${argMaxNonNull("requestId")},
+    ${argMaxNonNull("environment")},
+    ${argMaxNonNull("source")},
+    ${argMaxNonNull("serviceName")},
+    ${argMaxNonNull("attributes")},
+    ${argMaxNonNull("metadata")},
+    ${argMaxNonNull("tags")},
+    ${argMaxNonNull("scope")},
+    ${argMaxNonNull("links")},
+    ${argMaxNonNull("input")},
+    ${argMaxNonNull("output")},
+    ${argMaxNonNull("error")},
+    ${argMaxNonNull("requestContext")}
+  FROM span_events
+`;
+/** Lightweight variant — only timeline-relevant columns. */
+const SPAN_RECONSTRUCT_SELECT_LIGHT = `
+  SELECT
+    traceId, spanId,
+    ${argMaxNonNull("name")},
+    ${argMaxNonNull("spanType")},
+    ${argMaxNonNull("parentSpanId")},
+    ${argMaxNonNull("isEvent")},
+    coalesce(min(timestamp) FILTER (WHERE eventType = 'start'), min(timestamp)) as startedAt,
+    ${argMaxNonNull("endedAt")},
+    ${argMaxNonNull("entityType")},
+    ${argMaxNonNull("entityId")},
+    ${argMaxNonNull("entityName")},
+    ${argMaxNonNull("error")}
+  FROM span_events
+`;
+/**
+* Which reconstructed columns each post-aggregation filter key can reference.
+* `status` is derived from endedAt + error (see buildWhereClause).
+*/
+const POSTAGG_FILTER_COLUMNS = {
+	status: ["endedAt", "error"],
+	endedAt: ["endedAt"],
+	tags: ["tags"],
+	metadata: ["metadata"],
+	scope: ["scope"]
+};
+/**
+* Narrow reconstruction used by the slow list paths to evaluate
+* post-aggregation filters and ordering before pagination. Includes only the
+* columns the active filters and order field actually reference, so the
+* full-set aggregate never decompresses the heavy JSON payload columns
+* (attributes, links, input, output, requestContext) and skips even the
+* cheaper JSON columns (tags/metadata/scope) unless a filter needs them.
+*/
+function buildPostAggReconstructSelect(postAgg, orderByField) {
+	const columns = /* @__PURE__ */ new Set();
+	if (orderByField === "endedAt") columns.add("endedAt");
+	for (const key of Object.keys(postAgg)) for (const column of POSTAGG_FILTER_COLUMNS[key] ?? []) columns.add(column);
+	return `
+  SELECT
+    traceId, spanId,
+    ${[...columns].map((col) => `${argMaxNonNull(col)},`).join("\n    ")}
+    coalesce(min(timestamp) FILTER (WHERE eventType = 'start'), min(timestamp)) as startedAt
+  FROM span_events
+`;
+}
+/**
+* Reconstruct spans for the `(traceId, spanId)` pairs selected by `anchorCte`,
+* scanning only events at/after the CTE's earliest `anchorStartedAt`.
+*
+* 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).
+*
+* 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.
+*/
+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`;
+}
+/**
+* Same time-bound trick as {@link reconstructForAnchors}, 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 —
+* a literal parameter always reaches the scan as a plain range filter.
+*/
+function reconstructForAnchorsWithBoundParam(reconstructSelect, anchorCte) {
+	return `
+    ${reconstructSelect}
+    WHERE timestamp >= ?
+      AND (traceId, spanId) IN (SELECT traceId, spanId FROM ${anchorCte})
+    GROUP BY traceId, spanId`;
+}
+function rowToLightSpanRecord(row) {
+	return {
+		traceId: row.traceId,
+		spanId: row.spanId,
+		name: row.name,
+		spanType: row.spanType,
+		parentSpanId: row.parentSpanId ?? null,
+		isEvent: row.isEvent,
+		startedAt: toDate(row.startedAt),
+		endedAt: toDateOrNull(row.endedAt),
+		entityType: row.entityType ?? null,
+		entityId: row.entityId ?? null,
+		entityName: row.entityName ?? null,
+		error: parseJson(row.error),
+		createdAt: toDate(row.startedAt),
+		updatedAt: toDateOrNull(row.endedAt)
+	};
+}
+function rowToSpanRecord(row) {
+	return {
+		traceId: row.traceId,
+		spanId: row.spanId,
+		name: row.name,
+		spanType: row.spanType,
+		parentSpanId: row.parentSpanId ?? null,
+		isEvent: row.isEvent,
+		startedAt: toDate(row.startedAt),
+		endedAt: toDateOrNull(row.endedAt),
+		experimentId: row.experimentId ?? null,
+		entityType: row.entityType ?? null,
+		entityId: row.entityId ?? null,
+		entityName: row.entityName ?? null,
+		entityVersionId: row.entityVersionId ?? null,
+		userId: row.userId ?? null,
+		organizationId: row.organizationId ?? null,
+		resourceId: row.resourceId ?? null,
+		runId: row.runId ?? null,
+		sessionId: row.sessionId ?? null,
+		threadId: row.threadId ?? null,
+		requestId: row.requestId ?? null,
+		environment: row.environment ?? null,
+		source: row.source ?? null,
+		serviceName: row.serviceName ?? null,
+		attributes: parseJson(row.attributes),
+		metadata: parseJson(row.metadata),
+		tags: parseJsonArray(row.tags),
+		scope: parseJson(row.scope),
+		links: parseJsonArray(row.links),
+		input: parseJson(row.input),
+		output: parseJson(row.output),
+		error: parseJson(row.error),
+		requestContext: parseJson(row.requestContext),
+		createdAt: toDate(row.startedAt),
+		updatedAt: null
+	};
+}
+function buildHasChildErrorClause(hasChildError, rootAlias) {
+	if (hasChildError === void 0) return "";
+	const base = `SELECT 1 FROM span_events c WHERE c.traceId = ${rootAlias}.traceId AND c.spanId != ${rootAlias}.spanId AND c.error IS NOT NULL`;
+	return hasChildError ? `EXISTS (${base})` : `NOT EXISTS (${base})`;
+}
+/**
+* Filter keys that can be evaluated directly against raw `span_events` start
+* rows. These are stable scalar columns whose value on the start row matches
+* the reconstructed span value, so pushing them down before reconstruction is
+* observation-equivalent to reconstructing first and filtering after.
+*/
+const PREFILTER_KEYS = /* @__PURE__ */ new Set([
+	"traceId",
+	"spanId",
+	"parentSpanId",
+	"name",
+	"spanType",
+	"source",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"experimentId",
+	"userId",
+	"organizationId",
+	"resourceId",
+	"runId",
+	"sessionId",
+	"threadId",
+	"requestId",
+	"environment",
+	"serviceName"
+]);
+/**
+* Order-by fields whose start-row value matches the reconstructed root-span
+* value, so ordering inside the prefilter (before GROUP BY) yields the same
+* sequence as ordering on reconstructed rows. Anything outside this set must
+* fall back to the slow path so pagination stays correct.
+*
+* `endedAt` is intentionally excluded — start rows always have NULL `endedAt`,
+* so ordering by it on raw rows would compare NULLs and produce wrong pages.
+*/
+const SAFE_PREFILTER_ORDER_FIELDS = /* @__PURE__ */ new Set(["startedAt"]);
+/**
+* Intersect the existing prefilter timestamp range with an incoming bound.
+* Each bound is an exact constraint on the start-row `timestamp`, so the
+* intersection is the **tighter** of the two on each side: the later `start`
+* wins, the earlier `end` wins. When two bounds tie on a side, the result is
+* exclusive if either input was exclusive (the union of exclusivity).
+*
+* Required for cases like `{ startedAt: { end: B }, endedAt: { end: C } }`:
+* both bound the start-row timestamp from above and we want `min(B, C)`,
+* regardless of insertion order.
+*/
+function intersectTimestampRange(existing, incoming) {
+	if (!existing) return { ...incoming };
+	const merged = { ...existing };
+	if (incoming.start !== void 0) {
+		if (merged.start === void 0 || incoming.start.getTime() > merged.start.getTime()) {
+			merged.start = incoming.start;
+			merged.startExclusive = incoming.startExclusive;
+		} else if (incoming.start.getTime() === merged.start.getTime()) merged.startExclusive = (merged.startExclusive ?? false) || (incoming.startExclusive ?? false);
+	}
+	if (incoming.end !== void 0) {
+		if (merged.end === void 0 || incoming.end.getTime() < merged.end.getTime()) {
+			merged.end = incoming.end;
+			merged.endExclusive = incoming.endExclusive;
+		} else if (incoming.end.getTime() === merged.end.getTime()) merged.endExclusive = (merged.endExclusive ?? false) || (incoming.endExclusive ?? false);
+	}
+	return merged;
+}
+/**
+* Split a span-anchor filter set into a `prefilter` half (pushed to raw
+* `span_events` start rows) and a `postAgg` half (applied after the
+* reconstruction GROUP BY). Used by both `listTraces` and `listBranches`.
+*
+* `hasChildError` is split out separately since it doesn't run via
+* `buildWhereClause` — `listTraces` wires it up via EXISTS, `listBranches`
+* never sees it (not in `branchesFilterSchema`).
+*/
+function partitionAnchorFilters(filters) {
+	const prefilter = {};
+	const postAgg = {};
+	let hasChildError;
+	for (const [key, value] of Object.entries(filters)) {
+		if (value === void 0 || value === null) continue;
+		if (key === "hasChildError") {
+			if (typeof value === "boolean") hasChildError = value;
+			continue;
+		}
+		if (key === "startedAt") {
+			prefilter.timestamp = intersectTimestampRange(prefilter.timestamp, value);
+			continue;
+		}
+		if (key === "endedAt") {
+			postAgg.endedAt = value;
+			const dateRange = value;
+			if (dateRange?.end) prefilter.timestamp = intersectTimestampRange(prefilter.timestamp, {
+				end: dateRange.end,
+				endExclusive: dateRange.endExclusive
+			});
+			continue;
+		}
+		if (PREFILTER_KEYS.has(key)) {
+			prefilter[key] = value;
+			continue;
+		}
+		postAgg[key] = value;
+	}
+	return {
+		prefilter,
+		postAgg,
+		hasChildError
+	};
+}
+function toValuesTuple(row) {
+	return [
+		v(row.eventType),
+		v(row.timestamp),
+		"nextval('span_events_cursor_id_seq')",
+		v(row.traceId),
+		v(row.spanId),
+		v(row.parentSpanId),
+		v(row.name),
+		v(row.spanType),
+		v(row.isEvent),
+		v(row.endedAt),
+		v(row.experimentId),
+		v(row.entityType),
+		v(row.entityId),
+		v(row.entityName),
+		v(row.entityVersionId),
+		v(row.userId),
+		v(row.organizationId),
+		v(row.resourceId),
+		v(row.runId),
+		v(row.sessionId),
+		v(row.threadId),
+		v(row.requestId),
+		v(row.environment),
+		v(row.source),
+		v(row.serviceName),
+		jsonV(row.attributes),
+		jsonV(row.metadata),
+		jsonV(row.tags),
+		jsonV(row.scope),
+		jsonV(row.links),
+		jsonV(row.input),
+		jsonV(row.output),
+		jsonV(row.error),
+		jsonV(row.requestContext)
+	].join(", ");
+}
+async function insertSpanEvents(db, rows) {
+	if (rows.length === 0) return;
+	const tuples = rows.map((row) => `(${toValuesTuple(row)})`).join(",\n");
+	await db.execute(`INSERT INTO span_events (${COLUMNS_SQL}) VALUES ${tuples}`);
+}
+function createStartSpanRow(s) {
+	return {
+		eventType: "start",
+		timestamp: s.startedAt,
+		traceId: s.traceId,
+		spanId: s.spanId,
+		parentSpanId: s.parentSpanId ?? null,
+		name: s.name,
+		spanType: s.spanType,
+		isEvent: s.isEvent,
+		endedAt: null,
+		experimentId: s.experimentId ?? null,
+		entityType: s.entityType ?? null,
+		entityId: s.entityId ?? null,
+		entityName: s.entityName ?? null,
+		entityVersionId: s.entityVersionId ?? null,
+		userId: s.userId ?? null,
+		organizationId: s.organizationId ?? null,
+		resourceId: s.resourceId ?? null,
+		runId: s.runId ?? null,
+		sessionId: s.sessionId ?? null,
+		threadId: s.threadId ?? null,
+		requestId: s.requestId ?? null,
+		environment: s.environment ?? null,
+		source: s.source ?? null,
+		serviceName: s.serviceName ?? null,
+		attributes: s.attributes ?? null,
+		metadata: s.metadata ?? null,
+		tags: s.tags ?? null,
+		scope: s.scope ?? null,
+		links: null,
+		input: s.input ?? null,
+		output: null,
+		error: null,
+		requestContext: s.requestContext ?? null
+	};
+}
+function createEndSpanRow(s) {
+	return {
+		eventType: "end",
+		timestamp: s.endedAt,
+		traceId: s.traceId,
+		spanId: s.spanId,
+		parentSpanId: s.parentSpanId ?? null,
+		name: s.name,
+		spanType: s.spanType,
+		isEvent: s.isEvent,
+		endedAt: s.endedAt ?? null,
+		experimentId: s.experimentId ?? null,
+		entityType: s.entityType ?? null,
+		entityId: s.entityId ?? null,
+		entityName: s.entityName ?? null,
+		entityVersionId: s.entityVersionId ?? null,
+		userId: s.userId ?? null,
+		organizationId: s.organizationId ?? null,
+		resourceId: s.resourceId ?? null,
+		runId: s.runId ?? null,
+		sessionId: s.sessionId ?? null,
+		threadId: s.threadId ?? null,
+		requestId: s.requestId ?? null,
+		environment: s.environment ?? null,
+		source: s.source ?? null,
+		serviceName: s.serviceName ?? null,
+		attributes: s.attributes ?? null,
+		metadata: s.metadata ?? null,
+		tags: s.tags ?? null,
+		scope: s.scope ?? null,
+		links: s.links ?? null,
+		input: s.input ?? null,
+		output: s.output ?? null,
+		error: s.error ?? null,
+		requestContext: s.requestContext ?? null
+	};
+}
+/** Insert a 'start' event for a new span. */
+async function createSpan(db, args) {
+	const rows = [createStartSpanRow(args.span)];
+	if (args.span.endedAt) rows.push(createEndSpanRow(args.span));
+	await insertSpanEvents(db, rows);
+}
+/** Insert 'start' events for multiple spans in a single statement. */
+async function batchCreateSpans(db, args) {
+	if (args.records.length === 0) return;
+	await insertSpanEvents(db, args.records.flatMap((record) => {
+		const events = [createStartSpanRow(record)];
+		if (record.endedAt) events.push(createEndSpanRow(record));
+		return events;
+	}));
+}
+/** Delete all span events for the given trace IDs. */
+async function batchDeleteTraces(db, args) {
+	if (args.traceIds.length === 0) return;
+	const placeholders = args.traceIds.map(() => "?").join(", ");
+	await db.execute(`DELETE FROM span_events WHERE traceId IN (${placeholders})`, args.traceIds);
+}
+/** Reconstruct a single span from its event history. */
+async function getSpan(db, args) {
+	const rows = await db.query(`${SPAN_RECONSTRUCT_SELECT} WHERE traceId = ? AND spanId = ? GROUP BY traceId, spanId`, [args.traceId, args.spanId]);
+	if (rows.length === 0) return null;
+	return { span: rowToSpanRecord(rows[0]) };
+}
+/** Reconstruct the root span (no parent) for a trace. */
+async function getRootSpan(db, args) {
+	const rows = await db.query(`${SPAN_RECONSTRUCT_SELECT} WHERE traceId = ? GROUP BY traceId, spanId HAVING arg_max(parentSpanId, timestamp) IS NULL LIMIT 1`, [args.traceId]);
+	if (rows.length === 0) return null;
+	return { span: rowToSpanRecord(rows[0]) };
+}
+/** Reconstruct all spans belonging to a trace. */
+async function getTrace(db, args) {
+	const rows = await db.query(`${SPAN_RECONSTRUCT_SELECT} WHERE traceId = ? GROUP BY traceId, spanId`, [args.traceId]);
+	if (rows.length === 0) return null;
+	return {
+		traceId: args.traceId,
+		spans: rows.map((row) => rowToSpanRecord(row))
+	};
+}
+/** Reconstruct lightweight spans belonging to a trace (timeline fields only). */
+async function getTraceLight(db, args) {
+	const rows = await db.query(`${SPAN_RECONSTRUCT_SELECT_LIGHT} WHERE traceId = ? GROUP BY traceId, spanId`, [args.traceId]);
+	if (rows.length === 0) return null;
+	return {
+		traceId: args.traceId,
+		spans: rows.map((row) => rowToLightSpanRecord(row))
+	};
+}
+/**
+* List root spans (traces) with filtering, ordering, and pagination.
+*
+* Instead of reconstructing every span in the table and then filtering, we:
+*   1. Pick candidate root `(traceId, spanId)` tuples from raw `span_events`
+*      by looking only at rows where `eventType = 'start'` and
+*      `parentSpanId IS NULL`. All scalar filters (entity*, *Id, service,
+*      environment, startedAt range, ...) run here, against raw columns.
+*   2. Fully reconstruct spans only for that narrowed set, then apply
+*      post-aggregation filters (status/tags/metadata/scope/endedAt/
+*      hasChildError).
+*
+* When there are no post-aggregation filters, ordering + pagination happen
+* inside the prefilter CTE so reconstruction runs on at most `perPage` rows.
+*/
+async function listTraceRows(db, args, reconstructSelect, mapRow, toSpans) {
+	const filters = args.filters ?? {};
+	const page = Number(args.pagination?.page ?? 0);
+	const perPage = Number(args.pagination?.perPage ?? 10);
+	const orderBy = {
+		field: args.orderBy?.field ?? "startedAt",
+		direction: args.orderBy?.direction ?? "DESC"
+	};
+	const { prefilter, postAgg, hasChildError } = partitionAnchorFilters(filters);
+	const { clause: prefilterClause, params: prefilterParams } = buildWhereClause(prefilter);
+	const prefilterParts = [`eventType = 'start'`, `parentSpanId IS NULL`];
+	if (prefilterClause) prefilterParts.push(prefilterClause.replace(/^WHERE\s+/i, ""));
+	const prefilterWhere = `WHERE ${prefilterParts.join(" AND ")}`;
+	const outerAlias = "outer_root";
+	const orderDir = orderBy.direction.toUpperCase();
+	if (orderDir !== "ASC" && orderDir !== "DESC") throw new Error(`Invalid sort direction: ${orderBy.direction}`);
+	const canOrderInPrefilter = SAFE_PREFILTER_ORDER_FIELDS.has(orderBy.field);
+	if (!(Object.keys(postAgg).length > 0 || hasChildError !== void 0 || !canOrderInPrefilter)) {
+		const prefilterOrderBy = `ORDER BY timestamp ${orderDir}`;
+		const offset = page * perPage;
+		const countSql = `
+      SELECT COUNT(*) as total
+      FROM span_events AS ${outerAlias}
+      ${prefilterWhere}
+    `;
+		const countResult = await db.query(countSql, prefilterParams);
+		const total = Number(countResult[0]?.total ?? 0);
+		const pageSql = `
+      WITH page_roots AS (
+        SELECT traceId, spanId, timestamp AS anchorStartedAt
+        FROM span_events AS ${outerAlias}
+        ${prefilterWhere}
+        ${prefilterOrderBy}
+        LIMIT ? OFFSET ?
+      )
+      ${reconstructForAnchors(reconstructSelect, "page_roots")}
+      ${buildOrderByClause(orderBy)}
+    `;
+		const spans = (await db.query(pageSql, [
+			...prefilterParams,
+			perPage,
+			offset
+		])).map((row) => mapRow(row));
+		return {
+			pagination: {
+				total,
+				page,
+				perPage,
+				hasMore: (page + 1) * perPage < total
+			},
+			spans: toSpans(spans)
+		};
+	}
+	const { clause: postAggClause, params: postAggParams } = buildWhereClause(postAgg);
+	const postAggParts = [];
+	if (postAggClause) postAggParts.push(postAggClause.replace(/^WHERE\s+/i, ""));
+	const childErrorClause = buildHasChildErrorClause(hasChildError, "root_spans");
+	if (childErrorClause) postAggParts.push(childErrorClause);
+	const postAggWhere = postAggParts.length > 0 ? `WHERE ${postAggParts.join(" AND ")}` : "";
+	const cteSql = `
+    WITH candidate_roots AS (
+      SELECT traceId, spanId
+      FROM span_events AS ${outerAlias}
+      ${prefilterWhere}
+    ),
+    root_spans AS (
+      ${buildPostAggReconstructSelect(postAgg, orderBy.field)}
+      WHERE (traceId, spanId) IN (SELECT traceId, spanId FROM candidate_roots)
+      GROUP BY traceId, spanId
+    )
+  `;
+	const orderByClause = buildOrderByClause(orderBy);
+	const { clause: paginationClause, params: paginationParams } = buildPaginationClause({
+		page,
+		perPage
+	});
+	const countSql = `
+    ${cteSql}
+    SELECT COUNT(*) as total FROM root_spans ${postAggWhere}
+  `;
+	const countResult = await db.query(countSql, [...prefilterParams, ...postAggParams]);
+	const total = Number(countResult[0]?.total ?? 0);
+	const dataSql = `
+    ${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, [
+		...prefilterParams,
+		...postAggParams,
+		...paginationParams
+	])).map((row) => mapRow(row));
+	return {
+		pagination: {
+			total,
+			page,
+			perPage,
+			hasMore: (page + 1) * perPage < total
+		},
+		spans: toSpans(spans)
+	};
+}
+async function listTraces(db, args) {
+	const { mode, filters, pagination, orderBy, after, limit } = listTracesArgsSchema.parse(args);
+	const filterRecord = filters ?? {};
+	if (mode === "delta") {
+		assertDeltaPollingEnabled();
+		const streamHeadCursor = await getTraceStreamHeadCursor(db);
+		if (after === void 0) return {
+			spans: [],
+			delta: {
+				limit,
+				hasMore: false
+			},
+			deltaCursor: streamHeadCursor
+		};
+		const afterCursorId = validateCursorId(after);
+		const { prefilter, postAgg, hasChildError } = partitionAnchorFilters(filterRecord);
+		const { clause: prefilterClause, params: prefilterParams } = buildWhereClause(prefilter);
+		const prefilterParts = [
+			`eventType = 'start'`,
+			`parentSpanId IS NULL`,
+			`cursorId IS NOT NULL`,
+			`cursorId > CAST(? AS BIGINT)`
+		];
+		if (prefilterClause) prefilterParts.push(prefilterClause.replace(/^WHERE\s+/i, ""));
+		const prefilterWhere = `WHERE ${prefilterParts.join(" AND ")}`;
+		const { clause: postAggClause, params: postAggParams } = buildWhereClause(postAgg);
+		const postAggParts = [];
+		if (postAggClause) postAggParts.push(postAggClause.replace(/^WHERE\s+/i, ""));
+		const childErrorClause = buildHasChildErrorClause(hasChildError, "root_spans");
+		if (childErrorClause) postAggParts.push(childErrorClause);
+		const postAggWhere = postAggParts.length > 0 ? `WHERE ${postAggParts.join(" AND ")}` : "";
+		const outerAlias = "outer_root";
+		const minTs = (await db.query(`SELECT min(timestamp) as minTs FROM span_events AS ${outerAlias} ${prefilterWhere}`, [afterCursorId, ...prefilterParams]))[0]?.minTs ?? null;
+		if (minTs === null) return {
+			spans: [],
+			delta: {
+				limit,
+				hasMore: false
+			},
+			deltaCursor: streamHeadCursor
+		};
+		const dataSql = `
+      WITH candidate_roots AS (
+        SELECT traceId, spanId, cursorId
+        FROM span_events AS ${outerAlias}
+        ${prefilterWhere}
+      ),
+      root_spans AS (
+        SELECT reconstructed.*, candidate_roots.cursorId AS anchorCursorId
+        FROM (
+          ${reconstructForAnchorsWithBoundParam(SPAN_RECONSTRUCT_SELECT, "candidate_roots")}
+        ) AS reconstructed
+        INNER JOIN candidate_roots USING (traceId, spanId)
+      )
+      SELECT * FROM root_spans ${postAggWhere} ORDER BY anchorCursorId ASC LIMIT ?
+    `;
+		const rows = await db.query(dataSql, [
+			afterCursorId,
+			...prefilterParams,
+			minTs,
+			...postAggParams,
+			limit + 1
+		]);
+		const visibleRows = rows.slice(0, limit).map((row) => ({
+			cursorId: row.anchorCursorId,
+			span: rowToSpanRecord(row)
+		}));
+		return {
+			spans: toTraceSpans(visibleRows.map((row) => row.span)),
+			delta: {
+				limit,
+				hasMore: rows.length > limit
+			},
+			deltaCursor: visibleRows.length > 0 ? encodeDeltaCursor(visibleRows[visibleRows.length - 1]?.cursorId) : streamHeadCursor
+		};
+	}
+	const currentDeltaCursor = deltaPollingFeatureEnabled() ? await getTraceDeltaCursor(db, filters) : void 0;
+	const { pagination: resultPagination, spans } = await listTraceRows(db, {
+		filters,
+		pagination,
+		orderBy
+	}, SPAN_RECONSTRUCT_SELECT, rowToSpanRecord, toTraceSpans);
+	return {
+		pagination: resultPagination,
+		spans,
+		...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+	};
+}
+async function listTracesLight(db, args) {
+	return listTraceRows(db, args, SPAN_RECONSTRUCT_SELECT_LIGHT, rowToLightSpanRecord, (spans) => spans);
+}
+const BRANCH_SPAN_TYPE_PLACEHOLDERS = BRANCH_SPAN_TYPES.map(() => "?").join(", ");
+/**
+* Reconstruct multiple spans by spanId within a single trace. Single round-trip
+* fetch used by the optimized {@link import('@mastra/core/storage').getBranch}
+* path: getStructure walks the skeleton to identify branch spanIds, then this
+* pulls full data for only those spans instead of the whole trace.
+*/
+async function getSpans(db, args) {
+	if (args.spanIds.length === 0) return {
+		traceId: args.traceId,
+		spans: []
+	};
+	const placeholders = args.spanIds.map(() => "?").join(", ");
+	const rows = await db.query(`${SPAN_RECONSTRUCT_SELECT}
+     WHERE traceId = ? AND spanId IN (${placeholders})
+     GROUP BY traceId, spanId`, [args.traceId, ...args.spanIds]);
+	return {
+		traceId: args.traceId,
+		spans: rows.map((row) => rowToSpanRecord(row))
+	};
+}
+/**
+* List branch anchor spans (named-entity invocations) across all traces with
+* filtering, ordering, and pagination.
+*
+* Same two-stage strategy as `listTraces`:
+*   1. Pick candidate anchor `(traceId, spanId)` tuples from raw `span_events`
+*      by looking only at `eventType = 'start'` rows whose `spanType` is in
+*      {@link BRANCH_SPAN_TYPES}. Scalar filters (entity*, *Id, environment,
+*      serviceName, startedAt range, ...) run here, against raw columns. This
+*      avoids paying reconstruction cost for the high-volume sub-operation
+*      events (MODEL_STEP, MODEL_CHUNK, ...) that are never anchors.
+*   2. Reconstruct full span data only for that narrowed set, then apply
+*      post-aggregation filters (status / metadata / tags / endedAt range).
+*
+* When there are no post-aggregation filters, ordering + pagination happen
+* inside the prefilter so reconstruction runs on at most `perPage` rows.
+*/
+async function listBranches(db, args) {
+	const { mode, filters, pagination, orderBy, after, limit } = listBranchesArgsSchema.parse(args);
+	const filterRecord = filters ?? {};
+	const page = Number(pagination.page);
+	const perPage = Number(pagination.perPage);
+	const userSpanType = filterRecord.spanType;
+	if (typeof userSpanType === "string" && !BRANCH_SPAN_TYPES.includes(userSpanType)) {
+		const currentDeltaCursor = deltaPollingFeatureEnabled() ? await getBranchDeltaCursor(db, filters) : void 0;
+		if (mode === "delta") {
+			assertDeltaPollingEnabled();
+			return {
+				branches: [],
+				delta: {
+					limit,
+					hasMore: false
+				},
+				deltaCursor: currentDeltaCursor
+			};
+		}
+		return {
+			pagination: {
+				total: 0,
+				page,
+				perPage,
+				hasMore: false
+			},
+			branches: [],
+			...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+		};
+	}
+	if (mode === "delta") {
+		assertDeltaPollingEnabled();
+		const streamHeadCursor = await getBranchStreamHeadCursor(db, typeof userSpanType === "string" ? userSpanType : null);
+		if (after === void 0) return {
+			branches: [],
+			delta: {
+				limit,
+				hasMore: false
+			},
+			deltaCursor: streamHeadCursor
+		};
+		const afterCursorId = validateCursorId(after);
+		const { spanType: _spanType, ...rest } = filterRecord;
+		const { prefilter, postAgg, hasChildError: _hasChildError } = partitionAnchorFilters(rest);
+		const { clause: prefilterClause, params: prefilterFilterParams } = buildWhereClause(prefilter);
+		const prefilterParts = [
+			`eventType = 'start'`,
+			`cursorId IS NOT NULL`,
+			`cursorId > CAST(? AS BIGINT)`
+		];
+		let spanTypeParams;
+		if (typeof userSpanType === "string") {
+			prefilterParts.push(`spanType = ?`);
+			spanTypeParams = [userSpanType];
+		} else {
+			prefilterParts.push(`spanType IN (${BRANCH_SPAN_TYPE_PLACEHOLDERS})`);
+			spanTypeParams = [...BRANCH_SPAN_TYPES];
+		}
+		if (prefilterClause) prefilterParts.push(prefilterClause.replace(/^WHERE\s+/i, ""));
+		const prefilterWhere = `WHERE ${prefilterParts.join(" AND ")}`;
+		const prefilterParams = [
+			afterCursorId,
+			...spanTypeParams,
+			...prefilterFilterParams
+		];
+		const { clause: postAggClause, params: postAggParams } = buildWhereClause(postAgg);
+		const postAggWhere = postAggClause ? postAggClause : "";
+		const outerAlias = "outer_anchor";
+		const minTs = (await db.query(`SELECT min(timestamp) as minTs FROM span_events AS ${outerAlias} ${prefilterWhere}`, prefilterParams))[0]?.minTs ?? null;
+		if (minTs === null) return {
+			branches: [],
+			delta: {
+				limit,
+				hasMore: false
+			},
+			deltaCursor: streamHeadCursor
+		};
+		const dataSql = `
+      WITH candidate_anchors AS (
+        SELECT traceId, spanId, cursorId
+        FROM span_events AS ${outerAlias}
+        ${prefilterWhere}
+      ),
+      branch_anchors AS (
+        SELECT reconstructed.*, candidate_anchors.cursorId AS anchorCursorId
+        FROM (
+          ${reconstructForAnchorsWithBoundParam(SPAN_RECONSTRUCT_SELECT, "candidate_anchors")}
+        ) AS reconstructed
+        INNER JOIN candidate_anchors USING (traceId, spanId)
+      )
+      SELECT * FROM branch_anchors ${postAggWhere} ORDER BY anchorCursorId ASC LIMIT ?
+    `;
+		const rows = await db.query(dataSql, [
+			...prefilterParams,
+			minTs,
+			...postAggParams,
+			limit + 1
+		]);
+		const visibleRows = rows.slice(0, limit).map((row) => ({
+			cursorId: row.anchorCursorId,
+			branch: rowToSpanRecord(row)
+		}));
+		return {
+			branches: toTraceSpans(visibleRows.map((row) => row.branch)),
+			delta: {
+				limit,
+				hasMore: rows.length > limit
+			},
+			deltaCursor: visibleRows.length > 0 ? encodeDeltaCursor(visibleRows[visibleRows.length - 1]?.cursorId) : streamHeadCursor
+		};
+	}
+	const { spanType: _spanType, ...rest } = filterRecord;
+	const { prefilter, postAgg, hasChildError: _hasChildError } = partitionAnchorFilters(rest);
+	const { clause: prefilterClause, params: prefilterFilterParams } = buildWhereClause(prefilter);
+	const prefilterParts = [`eventType = 'start'`];
+	let spanTypeParams;
+	if (typeof userSpanType === "string") {
+		prefilterParts.push(`spanType = ?`);
+		spanTypeParams = [userSpanType];
+	} else {
+		prefilterParts.push(`spanType IN (${BRANCH_SPAN_TYPE_PLACEHOLDERS})`);
+		spanTypeParams = [...BRANCH_SPAN_TYPES];
+	}
+	if (prefilterClause) prefilterParts.push(prefilterClause.replace(/^WHERE\s+/i, ""));
+	const prefilterWhere = `WHERE ${prefilterParts.join(" AND ")}`;
+	const prefilterParams = [...spanTypeParams, ...prefilterFilterParams];
+	const outerAlias = "outer_anchor";
+	const orderDir = orderBy.direction.toUpperCase();
+	if (orderDir !== "ASC" && orderDir !== "DESC") throw new Error(`Invalid sort direction: ${orderBy.direction}`);
+	const currentDeltaCursor = deltaPollingFeatureEnabled() ? await getBranchDeltaCursor(db, filters) : void 0;
+	const canOrderInPrefilter = SAFE_PREFILTER_ORDER_FIELDS.has(orderBy.field);
+	if (!(Object.keys(postAgg).length > 0 || !canOrderInPrefilter)) {
+		const prefilterOrderBy = `ORDER BY timestamp ${orderDir}`;
+		const offset = page * perPage;
+		const countSql = `
+      SELECT COUNT(*) as total
+      FROM span_events AS ${outerAlias}
+      ${prefilterWhere}
+    `;
+		const countResult = await db.query(countSql, prefilterParams);
+		const total = Number(countResult[0]?.total ?? 0);
+		if (total === 0) return {
+			pagination: {
+				total: 0,
+				page,
+				perPage,
+				hasMore: false
+			},
+			branches: [],
+			...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+		};
+		const pageSql = `
+      WITH page_anchors AS (
+        SELECT traceId, spanId, timestamp AS anchorStartedAt
+        FROM span_events AS ${outerAlias}
+        ${prefilterWhere}
+        ${prefilterOrderBy}
+        LIMIT ? OFFSET ?
+      )
+      ${reconstructForAnchors(SPAN_RECONSTRUCT_SELECT, "page_anchors")}
+      ${buildOrderByClause(orderBy)}
+    `;
+		const spans = (await db.query(pageSql, [
+			...prefilterParams,
+			perPage,
+			offset
+		])).map((row) => rowToSpanRecord(row));
+		return {
+			pagination: {
+				total,
+				page,
+				perPage,
+				hasMore: (page + 1) * perPage < total
+			},
+			branches: toTraceSpans(spans),
+			...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+		};
+	}
+	const { clause: postAggClause, params: postAggParams } = buildWhereClause(postAgg);
+	const postAggWhere = postAggClause ? postAggClause : "";
+	const orderByClause = buildOrderByClause(orderBy);
+	const { clause: paginationClause, params: paginationParams } = buildPaginationClause({
+		page,
+		perPage
+	});
+	const cteSql = `
+    WITH candidate_anchors AS (
+      SELECT traceId, spanId
+      FROM span_events AS ${outerAlias}
+      ${prefilterWhere}
+    ),
+    branch_anchors AS (
+      ${buildPostAggReconstructSelect(postAgg, orderBy.field)}
+      WHERE (traceId, spanId) IN (SELECT traceId, spanId FROM candidate_anchors)
+      GROUP BY traceId, spanId
+    )
+  `;
+	const countSql = `
+    ${cteSql}
+    SELECT COUNT(*) as total FROM branch_anchors ${postAggWhere}
+  `;
+	const countResult = await db.query(countSql, [...prefilterParams, ...postAggParams]);
+	const total = Number(countResult[0]?.total ?? 0);
+	if (total === 0) return {
+		pagination: {
+			total: 0,
+			page,
+			perPage,
+			hasMore: false
+		},
+		branches: [],
+		...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+	};
+	const dataSql = `
+    ${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, [
+		...prefilterParams,
+		...postAggParams,
+		...paginationParams
+	])).map((row) => rowToSpanRecord(row));
+	return {
+		pagination: {
+			total,
+			page,
+			perPage,
+			hasMore: (page + 1) * perPage < total
+		},
+		branches: toTraceSpans(spans),
+		...deltaPollingFeatureEnabled() ? { deltaCursor: currentDeltaCursor } : {}
+	};
+}
+async function getTraceDeltaCursor(db, filters) {
+	const { prefilter, postAgg, hasChildError } = partitionAnchorFilters(filters ?? {});
+	const { clause: prefilterClause, params: prefilterParams } = buildWhereClause(prefilter);
+	const prefilterParts = [
+		`eventType = 'start'`,
+		`parentSpanId IS NULL`,
+		`cursorId IS NOT NULL`
+	];
+	if (prefilterClause) prefilterParts.push(prefilterClause.replace(/^WHERE\s+/i, ""));
+	const prefilterWhere = `WHERE ${prefilterParts.join(" AND ")}`;
+	const outerAlias = "outer_root";
+	const { clause: postAggClause, params: postAggParams } = buildWhereClause(postAgg);
+	const postAggParts = [];
+	if (postAggClause) postAggParts.push(postAggClause.replace(/^WHERE\s+/i, ""));
+	const childErrorClause = buildHasChildErrorClause(hasChildError, "root_spans");
+	if (childErrorClause) postAggParts.push(childErrorClause);
+	const postAggWhere = postAggParts.length > 0 ? `WHERE ${postAggParts.join(" AND ")}` : "";
+	if (postAggWhere === "") {
+		const cursorId = (await db.query(`SELECT max(cursorId) AS cursorId FROM span_events AS ${outerAlias} ${prefilterWhere}`, prefilterParams))[0]?.cursorId;
+		if (cursorId !== null && cursorId !== void 0) return encodeDeltaCursor(cursorId);
+		return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM span_events WHERE eventType = 'start' AND parentSpanId IS NULL AND cursorId IS NOT NULL`))[0]?.cursorId);
+	}
+	const cteSql = `
+    WITH candidate_roots AS (
+      SELECT traceId, spanId, cursorId
+      FROM span_events AS ${outerAlias}
+      ${prefilterWhere}
+    ),
+    root_spans AS (
+      SELECT reconstructed.*, candidate_roots.cursorId AS anchorCursorId
+      FROM (
+        ${SPAN_RECONSTRUCT_SELECT}
+        WHERE (traceId, spanId) IN (SELECT traceId, spanId FROM candidate_roots)
+        GROUP BY traceId, spanId
+      ) AS reconstructed
+      INNER JOIN candidate_roots USING (traceId, spanId)
+    )
+  `;
+	const cursorId = (await db.query(`${cteSql} SELECT max(anchorCursorId) AS cursorId FROM root_spans ${postAggWhere}`, [...prefilterParams, ...postAggParams]))[0]?.cursorId;
+	if (cursorId !== null && cursorId !== void 0) return encodeDeltaCursor(cursorId);
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM span_events WHERE eventType = 'start' AND parentSpanId IS NULL AND cursorId IS NOT NULL`))[0]?.cursorId);
+}
+async function getTraceStreamHeadCursor(db) {
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM span_events WHERE eventType = 'start' AND parentSpanId IS NULL AND cursorId IS NOT NULL`))[0]?.cursorId);
+}
+async function getBranchDeltaCursor(db, filters) {
+	const filterRecord = filters ?? {};
+	const userSpanType = filterRecord.spanType;
+	const { spanType: _spanType, ...rest } = filterRecord;
+	const { prefilter, postAgg } = partitionAnchorFilters(rest);
+	const { clause: prefilterClause, params: prefilterFilterParams } = buildWhereClause(prefilter);
+	const prefilterParts = [`eventType = 'start'`, `cursorId IS NOT NULL`];
+	let spanTypeParams;
+	if (typeof userSpanType === "string") {
+		prefilterParts.push(`spanType = ?`);
+		spanTypeParams = [userSpanType];
+	} else {
+		prefilterParts.push(`spanType IN (${BRANCH_SPAN_TYPE_PLACEHOLDERS})`);
+		spanTypeParams = [...BRANCH_SPAN_TYPES];
+	}
+	if (prefilterClause) prefilterParts.push(prefilterClause.replace(/^WHERE\s+/i, ""));
+	const prefilterWhere = `WHERE ${prefilterParts.join(" AND ")}`;
+	const prefilterParams = [...spanTypeParams, ...prefilterFilterParams];
+	const outerAlias = "outer_anchor";
+	const { clause: postAggClause, params: postAggParams } = buildWhereClause(postAgg);
+	if (!postAggClause) {
+		const cursorId = (await db.query(`SELECT max(cursorId) AS cursorId FROM span_events AS ${outerAlias} ${prefilterWhere}`, prefilterParams))[0]?.cursorId;
+		if (cursorId !== null && cursorId !== void 0) return encodeDeltaCursor(cursorId);
+		return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM span_events WHERE eventType = 'start' AND spanType IN (${BRANCH_SPAN_TYPE_PLACEHOLDERS}) AND cursorId IS NOT NULL`, [...BRANCH_SPAN_TYPES]))[0]?.cursorId);
+	}
+	const cteSql = `
+    WITH candidate_anchors AS (
+      SELECT traceId, spanId, cursorId
+      FROM span_events AS ${outerAlias}
+      ${prefilterWhere}
+    ),
+    branch_anchors AS (
+      SELECT reconstructed.*, candidate_anchors.cursorId AS anchorCursorId
+      FROM (
+        ${SPAN_RECONSTRUCT_SELECT}
+        WHERE (traceId, spanId) IN (SELECT traceId, spanId FROM candidate_anchors)
+        GROUP BY traceId, spanId
+      ) AS reconstructed
+      INNER JOIN candidate_anchors USING (traceId, spanId)
+    )
+  `;
+	const cursorId = (await db.query(`${cteSql} SELECT max(anchorCursorId) AS cursorId FROM branch_anchors ${postAggClause}`, [...prefilterParams, ...postAggParams]))[0]?.cursorId;
+	if (cursorId !== null && cursorId !== void 0) return encodeDeltaCursor(cursorId);
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM span_events WHERE eventType = 'start' AND spanType IN (${BRANCH_SPAN_TYPE_PLACEHOLDERS}) AND cursorId IS NOT NULL`, [...BRANCH_SPAN_TYPES]))[0]?.cursorId);
+}
+async function getBranchStreamHeadCursor(db, userSpanType) {
+	if (userSpanType) return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM span_events WHERE eventType = 'start' AND spanType = ? AND cursorId IS NOT NULL`, [userSpanType]))[0]?.cursorId);
+	return encodeDeltaCursor((await db.query(`SELECT max(cursorId) AS cursorId FROM span_events WHERE eventType = 'start' AND spanType IN (${BRANCH_SPAN_TYPE_PLACEHOLDERS}) AND cursorId IS NOT NULL`, [...BRANCH_SPAN_TYPES]))[0]?.cursorId);
+}
+//#endregion
+//#region src/storage/domains/observability/index.ts
+function buildSignalMigrationRequiredMessage(args) {
+	return `
+===========================================================================
+MIGRATION REQUIRED: DuckDB observability signal tables need signal IDs
+===========================================================================
+
+The following signal tables still use the legacy schema and must be migrated
+before observability storage can initialize:
+
+${args.tables.map((table) => `  - ${table.table}`).join("\n")}\n\nTo fix this, run the manual migration command:\n\n  npx mastra migrate\n\nThis command will:\n  1. Create replacement signal tables with signal-ID primary keys\n  2. Backfill missing signal IDs for legacy rows\n  3. Swap the migrated tables into place\n\nWARNING: This migration recreates the signal tables and may take significant\ntime for large databases. Please ensure you have a backup before proceeding.\n===========================================================================\n`;
+}
+/**
+* DuckDB-backed observability storage for traces, metrics, logs, scores, and feedback.
+* Uses an append-only event-sourced model with SQL-based reconstruction for spans.
+*/
+var ObservabilityStorageDuckDB = class extends ObservabilityStorage {
+	db;
+	constructor(config) {
+		super();
+		this.db = config.db;
+	}
+	/** Create all observability tables if they don't exist. */
+	async init() {
+		const migrationStatus = await checkSignalTablesMigrationStatus(this.db);
+		if (migrationStatus.needsMigration) throw new MastraError({
+			id: createStorageErrorId("DUCKDB", "MIGRATION_REQUIRED", "SIGNAL_TABLES"),
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			text: buildSignalMigrationRequiredMessage({ tables: migrationStatus.tables.map(({ table }) => ({ table })) })
+		});
+		await this.db.executeBatch([...ALL_DDL, ...ALL_MIGRATIONS]);
+		await dropLegacyCursorIdDefaults(this.db);
+	}
+	/**
+	* Manually migrate legacy signal tables to the signal-ID primary-key schema.
+	* The public method name is historical; the CLI still calls `migrateSpans()`
+	* for observability migrations even though this now also migrates signal tables.
+	*/
+	async migrateSpans() {
+		const migrationStatus = await checkSignalTablesMigrationStatus(this.db);
+		if (!migrationStatus.needsMigration) return {
+			success: true,
+			alreadyMigrated: true,
+			duplicatesRemoved: 0,
+			message: "Migration already complete. Signal tables already use signal-ID primary keys."
+		};
+		await migrateSignalTables(this.db, this.logger);
+		return {
+			success: true,
+			alreadyMigrated: false,
+			duplicatesRemoved: 0,
+			message: `Migration complete. Migrated signal tables: ${migrationStatus.tables.map((t) => t.table).join(", ")}.`
+		};
+	}
+	/** Delete all rows from every observability table. Use with caution. */
+	async dangerouslyClearAll() {
+		for (const table of [
+			"span_events",
+			"metric_events",
+			"log_events",
+			"score_events",
+			"feedback_events"
+		]) await this.db.execute(`TRUNCATE TABLE ${table}`);
+	}
+	get observabilityStrategy() {
+		return {
+			preferred: "event-sourced",
+			supported: ["event-sourced"]
+		};
+	}
+	getFeatures() {
+		if (!deltaPollingFeatureEnabled()) return;
+		return ["delta-polling"];
+	}
+	async createSpan(args) {
+		return createSpan(this.db, args);
+	}
+	async batchCreateSpans(args) {
+		return batchCreateSpans(this.db, args);
+	}
+	async batchDeleteTraces(args) {
+		return batchDeleteTraces(this.db, args);
+	}
+	async getSpan(args) {
+		return getSpan(this.db, args);
+	}
+	async getSpans(args) {
+		return getSpans(this.db, args);
+	}
+	async getRootSpan(args) {
+		return getRootSpan(this.db, args);
+	}
+	async getTrace(args) {
+		return getTrace(this.db, args);
+	}
+	async getTraceLight(args) {
+		return getTraceLight(this.db, args);
+	}
+	async listTraces(args) {
+		return listTraces(this.db, args);
+	}
+	async listTracesLight(args) {
+		return listTracesLight(this.db, args);
+	}
+	async listBranches(args) {
+		return listBranches(this.db, args);
+	}
+	async batchCreateLogs(args) {
+		return batchCreateLogs(this.db, args);
+	}
+	async listLogs(args) {
+		return listLogs(this.db, args);
+	}
+	async batchCreateMetrics(args) {
+		return batchCreateMetrics(this.db, args);
+	}
+	async listMetrics(args) {
+		return listMetrics(this.db, args);
+	}
+	async getMetricAggregate(args) {
+		return getMetricAggregate(this.db, args);
+	}
+	async getMetricBreakdown(args) {
+		return getMetricBreakdown(this.db, args);
+	}
+	async getMetricTimeSeries(args) {
+		return getMetricTimeSeries(this.db, args);
+	}
+	async getMetricPercentiles(args) {
+		return getMetricPercentiles(this.db, args);
+	}
+	async getMetricNames(args) {
+		return getMetricNames(this.db, args);
+	}
+	async getMetricLabelKeys(args) {
+		return getMetricLabelKeys(this.db, args);
+	}
+	async getMetricLabelValues(args) {
+		return getMetricLabelValues(this.db, args);
+	}
+	async getEntityTypes(args) {
+		return getEntityTypes(this.db, args);
+	}
+	async getEntityNames(args) {
+		return getEntityNames(this.db, args);
+	}
+	async getServiceNames(args) {
+		return getServiceNames(this.db, args);
+	}
+	async getEnvironments(args) {
+		return getEnvironments(this.db, args);
+	}
+	async getTags(args) {
+		return getTags(this.db, args);
+	}
+	async createScore(args) {
+		return createScore(this.db, args);
+	}
+	async batchCreateScores(args) {
+		return batchCreateScores(this.db, args);
+	}
+	async listScores(args) {
+		return listScores(this.db, args);
+	}
+	async getScoreById(scoreId) {
+		return getScoreById(this.db, scoreId);
+	}
+	async getScoreAggregate(args) {
+		return getScoreAggregate(this.db, args);
+	}
+	async getScoreBreakdown(args) {
+		return getScoreBreakdown(this.db, args);
+	}
+	async getScoreTimeSeries(args) {
+		return getScoreTimeSeries(this.db, args);
+	}
+	async getScorePercentiles(args) {
+		return getScorePercentiles(this.db, args);
+	}
+	async createFeedback(args) {
+		return createFeedback(this.db, args);
+	}
+	async batchCreateFeedback(args) {
+		return batchCreateFeedback(this.db, args);
+	}
+	async listFeedback(args) {
+		return listFeedback(this.db, args);
+	}
+	async getFeedbackAggregate(args) {
+		return getFeedbackAggregate(this.db, args);
+	}
+	async getFeedbackBreakdown(args) {
+		return getFeedbackBreakdown(this.db, args);
+	}
+	async getFeedbackTimeSeries(args) {
+		return getFeedbackTimeSeries(this.db, args);
+	}
+	async getFeedbackPercentiles(args) {
+		return getFeedbackPercentiles(this.db, args);
+	}
+};
+//#endregion
+export { ObservabilityStorageDuckDB };
+
+//# sourceMappingURL=observability-5ro3rotr.js.map