@mastra/cloudflare-d1 1.1.1 → 1.2.0-alpha.1

package/dist/index.cjs

@@ -1,1506 +1,1438 @@
-'use strict';
-
-var error = require('@mastra/core/error');
-var storage = require('@mastra/core/storage');
-var Cloudflare = require('cloudflare');
-var base = require('@mastra/core/base');
-var utils = require('@mastra/core/utils');
-var agent = require('@mastra/core/agent');
-var evals = require('@mastra/core/evals');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
-
-// src/storage/index.ts
-
-// src/storage/domains/utils.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _mastra_core_error = require("@mastra/core/error");
+let _mastra_core_storage = require("@mastra/core/storage");
+let cloudflare = require("cloudflare");
+cloudflare = __toESM(cloudflare, 1);
+let _mastra_core_base = require("@mastra/core/base");
+let _mastra_core_utils = require("@mastra/core/utils");
+let _mastra_core_agent = require("@mastra/core/agent");
+let _mastra_core_evals = require("@mastra/core/evals");
+//#region src/storage/domains/utils.ts
 function isArrayOfRecords(value) {
-  return value && Array.isArray(value) && value.length > 0;
+	return value && Array.isArray(value) && value.length > 0;
 }
 function deserializeValue(value, type) {
-  if (value === null || value === void 0) return null;
-  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return value;
-    }
-  }
-  return value;
+	if (value === null || value === void 0) return null;
+	if (type === "date" && typeof value === "string") return new Date(value);
+	if (type === "jsonb" && typeof value === "string") try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+	if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+	return value;
 }
+//#endregion
+//#region src/storage/sql-builder.ts
+/**
+* SQL Builder class for constructing type-safe SQL queries
+* This helps create maintainable and secure SQL queries with proper parameter handling
+*/
 var SqlBuilder = class {
-  sql = "";
-  params = [];
-  whereAdded = false;
-  // Basic query building
-  select(columns) {
-    if (!columns || Array.isArray(columns) && columns.length === 0) {
-      this.sql = "SELECT *";
-    } else {
-      const cols = Array.isArray(columns) ? columns : [columns];
-      const parsedCols = cols.map((col) => parseSelectIdentifier(col));
-      this.sql = `SELECT ${parsedCols.join(", ")}`;
-    }
-    return this;
-  }
-  from(table) {
-    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
-    this.sql += ` FROM ${parsedTableName}`;
-    return this;
-  }
-  /**
-   * Add a WHERE clause to the query
-   * @param condition The condition to add
-   * @param params Parameters to bind to the condition
-   */
-  where(condition, ...params) {
-    this.sql += ` WHERE ${condition}`;
-    this.params.push(...params);
-    this.whereAdded = true;
-    return this;
-  }
-  /**
-   * Add a WHERE clause if it hasn't been added yet, otherwise add an AND clause
-   * @param condition The condition to add
-   * @param params Parameters to bind to the condition
-   */
-  whereAnd(condition, ...params) {
-    if (this.whereAdded) {
-      return this.andWhere(condition, ...params);
-    } else {
-      return this.where(condition, ...params);
-    }
-  }
-  andWhere(condition, ...params) {
-    this.sql += ` AND ${condition}`;
-    this.params.push(...params);
-    return this;
-  }
-  orWhere(condition, ...params) {
-    this.sql += ` OR ${condition}`;
-    this.params.push(...params);
-    return this;
-  }
-  orderBy(column, direction = "ASC") {
-    const parsedColumn = utils.parseSqlIdentifier(column, "column name");
-    if (!["ASC", "DESC"].includes(direction)) {
-      throw new Error(`Invalid sort direction: ${direction}`);
-    }
-    this.sql += ` ORDER BY ${parsedColumn} ${direction}`;
-    return this;
-  }
-  limit(count) {
-    this.sql += ` LIMIT ?`;
-    this.params.push(count);
-    return this;
-  }
-  offset(count) {
-    this.sql += ` OFFSET ?`;
-    this.params.push(count);
-    return this;
-  }
-  count() {
-    this.sql += "SELECT COUNT(*) AS count";
-    return this;
-  }
-  /**
-   * Insert a row, or update specific columns on conflict (upsert).
-   * @param table Table name
-   * @param columns Columns to insert
-   * @param values Values to insert
-   * @param conflictColumns Columns to check for conflict (usually PK or UNIQUE)
-   * @param updateMap Object mapping columns to update to their new value (e.g. { name: 'excluded.name' })
-   */
-  insert(table, columns, values, conflictColumns, updateMap) {
-    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
-    const parsedColumns = columns.map((col) => utils.parseSqlIdentifier(col, "column name"));
-    const placeholders = parsedColumns.map(() => "?").join(", ");
-    if (conflictColumns && updateMap) {
-      const parsedConflictColumns = conflictColumns.map((col) => utils.parseSqlIdentifier(col, "column name"));
-      const updateClause = Object.entries(updateMap).map(([col, expr]) => `${col} = ${expr}`).join(", ");
-      this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${parsedConflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
-      this.params.push(...values);
-      return this;
-    }
-    this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders})`;
-    this.params.push(...values);
-    return this;
-  }
-  // Update operations
-  update(table, columns, values) {
-    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
-    const parsedColumns = columns.map((col) => utils.parseSqlIdentifier(col, "column name"));
-    const setClause = parsedColumns.map((col) => `${col} = ?`).join(", ");
-    this.sql = `UPDATE ${parsedTableName} SET ${setClause}`;
-    this.params.push(...values);
-    return this;
-  }
-  // Delete operations
-  delete(table) {
-    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
-    this.sql = `DELETE FROM ${parsedTableName}`;
-    return this;
-  }
-  /**
-   * Create a table if it doesn't exist
-   * @param table The table name
-   * @param columnDefinitions The column definitions as an array of strings
-   * @param tableConstraints Optional constraints for the table
-   * @returns The builder instance
-   */
-  createTable(table, columnDefinitions, tableConstraints) {
-    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
-    const parsedColumnDefinitions = columnDefinitions.map((def) => {
-      const colName = def.split(/\s+/)[0];
-      if (!colName) throw new Error("Empty column name in definition");
-      utils.parseSqlIdentifier(colName, "column name");
-      return def;
-    });
-    const columns = parsedColumnDefinitions.join(", ");
-    const constraints = tableConstraints && tableConstraints.length > 0 ? ", " + tableConstraints.join(", ") : "";
-    this.sql = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns}${constraints})`;
-    return this;
-  }
-  /**
-   * Check if an index exists in the database
-   * @param indexName The name of the index to check
-   * @param tableName The table the index is on
-   * @returns The builder instance
-   */
-  checkIndexExists(indexName, tableName) {
-    this.sql = `SELECT name FROM sqlite_master WHERE type='index' AND name=? AND tbl_name=?`;
-    this.params.push(indexName, tableName);
-    return this;
-  }
-  /**
-   * Create an index if it doesn't exist
-   * @param indexName The name of the index to create
-   * @param tableName The table to create the index on
-   * @param columnName The column to index
-   * @param indexType Optional index type (e.g., 'UNIQUE')
-   * @returns The builder instance
-   */
-  createIndex(indexName, tableName, columnName, indexType = "") {
-    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
-    const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
-    this.sql = `CREATE ${indexType ? indexType + " " : ""}INDEX IF NOT EXISTS ${parsedIndexName} ON ${parsedTableName}(${parsedColumnName})`;
-    return this;
-  }
-  /**
-   * Add a LIKE condition to the query
-   * @param column The column to check
-   * @param value The value to match (will be wrapped with % for LIKE)
-   * @param exact If true, will not add % wildcards
-   */
-  like(column, value, exact = false) {
-    const parsedColumnName = utils.parseSqlIdentifier(column, "column name");
-    const likeValue = exact ? value : `%${value}%`;
-    if (this.whereAdded) {
-      this.sql += ` AND ${parsedColumnName} LIKE ?`;
-    } else {
-      this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
-      this.whereAdded = true;
-    }
-    this.params.push(likeValue);
-    return this;
-  }
-  /**
-   * Add a JSON LIKE condition for searching in JSON fields
-   * @param column The JSON column to search in
-   * @param key The JSON key to match
-   * @param value The value to match
-   */
-  jsonLike(column, key, value) {
-    const parsedColumnName = utils.parseSqlIdentifier(column, "column name");
-    const parsedKey = utils.parseSqlIdentifier(key, "key name");
-    const jsonPattern = `%"${parsedKey}":"${value}"%`;
-    if (this.whereAdded) {
-      this.sql += ` AND ${parsedColumnName} LIKE ?`;
-    } else {
-      this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
-      this.whereAdded = true;
-    }
-    this.params.push(jsonPattern);
-    return this;
-  }
-  /**
-   * Get the built query
-   * @returns Object containing the SQL string and parameters array
-   */
-  build() {
-    return {
-      sql: this.sql,
-      params: this.params
-    };
-  }
-  /**
-   * Reset the builder for reuse
-   * @returns The reset builder instance
-   */
-  reset() {
-    this.sql = "";
-    this.params = [];
-    this.whereAdded = false;
-    return this;
-  }
+	sql = "";
+	params = [];
+	whereAdded = false;
+	select(columns) {
+		if (!columns || Array.isArray(columns) && columns.length === 0) this.sql = "SELECT *";
+		else {
+			const parsedCols = (Array.isArray(columns) ? columns : [columns]).map((col) => parseSelectIdentifier(col));
+			this.sql = `SELECT ${parsedCols.join(", ")}`;
+		}
+		return this;
+	}
+	from(table) {
+		const parsedTableName = (0, _mastra_core_utils.parseSqlIdentifier)(table, "table name");
+		this.sql += ` FROM ${parsedTableName}`;
+		return this;
+	}
+	/**
+	* Add a WHERE clause to the query
+	* @param condition The condition to add
+	* @param params Parameters to bind to the condition
+	*/
+	where(condition, ...params) {
+		this.sql += ` WHERE ${condition}`;
+		this.params.push(...params);
+		this.whereAdded = true;
+		return this;
+	}
+	/**
+	* Add a WHERE clause if it hasn't been added yet, otherwise add an AND clause
+	* @param condition The condition to add
+	* @param params Parameters to bind to the condition
+	*/
+	whereAnd(condition, ...params) {
+		if (this.whereAdded) return this.andWhere(condition, ...params);
+		else return this.where(condition, ...params);
+	}
+	andWhere(condition, ...params) {
+		this.sql += ` AND ${condition}`;
+		this.params.push(...params);
+		return this;
+	}
+	orWhere(condition, ...params) {
+		this.sql += ` OR ${condition}`;
+		this.params.push(...params);
+		return this;
+	}
+	orderBy(column, direction = "ASC") {
+		const parsedColumn = (0, _mastra_core_utils.parseSqlIdentifier)(column, "column name");
+		if (!["ASC", "DESC"].includes(direction)) throw new Error(`Invalid sort direction: ${direction}`);
+		this.sql += ` ORDER BY ${parsedColumn} ${direction}`;
+		return this;
+	}
+	limit(count) {
+		this.sql += ` LIMIT ?`;
+		this.params.push(count);
+		return this;
+	}
+	offset(count) {
+		this.sql += ` OFFSET ?`;
+		this.params.push(count);
+		return this;
+	}
+	count() {
+		this.sql += "SELECT COUNT(*) AS count";
+		return this;
+	}
+	/**
+	* Insert a row, or update specific columns on conflict (upsert).
+	* @param table Table name
+	* @param columns Columns to insert
+	* @param values Values to insert
+	* @param conflictColumns Columns to check for conflict (usually PK or UNIQUE)
+	* @param updateMap Object mapping columns to update to their new value (e.g. { name: 'excluded.name' })
+	*/
+	insert(table, columns, values, conflictColumns, updateMap) {
+		const parsedTableName = (0, _mastra_core_utils.parseSqlIdentifier)(table, "table name");
+		const parsedColumns = columns.map((col) => (0, _mastra_core_utils.parseSqlIdentifier)(col, "column name"));
+		const placeholders = parsedColumns.map(() => "?").join(", ");
+		if (conflictColumns && updateMap) {
+			const parsedConflictColumns = conflictColumns.map((col) => (0, _mastra_core_utils.parseSqlIdentifier)(col, "column name"));
+			const updateClause = Object.entries(updateMap).map(([col, expr]) => `${col} = ${expr}`).join(", ");
+			this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${parsedConflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
+			this.params.push(...values);
+			return this;
+		}
+		this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders})`;
+		this.params.push(...values);
+		return this;
+	}
+	update(table, columns, values) {
+		const parsedTableName = (0, _mastra_core_utils.parseSqlIdentifier)(table, "table name");
+		const setClause = columns.map((col) => (0, _mastra_core_utils.parseSqlIdentifier)(col, "column name")).map((col) => `${col} = ?`).join(", ");
+		this.sql = `UPDATE ${parsedTableName} SET ${setClause}`;
+		this.params.push(...values);
+		return this;
+	}
+	delete(table) {
+		const parsedTableName = (0, _mastra_core_utils.parseSqlIdentifier)(table, "table name");
+		this.sql = `DELETE FROM ${parsedTableName}`;
+		return this;
+	}
+	/**
+	* Create a table if it doesn't exist
+	* @param table The table name
+	* @param columnDefinitions The column definitions as an array of strings
+	* @param tableConstraints Optional constraints for the table
+	* @returns The builder instance
+	*/
+	createTable(table, columnDefinitions, tableConstraints) {
+		const parsedTableName = (0, _mastra_core_utils.parseSqlIdentifier)(table, "table name");
+		const columns = columnDefinitions.map((def) => {
+			const colName = def.split(/\s+/)[0];
+			if (!colName) throw new Error("Empty column name in definition");
+			(0, _mastra_core_utils.parseSqlIdentifier)(colName, "column name");
+			return def;
+		}).join(", ");
+		const constraints = tableConstraints && tableConstraints.length > 0 ? ", " + tableConstraints.join(", ") : "";
+		this.sql = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns}${constraints})`;
+		return this;
+	}
+	/**
+	* Check if an index exists in the database
+	* @param indexName The name of the index to check
+	* @param tableName The table the index is on
+	* @returns The builder instance
+	*/
+	checkIndexExists(indexName, tableName) {
+		this.sql = `SELECT name FROM sqlite_master WHERE type='index' AND name=? AND tbl_name=?`;
+		this.params.push(indexName, tableName);
+		return this;
+	}
+	/**
+	* Create an index if it doesn't exist
+	* @param indexName The name of the index to create
+	* @param tableName The table to create the index on
+	* @param columnName The column to index
+	* @param indexType Optional index type (e.g., 'UNIQUE')
+	* @returns The builder instance
+	*/
+	createIndex(indexName, tableName, columnName, indexType = "") {
+		const parsedIndexName = (0, _mastra_core_utils.parseSqlIdentifier)(indexName, "index name");
+		const parsedTableName = (0, _mastra_core_utils.parseSqlIdentifier)(tableName, "table name");
+		const parsedColumnName = (0, _mastra_core_utils.parseSqlIdentifier)(columnName, "column name");
+		this.sql = `CREATE ${indexType ? indexType + " " : ""}INDEX IF NOT EXISTS ${parsedIndexName} ON ${parsedTableName}(${parsedColumnName})`;
+		return this;
+	}
+	/**
+	* Add a LIKE condition to the query
+	* @param column The column to check
+	* @param value The value to match (will be wrapped with % for LIKE)
+	* @param exact If true, will not add % wildcards
+	*/
+	like(column, value, exact = false) {
+		const parsedColumnName = (0, _mastra_core_utils.parseSqlIdentifier)(column, "column name");
+		const likeValue = exact ? value : `%${value}%`;
+		if (this.whereAdded) this.sql += ` AND ${parsedColumnName} LIKE ?`;
+		else {
+			this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
+			this.whereAdded = true;
+		}
+		this.params.push(likeValue);
+		return this;
+	}
+	/**
+	* Add a JSON LIKE condition for searching in JSON fields
+	* @param column The JSON column to search in
+	* @param key The JSON key to match
+	* @param value The value to match
+	*/
+	jsonLike(column, key, value) {
+		const parsedColumnName = (0, _mastra_core_utils.parseSqlIdentifier)(column, "column name");
+		const jsonPattern = `%"${(0, _mastra_core_utils.parseSqlIdentifier)(key, "key name")}":"${value}"%`;
+		if (this.whereAdded) this.sql += ` AND ${parsedColumnName} LIKE ?`;
+		else {
+			this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
+			this.whereAdded = true;
+		}
+		this.params.push(jsonPattern);
+		return this;
+	}
+	/**
+	* Get the built query
+	* @returns Object containing the SQL string and parameters array
+	*/
+	build() {
+		return {
+			sql: this.sql,
+			params: this.params
+		};
+	}
+	/**
+	* Reset the builder for reuse
+	* @returns The reset builder instance
+	*/
+	reset() {
+		this.sql = "";
+		this.params = [];
+		this.whereAdded = false;
+		return this;
+	}
 };
 function createSqlBuilder() {
-  return new SqlBuilder();
+	return new SqlBuilder();
 }
-var SQL_IDENTIFIER_PATTERN = /^[a-zA-Z0-9_]+(\s+AS\s+[a-zA-Z0-9_]+)?$/;
+const SQL_IDENTIFIER_PATTERN = /^[a-zA-Z0-9_]+(\s+AS\s+[a-zA-Z0-9_]+)?$/;
+/**
+* Parses and returns a valid SQL SELECT column identifier.
+* Allows a single identifier (letters, numbers, underscores), or '*', optionally with 'AS alias'.
+*
+* @param column - The column identifier string to parse.
+* @returns The validated column identifier as a branded type.
+* @throws {Error} If invalid.
+*
+* @example
+* const col = parseSelectIdentifier('user_id'); // Ok
+* parseSelectIdentifier('user_id AS uid'); // Ok
+* parseSelectIdentifier('*'); // Ok
+* parseSelectIdentifier('user id'); // Throws error
+*/
 function parseSelectIdentifier(column) {
-  if (column !== "*" && !SQL_IDENTIFIER_PATTERN.test(column)) {
-    throw new Error(
-      `Invalid column name: "${column}". Must be "*" or a valid identifier (letters, numbers, underscores), optionally with "AS alias".`
-    );
-  }
-  return column;
+	if (column !== "*" && !SQL_IDENTIFIER_PATTERN.test(column)) throw new Error(`Invalid column name: "${column}". Must be "*" or a valid identifier (letters, numbers, underscores), optionally with "AS alias".`);
+	return column;
 }
