@mastra/pg 1.12.1 → 1.13.0-alpha.1

package/dist/index.cjs

@@ -7,13 +7,14 @@ var vector = require('@mastra/core/vector');
 var asyncMutex = require('async-mutex');
 var pg = require('pg');
 var xxhash = require('xxhash-wasm');
+var pgConnectionString = require('pg-connection-string');
 var filter = require('@mastra/core/vector/filter');
 var base = require('@mastra/core/base');
 var crypto$1 = require('crypto');
 var module$1 = require('module');
 var agent = require('@mastra/core/agent');
+var features = require('@mastra/core/features');
 var evals = require('@mastra/core/evals');
-var pgConnectionString = require('pg-connection-string');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -90,6 +91,15 @@ var validateConfig = (name, config) => {
     );
   }
 };
+function buildConnectionStringPoolConfig(config, defaults) {
+  const parsed = pgConnectionString.parse(config.connectionString);
+  return {
+    ...parsed,
+    ...config.ssl !== void 0 ? { ssl: config.ssl } : {},
+    max: config.max ?? defaults.max,
+    idleTimeoutMillis: config.idleTimeoutMillis ?? defaults.idleTimeoutMillis
+  };
+}
 var PGFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -637,10 +647,7 @@ var PgVector = class extends vector.MastraVector {
       let poolConfig;
       if (isConnectionStringConfig(config)) {
         poolConfig = {
-          connectionString: config.connectionString,
-          ssl: config.ssl,
-          max: config.max ?? 20,
-          idleTimeoutMillis: config.idleTimeoutMillis ?? 3e4,
+          ...buildConnectionStringPoolConfig(config, { max: 20, idleTimeoutMillis: 3e4 }),
           connectionTimeoutMillis: 2e3,
           ...config.pgPoolOptions
         };
@@ -3554,7 +3561,15 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
     await this.#db.alterTable({
       tableName: storage.TABLE_AGENT_VERSIONS,
       schema: storage.TABLE_SCHEMAS[storage.TABLE_AGENT_VERSIONS],
-      ifNotExists: ["mcpClients", "requestContextSchema", "workspace", "skills", "skillsFormat", "browser"]
+      ifNotExists: [
+        "mcpClients",
+        "requestContextSchema",
+        "workspace",
+        "skills",
+        "skillsFormat",
+        "browser",
+        "toolProviders"
+      ]
     });
     await this.#migrateToolsToJsonbFormat();
     await this.createDefaultIndexes();