-
-// src/storage/db/index.ts
+//#endregion
+//#region src/storage/db/index.ts
+/**
+* Resolves D1DomainConfig to D1DBConfig.
+* Handles creating a new D1 client if apiToken is provided.
+*/
 function resolveD1Config(config) {
-  if ("client" in config) {
-    return {
-      client: config.client,
-      tablePrefix: config.tablePrefix
-    };
-  }
-  if ("binding" in config) {
-    return {
-      binding: config.binding,
-      tablePrefix: config.tablePrefix
-    };
-  }
-  const cfClient = new Cloudflare__default.default({ apiToken: config.apiToken });
-  return {
-    client: {
-      query: ({ sql, params }) => {
-        return cfClient.d1.database.query(config.databaseId, {
-          account_id: config.accountId,
-          sql,
-          params
-        });
-      }
-    },
-    tablePrefix: config.tablePrefix
-  };
+	if ("client" in config) return {
+		client: config.client,
+		tablePrefix: config.tablePrefix
+	};
+	if ("binding" in config) return {
+		binding: config.binding,
+		tablePrefix: config.tablePrefix
+	};
+	const cfClient = new cloudflare.default({ apiToken: config.apiToken });
+	return {
+		client: { query: ({ sql, params }) => {
+			return cfClient.d1.database.query(config.databaseId, {
+				account_id: config.accountId,
+				sql,
+				params
+			});
+		} },
+		tablePrefix: config.tablePrefix
+	};
 }
-var D1DB = class extends base.MastraBase {
-  client;
-  binding;
-  tablePrefix;
-  /** Cache of actual table columns: tableName -> Promise<Set<columnName>> (stores in-flight promise to coalesce concurrent calls) */
-  tableColumnsCache = /* @__PURE__ */ new Map();
-  constructor(config) {
-    super({
-      component: "STORAGE",
-      name: "D1_DB"
-    });
-    this.client = config.client;
-    this.binding = config.binding;
-    this.tablePrefix = config.tablePrefix || "";
-  }
-  async hasColumn(table, column) {
-    const fullTableName = table.startsWith(this.tablePrefix) ? table : `${this.tablePrefix}${table}`;
-    const sql = `PRAGMA table_info(${fullTableName});`;
-    const result = await this.executeQuery({ sql, params: [] });
-    if (!result || !Array.isArray(result)) return false;
-    return result.some((col) => col.name === column || col.name === column.toLowerCase());
-  }
-  getTableName(tableName) {
-    return `${this.tablePrefix}${tableName}`;
-  }
-  formatSqlParams(params) {
-    return params.map((p) => p === void 0 || p === null ? null : p);
-  }
-  async executeWorkersBindingQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.binding) {
-      throw new Error("Workers binding is not configured");
-    }
-    try {
-      const statement = this.binding.prepare(sql);
-      const formattedParams = this.formatSqlParams(params);
-      let result;
-      if (formattedParams.length > 0) {
-        if (first) {
-          result = await statement.bind(...formattedParams).first();
-          if (!result) return null;
-          return result;
-        } else {
-          result = await statement.bind(...formattedParams).all();
-          const results = result.results || [];
-          return results;
-        }
-      } else {
-        if (first) {
-          result = await statement.first();
-          if (!result) return null;
-          return result;
-        } else {
-          result = await statement.all();
-          const results = result.results || [];
-          return results;
-        }
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "WORKERS_BINDING_QUERY", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { sql }
-        },
-        error$1
-      );
-    }
-  }
-  async executeRestQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.client) {
-      throw new Error("D1 client is not configured");
-    }
-    try {
-      const formattedParams = this.formatSqlParams(params);
-      const response = await this.client.query({
-        sql,
-        params: formattedParams
-      });
-      const result = response.result || [];
-      const results = result.flatMap((r) => r.results || []);
-      if (first) {
-        return results[0] || null;
-      }
-      return results;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "REST_QUERY", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { sql }
-        },
-        error$1
-      );
-    }
-  }
-  async executeQuery(options) {
-    if (this.binding) {
-      return this.executeWorkersBindingQuery(options);
-    } else if (this.client) {
-      return this.executeRestQuery(options);
-    } else {
-      throw new Error("Neither binding nor client is configured");
-    }
-  }
-  /**
-   * Gets the set of column names that actually exist in the database table.
-   * Results are cached; the cache is invalidated when alterTable() adds new columns.
-   */
-  async getKnownColumnNames(tableName) {
-    const cached = this.tableColumnsCache.get(tableName);
-    if (cached) return cached;
-    const promise = this.getTableColumns(tableName).then((columns) => {
-      const names = new Set(columns.map((c) => c.name));
-      if (names.size === 0) {
-        this.tableColumnsCache.delete(tableName);
-      }
-      return names;
-    });
-    this.tableColumnsCache.set(tableName, promise);
-    return promise;
-  }
-  /**
-   * Filters a record to only include columns that exist in the actual database table.
-   * Unknown columns are silently dropped to ensure forward compatibility.
-   */
-  async filterRecordToKnownColumns(tableName, record) {
-    const knownColumns = await this.getKnownColumnNames(tableName);
-    if (knownColumns.size === 0) return record;
-    const filtered = {};
-    for (const [key, value] of Object.entries(record)) {
-      if (knownColumns.has(key)) {
-        filtered[key] = value;
-      }
-    }
-    return filtered;
-  }
-  async getTableColumns(tableName) {
-    try {
-      const sql = `PRAGMA table_info(${tableName})`;
-      const result = await this.executeQuery({ sql });
-      if (!result || !Array.isArray(result)) {
-        return [];
-      }
-      return result.map((row) => ({
-        name: row.name,
-        type: row.type
-      }));
-    } catch (error) {
-      this.logger.warn(`Failed to get table columns for ${tableName}:`, error);
-      return [];
-    }
-  }
-  serializeValue(value) {
-    if (value === null || value === void 0) {
-      return null;
-    }
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (typeof value === "object") {
-      return JSON.stringify(value);
-    }
-    return value;
-  }
-  getSqlType(type) {
-    switch (type) {
-      case "bigint":
-        return "INTEGER";
-      // SQLite uses INTEGER for all integer sizes
-      case "jsonb":
-        return "TEXT";
-      // Store JSON as TEXT in SQLite
-      case "boolean":
-        return "INTEGER";
-      // SQLite uses 0/1 for booleans
-      default:
-        return storage.getSqlType(type);
-    }
-  }
-  getDefaultValue(type) {
-    return storage.getDefaultValue(type);
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
-        const type = this.getSqlType(colDef.type);
-        const nullable = colDef.nullable === false ? "NOT NULL" : "";
-        const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
-        return `${colName} ${type} ${nullable} ${primaryKey}`.trim();
-      });
-      const tableConstraints = [];
-      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-        tableConstraints.push("UNIQUE (workflow_name, run_id)");
-      }
-      const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Created table ${fullTableName}`);
-      this.tableColumnsCache.delete(fullTableName);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "CREATE_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async clearTable({ tableName }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const query = createSqlBuilder().delete(fullTableName);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Cleared table ${fullTableName}`);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "CLEAR_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async dropTable({ tableName }) {
-    const fullTableName = this.getTableName(tableName);
-    try {
-      const sql = `DROP TABLE IF EXISTS ${fullTableName}`;
-      await this.executeQuery({ sql });
-      this.logger.debug(`Dropped table ${fullTableName}`);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "DROP_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    } finally {
-      this.tableColumnsCache.delete(fullTableName);
-    }
-  }
-  async alterTable(args) {
-    const fullTableName = this.getTableName(args.tableName);
-    try {
-      const existingColumns = await this.getTableColumns(fullTableName);
-      const existingColumnNames = new Set(existingColumns.map((col) => col.name));
-      for (const [columnName, column] of Object.entries(args.schema)) {
-        if (!existingColumnNames.has(columnName) && args.ifNotExists.includes(columnName)) {
-          const sqlType = this.getSqlType(column.type);
-          const defaultValue = this.getDefaultValue(column.type);
-          const sql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${defaultValue}`;
-          await this.executeQuery({ sql });
-          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
-        }
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "ALTER_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName: args.tableName }
-        },
-        error$1
-      );
-    } finally {
-      this.tableColumnsCache.delete(fullTableName);
-    }
-  }
-  async insert({ tableName, record }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const processedRecord = await this.processRecord(record);
-      const filteredRecord = await this.filterRecordToKnownColumns(fullTableName, processedRecord);
-      const columns = Object.keys(filteredRecord);
-      if (columns.length === 0) return;
-      const values = Object.values(filteredRecord);
-      const query = createSqlBuilder().insert(fullTableName, columns, values);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "INSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async batchInsert({ tableName, records }) {
-    try {
-      if (records.length === 0) return;
-      const fullTableName = this.getTableName(tableName);
-      const processedRecords = await Promise.all(records.map((record) => this.processRecord(record)));
-      const filteredRecords = await Promise.all(
-        processedRecords.map((r) => this.filterRecordToKnownColumns(fullTableName, r))
-      );
-      for (const record of filteredRecords) {
-        const columns = Object.keys(record);
-        if (columns.length === 0) continue;
-        const values = Object.values(record);
-        const query = createSqlBuilder().insert(fullTableName, columns, values);
-        const { sql, params } = query.build();
-        await this.executeQuery({ sql, params });
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "BATCH_INSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async load({ tableName, keys }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const query = createSqlBuilder().select("*").from(fullTableName);
-      let firstKey = true;
-      for (const [key, value] of Object.entries(keys)) {
-        if (firstKey) {
-          query.where(`${key} = ?`, value);
-          firstKey = false;
-        } else {
-          query.andWhere(`${key} = ?`, value);
-        }
-      }
-      query.orderBy("createdAt", "DESC");
-      query.limit(1);
-      const { sql, params } = query.build();
-      const result = await this.executeQuery({ sql, params, first: true });
-      if (!result) {
-        return null;
-      }
-      const deserializedResult = {};
-      for (const [key, value] of Object.entries(result)) {
-        deserializedResult[key] = deserializeValue(value);
-      }
-      return deserializedResult;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LOAD", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async processRecord(record) {
-    const processed = {};
-    for (const [key, value] of Object.entries(record)) {
-      processed[key] = this.serializeValue(value);
-    }
-    return processed;
-  }
-  /**
-   * Upsert multiple records in a batch operation
-   * @param tableName The table to insert into
-   * @param records The records to insert
-   */
-  async batchUpsert({ tableName, records }) {
-    if (records.length === 0) return;
-    const fullTableName = this.getTableName(tableName);
-    try {
-      const batchSize = 50;
-      for (let i = 0; i < records.length; i += batchSize) {
-        const batch = records.slice(i, i + batchSize);
-        const recordsToInsert = batch;
-        if (recordsToInsert.length > 0) {
-          const filteredRecords = await Promise.all(
-            recordsToInsert.map((r) => this.filterRecordToKnownColumns(fullTableName, r || {}))
-          );
-          for (const record of filteredRecords) {
-            const columns = Object.keys(record);
-            if (columns.length === 0) continue;
-            const values = columns.map((col) => {
-              const value = record[col];
-              return this.serializeValue(value);
-            });
-            const recordToUpsert = columns.reduce(
-              (acc, col) => {
-                if (col !== "createdAt") acc[col] = `excluded.${col}`;
-                return acc;
-              },
-              {}
-            );
-            const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], recordToUpsert);
-            const { sql, params } = query.build();
-            await this.executeQuery({ sql, params });
-          }
-        }
-        this.logger.debug(
-          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
-        );
-      }
-      this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "BATCH_UPSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to batch upsert into ${tableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
+var D1DB = class extends _mastra_core_base.MastraBase {
+	client;
+	binding;
+	tablePrefix;
+	/** Cache of actual table columns: tableName -> Promise<Set<columnName>> (stores in-flight promise to coalesce concurrent calls) */
+	tableColumnsCache = /* @__PURE__ */ new Map();
+	constructor(config) {
+		super({
+			component: "STORAGE",
+			name: "D1_DB"
+		});
+		this.client = config.client;
+		this.binding = config.binding;
+		this.tablePrefix = config.tablePrefix || "";
+	}
+	async hasColumn(table, column) {
+		const sql = `PRAGMA table_info(${table.startsWith(this.tablePrefix) ? table : `${this.tablePrefix}${table}`});`;
+		const result = await this.executeQuery({
+			sql,
+			params: []
+		});
+		if (!result || !Array.isArray(result)) return false;
+		return result.some((col) => col.name === column || col.name === column.toLowerCase());
+	}
+	getTableName(tableName) {
+		return `${this.tablePrefix}${tableName}`;
+	}
+	formatSqlParams(params) {
+		return params.map((p) => p === void 0 || p === null ? null : p);
+	}
+	async executeWorkersBindingQuery({ sql, params = [], first = false }) {
+		if (!this.binding) throw new Error("Workers binding is not configured");
+		try {
+			const statement = this.binding.prepare(sql);
+			const formattedParams = this.formatSqlParams(params);
+			let result;
+			if (formattedParams.length > 0) if (first) {
+				result = await statement.bind(...formattedParams).first();
+				if (!result) return null;
+				return result;
+			} else {
+				result = await statement.bind(...formattedParams).all();
+				return result.results || [];
+			}
+			else if (first) {
+				result = await statement.first();
+				if (!result) return null;
+				return result;
+			} else {
+				result = await statement.all();
+				return result.results || [];
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "WORKERS_BINDING_QUERY", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { sql }
+			}, error);
+		}
+	}
+	async executeRestQuery({ sql, params = [], first = false }) {
+		if (!this.client) throw new Error("D1 client is not configured");
+		try {
+			const formattedParams = this.formatSqlParams(params);
+			const results = ((await this.client.query({
+				sql,
+				params: formattedParams
+			})).result || []).flatMap((r) => r.results || []);
+			if (first) return results[0] || null;
+			return results;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "REST_QUERY", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { sql }
+			}, error);
+		}
+	}
+	async executeQuery(options) {
+		if (this.binding) return this.executeWorkersBindingQuery(options);
+		else if (this.client) return this.executeRestQuery(options);
+		else throw new Error("Neither binding nor client is configured");
+	}
+	/**
+	* Gets the set of column names that actually exist in the database table.
+	* Results are cached; the cache is invalidated when alterTable() adds new columns.
+	*/
+	async getKnownColumnNames(tableName) {
+		const cached = this.tableColumnsCache.get(tableName);
+		if (cached) return cached;
+		const promise = this.getTableColumns(tableName).then((columns) => {
+			const names = new Set(columns.map((c) => c.name));
+			if (names.size === 0) this.tableColumnsCache.delete(tableName);
+			return names;
+		});
+		this.tableColumnsCache.set(tableName, promise);
+		return promise;
+	}
+	/**
+	* Filters a record to only include columns that exist in the actual database table.
+	* Unknown columns are silently dropped to ensure forward compatibility.
+	*/
+	async filterRecordToKnownColumns(tableName, record) {
+		const knownColumns = await this.getKnownColumnNames(tableName);
+		if (knownColumns.size === 0) return record;
+		const filtered = {};
+		for (const [key, value] of Object.entries(record)) if (knownColumns.has(key)) filtered[key] = value;
+		return filtered;
+	}
+	async getTableColumns(tableName) {
+		try {
+			const sql = `PRAGMA table_info(${tableName})`;
+			const result = await this.executeQuery({ sql });
+			if (!result || !Array.isArray(result)) return [];
+			return result.map((row) => ({
+				name: row.name,
+				type: row.type
+			}));
+		} catch (error) {
+			this.logger.warn(`Failed to get table columns for ${tableName}:`, error);
+			return [];
+		}
+	}
+	serializeValue(value) {
+		if (value === null || value === void 0) return null;
+		if (value instanceof Date) return value.toISOString();
+		if (typeof value === "object") return JSON.stringify(value);
+		return value;
+	}
+	getSqlType(type) {
+		switch (type) {
+			case "bigint": return "INTEGER";
+			case "jsonb": return "TEXT";
+			case "boolean": return "INTEGER";
+			default: return (0, _mastra_core_storage.getSqlType)(type);
+		}
+	}
+	getDefaultValue(type) {
+		return (0, _mastra_core_storage.getDefaultValue)(type);
+	}
+	async createTable({ tableName, schema }) {
+		try {
+			const fullTableName = this.getTableName(tableName);
+			const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
+				return `${colName} ${this.getSqlType(colDef.type)} ${colDef.nullable === false ? "NOT NULL" : ""} ${colDef.primaryKey ? "PRIMARY KEY" : ""}`.trim();
+			});
+			const tableConstraints = [];
+			if (tableName === _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT) tableConstraints.push("UNIQUE (workflow_name, run_id)");
+			const { sql, params } = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints).build();
+			await this.executeQuery({
+				sql,
+				params
+			});
+			this.logger.debug(`Created table ${fullTableName}`);
+			this.tableColumnsCache.delete(fullTableName);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "CREATE_TABLE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async clearTable({ tableName }) {
+		try {
+			const fullTableName = this.getTableName(tableName);
+			const { sql, params } = createSqlBuilder().delete(fullTableName).build();
+			await this.executeQuery({
+				sql,
+				params
+			});
+			this.logger.debug(`Cleared table ${fullTableName}`);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "CLEAR_TABLE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async dropTable({ tableName }) {
+		const fullTableName = this.getTableName(tableName);
+		try {
+			const sql = `DROP TABLE IF EXISTS ${fullTableName}`;
+			await this.executeQuery({ sql });
+			this.logger.debug(`Dropped table ${fullTableName}`);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "DROP_TABLE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		} finally {
+			this.tableColumnsCache.delete(fullTableName);
+		}
+	}
+	async alterTable(args) {
+		const fullTableName = this.getTableName(args.tableName);
+		try {
+			const existingColumns = await this.getTableColumns(fullTableName);
+			const existingColumnNames = new Set(existingColumns.map((col) => col.name));
+			for (const [columnName, column] of Object.entries(args.schema)) if (!existingColumnNames.has(columnName) && args.ifNotExists.includes(columnName)) {
+				const sql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${this.getSqlType(column.type)} ${this.getDefaultValue(column.type)}`;
+				await this.executeQuery({ sql });
+				this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "ALTER_TABLE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName: args.tableName }
+			}, error);
+		} finally {
+			this.tableColumnsCache.delete(fullTableName);
+		}
+	}
+	async insert({ tableName, record }) {
+		try {
+			const fullTableName = this.getTableName(tableName);
+			const processedRecord = await this.processRecord(record);
+			const filteredRecord = await this.filterRecordToKnownColumns(fullTableName, processedRecord);
+			const columns = Object.keys(filteredRecord);
+			if (columns.length === 0) return;
+			const values = Object.values(filteredRecord);
+			const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values).build();
+			await this.executeQuery({
+				sql,
+				params
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "INSERT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async batchInsert({ tableName, records }) {
+		try {
+			if (records.length === 0) return;
+			const fullTableName = this.getTableName(tableName);
+			const processedRecords = await Promise.all(records.map((record) => this.processRecord(record)));
+			const filteredRecords = await Promise.all(processedRecords.map((r) => this.filterRecordToKnownColumns(fullTableName, r)));
+			for (const record of filteredRecords) {
+				const columns = Object.keys(record);
+				if (columns.length === 0) continue;
+				const values = Object.values(record);
+				const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values).build();
+				await this.executeQuery({
+					sql,
+					params
+				});
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "BATCH_INSERT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async load({ tableName, keys }) {
+		try {
+			const fullTableName = this.getTableName(tableName);
+			const query = createSqlBuilder().select("*").from(fullTableName);
+			let firstKey = true;
+			for (const [key, value] of Object.entries(keys)) if (firstKey) {
+				query.where(`${key} = ?`, value);
+				firstKey = false;
+			} else query.andWhere(`${key} = ?`, value);
+			query.orderBy("createdAt", "DESC");
+			query.limit(1);
+			const { sql, params } = query.build();
+			const result = await this.executeQuery({
+				sql,
+				params,
+				first: true
+			});
+			if (!result) return null;
+			const deserializedResult = {};
+			for (const [key, value] of Object.entries(result)) deserializedResult[key] = deserializeValue(value);
+			return deserializedResult;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LOAD", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async processRecord(record) {
+		const processed = {};
+		for (const [key, value] of Object.entries(record)) processed[key] = this.serializeValue(value);
+		return processed;
+	}
+	/**
+	* Upsert multiple records in a batch operation
+	* @param tableName The table to insert into
+	* @param records The records to insert
+	*/
+	async batchUpsert({ tableName, records }) {
+		if (records.length === 0) return;
+		const fullTableName = this.getTableName(tableName);
+		try {
+			const batchSize = 50;
+			for (let i = 0; i < records.length; i += batchSize) {
+				const recordsToInsert = records.slice(i, i + batchSize);
+				if (recordsToInsert.length > 0) {
+					const filteredRecords = await Promise.all(recordsToInsert.map((r) => this.filterRecordToKnownColumns(fullTableName, r || {})));
+					for (const record of filteredRecords) {
+						const columns = Object.keys(record);
+						if (columns.length === 0) continue;
+						const values = columns.map((col) => {
+							const value = record[col];
+							return this.serializeValue(value);
+						});
+						const recordToUpsert = columns.reduce((acc, col) => {
+							if (col !== "createdAt") acc[col] = `excluded.${col}`;
+							return acc;
+						}, {});
+						const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["id"], recordToUpsert).build();
+						await this.executeQuery({
+							sql,
+							params
+						});
+					}
+				}
+				this.logger.debug(`Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`);
+			}
+			this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "BATCH_UPSERT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to batch upsert into ${tableName}: ${error instanceof Error ? error.message : String(error)}`,
+				details: { tableName }
+			}, error);
+		}
+	}
 };
-
-// src/storage/domains/background-tasks/index.ts
+//#endregion
+//#region src/storage/domains/background-tasks/index.ts
 function serializeJson(v) {
-  if (typeof v === "object" && v != null) return JSON.stringify(v);
-  return v ?? null;
+	if (typeof v === "object" && v != null) return JSON.stringify(v);
+	return v ?? null;
 }
 function rowToTask(row) {
-  const parseJson = (val) => {
-    if (val == null || val === "") return void 0;
-    if (typeof val === "string") {
-      try {
-        return JSON.parse(val);
-      } catch {
-        return val;
-      }
-    }
-    return val;
-  };
-  return {
-    id: row.id,
-    status: row.status,
-    toolName: row.tool_name,
-    toolCallId: row.tool_call_id,
-    args: parseJson(row.args) ?? {},
-    agentId: row.agent_id,
-    threadId: row.thread_id || void 0,
-    resourceId: row.resource_id || void 0,
-    runId: row.run_id ?? "",
-    result: parseJson(row.result),
-    error: parseJson(row.error),
-    suspendPayload: parseJson(row.suspend_payload),
-    retryCount: Number(row.retry_count ?? 0),
-    maxRetries: Number(row.max_retries ?? 0),
-    timeoutMs: Number(row.timeout_ms ?? 3e5),
-    createdAt: new Date(row.createdAt),
-    startedAt: row.startedAt ? new Date(row.startedAt) : void 0,
-    suspendedAt: row.suspendedAt ? new Date(row.suspendedAt) : void 0,
-    completedAt: row.completedAt ? new Date(row.completedAt) : void 0
-  };
+	const parseJson = (val) => {
+		if (val == null || val === "") return void 0;
+		if (typeof val === "string") try {
+			return JSON.parse(val);
+		} catch {
+			return val;
+		}
+		return val;
+	};
+	return {
+		id: row.id,
+		status: row.status,
+		toolName: row.tool_name,
+		toolCallId: row.tool_call_id,
+		args: parseJson(row.args) ?? {},
+		agentId: row.agent_id,
+		threadId: row.thread_id || void 0,
+		resourceId: row.resource_id || void 0,
+		runId: row.run_id ?? "",
+		result: parseJson(row.result),
+		error: parseJson(row.error),
+		suspendPayload: parseJson(row.suspend_payload),
+		retryCount: Number(row.retry_count ?? 0),
+		maxRetries: Number(row.max_retries ?? 0),
+		timeoutMs: Number(row.timeout_ms ?? 3e5),
+		createdAt: new Date(row.createdAt),
+		startedAt: row.startedAt ? new Date(row.startedAt) : void 0,
+		suspendedAt: row.suspendedAt ? new Date(row.suspendedAt) : void 0,
+		completedAt: row.completedAt ? new Date(row.completedAt) : void 0
+	};
 }
-var BackgroundTasksStorageD1 = class extends storage.BackgroundTasksStorage {
-  #db;
-  constructor(config) {
-    super();
-    const resolved = resolveD1Config(config);
-    this.#db = new D1DB(resolved);
-  }
-  async init() {
-    await this.#db.createTable({ tableName: storage.TABLE_BACKGROUND_TASKS, schema: storage.TABLE_SCHEMAS[storage.TABLE_BACKGROUND_TASKS] });
-    await this.#db.alterTable({
-      tableName: storage.TABLE_BACKGROUND_TASKS,
-      schema: storage.TABLE_SCHEMAS[storage.TABLE_BACKGROUND_TASKS],
-      ifNotExists: ["suspend_payload", "suspendedAt"]
-    });
-  }
-  async dangerouslyClearAll() {
-    await this.#db.clearTable({ tableName: storage.TABLE_BACKGROUND_TASKS });
-  }
-  async createTask(task) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_BACKGROUND_TASKS);
-    const { sql, params } = createSqlBuilder().insert(
-      fullTableName,
-      [
-        "id",
-        "tool_call_id",
-        "tool_name",
-        "agent_id",
-        "thread_id",
-        "resource_id",
-        "run_id",
-        "status",
-        "args",
-        "result",
-        "error",
-        "suspend_payload",
-        "retry_count",
-        "max_retries",
-        "timeout_ms",
-        "createdAt",
-        "startedAt",
-        "suspendedAt",
-        "completedAt"
-      ],
-      [
-        task.id,
-        task.toolCallId,
-        task.toolName,
-        task.agentId,
-        task.threadId ?? null,
-        task.resourceId ?? null,
-        task.runId,
-        task.status,
-        serializeJson(task.args),
-        serializeJson(task.result),
-        serializeJson(task.error),
-        serializeJson(task.suspendPayload),
-        task.retryCount,
-        task.maxRetries,
-        task.timeoutMs,
-        task.createdAt.toISOString(),
-        task.startedAt?.toISOString() ?? null,
-        task.suspendedAt?.toISOString() ?? null,
-        task.completedAt?.toISOString() ?? null
-      ]
-    ).build();
-    await this.#db.executeQuery({ sql, params });
-  }
-  async updateTask(taskId, update) {
-    const sets = [];
-    const params = [];
-    if ("status" in update) {
-      sets.push("status = ?");
-      params.push(update.status);
-    }
-    if ("result" in update) {
-      sets.push("result = ?");
-      params.push(serializeJson(update.result));
-    }
-    if ("error" in update) {
-      sets.push("error = ?");
-      params.push(serializeJson(update.error));
-    }
-    if ("suspendPayload" in update) {
-      sets.push("suspend_payload = ?");
-      params.push(serializeJson(update.suspendPayload));
-    }
-    if ("retryCount" in update) {
-      sets.push("retry_count = ?");
-      params.push(update.retryCount);
-    }
-    if ("startedAt" in update) {
-      sets.push("startedAt = ?");
-      params.push(update.startedAt?.toISOString() ?? null);
-    }
-    if ("suspendedAt" in update) {
-      sets.push("suspendedAt = ?");
-      params.push(update.suspendedAt?.toISOString() ?? null);
-    }
-    if ("completedAt" in update) {
-      sets.push("completedAt = ?");
-      params.push(update.completedAt?.toISOString() ?? null);
-    }
-    if (sets.length === 0) return;
-    params.push(taskId);
-    const fullTableName = this.#db.getTableName(storage.TABLE_BACKGROUND_TASKS);
-    await this.#db.executeQuery({
-      sql: `UPDATE ${fullTableName} SET ${sets.join(", ")} WHERE id = ?`,
-      params
-    });
-  }
-  async getTask(taskId) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_BACKGROUND_TASKS);
-    const { sql, params } = createSqlBuilder().select("*").from(fullTableName).where("id = ?", taskId).build();
-    const row = await this.#db.executeQuery({ sql, params, first: true });
-    return row ? rowToTask(row) : null;
-  }
-  async listTasks(filter) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_BACKGROUND_TASKS);
-    let builder = createSqlBuilder().select("*").from(fullTableName);
-    let countBuilder = createSqlBuilder().count().from(fullTableName);
-    if (filter.status) {
-      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-      builder = builder.where(`status IN (${statuses.map(() => "?").join(",")})`, ...statuses);
-      countBuilder = countBuilder.where(`status IN (${statuses.map(() => "?").join(",")})`, ...statuses);
-    }
-    if (filter.agentId) {
-      builder = builder.whereAnd("agent_id = ?", filter.agentId);
-      countBuilder = countBuilder.whereAnd("agent_id = ?", filter.agentId);
-    }
-    if (filter.threadId) {
-      builder = builder.whereAnd("thread_id = ?", filter.threadId);
-      countBuilder = countBuilder.whereAnd("thread_id = ?", filter.threadId);
-    }
-    if (filter.runId) {
-      builder = builder.whereAnd("run_id = ?", filter.runId);
-      countBuilder = countBuilder.whereAnd("run_id = ?", filter.runId);
-    }
-    if (filter.toolName) {
-      builder = builder.whereAnd("tool_name = ?", filter.toolName);
-      countBuilder = countBuilder.whereAnd("tool_name = ?", filter.toolName);
-    }
-    if (filter.toolCallId) {
-      builder = builder.whereAnd("tool_call_id = ?", filter.toolCallId);
-      countBuilder = countBuilder.whereAnd("tool_call_id = ?", filter.toolCallId);
-    }
-    const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "suspendedAt" ? "suspendedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : "createdAt";
-    if (filter.fromDate) {
-      builder = builder.whereAnd(`${dateCol} >= ?`, filter.fromDate.toISOString());
-      countBuilder = countBuilder.whereAnd(`${dateCol} >= ?`, filter.fromDate.toISOString());
-    }
-    if (filter.toDate) {
-      builder = builder.whereAnd(`${dateCol} < ?`, filter.toDate.toISOString());
-      countBuilder = countBuilder.whereAnd(`${dateCol} < ?`, filter.toDate.toISOString());
-    }
-    const { sql: countSql, params: countParams } = countBuilder.build();
-    const countRow = await this.#db.executeQuery({ sql: countSql, params: countParams, first: true });
-    const total = Number(countRow?.count ?? 0);
-    const orderCol = filter.orderBy === "startedAt" ? "startedAt" : filter.orderBy === "suspendedAt" ? "suspendedAt" : filter.orderBy === "completedAt" ? "completedAt" : "createdAt";
-    builder = builder.orderBy(orderCol, filter.orderDirection === "desc" ? "DESC" : "ASC");
-    if (filter.perPage != null) {
-      builder = builder.limit(filter.perPage);
-      if (filter.page != null) {
-        builder = builder.offset(filter.page * filter.perPage);
-      }
-    }
-    const { sql, params } = builder.build();
-    const rows = await this.#db.executeQuery({ sql, params });
-    return { tasks: rows.map(rowToTask), total };
-  }
-  async deleteTask(taskId) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_BACKGROUND_TASKS);
-    await this.#db.executeQuery({ sql: `DELETE FROM ${fullTableName} WHERE id = ?`, params: [taskId] });
-  }
-  async deleteTasks(filter) {
-    const conditions = [];
-    const params = [];
-    if (filter.status) {
-      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-      conditions.push(`status IN (${statuses.map(() => "?").join(",")})`);
-      params.push(...statuses);
-    }
-    const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "suspendedAt" ? "suspendedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : "createdAt";
-    if (filter.fromDate) {
-      conditions.push(`${dateCol} >= ?`);
-      params.push(filter.fromDate.toISOString());
-    }
-    if (filter.toDate) {
-      conditions.push(`${dateCol} < ?`);
-      params.push(filter.toDate.toISOString());
-    }
-    if (filter.agentId) {
-      conditions.push("agent_id = ?");
-      params.push(filter.agentId);
-    }
-    if (filter.runId) {
-      conditions.push("run_id = ?");
-      params.push(filter.runId);
-    }
-    if (filter.toolCallId) {
-      conditions.push("tool_call_id = ?");
-      params.push(filter.toolCallId);
-    }
-    if (conditions.length === 0) return;
-    const fullTableName = this.#db.getTableName(storage.TABLE_BACKGROUND_TASKS);
-    await this.#db.executeQuery({
-      sql: `DELETE FROM ${fullTableName} WHERE ${conditions.join(" AND ")}`,
-      params
-    });
-  }
-  async getRunningCount() {
-    const fullTableName = this.#db.getTableName(storage.TABLE_BACKGROUND_TASKS);
-    const row = await this.#db.executeQuery({
-      sql: `SELECT COUNT(*) as count FROM ${fullTableName} WHERE status = 'running'`,
-      params: [],
-      first: true
-    });
-    return Number(row?.count ?? 0);
-  }
-  async getRunningCountByAgent(agentId) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_BACKGROUND_TASKS);
-    const row = await this.#db.executeQuery({
-      sql: `SELECT COUNT(*) as count FROM ${fullTableName} WHERE status = 'running' AND agent_id = ?`,
-      params: [agentId],
-      first: true
-    });
-    return Number(row?.count ?? 0);
-  }
+var BackgroundTasksStorageD1 = class extends _mastra_core_storage.BackgroundTasksStorage {
+	#db;
+	constructor(config) {
+		super();
+		const resolved = resolveD1Config(config);
+		this.#db = new D1DB(resolved);
+	}
+	async init() {
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_BACKGROUND_TASKS,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_BACKGROUND_TASKS]
+		});
+		await this.#db.alterTable({
+			tableName: _mastra_core_storage.TABLE_BACKGROUND_TASKS,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_BACKGROUND_TASKS],
+			ifNotExists: ["suspend_payload", "suspendedAt"]
+		});
+	}
+	async dangerouslyClearAll() {
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_BACKGROUND_TASKS });
+	}
+	async createTask(task) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		const { sql, params } = createSqlBuilder().insert(fullTableName, [
+			"id",
+			"tool_call_id",
+			"tool_name",
+			"agent_id",
+			"thread_id",
+			"resource_id",
+			"run_id",
+			"status",
+			"args",
+			"result",
+			"error",
+			"suspend_payload",
+			"retry_count",
+			"max_retries",
+			"timeout_ms",
+			"createdAt",
+			"startedAt",
+			"suspendedAt",
+			"completedAt"
+		], [
+			task.id,
+			task.toolCallId,
+			task.toolName,
+			task.agentId,
+			task.threadId ?? null,
+			task.resourceId ?? null,
+			task.runId,
+			task.status,
+			serializeJson(task.args),
+			serializeJson(task.result),
+			serializeJson(task.error),
+			serializeJson(task.suspendPayload),
+			task.retryCount,
+			task.maxRetries,
+			task.timeoutMs,
+			task.createdAt.toISOString(),
+			task.startedAt?.toISOString() ?? null,
+			task.suspendedAt?.toISOString() ?? null,
+			task.completedAt?.toISOString() ?? null
+		]).build();
+		await this.#db.executeQuery({
+			sql,
+			params
+		});
+	}
+	async updateTask(taskId, update) {
+		const sets = [];
+		const params = [];
+		if ("status" in update) {
+			sets.push("status = ?");
+			params.push(update.status);
+		}
+		if ("result" in update) {
+			sets.push("result = ?");
+			params.push(serializeJson(update.result));
+		}
+		if ("error" in update) {
+			sets.push("error = ?");
+			params.push(serializeJson(update.error));
+		}
+		if ("suspendPayload" in update) {
+			sets.push("suspend_payload = ?");
+			params.push(serializeJson(update.suspendPayload));
+		}
+		if ("retryCount" in update) {
+			sets.push("retry_count = ?");
+			params.push(update.retryCount);
+		}
+		if ("startedAt" in update) {
+			sets.push("startedAt = ?");
+			params.push(update.startedAt?.toISOString() ?? null);
+		}
+		if ("suspendedAt" in update) {
+			sets.push("suspendedAt = ?");
+			params.push(update.suspendedAt?.toISOString() ?? null);
+		}
+		if ("completedAt" in update) {
+			sets.push("completedAt = ?");
+			params.push(update.completedAt?.toISOString() ?? null);
+		}
+		if (sets.length === 0) return;
+		params.push(taskId);
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		await this.#db.executeQuery({
+			sql: `UPDATE ${fullTableName} SET ${sets.join(", ")} WHERE id = ?`,
+			params
+		});
+	}
+	async getTask(taskId) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		const { sql, params } = createSqlBuilder().select("*").from(fullTableName).where("id = ?", taskId).build();
+		const row = await this.#db.executeQuery({
+			sql,
+			params,
+			first: true
+		});
+		return row ? rowToTask(row) : null;
+	}
+	async listTasks(filter) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		let builder = createSqlBuilder().select("*").from(fullTableName);
+		let countBuilder = createSqlBuilder().count().from(fullTableName);
+		if (filter.status) {
+			const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+			builder = builder.where(`status IN (${statuses.map(() => "?").join(",")})`, ...statuses);
+			countBuilder = countBuilder.where(`status IN (${statuses.map(() => "?").join(",")})`, ...statuses);
+		}
+		if (filter.agentId) {
+			builder = builder.whereAnd("agent_id = ?", filter.agentId);
+			countBuilder = countBuilder.whereAnd("agent_id = ?", filter.agentId);
+		}
+		if (filter.threadId) {
+			builder = builder.whereAnd("thread_id = ?", filter.threadId);
+			countBuilder = countBuilder.whereAnd("thread_id = ?", filter.threadId);
+		}
+		if (filter.runId) {
+			builder = builder.whereAnd("run_id = ?", filter.runId);
+			countBuilder = countBuilder.whereAnd("run_id = ?", filter.runId);
+		}
+		if (filter.toolName) {
+			builder = builder.whereAnd("tool_name = ?", filter.toolName);
+			countBuilder = countBuilder.whereAnd("tool_name = ?", filter.toolName);
+		}
+		if (filter.toolCallId) {
+			builder = builder.whereAnd("tool_call_id = ?", filter.toolCallId);
+			countBuilder = countBuilder.whereAnd("tool_call_id = ?", filter.toolCallId);
+		}
+		const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "suspendedAt" ? "suspendedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : "createdAt";
+		if (filter.fromDate) {
+			builder = builder.whereAnd(`${dateCol} >= ?`, filter.fromDate.toISOString());
+			countBuilder = countBuilder.whereAnd(`${dateCol} >= ?`, filter.fromDate.toISOString());
+		}
+		if (filter.toDate) {
+			builder = builder.whereAnd(`${dateCol} < ?`, filter.toDate.toISOString());
+			countBuilder = countBuilder.whereAnd(`${dateCol} < ?`, filter.toDate.toISOString());
+		}
+		const { sql: countSql, params: countParams } = countBuilder.build();
+		const countRow = await this.#db.executeQuery({
+			sql: countSql,
+			params: countParams,
+			first: true
+		});
+		const total = Number(countRow?.count ?? 0);
+		const orderCol = filter.orderBy === "startedAt" ? "startedAt" : filter.orderBy === "suspendedAt" ? "suspendedAt" : filter.orderBy === "completedAt" ? "completedAt" : "createdAt";
+		builder = builder.orderBy(orderCol, filter.orderDirection === "desc" ? "DESC" : "ASC");
+		if (filter.perPage != null) {
+			builder = builder.limit(filter.perPage);
+			if (filter.page != null) builder = builder.offset(filter.page * filter.perPage);
+		}
+		const { sql, params } = builder.build();
+		return {
+			tasks: (await this.#db.executeQuery({
+				sql,
+				params
+			})).map(rowToTask),
+			total
+		};
+	}
+	async deleteTask(taskId) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		await this.#db.executeQuery({
+			sql: `DELETE FROM ${fullTableName} WHERE id = ?`,
+			params: [taskId]
+		});
+	}
+	async deleteTasks(filter) {
+		const conditions = [];
+		const params = [];
+		if (filter.status) {
+			const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+			conditions.push(`status IN (${statuses.map(() => "?").join(",")})`);
+			params.push(...statuses);
+		}
+		const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "suspendedAt" ? "suspendedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : "createdAt";
+		if (filter.fromDate) {
+			conditions.push(`${dateCol} >= ?`);
+			params.push(filter.fromDate.toISOString());
+		}
+		if (filter.toDate) {
+			conditions.push(`${dateCol} < ?`);
+			params.push(filter.toDate.toISOString());
+		}
+		if (filter.agentId) {
+			conditions.push("agent_id = ?");
+			params.push(filter.agentId);
+		}
+		if (filter.runId) {
+			conditions.push("run_id = ?");
+			params.push(filter.runId);
+		}
+		if (filter.toolCallId) {
+			conditions.push("tool_call_id = ?");
+			params.push(filter.toolCallId);
+		}
+		if (conditions.length === 0) return;
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		await this.#db.executeQuery({
+			sql: `DELETE FROM ${fullTableName} WHERE ${conditions.join(" AND ")}`,
+			params
+		});
+	}
+	async getRunningCount() {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		const row = await this.#db.executeQuery({
+			sql: `SELECT COUNT(*) as count FROM ${fullTableName} WHERE status = 'running'`,
+			params: [],
+			first: true
+		});
+		return Number(row?.count ?? 0);
+	}
+	async getRunningCountByAgent(agentId) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		const row = await this.#db.executeQuery({
+			sql: `SELECT COUNT(*) as count FROM ${fullTableName} WHERE status = 'running' AND agent_id = ?`,
+			params: [agentId],
+			first: true
+		});
+		return Number(row?.count ?? 0);
+	}
 };