@@ -3607,9 +3622,9 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       await this.#db.client.none(
         `INSERT INTO ${fullVersionsTableName}
          (id, "agentId", "versionNumber", name, description, instructions, model, tools,
-          "defaultOptions", workflows, agents, "integrationTools", "inputProcessors",
+          "defaultOptions", workflows, agents, "integrationTools", "toolProviders", "inputProcessors",
           "outputProcessors", memory, scorers, "changedFields", "changeMessage", "createdAt")
-         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19)
+         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20)
          ON CONFLICT (id) DO NOTHING`,
         [
           versionId,
@@ -3624,6 +3639,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
           row.workflows ? JSON.stringify(row.workflows) : null,
           row.agents ? JSON.stringify(row.agents) : null,
           row.integrationTools ? JSON.stringify(row.integrationTools) : null,
+          row.toolProviders ? JSON.stringify(row.toolProviders) : null,
           row.inputProcessors ? JSON.stringify(row.inputProcessors) : null,
           row.outputProcessors ? JSON.stringify(row.outputProcessors) : null,
           row.memory ? JSON.stringify(row.memory) : null,
@@ -4076,13 +4092,13 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
         `INSERT INTO ${tableName} (
           id, "agentId", "versionNumber",
           name, description, instructions, model, tools,
-          "defaultOptions", workflows, agents, "integrationTools",
+          "defaultOptions", workflows, agents, "integrationTools", "toolProviders",
           "inputProcessors", "outputProcessors", memory, scorers,
           "mcpClients", "requestContextSchema", workspace, skills, "skillsFormat",
           browser,
           "changedFields", "changeMessage",
           "createdAt", "createdAtZ"
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26)`,
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27)`,
         [
           input.id,
           input.agentId,
@@ -4096,6 +4112,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
           input.workflows ? JSON.stringify(input.workflows) : null,
           input.agents ? JSON.stringify(input.agents) : null,
           input.integrationTools ? JSON.stringify(input.integrationTools) : null,
+          input.toolProviders ? JSON.stringify(input.toolProviders) : null,
           input.inputProcessors ? JSON.stringify(input.inputProcessors) : null,
           input.outputProcessors ? JSON.stringify(input.outputProcessors) : null,
           input.memory ? JSON.stringify(input.memory) : null,
@@ -4346,6 +4363,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       workflows: parseJsonResilient(row.workflows),
       agents: parseJsonResilient(row.agents),
       integrationTools: parseJsonResilient(row.integrationTools),
+      toolProviders: parseJsonResilient(row.toolProviders),
       inputProcessors: parseJsonResilient(row.inputProcessors),
       outputProcessors: parseJsonResilient(row.outputProcessors),
       memory: parseJsonResilient(row.memory),
@@ -4384,6 +4402,10 @@ function parseJson(v) {
   return v ?? void 0;
 }
 function rowToTask(row) {
+  const createdAt = row.createdAtZ || row.createdAt;
+  const startedAt = row.startedAtZ || row.startedAt;
+  const suspendedAt = row.suspendedAtZ || row.suspendedAt;
+  const completedAt = row.completedAtZ || row.completedAt;
   return {
     id: row.id,
     status: row.status,
@@ -4400,10 +4422,10 @@ function rowToTask(row) {
     retryCount: Number(row.retry_count),
     maxRetries: Number(row.max_retries),
     timeoutMs: Number(row.timeout_ms),
-    createdAt: new Date(row.createdAtZ || row.createdAt),
-    startedAt: row.startedAtZ || row.startedAt ? new Date(row.startedAtZ || row.startedAt) : void 0,
-    suspendedAt: row.suspendedAtZ || row.suspendedAt ? new Date(row.suspendedAtZ || row.suspendedAt) : void 0,
-    completedAt: row.completedAtZ || row.completedAt ? new Date(row.completedAtZ || row.completedAt) : void 0
+    createdAt: createdAt instanceof Date ? createdAt : new Date(createdAt),
+    startedAt: startedAt ? startedAt instanceof Date ? startedAt : new Date(startedAt) : void 0,
+    suspendedAt: suspendedAt ? suspendedAt instanceof Date ? suspendedAt : new Date(suspendedAt) : void 0,
+    completedAt: completedAt ? completedAt instanceof Date ? completedAt : new Date(completedAt) : void 0
   };
 }
 var BackgroundTasksPG = class _BackgroundTasksPG extends storage.BackgroundTasksStorage {
@@ -4521,9 +4543,13 @@ var BackgroundTasksPG = class _BackgroundTasksPG extends storage.BackgroundTasks
         max_retries: task.maxRetries,
         timeout_ms: task.timeoutMs,
         createdAt: task.createdAt.toISOString(),
+        createdAtZ: task.createdAt.toISOString(),
         startedAt: task.startedAt?.toISOString() ?? null,
+        startedAtZ: task.startedAt?.toISOString() ?? null,
         suspendedAt: task.suspendedAt?.toISOString() ?? null,
-        completedAt: task.completedAt?.toISOString() ?? null
+        suspendedAtZ: task.suspendedAt?.toISOString() ?? null,
+        completedAt: task.completedAt?.toISOString() ?? null,
+        completedAtZ: task.completedAt?.toISOString() ?? null
       }
     });
   }
@@ -4700,6 +4726,16 @@ var BlobsPG = class extends storage.BlobStore {
     this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
     this.#schema = schemaName || "public";
   }
+  static getExportDDL(schemaName) {
+    return [
+      generateTableSQL({
+        tableName: storage.TABLE_SKILL_BLOBS,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_SKILL_BLOBS],
+        schemaName,
+        includeAllConstraints: true
+      })
+    ];
+  }
   async init() {
     await this.#db.createTable({
       tableName: storage.TABLE_SKILL_BLOBS,
@@ -6778,16 +6814,39 @@ var MCPClientsPG = class _MCPClientsPG extends storage.MCPClientsStorage {
     this.#skipDefaultIndexes = skipDefaultIndexes;
     this.#indexes = indexes?.filter((idx) => _MCPClientsPG.MANAGED_TABLES.includes(idx.table));
   }
-  getDefaultIndexDefinitions() {
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
-        name: "idx_mcp_client_versions_client_version",
+        name: `${schemaPrefix}idx_mcp_client_versions_client_version`,
         table: storage.TABLE_MCP_CLIENT_VERSIONS,
         columns: ["mcpClientId", "versionNumber"],
         unique: true
       }
     ];
   }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    for (const tableName of _MCPClientsPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    for (const idx of _MCPClientsPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _MCPClientsPG.getDefaultIndexDefs(schemaPrefix);
+  }
   async createDefaultIndexes() {
     if (this.#skipDefaultIndexes) {
       return;
@@ -7391,16 +7450,39 @@ var MCPServersPG = class _MCPServersPG extends storage.MCPServersStorage {
     this.#skipDefaultIndexes = skipDefaultIndexes;
     this.#indexes = indexes?.filter((idx) => _MCPServersPG.MANAGED_TABLES.includes(idx.table));
   }
-  getDefaultIndexDefinitions() {
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
-        name: "idx_mcp_server_versions_server_version",
+        name: `${schemaPrefix}idx_mcp_server_versions_server_version`,
         table: storage.TABLE_MCP_SERVER_VERSIONS,
         columns: ["mcpServerId", "versionNumber"],
         unique: true
       }
     ];
   }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    for (const tableName of _MCPServersPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    for (const idx of _MCPServersPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _MCPServersPG.getDefaultIndexDefs(schemaPrefix);
+  }
   async createDefaultIndexes() {
     if (this.#skipDefaultIndexes) {
       return;
@@ -11463,109 +11545,3348 @@ var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorag
     }
   }
 };
-var SNAPSHOT_FIELDS3 = ["name", "description", "content", "rules", "requestContextSchema"];
-var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
-  #db;
-  #schema;
-  #skipDefaultIndexes;
-  #indexes;
-  static MANAGED_TABLES = [storage.TABLE_PROMPT_BLOCKS, storage.TABLE_PROMPT_BLOCK_VERSIONS];
-  constructor(config) {
-    super();
-    const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
-    this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
-    this.#schema = schemaName || "public";
-    this.#skipDefaultIndexes = skipDefaultIndexes;
-    this.#indexes = indexes?.filter((idx) => _PromptBlocksPG.MANAGED_TABLES.includes(idx.table));
-  }
-  /**
-   * Returns default index definitions for the prompt blocks domain tables.
-   * @param schemaPrefix - Prefix for index names (e.g. "my_schema_" or "")
-   */
-  static getDefaultIndexDefs(schemaPrefix) {
-    return [
-      {
-        name: `${schemaPrefix}idx_prompt_block_versions_block_version`,
-        table: storage.TABLE_PROMPT_BLOCK_VERSIONS,
-        columns: ["blockId", "versionNumber"],
-        unique: true
+
+// src/storage/domains/observability/v-next/signal-schema.ts
+var CURSOR_ID_COLUMN = { name: "cursorId", type: "bigserial" };
+var XACT_ID_COLUMN = {
+  name: "xactId",
+  type: "xid8",
+  defaultSql: "pg_current_xact_id()"
+};
+var COMMON_CONTEXT_COLUMNS = [
+  { name: "traceId", type: "text", nullable: true },
+  { name: "spanId", type: "text", nullable: true },
+  { name: "experimentId", type: "text", nullable: true },
+  { name: "entityType", type: "text", nullable: true },
+  { name: "entityId", type: "text", nullable: true },
+  { name: "entityName", type: "text", nullable: true },
+  { name: "entityVersionId", type: "text", nullable: true },
+  { name: "parentEntityType", type: "text", nullable: true },
+  { name: "parentEntityId", type: "text", nullable: true },
+  { name: "parentEntityName", type: "text", nullable: true },
+  { name: "parentEntityVersionId", type: "text", nullable: true },
+  { name: "rootEntityType", type: "text", nullable: true },
+  { name: "rootEntityId", type: "text", nullable: true },
+  { name: "rootEntityName", type: "text", nullable: true },
+  { name: "rootEntityVersionId", type: "text", nullable: true },
+  { name: "userId", type: "text", nullable: true },
+  { name: "organizationId", type: "text", nullable: true },
+  { name: "resourceId", type: "text", nullable: true },
+  { name: "runId", type: "text", nullable: true },
+  { name: "sessionId", type: "text", nullable: true },
+  { name: "threadId", type: "text", nullable: true },
+  { name: "requestId", type: "text", nullable: true },
+  { name: "environment", type: "text", nullable: true },
+  { name: "executionSource", type: "text", nullable: true },
+  { name: "serviceName", type: "text", nullable: true }
+];
+var SPAN_EVENT_COLUMNS = [
+  CURSOR_ID_COLUMN,
+  XACT_ID_COLUMN,
+  { name: "traceId", type: "text" },
+  { name: "spanId", type: "text" },
+  { name: "parentSpanId", type: "text", nullable: true },
+  { name: "experimentId", type: "text", nullable: true },
+  { name: "entityType", type: "text", nullable: true },
+  { name: "entityId", type: "text", nullable: true },
+  { name: "entityName", type: "text", nullable: true },
+  { name: "entityVersionId", type: "text", nullable: true },
+  { name: "parentEntityType", type: "text", nullable: true },
+  { name: "parentEntityId", type: "text", nullable: true },
+  { name: "parentEntityName", type: "text", nullable: true },
+  { name: "parentEntityVersionId", type: "text", nullable: true },
+  { name: "rootEntityType", type: "text", nullable: true },
+  { name: "rootEntityId", type: "text", nullable: true },
+  { name: "rootEntityName", type: "text", nullable: true },
+  { name: "rootEntityVersionId", type: "text", nullable: true },
+  { name: "userId", type: "text", nullable: true },
+  { name: "organizationId", type: "text", nullable: true },
+  { name: "resourceId", type: "text", nullable: true },
+  { name: "runId", type: "text", nullable: true },
+  { name: "sessionId", type: "text", nullable: true },
+  { name: "threadId", type: "text", nullable: true },
+  { name: "requestId", type: "text", nullable: true },
+  { name: "environment", type: "text", nullable: true },
+  { name: "executionSource", type: "text", nullable: true },
+  { name: "serviceName", type: "text", nullable: true },
+  { name: "name", type: "text" },
+  { name: "spanType", type: "text" },
+  { name: "isEvent", type: "boolean", defaultSql: "false" },
+  { name: "startedAt", type: "timestamptz" },
+  { name: "endedAt", type: "timestamptz" },
+  { name: "tags", type: "text[]", defaultSql: "'{}'" },
+  { name: "metadataSearch", type: "jsonb", defaultSql: "'{}'::jsonb" },
+  { name: "attributes", type: "jsonb", nullable: true },
+  { name: "scope", type: "jsonb", nullable: true },
+  { name: "links", type: "jsonb", nullable: true },
+  { name: "input", type: "jsonb", nullable: true },
+  { name: "output", type: "jsonb", nullable: true },
+  { name: "error", type: "jsonb", nullable: true },
+  { name: "metadataRaw", type: "jsonb", nullable: true },
+  { name: "requestContext", type: "jsonb", nullable: true }
+];
+var METRIC_EVENT_COLUMNS = [
+  CURSOR_ID_COLUMN,
+  XACT_ID_COLUMN,
+  { name: "metricId", type: "text" },
+  { name: "timestamp", type: "timestamptz" },
+  { name: "name", type: "text" },
+  { name: "value", type: "double precision" },
+  ...COMMON_CONTEXT_COLUMNS,
+  { name: "provider", type: "text", nullable: true },
+  { name: "model", type: "text", nullable: true },
+  { name: "estimatedCost", type: "double precision", nullable: true },
+  { name: "costUnit", type: "text", nullable: true },
+  { name: "tags", type: "text[]", defaultSql: "'{}'" },
+  { name: "labels", type: "jsonb", defaultSql: "'{}'::jsonb" },
+  { name: "costMetadata", type: "jsonb", nullable: true },
+  { name: "metadata", type: "jsonb", nullable: true },
+  { name: "scope", type: "jsonb", nullable: true }
+];
+var LOG_EVENT_COLUMNS = [
+  CURSOR_ID_COLUMN,
+  XACT_ID_COLUMN,
+  { name: "logId", type: "text" },
+  { name: "timestamp", type: "timestamptz" },
+  { name: "level", type: "text" },
+  { name: "message", type: "text" },
+  ...COMMON_CONTEXT_COLUMNS,
+  { name: "tags", type: "text[]", defaultSql: "'{}'" },
+  { name: "data", type: "jsonb", nullable: true },
+  { name: "metadata", type: "jsonb", nullable: true },
+  { name: "scope", type: "jsonb", nullable: true }
+];
+var SCORE_EVENT_COLUMNS = [
+  CURSOR_ID_COLUMN,
+  XACT_ID_COLUMN,
+  { name: "scoreId", type: "text" },
+  { name: "timestamp", type: "timestamptz" },
+  { name: "scorerId", type: "text" },
+  { name: "scorerVersion", type: "text", nullable: true },
+  { name: "scoreSource", type: "text", nullable: true },
+  { name: "score", type: "double precision" },
+  { name: "reason", type: "text", nullable: true },
+  ...COMMON_CONTEXT_COLUMNS,
+  { name: "scoreTraceId", type: "text", nullable: true },
+  { name: "tags", type: "text[]", defaultSql: "'{}'" },
+  { name: "metadata", type: "jsonb", nullable: true },
+  { name: "scope", type: "jsonb", nullable: true }
+];
+var FEEDBACK_EVENT_COLUMNS = [
+  CURSOR_ID_COLUMN,
+  XACT_ID_COLUMN,
+  { name: "feedbackId", type: "text" },
+  { name: "timestamp", type: "timestamptz" },
+  { name: "feedbackSource", type: "text" },
+  { name: "feedbackType", type: "text" },
+  { name: "valueString", type: "text", nullable: true },
+  { name: "valueNumber", type: "double precision", nullable: true },
+  { name: "comment", type: "text", nullable: true },
+  { name: "feedbackUserId", type: "text", nullable: true },
+  { name: "sourceId", type: "text", nullable: true },
+  ...COMMON_CONTEXT_COLUMNS,
+  { name: "tags", type: "text[]", defaultSql: "'{}'" },
+  { name: "metadata", type: "jsonb", nullable: true },
+  { name: "scope", type: "jsonb", nullable: true }
+];
+var SPAN_LIGHT_SELECT_COLUMN_NAMES = [
+  "cursorId",
+  "xactId",
+  "traceId",
+  "spanId",
+  "parentSpanId",
+  "name",
+  "entityType",
+  "entityId",
+  "entityName",
+  "spanType",
+  "error",
+  "isEvent",
+  "startedAt",
+  "endedAt"
+];
+function quotedColumnName(name) {
+  return `"${name}"`;
+}
+function columnDefinition(column) {
+  const nullable = column.nullable ? "" : " NOT NULL";
+  const defaultSql = column.defaultSql ? ` DEFAULT ${column.defaultSql}` : "";
+  return `  ${quotedColumnName(column.name)} ${column.type}${nullable}${defaultSql}`;
+}
+function buildColumnDefinitions(columns) {
+  return columns.map(columnDefinition).join(",\n");
+}
+function buildSelectColumns(columns) {
+  return `
+  ${columns.map((column) => quotedColumnName(column.name)).join(",\n  ")}
+`;
+}
+function buildNamedSelectColumns(columnNames) {
+  return `
+  ${columnNames.map(quotedColumnName).join(",\n  ")}
+`;
+}
+function columnNamesByType(columns, type) {
+  return columns.filter((column) => column.type === type).map((column) => column.name);
+}
+function typedColumnNames(columns) {
+  return new Set(
+    columns.filter((column) => !["bigserial", "jsonb", "text[]", "xid8"].includes(column.type)).map((column) => column.name)
+  );
+}
+var ALL_EVENT_COLUMNS = [
+  ...SPAN_EVENT_COLUMNS,
+  ...METRIC_EVENT_COLUMNS,
+  ...LOG_EVENT_COLUMNS,
+  ...SCORE_EVENT_COLUMNS,
+  ...FEEDBACK_EVENT_COLUMNS
+];
+var JSONB_COLUMNS = new Set(columnNamesByType(ALL_EVENT_COLUMNS, "jsonb"));
+var TEXT_ARRAY_COLUMNS = new Set(columnNamesByType(ALL_EVENT_COLUMNS, "text[]"));
+var METRIC_TYPED_COLUMNS = typedColumnNames(METRIC_EVENT_COLUMNS);
+var SCORE_TYPED_COLUMNS = typedColumnNames(SCORE_EVENT_COLUMNS);
+var FEEDBACK_TYPED_COLUMNS = typedColumnNames(FEEDBACK_EVENT_COLUMNS);
+
+// src/storage/domains/observability/v-next/ddl.ts
+var TABLE_SPAN_EVENTS = "mastra_span_events";
+var TABLE_METRIC_EVENTS = "mastra_metric_events";
+var TABLE_LOG_EVENTS = "mastra_log_events";
+var TABLE_SCORE_EVENTS = "mastra_score_events";
+var TABLE_FEEDBACK_EVENTS = "mastra_feedback_events";
+var TABLE_DISCOVERY = "mastra_observability_discovery";
+var ALL_SIGNAL_TABLES = [
+  TABLE_SPAN_EVENTS,
+  TABLE_METRIC_EVENTS,
+  TABLE_LOG_EVENTS,
+  TABLE_SCORE_EVENTS,
+  TABLE_FEEDBACK_EVENTS
+];
+var SIGNAL_TIME_COLUMN = {
+  [TABLE_SPAN_EVENTS]: "endedAt",
+  [TABLE_METRIC_EVENTS]: "timestamp",
+  [TABLE_LOG_EVENTS]: "timestamp",
+  [TABLE_SCORE_EVENTS]: "timestamp",
+  [TABLE_FEEDBACK_EVENTS]: "timestamp"
+};
+function qualifiedTable(schema, table) {
+  const s = utils.parseSqlIdentifier(schema, "schema name");
+  const t = utils.parseSqlIdentifier(table, "table name");
+  return `"${s}"."${t}"`;
+}
+function qualifiedName(schema, name) {
+  const s = utils.parseSqlIdentifier(schema, "schema name");
+  const n = utils.parseSqlIdentifier(name, "object name");
+  return `"${s}"."${n}"`;
+}
+function schemaDDL(schema) {
+  const s = utils.parseSqlIdentifier(schema, "schema name");
+  return `CREATE SCHEMA IF NOT EXISTS "${s}"`;
+}
+function partitionClause(mode, column) {
+  return mode === "timescale" ? "" : `PARTITION BY RANGE ("${column}")`;
+}
+function spanEventsTableDDL(schema, mode) {
+  return `
+CREATE TABLE IF NOT EXISTS ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} (
+${buildColumnDefinitions(SPAN_EVENT_COLUMNS)},
+  PRIMARY KEY ("traceId", "spanId", "endedAt")
+)
+${partitionClause(mode, "endedAt")}
+`.trim();
+}
+function metricEventsTableDDL(schema, mode) {
+  return `
+CREATE TABLE IF NOT EXISTS ${qualifiedTable(schema, TABLE_METRIC_EVENTS)} (
+${buildColumnDefinitions(METRIC_EVENT_COLUMNS)},
+  PRIMARY KEY ("metricId", "timestamp")
+)
+${partitionClause(mode, "timestamp")}
+`.trim();
+}
+function logEventsTableDDL(schema, mode) {
+  return `
+CREATE TABLE IF NOT EXISTS ${qualifiedTable(schema, TABLE_LOG_EVENTS)} (
+${buildColumnDefinitions(LOG_EVENT_COLUMNS)},
+  PRIMARY KEY ("logId", "timestamp")
+)
+${partitionClause(mode, "timestamp")}
+`.trim();
+}
+function scoreEventsTableDDL(schema, mode) {
+  return `
+CREATE TABLE IF NOT EXISTS ${qualifiedTable(schema, TABLE_SCORE_EVENTS)} (
+${buildColumnDefinitions(SCORE_EVENT_COLUMNS)},
+  PRIMARY KEY ("scoreId", "timestamp")
+)
+${partitionClause(mode, "timestamp")}
+`.trim();
+}
+function feedbackEventsTableDDL(schema, mode) {
+  return `
+CREATE TABLE IF NOT EXISTS ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)} (
+${buildColumnDefinitions(FEEDBACK_EVENT_COLUMNS)},
+  PRIMARY KEY ("feedbackId", "timestamp")
+)
+${partitionClause(mode, "timestamp")}
+`.trim();
+}
+function discoveryTableDDL(schema) {
+  return `
+CREATE TABLE IF NOT EXISTS ${qualifiedTable(schema, TABLE_DISCOVERY)} (
+  "cacheKey"              text PRIMARY KEY,
+  "refreshedAt"           timestamptz NOT NULL,
+  "values"                jsonb NOT NULL DEFAULT '[]'::jsonb
+)
+`.trim();
+}
+var ROOT_SPAN_WHERE = '"parentSpanId" IS NULL';
+function tableIndexes() {
+  return [
+    // span_events — full-table indexes used by getTrace / getSpan
+    { name: "mastra_span_events_traceid_idx", table: TABLE_SPAN_EVENTS, columns: '("traceId", "endedAt" DESC)' },
+    {
+      name: "mastra_span_events_parentspan_idx",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("parentSpanId", "endedAt" DESC)'
+    },
+    { name: "mastra_span_events_name_idx", table: TABLE_SPAN_EVENTS, columns: '("name")' },
+    // Used by listBranches page mode (filter by spanType, order by startedAt).
+    { name: "mastra_span_events_spantype_idx", table: TABLE_SPAN_EVENTS, columns: '("spanType", "startedAt" DESC)' },
+    { name: "mastra_span_events_entity_idx", table: TABLE_SPAN_EVENTS, columns: '("entityType", "entityId")' },
+    {
+      name: "mastra_span_events_orgid_userid_idx",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("organizationId", "userId")'
+    },
+    {
+      name: "mastra_span_events_metadatasearch_gin",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("metadataSearch" jsonb_path_ops)',
+      using: "gin"
+    },
+    { name: "mastra_span_events_tags_gin", table: TABLE_SPAN_EVENTS, columns: '("tags")', using: "gin" },
+    // span_events — partial indexes acting as the root-span projection. The
+    // listTraces filter surface (startedAt / spanType / entityType / etc.) is
+    // covered by these; rows where parentSpanId IS NOT NULL are excluded from
+    // the index, so the index is the size of a separate trace_roots table.
+    {
+      name: "mastra_span_events_root_startedat_idx",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("startedAt" DESC)',
+      where: ROOT_SPAN_WHERE
+    },
+    {
+      name: "mastra_span_events_root_endedat_idx",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("endedAt" DESC)',
+      where: ROOT_SPAN_WHERE
+    },
+    {
+      name: "mastra_span_events_root_spantype_idx",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("spanType", "startedAt" DESC)',
+      where: ROOT_SPAN_WHERE
+    },
+    {
+      name: "mastra_span_events_root_entityname_idx",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("entityType", "entityName", "startedAt" DESC)',
+      where: ROOT_SPAN_WHERE
+    },
+    {
+      name: "mastra_span_events_root_traceid_idx",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("traceId")',
+      where: ROOT_SPAN_WHERE
+    },
+    // Delta polling: transaction-safe cursor ordering. Full-table coverage so the same index
+    // serves both listTraces (combined with the `parentSpanId IS NULL`
+    // predicate) and listBranches (combined with `spanType IN (...)`).
+    {
+      name: "mastra_span_events_cursor_idx",
+      table: TABLE_SPAN_EVENTS,
+      columns: '("xactId", "cursorId")'
+    },
+    // metric_events
+    { name: "mastra_metric_events_name_ts_idx", table: TABLE_METRIC_EVENTS, columns: '("name", "timestamp" DESC)' },
+    {
+      name: "mastra_metric_events_entity_idx",
+      table: TABLE_METRIC_EVENTS,
+      columns: '("entityType", "entityId", "timestamp" DESC)'
+    },
+    { name: "mastra_metric_events_traceid_idx", table: TABLE_METRIC_EVENTS, columns: '("traceId")' },
+    { name: "mastra_metric_events_labels_gin", table: TABLE_METRIC_EVENTS, columns: '("labels")', using: "gin" },
+    { name: "mastra_metric_events_tags_gin", table: TABLE_METRIC_EVENTS, columns: '("tags")', using: "gin" },
+    { name: "mastra_metric_events_cursor_idx", table: TABLE_METRIC_EVENTS, columns: '("xactId", "cursorId")' },
+    // log_events
+    { name: "mastra_log_events_ts_idx", table: TABLE_LOG_EVENTS, columns: '("timestamp" DESC)' },
+    { name: "mastra_log_events_level_ts_idx", table: TABLE_LOG_EVENTS, columns: '("level", "timestamp" DESC)' },
+    { name: "mastra_log_events_traceid_idx", table: TABLE_LOG_EVENTS, columns: '("traceId")' },
+    {
+      name: "mastra_log_events_entity_idx",
+      table: TABLE_LOG_EVENTS,
+      columns: '("entityType", "entityId", "timestamp" DESC)'
+    },
+    { name: "mastra_log_events_tags_gin", table: TABLE_LOG_EVENTS, columns: '("tags")', using: "gin" },
+    { name: "mastra_log_events_cursor_idx", table: TABLE_LOG_EVENTS, columns: '("xactId", "cursorId")' },
+    // score_events
+    { name: "mastra_score_events_traceid_idx", table: TABLE_SCORE_EVENTS, columns: '("traceId", "timestamp" DESC)' },
+    { name: "mastra_score_events_scorerid_idx", table: TABLE_SCORE_EVENTS, columns: '("scorerId", "timestamp" DESC)' },
+    {
+      name: "mastra_score_events_entity_idx",
+      table: TABLE_SCORE_EVENTS,
+      columns: '("entityType", "entityId", "timestamp" DESC)'
+    },
+    { name: "mastra_score_events_tags_gin", table: TABLE_SCORE_EVENTS, columns: '("tags")', using: "gin" },
+    { name: "mastra_score_events_cursor_idx", table: TABLE_SCORE_EVENTS, columns: '("xactId", "cursorId")' },
+    // feedback_events
+    {
+      name: "mastra_feedback_events_traceid_idx",
+      table: TABLE_FEEDBACK_EVENTS,
+      columns: '("traceId", "timestamp" DESC)'
+    },
+    {
+      name: "mastra_feedback_events_type_idx",
+      table: TABLE_FEEDBACK_EVENTS,
+      columns: '("feedbackType", "timestamp" DESC)'
+    },
+    {
+      name: "mastra_feedback_events_entity_idx",
+      table: TABLE_FEEDBACK_EVENTS,
+      columns: '("entityType", "entityId", "timestamp" DESC)'
+    },
+    { name: "mastra_feedback_events_tags_gin", table: TABLE_FEEDBACK_EVENTS, columns: '("tags")', using: "gin" },
+    { name: "mastra_feedback_events_cursor_idx", table: TABLE_FEEDBACK_EVENTS, columns: '("xactId", "cursorId")' }
+  ];
+}
+function indexDDL(schema, spec) {
+  const idxName = utils.parseSqlIdentifier(spec.name, "index name");
+  const using = spec.using ? `USING ${spec.using}` : "";
+  const where = spec.where ? `WHERE ${spec.where}` : "";
+  return `CREATE INDEX IF NOT EXISTS "${idxName}" ON ${qualifiedTable(schema, spec.table)} ${using} ${spec.columns} ${where}`.replace(
+    /\s+/g,
+    " "
+  );
+}
+function allTableDDL(schema, mode) {
+  return [
+    spanEventsTableDDL(schema, mode),
+    metricEventsTableDDL(schema, mode),
+    logEventsTableDDL(schema, mode),
+    scoreEventsTableDDL(schema, mode),
+    feedbackEventsTableDDL(schema, mode),
+    discoveryTableDDL(schema)
+  ];
+}
+function allIndexDDL(schema) {
+  return tableIndexes().map((spec) => indexDDL(schema, spec));
+}
+var DEFAULT_TTL_SECONDS = 5 * 60;
+var SIGNAL_TABLES_WITH_CONTEXT = [
+  TABLE_SPAN_EVENTS,
+  TABLE_METRIC_EVENTS,
+  TABLE_LOG_EVENTS,
+  TABLE_SCORE_EVENTS,
+  TABLE_FEEDBACK_EVENTS
+];
+var ENTITY_DISCOVERY_TABLES = [TABLE_SPAN_EVENTS, TABLE_METRIC_EVENTS, TABLE_LOG_EVENTS];
+var inFlightRefreshes = /* @__PURE__ */ new Map();
+function startOrJoinRefresh(dedupeKey, cacheKey, refresh, upsert, logger) {
+  const existing = inFlightRefreshes.get(dedupeKey);
+  if (existing) return existing;
+  const promise = (async () => {
+    try {
+      const values = await refresh();
+      await upsert(values);
+      return values;
+    } catch (error) {
+      const message = `[observability/v-next] background refresh failed for discovery cache key "${cacheKey}"`;
+      if (logger) {
+        logger.warn(message, { error });
+      } else {
+        console.warn(message + ":", error);
       }
-    ];
-  }
-  /**
-   * Returns all DDL statements for this domain: tables and indexes.
-   * Used by exportSchemas to produce a complete, reproducible schema export.
-   */
-  static getExportDDL(schemaName) {
-    const statements = [];
-    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
-    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
-    for (const tableName of _PromptBlocksPG.MANAGED_TABLES) {
-      statements.push(
-        generateTableSQL({
-          tableName,
-          schema: storage.TABLE_SCHEMAS[tableName],
-          schemaName,
-          includeAllConstraints: true
-        })
-      );
+      throw error;
+    } finally {
+      inFlightRefreshes.delete(dedupeKey);
     }
-    for (const idx of _PromptBlocksPG.getDefaultIndexDefs(schemaPrefix)) {
-      statements.push(generateIndexSQL(idx, schemaName));
+  })();
+  inFlightRefreshes.set(dedupeKey, promise);
+  return promise;
+}
+async function readWithRefresh(client, schema, cacheKey, refresh, ttlSeconds, logger) {
+  const table = qualifiedTable(schema, TABLE_DISCOVERY);
+  const row = await client.oneOrNone(
+    `SELECT "values", "refreshedAt" FROM ${table} WHERE "cacheKey" = $1`,
+    [cacheKey]
+  );
+  const refreshedAtMs = row ? new Date(row.refreshedAt).getTime() : 0;
+  const stale = !row || Date.now() - refreshedAtMs > ttlSeconds * 1e3;
+  if (!stale) return row.values;
+  const dedupeKey = `${schema}:${cacheKey}`;
+  const refreshing = startOrJoinRefresh(
+    dedupeKey,
+    cacheKey,
+    refresh,
+    (values) => upsertCache(client, schema, cacheKey, values),
+    logger
+  );
+  if (ttlSeconds <= 0) {
+    try {
+      return await refreshing;
+    } catch {
+      return row?.values ?? [];
     }
-    return statements;
-  }
-  getDefaultIndexDefinitions() {
-    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
-    return _PromptBlocksPG.getDefaultIndexDefs(schemaPrefix);
   }
-  async createDefaultIndexes() {
-    if (this.#skipDefaultIndexes) {
-      return;
-    }
-    for (const indexDef of this.getDefaultIndexDefinitions()) {
-      try {
-        await this.#db.createIndex(indexDef);
-      } catch {
-      }
+  if (!row) {
+    try {
+      return await refreshing;
+    } catch {
+      return [];
     }
   }
-  async init() {
-    await this.#db.createTable({ tableName: storage.TABLE_PROMPT_BLOCKS, schema: storage.TABLE_SCHEMAS[storage.TABLE_PROMPT_BLOCKS] });
-    await this.#db.createTable({
-      tableName: storage.TABLE_PROMPT_BLOCK_VERSIONS,
-      schema: storage.TABLE_SCHEMAS[storage.TABLE_PROMPT_BLOCK_VERSIONS]
-    });
-    await this.#db.alterTable({
-      tableName: storage.TABLE_PROMPT_BLOCK_VERSIONS,
-      schema: storage.TABLE_SCHEMAS[storage.TABLE_PROMPT_BLOCK_VERSIONS],
-      ifNotExists: ["requestContextSchema"]
-    });
-    await this.createDefaultIndexes();
-    await this.createCustomIndexes();
+  refreshing.catch(() => {
+  });
+  return row.values;
+}
+async function upsertCache(client, schema, cacheKey, values) {
+  const table = qualifiedTable(schema, TABLE_DISCOVERY);
+  await client.query(
+    `INSERT INTO ${table} ("cacheKey", "refreshedAt", "values")
+     VALUES ($1, NOW(), $2::jsonb)
+     ON CONFLICT ("cacheKey") DO UPDATE SET
+       "refreshedAt" = EXCLUDED."refreshedAt",
+       "values" = EXCLUDED."values"`,
+    [cacheKey, JSON.stringify(values)]
+  );
+}
+async function distinctAcrossTables(client, schema, column, tables, filterSql = "", filterParams = []) {
+  const safeColumn = utils.parseSqlIdentifier(column, "column name");
+  const unions = tables.map(
+    (t) => `SELECT DISTINCT "${safeColumn}" AS v FROM ${qualifiedTable(schema, t)} WHERE "${safeColumn}" IS NOT NULL AND "${safeColumn}" <> '' ${filterSql}`
+  ).join(" UNION ");
+  const rows = await client.manyOrNone(`SELECT v FROM (${unions}) sub ORDER BY v`, filterParams);
+  return rows.map((r) => r.v);
+}
+async function getEntityTypes(client, schema, _args, config) {
+  const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const values = await readWithRefresh(
+    client,
+    schema,
+    "entity_types",
+    () => distinctAcrossTables(client, schema, "entityType", ENTITY_DISCOVERY_TABLES),
+    ttl,
+    config.logger
+  );
+  return { entityTypes: values };
+}
+async function getEntityNames(client, schema, args, config) {
+  const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const cacheKey = args.entityType ? `entity_names:${args.entityType}` : "entity_names";
+  const filterSql = args.entityType ? `AND "entityType" = $1` : "";
+  const filterParams = args.entityType ? [args.entityType] : [];
+  const values = await readWithRefresh(
+    client,
+    schema,
+    cacheKey,
+    () => distinctAcrossTables(client, schema, "entityName", ENTITY_DISCOVERY_TABLES, filterSql, filterParams),
+    ttl,
+    config.logger
+  );
+  return { names: values };
+}
+async function getServiceNames(client, schema, _args, config) {
+  const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const values = await readWithRefresh(
+    client,
+    schema,
+    "service_names",
+    () => distinctAcrossTables(client, schema, "serviceName", SIGNAL_TABLES_WITH_CONTEXT),
+    ttl,
+    config.logger
+  );
+  return { serviceNames: values };
+}
+async function getEnvironments(client, schema, _args, config) {
+  const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const values = await readWithRefresh(
+    client,
+    schema,
+    "environments",
+    () => distinctAcrossTables(client, schema, "environment", SIGNAL_TABLES_WITH_CONTEXT),
+    ttl,
+    config.logger
+  );
+  return { environments: values };
+}
+async function getTags(client, schema, args, config) {
+  const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const cacheKey = args.entityType ? `tags:${args.entityType}` : "tags";
+  const refresh = async () => {
+    const filter = args.entityType ? `AND "entityType" = $1` : "";
+    const params = args.entityType ? [args.entityType] : [];
+    const unions = ENTITY_DISCOVERY_TABLES.map(
+      (t) => `SELECT DISTINCT UNNEST("tags") AS v FROM ${qualifiedTable(schema, t)} WHERE array_length("tags", 1) > 0 ${filter}`
+    ).join(" UNION ");
+    const rows = await client.manyOrNone(
+      `SELECT v FROM (${unions}) sub WHERE v IS NOT NULL AND v <> '' ORDER BY v`,
+      params
+    );
+    return rows.map((r) => r.v);
+  };
+  const values = await readWithRefresh(client, schema, cacheKey, refresh, ttl, config.logger);
+  return { tags: values };
+}
+async function getMetricNames(client, schema, args, config) {
+  const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const values = await readWithRefresh(
+    client,
+    schema,
+    "metric_names",
+    async () => {
+      const rows = await client.manyOrNone(
+        `SELECT DISTINCT "name" AS v FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
+         WHERE "name" IS NOT NULL AND "name" <> '' ORDER BY "name"`
+      );
+      return rows.map((r) => r.v);
+    },
+    ttl,
+    config.logger
+  );
+  let filtered = values;
+  if (args.prefix) filtered = filtered.filter((v) => v.startsWith(args.prefix));
+  if (args.limit) filtered = filtered.slice(0, args.limit);
+  return { names: filtered };
+}
+async function getMetricLabelKeys(client, schema, args, config) {
+  const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const cacheKey = `metric_label_keys:${args.metricName}`;
+  const values = await readWithRefresh(
+    client,
+    schema,
+    cacheKey,
+    async () => {
+      const rows = await client.manyOrNone(
+        `SELECT DISTINCT k AS v
+         FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}, jsonb_object_keys("labels") k
+         WHERE "name" = $1 ORDER BY k`,
+        [args.metricName]
+      );
+      return rows.map((r) => r.v);
+    },
+    ttl,
+    config.logger
+  );
+  return { keys: values };
+}
+async function getMetricLabelValues(client, schema, args, config) {
+  const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const cacheKey = `metric_label_values:${args.metricName}:${args.labelKey}`;
+  const values = await readWithRefresh(
+    client,
+    schema,
+    cacheKey,
+    async () => {
+      const rows = await client.manyOrNone(
+        `SELECT DISTINCT "labels" ->> $2 AS v
+         FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
+         WHERE "name" = $1 AND "labels" ? $2
+         ORDER BY v`,
+        [args.metricName, args.labelKey]
+      );
+      return rows.map((r) => r.v).filter((v) => v != null && v !== "");
+    },
+    ttl,
+    config.logger
+  );
+  let filtered = values;
+  if (args.prefix) filtered = filtered.filter((v) => v.startsWith(args.prefix));
+  if (args.limit) filtered = filtered.slice(0, args.limit);
+  return { values: filtered };
+}
+
+// src/storage/domains/observability/v-next/filters.ts
+function newFilterAccumulator(startIndex = 1) {
+  return { conditions: [], params: [], next: startIndex };
+}
+function pushEq(acc, column, value, prefix = "") {
+  if (value === void 0) return;
+  acc.conditions.push(`${prefix}"${column}" = $${acc.next++}`);
+  acc.params.push(value);
+}
+function pushIn(acc, column, values, prefix = "") {
+  if (!values.length) return;
+  const placeholders = values.map(() => `$${acc.next++}`).join(", ");
+  acc.conditions.push(`${prefix}"${column}" IN (${placeholders})`);
+  acc.params.push(...values);
+}
+function applyCommonFilters(acc, filters, options = {}) {
+  if (!filters) return;
+  const tsCol = options.timestampColumn ?? "timestamp";
+  const prefix = options.prefix ?? "";
+  if (filters.timestamp?.start) {
+    const op = filters.timestamp.startExclusive ? ">" : ">=";
+    acc.conditions.push(`${prefix}"${tsCol}" ${op} $${acc.next++}`);
+    acc.params.push(filters.timestamp.start.toISOString());
+  }
+  if (filters.timestamp?.end) {
+    const op = filters.timestamp.endExclusive ? "<" : "<=";
+    acc.conditions.push(`${prefix}"${tsCol}" ${op} $${acc.next++}`);
+    acc.params.push(filters.timestamp.end.toISOString());
+  }
+  pushEq(acc, "traceId", filters.traceId, prefix);
+  pushEq(acc, "spanId", filters.spanId, prefix);
+  pushEq(acc, "entityType", filters.entityType, prefix);
+  pushEq(acc, "entityName", filters.entityName, prefix);
+  pushEq(acc, "entityVersionId", filters.entityVersionId, prefix);
+  pushEq(acc, "parentEntityType", filters.parentEntityType, prefix);
+  pushEq(acc, "parentEntityName", filters.parentEntityName, prefix);
+  pushEq(acc, "parentEntityVersionId", filters.parentEntityVersionId, prefix);
+  pushEq(acc, "rootEntityType", filters.rootEntityType, prefix);
+  pushEq(acc, "rootEntityName", filters.rootEntityName, prefix);
+  pushEq(acc, "rootEntityVersionId", filters.rootEntityVersionId, prefix);
+  pushEq(acc, "userId", filters.userId, prefix);
+  pushEq(acc, "organizationId", filters.organizationId, prefix);
+  pushEq(acc, "resourceId", filters.resourceId, prefix);
+  pushEq(acc, "runId", filters.runId, prefix);
+  pushEq(acc, "sessionId", filters.sessionId, prefix);
+  pushEq(acc, "threadId", filters.threadId, prefix);
+  pushEq(acc, "requestId", filters.requestId, prefix);
+  pushEq(acc, "experimentId", filters.experimentId, prefix);
+  pushEq(acc, "environment", filters.environment, prefix);
+  pushEq(acc, "serviceName", filters.serviceName, prefix);
+  pushEq(acc, "executionSource", filters.executionSource ?? filters.source, prefix);
+  if (filters.tags != null && Array.isArray(filters.tags) && filters.tags.length > 0) {
+    acc.conditions.push(`${prefix}"tags" @> $${acc.next++}::text[]`);
+    acc.params.push(filters.tags);
   }
-  async createCustomIndexes() {
-    if (!this.#indexes || this.#indexes.length === 0) {
-      return;
-    }
-    for (const indexDef of this.#indexes) {
-      try {
-        await this.#db.createIndex(indexDef);
-      } catch (error) {
-        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
-      }
-    }
+}
+function applySingleOrArrayFilter(acc, column, value, prefix = "") {
+  if (value === void 0) return;
+  if (Array.isArray(value)) {
+    pushIn(acc, column, value, prefix);
+  } else {
+    pushEq(acc, column, value, prefix);
   }
-  async dangerouslyClearAll() {
-    await this.#db.clearTable({ tableName: storage.TABLE_PROMPT_BLOCK_VERSIONS });
-    await this.#db.clearTable({ tableName: storage.TABLE_PROMPT_BLOCKS });
+}
+function whereOrEmpty(acc) {
+  return acc.conditions.length ? `WHERE ${acc.conditions.join(" AND ")}` : "";
+}
+var PROMOTED_KEYS = /* @__PURE__ */ new Set([
+  "experimentId",
+  "entityType",
+  "entityId",
+  "entityName",
+  "entityVersionId",
+  "parentEntityVersionId",
+  "rootEntityVersionId",
+  "userId",
+  "organizationId",
+  "resourceId",
+  "runId",
+  "sessionId",
+  "threadId",
+  "requestId",
+  "environment",
+  "executionSource",
+  "serviceName"
+]);
+function nullableString(value) {
+  if (typeof value === "string") return value === "" ? null : value;
+  if (value == null) return null;
+  return String(value);
+}
+function nullableEntityType(value) {
+  const normalized = nullableString(value);
+  if (!normalized) return null;
+  return Object.values(storage.EntityType).includes(normalized) ? normalized : null;
+}
+function normalizeTags(tags) {
+  if (!Array.isArray(tags)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const t of tags) {
+    if (typeof t !== "string") continue;
+    const trimmed = t.trim();
+    if (trimmed === "" || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    result.push(trimmed);
   }
-  // ==========================================================================
-  // Prompt Block CRUD Methods
-  // ==========================================================================
-  async getById(id) {
+  return result;
+}
+function normalizeLabels(labels) {
+  if (labels == null || typeof labels !== "object") return {};
+  const result = {};
+  for (const [k, v] of Object.entries(labels)) {
+    if (typeof v !== "string") continue;
+    const trimmedK = k.trim();
+    const trimmedV = v.trim();
+    if (trimmedK === "" || trimmedV === "") continue;
+    result[trimmedK] = trimmedV;
+  }
+  return result;
+}
+function buildMetadataSearch(metadata) {
+  if (metadata == null || typeof metadata !== "object") return {};
+  const result = {};
+  for (const [k, v] of Object.entries(metadata)) {
+    if (PROMOTED_KEYS.has(k)) continue;
+    if (typeof v !== "string") continue;
+    const trimmed = v.trim();
+    if (trimmed === "") continue;
+    result[k] = trimmed;
+  }
+  return result;
+}
+function toDate(value) {
+  if (value instanceof Date) return value;
+  if (value == null || value === "") throw new Error(`Invalid date: ${String(value)}`);
+  const d = new Date(value);
+  if (isNaN(d.getTime())) throw new Error(`Invalid date: ${String(value)}`);
+  return d;
+}
+function toDateOrNull(value) {
+  if (value == null || value === "") return null;
+  if (value instanceof Date) return value;
+  const d = new Date(value);
+  if (isNaN(d.getTime())) return null;
+  return d;
+}
+function toIsoOrDate(value) {
+  if (value instanceof Date) return value;
+  if (typeof value === "number") return new Date(value);
+  return value;
+}
+function jsonField(value) {
+  if (value === void 0) return null;
+  return value;
+}
+function parsedJson(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") {
     try {
-      const tableName = getTableName2({ indexName: storage.TABLE_PROMPT_BLOCKS, schemaName: getSchemaName2(this.#schema) });
+      return JSON.parse(value);
+    } catch {
+      return void 0;
+    }
+  }
+  return value;
+}
+function rowToCommonContext(row) {
+  return {
+    experimentId: nullableString(row.experimentId),
+    entityType: nullableEntityType(row.entityType),
+    entityId: nullableString(row.entityId),
+    entityName: nullableString(row.entityName),
+    entityVersionId: nullableString(row.entityVersionId),
+    parentEntityType: nullableEntityType(row.parentEntityType),
+    parentEntityId: nullableString(row.parentEntityId),
+    parentEntityName: nullableString(row.parentEntityName),
+    parentEntityVersionId: nullableString(row.parentEntityVersionId),
+    rootEntityType: nullableEntityType(row.rootEntityType),
+    rootEntityId: nullableString(row.rootEntityId),
+    rootEntityName: nullableString(row.rootEntityName),
+    rootEntityVersionId: nullableString(row.rootEntityVersionId),
+    userId: nullableString(row.userId),
+    organizationId: nullableString(row.organizationId),
+    resourceId: nullableString(row.resourceId),
+    runId: nullableString(row.runId),
+    sessionId: nullableString(row.sessionId),
+    threadId: nullableString(row.threadId),
+    requestId: nullableString(row.requestId),
+    environment: nullableString(row.environment),
+    executionSource: nullableString(row.executionSource),
+    serviceName: nullableString(row.serviceName)
+  };
+}
+function commonContextToRow(record) {
+  return {
+    experimentId: record.experimentId ?? null,
+    entityType: record.entityType ?? null,
+    entityId: record.entityId ?? null,
+    entityName: record.entityName ?? null,
+    entityVersionId: record.entityVersionId ?? null,
+    parentEntityType: record.parentEntityType ?? null,
+    parentEntityId: record.parentEntityId ?? null,
+    parentEntityName: record.parentEntityName ?? null,
+    parentEntityVersionId: record.parentEntityVersionId ?? null,
+    rootEntityType: record.rootEntityType ?? null,
+    rootEntityId: record.rootEntityId ?? null,
+    rootEntityName: record.rootEntityName ?? null,
+    rootEntityVersionId: record.rootEntityVersionId ?? null,
+    userId: record.userId ?? null,
+    organizationId: record.organizationId ?? null,
+    resourceId: record.resourceId ?? null,
+    runId: record.runId ?? null,
+    sessionId: record.sessionId ?? null,
+    threadId: record.threadId ?? null,
+    requestId: record.requestId ?? null,
+    environment: record.environment ?? null,
+    executionSource: record.executionSource ?? record.source ?? null,
+    serviceName: record.serviceName ?? null
+  };
+}
+function spanRecordToRow(span) {
+  const endedAt = span.isEvent ? span.startedAt : span.endedAt ?? span.startedAt;
+  const metadata = span.metadata ?? null;
+  return {
+    ...commonContextToRow(span),
+    traceId: span.traceId,
+    spanId: span.spanId,
+    parentSpanId: span.parentSpanId ?? null,
+    name: span.name,
+    spanType: span.spanType,
+    isEvent: Boolean(span.isEvent),
+    startedAt: toIsoOrDate(span.startedAt),
+    endedAt: toIsoOrDate(endedAt),
+    tags: normalizeTags(span.tags),
+    metadataSearch: buildMetadataSearch(metadata),
+    metadataRaw: jsonField(metadata),
+    scope: jsonField(span.scope),
+    attributes: jsonField(span.attributes),
+    links: jsonField(span.links),
+    input: jsonField(span.input),
+    output: jsonField(span.output),
+    error: jsonField(span.error),
+    requestContext: jsonField(span.requestContext)
+  };
+}
+function rowToSpanRecord(row) {
+  const startedAt = toDate(row.startedAt);
+  const endedAt = row.isEvent ? startedAt : toDateOrNull(row.endedAt);
+  const error = parsedJson(row.error);
+  const { executionSource, ...ctx } = rowToCommonContext(row);
+  return {
+    ...ctx,
+    source: executionSource,
+    traceId: row.traceId,
+    spanId: row.spanId,
+    parentSpanId: nullableString(row.parentSpanId),
+    name: row.name,
+    spanType: row.spanType,
+    isEvent: Boolean(row.isEvent),
+    startedAt,
+    endedAt,
+    tags: normalizeTags(row.tags),
+    metadata: parsedJson(row.metadataRaw) ?? void 0,
+    scope: parsedJson(row.scope) ?? void 0,
+    attributes: parsedJson(row.attributes) ?? void 0,
+    links: parsedJson(row.links) ?? void 0,
+    input: parsedJson(row.input) ?? void 0,
+    output: parsedJson(row.output) ?? void 0,
+    error: error ?? void 0,
+    requestContext: parsedJson(row.requestContext) ?? void 0,
+    createdAt: startedAt,
+    updatedAt: null
+  };
+}
+function rowToLightSpanRecord(row) {
+  const startedAt = toDate(row.startedAt);
+  const endedAt = row.isEvent ? startedAt : toDateOrNull(row.endedAt);
+  return {
+    traceId: row.traceId,
+    spanId: row.spanId,
+    parentSpanId: row.parentSpanId == null || row.parentSpanId === "" ? null : String(row.parentSpanId),
+    name: row.name,
+    spanType: row.spanType,
+    isEvent: Boolean(row.isEvent),
+    startedAt,
+    endedAt,
+    entityType: row.entityType == null || row.entityType === "" ? null : Object.values(storage.EntityType).includes(row.entityType) ? row.entityType : null,
+    entityId: row.entityId == null || row.entityId === "" ? null : String(row.entityId),
+    entityName: row.entityName == null || row.entityName === "" ? null : String(row.entityName),
+    error: parsedJson(row.error) ?? void 0,
+    createdAt: startedAt,
+    updatedAt: null
+  };
+}
+function logRecordToRow(log) {
+  return {
+    ...commonContextToRow(log),
+    logId: log.logId,
+    timestamp: toIsoOrDate(log.timestamp),
+    level: log.level,
+    message: log.message,
+    data: jsonField(log.data),
+    traceId: log.traceId ?? null,
+    spanId: log.spanId ?? null,
+    tags: normalizeTags(log.tags),
+    metadata: jsonField(log.metadata),
+    scope: jsonField(log.scope)
+  };
+}
+function rowToLogRecord(row) {
+  return {
+    ...rowToCommonContext(row),
+    logId: row.logId,
+    timestamp: toDate(row.timestamp),
+    level: row.level,
+    message: row.message,
+    data: parsedJson(row.data) ?? void 0,
+    traceId: nullableString(row.traceId),
+    spanId: nullableString(row.spanId),
+    tags: normalizeTags(row.tags),
+    metadata: parsedJson(row.metadata) ?? void 0,
+    scope: parsedJson(row.scope) ?? void 0
+  };
+}
+function metricRecordToRow(metric) {
+  return {
+    ...commonContextToRow(metric),
+    metricId: metric.metricId,
+    timestamp: toIsoOrDate(metric.timestamp),
+    name: metric.name,
+    value: metric.value,
+    traceId: metric.traceId ?? null,
+    spanId: metric.spanId ?? null,
+    provider: metric.provider ?? null,
+    model: metric.model ?? null,
+    estimatedCost: metric.estimatedCost ?? null,
+    costUnit: metric.costUnit ?? null,
+    tags: normalizeTags(metric.tags),
+    labels: normalizeLabels(metric.labels),
+    costMetadata: jsonField(metric.costMetadata),
+    metadata: jsonField(metric.metadata),
+    scope: jsonField(metric.scope)
+  };
+}
+function rowToMetricRecord(row) {
+  return {
+    ...rowToCommonContext(row),
+    metricId: row.metricId,
+    timestamp: toDate(row.timestamp),
+    name: row.name,
+    value: Number(row.value),
+    traceId: nullableString(row.traceId),
+    spanId: nullableString(row.spanId),
+    provider: nullableString(row.provider),
+    model: nullableString(row.model),
+    estimatedCost: row.estimatedCost == null ? void 0 : Number(row.estimatedCost),
+    costUnit: nullableString(row.costUnit),
+    costMetadata: parsedJson(row.costMetadata) ?? void 0,
+    tags: normalizeTags(row.tags),
+    labels: normalizeLabels(row.labels),
+    metadata: parsedJson(row.metadata) ?? void 0,
+    scope: parsedJson(row.scope) ?? void 0
+  };
+}
+function scoreRecordToRow(score) {
+  const metadata = score.metadata ?? null;
+  const scoreSource = score.scoreSource ?? score.source ?? null;
+  return {
+    ...commonContextToRow(score),
+    scoreId: score.scoreId,
+    timestamp: toIsoOrDate(score.timestamp),
+    traceId: score.traceId ?? null,
+    spanId: score.spanId ?? null,
+    scoreTraceId: score.scoreTraceId ?? null,
+    scorerId: score.scorerId,
+    scorerVersion: score.scorerVersion ?? null,
+    scoreSource,
+    score: score.score,
+    reason: score.reason ?? null,
+    tags: normalizeTags(score.tags),
+    metadata: jsonField(metadata),
+    scope: jsonField(score.scope)
+  };
+}
+function rowToScoreRecord(row) {
+  return {
+    ...rowToCommonContext(row),
+    scoreId: row.scoreId,
+    timestamp: toDate(row.timestamp),
+    // Legacy schema types traceId as required string even though the column is nullable.
+    traceId: nullableString(row.traceId),
+    spanId: nullableString(row.spanId),
+    scoreTraceId: nullableString(row.scoreTraceId),
+    scorerId: row.scorerId,
+    scorerVersion: nullableString(row.scorerVersion),
+    scoreSource: nullableString(row.scoreSource),
+    score: Number(row.score),
+    reason: nullableString(row.reason),
+    tags: normalizeTags(row.tags),
+    metadata: parsedJson(row.metadata) ?? void 0,
+    scope: parsedJson(row.scope) ?? void 0
+  };
+}
+function feedbackRecordToRow(feedback) {
+  const metadata = feedback.metadata ?? null;
+  const feedbackSource = feedback.feedbackSource ?? feedback.source ?? "";
+  return {
+    ...commonContextToRow(feedback),
+    feedbackId: feedback.feedbackId,
+    timestamp: toIsoOrDate(feedback.timestamp),
+    traceId: feedback.traceId ?? null,
+    spanId: feedback.spanId ?? null,
+    feedbackUserId: feedback.feedbackUserId ?? null,
+    sourceId: feedback.sourceId ?? null,
+    feedbackSource,
+    feedbackType: feedback.feedbackType,
+    valueString: typeof feedback.value === "string" ? feedback.value : null,
+    valueNumber: typeof feedback.value === "number" ? feedback.value : null,
+    comment: feedback.comment ?? null,
+    tags: normalizeTags(feedback.tags),
+    metadata: jsonField(metadata),
+    scope: jsonField(feedback.scope)
+  };
+}
+function rowToFeedbackRecord(row) {
+  const hasNumber = row.valueNumber != null;
+  const feedbackSource = nullableString(row.feedbackSource);
+  return {
+    ...rowToCommonContext(row),
+    feedbackId: row.feedbackId,
+    timestamp: toDate(row.timestamp),
+    // Legacy schema types traceId as required string even though the column is nullable.
+    traceId: nullableString(row.traceId),
+    spanId: nullableString(row.spanId),
+    feedbackUserId: nullableString(row.feedbackUserId),
+    sourceId: nullableString(row.sourceId),
+    feedbackSource,
+    feedbackType: row.feedbackType,
+    value: hasNumber ? Number(row.valueNumber) : nullableString(row.valueString) ?? "",
+    comment: nullableString(row.comment),
+    tags: normalizeTags(row.tags),
+    metadata: parsedJson(row.metadata) ?? void 0,
+    scope: parsedJson(row.scope) ?? void 0
+  };
+}
+var OBSERVABILITY_DELTA_POLLING_FEATURE = "observability-delta-polling";
+function deltaPollingFeatureEnabled() {
+  return features.coreFeatures.has(OBSERVABILITY_DELTA_POLLING_FEATURE);
+}
+function assertDeltaPollingEnabled() {
+  if (deltaPollingFeatureEnabled()) return;
+  throw new error.MastraError({
+    id: "OBSERVABILITY_DELTA_POLLING_NOT_SUPPORTED",
+    domain: error.ErrorDomain.MASTRA_OBSERVABILITY,
+    category: error.ErrorCategory.SYSTEM,
+    text: "This storage provider does not support observability delta polling"
+  });
+}
+var PG_BIGINT_MAX = 9223372036854775807n;
+function invalidDeltaCursor() {
+  throw new error.MastraError({
+    id: "OBSERVABILITY_INVALID_DELTA_CURSOR",
+    domain: error.ErrorDomain.MASTRA_OBSERVABILITY,
+    category: error.ErrorCategory.USER,
+    text: "Invalid observability delta cursor"
+  });
+}
+function validatePgInteger(value) {
+  if (!/^\d+$/.test(value)) {
+    invalidDeltaCursor();
+  }
+  let parsed;
+  try {
+    parsed = BigInt(value);
+  } catch {
+    invalidDeltaCursor();
+  }
+  if (parsed < 0n || parsed > PG_BIGINT_MAX) {
+    invalidDeltaCursor();
+  }
+  return value;
+}
+function encodeDeltaCursor(xactId, cursorId = 0) {
+  return `${validatePgInteger(String(xactId ?? 0))}:${validatePgInteger(String(cursorId ?? 0))}`;
+}
+function decodeDeltaCursor(cursor) {
+  const parts = cursor.split(":");
+  if (parts.length !== 2) {
+    invalidDeltaCursor();
+  }
+  return {
+    xactId: validatePgInteger(parts[0]),
+    cursorId: validatePgInteger(parts[1])
+  };
+}
+async function readSafeXactHorizon(client) {
+  const row = await client.one(`SELECT pg_snapshot_xmin(pg_current_snapshot())::text AS "xactId"`);
+  return validatePgInteger(row.xactId);
+}
+
+// src/storage/domains/observability/v-next/listing.ts
+function responseItems(key, items) {
+  return { [key]: items };
+}
+async function readSignalStreamHeadCursor({
+  client,
+  table,
+  filters,
+  applyFilters
+}) {
+  return encodeDeltaCursor(await readSafeXactHorizon(client), 0);
+}
+async function listSignalPage(config) {
+  const {
+    client,
+    table,
+    filters,
+    selectColumns,
+    responseKey,
+    applyFilters,
+    mapRow,
+    page,
+    perPage,
+    orderField,
+    orderDir
+  } = config;
+  const acc = newFilterAccumulator();
+  applyFilters(acc, filters);
+  const whereClause = whereOrEmpty(acc);
+  const countRow = await client.oneOrNone(
+    `SELECT COUNT(*)::text AS count FROM ${table} ${whereClause}`,
+    acc.params
+  );
+  const total = Number(countRow?.count ?? 0);
+  let items = [];
+  if (total > 0) {
+    const safeOrderField = utils.parseSqlIdentifier(orderField, "order field");
+    const rows = await client.manyOrNone(
+      `SELECT ${selectColumns}
+       FROM ${table}
+       ${whereClause}
+       ORDER BY "${safeOrderField}" ${orderDir}, "cursorId" ${orderDir}
+       LIMIT $${acc.next++} OFFSET $${acc.next++}`,
+      [...acc.params, perPage, page * perPage]
+    );
+    items = rows.map(mapRow);
+  }
+  const deltaCursor = config.includeDeltaCursor ? await readSignalStreamHeadCursor({ client, table, filters, applyFilters }) : void 0;
+  return {
+    pagination: { total, page, perPage, hasMore: (page + 1) * perPage < total },
+    ...responseItems(responseKey, items),
+    ...deltaCursor !== void 0 ? { deltaCursor } : {}
+  };
+}
+async function listSignalDelta(config) {
+  const { client, table, filters, selectColumns, responseKey, applyFilters, mapRow, after, limit } = config;
+  if (after === void 0) {
+    const deltaCursor2 = await readSignalStreamHeadCursor({ client, table, filters, applyFilters });
+    return { ...responseItems(responseKey, []), delta: { limit, hasMore: false }, deltaCursor: deltaCursor2 };
+  }
+  const afterCursor = decodeDeltaCursor(after);
+  const safeHorizon = await readSafeXactHorizon(client);
+  const acc = newFilterAccumulator();
+  applyFilters(acc, filters);
+  acc.conditions.push(`("xactId", "cursorId") > ($${acc.next++}::xid8, $${acc.next++}::bigint)`);
+  acc.params.push(afterCursor.xactId, afterCursor.cursorId);
+  acc.conditions.push(`"xactId" < $${acc.next++}::xid8`);
+  acc.params.push(safeHorizon);
+  const rows = await client.manyOrNone(
+    `SELECT ${selectColumns}
+     FROM ${table}
+     ${whereOrEmpty(acc)}
+     ORDER BY "xactId" ASC, "cursorId" ASC
+     LIMIT $${acc.next++}`,
+    [...acc.params, limit + 1]
+  );
+  const hasMore = rows.length > limit;
+  const visible = rows.slice(0, limit);
+  const deltaCursor = visible.length > 0 ? encodeDeltaCursor(visible[visible.length - 1].xactId, visible[visible.length - 1].cursorId) : encodeDeltaCursor(safeHorizon, 0);
+  return {
+    ...responseItems(responseKey, visible.map(mapRow)),
+    delta: { limit, hasMore },
+    deltaCursor
+  };
+}
+var INTERVAL_SECONDS = {
+  "1m": 60,
+  "5m": 300,
+  "15m": 900,
+  "1h": 3600,
+  "1d": 86400
+};
+function bucketSql(column, interval) {
+  const seconds = INTERVAL_SECONDS[interval] ?? 3600;
+  return `to_timestamp(floor(extract(epoch from ${column}) / ${seconds}) * ${seconds})`;
+}
+function resolveDistinctColumnSql(distinctColumn) {
+  if (!distinctColumn) {
+    throw new Error(`count_distinct aggregation requires a 'distinctColumn' argument`);
+  }
+  if (!storage.METRIC_DISTINCT_COLUMNS.includes(distinctColumn)) {
+    throw new Error(`Invalid distinctColumn: ${distinctColumn}`);
+  }
+  return `"${utils.parseFieldKey(distinctColumn)}"`;
+}
+function metricAggregationSql(agg, measure, timestampColumn = "timestamp", distinctColumn) {
+  if (agg === "count_distinct") {
+    return `COUNT(DISTINCT ${resolveDistinctColumnSql(distinctColumn)})::double precision`;
+  }
+  return aggregationSql(agg, measure, timestampColumn);
+}
+function aggregationSql(agg, measure, timestampColumn = "timestamp") {
+  switch (agg) {
+    case "sum":
+      return `SUM(${measure})`;
+    case "avg":
+      return `AVG(${measure})`;
+    case "min":
+      return `MIN(${measure})`;
+    case "max":
+      return `MAX(${measure})`;
+    case "count":
+      return `COUNT(${measure})::double precision`;
+    case "last":
+      return `(array_agg(${measure} ORDER BY "${timestampColumn}" DESC))[1]`;
+    default:
+      return `SUM(${measure})`;
+  }
+}
+function resolveGroupBy(acc, groupBy, options) {
+  const labelsColumn = options.labelsColumn ?? null;
+  const excluded = options.excludedColumns ?? /* @__PURE__ */ new Set();
+  return groupBy.map((key, index) => {
+    const alias = `group_by_${index}`;
+    if (options.typedColumns.has(key)) {
+      const parsed = utils.parseFieldKey(key);
+      if (excluded.has(parsed)) {
+        throw new Error(`Invalid groupBy column(s): ${key}`);
+      }
+      return {
+        requestedKey: key,
+        alias,
+        selectSql: `"${parsed}" AS ${alias}`,
+        valueSql: `"${parsed}"`
+      };
+    }
+    if (!labelsColumn) {
+      throw new Error(`Invalid groupBy column(s): ${key}`);
+    }
+    const valueSql = `"${labelsColumn}" ->> $${acc.next++}`;
+    acc.params.push(key);
+    return {
+      requestedKey: key,
+      alias,
+      selectSql: `${valueSql} AS ${alias}`,
+      valueSql
+    };
+  });
+}
+function pushLabelExclusions(acc, resolved) {
+  for (const entry of resolved) {
+    if (entry.valueSql.includes("->>")) {
+      acc.conditions.push(`${entry.valueSql} IS NOT NULL`);
+      acc.conditions.push(`${entry.valueSql} <> ''`);
+    }
+  }
+}
+function dimensionsFromRow(row, resolved) {
+  const out = {};
+  for (const entry of resolved) {
+    const v = row[entry.alias];
+    out[entry.requestedKey] = v == null || v === "" ? null : String(v);
+  }
+  return out;
+}
+function seriesNameFromDimensions(values) {
+  return values.map((v) => v == null || v === "" ? "" : String(v)).join("|");
+}
+function shiftRange(range, period) {
+  if (!range.start || !range.end) return null;
+  const start = range.start.getTime();
+  const end = range.end.getTime();
+  const duration = end - start;
+  let offset;
+  switch (period) {
+    case "previous_day":
+      offset = 864e5;
+      break;
+    case "previous_week":
+      offset = 7 * 864e5;
+      break;
+    case "previous_period":
+    default:
+      offset = duration;
+  }
+  return {
+    start: new Date(start - offset),
+    end: new Date(end - offset),
+    startExclusive: range.startExclusive,
+    endExclusive: range.endExclusive
+  };
+}
+function changePercent(current, previous) {
+  if (current === null || previous === null || previous === 0) return null;
+  return (current - previous) / Math.abs(previous) * 100;
+}
+function bucketDate(value) {
+  return value instanceof Date ? value : new Date(String(value));
+}
+function validatePercentiles(percentiles) {
+  if (!percentiles.length) {
+    throw new Error("Percentiles must include at least one value between 0 and 1.");
+  }
+  for (const percentile of percentiles) {
+    if (!Number.isFinite(percentile) || percentile < 0 || percentile > 1) {
+      throw new Error(`Percentile value must be a finite number between 0 and 1, got ${percentile}`);
+    }
+  }
+}
+function percentileSelectSql(percentiles, measureSql) {
+  return percentiles.map((percentile, index) => `percentile_cont(${percentile}) WITHIN GROUP (ORDER BY ${measureSql}) AS p${index}`).join(", ");
+}
+function percentileSeriesFromRows(rows, percentiles) {
+  return percentiles.map((percentile, index) => ({
+    percentile,
+    points: rows.map((row) => ({
+      timestamp: bucketDate(row.bucket),
+      value: Number(row[`p${index}`] ?? 0)
+    }))
+  }));
+}
+function collectSeriesByDimensions(rows, resolved, createEntry, appendRow) {
+  const seriesMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const dimensionValues = resolved.map((entry2) => row[entry2.alias]);
+    const seriesKey = JSON.stringify(dimensionValues);
+    let entry = seriesMap.get(seriesKey);
+    if (!entry) {
+      entry = createEntry(dimensionValues);
+      seriesMap.set(seriesKey, entry);
+    }
+    appendRow(entry, row, dimensionValues);
+  }
+  return Array.from(seriesMap.values());
+}
+var COST_SUMMARY_SELECT = `
+  SUM("estimatedCost") FILTER (WHERE "estimatedCost" IS NOT NULL) AS "agg_estimatedCost",
+  CASE
+    WHEN COUNT(DISTINCT "costUnit") FILTER (WHERE "costUnit" IS NOT NULL) = 1
+      THEN MIN("costUnit") FILTER (WHERE "costUnit" IS NOT NULL)
+    ELSE NULL
+  END AS "agg_costUnit"
+`;
+function costSummaryFromRow(row) {
+  return {
+    estimatedCost: row.agg_estimatedCost == null ? null : Number(row.agg_estimatedCost),
+    costUnit: row.agg_costUnit == null || row.agg_costUnit === "" ? null : String(row.agg_costUnit)
+  };
+}
+var COMPLEX_GROUP_BY_EXCLUDED = /* @__PURE__ */ new Set([
+  "metadata",
+  "metadataRaw",
+  "metadataSearch",
+  "scope",
+  "attributes",
+  "links",
+  "input",
+  "output",
+  "error",
+  "data",
+  "labels",
+  "costMetadata",
+  "tags",
+  "requestContext"
+]);
+function encodeJsonb(value) {
+  if (value === null || value === void 0) return null;
+  return JSON.stringify(value);
+}
+function buildInsert(schema, table, records) {
+  if (records.length === 0) return null;
+  const columns = Object.keys(records[0]).map((c) => utils.parseSqlIdentifier(c, "column name"));
+  const quotedColumns = columns.map((c) => `"${c}"`).join(", ");
+  const values = [];
+  const rowPlaceholders = [];
+  let p = 1;
+  for (const record of records) {
+    const placeholders = columns.map((col) => {
+      const raw = record[col];
+      if (JSONB_COLUMNS.has(col)) {
+        values.push(encodeJsonb(raw));
+        return `$${p++}::jsonb`;
+      }
+      if (TEXT_ARRAY_COLUMNS.has(col)) {
+        values.push(Array.isArray(raw) ? raw : []);
+        return `$${p++}::text[]`;
+      }
+      values.push(raw === void 0 ? null : raw);
+      return `$${p++}`;
+    });
+    rowPlaceholders.push(`(${placeholders.join(", ")})`);
+  }
+  const text = `INSERT INTO ${qualifiedTable(schema, table)} (${quotedColumns})
+VALUES ${rowPlaceholders.join(", ")}
+ON CONFLICT DO NOTHING`;
+  return { text, values };
+}
+var SPAN_SELECT_COLUMNS = `
+${buildSelectColumns(SPAN_EVENT_COLUMNS)}`;
+var SPAN_LIGHT_SELECT_COLUMNS = `
+${buildNamedSelectColumns(SPAN_LIGHT_SELECT_COLUMN_NAMES)}`;
+var METRIC_SELECT_COLUMNS = `
+${buildSelectColumns(METRIC_EVENT_COLUMNS)}`;
+var LOG_SELECT_COLUMNS = `
+${buildSelectColumns(LOG_EVENT_COLUMNS)}`;
+var SCORE_SELECT_COLUMNS = `
+${buildSelectColumns(SCORE_EVENT_COLUMNS)}`;
+var FEEDBACK_SELECT_COLUMNS = `
+${buildSelectColumns(FEEDBACK_EVENT_COLUMNS)}`;
+
+// src/storage/domains/observability/v-next/feedback.ts
+function applyFeedbackFilters(acc, filters) {
+  applyCommonFilters(acc, filters);
+  applySingleOrArrayFilter(acc, "feedbackType", filters?.feedbackType);
+  if (filters?.feedbackSource ?? filters?.source) {
+    acc.conditions.push(`"feedbackSource" = $${acc.next++}`);
+    acc.params.push(filters.feedbackSource ?? filters.source);
+  }
+  if (filters?.feedbackUserId) {
+    acc.conditions.push(`"feedbackUserId" = $${acc.next++}`);
+    acc.params.push(filters.feedbackUserId);
+  }
+}
+function pushFeedbackIdentity(acc, feedbackType, feedbackSource) {
+  acc.conditions.push(`"feedbackType" = $${acc.next++}`);
+  acc.params.push(feedbackType);
+  if (feedbackSource !== void 0) {
+    acc.conditions.push(`"feedbackSource" = $${acc.next++}`);
+    acc.params.push(feedbackSource);
+  }
+  acc.conditions.push(`"valueNumber" IS NOT NULL`);
+}
+async function createFeedback(client, schema, args) {
+  const row = feedbackRecordToRow(args.feedback);
+  const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, [row]);
+  if (insert) await client.query(insert.text, insert.values);
+}
+async function batchCreateFeedback(client, schema, args) {
+  if (args.feedbacks.length === 0) return;
+  const rows = args.feedbacks.map(feedbackRecordToRow);
+  const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, rows);
+  if (insert) await client.query(insert.text, insert.values);
+}
+async function listFeedback(client, schema, args) {
+  const { mode, filters, pagination, orderBy, after, limit } = storage.listFeedbackArgsSchema.parse(args);
+  const table = qualifiedTable(schema, TABLE_FEEDBACK_EVENTS);
+  if (mode === "delta") {
+    assertDeltaPollingEnabled();
+    return listFeedbackDelta(client, table, filters, after, limit);
+  }
+  return listFeedbackPage(
+    client,
+    table,
+    filters,
+    pagination.page,
+    pagination.perPage,
+    orderBy.field,
+    orderBy.direction
+  );
+}
+async function listFeedbackPage(client, table, filters, page, perPage, orderField, orderDir) {
+  return listSignalPage({
+    client,
+    table,
+    filters,
+    page,
+    perPage,
+    orderField,
+    orderDir,
+    includeDeltaCursor: deltaPollingFeatureEnabled(),
+    selectColumns: FEEDBACK_SELECT_COLUMNS,
+    responseKey: "feedback",
+    applyFilters: applyFeedbackFilters,
+    mapRow: rowToFeedbackRecord
+  });
+}
+async function listFeedbackDelta(client, table, filters, after, limit) {
+  return listSignalDelta({
+    client,
+    table,
+    filters,
+    after,
+    limit,
+    selectColumns: FEEDBACK_SELECT_COLUMNS,
+    responseKey: "feedback",
+    applyFilters: applyFeedbackFilters,
+    mapRow: rowToFeedbackRecord
+  });
+}
+async function runFeedbackAggregateQuery(client, schema, args, filters) {
+  const acc = newFilterAccumulator();
+  pushFeedbackIdentity(acc, args.feedbackType, args.feedbackSource);
+  applyFeedbackFilters(acc, filters);
+  const sql = `
+    SELECT ${aggregationSql(args.aggregation, '"valueNumber"')} AS "value"
+    FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
+    ${whereOrEmpty(acc)}
+  `;
+  const row = await client.oneOrNone(sql, acc.params);
+  return row?.value == null ? null : Number(row.value);
+}
+async function getFeedbackAggregate(client, schema, args) {
+  const value = await runFeedbackAggregateQuery(client, schema, args, args.filters);
+  if (args.comparePeriod && args.filters?.timestamp) {
+    const prevRange = shiftRange(args.filters.timestamp, args.comparePeriod);
+    if (prevRange) {
+      const previousValue = await runFeedbackAggregateQuery(client, schema, args, {
+        ...args.filters ?? {},
+        timestamp: prevRange
+      });
+      return {
+        value,
+        previousValue,
+        changePercent: changePercent(value, previousValue)
+      };
+    }
+  }
+  return { value };
+}
+async function getFeedbackBreakdown(client, schema, args) {
+  const acc = newFilterAccumulator();
+  const resolved = resolveGroupBy(acc, args.groupBy, {
+    typedColumns: FEEDBACK_TYPED_COLUMNS,
+    excludedColumns: COMPLEX_GROUP_BY_EXCLUDED
+  });
+  pushFeedbackIdentity(acc, args.feedbackType, args.feedbackSource);
+  applyFeedbackFilters(acc, args.filters);
+  const sql = `
+    SELECT ${resolved.map((e) => e.selectSql).join(", ")},
+           ${aggregationSql(args.aggregation, '"valueNumber"')} AS "value"
+    FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY ${resolved.map((e) => e.alias).join(", ")}
+    ORDER BY "value" DESC NULLS LAST
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  return {
+    groups: rows.map((row) => ({
+      dimensions: dimensionsFromRow(row, resolved),
+      value: Number(row.value ?? 0)
+    }))
+  };
+}
+async function getFeedbackTimeSeries(client, schema, args) {
+  const bucket = bucketSql('"timestamp"', args.interval);
+  if (args.groupBy && args.groupBy.length > 0) {
+    const acc2 = newFilterAccumulator();
+    const resolved = resolveGroupBy(acc2, args.groupBy, {
+      typedColumns: FEEDBACK_TYPED_COLUMNS,
+      excludedColumns: COMPLEX_GROUP_BY_EXCLUDED
+    });
+    pushFeedbackIdentity(acc2, args.feedbackType, args.feedbackSource);
+    applyFeedbackFilters(acc2, args.filters);
+    const sql2 = `
+      SELECT ${bucket} AS bucket,
+             ${resolved.map((e) => e.selectSql).join(", ")},
+             ${aggregationSql(args.aggregation, '"valueNumber"')} AS "value"
+      FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
+      ${whereOrEmpty(acc2)}
+      GROUP BY bucket, ${resolved.map((e) => e.alias).join(", ")}
+      ORDER BY bucket
+    `;
+    const rows2 = await client.manyOrNone(sql2, acc2.params);
+    return {
+      series: collectSeriesByDimensions(
+        rows2,
+        resolved,
+        (dimValues) => ({
+          name: seriesNameFromDimensions(dimValues),
+          points: []
+        }),
+        (entry, row) => {
+          entry.points.push({
+            timestamp: bucketDate(row.bucket),
+            value: Number(row.value ?? 0)
+          });
+        }
+      )
+    };
+  }
+  const acc = newFilterAccumulator();
+  pushFeedbackIdentity(acc, args.feedbackType, args.feedbackSource);
+  applyFeedbackFilters(acc, args.filters);
+  const sql = `
+    SELECT ${bucket} AS bucket,
+           ${aggregationSql(args.aggregation, '"valueNumber"')} AS "value"
+    FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY bucket
+    ORDER BY bucket
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  const seriesName = args.feedbackSource ? `${args.feedbackType}|${args.feedbackSource}` : args.feedbackType;
+  return {
+    series: [
+      {
+        name: seriesName,
+        points: rows.map((row) => ({
+          timestamp: bucketDate(row.bucket),
+          value: Number(row.value ?? 0)
+        }))
+      }
+    ]
+  };
+}
+async function getFeedbackPercentiles(client, schema, args) {
+  validatePercentiles(args.percentiles);
+  const bucket = bucketSql('"timestamp"', args.interval);
+  const acc = newFilterAccumulator();
+  pushFeedbackIdentity(acc, args.feedbackType, args.feedbackSource);
+  applyFeedbackFilters(acc, args.filters);
+  const percentileSelect = percentileSelectSql(args.percentiles, '"valueNumber"');
+  const sql = `
+    SELECT ${bucket} AS bucket, ${percentileSelect}
+    FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY bucket
+    ORDER BY bucket
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  return { series: percentileSeriesFromRows(rows, args.percentiles) };
+}
+function applyLogFilters(acc, filters) {
+  applyCommonFilters(acc, filters);
+  applySingleOrArrayFilter(acc, "level", filters?.level);
+}
+async function batchCreateLogs(client, schema, args) {
+  if (args.logs.length === 0) return;
+  const rows = args.logs.map(logRecordToRow);
+  const insert = buildInsert(schema, TABLE_LOG_EVENTS, rows);
+  if (insert) await client.query(insert.text, insert.values);
+}
+async function listLogs(client, schema, args) {
+  const { mode, filters, pagination, orderBy, after, limit } = storage.listLogsArgsSchema.parse(args);
+  const table = qualifiedTable(schema, TABLE_LOG_EVENTS);
+  if (mode === "delta") {
+    assertDeltaPollingEnabled();
+    return listLogsDelta(client, table, filters, after, limit);
+  }
+  return listLogsPage(client, table, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
+}
+async function listLogsPage(client, table, filters, page, perPage, orderField, orderDir) {
+  return listSignalPage({
+    client,
+    table,
+    filters,
+    page,
+    perPage,
+    orderField,
+    orderDir,
+    includeDeltaCursor: deltaPollingFeatureEnabled(),
+    selectColumns: LOG_SELECT_COLUMNS,
+    responseKey: "logs",
+    applyFilters: applyLogFilters,
+    mapRow: rowToLogRecord
+  });
+}
+async function listLogsDelta(client, table, filters, after, limit) {
+  return listSignalDelta({
+    client,
+    table,
+    filters,
+    after,
+    limit,
+    selectColumns: LOG_SELECT_COLUMNS,
+    responseKey: "logs",
+    applyFilters: applyLogFilters,
+    mapRow: rowToLogRecord
+  });
+}
+function applyMetricFilters(acc, filters) {
+  applyCommonFilters(acc, filters);
+  applySingleOrArrayFilter(acc, "name", filters?.name);
+  applySingleOrArrayFilter(acc, "provider", filters?.provider);
+  applySingleOrArrayFilter(acc, "model", filters?.model);
+  applySingleOrArrayFilter(acc, "costUnit", filters?.costUnit);
+  if (filters?.labels) {
+    acc.conditions.push(`"labels" @> $${acc.next++}::jsonb`);
+    acc.params.push(JSON.stringify(filters.labels));
+  }
+}
+function pushMetricNameFilter(acc, names) {
+  if (!names.length) return;
+  const placeholders = names.map(() => `$${acc.next++}`).join(", ");
+  acc.conditions.push(`"name" IN (${placeholders})`);
+  acc.params.push(...names);
+}
+async function batchCreateMetrics(client, schema, args) {
+  if (args.metrics.length === 0) return;
+  const rows = args.metrics.map(metricRecordToRow);
+  const insert = buildInsert(schema, TABLE_METRIC_EVENTS, rows);
+  if (insert) await client.query(insert.text, insert.values);
+}
+async function listMetrics(client, schema, args) {
+  const { mode, filters, pagination, orderBy, after, limit } = storage.listMetricsArgsSchema.parse(args);
+  const table = qualifiedTable(schema, TABLE_METRIC_EVENTS);
+  if (mode === "delta") {
+    assertDeltaPollingEnabled();
+    return listMetricsDelta(client, table, filters, after, limit);
+  }
+  return listMetricsPage(client, table, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
+}
+async function listMetricsPage(client, table, filters, page, perPage, orderField, orderDir) {
+  return listSignalPage({
+    client,
+    table,
+    filters,
+    page,
+    perPage,
+    orderField,
+    orderDir,
+    includeDeltaCursor: deltaPollingFeatureEnabled(),
+    selectColumns: METRIC_SELECT_COLUMNS,
+    responseKey: "metrics",
+    applyFilters: applyMetricFilters,
+    mapRow: rowToMetricRecord
+  });
+}
+async function listMetricsDelta(client, table, filters, after, limit) {
+  return listSignalDelta({
+    client,
+    table,
+    filters,
+    after,
+    limit,
+    selectColumns: METRIC_SELECT_COLUMNS,
+    responseKey: "metrics",
+    applyFilters: applyMetricFilters,
+    mapRow: rowToMetricRecord
+  });
+}
+async function runMetricAggregateQuery(client, schema, filters, names, aggregation, distinctColumn) {
+  const acc = newFilterAccumulator();
+  pushMetricNameFilter(acc, names);
+  applyMetricFilters(acc, filters);
+  const where = whereOrEmpty(acc);
+  const sql = `
+    SELECT ${metricAggregationSql(aggregation, '"value"', "timestamp", distinctColumn)} AS "value",
+           ${COST_SUMMARY_SELECT}
+    FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
+    ${where}
+  `;
+  const row = await client.oneOrNone(sql, acc.params) ?? {};
+  return {
+    value: row.value == null ? null : Number(row.value),
+    cost: costSummaryFromRow(row)
+  };
+}
+async function getMetricAggregate(client, schema, args) {
+  const { value, cost } = await runMetricAggregateQuery(
+    client,
+    schema,
+    args.filters,
+    args.name,
+    args.aggregation,
+    args.distinctColumn
+  );
+  if (args.comparePeriod && args.filters?.timestamp) {
+    const prevRange = shiftRange(args.filters.timestamp, args.comparePeriod);
+    if (prevRange) {
+      const prevFilters = { ...args.filters ?? {}, timestamp: prevRange };
+      const prev = await runMetricAggregateQuery(
+        client,
+        schema,
+        prevFilters,
+        args.name,
+        args.aggregation,
+        args.distinctColumn
+      );
+      return {
+        value,
+        estimatedCost: cost.estimatedCost,
+        costUnit: cost.costUnit,
+        previousValue: prev.value,
+        previousEstimatedCost: prev.cost.estimatedCost,
+        changePercent: changePercent(value, prev.value),
+        costChangePercent: changePercent(cost.estimatedCost, prev.cost.estimatedCost)
+      };
+    }
+  }
+  return { value, estimatedCost: cost.estimatedCost, costUnit: cost.costUnit };
+}
+async function getMetricBreakdown(client, schema, args) {
+  const acc = newFilterAccumulator();
+  const resolved = resolveGroupBy(acc, args.groupBy, {
+    typedColumns: METRIC_TYPED_COLUMNS,
+    excludedColumns: COMPLEX_GROUP_BY_EXCLUDED,
+    labelsColumn: "labels"
+  });
+  pushMetricNameFilter(acc, args.name);
+  applyMetricFilters(acc, args.filters);
+  pushLabelExclusions(acc, resolved);
+  const orderDirection = args.orderDirection === "ASC" ? "ASC" : "DESC";
+  const limitClause = args.limit == null ? "" : `LIMIT $${acc.next++}`;
+  if (args.limit != null) acc.params.push(args.limit);
+  const sql = `
+    SELECT ${resolved.map((e) => e.selectSql).join(", ")},
+           ${metricAggregationSql(args.aggregation, '"value"', "timestamp", args.distinctColumn)} AS "value",
+           ${COST_SUMMARY_SELECT}
+    FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY ${resolved.map((e) => e.alias).join(", ")}
+    ORDER BY "value" ${orderDirection} NULLS LAST
+    ${limitClause}
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  return {
+    groups: rows.map((row) => {
+      const cs = costSummaryFromRow(row);
+      return {
+        dimensions: dimensionsFromRow(row, resolved),
+        value: Number(row.value ?? 0),
+        estimatedCost: cs.estimatedCost,
+        costUnit: cs.costUnit
+      };
+    })
+  };
+}
+async function getMetricTimeSeries(client, schema, args) {
+  const bucket = bucketSql('"timestamp"', args.interval);
+  if (args.groupBy && args.groupBy.length > 0) {
+    const acc2 = newFilterAccumulator();
+    const resolved = resolveGroupBy(acc2, args.groupBy, {
+      typedColumns: METRIC_TYPED_COLUMNS,
+      excludedColumns: COMPLEX_GROUP_BY_EXCLUDED,
+      labelsColumn: "labels"
+    });
+    pushMetricNameFilter(acc2, args.name);
+    applyMetricFilters(acc2, args.filters);
+    pushLabelExclusions(acc2, resolved);
+    const sql2 = `
+      SELECT ${bucket} AS bucket,
+             ${resolved.map((e) => e.selectSql).join(", ")},
+             ${metricAggregationSql(args.aggregation, '"value"', "timestamp", args.distinctColumn)} AS "value",
+             ${COST_SUMMARY_SELECT}
+      FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
+      ${whereOrEmpty(acc2)}
+      GROUP BY bucket, ${resolved.map((e) => e.alias).join(", ")}
+      ORDER BY bucket
+    `;
+    const rows2 = await client.manyOrNone(sql2, acc2.params);
+    const series = collectSeriesByDimensions(
+      rows2,
+      resolved,
+      (dimValues) => ({
+        name: seriesNameFromDimensions(dimValues),
+        costUnits: /* @__PURE__ */ new Set(),
+        points: []
+      }),
+      (entry, row) => {
+        const cs = costSummaryFromRow(row);
+        if (cs.costUnit) entry.costUnits.add(cs.costUnit);
+        entry.points.push({
+          timestamp: bucketDate(row.bucket),
+          value: Number(row.value ?? 0),
+          estimatedCost: cs.estimatedCost
+        });
+      }
+    ).map((s) => ({
+      name: s.name,
+      costUnit: s.costUnits.size === 1 ? Array.from(s.costUnits)[0] : null,
+      points: s.points
+    }));
+    return { series };
+  }
+  const acc = newFilterAccumulator();
+  pushMetricNameFilter(acc, args.name);
+  applyMetricFilters(acc, args.filters);
+  const sql = `
+    SELECT ${bucket} AS bucket,
+           ${metricAggregationSql(args.aggregation, '"value"', "timestamp", args.distinctColumn)} AS "value",
+           ${COST_SUMMARY_SELECT}
+    FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY bucket
+    ORDER BY bucket
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  const overallCostUnits = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const cs = costSummaryFromRow(row);
+    if (cs.costUnit) overallCostUnits.add(cs.costUnit);
+  }
+  return {
+    series: [
+      {
+        name: args.name.join("|"),
+        costUnit: overallCostUnits.size === 1 ? Array.from(overallCostUnits)[0] : null,
+        points: rows.map((row) => {
+          const cs = costSummaryFromRow(row);
+          return {
+            timestamp: bucketDate(row.bucket),
+            value: Number(row.value ?? 0),
+            estimatedCost: cs.estimatedCost
+          };
+        })
+      }
+    ]
+  };
+}
+async function getMetricPercentiles(client, schema, args) {
+  validatePercentiles(args.percentiles);
+  const bucket = bucketSql('"timestamp"', args.interval);
+  const acc = newFilterAccumulator();
+  pushMetricNameFilter(acc, [args.name]);
+  applyMetricFilters(acc, args.filters);
+  const percentileSelect = percentileSelectSql(args.percentiles, '"value"');
+  const sql = `
+    SELECT ${bucket} AS bucket, ${percentileSelect}
+    FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY bucket
+    ORDER BY bucket
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  return { series: percentileSeriesFromRows(rows, args.percentiles) };
+}
+
+// src/storage/domains/observability/v-next/pg-errors.ts
+function asPgError(error) {
+  return error ?? {};
+}
+function isDuplicateRelationError(error) {
+  const { code, constraint, message = "" } = asPgError(error);
+  if (code === "42P07") return true;
+  if (code === "23505" && (constraint === "pg_type_typname_nsp_index" || constraint === "pg_class_relname_nsp_index")) {
+    return true;
+  }
+  return /already exists/i.test(message);
+}
+function isDuplicateSchemaError(error) {
+  const { code, constraint, message = "" } = asPgError(error);
+  if (code === "42P06") return true;
+  if (code === "23505" && constraint === "pg_namespace_nspname_index") return true;
+  return /schema .* already exists/i.test(message);
+}
+
+// src/storage/domains/observability/v-next/partitioning.ts
+var DEFAULT_FUTURE_DAYS = 14;
+async function detectTimescale(client) {
+  const row = await client.oneOrNone(
+    `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb') AS "exists"`
+  );
+  return Boolean(row?.exists);
+}
+async function detectPartman(client) {
+  const row = await client.oneOrNone(
+    `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_partman') AS "exists"`
+  );
+  return Boolean(row?.exists);
+}
+async function getPartmanVersion(client) {
+  const row = await client.oneOrNone(
+    `SELECT extversion FROM pg_extension WHERE extname = 'pg_partman'`
+  );
+  return row?.extversion ?? null;
+}
+function getPartmanMajor(version) {
+  if (!version) return null;
+  const match = /^(\d+)/.exec(version);
+  return match ? Number(match[1]) : null;
+}
+async function resolveMode(client, options = {}) {
+  if (options.mode && options.mode !== "auto") return options.mode;
+  if (await detectTimescale(client)) return "timescale";
+  if (await detectPartman(client)) return "partman";
+  return "native";
+}
+function dayBounds(d) {
+  const year = d.getUTCFullYear();
+  const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  const start = `${year}-${month}-${day} 00:00:00+00`;
+  const next = new Date(Date.UTC(year, d.getUTCMonth(), d.getUTCDate() + 1));
+  const ny = next.getUTCFullYear();
+  const nm = String(next.getUTCMonth() + 1).padStart(2, "0");
+  const nd = String(next.getUTCDate()).padStart(2, "0");
+  const end = `${ny}-${nm}-${nd} 00:00:00+00`;
+  return { start, end, suffix: `${year}${month}${day}` };
+}
+function partitionName(table, suffix) {
+  return `${table}_p${suffix}`;
+}
+async function ensureNativePartitions(client, schema, options = {}) {
+  const futureDays = options.futureDays ?? DEFAULT_FUTURE_DAYS;
+  const includeYesterday = options.includeYesterday ?? true;
+  const start = includeYesterday ? -1 : 0;
+  const baseNowMs = Date.now();
+  for (const table of ALL_SIGNAL_TABLES) {
+    for (let i = start; i <= futureDays; i++) {
+      const d = new Date(baseNowMs + i * 864e5);
+      const { start: partStart, end: partEnd, suffix } = dayBounds(d);
+      const childName = partitionName(table, suffix);
+      const child = qualifiedName(schema, childName);
+      const parent = qualifiedTable(schema, table);
+      try {
+        await client.none(`CREATE TABLE IF NOT EXISTS ${child} (LIKE ${parent} INCLUDING ALL)`);
+      } catch (error) {
+        if (!isDuplicateRelationError(error)) throw error;
+      }
+      try {
+        await client.none(
+          `ALTER TABLE ${parent} ATTACH PARTITION ${child}
+           FOR VALUES FROM ('${partStart}') TO ('${partEnd}')`
+        );
+      } catch (error) {
+        if (!isAlreadyAttachedError(error)) throw error;
+      }
+    }
+  }
+}
+function isAlreadyAttachedError(error) {
+  const code = error?.code;
+  const message = error?.message ?? "";
+  if (code === "42P17" || code === "42710") {
+    return /is already a partition/i.test(message) || /already a partition/i.test(message);
+  }
+  return /is already a partition/i.test(message);
+}
+async function ensureTimescaleHypertables(client, schema) {
+  for (const table of ALL_SIGNAL_TABLES) {
+    const tableExpr = qualifiedTable(schema, table);
+    const timeColumn = SIGNAL_TIME_COLUMN[table].replace(/'/g, "''");
+    await client.none(
+      `SELECT create_hypertable($1::regclass, '${timeColumn}', chunk_time_interval => INTERVAL '1 day', if_not_exists => true)`,
+      [tableExpr]
+    );
+  }
+}
+async function ensurePartmanHypertables(client, schema) {
+  const partmanMajor = getPartmanMajor(await getPartmanVersion(client));
+  for (const table of ALL_SIGNAL_TABLES) {
+    const exists = await client.oneOrNone(
+      `SELECT EXISTS (
+         SELECT 1 FROM partman.part_config
+         WHERE parent_table = format('%I.%I', $1::text, $2::text)
+       ) AS "exists"`,
+      [schema, table]
+    );
+    if (exists?.exists) continue;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        if (partmanMajor != null && partmanMajor >= 5) {
+          await client.none(
+            `SELECT partman.create_parent(
+               p_parent_table := format('%I.%I', $1::text, $2::text),
+               p_control := $3,
+               p_interval := '1 day',
+               p_type := 'range'
+             )`,
+            [schema, table, SIGNAL_TIME_COLUMN[table]]
+          );
+        } else {
+          await client.none(
+            `SELECT partman.create_parent(
+               p_parent_table := format('%I.%I', $1::text, $2::text),
+               p_control := $3,
+               p_type := 'native',
+               p_interval := '1 day'
+             )`,
+            [schema, table, SIGNAL_TIME_COLUMN[table]]
+          );
+        }
+        break;
+      } catch (error) {
+        const message = error?.message ?? "";
+        const code = error?.code;
+        const isDuplicate = code === "23505" || /already managed by pg_partman/i.test(message) || /relation .* already exists/i.test(message);
+        if (isDuplicate) break;
+        const isDeadlock = /deadlock detected/i.test(message);
+        if (!isDeadlock) throw error;
+        const registered = await client.oneOrNone(
+          `SELECT EXISTS (
+             SELECT 1 FROM partman.part_config
+             WHERE parent_table = format('%I.%I', $1::text, $2::text)
+           ) AS "exists"`,
+          [schema, table]
+        );
+        if (registered?.exists) break;
+        if (attempt === 2) throw error;
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+  }
+}
+async function setupPartitioning(client, schema, options = {}) {
+  const mode = await resolveMode(client, options);
+  switch (mode) {
+    case "timescale":
+      await ensureTimescaleHypertables(client, schema);
+      return "timescale";
+    case "partman":
+      await ensurePartmanHypertables(client, schema);
+      return "partman";
+    case "native":
+      await ensureNativePartitions(client, schema, options);
+      return "native";
+  }
+}
+function applyScoreFilters(acc, filters) {
+  applyCommonFilters(acc, filters);
+  applySingleOrArrayFilter(acc, "scorerId", filters?.scorerId);
+  if (filters?.scoreSource ?? filters?.source) {
+    acc.conditions.push(`"scoreSource" = $${acc.next++}`);
+    acc.params.push(filters.scoreSource ?? filters.source);
+  }
+}
+function pushScoreIdentity(acc, scorerId, scoreSource) {
+  acc.conditions.push(`"scorerId" = $${acc.next++}`);
+  acc.params.push(scorerId);
+  if (scoreSource !== void 0) {
+    acc.conditions.push(`"scoreSource" = $${acc.next++}`);
+    acc.params.push(scoreSource);
+  }
+}
+async function createScore(client, schema, args) {
+  const row = scoreRecordToRow(args.score);
+  const insert = buildInsert(schema, TABLE_SCORE_EVENTS, [row]);
+  if (insert) await client.query(insert.text, insert.values);
+}
+async function batchCreateScores(client, schema, args) {
+  if (args.scores.length === 0) return;
+  const rows = args.scores.map(scoreRecordToRow);
+  const insert = buildInsert(schema, TABLE_SCORE_EVENTS, rows);
+  if (insert) await client.query(insert.text, insert.values);
+}
+async function listScores(client, schema, args) {
+  const { mode, filters, pagination, orderBy, after, limit } = storage.listScoresArgsSchema.parse(args);
+  const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
+  if (mode === "delta") {
+    assertDeltaPollingEnabled();
+    return listScoresDelta(client, table, filters, after, limit);
+  }
+  return listScoresPage(client, table, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
+}
+async function getScoreById(client, schema, scoreId) {
+  const row = await client.oneOrNone(
+    `SELECT ${SCORE_SELECT_COLUMNS}
+     FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+     WHERE "scoreId" = $1
+     ORDER BY "timestamp" DESC
+     LIMIT 1`,
+    [scoreId]
+  );
+  return row ? rowToScoreRecord(row) : null;
+}
+async function listScoresPage(client, table, filters, page, perPage, orderField, orderDir) {
+  return listSignalPage({
+    client,
+    table,
+    filters,
+    page,
+    perPage,
+    orderField,
+    orderDir,
+    includeDeltaCursor: deltaPollingFeatureEnabled(),
+    selectColumns: SCORE_SELECT_COLUMNS,
+    responseKey: "scores",
+    applyFilters: applyScoreFilters,
+    mapRow: rowToScoreRecord
+  });
+}
+async function listScoresDelta(client, table, filters, after, limit) {
+  return listSignalDelta({
+    client,
+    table,
+    filters,
+    after,
+    limit,
+    selectColumns: SCORE_SELECT_COLUMNS,
+    responseKey: "scores",
+    applyFilters: applyScoreFilters,
+    mapRow: rowToScoreRecord
+  });
+}
+async function runScoreAggregateQuery(client, schema, args, filters) {
+  const acc = newFilterAccumulator();
+  pushScoreIdentity(acc, args.scorerId, args.scoreSource);
+  applyScoreFilters(acc, filters);
+  const sql = `
+    SELECT ${aggregationSql(args.aggregation, '"score"')} AS "value"
+    FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+    ${whereOrEmpty(acc)}
+  `;
+  const row = await client.oneOrNone(sql, acc.params);
+  return row?.value == null ? null : Number(row.value);
+}
+async function getScoreAggregate(client, schema, args) {
+  const value = await runScoreAggregateQuery(client, schema, args, args.filters);
+  if (args.comparePeriod && args.filters?.timestamp) {
+    const prevRange = shiftRange(args.filters.timestamp, args.comparePeriod);
+    if (prevRange) {
+      const previousValue = await runScoreAggregateQuery(client, schema, args, {
+        ...args.filters ?? {},
+        timestamp: prevRange
+      });
+      return {
+        value,
+        previousValue,
+        changePercent: changePercent(value, previousValue)
+      };
+    }
+  }
+  return { value };
+}
+async function getScoreBreakdown(client, schema, args) {
+  const acc = newFilterAccumulator();
+  const resolved = resolveGroupBy(acc, args.groupBy, {
+    typedColumns: SCORE_TYPED_COLUMNS,
+    excludedColumns: COMPLEX_GROUP_BY_EXCLUDED
+  });
+  pushScoreIdentity(acc, args.scorerId, args.scoreSource);
+  applyScoreFilters(acc, args.filters);
+  const sql = `
+    SELECT ${resolved.map((e) => e.selectSql).join(", ")},
+           ${aggregationSql(args.aggregation, '"score"')} AS "value"
+    FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY ${resolved.map((e) => e.alias).join(", ")}
+    ORDER BY "value" DESC NULLS LAST
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  return {
+    groups: rows.map((row) => ({
+      dimensions: dimensionsFromRow(row, resolved),
+      value: Number(row.value ?? 0)
+    }))
+  };
+}
+async function getScoreTimeSeries(client, schema, args) {
+  const bucket = bucketSql('"timestamp"', args.interval);
+  if (args.groupBy && args.groupBy.length > 0) {
+    const acc2 = newFilterAccumulator();
+    const resolved = resolveGroupBy(acc2, args.groupBy, {
+      typedColumns: SCORE_TYPED_COLUMNS,
+      excludedColumns: COMPLEX_GROUP_BY_EXCLUDED
+    });
+    pushScoreIdentity(acc2, args.scorerId, args.scoreSource);
+    applyScoreFilters(acc2, args.filters);
+    const sql2 = `
+      SELECT ${bucket} AS bucket,
+             ${resolved.map((e) => e.selectSql).join(", ")},
+             ${aggregationSql(args.aggregation, '"score"')} AS "value"
+      FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+      ${whereOrEmpty(acc2)}
+      GROUP BY bucket, ${resolved.map((e) => e.alias).join(", ")}
+      ORDER BY bucket
+    `;
+    const rows2 = await client.manyOrNone(sql2, acc2.params);
+    return {
+      series: collectSeriesByDimensions(
+        rows2,
+        resolved,
+        (dimValues) => ({
+          name: seriesNameFromDimensions(dimValues),
+          points: []
+        }),
+        (entry, row) => {
+          entry.points.push({
+            timestamp: bucketDate(row.bucket),
+            value: Number(row.value ?? 0)
+          });
+        }
+      )
+    };
+  }
+  const acc = newFilterAccumulator();
+  pushScoreIdentity(acc, args.scorerId, args.scoreSource);
+  applyScoreFilters(acc, args.filters);
+  const sql = `
+    SELECT ${bucket} AS bucket,
+           ${aggregationSql(args.aggregation, '"score"')} AS "value"
+    FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY bucket
+    ORDER BY bucket
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  const seriesName = args.scoreSource ? `${args.scorerId}|${args.scoreSource}` : args.scorerId;
+  return {
+    series: [
+      {
+        name: seriesName,
+        points: rows.map((row) => ({
+          timestamp: bucketDate(row.bucket),
+          value: Number(row.value ?? 0)
+        }))
+      }
+    ]
+  };
+}
+async function getScorePercentiles(client, schema, args) {
+  validatePercentiles(args.percentiles);
+  const bucket = bucketSql('"timestamp"', args.interval);
+  const acc = newFilterAccumulator();
+  pushScoreIdentity(acc, args.scorerId, args.scoreSource);
+  applyScoreFilters(acc, args.filters);
+  const percentileSelect = percentileSelectSql(args.percentiles, '"score"');
+  const sql = `
+    SELECT ${bucket} AS bucket, ${percentileSelect}
+    FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+    ${whereOrEmpty(acc)}
+    GROUP BY bucket
+    ORDER BY bucket
+  `;
+  const rows = await client.manyOrNone(sql, acc.params);
+  return { series: percentileSeriesFromRows(rows, args.percentiles) };
+}
+function asIsoTimestamp(value) {
+  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+async function getRootSpan(client, schema, args) {
+  const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  const row = await client.oneOrNone(
+    `SELECT ${SPAN_SELECT_COLUMNS}
+     FROM ${table}
+     WHERE "traceId" = $1 AND "parentSpanId" IS NULL
+     ORDER BY "endedAt" DESC
+     LIMIT 1`,
+    [args.traceId]
+  );
+  if (!row) return null;
+  return { span: rowToSpanRecord(row) };
+}
+function buildListTracesFilters(filters, spanTable, nextParamIdx) {
+  const conditions = [`r."parentSpanId" IS NULL`];
+  const params = [];
+  let i = nextParamIdx;
+  if (!filters) {
+    return { conditions, params, nextParamIdx: i };
+  }
+  if (filters.startedAt?.start) {
+    conditions.push(`r."startedAt" ${filters.startedAt.startExclusive ? ">" : ">="} $${i++}`);
+    params.push(asIsoTimestamp(filters.startedAt.start));
+  }
+  if (filters.startedAt?.end) {
+    conditions.push(`r."startedAt" ${filters.startedAt.endExclusive ? "<" : "<="} $${i++}`);
+    params.push(asIsoTimestamp(filters.startedAt.end));
+  }
+  if (filters.endedAt?.start) {
+    conditions.push(`r."endedAt" ${filters.endedAt.startExclusive ? ">" : ">="} $${i++}`);
+    params.push(asIsoTimestamp(filters.endedAt.start));
+  }
+  if (filters.endedAt?.end) {
+    conditions.push(`r."endedAt" ${filters.endedAt.endExclusive ? "<" : "<="} $${i++}`);
+    params.push(asIsoTimestamp(filters.endedAt.end));
+  }
+  if (filters.spanType !== void 0) {
+    conditions.push(`r."spanType" = $${i++}`);
+    params.push(filters.spanType);
+  }
+  if (filters.entityType !== void 0) {
+    conditions.push(`r."entityType" = $${i++}`);
+    params.push(filters.entityType);
+  }
+  if (filters.entityId !== void 0) {
+    conditions.push(`r."entityId" = $${i++}`);
+    params.push(filters.entityId);
+  }
+  if (filters.entityName !== void 0) {
+    conditions.push(`r."entityName" = $${i++}`);
+    params.push(filters.entityName);
+  }
+  if (filters.userId !== void 0) {
+    conditions.push(`r."userId" = $${i++}`);
+    params.push(filters.userId);
+  }
+  if (filters.organizationId !== void 0) {
+    conditions.push(`r."organizationId" = $${i++}`);
+    params.push(filters.organizationId);
+  }
+  if (filters.resourceId !== void 0) {
+    conditions.push(`r."resourceId" = $${i++}`);
+    params.push(filters.resourceId);
+  }
+  if (filters.runId !== void 0) {
+    conditions.push(`r."runId" = $${i++}`);
+    params.push(filters.runId);
+  }
+  if (filters.sessionId !== void 0) {
+    conditions.push(`r."sessionId" = $${i++}`);
+    params.push(filters.sessionId);
+  }
+  if (filters.threadId !== void 0) {
+    conditions.push(`r."threadId" = $${i++}`);
+    params.push(filters.threadId);
+  }
+  if (filters.requestId !== void 0) {
+    conditions.push(`r."requestId" = $${i++}`);
+    params.push(filters.requestId);
+  }
+  if (filters.environment !== void 0) {
+    conditions.push(`r."environment" = $${i++}`);
+    params.push(filters.environment);
+  }
+  if (filters.source !== void 0) {
+    conditions.push(`r."executionSource" = $${i++}`);
+    params.push(filters.source);
+  }
+  if (filters.serviceName !== void 0) {
+    conditions.push(`r."serviceName" = $${i++}`);
+    params.push(filters.serviceName);
+  }
+  if (filters.metadata != null) {
+    conditions.push(`r."metadataSearch" @> $${i++}::jsonb`);
+    params.push(JSON.stringify(filters.metadata));
+  }
+  if (filters.tags != null && filters.tags.length > 0) {
+    conditions.push(`r."tags" @> $${i++}::text[]`);
+    params.push(filters.tags);
+  }
+  if (filters.status !== void 0) {
+    switch (filters.status) {
+      case storage.TraceStatus.ERROR:
+        conditions.push(`r."error" IS NOT NULL`);
+        break;
+      case storage.TraceStatus.RUNNING:
+        conditions.push(`FALSE`);
+        break;
+      case storage.TraceStatus.SUCCESS:
+        conditions.push(`r."error" IS NULL`);
+        break;
+    }
+  }
+  if (filters.hasChildError !== void 0) {
+    const sub = `EXISTS (
+      SELECT 1 FROM ${spanTable} c
+      WHERE c."traceId" = r."traceId" AND c."spanId" <> r."spanId" AND c."error" IS NOT NULL
+    )`;
+    conditions.push(filters.hasChildError ? sub : `NOT ${sub}`);
+  }
+  return { conditions, params, nextParamIdx: i };
+}
+var SPAN_SELECT_COLUMNS_ALIASED = SPAN_SELECT_COLUMNS.replace(/\n/g, " ").split(",").map((c) => `r.${c.trim()}`).join(", ");
+async function listTraces(client, schema, args) {
+  const { mode, filters, pagination, orderBy, after, limit } = storage.listTracesArgsSchema.parse(args);
+  const span = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  if (mode === "delta") {
+    assertDeltaPollingEnabled();
+    return listTracesDelta(client, span, filters, after, limit);
+  }
+  return listTracesPage(client, span, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
+}
+async function listTracesPage(client, span, filters, page, perPage, orderField, orderDir) {
+  const { conditions, params, nextParamIdx } = buildListTracesFilters(filters, span, 1);
+  let i = nextParamIdx;
+  const whereClause = `WHERE ${conditions.join(" AND ")}`;
+  const orderClause = orderField === "endedAt" ? `ORDER BY r."endedAt" ${orderDir} NULLS ${orderDir === "DESC" ? "FIRST" : "LAST"}, r."cursorId" ${orderDir}` : `ORDER BY r."${orderField}" ${orderDir}, r."cursorId" ${orderDir}`;
+  const countRow = await client.oneOrNone(
+    `SELECT COUNT(*)::text AS count FROM ${span} r ${whereClause}`,
+    params
+  );
+  const count = Number(countRow?.count ?? 0);
+  let spans = [];
+  if (count > 0) {
+    const rows = await client.manyOrNone(
+      `SELECT ${SPAN_SELECT_COLUMNS_ALIASED}
+       FROM ${span} r
+       ${whereClause}
+       ${orderClause}
+       LIMIT $${i++} OFFSET $${i++}`,
+      [...params, perPage, page * perPage]
+    );
+    spans = rows.map(rowToSpanRecord);
+  }
+  const deltaCursor = deltaPollingFeatureEnabled() ? await readTracesStreamHeadCursor(client) : void 0;
+  return {
+    pagination: { total: count, page, perPage, hasMore: (page + 1) * perPage < count },
+    spans: storage.toTraceSpans(spans),
+    ...deltaCursor !== void 0 ? { deltaCursor } : {}
+  };
+}
+async function listTracesDelta(client, span, filters, after, limit) {
+  if (after === void 0) {
+    const deltaCursor2 = await readTracesStreamHeadCursor(client);
+    return { spans: [], delta: { limit, hasMore: false }, deltaCursor: deltaCursor2 };
+  }
+  const afterCursor = decodeDeltaCursor(after);
+  const safeHorizon = await readSafeXactHorizon(client);
+  const { conditions, params, nextParamIdx } = buildListTracesFilters(filters, span, 1);
+  let i = nextParamIdx;
+  conditions.push(`(r."xactId", r."cursorId") > ($${i++}::xid8, $${i++}::bigint)`);
+  params.push(afterCursor.xactId, afterCursor.cursorId);
+  conditions.push(`r."xactId" < $${i++}::xid8`);
+  params.push(safeHorizon);
+  const rows = await client.manyOrNone(
+    `SELECT ${SPAN_SELECT_COLUMNS_ALIASED}
+     FROM ${span} r
+     WHERE ${conditions.join(" AND ")}
+     ORDER BY r."xactId" ASC, r."cursorId" ASC
+     LIMIT $${i++}`,
+    [...params, limit + 1]
+  );
+  const hasMore = rows.length > limit;
+  const visible = rows.slice(0, limit);
+  const deltaCursor = visible.length > 0 ? encodeDeltaCursor(visible[visible.length - 1].xactId, visible[visible.length - 1].cursorId) : encodeDeltaCursor(safeHorizon, 0);
+  return {
+    spans: storage.toTraceSpans(visible.map(rowToSpanRecord)),
+    delta: { limit, hasMore },
+    deltaCursor
+  };
+}
+async function readTracesStreamHeadCursor(client, span, filters) {
+  return encodeDeltaCursor(await readSafeXactHorizon(client), 0);
+}
+var BRANCH_SPAN_TYPE_SET = new Set(storage.BRANCH_SPAN_TYPES);
+function buildBranchSpanTypeClause(userSpanType, params, startIdx) {
+  if (userSpanType !== void 0) {
+    if (!BRANCH_SPAN_TYPE_SET.has(userSpanType)) {
+      return null;
+    }
+    params.push(userSpanType);
+    return { clause: `r."spanType" = $${startIdx}`, nextIdx: startIdx + 1 };
+  }
+  const placeholders = [];
+  for (const t of storage.BRANCH_SPAN_TYPES) {
+    placeholders.push(`$${startIdx + placeholders.length}`);
+    params.push(t);
+  }
+  return { clause: `r."spanType" IN (${placeholders.join(", ")})`, nextIdx: startIdx + placeholders.length };
+}
+function buildListBranchesFilters(filters, spanType, nextParamIdx) {
+  const conditions = [];
+  const params = [];
+  let i = nextParamIdx;
+  const spanTypeClause = buildBranchSpanTypeClause(spanType, params, i);
+  if (!spanTypeClause) return null;
+  conditions.push(spanTypeClause.clause);
+  i = spanTypeClause.nextIdx;
+  if (!filters) return { conditions, params, nextParamIdx: i };
+  if (filters.startedAt?.start) {
+    conditions.push(`r."startedAt" ${filters.startedAt.startExclusive ? ">" : ">="} $${i++}`);
+    params.push(asIsoTimestamp(filters.startedAt.start));
+  }
+  if (filters.startedAt?.end) {
+    conditions.push(`r."startedAt" ${filters.startedAt.endExclusive ? "<" : "<="} $${i++}`);
+    params.push(asIsoTimestamp(filters.startedAt.end));
+  }
+  if (filters.endedAt?.start) {
+    conditions.push(`r."endedAt" ${filters.endedAt.startExclusive ? ">" : ">="} $${i++}`);
+    params.push(asIsoTimestamp(filters.endedAt.start));
+  }
+  if (filters.endedAt?.end) {
+    conditions.push(`r."endedAt" ${filters.endedAt.endExclusive ? "<" : "<="} $${i++}`);
+    params.push(asIsoTimestamp(filters.endedAt.end));
+  }
+  if (filters.traceId !== void 0) {
+    conditions.push(`r."traceId" = $${i++}`);
+    params.push(filters.traceId);
+  }
+  if (filters.entityType !== void 0) {
+    conditions.push(`r."entityType" = $${i++}`);
+    params.push(filters.entityType);
+  }
+  if (filters.entityId !== void 0) {
+    conditions.push(`r."entityId" = $${i++}`);
+    params.push(filters.entityId);
+  }
+  if (filters.entityName !== void 0) {
+    conditions.push(`r."entityName" = $${i++}`);
+    params.push(filters.entityName);
+  }
+  if (filters.entityVersionId !== void 0) {
+    conditions.push(`r."entityVersionId" = $${i++}`);
+    params.push(filters.entityVersionId);
+  }
+  if (filters.parentEntityType !== void 0) {
+    conditions.push(`r."parentEntityType" = $${i++}`);
+    params.push(filters.parentEntityType);
+  }
+  if (filters.parentEntityId !== void 0) {
+    conditions.push(`r."parentEntityId" = $${i++}`);
+    params.push(filters.parentEntityId);
+  }
+  if (filters.parentEntityName !== void 0) {
+    conditions.push(`r."parentEntityName" = $${i++}`);
+    params.push(filters.parentEntityName);
+  }
+  if (filters.parentEntityVersionId !== void 0) {
+    conditions.push(`r."parentEntityVersionId" = $${i++}`);
+    params.push(filters.parentEntityVersionId);
+  }
+  if (filters.rootEntityType !== void 0) {
+    conditions.push(`r."rootEntityType" = $${i++}`);
+    params.push(filters.rootEntityType);
+  }
+  if (filters.rootEntityId !== void 0) {
+    conditions.push(`r."rootEntityId" = $${i++}`);
+    params.push(filters.rootEntityId);
+  }
+  if (filters.rootEntityName !== void 0) {
+    conditions.push(`r."rootEntityName" = $${i++}`);
+    params.push(filters.rootEntityName);
+  }
+  if (filters.rootEntityVersionId !== void 0) {
+    conditions.push(`r."rootEntityVersionId" = $${i++}`);
+    params.push(filters.rootEntityVersionId);
+  }
+  if (filters.userId !== void 0) {
+    conditions.push(`r."userId" = $${i++}`);
+    params.push(filters.userId);
+  }
+  if (filters.organizationId !== void 0) {
+    conditions.push(`r."organizationId" = $${i++}`);
+    params.push(filters.organizationId);
+  }
+  if (filters.resourceId !== void 0) {
+    conditions.push(`r."resourceId" = $${i++}`);
+    params.push(filters.resourceId);
+  }
+  if (filters.runId !== void 0) {
+    conditions.push(`r."runId" = $${i++}`);
+    params.push(filters.runId);
+  }
+  if (filters.sessionId !== void 0) {
+    conditions.push(`r."sessionId" = $${i++}`);
+    params.push(filters.sessionId);
+  }
+  if (filters.threadId !== void 0) {
+    conditions.push(`r."threadId" = $${i++}`);
+    params.push(filters.threadId);
+  }
+  if (filters.requestId !== void 0) {
+    conditions.push(`r."requestId" = $${i++}`);
+    params.push(filters.requestId);
+  }
+  if (filters.experimentId !== void 0) {
+    conditions.push(`r."experimentId" = $${i++}`);
+    params.push(filters.experimentId);
+  }
+  if (filters.environment !== void 0) {
+    conditions.push(`r."environment" = $${i++}`);
+    params.push(filters.environment);
+  }
+  if (filters.serviceName !== void 0) {
+    conditions.push(`r."serviceName" = $${i++}`);
+    params.push(filters.serviceName);
+  }
+  if (filters.source !== void 0) {
+    conditions.push(`r."executionSource" = $${i++}`);
+    params.push(filters.source);
+  }
+  if (filters.metadata != null) {
+    conditions.push(`r."metadataSearch" @> $${i++}::jsonb`);
+    params.push(JSON.stringify(filters.metadata));
+  }
+  if (filters.tags != null && filters.tags.length > 0) {
+    conditions.push(`r."tags" @> $${i++}::text[]`);
+    params.push(filters.tags);
+  }
+  if (filters.status !== void 0) {
+    switch (filters.status) {
+      case storage.TraceStatus.ERROR:
+        conditions.push(`r."error" IS NOT NULL`);
+        break;
+      case storage.TraceStatus.RUNNING:
+        conditions.push(`FALSE`);
+        break;
+      case storage.TraceStatus.SUCCESS:
+        conditions.push(`r."error" IS NULL`);
+        break;
+    }
+  }
+  return { conditions, params, nextParamIdx: i };
+}
+async function listBranches(client, schema, args) {
+  const { mode, filters, pagination, orderBy, after, limit } = storage.listBranchesArgsSchema.parse(args);
+  const span = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  if (mode === "delta") {
+    assertDeltaPollingEnabled();
+    return listBranchesDelta(client, span, filters, after, limit);
+  }
+  return listBranchesPage(client, span, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
+}
+async function listBranchesPage(client, span, filters, page, perPage, orderField, orderDir) {
+  const built = buildListBranchesFilters(filters, filters?.spanType, 1);
+  if (!built) {
+    const deltaCursor2 = deltaPollingFeatureEnabled() ? await readBranchesStreamHeadCursor(client) : void 0;
+    return {
+      pagination: { total: 0, page, perPage, hasMore: false },
+      branches: [],
+      ...deltaCursor2 !== void 0 ? { deltaCursor: deltaCursor2 } : {}
+    };
+  }
+  const { conditions, params, nextParamIdx } = built;
+  let i = nextParamIdx;
+  const whereClause = `WHERE ${conditions.join(" AND ")}`;
+  const orderClause = orderField === "endedAt" ? `ORDER BY r."endedAt" ${orderDir} NULLS ${orderDir === "DESC" ? "FIRST" : "LAST"}, r."cursorId" ${orderDir}` : `ORDER BY r."${orderField}" ${orderDir}, r."cursorId" ${orderDir}`;
+  const countRow = await client.oneOrNone(
+    `SELECT COUNT(*)::text AS count FROM ${span} r ${whereClause}`,
+    params
+  );
+  const count = Number(countRow?.count ?? 0);
+  let spans = [];
+  if (count > 0) {
+    const rows = await client.manyOrNone(
+      `SELECT ${SPAN_SELECT_COLUMNS_ALIASED}
+       FROM ${span} r
+       ${whereClause}
+       ${orderClause}
+       LIMIT $${i++} OFFSET $${i++}`,
+      [...params, perPage, page * perPage]
+    );
+    spans = rows.map(rowToSpanRecord);
+  }
+  const deltaCursor = deltaPollingFeatureEnabled() ? await readBranchesStreamHeadCursor(client) : void 0;
+  return {
+    pagination: { total: count, page, perPage, hasMore: (page + 1) * perPage < count },
+    branches: storage.toTraceSpans(spans),
+    ...deltaCursor !== void 0 ? { deltaCursor } : {}
+  };
+}
+async function listBranchesDelta(client, span, filters, after, limit) {
+  if (after === void 0) {
+    const deltaCursor2 = await readBranchesStreamHeadCursor(client);
+    return { branches: [], delta: { limit, hasMore: false }, deltaCursor: deltaCursor2 };
+  }
+  const built = buildListBranchesFilters(filters, filters?.spanType, 1);
+  if (!built) {
+    return {
+      branches: [],
+      delta: { limit, hasMore: false },
+      deltaCursor: await readBranchesStreamHeadCursor(client)
+    };
+  }
+  const { conditions, params, nextParamIdx } = built;
+  let i = nextParamIdx;
+  const afterCursor = decodeDeltaCursor(after);
+  const safeHorizon = await readSafeXactHorizon(client);
+  conditions.push(`(r."xactId", r."cursorId") > ($${i++}::xid8, $${i++}::bigint)`);
+  params.push(afterCursor.xactId, afterCursor.cursorId);
+  conditions.push(`r."xactId" < $${i++}::xid8`);
+  params.push(safeHorizon);
+  const rows = await client.manyOrNone(
+    `SELECT ${SPAN_SELECT_COLUMNS_ALIASED}
+     FROM ${span} r
+     WHERE ${conditions.join(" AND ")}
+     ORDER BY r."xactId" ASC, r."cursorId" ASC
+     LIMIT $${i++}`,
+    [...params, limit + 1]
+  );
+  const hasMore = rows.length > limit;
+  const visible = rows.slice(0, limit);
+  const deltaCursor = visible.length > 0 ? encodeDeltaCursor(visible[visible.length - 1].xactId, visible[visible.length - 1].cursorId) : encodeDeltaCursor(safeHorizon, 0);
+  return {
+    branches: storage.toTraceSpans(visible.map(rowToSpanRecord)),
+    delta: { limit, hasMore },
+    deltaCursor
+  };
+}
+async function readBranchesStreamHeadCursor(client, span, filters) {
+  return encodeDeltaCursor(await readSafeXactHorizon(client), 0);
+}
+
+// src/storage/domains/observability/v-next/tracing.ts
+async function createSpan(client, schema, args) {
+  const row = spanRecordToRow(args.span);
+  const insert = buildInsert(schema, TABLE_SPAN_EVENTS, [row]);
+  if (insert) await client.query(insert.text, insert.values);
+}
+async function batchCreateSpans(client, schema, args) {
+  if (args.records.length === 0) return;
+  const rows = args.records.map(spanRecordToRow);
+  const insert = buildInsert(schema, TABLE_SPAN_EVENTS, rows);
+  if (insert) await client.query(insert.text, insert.values);
+}
+async function getSpans(client, schema, args) {
+  if (args.spanIds.length === 0) {
+    return { traceId: args.traceId, spans: [] };
+  }
+  const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  const rows = await client.manyOrNone(
+    `SELECT ${SPAN_SELECT_COLUMNS}
+     FROM ${table}
+     WHERE "traceId" = $1
+       AND "spanId" = ANY($2::text[])
+     ORDER BY "startedAt" ASC`,
+    [args.traceId, args.spanIds]
+  );
+  return { traceId: args.traceId, spans: rows.map(rowToSpanRecord) };
+}
+async function getSpan(client, schema, args) {
+  const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  const row = await client.oneOrNone(
+    `SELECT ${SPAN_SELECT_COLUMNS}
+     FROM ${table}
+     WHERE "traceId" = $1 AND "spanId" = $2
+     ORDER BY "endedAt" DESC
+     LIMIT 1`,
+    [args.traceId, args.spanId]
+  );
+  if (!row) return null;
+  return { span: rowToSpanRecord(row) };
+}
+async function getTrace(client, schema, args) {
+  const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  const rows = await client.manyOrNone(
+    `SELECT ${SPAN_SELECT_COLUMNS}
+     FROM ${table}
+     WHERE "traceId" = $1
+     ORDER BY "startedAt" ASC`,
+    [args.traceId]
+  );
+  if (!rows.length) return null;
+  return { traceId: args.traceId, spans: rows.map(rowToSpanRecord) };
+}
+async function getTraceLight(client, schema, args) {
+  const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  const rows = await client.manyOrNone(
+    `SELECT ${SPAN_LIGHT_SELECT_COLUMNS}
+     FROM ${table}
+     WHERE "traceId" = $1
+     ORDER BY "startedAt" ASC`,
+    [args.traceId]
+  );
+  if (!rows.length) return null;
+  return {
+    traceId: args.traceId,
+    spans: rows.map(rowToLightSpanRecord)
+  };
+}
+async function batchDeleteTraces(client, schema, args) {
+  if (args.traceIds.length === 0) return;
+  const span = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  const placeholders = args.traceIds.map((_, i) => `$${i + 1}`).join(", ");
+  await client.query(`DELETE FROM ${span} WHERE "traceId" IN (${placeholders})`, args.traceIds);
+}
+async function dangerouslyClearTracing(client, schema) {
+  const span = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+  await client.none(`TRUNCATE TABLE ${span} RESTART IDENTITY`);
+}
+
+// src/storage/domains/observability/v-next/index.ts
+function wrapError(op, error$1, details) {
+  if (error$1 instanceof error.MastraError) throw error$1;
+  throw new error.MastraError(
+    {
+      id: storage.createStorageErrorId("PG", op, "FAILED"),
+      domain: error.ErrorDomain.STORAGE,
+      category: error.ErrorCategory.THIRD_PARTY,
+      details
+    },
+    error$1
+  );
+}
+var ObservabilityStoragePostgresVNext = class extends storage.ObservabilityStorage {
+  #client;
+  #schema;
+  #partitioning;
+  #discoveryConfig;
+  #partitionMode;
+  constructor(config) {
+    super();
+    const { client, schemaName } = resolvePgConfig(config);
+    this.#client = client;
+    this.#schema = schemaName ?? "public";
+    this.#partitioning = config.partitioning ?? {};
+    this.#discoveryConfig = config.discovery ?? {};
+  }
+  /**
+   * Build the discovery config used at each call site, with the framework
+   * logger injected so background refresh failures land in the same log
+   * stream as the rest of the store. Reads `this.logger` lazily so
+   * `__setLogger()` calls (e.g. when the domain is mounted under a Mastra
+   * instance) propagate without rebuilding the domain.
+   */
+  get #discovery() {
+    return { ...this.#discoveryConfig, logger: this.logger };
+  }
+  // -------------------------------------------------------------------------
+  // Initialization
+  // -------------------------------------------------------------------------
+  /**
+   * Create the signal tables, indexes, and (if Timescale / pg_partman is
+   * present) hypertable / partman registrations.
+   *
+   * Not transactional: each `CREATE TABLE IF NOT EXISTS`, `CREATE INDEX IF
+   * NOT EXISTS`, and `create_hypertable()` / `create_parent()` runs in its
+   * own implicit transaction. Re-running `init()` after a failure is safe
+   * (every statement is idempotent), but a failure partway through against
+   * Timescale can leave some signal tables as hypertables and others as
+   * plain tables. If that happens, fix the underlying error and call
+   * `init()` again — the partially-converted state is recoverable.
+   */
+  async init() {
+    try {
+      const explicit = this.#partitioning.mode;
+      let mode;
+      if (explicit && explicit !== "auto") {
+        mode = explicit;
+      } else if (await detectTimescale(this.#client)) {
+        mode = "timescale";
+      } else if (await detectPartman(this.#client)) {
+        mode = "partman";
+      } else {
+        mode = "native";
+      }
+      const ddlMode = mode === "timescale" ? "timescale" : "partitioned";
+      try {
+        await this.#client.none(schemaDDL(this.#schema));
+      } catch (error) {
+        if (!isDuplicateSchemaError(error)) throw error;
+      }
+      for (const ddl of allTableDDL(this.#schema, ddlMode)) {
+        try {
+          await this.#client.none(ddl);
+        } catch (error) {
+          if (!isDuplicateRelationError(error)) throw error;
+        }
+      }
+      for (const ddl of allIndexDDL(this.#schema)) {
+        try {
+          await this.#client.none(ddl);
+        } catch (error) {
+          if (!isDuplicateRelationError(error)) throw error;
+        }
+      }
+      this.#partitionMode = await setupPartitioning(this.#client, this.#schema, {
+        ...this.#partitioning,
+        mode
+      });
+    } catch (error) {
+      wrapError("VNEXT_INIT", error);
+    }
+  }
+  /** Resolved partition mode after init(). Useful for tests and diagnostics. */
+  get partitionMode() {
+    return this.#partitionMode;
+  }
+  get observabilityStrategy() {
+    return { preferred: "insert-only", supported: ["insert-only"] };
+  }
+  getFeatures() {
+    if (!deltaPollingFeatureEnabled()) return void 0;
+    return ["delta-polling"];
+  }
+  async #run(op, fn, details) {
+    try {
+      return await fn();
+    } catch (error) {
+      wrapError(op, error, details);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Tracing — writes
+  // -------------------------------------------------------------------------
+  async createSpan(args) {
+    await this.#run("CREATE_SPAN", () => createSpan(this.#client, this.#schema, args), {
+      traceId: args.span.traceId,
+      spanId: args.span.spanId
+    });
+  }
+  async batchCreateSpans(args) {
+    await this.#run("BATCH_CREATE_SPANS", () => batchCreateSpans(this.#client, this.#schema, args), {
+      count: args.records.length
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Tracing — reads
+  // -------------------------------------------------------------------------
+  async getSpan(args) {
+    return this.#run("GET_SPAN", () => getSpan(this.#client, this.#schema, args), {
+      traceId: args.traceId,
+      spanId: args.spanId
+    });
+  }
+  async getSpans(args) {
+    return this.#run("GET_SPANS", () => getSpans(this.#client, this.#schema, args), {
+      traceId: args.traceId,
+      count: args.spanIds.length
+    });
+  }
+  async getRootSpan(args) {
+    return this.#run("GET_ROOT_SPAN", () => getRootSpan(this.#client, this.#schema, args), {
+      traceId: args.traceId
+    });
+  }
+  async getTrace(args) {
+    return this.#run("GET_TRACE", () => getTrace(this.#client, this.#schema, args), {
+      traceId: args.traceId
+    });
+  }
+  async getTraceLight(args) {
+    return this.#run("GET_TRACE_LIGHT", () => getTraceLight(this.#client, this.#schema, args), {
+      traceId: args.traceId
+    });
+  }
+  async listTraces(args) {
+    return this.#run("LIST_TRACES", () => listTraces(this.#client, this.#schema, args));
+  }
+  async listBranches(args) {
+    return this.#run("LIST_BRANCHES", () => listBranches(this.#client, this.#schema, args));
+  }
+  // -------------------------------------------------------------------------
+  // Logs / metrics / scores / feedback — writes
+  // -------------------------------------------------------------------------
+  async batchCreateLogs(args) {
+    await this.#run("BATCH_CREATE_LOGS", () => batchCreateLogs(this.#client, this.#schema, args), {
+      count: args.logs.length
+    });
+  }
+  async batchCreateMetrics(args) {
+    await this.#run("BATCH_CREATE_METRICS", () => batchCreateMetrics(this.#client, this.#schema, args), {
+      count: args.metrics.length
+    });
+  }
+  async createScore(args) {
+    await this.#run("CREATE_SCORE", () => createScore(this.#client, this.#schema, args));
+  }
+  async batchCreateScores(args) {
+    await this.#run("BATCH_CREATE_SCORES", () => batchCreateScores(this.#client, this.#schema, args), {
+      count: args.scores.length
+    });
+  }
+  async createFeedback(args) {
+    await this.#run("CREATE_FEEDBACK", () => createFeedback(this.#client, this.#schema, args));
+  }
+  async batchCreateFeedback(args) {
+    await this.#run("BATCH_CREATE_FEEDBACK", () => batchCreateFeedback(this.#client, this.#schema, args), {
+      count: args.feedbacks.length
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Logs / metrics / scores / feedback — list reads
+  // -------------------------------------------------------------------------
+  async listLogs(args) {
+    return this.#run("LIST_LOGS", () => listLogs(this.#client, this.#schema, args));
+  }
+  async listMetrics(args) {
+    return this.#run("LIST_METRICS", () => listMetrics(this.#client, this.#schema, args));
+  }
+  async listScores(args) {
+    return this.#run("LIST_SCORES", () => listScores(this.#client, this.#schema, args));
+  }
+  async getScoreById(scoreId) {
+    return this.#run("GET_SCORE_BY_ID", () => getScoreById(this.#client, this.#schema, scoreId), {
+      scoreId
+    });
+  }
+  async listFeedback(args) {
+    return this.#run("LIST_FEEDBACK", () => listFeedback(this.#client, this.#schema, args));
+  }
+  // -------------------------------------------------------------------------
+  // OLAP — metrics
+  // -------------------------------------------------------------------------
+  async getMetricAggregate(args) {
+    return this.#run("GET_METRIC_AGGREGATE", () => getMetricAggregate(this.#client, this.#schema, args));
+  }
+  async getMetricBreakdown(args) {
+    return this.#run("GET_METRIC_BREAKDOWN", () => getMetricBreakdown(this.#client, this.#schema, args));
+  }
+  async getMetricTimeSeries(args) {
+    return this.#run("GET_METRIC_TIME_SERIES", () => getMetricTimeSeries(this.#client, this.#schema, args));
+  }
+  async getMetricPercentiles(args) {
+    return this.#run("GET_METRIC_PERCENTILES", () => getMetricPercentiles(this.#client, this.#schema, args));
+  }
+  // -------------------------------------------------------------------------
+  // OLAP — scores
+  // -------------------------------------------------------------------------
+  async getScoreAggregate(args) {
+    return this.#run("GET_SCORE_AGGREGATE", () => getScoreAggregate(this.#client, this.#schema, args));
+  }
+  async getScoreBreakdown(args) {
+    return this.#run("GET_SCORE_BREAKDOWN", () => getScoreBreakdown(this.#client, this.#schema, args));
+  }
+  async getScoreTimeSeries(args) {
+    return this.#run("GET_SCORE_TIME_SERIES", () => getScoreTimeSeries(this.#client, this.#schema, args));
+  }
+  async getScorePercentiles(args) {
+    return this.#run("GET_SCORE_PERCENTILES", () => getScorePercentiles(this.#client, this.#schema, args));
+  }
+  // -------------------------------------------------------------------------
+  // OLAP — feedback
+  // -------------------------------------------------------------------------
+  async getFeedbackAggregate(args) {
+    return this.#run(
+      "GET_FEEDBACK_AGGREGATE",
+      () => getFeedbackAggregate(this.#client, this.#schema, args)
+    );
+  }
+  async getFeedbackBreakdown(args) {
+    return this.#run(
+      "GET_FEEDBACK_BREAKDOWN",
+      () => getFeedbackBreakdown(this.#client, this.#schema, args)
+    );
+  }
+  async getFeedbackTimeSeries(args) {
+    return this.#run(
+      "GET_FEEDBACK_TIME_SERIES",
+      () => getFeedbackTimeSeries(this.#client, this.#schema, args)
+    );
+  }
+  async getFeedbackPercentiles(args) {
+    return this.#run(
+      "GET_FEEDBACK_PERCENTILES",
+      () => getFeedbackPercentiles(this.#client, this.#schema, args)
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Discovery
+  // -------------------------------------------------------------------------
+  async getEntityTypes(args) {
+    return this.#run(
+      "GET_ENTITY_TYPES",
+      () => getEntityTypes(this.#client, this.#schema, args, this.#discovery)
+    );
+  }
+  async getEntityNames(args) {
+    return this.#run(
+      "GET_ENTITY_NAMES",
+      () => getEntityNames(this.#client, this.#schema, args, this.#discovery)
+    );
+  }
+  async getServiceNames(args) {
+    return this.#run(
+      "GET_SERVICE_NAMES",
+      () => getServiceNames(this.#client, this.#schema, args, this.#discovery)
+    );
+  }
+  async getEnvironments(args) {
+    return this.#run(
+      "GET_ENVIRONMENTS",
+      () => getEnvironments(this.#client, this.#schema, args, this.#discovery)
+    );
+  }
+  async getTags(args) {
+    return this.#run("GET_TAGS", () => getTags(this.#client, this.#schema, args, this.#discovery));
+  }
+  async getMetricNames(args) {
+    return this.#run(
+      "GET_METRIC_NAMES",
+      () => getMetricNames(this.#client, this.#schema, args, this.#discovery)
+    );
+  }
+  async getMetricLabelKeys(args) {
+    return this.#run(
+      "GET_METRIC_LABEL_KEYS",
+      () => getMetricLabelKeys(this.#client, this.#schema, args, this.#discovery)
+    );
+  }
+  async getMetricLabelValues(args) {
+    return this.#run(
+      "GET_METRIC_LABEL_VALUES",
+      () => getMetricLabelValues(this.#client, this.#schema, args, this.#discovery)
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Tracing — deletes / clear
+  // -------------------------------------------------------------------------
+  async batchDeleteTraces(args) {
+    await this.#run("BATCH_DELETE_TRACES", () => batchDeleteTraces(this.#client, this.#schema, args), {
+      count: args.traceIds.length
+    });
+  }
+  async dangerouslyClearAll() {
+    try {
+      await dangerouslyClearTracing(this.#client, this.#schema);
+      for (const t of ALL_SIGNAL_TABLES) {
+        if (t === TABLE_SPAN_EVENTS) continue;
+        await this.#client.none(`TRUNCATE TABLE ${qualifiedTable(this.#schema, t)} RESTART IDENTITY`);
+      }
+      await this.#client.none(`TRUNCATE TABLE ${qualifiedTable(this.#schema, TABLE_DISCOVERY)} RESTART IDENTITY`);
+    } catch (error) {
+      wrapError("DANGEROUSLY_CLEAR_ALL", error);
+    }
+  }
+};
+var SNAPSHOT_FIELDS3 = ["name", "description", "content", "rules", "requestContextSchema"];
+var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_PROMPT_BLOCKS, storage.TABLE_PROMPT_BLOCK_VERSIONS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
+    this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _PromptBlocksPG.MANAGED_TABLES.includes(idx.table));
+  }
+  /**
+   * Returns default index definitions for the prompt blocks domain tables.
+   * @param schemaPrefix - Prefix for index names (e.g. "my_schema_" or "")
+   */
+  static getDefaultIndexDefs(schemaPrefix) {
+    return [
+      {
+        name: `${schemaPrefix}idx_prompt_block_versions_block_version`,
+        table: storage.TABLE_PROMPT_BLOCK_VERSIONS,
+        columns: ["blockId", "versionNumber"],
+        unique: true
+      }
+    ];
+  }
+  /**
+   * Returns all DDL statements for this domain: tables and indexes.
+   * Used by exportSchemas to produce a complete, reproducible schema export.
+   */
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    for (const tableName of _PromptBlocksPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    for (const idx of _PromptBlocksPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _PromptBlocksPG.getDefaultIndexDefs(schemaPrefix);
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch {
+      }
+    }
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_PROMPT_BLOCKS, schema: storage.TABLE_SCHEMAS[storage.TABLE_PROMPT_BLOCKS] });
+    await this.#db.createTable({
+      tableName: storage.TABLE_PROMPT_BLOCK_VERSIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_PROMPT_BLOCK_VERSIONS]
+    });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_PROMPT_BLOCK_VERSIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_PROMPT_BLOCK_VERSIONS],
+      ifNotExists: ["requestContextSchema"]
+    });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_PROMPT_BLOCK_VERSIONS });
+    await this.#db.clearTable({ tableName: storage.TABLE_PROMPT_BLOCKS });
+  }
+  // ==========================================================================
+  // Prompt Block CRUD Methods
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_PROMPT_BLOCKS, schemaName: getSchemaName2(this.#schema) });
       const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
       if (!result) {
         return null;
@@ -13534,16 +16855,39 @@ var SkillsPG = class _SkillsPG extends storage.SkillsStorage {
     this.#skipDefaultIndexes = skipDefaultIndexes;
     this.#indexes = indexes?.filter((idx) => _SkillsPG.MANAGED_TABLES.includes(idx.table));
   }
-  getDefaultIndexDefinitions() {
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
-        name: "idx_skill_versions_skill_version",
+        name: `${schemaPrefix}idx_skill_versions_skill_version`,
         table: storage.TABLE_SKILL_VERSIONS,
         columns: ["skillId", "versionNumber"],
         unique: true
       }
     ];
   }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    for (const tableName of _SkillsPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    for (const idx of _SkillsPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _SkillsPG.getDefaultIndexDefs(schemaPrefix);
+  }
   async createDefaultIndexes() {
     if (this.#skipDefaultIndexes) {
       return;
@@ -14241,6 +17585,254 @@ var SkillsPG = class _SkillsPG extends storage.SkillsStorage {
     };
   }
 };
+function normaliseScope(raw) {
+  const value = raw == null ? "per-author" : String(raw);
+  if (value === "shared") return "shared";
+  if (value === "caller-supplied") return "caller-supplied";
+  return "per-author";
+}
+function rowToToolProviderConnection(row) {
+  return {
+    authorId: String(row.authorId),
+    providerId: String(row.providerId),
+    toolkit: String(row.toolkit),
+    connectionId: String(row.connectionId),
+    label: row.label == null ? null : String(row.label),
+    scope: normaliseScope(row.scope),
+    createdAt: new Date(String(row.createdAtZ ?? row.createdAt)),
+    updatedAt: new Date(String(row.updatedAtZ ?? row.updatedAt))
+  };
+}
+var ToolProviderConnectionsPG = class _ToolProviderConnectionsPG extends storage.ToolProviderConnectionsStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_TOOL_PROVIDER_CONNECTIONS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
+    this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter(
+      (idx) => _ToolProviderConnectionsPG.MANAGED_TABLES.includes(idx.table)
+    );
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_TOOL_PROVIDER_CONNECTIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_TOOL_PROVIDER_CONNECTIONS],
+      compositePrimaryKey: ["authorId", "providerId", "connectionId"]
+    });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  static getDefaultIndexDefs(schemaPrefix) {
+    return [
+      {
+        name: `${schemaPrefix}idx_tool_provider_connections_author`,
+        table: storage.TABLE_TOOL_PROVIDER_CONNECTIONS,
+        columns: ["authorId", "providerId", "toolkit"]
+      }
+    ];
+  }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    statements.push(
+      generateTableSQL({
+        tableName: storage.TABLE_TOOL_PROVIDER_CONNECTIONS,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_TOOL_PROVIDER_CONNECTIONS],
+        schemaName,
+        compositePrimaryKey: ["authorId", "providerId", "connectionId"],
+        includeAllConstraints: true
+      })
+    );
+    for (const idx of _ToolProviderConnectionsPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _ToolProviderConnectionsPG.getDefaultIndexDefs(schemaPrefix);
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) return;
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) return;
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_TOOL_PROVIDER_CONNECTIONS });
+  }
+  async getConnectionById({
+    authorId,
+    providerId,
+    connectionId
+  }) {
+    const tableName = getTableName2({
+      indexName: storage.TABLE_TOOL_PROVIDER_CONNECTIONS,
+      schemaName: getSchemaName2(this.#schema)
+    });
+    try {
+      const row = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE "authorId" = $1 AND "providerId" = $2 AND "connectionId" = $3 LIMIT 1`,
+        [authorId, providerId, connectionId]
+      );
+      return row ? rowToToolProviderConnection(row) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "TOOL_PROVIDER_CONNECTION_GET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { authorId, providerId, connectionId }
+        },
+        error$1
+      );
+    }
+  }
+  async upsertConnection(input) {
+    const { authorId, providerId, toolkit, connectionId, label } = input;
+    const tableName = getTableName2({
+      indexName: storage.TABLE_TOOL_PROVIDER_CONNECTIONS,
+      schemaName: getSchemaName2(this.#schema)
+    });
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    const labelValue = label == null ? null : label;
+    try {
+      return await this.#db.client.tx(async (t) => {
+        const existing = await t.oneOrNone(
+          `SELECT "createdAt", "createdAtZ", scope FROM ${tableName} WHERE "authorId" = $1 AND "providerId" = $2 AND "connectionId" = $3 LIMIT 1`,
+          [authorId, providerId, connectionId]
+        );
+        const existingCreatedAt = existing ? existing.createdAtZ ?? existing.createdAt : null;
+        const createdAt = existingCreatedAt != null ? new Date(existingCreatedAt).toISOString() : nowIso;
+        const existingScope = existing && existing.scope != null ? normaliseScope(existing.scope) : void 0;
+        const scope = input.scope ?? existingScope ?? "per-author";
+        await t.none(
+          `INSERT INTO ${tableName} ("authorId", "providerId", toolkit, "connectionId", label, scope, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ")
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+           ON CONFLICT ("authorId", "providerId", "connectionId") DO UPDATE SET
+             toolkit = EXCLUDED.toolkit,
+             label = EXCLUDED.label,
+             scope = EXCLUDED.scope,
+             "updatedAt" = EXCLUDED."updatedAt",
+             "updatedAtZ" = EXCLUDED."updatedAtZ"`,
+          [authorId, providerId, toolkit, connectionId, labelValue, scope, createdAt, createdAt, nowIso, nowIso]
+        );
+        return {
+          authorId,
+          providerId,
+          toolkit,
+          connectionId,
+          label: labelValue,
+          scope,
+          createdAt: new Date(createdAt),
+          updatedAt: now
+        };
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "TOOL_PROVIDER_CONNECTION_UPSERT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { authorId, providerId, connectionId }
+        },
+        error$1
+      );
+    }
+  }
+  async listConnectionsByAuthor({
+    authorId,
+    providerId,
+    toolkit,
+    scope
+  }) {
+    const tableName = getTableName2({
+      indexName: storage.TABLE_TOOL_PROVIDER_CONNECTIONS,
+      schemaName: getSchemaName2(this.#schema)
+    });
+    try {
+      const clauses = [];
+      const args = [];
+      if (authorId !== void 0) {
+        args.push(authorId);
+        clauses.push(`"authorId" = $${args.length}`);
+      }
+      if (providerId) {
+        args.push(providerId);
+        clauses.push(`"providerId" = $${args.length}`);
+      }
+      if (toolkit) {
+        args.push(toolkit);
+        clauses.push(`toolkit = $${args.length}`);
+      }
+      if (scope) {
+        args.push(scope);
+        clauses.push(`scope = $${args.length}`);
+      }
+      const whereClause = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+      const rows = await this.#db.client.manyOrNone(`SELECT * FROM ${tableName}${whereClause}`, args);
+      return rows.map((row) => rowToToolProviderConnection(row));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "TOOL_PROVIDER_CONNECTION_LIST", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { authorId: authorId ?? "", providerId: providerId ?? "", toolkit: toolkit ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteConnection({
+    authorId,
+    providerId,
+    connectionId
+  }) {
+    const tableName = getTableName2({
+      indexName: storage.TABLE_TOOL_PROVIDER_CONNECTIONS,
+      schemaName: getSchemaName2(this.#schema)
+    });
+    try {
+      await this.#db.client.none(
+        `DELETE FROM ${tableName} WHERE "authorId" = $1 AND "providerId" = $2 AND "connectionId" = $3`,
+        [authorId, providerId, connectionId]
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "TOOL_PROVIDER_CONNECTION_DELETE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { authorId, providerId, connectionId }
+        },
+        error$1
+      );
+    }
+  }
+};
 function getSchemaName7(schema) {
   return schema ? `"${schema}"` : '"public"';
 }
@@ -14381,8 +17973,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
           const existingSnapshot = existingSnapshotResult.snapshot;
           snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
         }
-        snapshot.context[stepId] = result;
-        snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+        storage.mergeWorkflowStepResult({ snapshot, stepId, result, requestContext });
         const now = /* @__PURE__ */ new Date();
         const sanitizedSnapshot = sanitizeJsonForPg(JSON.stringify(snapshot));
         await t.none(
@@ -14574,7 +18165,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
   async listWorkflowRuns({
     workflowName,
     fromDate,
-    toDate,
+    toDate: toDate2,
     perPage,
     page,
     resourceId,
@@ -14611,9 +18202,9 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
         values.push(fromDate);
         paramIndex++;
       }
-      if (toDate) {
+      if (toDate2) {
         conditions.push(`"createdAt" <= $${paramIndex}`);
-        values.push(toDate);
+        values.push(toDate2);
         paramIndex++;
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -14681,16 +18272,39 @@ var WorkspacesPG = class _WorkspacesPG extends storage.WorkspacesStorage {
     this.#skipDefaultIndexes = skipDefaultIndexes;
     this.#indexes = indexes?.filter((idx) => _WorkspacesPG.MANAGED_TABLES.includes(idx.table));
   }
-  getDefaultIndexDefinitions() {
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
-        name: "idx_workspace_versions_workspace_version",
+        name: `${schemaPrefix}idx_workspace_versions_workspace_version`,
         table: storage.TABLE_WORKSPACE_VERSIONS,
         columns: ["workspaceId", "versionNumber"],
         unique: true
       }
     ];
   }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    for (const tableName of _WorkspacesPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    for (const idx of _WorkspacesPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _WorkspacesPG.getDefaultIndexDefs(schemaPrefix);
+  }
   async createDefaultIndexes() {
     if (this.#skipDefaultIndexes) {
       return;
@@ -15332,19 +18946,30 @@ var WorkspacesPG = class _WorkspacesPG extends storage.WorkspacesStorage {
     };
   }
 };
-function buildConnectionStringPoolConfig(config, defaults) {
-  const parsed = pgConnectionString.parse(config.connectionString);
-  return {
-    ...parsed,
-    ...config.ssl !== void 0 ? { ssl: config.ssl } : {},
-    max: config.max ?? defaults.max,
-    idleTimeoutMillis: config.idleTimeoutMillis ?? defaults.idleTimeoutMillis
-  };
-}
 
 // src/storage/index.ts
 var DEFAULT_MAX_CONNECTIONS = 20;
 var DEFAULT_IDLE_TIMEOUT_MS = 3e4;
+function createConnectionStringPool(config) {
+  return new pg.Pool(
+    buildConnectionStringPoolConfig(config, {
+      max: DEFAULT_MAX_CONNECTIONS,
+      idleTimeoutMillis: DEFAULT_IDLE_TIMEOUT_MS
+    })
+  );
+}
+function createHostPool(config) {
+  return new pg.Pool({
+    host: config.host,
+    port: config.port,
+    database: config.database,
+    user: config.user,
+    password: config.password,
+    ssl: config.ssl,
+    max: config.max ?? DEFAULT_MAX_CONNECTIONS,
+    idleTimeoutMillis: config.idleTimeoutMillis ?? DEFAULT_IDLE_TIMEOUT_MS
+  });
+}
 var ALL_DOMAINS = [
   MemoryPG,
   NotificationsPG,
@@ -15353,6 +18978,12 @@ var ALL_DOMAINS = [
   ScorerDefinitionsPG,
   PromptBlocksPG,
   AgentsPG,
+  MCPClientsPG,
+  MCPServersPG,
+  WorkspacesPG,
+  SkillsPG,
+  BlobsPG,
+  ToolProviderConnectionsPG,
   WorkflowsPG,
   DatasetsPG,
   ExperimentsPG,
@@ -15377,6 +19008,7 @@ var PostgresStore = class extends storage.MastraCompositeStore {
   #pool;
   #db;
   #ownsPool;
+  #poolClosed = false;
   schema;
   isInitialized = false;
   stores;
@@ -15413,6 +19045,7 @@ var PostgresStore = class extends storage.MastraCompositeStore {
         workspaces: new WorkspacesPG(domainConfig),
         skills: new SkillsPG(domainConfig),
         favorites: new FavoritesPG(domainConfig),
+        toolProviderConnections: new ToolProviderConnectionsPG(domainConfig),
         blobs: new BlobsPG(domainConfig),
         datasets: new DatasetsPG(domainConfig),
         experiments: new ExperimentsPG(domainConfig),
@@ -15433,24 +19066,10 @@ var PostgresStore = class extends storage.MastraCompositeStore {
   }
   createPool(config) {
     if (isConnectionStringConfig(config)) {
-      return new pg.Pool(
-        buildConnectionStringPoolConfig(config, {
-          max: DEFAULT_MAX_CONNECTIONS,
-          idleTimeoutMillis: DEFAULT_IDLE_TIMEOUT_MS
-        })
-      );
+      return createConnectionStringPool(config);
     }
     if (isHostConfig(config)) {
-      return new pg.Pool({
-        host: config.host,
-        port: config.port,
-        database: config.database,
-        user: config.user,
-        password: config.password,
-        ssl: config.ssl,
-        max: config.max ?? DEFAULT_MAX_CONNECTIONS,
-        idleTimeoutMillis: config.idleTimeoutMillis ?? DEFAULT_IDLE_TIMEOUT_MS
-      });
+      return createHostPool(config);
     }
     if (isCloudSqlConfig(config)) {
       return new pg.Pool(config);
@@ -15500,13 +19119,81 @@ var PostgresStore = class extends storage.MastraCompositeStore {
   /**
    * Closes the connection pool if it was created by this store.
    * If a pool was passed in via config, it will not be closed.
+   * Safe to call multiple times — subsequent calls are no-ops.
    */
   async close() {
-    if (this.#ownsPool) {
+    if (this.#ownsPool && !this.#poolClosed) {
+      this.#poolClosed = true;
       await this.#pool.end();
     }
   }
 };
+function isSameConnectionTarget(primary, observability) {
+  if ("pool" in primary && "pool" in observability) {
+    return primary.pool === observability.pool;
+  }
+  if ("connectionString" in primary && "connectionString" in observability) {
+    return primary.connectionString === observability.connectionString;
+  }
+  if ("host" in primary && "host" in observability) {
+    return primary.host === observability.host && (primary.port ?? 5432) === (observability.port ?? 5432) && primary.database === observability.database;
+  }
+  return false;
+}
+var COLLISION_WARNING = "PostgresStoreVNext: the `observability` connection appears to point at the same Postgres instance as the primary store. For production workloads, point observability at a dedicated Postgres instance to avoid degrading your application database performance.";
+var PostgresStoreVNext = class extends PostgresStore {
+  #observabilityPool;
+  #ownsObservabilityPool = false;
+  #observabilityPoolClosed = false;
+  constructor(config) {
+    super(config);
+    this.name = "PostgresStoreVNext";
+    const obsConfig = config.observability;
+    if (isSameConnectionTarget(config, obsConfig)) {
+      console.warn(COLLISION_WARNING);
+    }
+    const built = this.#createObservabilityClient(obsConfig);
+    const observabilityClient = built.client;
+    this.#observabilityPool = built.pool;
+    this.#ownsObservabilityPool = built.owned;
+    const observability = new ObservabilityStoragePostgresVNext({
+      client: observabilityClient,
+      schemaName: obsConfig.schemaName ?? config.schemaName,
+      partitioning: obsConfig.partitioning,
+      discovery: obsConfig.discovery
+    });
+    this.stores = {
+      ...this.stores,
+      observability
+    };
+  }
+  #createObservabilityClient(cfg) {
+    if ("pool" in cfg && cfg.pool) {
+      return { client: new PoolAdapter(cfg.pool), pool: cfg.pool, owned: false };
+    }
+    if ("connectionString" in cfg && typeof cfg.connectionString === "string") {
+      const pool2 = createConnectionStringPool(cfg);
+      return { client: new PoolAdapter(pool2), pool: pool2, owned: true };
+    }
+    if ("host" in cfg) {
+      const pool2 = createHostPool(cfg);
+      return { client: new PoolAdapter(pool2), pool: pool2, owned: true };
+    }
+    const pool = new pg.Pool(cfg);
+    return { client: new PoolAdapter(pool), pool, owned: true };
+  }
+  /**
+   * Closes both the primary pool (when owned) and the observability pool
+   * (when this store created it). Safe to call multiple times.
+   */
+  async close() {
+    await super.close();
+    if (this.#ownsObservabilityPool && this.#observabilityPool && !this.#observabilityPoolClosed) {
+      this.#observabilityPoolClosed = true;
+      await this.#observabilityPool.end();
+    }
+  }
+};
 
 // src/vector/prompt.ts
 var PGVECTOR_PROMPT = `When querying PG Vector, you can ONLY use the operators listed below. Any other operators will be rejected.
@@ -15619,15 +19306,18 @@ exports.MCPServersPG = MCPServersPG;
 exports.MemoryPG = MemoryPG;
 exports.NotificationsPG = NotificationsPG;
 exports.ObservabilityPG = ObservabilityPG;
+exports.ObservabilityStoragePostgresVNext = ObservabilityStoragePostgresVNext;
 exports.PGVECTOR_PROMPT = PGVECTOR_PROMPT;
 exports.PgVector = PgVector;
 exports.PoolAdapter = PoolAdapter;
 exports.PostgresStore = PostgresStore;
+exports.PostgresStoreVNext = PostgresStoreVNext;
 exports.PromptBlocksPG = PromptBlocksPG;
 exports.SchedulesPG = SchedulesPG;
 exports.ScorerDefinitionsPG = ScorerDefinitionsPG;
 exports.ScoresPG = ScoresPG;
 exports.SkillsPG = SkillsPG;
+exports.ToolProviderConnectionsPG = ToolProviderConnectionsPG;
 exports.WorkflowsPG = WorkflowsPG;
 exports.WorkspacesPG = WorkspacesPG;
 exports.exportSchemas = exportSchemas;