-var MemoryStorageD1 = class extends storage.MemoryStorage {
-  #db;
-  constructor(config) {
-    super();
-    this.#db = new D1DB(resolveD1Config(config));
-  }
-  async init() {
-    await this.#db.createTable({ tableName: storage.TABLE_THREADS, schema: storage.TABLE_SCHEMAS[storage.TABLE_THREADS] });
-    await this.#db.createTable({ tableName: storage.TABLE_MESSAGES, schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES] });
-    await this.#db.createTable({ tableName: storage.TABLE_RESOURCES, schema: storage.TABLE_SCHEMAS[storage.TABLE_RESOURCES] });
-    await this.#db.alterTable({
-      tableName: storage.TABLE_MESSAGES,
-      schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES],
-      ifNotExists: ["resourceId"]
-    });
-  }
-  async dangerouslyClearAll() {
-    await this.#db.clearTable({ tableName: storage.TABLE_MESSAGES });
-    await this.#db.clearTable({ tableName: storage.TABLE_THREADS });
-    await this.#db.clearTable({ tableName: storage.TABLE_RESOURCES });
-  }
-  async getResourceById({ resourceId }) {
-    const resource = await this.#db.load({
-      tableName: storage.TABLE_RESOURCES,
-      keys: { id: resourceId }
-    });
-    if (!resource) return null;
-    try {
-      return {
-        ...resource,
-        createdAt: storage.ensureDate(resource.createdAt),
-        updatedAt: storage.ensureDate(resource.updatedAt),
-        metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata || "{}") : resource.metadata
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_RESOURCE_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error processing resource ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { resourceId }
-        },
-        error$1
-      );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return null;
-    }
-  }
-  async saveResource({ resource }) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_RESOURCES);
-    const resourceToSave = {
-      id: resource.id,
-      workingMemory: resource.workingMemory,
-      metadata: resource.metadata ? JSON.stringify(resource.metadata) : null,
-      createdAt: resource.createdAt,
-      updatedAt: resource.updatedAt
-    };
-    const processedRecord = await this.#db.processRecord(resourceToSave);
-    const columns = Object.keys(processedRecord);
-    const values = Object.values(processedRecord);
-    const updateMap = {
-      workingMemory: "excluded.workingMemory",
-      metadata: "excluded.metadata",
-      createdAt: "excluded.createdAt",
-      updatedAt: "excluded.updatedAt"
-    };
-    const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
-    const { sql, params } = query.build();
-    try {
-      await this.#db.executeQuery({ sql, params });
-      return resource;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_RESOURCE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to save resource to ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { resourceId: resource.id }
-        },
-        error$1
-      );
-    }
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    const existingResource = await this.getResourceById({ resourceId });
-    if (!existingResource) {
-      const newResource = {
-        id: resourceId,
-        workingMemory,
-        metadata: metadata || {},
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      return this.saveResource({ resource: newResource });
-    }
-    const updatedAt = /* @__PURE__ */ new Date();
-    const updatedResource = {
-      ...existingResource,
-      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
-      metadata: {
-        ...existingResource.metadata,
-        ...metadata
-      },
-      updatedAt
-    };
-    const fullTableName = this.#db.getTableName(storage.TABLE_RESOURCES);
-    const columns = ["workingMemory", "metadata", "updatedAt"];
-    const values = [updatedResource.workingMemory, JSON.stringify(updatedResource.metadata), updatedAt.toISOString()];
-    const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId);
-    const { sql, params } = query.build();
-    try {
-      await this.#db.executeQuery({ sql, params });
-      return updatedResource;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "UPDATE_RESOURCE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to update resource ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { resourceId }
-        },
-        error$1
-      );
-    }
-  }
-  async getThreadById({
-    threadId,
-    resourceId
-  }) {
-    const thread = await this.#db.load({
-      tableName: storage.TABLE_THREADS,
-      keys: { id: threadId }
-    });
-    if (!thread || resourceId !== void 0 && thread.resourceId !== resourceId) return null;
-    try {
-      return {
-        ...thread,
-        createdAt: storage.ensureDate(thread.createdAt),
-        updatedAt: storage.ensureDate(thread.updatedAt),
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_THREAD_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error processing thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId }
-        },
-        error$1
-      );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return null;
-    }
-  }
-  async listThreads(args) {
-    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
-    try {
-      this.validatePaginationInput(page, perPageInput ?? 100);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_PAGE"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
-        },
-        error$1 instanceof Error ? error$1 : new Error("Invalid pagination parameters")
-      );
-    }
-    const perPage = storage.normalizePerPage(perPageInput, 100);
-    try {
-      this.validateMetadataKeys(filter?.metadata);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_METADATA_KEY"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
-        },
-        error$1 instanceof Error ? error$1 : new Error("Invalid metadata key")
-      );
-    }
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-    const { field, direction } = this.parseOrderBy(orderBy);
-    const fullTableName = this.#db.getTableName(storage.TABLE_THREADS);
-    const mapRowToStorageThreadType = (row) => ({
-      ...row,
-      createdAt: storage.ensureDate(row.createdAt),
-      updatedAt: storage.ensureDate(row.updatedAt),
-      metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata || "{}") : row.metadata || {}
-    });
-    try {
-      let countQuery = createSqlBuilder().count().from(fullTableName);
-      let selectQuery = createSqlBuilder().select("*").from(fullTableName);
-      if (filter?.resourceId) {
-        countQuery = countQuery.whereAnd("resourceId = ?", filter.resourceId);
-        selectQuery = selectQuery.whereAnd("resourceId = ?", filter.resourceId);
-      }
-      if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
-        for (const [key, value] of Object.entries(filter.metadata)) {
-          if (value !== null && typeof value === "object") {
-            throw new error.MastraError(
-              {
-                id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_METADATA_VALUE"),
-                domain: error.ErrorDomain.STORAGE,
-                category: error.ErrorCategory.USER,
-                text: `Metadata filter value for key "${key}" must be a scalar type (string, number, boolean, or null), got ${Array.isArray(value) ? "array" : "object"}`,
-                details: { key, valueType: Array.isArray(value) ? "array" : "object" }
-              },
-              new Error("Invalid metadata filter value type")
-            );
-          }
-          if (value === null) {
-            const condition = `json_extract(metadata, '$.${key}') IS NULL`;
-            countQuery = countQuery.whereAnd(condition);
-            selectQuery = selectQuery.whereAnd(condition);
-          } else {
-            const condition = `json_extract(metadata, '$.${key}') = ?`;
-            const filterValue = value;
-            countQuery = countQuery.whereAnd(condition, filterValue);
-            selectQuery = selectQuery.whereAnd(condition, filterValue);
-          }
-        }
-      }
-      const countResult = await this.#db.executeQuery(countQuery.build());
-      const total = Number(countResult?.[0]?.count ?? 0);
-      if (total === 0) {
-        return {
-          threads: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      const limitValue = perPageInput === false ? total : perPage;
-      selectQuery = selectQuery.orderBy(field, direction).limit(limitValue).offset(offset);
-      const results = await this.#db.executeQuery(selectQuery.build());
-      const threads = results.map(mapRowToStorageThreadType);
-      return {
-        threads,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore: perPageInput === false ? false : offset + perPage < total
-      };
-    } catch (error$1) {
-      if (error$1 instanceof error.MastraError && error$1.category === error.ErrorCategory.USER) {
-        throw error$1;
-      }
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Error listing threads: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: {
-            ...filter?.resourceId && { resourceId: filter.resourceId },
-            hasMetadataFilter: !!filter?.metadata
-          }
-        },
-        error$1
-      );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return {
-        threads: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
-    }
-  }
-  async saveThread({ thread }) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_THREADS);
-    const threadToSave = {
-      id: thread.id,
-      resourceId: thread.resourceId,
-      title: thread.title,
-      metadata: thread.metadata ? JSON.stringify(thread.metadata) : null,
-      createdAt: thread.createdAt.toISOString(),
-      updatedAt: thread.updatedAt.toISOString()
-    };
-    const processedRecord = await this.#db.processRecord(threadToSave);
-    const columns = Object.keys(processedRecord);
-    const values = Object.values(processedRecord);
-    const updateMap = {
-      resourceId: "excluded.resourceId",
-      title: "excluded.title",
-      metadata: "excluded.metadata",
-      createdAt: "excluded.createdAt",
-      updatedAt: "excluded.updatedAt"
-    };
-    const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
-    const { sql, params } = query.build();
-    try {
-      await this.#db.executeQuery({ sql, params });
-      return thread;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_THREAD", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to save thread to ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId: thread.id }
-        },
-        error$1
-      );
-    }
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    const thread = await this.getThreadById({ threadId: id });
-    try {
-      if (!thread) {
-        throw new Error(`Thread ${id} not found`);
-      }
-      const fullTableName = this.#db.getTableName(storage.TABLE_THREADS);
-      const mergedMetadata = {
-        ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        ...metadata
-      };
-      const updatedAt = /* @__PURE__ */ new Date();
-      const columns = ["title", "metadata", "updatedAt"];
-      const values = [title, JSON.stringify(mergedMetadata), updatedAt.toISOString()];
-      const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id);
-      const { sql, params } = query.build();
-      await this.#db.executeQuery({ sql, params });
-      return {
-        ...thread,
-        title,
-        metadata: {
-          ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-          ...metadata
-        },
-        updatedAt
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "UPDATE_THREAD", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to update thread ${id}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId: id }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteThread({ threadId }) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_THREADS);
-    try {
-      const deleteThreadQuery = createSqlBuilder().delete(fullTableName).where("id = ?", threadId);
-      const { sql: threadSql, params: threadParams } = deleteThreadQuery.build();
-      await this.#db.executeQuery({ sql: threadSql, params: threadParams });
-      const messagesTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
-      const deleteMessagesQuery = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId);
-      const { sql: messagesSql, params: messagesParams } = deleteMessagesQuery.build();
-      await this.#db.executeQuery({ sql: messagesSql, params: messagesParams });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "DELETE_THREAD", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to delete thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId }
-        },
-        error$1
-      );
-    }
-  }
-  async saveMessages(args) {
-    const { messages } = args;
-    if (messages.length === 0) return { messages: [] };
-    try {
-      const now = /* @__PURE__ */ new Date();
-      const threadId = messages[0]?.threadId;
-      for (const [i, message] of messages.entries()) {
-        if (!message.id) throw new Error(`Message at index ${i} missing id`);
-        if (!message.threadId) {
-          throw new Error(`Message at index ${i} missing threadId`);
-        }
-        if (!message.content) {
-          throw new Error(`Message at index ${i} missing content`);
-        }
-        if (!message.role) {
-          throw new Error(`Message at index ${i} missing role`);
-        }
-        if (!message.resourceId) {
-          throw new Error(`Message at index ${i} missing resourceId`);
-        }
-        const thread = await this.getThreadById({ threadId: message.threadId });
-        if (!thread) {
-          throw new Error(`Thread ${message.threadId} not found`);
-        }
-      }
-      const messagesToInsert = messages.map((message) => {
-        const createdAt = message.createdAt ? new Date(message.createdAt) : now;
-        return {
-          id: message.id,
-          thread_id: message.threadId,
-          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
-          createdAt: createdAt.toISOString(),
-          role: message.role,
-          type: message.type || "v2",
-          resourceId: message.resourceId
-        };
-      });
-      await Promise.all([
-        this.#db.batchUpsert({
-          tableName: storage.TABLE_MESSAGES,
-          records: messagesToInsert
-        }),
-        // Update thread's updatedAt timestamp
-        this.#db.executeQuery({
-          sql: `UPDATE ${this.#db.getTableName(storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
-          params: [now.toISOString(), threadId]
-        })
-      ]);
-      this.logger.debug(`Saved ${messages.length} messages`);
-      const list = new agent.MessageList().add(messages, "memory");
-      return { messages: list.get.all.db() };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_MESSAGES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to save messages: ${error$1 instanceof Error ? error$1.message : String(error$1)}`
-        },
-        error$1
-      );
-    }
-  }
-  _sortMessages(messages, field, direction) {
-    return messages.sort((a, b) => {
-      const isDateField = field === "createdAt" || field === "updatedAt";
-      const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
-      const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
-      if (aValue === bValue) {
-        return a.id.localeCompare(b.id);
-      }
-      if (typeof aValue === "number" && typeof bValue === "number") {
-        return direction === "ASC" ? aValue - bValue : bValue - aValue;
-      }
-      return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
-    });
-  }
-  async _getIncludedMessages(include) {
-    if (!include || include.length === 0) return null;
-    const tableName = this.#db.getTableName(storage.TABLE_MESSAGES);
-    const targetIds = include.map((inc) => inc.id).filter(Boolean);
-    if (targetIds.length === 0) return null;
-    const idPlaceholders = targetIds.map(() => "?").join(", ");
-    const targetResult = await this.#db.executeQuery({
-      sql: `SELECT id, thread_id, createdAt FROM ${tableName} WHERE id IN (${idPlaceholders})`,
-      params: targetIds
-    });
-    if (!Array.isArray(targetResult) || targetResult.length === 0) return null;
-    const targetMap = new Map(
-      targetResult.map((r) => [r.id, { threadId: r.thread_id, createdAt: r.createdAt }])
-    );
-    const MAX_UNION_TERMS = 5;
-    const unionQueries = [];
-    const unionParams = [];
-    const allMessages = [];
-    const flushBatch = async () => {
-      if (unionQueries.length === 0) return;
-      const sql = unionQueries.length === 1 ? unionQueries[0] : `${unionQueries.join(" UNION ALL ")} ORDER BY createdAt ASC, id ASC`;
-      const result = await this.#db.executeQuery({ sql, params: unionParams });
-      if (Array.isArray(result)) {
-        allMessages.push(...result);
-      }
-      unionQueries.length = 0;
-      unionParams.length = 0;
-    };
-    for (const inc of include) {
-      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const target = targetMap.get(id);
-      if (!target) continue;
-      const termsNeeded = withNextMessages > 0 ? 2 : 1;
-      if (unionQueries.length + termsNeeded > MAX_UNION_TERMS) {
-        await flushBatch();
-      }
-      unionQueries.push(`SELECT * FROM (
+//#endregion
+//#region src/storage/domains/memory/index.ts
+function addSqliteMetadataFilter(conditions, params, metadataFilter) {
+	if (!metadataFilter) return;
+	for (const [key, value] of Object.entries(metadataFilter)) {
+		const path = `$.metadata.${key}`;
+		conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) IS NOT NULL ELSE 0 END`);
+		params.push(path);
+		addSqliteMetadataValuePredicate(conditions, params, path, value);
+	}
+}
+function addSqliteMetadataValuePredicate(conditions, params, path, value) {
+	if (value === null) {
+		conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) = 'null' ELSE 0 END`);
+		params.push(path);
+		return;
+	}
+	if (typeof value === "string") {
+		conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) = 'text' AND json_extract(content, ?) = ? ELSE 0 END`);
+		params.push(path, path, value);
+		return;
+	}
+	if (typeof value === "number") {
+		conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) IN ('integer', 'real') AND json_extract(content, ?) = ? ELSE 0 END`);
+		params.push(path, path, value);
+		return;
+	}
+	conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) = ? AND json_extract(content, ?) = ? ELSE 0 END`);
+	params.push(path, value ? "true" : "false", path, value ? 1 : 0);
+}
+var MemoryStorageD1 = class extends _mastra_core_storage.MemoryStorage {
+	#db;
+	constructor(config) {
+		super();
+		this.#db = new D1DB(resolveD1Config(config));
+	}
+	async init() {
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_THREADS,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_THREADS]
+		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_MESSAGES,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_MESSAGES]
+		});
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_RESOURCES,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_RESOURCES]
+		});
+		await this.#db.alterTable({
+			tableName: _mastra_core_storage.TABLE_MESSAGES,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_MESSAGES],
+			ifNotExists: ["resourceId"]
+		});
+	}
+	async dangerouslyClearAll() {
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_MESSAGES });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_THREADS });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_RESOURCES });
+	}
+	async getResourceById({ resourceId }) {
+		const resource = await this.#db.load({
+			tableName: _mastra_core_storage.TABLE_RESOURCES,
+			keys: { id: resourceId }
+		});
+		if (!resource) return null;
+		try {
+			return {
+				...resource,
+				createdAt: (0, _mastra_core_storage.ensureDate)(resource.createdAt),
+				updatedAt: (0, _mastra_core_storage.ensureDate)(resource.updatedAt),
+				metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata || "{}") : resource.metadata
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "GET_RESOURCE_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Error processing resource ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
+				details: { resourceId }
+			}, error);
+			this.logger?.error(mastraError.toString());
+			this.logger?.trackException(mastraError);
+			return null;
+		}
+	}
+	async saveResource({ resource }) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_RESOURCES);
+		const resourceToSave = {
+			id: resource.id,
+			workingMemory: resource.workingMemory,
+			metadata: resource.metadata ? JSON.stringify(resource.metadata) : null,
+			createdAt: resource.createdAt,
+			updatedAt: resource.updatedAt
+		};
+		const processedRecord = await this.#db.processRecord(resourceToSave);
+		const columns = Object.keys(processedRecord);
+		const values = Object.values(processedRecord);
+		const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["id"], {
+			workingMemory: "excluded.workingMemory",
+			metadata: "excluded.metadata",
+			createdAt: "excluded.createdAt",
+			updatedAt: "excluded.updatedAt"
+		}).build();
+		try {
+			await this.#db.executeQuery({
+				sql,
+				params
+			});
+			return resource;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "SAVE_RESOURCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to save resource to ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+				details: { resourceId: resource.id }
+			}, error);
+		}
+	}
+	async updateResource({ resourceId, workingMemory, metadata }) {
+		const existingResource = await this.getResourceById({ resourceId });
+		if (!existingResource) {
+			const newResource = {
+				id: resourceId,
+				workingMemory,
+				metadata: metadata || {},
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+			return this.saveResource({ resource: newResource });
+		}
+		const updatedAt = /* @__PURE__ */ new Date();
+		const updatedResource = {
+			...existingResource,
+			workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+			metadata: {
+				...existingResource.metadata,
+				...metadata
+			},
+			updatedAt
+		};
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_RESOURCES);
+		const columns = [
+			"workingMemory",
+			"metadata",
+			"updatedAt"
+		];
+		const values = [
+			updatedResource.workingMemory,
+			JSON.stringify(updatedResource.metadata),
+			updatedAt.toISOString()
+		];
+		const { sql, params } = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId).build();
+		try {
+			await this.#db.executeQuery({
+				sql,
+				params
+			});
+			return updatedResource;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "UPDATE_RESOURCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to update resource ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
+				details: { resourceId }
+			}, error);
+		}
+	}
+	async getThreadById({ threadId, resourceId }) {
+		const thread = await this.#db.load({
+			tableName: _mastra_core_storage.TABLE_THREADS,
+			keys: { id: threadId }
+		});
+		if (!thread || resourceId !== void 0 && thread.resourceId !== resourceId) return null;
+		try {
+			return {
+				...thread,
+				createdAt: (0, _mastra_core_storage.ensureDate)(thread.createdAt),
+				updatedAt: (0, _mastra_core_storage.ensureDate)(thread.updatedAt),
+				metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "GET_THREAD_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Error processing thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
+				details: { threadId }
+			}, error);
+			this.logger?.error(mastraError.toString());
+			this.logger?.trackException(mastraError);
+			return null;
+		}
+	}
+	async listThreads(args) {
+		const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+		try {
+			this.validatePaginationInput(page, perPageInput ?? 100);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_PAGE"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: {
+					page,
+					...perPageInput !== void 0 && { perPage: perPageInput }
+				}
+			}, error instanceof Error ? error : /* @__PURE__ */ new Error("Invalid pagination parameters"));
+		}
+		const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+		try {
+			this.validateMetadataKeys(filter?.metadata);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_METADATA_KEY"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
+			}, error instanceof Error ? error : /* @__PURE__ */ new Error("Invalid metadata key"));
+		}
+		const { offset, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+		const { field, direction } = this.parseOrderBy(orderBy);
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_THREADS);
+		const mapRowToStorageThreadType = (row) => ({
+			...row,
+			createdAt: (0, _mastra_core_storage.ensureDate)(row.createdAt),
+			updatedAt: (0, _mastra_core_storage.ensureDate)(row.updatedAt),
+			metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata || "{}") : row.metadata || {}
+		});
+		try {
+			let countQuery = createSqlBuilder().count().from(fullTableName);
+			let selectQuery = createSqlBuilder().select("*").from(fullTableName);
+			if (filter?.resourceId) {
+				countQuery = countQuery.whereAnd("resourceId = ?", filter.resourceId);
+				selectQuery = selectQuery.whereAnd("resourceId = ?", filter.resourceId);
+			}
+			if (filter?.metadata && Object.keys(filter.metadata).length > 0) for (const [key, value] of Object.entries(filter.metadata)) {
+				if (value !== null && typeof value === "object") throw new _mastra_core_error.MastraError({
+					id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_THREADS", "INVALID_METADATA_VALUE"),
+					domain: _mastra_core_error.ErrorDomain.STORAGE,
+					category: _mastra_core_error.ErrorCategory.USER,
+					text: `Metadata filter value for key "${key}" must be a scalar type (string, number, boolean, or null), got ${Array.isArray(value) ? "array" : "object"}`,
+					details: {
+						key,
+						valueType: Array.isArray(value) ? "array" : "object"
+					}
+				}, /* @__PURE__ */ new Error("Invalid metadata filter value type"));
+				if (value === null) {
+					const condition = `json_extract(metadata, '$.${key}') IS NULL`;
+					countQuery = countQuery.whereAnd(condition);
+					selectQuery = selectQuery.whereAnd(condition);
+				} else {
+					const condition = `json_extract(metadata, '$.${key}') = ?`;
+					const filterValue = value;
+					countQuery = countQuery.whereAnd(condition, filterValue);
+					selectQuery = selectQuery.whereAnd(condition, filterValue);
+				}
+			}
+			const countResult = await this.#db.executeQuery(countQuery.build());
+			const total = Number(countResult?.[0]?.count ?? 0);
+			if (total === 0) return {
+				threads: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			const limitValue = perPageInput === false ? total : perPage;
+			selectQuery = selectQuery.orderBy(field, direction).limit(limitValue).offset(offset);
+			return {
+				threads: (await this.#db.executeQuery(selectQuery.build())).map(mapRowToStorageThreadType),
+				total,
+				page,
+				perPage: perPageForResponse,
+				hasMore: perPageInput === false ? false : offset + perPage < total
+			};
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError && error.category === _mastra_core_error.ErrorCategory.USER) throw error;
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_THREADS", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Error listing threads: ${error instanceof Error ? error.message : String(error)}`,
+				details: {
+					...filter?.resourceId && { resourceId: filter.resourceId },
+					hasMetadataFilter: !!filter?.metadata
+				}
+			}, error);
+			this.logger?.error(mastraError.toString());
+			this.logger?.trackException(mastraError);
+			return {
+				threads: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+		}
+	}
+	async saveThread({ thread }) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_THREADS);
+		const threadToSave = {
+			id: thread.id,
+			resourceId: thread.resourceId,
+			title: thread.title,
+			metadata: thread.metadata ? JSON.stringify(thread.metadata) : null,
+			createdAt: thread.createdAt.toISOString(),
+			updatedAt: thread.updatedAt.toISOString()
+		};
+		const processedRecord = await this.#db.processRecord(threadToSave);
+		const columns = Object.keys(processedRecord);
+		const values = Object.values(processedRecord);
+		const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["id"], {
+			resourceId: "excluded.resourceId",
+			title: "excluded.title",
+			metadata: "excluded.metadata",
+			createdAt: "excluded.createdAt",
+			updatedAt: "excluded.updatedAt"
+		}).build();
+		try {
+			await this.#db.executeQuery({
+				sql,
+				params
+			});
+			return thread;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "SAVE_THREAD", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to save thread to ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+				details: { threadId: thread.id }
+			}, error);
+		}
+	}
+	async updateThread({ id, title, metadata }) {
+		const thread = await this.getThreadById({ threadId: id });
+		try {
+			if (!thread) throw new Error(`Thread ${id} not found`);
+			const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_THREADS);
+			const mergedMetadata = {
+				...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+				...metadata
+			};
+			const updatedAt = /* @__PURE__ */ new Date();
+			const columns = [
+				"title",
+				"metadata",
+				"updatedAt"
+			];
+			const values = [
+				title,
+				JSON.stringify(mergedMetadata),
+				updatedAt.toISOString()
+			];
+			const { sql, params } = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id).build();
+			await this.#db.executeQuery({
+				sql,
+				params
+			});
+			return {
+				...thread,
+				title,
+				metadata: {
+					...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+					...metadata
+				},
+				updatedAt
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "UPDATE_THREAD", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to update thread ${id}: ${error instanceof Error ? error.message : String(error)}`,
+				details: { threadId: id }
+			}, error);
+		}
+	}
+	async deleteThread({ threadId }) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_THREADS);
+		try {
+			const { sql: threadSql, params: threadParams } = createSqlBuilder().delete(fullTableName).where("id = ?", threadId).build();
+			await this.#db.executeQuery({
+				sql: threadSql,
+				params: threadParams
+			});
+			const messagesTableName = this.#db.getTableName(_mastra_core_storage.TABLE_MESSAGES);
+			const { sql: messagesSql, params: messagesParams } = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId).build();
+			await this.#db.executeQuery({
+				sql: messagesSql,
+				params: messagesParams
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "DELETE_THREAD", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to delete thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
+				details: { threadId }
+			}, error);
+		}
+	}
+	async saveMessages(args) {
+		const { messages } = args;
+		if (messages.length === 0) return { messages: [] };
+		try {
+			const now = /* @__PURE__ */ new Date();
+			const threadId = messages[0]?.threadId;
+			for (const [i, message] of messages.entries()) {
+				if (!message.id) throw new Error(`Message at index ${i} missing id`);
+				if (!message.threadId) throw new Error(`Message at index ${i} missing threadId`);
+				if (!message.content) throw new Error(`Message at index ${i} missing content`);
+				if (!message.role) throw new Error(`Message at index ${i} missing role`);
+				if (!message.resourceId) throw new Error(`Message at index ${i} missing resourceId`);
+				if (!await this.getThreadById({ threadId: message.threadId })) throw new Error(`Thread ${message.threadId} not found`);
+			}
+			const messagesToInsert = messages.map((message) => {
+				const createdAt = message.createdAt ? new Date(message.createdAt) : now;
+				return {
+					id: message.id,
+					thread_id: message.threadId,
+					content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+					createdAt: createdAt.toISOString(),
+					role: message.role,
+					type: message.type || "v2",
+					resourceId: message.resourceId
+				};
+			});
+			await Promise.all([this.#db.batchUpsert({
+				tableName: _mastra_core_storage.TABLE_MESSAGES,
+				records: messagesToInsert
+			}), this.#db.executeQuery({
+				sql: `UPDATE ${this.#db.getTableName(_mastra_core_storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
+				params: [now.toISOString(), threadId]
+			})]);
+			this.logger.debug(`Saved ${messages.length} messages`);
+			return { messages: new _mastra_core_agent.MessageList().add(messages, "memory").get.all.db() };
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "SAVE_MESSAGES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to save messages: ${error instanceof Error ? error.message : String(error)}`
+			}, error);
+		}
+	}
+	_sortMessages(messages, field, direction) {
+		return messages.sort((a, b) => {
+			const isDateField = field === "createdAt" || field === "updatedAt";
+			const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+			const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+			if (aValue === bValue) return a.id.localeCompare(b.id);
+			if (typeof aValue === "number" && typeof bValue === "number") return direction === "ASC" ? aValue - bValue : bValue - aValue;
+			return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+		});
+	}
+	async _getIncludedMessages(include) {
+		if (!include || include.length === 0) return null;
+		const tableName = this.#db.getTableName(_mastra_core_storage.TABLE_MESSAGES);
+		const targetIds = include.map((inc) => inc.id).filter(Boolean);
+		if (targetIds.length === 0) return null;
+		const idPlaceholders = targetIds.map(() => "?").join(", ");
+		const targetResult = await this.#db.executeQuery({
+			sql: `SELECT id, thread_id, createdAt FROM ${tableName} WHERE id IN (${idPlaceholders})`,
+			params: targetIds
+		});
+		if (!Array.isArray(targetResult) || targetResult.length === 0) return null;
+		const targetMap = new Map(targetResult.map((r) => [r.id, {
+			threadId: r.thread_id,
+			createdAt: r.createdAt
+		}]));
+		const MAX_UNION_TERMS = 5;
+		const unionQueries = [];
+		const unionParams = [];
+		const allMessages = [];
+		const flushBatch = async () => {
+			if (unionQueries.length === 0) return;
+			const sql = unionQueries.length === 1 ? unionQueries[0] : `${unionQueries.join(" UNION ALL ")} ORDER BY createdAt ASC, id ASC`;
+			const result = await this.#db.executeQuery({
+				sql,
+				params: unionParams
+			});
+			if (Array.isArray(result)) allMessages.push(...result);
+			unionQueries.length = 0;
+			unionParams.length = 0;
+		};
+		for (const inc of include) {
+			const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+			const target = targetMap.get(id);
+			if (!target) continue;
+			const termsNeeded = withNextMessages > 0 ? 2 : 1;
+			if (unionQueries.length + termsNeeded > MAX_UNION_TERMS) await flushBatch();
+			unionQueries.push(`SELECT * FROM (
         SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
         FROM ${tableName}
         WHERE thread_id = ?
@@ -1508,9 +1440,9 @@ var MemoryStorageD1 = class extends storage.MemoryStorage {
         ORDER BY createdAt DESC, id DESC
         LIMIT ?
       )`);
-      unionParams.push(target.threadId, target.createdAt, withPreviousMessages + 1);
-      if (withNextMessages > 0) {
-        unionQueries.push(`SELECT * FROM (
+			unionParams.push(target.threadId, target.createdAt, withPreviousMessages + 1);
+			if (withNextMessages > 0) {
+				unionQueries.push(`SELECT * FROM (
           SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
           FROM ${tableName}
           WHERE thread_id = ?
@@ -1518,1048 +1450,1017 @@ var MemoryStorageD1 = class extends storage.MemoryStorage {
           ORDER BY createdAt ASC, id ASC
           LIMIT ?
         )`);
-        unionParams.push(target.threadId, target.createdAt, withNextMessages);
-      }
-    }
-    await flushBatch();
-    const seen = /* @__PURE__ */ new Set();
-    const processedMessages = allMessages.filter((message) => {
-      const id = message.id;
-      if (seen.has(id)) return false;
-      seen.add(id);
-      return true;
-    }).map((message) => {
-      const processedMsg = {};
-      for (const [key, value] of Object.entries(message)) {
-        if (key === `type` && value === `v2`) continue;
-        processedMsg[key] = deserializeValue(value);
-      }
-      return processedMsg;
-    });
-    return processedMessages;
-  }
-  async listMessagesById({ messageIds }) {
-    if (messageIds.length === 0) return { messages: [] };
-    const fullTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
-    const messages = [];
-    try {
-      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId", "resourceId"]).from(fullTableName).where(`id in (${messageIds.map(() => "?").join(",")})`, ...messageIds);
-      query.orderBy("createdAt", "DESC");
-      const { sql, params } = query.build();
-      const result = await this.#db.executeQuery({ sql, params });
-      if (Array.isArray(result)) messages.push(...result);
-      const processedMessages = messages.map((message) => {
-        const processedMsg = {};
-        for (const [key, value] of Object.entries(message)) {
-          if (key === `type` && value === `v2`) continue;
-          processedMsg[key] = deserializeValue(value);
-        }
-        return processedMsg;
-      });
-      this.logger.debug(`Retrieved ${messages.length} messages`);
-      const list = new agent.MessageList().add(processedMessages, "memory");
-      return { messages: list.get.all.db() };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve messages by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { messageIds: JSON.stringify(messageIds) }
-        },
-        error$1
-      );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      throw mastraError;
-    }
-  }
-  async listMessages(args) {
-    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
-    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "INVALID_THREAD_ID"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
-        },
-        new Error("threadId must be a non-empty string or array of non-empty strings")
-      );
-    }
-    if (page < 0) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "INVALID_PAGE"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { page }
-        },
-        new Error("page must be >= 0")
-      );
-    }
-    const perPage = storage.normalizePerPage(perPageInput, 40);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-    try {
-      const fullTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
-      let query = `
+				unionParams.push(target.threadId, target.createdAt, withNextMessages);
+			}
+		}
+		await flushBatch();
+		const seen = /* @__PURE__ */ new Set();
+		return allMessages.filter((message) => {
+			const id = message.id;
+			if (seen.has(id)) return false;
+			seen.add(id);
+			return true;
+		}).map((message) => {
+			const processedMsg = {};
+			for (const [key, value] of Object.entries(message)) {
+				if (key === `type` && value === `v2`) continue;
+				processedMsg[key] = deserializeValue(value);
+			}
+			return processedMsg;
+		});
+	}
+	async listMessagesById({ messageIds }) {
+		if (messageIds.length === 0) return { messages: [] };
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_MESSAGES);
+		const messages = [];
+		try {
+			const query = createSqlBuilder().select([
+				"id",
+				"content",
+				"role",
+				"type",
+				"createdAt",
+				"thread_id AS threadId",
+				"resourceId"
+			]).from(fullTableName).where(`id in (${messageIds.map(() => "?").join(",")})`, ...messageIds);
+			query.orderBy("createdAt", "DESC");
+			const { sql, params } = query.build();
+			const result = await this.#db.executeQuery({
+				sql,
+				params
+			});
+			if (Array.isArray(result)) messages.push(...result);
+			const processedMessages = messages.map((message) => {
+				const processedMsg = {};
+				for (const [key, value] of Object.entries(message)) {
+					if (key === `type` && value === `v2`) continue;
+					processedMsg[key] = deserializeValue(value);
+				}
+				return processedMsg;
+			});
+			this.logger.debug(`Retrieved ${messages.length} messages`);
+			return { messages: new _mastra_core_agent.MessageList().add(processedMessages, "memory").get.all.db() };
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_MESSAGES_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to retrieve messages by ID: ${error instanceof Error ? error.message : String(error)}`,
+				details: { messageIds: JSON.stringify(messageIds) }
+			}, error);
+			this.logger?.error(mastraError.toString());
+			this.logger?.trackException(mastraError);
+			throw mastraError;
+		}
+	}
+	async listMessages(args) {
+		const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+		const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+		if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+		}, /* @__PURE__ */ new Error("threadId must be a non-empty string or array of non-empty strings"));
+		if (page < 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_MESSAGES", "INVALID_PAGE"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { page }
+		}, /* @__PURE__ */ new Error("page must be >= 0"));
+		const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 40);
+		const { offset, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+		const metadataFilter = (0, _mastra_core_storage.validateStorageMetadataFilter)(filter?.metadata);
+		try {
+			const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_MESSAGES);
+			const threadPlaceholders = threadIds.map(() => "?").join(", ");
+			let query = `
         SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
         FROM ${fullTableName}
-        WHERE thread_id = ?
+        WHERE thread_id IN (${threadPlaceholders})
       `;
-      const queryParams = [threadId];
-      if (resourceId) {
-        query += ` AND resourceId = ?`;
-        queryParams.push(resourceId);
-      }
-      const dateRange = filter?.dateRange;
-      if (dateRange?.start) {
-        const startDate = dateRange.start instanceof Date ? storage.serializeDate(dateRange.start) : storage.serializeDate(new Date(dateRange.start));
-        const startOp = dateRange.startExclusive ? ">" : ">=";
-        query += ` AND createdAt ${startOp} ?`;
-        queryParams.push(startDate);
-      }
-      if (dateRange?.end) {
-        const endDate = dateRange.end instanceof Date ? storage.serializeDate(dateRange.end) : storage.serializeDate(new Date(dateRange.end));
-        const endOp = dateRange.endExclusive ? "<" : "<=";
-        query += ` AND createdAt ${endOp} ?`;
-        queryParams.push(endDate);
-      }
-      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-      if (perPage === 0 && (!include || include.length === 0)) {
-        return { messages: [], total: 0, page, perPage: perPageForResponse, hasMore: false };
-      }
-      if (perPage === 0 && include && include.length > 0) {
-        const includeResult = await this._getIncludedMessages(include);
-        if (!Array.isArray(includeResult) || includeResult.length === 0) {
-          return { messages: [], total: 0, page, perPage: perPageForResponse, hasMore: false };
-        }
-        const list2 = new agent.MessageList().add(includeResult, "memory");
-        return {
-          messages: this._sortMessages(list2.get.all.db(), field, direction),
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      query += ` ORDER BY "${field}" ${direction}`;
-      if (perPage !== Number.MAX_SAFE_INTEGER) {
-        query += ` LIMIT ? OFFSET ?`;
-        queryParams.push(perPage, offset);
-      }
-      const results = await this.#db.executeQuery({ sql: query, params: queryParams });
-      const paginatedMessages = (isArrayOfRecords(results) ? results : []).map((message) => {
-        const processedMsg = {};
-        for (const [key, value] of Object.entries(message)) {
-          if (key === `type` && value === `v2`) continue;
-          processedMsg[key] = deserializeValue(value);
-        }
-        return processedMsg;
-      });
-      const paginatedCount = paginatedMessages.length;
-      let countQuery = `SELECT count() as count FROM ${fullTableName} WHERE thread_id = ?`;
-      const countParams = [threadId];
-      if (resourceId) {
-        countQuery += ` AND resourceId = ?`;
-        countParams.push(resourceId);
-      }
-      if (dateRange?.start) {
-        const startDate = dateRange.start instanceof Date ? storage.serializeDate(dateRange.start) : storage.serializeDate(new Date(dateRange.start));
-        const startOp = dateRange.startExclusive ? ">" : ">=";
-        countQuery += ` AND createdAt ${startOp} ?`;
-        countParams.push(startDate);
-      }
-      if (dateRange?.end) {
-        const endDate = dateRange.end instanceof Date ? storage.serializeDate(dateRange.end) : storage.serializeDate(new Date(dateRange.end));
-        const endOp = dateRange.endExclusive ? "<" : "<=";
-        countQuery += ` AND createdAt ${endOp} ?`;
-        countParams.push(endDate);
-      }
-      const countResult = await this.#db.executeQuery({ sql: countQuery, params: countParams });
-      const total = Number(countResult[0]?.count ?? 0);
-      if (total === 0 && paginatedCount === 0 && (!include || include.length === 0)) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      const messageIds = new Set(paginatedMessages.map((m) => m.id));
-      let includeMessages = [];
-      if (include && include.length > 0) {
-        const includeResult = await this._getIncludedMessages(include);
-        if (Array.isArray(includeResult)) {
-          includeMessages = includeResult;
-          for (const includeMsg of includeMessages) {
-            if (!messageIds.has(includeMsg.id)) {
-              paginatedMessages.push(includeMsg);
-              messageIds.add(includeMsg.id);
-            }
-          }
-        }
-      }
-      const list = new agent.MessageList().add(paginatedMessages, "memory");
-      const finalMessages = this._sortMessages(list.get.all.db(), field, direction);
-      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
-      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
-      const hasMore = perPageInput === false ? false : allThreadMessagesReturned ? false : offset + paginatedCount < total;
-      return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to list messages for thread ${Array.isArray(threadId) ? threadId.join(",") : threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: {
-            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
-            resourceId: resourceId ?? ""
-          }
-        },
-        error$1
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
-    }
-  }
-  async updateMessages(args) {
-    const { messages } = args;
-    this.logger.debug("Updating messages", { count: messages.length });
-    if (!messages.length) {
-      return [];
-    }
-    const messageIds = messages.map((m) => m.id);
-    const fullTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
-    const threadsTableName = this.#db.getTableName(storage.TABLE_THREADS);
-    try {
-      const placeholders = messageIds.map(() => "?").join(",");
-      const selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${fullTableName} WHERE id IN (${placeholders})`;
-      const existingMessages = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
-      if (existingMessages.length === 0) {
-        return [];
-      }
-      const parsedExistingMessages = existingMessages.map((msg) => {
-        if (typeof msg.content === "string") {
-          try {
-            msg.content = JSON.parse(msg.content);
-          } catch {
-          }
-        }
-        return msg;
-      });
-      const threadIdsToUpdate = /* @__PURE__ */ new Set();
-      const updateQueries = [];
-      for (const existingMessage of parsedExistingMessages) {
-        const updatePayload = messages.find((m) => m.id === existingMessage.id);
-        if (!updatePayload) continue;
-        const { id, ...fieldsToUpdate } = updatePayload;
-        if (Object.keys(fieldsToUpdate).length === 0) continue;
-        threadIdsToUpdate.add(existingMessage.threadId);
-        if ("threadId" in updatePayload && updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
-          threadIdsToUpdate.add(updatePayload.threadId);
-        }
-        const setClauses = [];
-        const values = [];
-        const updatableFields = { ...fieldsToUpdate };
-        if (updatableFields.content) {
-          const existingContent = existingMessage.content || {};
-          const newContent = {
-            ...existingContent,
-            ...updatableFields.content,
-            // Deep merge metadata if it exists on both
-            ...existingContent?.metadata && updatableFields.content.metadata ? {
-              metadata: {
-                ...existingContent.metadata,
-                ...updatableFields.content.metadata
-              }
-            } : {}
-          };
-          setClauses.push(`content = ?`);
-          values.push(JSON.stringify(newContent));
-          delete updatableFields.content;
-        }
-        for (const key in updatableFields) {
-          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
-            const dbColumn = key === "threadId" ? "thread_id" : key;
-            setClauses.push(`${dbColumn} = ?`);
-            values.push(updatableFields[key]);
-          }
-        }
-        if (setClauses.length > 0) {
-          values.push(id);
-          const updateQuery = `UPDATE ${fullTableName} SET ${setClauses.join(", ")} WHERE id = ?`;
-          updateQueries.push({ sql: updateQuery, params: values });
-        }
-      }
-      for (const query of updateQueries) {
-        await this.#db.executeQuery(query);
-      }
-      if (threadIdsToUpdate.size > 0) {
-        const threadPlaceholders = Array.from(threadIdsToUpdate).map(() => "?").join(",");
-        const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${threadPlaceholders})`;
-        const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...Array.from(threadIdsToUpdate)];
-        await this.#db.executeQuery({ sql: threadUpdateQuery, params: threadUpdateParams });
-      }
-      const updatedMessages = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
-      return updatedMessages.map((message) => {
-        if (typeof message.content === "string") {
-          try {
-            message.content = JSON.parse(message.content);
-          } catch {
-          }
-        }
-        return message;
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "UPDATE_MESSAGES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { count: messages.length }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteMessages(messageIds) {
-    if (messageIds.length === 0) return;
-    const fullTableName = this.#db.getTableName(storage.TABLE_MESSAGES);
-    const threadsTableName = this.#db.getTableName(storage.TABLE_THREADS);
-    try {
-      const placeholders = messageIds.map(() => "?").join(",");
-      const selectQuery = `SELECT DISTINCT thread_id FROM ${fullTableName} WHERE id IN (${placeholders})`;
-      const threadResults = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
-      const threadIds = threadResults.map((r) => r.thread_id).filter(Boolean);
-      const deleteQuery = createSqlBuilder().delete(fullTableName).where(`id IN (${placeholders})`, ...messageIds);
-      const { sql, params } = deleteQuery.build();
-      await this.#db.executeQuery({ sql, params });
-      if (threadIds.length > 0) {
-        const threadPlaceholders = threadIds.map(() => "?").join(",");
-        const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${threadPlaceholders})`;
-        const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...threadIds];
-        await this.#db.executeQuery({ sql: threadUpdateQuery, params: threadUpdateParams });
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "DELETE_MESSAGES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { messageIds: JSON.stringify(messageIds) }
-        },
-        error$1
-      );
-    }
-  }
+			const queryParams = [...threadIds];
+			if (resourceId) {
+				query += ` AND resourceId = ?`;
+				queryParams.push(resourceId);
+			}
+			const dateRange = filter?.dateRange;
+			if (dateRange?.start) {
+				const startDate = dateRange.start instanceof Date ? (0, _mastra_core_storage.serializeDate)(dateRange.start) : (0, _mastra_core_storage.serializeDate)(new Date(dateRange.start));
+				const startOp = dateRange.startExclusive ? ">" : ">=";
+				query += ` AND createdAt ${startOp} ?`;
+				queryParams.push(startDate);
+			}
+			if (dateRange?.end) {
+				const endDate = dateRange.end instanceof Date ? (0, _mastra_core_storage.serializeDate)(dateRange.end) : (0, _mastra_core_storage.serializeDate)(new Date(dateRange.end));
+				const endOp = dateRange.endExclusive ? "<" : "<=";
+				query += ` AND createdAt ${endOp} ?`;
+				queryParams.push(endDate);
+			}
+			const metadataConditions = [];
+			addSqliteMetadataFilter(metadataConditions, queryParams, metadataFilter);
+			if (metadataConditions.length > 0) query += ` AND ${metadataConditions.join(" AND ")}`;
+			const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+			if (perPage === 0 && (!include || include.length === 0)) return {
+				messages: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			if (perPage === 0 && include && include.length > 0) {
+				const includeResult = await this._getIncludedMessages(include);
+				if (!Array.isArray(includeResult) || includeResult.length === 0) return {
+					messages: [],
+					total: 0,
+					page,
+					perPage: perPageForResponse,
+					hasMore: false
+				};
+				const list = new _mastra_core_agent.MessageList().add(includeResult, "memory");
+				return {
+					messages: this._sortMessages(list.get.all.db(), field, direction),
+					total: 0,
+					page,
+					perPage: perPageForResponse,
+					hasMore: false
+				};
+			}
+			query += ` ORDER BY "${field}" ${direction}`;
+			if (perPage !== Number.MAX_SAFE_INTEGER) {
+				query += ` LIMIT ? OFFSET ?`;
+				queryParams.push(perPage, offset);
+			}
+			const results = await this.#db.executeQuery({
+				sql: query,
+				params: queryParams
+			});
+			const paginatedMessages = (isArrayOfRecords(results) ? results : []).map((message) => {
+				const processedMsg = {};
+				for (const [key, value] of Object.entries(message)) {
+					if (key === `type` && value === `v2`) continue;
+					processedMsg[key] = deserializeValue(value);
+				}
+				return processedMsg;
+			});
+			const paginatedCount = paginatedMessages.length;
+			let countQuery = `SELECT count() as count FROM ${fullTableName} WHERE thread_id IN (${threadPlaceholders})`;
+			const countParams = [...threadIds];
+			if (resourceId) {
+				countQuery += ` AND resourceId = ?`;
+				countParams.push(resourceId);
+			}
+			if (dateRange?.start) {
+				const startDate = dateRange.start instanceof Date ? (0, _mastra_core_storage.serializeDate)(dateRange.start) : (0, _mastra_core_storage.serializeDate)(new Date(dateRange.start));
+				const startOp = dateRange.startExclusive ? ">" : ">=";
+				countQuery += ` AND createdAt ${startOp} ?`;
+				countParams.push(startDate);
+			}
+			if (dateRange?.end) {
+				const endDate = dateRange.end instanceof Date ? (0, _mastra_core_storage.serializeDate)(dateRange.end) : (0, _mastra_core_storage.serializeDate)(new Date(dateRange.end));
+				const endOp = dateRange.endExclusive ? "<" : "<=";
+				countQuery += ` AND createdAt ${endOp} ?`;
+				countParams.push(endDate);
+			}
+			const countMetadataConditions = [];
+			addSqliteMetadataFilter(countMetadataConditions, countParams, metadataFilter);
+			if (countMetadataConditions.length > 0) countQuery += ` AND ${countMetadataConditions.join(" AND ")}`;
+			const countResult = await this.#db.executeQuery({
+				sql: countQuery,
+				params: countParams
+			});
+			const total = Number(countResult[0]?.count ?? 0);
+			if (total === 0 && paginatedCount === 0 && (!include || include.length === 0)) return {
+				messages: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			const messageIds = new Set(paginatedMessages.map((m) => m.id));
+			let includeMessages = [];
+			if (include && include.length > 0) {
+				const includeResult = await this._getIncludedMessages(include);
+				if (Array.isArray(includeResult)) {
+					includeMessages = includeResult;
+					for (const includeMsg of includeMessages) if (!messageIds.has(includeMsg.id)) {
+						paginatedMessages.push(includeMsg);
+						messageIds.add(includeMsg.id);
+					}
+				}
+			}
+			const list = new _mastra_core_agent.MessageList().add(paginatedMessages, "memory");
+			const finalMessages = this._sortMessages(list.get.all.db(), field, direction);
+			const threadIdSet = new Set(threadIds);
+			const allThreadMessagesReturned = new Set(finalMessages.filter((m) => m.threadId && threadIdSet.has(m.threadId)).map((m) => m.id)).size >= total;
+			return {
+				messages: finalMessages,
+				total,
+				page,
+				perPage: perPageForResponse,
+				hasMore: metadataFilter ? perPageInput !== false && offset + paginatedCount < total : perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_MESSAGES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to list messages for thread ${Array.isArray(threadId) ? threadId.join(",") : threadId}: ${error instanceof Error ? error.message : String(error)}`,
+				details: {
+					threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+					resourceId: resourceId ?? ""
+				}
+			}, error);
+			this.logger?.error?.(mastraError.toString());
+			this.logger?.trackException?.(mastraError);
+			return {
+				messages: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+		}
+	}
+	async updateMessages(args) {
+		const { messages } = args;
+		this.logger.debug("Updating messages", { count: messages.length });
+		if (!messages.length) return [];
+		const messageIds = messages.map((m) => m.id);
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_MESSAGES);
+		const threadsTableName = this.#db.getTableName(_mastra_core_storage.TABLE_THREADS);
+		try {
+			const selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${fullTableName} WHERE id IN (${messageIds.map(() => "?").join(",")})`;
+			const existingMessages = await this.#db.executeQuery({
+				sql: selectQuery,
+				params: messageIds
+			});
+			if (existingMessages.length === 0) return [];
+			const parsedExistingMessages = existingMessages.map((msg) => {
+				if (typeof msg.content === "string") try {
+					msg.content = JSON.parse(msg.content);
+				} catch {}
+				return msg;
+			});
+			const threadIdsToUpdate = /* @__PURE__ */ new Set();
+			const updateQueries = [];
+			for (const existingMessage of parsedExistingMessages) {
+				const updatePayload = messages.find((m) => m.id === existingMessage.id);
+				if (!updatePayload) continue;
+				const { id, ...fieldsToUpdate } = updatePayload;
+				if (Object.keys(fieldsToUpdate).length === 0) continue;
+				threadIdsToUpdate.add(existingMessage.threadId);
+				if ("threadId" in updatePayload && updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) threadIdsToUpdate.add(updatePayload.threadId);
+				const setClauses = [];
+				const values = [];
+				const updatableFields = { ...fieldsToUpdate };
+				if (updatableFields.content) {
+					const existingContent = existingMessage.content || {};
+					const newContent = {
+						...existingContent,
+						...updatableFields.content,
+						...existingContent?.metadata && updatableFields.content.metadata ? { metadata: {
+							...existingContent.metadata,
+							...updatableFields.content.metadata
+						} } : {}
+					};
+					setClauses.push(`content = ?`);
+					values.push(JSON.stringify(newContent));
+					delete updatableFields.content;
+				}
+				for (const key in updatableFields) if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+					const dbColumn = key === "threadId" ? "thread_id" : key;
+					setClauses.push(`${dbColumn} = ?`);
+					values.push(updatableFields[key]);
+				}
+				if (setClauses.length > 0) {
+					values.push(id);
+					const updateQuery = `UPDATE ${fullTableName} SET ${setClauses.join(", ")} WHERE id = ?`;
+					updateQueries.push({
+						sql: updateQuery,
+						params: values
+					});
+				}
+			}
+			for (const query of updateQueries) await this.#db.executeQuery(query);
+			if (threadIdsToUpdate.size > 0) {
+				const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${Array.from(threadIdsToUpdate).map(() => "?").join(",")})`;
+				const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...Array.from(threadIdsToUpdate)];
+				await this.#db.executeQuery({
+					sql: threadUpdateQuery,
+					params: threadUpdateParams
+				});
+			}
+			return (await this.#db.executeQuery({
+				sql: selectQuery,
+				params: messageIds
+			})).map((message) => {
+				if (typeof message.content === "string") try {
+					message.content = JSON.parse(message.content);
+				} catch {}
+				return message;
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "UPDATE_MESSAGES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { count: messages.length }
+			}, error);
+		}
+	}
+	async deleteMessages(messageIds) {
+		if (messageIds.length === 0) return;
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_MESSAGES);
+		const threadsTableName = this.#db.getTableName(_mastra_core_storage.TABLE_THREADS);
+		try {
+			const placeholders = messageIds.map(() => "?").join(",");
+			const selectQuery = `SELECT DISTINCT thread_id FROM ${fullTableName} WHERE id IN (${placeholders})`;
+			const threadIds = (await this.#db.executeQuery({
+				sql: selectQuery,
+				params: messageIds
+			})).map((r) => r.thread_id).filter(Boolean);
+			const { sql, params } = createSqlBuilder().delete(fullTableName).where(`id IN (${placeholders})`, ...messageIds).build();
+			await this.#db.executeQuery({
+				sql,
+				params
+			});
+			if (threadIds.length > 0) {
+				const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${threadIds.map(() => "?").join(",")})`;
+				const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...threadIds];
+				await this.#db.executeQuery({
+					sql: threadUpdateQuery,
+					params: threadUpdateParams
+				});
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "DELETE_MESSAGES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { messageIds: JSON.stringify(messageIds) }
+			}, error);
+		}
+	}
 };
+//#endregion
+//#region src/storage/domains/scores/index.ts
+/** Applies multi-tenant scope conditions to a query builder. */
 function applyTenancyFilters(query, filters) {
-  if (filters?.organizationId !== void 0) {
-    query.andWhere("organizationId = ?", filters.organizationId);
-  }
-  if (filters?.projectId !== void 0) {
-    query.andWhere("projectId = ?", filters.projectId);
-  }
+	if (filters?.organizationId !== void 0) query.andWhere("organizationId = ?", filters.organizationId);
+	if (filters?.projectId !== void 0) query.andWhere("projectId = ?", filters.projectId);
 }
+/**
+* Cloudflare D1-specific score row transformation.
+* Uses Z-suffix timestamps (createdAtZ, updatedAtZ) when available.
+*/
 function transformScoreRow(row) {
-  return storage.transformScoreRow(row, {
-    preferredTimestampFields: {
-      createdAt: "createdAtZ",
-      updatedAt: "updatedAtZ"
-    }
-  });
+	return (0, _mastra_core_storage.transformScoreRow)(row, { preferredTimestampFields: {
+		createdAt: "createdAtZ",
+		updatedAt: "updatedAtZ"
+	} });
 }
-var ScoresStorageD1 = class extends storage.ScoresStorage {
-  #db;
-  constructor(config) {
-    super();
-    this.#db = new D1DB(resolveD1Config(config));
-  }
-  async init() {
-    await this.#db.createTable({ tableName: storage.TABLE_SCORERS, schema: storage.TABLE_SCHEMAS[storage.TABLE_SCORERS] });
-    await this.#db.alterTable({
-      tableName: storage.TABLE_SCORERS,
-      schema: storage.TABLE_SCHEMAS[storage.TABLE_SCORERS],
-      ifNotExists: ["organizationId", "projectId", "batchId", "datasetId", "datasetItemId"]
-    });
-  }
-  async dangerouslyClearAll() {
-    await this.#db.clearTable({ tableName: storage.TABLE_SCORERS });
-  }
-  async getScoreById({ id }) {
-    try {
-      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
-      const query = createSqlBuilder().select("*").from(fullTableName).where("id = ?", id);
-      const { sql, params } = query.build();
-      const result = await this.#db.executeQuery({ sql, params, first: true });
-      if (!result) {
-        return null;
-      }
-      return transformScoreRow(result);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORE_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  async saveScore(score) {
-    let parsedScore;
-    try {
-      parsedScore = evals.saveScorePayloadSchema.parse(score);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_SCORE", "VALIDATION_FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
-            entityId: score.entityId ?? "unknown",
-            entityType: score.entityType ?? "unknown",
-            traceId: score.traceId ?? "",
-            spanId: score.spanId ?? ""
-          }
-        },
-        error$1
-      );
-    }
-    const id = crypto.randomUUID();
-    try {
-      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
-      const serializedRecord = {};
-      for (const [key, value] of Object.entries(parsedScore)) {
-        if (value !== null && value !== void 0) {
-          if (typeof value === "object") {
-            serializedRecord[key] = JSON.stringify(value);
-          } else {
-            serializedRecord[key] = value;
-          }
-        } else {
-          serializedRecord[key] = null;
-        }
-      }
-      const now = /* @__PURE__ */ new Date();
-      serializedRecord.id = id;
-      serializedRecord.createdAt = now.toISOString();
-      serializedRecord.updatedAt = now.toISOString();
-      const columns = Object.keys(serializedRecord);
-      const values = Object.values(serializedRecord);
-      const query = createSqlBuilder().insert(fullTableName, columns, values);
-      const { sql, params } = query.build();
-      await this.#db.executeQuery({ sql, params });
-      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "SAVE_SCORE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { id }
-        },
-        error$1
-      );
-    }
-  }
-  async listScoresByScorerId({
-    scorerId,
-    entityId,
-    entityType,
-    source,
-    pagination,
-    filters
-  }) {
-    try {
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
-      const countQuery = createSqlBuilder().count().from(fullTableName).where("scorerId = ?", scorerId);
-      if (entityId) {
-        countQuery.andWhere("entityId = ?", entityId);
-      }
-      if (entityType) {
-        countQuery.andWhere("entityType = ?", entityType);
-      }
-      if (source) {
-        countQuery.andWhere("source = ?", source);
-      }
-      applyTenancyFilters(countQuery, filters);
-      const countResult = await this.#db.executeQuery(countQuery.build());
-      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
-      if (total === 0) {
-        return {
-          pagination: {
-            total: 0,
-            page,
-            perPage: perPageForResponse,
-            hasMore: false
-          },
-          scores: []
-        };
-      }
-      const end = perPageInput === false ? total : start + perPage;
-      const limitValue = perPageInput === false ? total : perPage;
-      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("scorerId = ?", scorerId);
-      if (entityId) {
-        selectQuery.andWhere("entityId = ?", entityId);
-      }
-      if (entityType) {
-        selectQuery.andWhere("entityType = ?", entityType);
-      }
-      if (source) {
-        selectQuery.andWhere("source = ?", source);
-      }
-      applyTenancyFilters(selectQuery, filters);
-      selectQuery.orderBy("createdAt", "DESC").limit(limitValue).offset(start);
-      const { sql, params } = selectQuery.build();
-      const results = await this.#db.executeQuery({ sql, params });
-      const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
-      return {
-        pagination: {
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
-        },
-        scores
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_SCORER_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  async listScoresByRunId({
-    runId,
-    pagination,
-    filters
-  }) {
-    try {
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
-      const countQuery = createSqlBuilder().count().from(fullTableName).where("runId = ?", runId);
-      applyTenancyFilters(countQuery, filters);
-      const countResult = await this.#db.executeQuery(countQuery.build());
-      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
-      if (total === 0) {
-        return {
-          pagination: {
-            total: 0,
-            page,
-            perPage: perPageForResponse,
-            hasMore: false
-          },
-          scores: []
-        };
-      }
-      const end = perPageInput === false ? total : start + perPage;
-      const limitValue = perPageInput === false ? total : perPage;
-      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("runId = ?", runId);
-      applyTenancyFilters(selectQuery, filters);
-      selectQuery.orderBy("createdAt", "DESC").limit(limitValue).offset(start);
-      const { sql, params } = selectQuery.build();
-      const results = await this.#db.executeQuery({ sql, params });
-      const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
-      return {
-        pagination: {
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
-        },
-        scores
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_RUN_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination,
-    filters
-  }) {
-    try {
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
-      const countQuery = createSqlBuilder().count().from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType);
-      applyTenancyFilters(countQuery, filters);
-      const countResult = await this.#db.executeQuery(countQuery.build());
-      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
-      if (total === 0) {
-        return {
-          pagination: {
-            total: 0,
-            page,
-            perPage: perPageForResponse,
-            hasMore: false
-          },
-          scores: []
-        };
-      }
-      const end = perPageInput === false ? total : start + perPage;
-      const limitValue = perPageInput === false ? total : perPage;
-      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType);
-      applyTenancyFilters(selectQuery, filters);
-      selectQuery.orderBy("createdAt", "DESC").limit(limitValue).offset(start);
-      const { sql, params } = selectQuery.build();
-      const results = await this.#db.executeQuery({ sql, params });
-      const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
-      return {
-        pagination: {
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
-        },
-        scores
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_ENTITY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination,
-    filters
-  }) {
-    try {
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const fullTableName = this.#db.getTableName(storage.TABLE_SCORERS);
-      const countQuery = createSqlBuilder().count().from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId);
-      applyTenancyFilters(countQuery, filters);
-      const countResult = await this.#db.executeQuery(countQuery.build());
-      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
-      if (total === 0) {
-        return {
-          pagination: {
-            total: 0,
-            page,
-            perPage: perPageForResponse,
-            hasMore: false
-          },
-          scores: []
-        };
-      }
-      const end = perPageInput === false ? total : start + perPage;
-      const limitValue = perPageInput === false ? total : perPage;
-      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId);
-      applyTenancyFilters(selectQuery, filters);
-      selectQuery.orderBy("createdAt", "DESC").limit(limitValue).offset(start);
-      const { sql, params } = selectQuery.build();
-      const results = await this.#db.executeQuery({ sql, params });
-      const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
-      return {
-        pagination: {
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
-        },
-        scores
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_SPAN", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
+var ScoresStorageD1 = class extends _mastra_core_storage.ScoresStorage {
+	#db;
+	constructor(config) {
+		super();
+		this.#db = new D1DB(resolveD1Config(config));
+	}
+	async init() {
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_SCORERS,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_SCORERS]
+		});
+		await this.#db.alterTable({
+			tableName: _mastra_core_storage.TABLE_SCORERS,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_SCORERS],
+			ifNotExists: [
+				"organizationId",
+				"projectId",
+				"batchId",
+				"datasetId",
+				"datasetItemId"
+			]
+		});
+	}
+	async dangerouslyClearAll() {
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_SCORERS });
+	}
+	async getScoreById({ id }) {
+		try {
+			const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_SCORERS);
+			const { sql, params } = createSqlBuilder().select("*").from(fullTableName).where("id = ?", id).build();
+			const result = await this.#db.executeQuery({
+				sql,
+				params,
+				first: true
+			});
+			if (!result) return null;
+			return transformScoreRow(result);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "GET_SCORE_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	async saveScore(score) {
+		let parsedScore;
+		try {
+			parsedScore = _mastra_core_evals.saveScorePayloadSchema.parse(score);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "SAVE_SCORE", "VALIDATION_FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: {
+					scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+					entityId: score.entityId ?? "unknown",
+					entityType: score.entityType ?? "unknown",
+					traceId: score.traceId ?? "",
+					spanId: score.spanId ?? ""
+				}
+			}, error);
+		}
+		const id = crypto.randomUUID();
+		try {
+			const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_SCORERS);
+			const serializedRecord = {};
+			for (const [key, value] of Object.entries(parsedScore)) if (value !== null && value !== void 0) if (typeof value === "object") serializedRecord[key] = JSON.stringify(value);
+			else serializedRecord[key] = value;
+			else serializedRecord[key] = null;
+			const now = /* @__PURE__ */ new Date();
+			serializedRecord.id = id;
+			serializedRecord.createdAt = now.toISOString();
+			serializedRecord.updatedAt = now.toISOString();
+			const columns = Object.keys(serializedRecord);
+			const values = Object.values(serializedRecord);
+			const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values).build();
+			await this.#db.executeQuery({
+				sql,
+				params
+			});
+			return { score: {
+				...parsedScore,
+				id,
+				createdAt: now,
+				updatedAt: now
+			} };
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "SAVE_SCORE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { id }
+			}, error);
+		}
+	}
+	async listScoresByScorerId({ scorerId, entityId, entityType, source, pagination, filters }) {
+		try {
+			const { page, perPage: perPageInput } = pagination;
+			const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+			const { offset: start, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_SCORERS);
+			const countQuery = createSqlBuilder().count().from(fullTableName).where("scorerId = ?", scorerId);
+			if (entityId) countQuery.andWhere("entityId = ?", entityId);
+			if (entityType) countQuery.andWhere("entityType = ?", entityType);
+			if (source) countQuery.andWhere("source = ?", source);
+			applyTenancyFilters(countQuery, filters);
+			const countResult = await this.#db.executeQuery(countQuery.build());
+			const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+			if (total === 0) return {
+				pagination: {
+					total: 0,
+					page,
+					perPage: perPageForResponse,
+					hasMore: false
+				},
+				scores: []
+			};
+			const end = perPageInput === false ? total : start + perPage;
+			const limitValue = perPageInput === false ? total : perPage;
+			const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("scorerId = ?", scorerId);
+			if (entityId) selectQuery.andWhere("entityId = ?", entityId);
+			if (entityType) selectQuery.andWhere("entityType = ?", entityType);
+			if (source) selectQuery.andWhere("source = ?", source);
+			applyTenancyFilters(selectQuery, filters);
+			selectQuery.orderBy("createdAt", "DESC").limit(limitValue).offset(start);
+			const { sql, params } = selectQuery.build();
+			const results = await this.#db.executeQuery({
+				sql,
+				params
+			});
+			const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
+			return {
+				pagination: {
+					total,
+					page,
+					perPage: perPageForResponse,
+					hasMore: end < total
+				},
+				scores
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "GET_SCORES_BY_SCORER_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	async listScoresByRunId({ runId, pagination, filters }) {
+		try {
+			const { page, perPage: perPageInput } = pagination;
+			const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+			const { offset: start, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_SCORERS);
+			const countQuery = createSqlBuilder().count().from(fullTableName).where("runId = ?", runId);
+			applyTenancyFilters(countQuery, filters);
+			const countResult = await this.#db.executeQuery(countQuery.build());
+			const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+			if (total === 0) return {
+				pagination: {
+					total: 0,
+					page,
+					perPage: perPageForResponse,
+					hasMore: false
+				},
+				scores: []
+			};
+			const end = perPageInput === false ? total : start + perPage;
+			const limitValue = perPageInput === false ? total : perPage;
+			const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("runId = ?", runId);
+			applyTenancyFilters(selectQuery, filters);
+			selectQuery.orderBy("createdAt", "DESC").limit(limitValue).offset(start);
+			const { sql, params } = selectQuery.build();
+			const results = await this.#db.executeQuery({
+				sql,
+				params
+			});
+			const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
+			return {
+				pagination: {
+					total,
+					page,
+					perPage: perPageForResponse,
+					hasMore: end < total
+				},
+				scores
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "GET_SCORES_BY_RUN_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	async listScoresByEntityId({ entityId, entityType, pagination, filters }) {
+		try {
+			const { page, perPage: perPageInput } = pagination;
+			const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+			const { offset: start, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_SCORERS);
+			const countQuery = createSqlBuilder().count().from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType);
+			applyTenancyFilters(countQuery, filters);
+			const countResult = await this.#db.executeQuery(countQuery.build());
+			const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+			if (total === 0) return {
+				pagination: {
+					total: 0,
+					page,
+					perPage: perPageForResponse,
+					hasMore: false
+				},
+				scores: []
+			};
+			const end = perPageInput === false ? total : start + perPage;
+			const limitValue = perPageInput === false ? total : perPage;
+			const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType);
+			applyTenancyFilters(selectQuery, filters);
+			selectQuery.orderBy("createdAt", "DESC").limit(limitValue).offset(start);
+			const { sql, params } = selectQuery.build();
+			const results = await this.#db.executeQuery({
+				sql,
+				params
+			});
+			const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
+			return {
+				pagination: {
+					total,
+					page,
+					perPage: perPageForResponse,
+					hasMore: end < total
+				},
+				scores
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "GET_SCORES_BY_ENTITY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	async listScoresBySpan({ traceId, spanId, pagination, filters }) {
+		try {
+			const { page, perPage: perPageInput } = pagination;
+			const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+			const { offset: start, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_SCORERS);
+			const countQuery = createSqlBuilder().count().from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId);
+			applyTenancyFilters(countQuery, filters);
+			const countResult = await this.#db.executeQuery(countQuery.build());
+			const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+			if (total === 0) return {
+				pagination: {
+					total: 0,
+					page,
+					perPage: perPageForResponse,
+					hasMore: false
+				},
+				scores: []
+			};
+			const end = perPageInput === false ? total : start + perPage;
+			const limitValue = perPageInput === false ? total : perPage;
+			const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId);
+			applyTenancyFilters(selectQuery, filters);
+			selectQuery.orderBy("createdAt", "DESC").limit(limitValue).offset(start);
+			const { sql, params } = selectQuery.build();
+			const results = await this.#db.executeQuery({
+				sql,
+				params
+			});
+			const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
+			return {
+				pagination: {
+					total,
+					page,
+					perPage: perPageForResponse,
+					hasMore: end < total
+				},
+				scores
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "GET_SCORES_BY_SPAN", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
 };
-var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
-  #db;
-  constructor(config) {
-    super();
-    this.#db = new D1DB(resolveD1Config(config));
-  }
-  supportsConcurrentUpdates() {
-    return false;
-  }
-  async init() {
-    await this.#db.createTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT, schema: storage.TABLE_SCHEMAS[storage.TABLE_WORKFLOW_SNAPSHOT] });
-  }
-  async dangerouslyClearAll() {
-    await this.#db.clearTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
-  }
-  async updateWorkflowResults(_args) {
-    throw new Error(
-      "updateWorkflowResults is not implemented for Cloudflare D1 storage. D1 does not support atomic read-modify-write operations needed for concurrent workflow updates."
-    );
-  }
-  async updateWorkflowState(_args) {
-    throw new Error(
-      "updateWorkflowState is not implemented for Cloudflare D1 storage. D1 does not support atomic read-modify-write operations needed for concurrent workflow updates."
-    );
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot,
-    createdAt,
-    updatedAt
-  }) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const currentSnapshot = await this.#db.load({
-      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-      keys: { workflow_name: workflowName, run_id: runId }
-    });
-    const persisting = currentSnapshot ? {
-      ...currentSnapshot,
-      resourceId,
-      snapshot: JSON.stringify(snapshot),
-      updatedAt: updatedAt ? updatedAt.toISOString() : now
-    } : {
-      workflow_name: workflowName,
-      run_id: runId,
-      resourceId,
-      snapshot,
-      createdAt: createdAt ? createdAt.toISOString() : now,
-      updatedAt: updatedAt ? updatedAt.toISOString() : now
-    };
-    const processedRecord = await this.#db.processRecord(persisting);
-    const columns = Object.keys(processedRecord);
-    const values = Object.values(processedRecord);
-    const updateMap = {
-      snapshot: "excluded.snapshot",
-      updatedAt: "excluded.updatedAt"
-    };
-    this.logger.debug("Persisting workflow snapshot", { workflowName, runId });
-    const query = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap);
-    const { sql, params } = query.build();
-    try {
-      await this.#db.executeQuery({ sql, params });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to persist workflow snapshot: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { workflowName, runId }
-        },
-        error$1
-      );
-    }
-  }
-  async loadWorkflowSnapshot(params) {
-    const { workflowName, runId } = params;
-    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
-    try {
-      const d = await this.#db.load({
-        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId
-        }
-      });
-      return d ? d.snapshot : null;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to load workflow snapshot: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { workflowName, runId }
-        },
-        error$1
-      );
-    }
-  }
-  parseWorkflowRun(row) {
-    let parsedSnapshot = row.snapshot;
-    if (typeof parsedSnapshot === "string") {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot);
-      } catch (e) {
-        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
-    }
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: storage.ensureDate(row.createdAt),
-      updatedAt: storage.ensureDate(row.updatedAt),
-      resourceId: row.resourceId
-    };
-  }
-  async listWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    page,
-    perPage,
-    resourceId,
-    status
-  } = {}) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
-    try {
-      const builder = createSqlBuilder().select().from(fullTableName);
-      const countBuilder = createSqlBuilder().count().from(fullTableName);
-      if (workflowName) builder.whereAnd("workflow_name = ?", workflowName);
-      if (status) {
-        builder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
-        countBuilder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
-      }
-      if (resourceId) {
-        const hasResourceId = await this.#db.hasColumn(fullTableName, "resourceId");
-        if (hasResourceId) {
-          builder.whereAnd("resourceId = ?", resourceId);
-          countBuilder.whereAnd("resourceId = ?", resourceId);
-        } else {
-          this.logger.warn(`[${fullTableName}] resourceId column not found. Skipping resourceId filter.`);
-        }
-      }
-      if (fromDate) {
-        builder.whereAnd("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
-        countBuilder.whereAnd("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
-      }
-      if (toDate) {
-        builder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
-        countBuilder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
-      }
-      builder.orderBy("createdAt", "DESC");
-      if (typeof perPage === "number" && typeof page === "number") {
-        const offset = page * perPage;
-        builder.limit(perPage);
-        builder.offset(offset);
-      }
-      const { sql, params } = builder.build();
-      let total = 0;
-      if (perPage !== void 0 && page !== void 0) {
-        const { sql: countSql, params: countParams } = countBuilder.build();
-        const countResult = await this.#db.executeQuery({
-          sql: countSql,
-          params: countParams,
-          first: true
-        });
-        total = Number(countResult?.count ?? 0);
-      }
-      const results = await this.#db.executeQuery({ sql, params });
-      const runs = (isArrayOfRecords(results) ? results : []).map((row) => this.parseWorkflowRun(row));
-      return { runs, total: total || runs.length };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "LIST_WORKFLOW_RUNS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve workflow runs: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: {
-            workflowName: workflowName ?? "",
-            resourceId: resourceId ?? ""
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
-    try {
-      const conditions = [];
-      const params = [];
-      if (runId) {
-        conditions.push("run_id = ?");
-        params.push(runId);
-      }
-      if (workflowName) {
-        conditions.push("workflow_name = ?");
-        params.push(workflowName);
-      }
-      const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
-      const sql = `SELECT * FROM ${fullTableName} ${whereClause} ORDER BY createdAt DESC LIMIT 1`;
-      const result = await this.#db.executeQuery({ sql, params, first: true });
-      if (!result) return null;
-      return this.parseWorkflowRun(result);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve workflow run by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { runId, workflowName: workflowName ?? "" }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteWorkflowRunById({ runId, workflowName }) {
-    const fullTableName = this.#db.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
-    try {
-      const sql = `DELETE FROM ${fullTableName} WHERE workflow_name = ? AND run_id = ?`;
-      const params = [workflowName, runId];
-      await this.#db.executeQuery({ sql, params });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to delete workflow run by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { runId, workflowName }
-        },
-        error$1
-      );
-    }
-  }
+//#endregion
+//#region src/storage/domains/workflows/index.ts
+var WorkflowsStorageD1 = class extends _mastra_core_storage.WorkflowsStorage {
+	#db;
+	constructor(config) {
+		super();
+		this.#db = new D1DB(resolveD1Config(config));
+	}
+	supportsConcurrentUpdates() {
+		return false;
+	}
+	async init() {
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT]
+		});
+	}
+	async dangerouslyClearAll() {
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT });
+	}
+	async updateWorkflowResults(_args) {
+		throw new Error("updateWorkflowResults is not implemented for Cloudflare D1 storage. D1 does not support atomic read-modify-write operations needed for concurrent workflow updates.");
+	}
+	async updateWorkflowState(_args) {
+		throw new Error("updateWorkflowState is not implemented for Cloudflare D1 storage. D1 does not support atomic read-modify-write operations needed for concurrent workflow updates.");
+	}
+	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt }) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const currentSnapshot = await this.#db.load({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+			keys: {
+				workflow_name: workflowName,
+				run_id: runId
+			}
+		});
+		const persisting = currentSnapshot ? {
+			...currentSnapshot,
+			resourceId,
+			snapshot: JSON.stringify(snapshot),
+			updatedAt: updatedAt ? updatedAt.toISOString() : now
+		} : {
+			workflow_name: workflowName,
+			run_id: runId,
+			resourceId,
+			snapshot,
+			createdAt: createdAt ? createdAt.toISOString() : now,
+			updatedAt: updatedAt ? updatedAt.toISOString() : now
+		};
+		const processedRecord = await this.#db.processRecord(persisting);
+		const columns = Object.keys(processedRecord);
+		const values = Object.values(processedRecord);
+		const updateMap = {
+			snapshot: "excluded.snapshot",
+			updatedAt: "excluded.updatedAt"
+		};
+		this.logger.debug("Persisting workflow snapshot", {
+			workflowName,
+			runId
+		});
+		const { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap).build();
+		try {
+			await this.#db.executeQuery({
+				sql,
+				params
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to persist workflow snapshot: ${error instanceof Error ? error.message : String(error)}`,
+				details: {
+					workflowName,
+					runId
+				}
+			}, error);
+		}
+	}
+	async loadWorkflowSnapshot(params) {
+		const { workflowName, runId } = params;
+		this.logger.debug("Loading workflow snapshot", {
+			workflowName,
+			runId
+		});
+		try {
+			const d = await this.#db.load({
+				tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+				keys: {
+					workflow_name: workflowName,
+					run_id: runId
+				}
+			});
+			return d ? d.snapshot : null;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to load workflow snapshot: ${error instanceof Error ? error.message : String(error)}`,
+				details: {
+					workflowName,
+					runId
+				}
+			}, error);
+		}
+	}
+	parseWorkflowRun(row) {
+		let parsedSnapshot = row.snapshot;
+		if (typeof parsedSnapshot === "string") try {
+			parsedSnapshot = JSON.parse(row.snapshot);
+		} catch (e) {
+			this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+		}
+		return {
+			workflowName: row.workflow_name,
+			runId: row.run_id,
+			snapshot: parsedSnapshot,
+			createdAt: (0, _mastra_core_storage.ensureDate)(row.createdAt),
+			updatedAt: (0, _mastra_core_storage.ensureDate)(row.updatedAt),
+			resourceId: row.resourceId
+		};
+	}
+	async listWorkflowRuns({ workflowName, fromDate, toDate, page, perPage, resourceId, status } = {}) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+		try {
+			const builder = createSqlBuilder().select().from(fullTableName);
+			const countBuilder = createSqlBuilder().count().from(fullTableName);
+			if (workflowName) builder.whereAnd("workflow_name = ?", workflowName);
+			if (status) {
+				builder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
+				countBuilder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
+			}
+			if (resourceId) if (await this.#db.hasColumn(fullTableName, "resourceId")) {
+				builder.whereAnd("resourceId = ?", resourceId);
+				countBuilder.whereAnd("resourceId = ?", resourceId);
+			} else this.logger.warn(`[${fullTableName}] resourceId column not found. Skipping resourceId filter.`);
+			if (fromDate) {
+				builder.whereAnd("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+				countBuilder.whereAnd("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+			}
+			if (toDate) {
+				builder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+				countBuilder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+			}
+			builder.orderBy("createdAt", "DESC");
+			if (typeof perPage === "number" && typeof page === "number") {
+				const offset = page * perPage;
+				builder.limit(perPage);
+				builder.offset(offset);
+			}
+			const { sql, params } = builder.build();
+			let total = 0;
+			if (perPage !== void 0 && page !== void 0) {
+				const { sql: countSql, params: countParams } = countBuilder.build();
+				const countResult = await this.#db.executeQuery({
+					sql: countSql,
+					params: countParams,
+					first: true
+				});
+				total = Number(countResult?.count ?? 0);
+			}
+			const results = await this.#db.executeQuery({
+				sql,
+				params
+			});
+			const runs = (isArrayOfRecords(results) ? results : []).map((row) => this.parseWorkflowRun(row));
+			return {
+				runs,
+				total: total || runs.length
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "LIST_WORKFLOW_RUNS", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to retrieve workflow runs: ${error instanceof Error ? error.message : String(error)}`,
+				details: {
+					workflowName: workflowName ?? "",
+					resourceId: resourceId ?? ""
+				}
+			}, error);
+		}
+	}
+	async getWorkflowRunById({ runId, workflowName }) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+		try {
+			const conditions = [];
+			const params = [];
+			if (runId) {
+				conditions.push("run_id = ?");
+				params.push(runId);
+			}
+			if (workflowName) {
+				conditions.push("workflow_name = ?");
+				params.push(workflowName);
+			}
+			const sql = `SELECT * FROM ${fullTableName} ${conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : ""} ORDER BY createdAt DESC LIMIT 1`;
+			const result = await this.#db.executeQuery({
+				sql,
+				params,
+				first: true
+			});
+			if (!result) return null;
+			return this.parseWorkflowRun(result);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to retrieve workflow run by ID: ${error instanceof Error ? error.message : String(error)}`,
+				details: {
+					runId,
+					workflowName: workflowName ?? ""
+				}
+			}, error);
+		}
+	}
+	async deleteWorkflowRunById({ runId, workflowName }) {
+		const fullTableName = this.#db.getTableName(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+		try {
+			const sql = `DELETE FROM ${fullTableName} WHERE workflow_name = ? AND run_id = ?`;
+			const params = [workflowName, runId];
+			await this.#db.executeQuery({
+				sql,
+				params
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to delete workflow run by ID: ${error instanceof Error ? error.message : String(error)}`,
+				details: {
+					runId,
+					workflowName
+				}
+			}, error);
+		}
+	}
 };
-
-// src/storage/index.ts
-var D1Store = class extends storage.MastraCompositeStore {
-  client;
-  binding;
-  tablePrefix;
-  stores;
-  /**
-   * Creates a new D1Store instance
-   * @param config Configuration for D1 access (either REST API or Workers Binding API)
-   */
-  constructor(config) {
-    try {
-      super({ id: config.id, name: "D1", disableInit: config.disableInit });
-      if (config.tablePrefix && !/^[a-zA-Z0-9_]*$/.test(config.tablePrefix)) {
-        throw new Error("Invalid tablePrefix: only letters, numbers, and underscores are allowed.");
-      }
-      this.tablePrefix = config.tablePrefix || "";
-      if ("binding" in config) {
-        if (!config.binding) {
-          throw new Error("D1 binding is required when using Workers Binding API");
-        }
-        this.binding = config.binding;
-        this.logger.info("Using D1 Workers Binding API");
-      } else if ("client" in config) {
-        if (!config.client) {
-          throw new Error("D1 client is required when using D1ClientConfig");
-        }
-        this.client = config.client;
-        this.logger.info("Using D1 Client");
-      } else {
-        if (!config.accountId || !config.databaseId || !config.apiToken) {
-          throw new Error("accountId, databaseId, and apiToken are required when using REST API");
-        }
-        const cfClient = new Cloudflare__default.default({
-          apiToken: config.apiToken
-        });
-        this.client = {
-          query: ({ sql, params }) => {
-            return cfClient.d1.database.query(config.databaseId, {
-              account_id: config.accountId,
-              sql,
-              params
-            });
-          }
-        };
-        this.logger.info("Using D1 REST API");
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("CLOUDFLARE_D1", "INITIALIZATION", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.SYSTEM,
-          text: "Error initializing D1Store"
-        },
-        error$1
-      );
-    }
-    let scores;
-    let workflows;
-    let memory;
-    let backgroundTasks;
-    if (this.binding) {
-      const domainConfig = { binding: this.binding, tablePrefix: this.tablePrefix };
-      scores = new ScoresStorageD1(domainConfig);
-      workflows = new WorkflowsStorageD1(domainConfig);
-      memory = new MemoryStorageD1(domainConfig);
-      backgroundTasks = new BackgroundTasksStorageD1(domainConfig);
-    } else {
-      const domainConfig = { client: this.client, tablePrefix: this.tablePrefix };
-      scores = new ScoresStorageD1(domainConfig);
-      workflows = new WorkflowsStorageD1(domainConfig);
-      memory = new MemoryStorageD1(domainConfig);
-      backgroundTasks = new BackgroundTasksStorageD1(domainConfig);
-    }
-    this.stores = {
-      scores,
-      workflows,
-      memory,
-      backgroundTasks
-    };
-  }
-  /**
-   * Close the database connection
-   * No explicit cleanup needed for D1 in either REST or Workers Binding mode
-   */
-  async close() {
-    this.logger.debug("Closing D1 connection");
-  }
+//#endregion
+//#region src/storage/index.ts
+/**
+* Cloudflare D1 storage adapter for Mastra.
+*
+* Access domain-specific storage via `getStore()`:
+*
+* @example
+* ```typescript
+* const storage = new D1Store({ id: 'my-store', accountId: '...', apiToken: '...', databaseId: '...' });
+*
+* // Access memory domain
+* const memory = await storage.getStore('memory');
+* await memory?.saveThread({ thread });
+*
+* // Access workflows domain
+* const workflows = await storage.getStore('workflows');
+* await workflows?.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+* ```
+*/
+var D1Store = class extends _mastra_core_storage.MastraCompositeStore {
+	client;
+	binding;
+	tablePrefix;
+	stores;
+	/**
+	* Creates a new D1Store instance
+	* @param config Configuration for D1 access (either REST API or Workers Binding API)
+	*/
+	constructor(config) {
+		try {
+			super({
+				id: config.id,
+				name: "D1",
+				disableInit: config.disableInit
+			});
+			if (config.tablePrefix && !/^[a-zA-Z0-9_]*$/.test(config.tablePrefix)) throw new Error("Invalid tablePrefix: only letters, numbers, and underscores are allowed.");
+			this.tablePrefix = config.tablePrefix || "";
+			if ("binding" in config) {
+				if (!config.binding) throw new Error("D1 binding is required when using Workers Binding API");
+				this.binding = config.binding;
+				this.logger.info("Using D1 Workers Binding API");
+			} else if ("client" in config) {
+				if (!config.client) throw new Error("D1 client is required when using D1ClientConfig");
+				this.client = config.client;
+				this.logger.info("Using D1 Client");
+			} else {
+				if (!config.accountId || !config.databaseId || !config.apiToken) throw new Error("accountId, databaseId, and apiToken are required when using REST API");
+				const cfClient = new cloudflare.default({ apiToken: config.apiToken });
+				this.client = { query: ({ sql, params }) => {
+					return cfClient.d1.database.query(config.databaseId, {
+						account_id: config.accountId,
+						sql,
+						params
+					});
+				} };
+				this.logger.info("Using D1 REST API");
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE_D1", "INITIALIZATION", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.SYSTEM,
+				text: "Error initializing D1Store"
+			}, error);
+		}
+		let scores;
+		let workflows;
+		let memory;
+		let backgroundTasks;
+		if (this.binding) {
+			const domainConfig = {
+				binding: this.binding,
+				tablePrefix: this.tablePrefix
+			};
+			scores = new ScoresStorageD1(domainConfig);
+			workflows = new WorkflowsStorageD1(domainConfig);
+			memory = new MemoryStorageD1(domainConfig);
+			backgroundTasks = new BackgroundTasksStorageD1(domainConfig);
+		} else {
+			const domainConfig = {
+				client: this.client,
+				tablePrefix: this.tablePrefix
+			};
+			scores = new ScoresStorageD1(domainConfig);
+			workflows = new WorkflowsStorageD1(domainConfig);
+			memory = new MemoryStorageD1(domainConfig);
+			backgroundTasks = new BackgroundTasksStorageD1(domainConfig);
+		}
+		this.stores = {
+			scores,
+			workflows,
+			memory,
+			backgroundTasks
+		};
+	}
+	/**
+	* Close the database connection
+	* No explicit cleanup needed for D1 in either REST or Workers Binding mode
+	*/
+	async close() {
+		this.logger.debug("Closing D1 connection");
+	}
 };
-
+//#endregion
 exports.BackgroundTasksStorageD1 = BackgroundTasksStorageD1;
 exports.D1Store = D1Store;
 exports.MemoryStorageD1 = MemoryStorageD1;
 exports.ScoresStorageD1 = ScoresStorageD1;
 exports.WorkflowsStorageD1 = WorkflowsStorageD1;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map