@mastra/duckdb 1.5.1 → 1.5.2

package/dist/index.cjs

@@ -1,339 +1,311 @@
-'use strict';
-
-var chunkSMRZJTCI_cjs = require('./chunk-SMRZJTCI.cjs');
-var nodeApi = require('@duckdb/node-api');
-var error = require('@mastra/core/error');
-var storage = require('@mastra/core/storage');
-var vector = require('@mastra/core/vector');
-var features = require('@mastra/core/features');
-
-// src/vector/filter-builder.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_db = require("./db-TBEcMD49.cjs");
+let _duckdb_node_api = require("@duckdb/node-api");
+let _mastra_core_error = require("@mastra/core/error");
+let _mastra_core_storage = require("@mastra/core/storage");
+let _mastra_core_vector = require("@mastra/core/vector");
+let _mastra_core_features = require("@mastra/core/features");
+//#region src/vector/filter-builder.ts
+/**
+* Escape a string for safe use in SQL.
+*/
 function escapeString(value) {
-  return value.replace(/'/g, "''");
+	return value.replace(/'/g, "''");
 }
+/**
+* Convert a value to a SQL literal for comparison with JSON-extracted values.
+* DuckDB's ->> operator returns the raw value without JSON quoting.
+*/
 function toSqlLiteral(value) {
-  if (value === null || value === void 0) {
-    return "NULL";
-  }
-  if (typeof value === "string") {
-    return `'${escapeString(value)}'`;
-  }
-  if (typeof value === "number") {
-    return String(value);
-  }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  }
-  return `'${escapeString(JSON.stringify(value))}'`;
+	if (value === null || value === void 0) return "NULL";
+	if (typeof value === "string") return `'${escapeString(value)}'`;
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "true" : "false";
+	return `'${escapeString(JSON.stringify(value))}'`;
 }
+/**
+* Build a SQL WHERE clause from a filter object.
+* Supports MongoDB-style query operators.
+*/
 function buildFilterClause(filter) {
-  if (!filter || Object.keys(filter).length === 0) {
-    return { clause: "1=1", params: [] };
-  }
-  const conditions = [];
-  for (const [key, value] of Object.entries(filter)) {
-    if (key === "$and") {
-      if (Array.isArray(value) && value.length > 0) {
-        const subConditions = value.map((subFilter) => buildFilterClause(subFilter));
-        const andClause = subConditions.map((sc) => `(${sc.clause})`).join(" AND ");
-        conditions.push(`(${andClause})`);
-      }
-      continue;
-    }
-    if (key === "$or") {
-      if (Array.isArray(value) && value.length > 0) {
-        const subConditions = value.map((subFilter) => buildFilterClause(subFilter));
-        const orClause = subConditions.map((sc) => `(${sc.clause})`).join(" OR ");
-        conditions.push(`(${orClause})`);
-      }
-      continue;
-    }
-    if (key === "$not") {
-      if (typeof value === "object" && value !== null) {
-        const subResult = buildFilterClause(value);
-        conditions.push(`NOT (${subResult.clause})`);
-      }
-      continue;
-    }
-    if (key === "$nor") {
-      if (Array.isArray(value) && value.length > 0) {
-        const subConditions = value.map((subFilter) => buildFilterClause(subFilter));
-        const norClause = subConditions.map((sc) => `(${sc.clause})`).join(" OR ");
-        conditions.push(`NOT (${norClause})`);
-      }
-      continue;
-    }
-    const fieldPath = buildJsonPath(key);
-    if (value === null) {
-      conditions.push(`${fieldPath} IS NULL`);
-    } else if (typeof value === "object" && !Array.isArray(value)) {
-      const operatorResult = buildOperatorCondition(key, value);
-      if (operatorResult) {
-        conditions.push(operatorResult);
-      }
-    } else {
-      conditions.push(`${fieldPath} = ${toSqlLiteral(value)}`);
-    }
-  }
-  if (conditions.length === 0) {
-    return { clause: "1=1", params: [] };
-  }
-  return { clause: conditions.join(" AND "), params: [] };
+	if (!filter || Object.keys(filter).length === 0) return {
+		clause: "1=1",
+		params: []
+	};
+	const conditions = [];
+	for (const [key, value] of Object.entries(filter)) {
+		if (key === "$and") {
+			if (Array.isArray(value) && value.length > 0) {
+				const andClause = value.map((subFilter) => buildFilterClause(subFilter)).map((sc) => `(${sc.clause})`).join(" AND ");
+				conditions.push(`(${andClause})`);
+			}
+			continue;
+		}
+		if (key === "$or") {
+			if (Array.isArray(value) && value.length > 0) {
+				const orClause = value.map((subFilter) => buildFilterClause(subFilter)).map((sc) => `(${sc.clause})`).join(" OR ");
+				conditions.push(`(${orClause})`);
+			}
+			continue;
+		}
+		if (key === "$not") {
+			if (typeof value === "object" && value !== null) {
+				const subResult = buildFilterClause(value);
+				conditions.push(`NOT (${subResult.clause})`);
+			}
+			continue;
+		}
+		if (key === "$nor") {
+			if (Array.isArray(value) && value.length > 0) {
+				const norClause = value.map((subFilter) => buildFilterClause(subFilter)).map((sc) => `(${sc.clause})`).join(" OR ");
+				conditions.push(`NOT (${norClause})`);
+			}
+			continue;
+		}
+		const fieldPath = buildJsonPath(key);
+		if (value === null) conditions.push(`${fieldPath} IS NULL`);
+		else if (typeof value === "object" && !Array.isArray(value)) {
+			const operatorResult = buildOperatorCondition(key, value);
+			if (operatorResult) conditions.push(operatorResult);
+		} else conditions.push(`${fieldPath} = ${toSqlLiteral(value)}`);
+	}
+	if (conditions.length === 0) return {
+		clause: "1=1",
+		params: []
+	};
+	return {
+		clause: conditions.join(" AND "),
+		params: []
+	};
 }
+/**
+* Build a JSON path expression for accessing nested fields in metadata.
+* DuckDB uses json_extract_string for extracting string values from JSON.
+*/
 function buildJsonPath(field) {
-  const parts = field.split(".");
-  const jsonPath = "$." + parts.map((p) => escapeString(p)).join(".");
-  return `json_extract_string(metadata, '${jsonPath}')`;
+	return `json_extract_string(metadata, '${"$." + field.split(".").map((p) => escapeString(p)).join(".")}')`;
 }
+/**
+* Build a condition from an operator object.
+*/
 function buildOperatorCondition(field, operators) {
-  const conditions = [];
-  const fieldPath = buildJsonPath(field);
-  for (const [op, value] of Object.entries(operators)) {
-    switch (op) {
-      case "$eq":
-        if (value === null) {
-          conditions.push(`${fieldPath} IS NULL`);
-        } else {
-          conditions.push(`${fieldPath} = ${toSqlLiteral(value)}`);
-        }
-        break;
-      case "$ne":
-        if (value === null) {
-          conditions.push(`${fieldPath} IS NOT NULL`);
-        } else {
-          conditions.push(`${fieldPath} != ${toSqlLiteral(value)}`);
-        }
-        break;
-      case "$gt":
-        conditions.push(`CAST(${fieldPath} AS DOUBLE) > ${toSqlLiteral(value)}`);
-        break;
-      case "$gte":
-        conditions.push(`CAST(${fieldPath} AS DOUBLE) >= ${toSqlLiteral(value)}`);
-        break;
-      case "$lt":
-        conditions.push(`CAST(${fieldPath} AS DOUBLE) < ${toSqlLiteral(value)}`);
-        break;
-      case "$lte":
-        conditions.push(`CAST(${fieldPath} AS DOUBLE) <= ${toSqlLiteral(value)}`);
-        break;
-      case "$in":
-        if (Array.isArray(value) && value.length > 0) {
-          const jsonPath = `json_extract(metadata, '$.${escapeString(field)}')`;
-          const literals = value.map((v) => toSqlLiteral(v)).join(", ");
-          const stringLiterals = value.map((v) => toSqlLiteral(String(v))).join(", ");
-          conditions.push(
-            `(list_has_any(TRY_CAST(${jsonPath} AS VARCHAR[]), [${stringLiterals}]) OR ${fieldPath} IN (${literals}))`
-          );
-        } else {
-          conditions.push("1=0");
-        }
-        break;
-      case "$nin":
-        if (Array.isArray(value) && value.length > 0) {
-          const literals = value.map((v) => toSqlLiteral(v)).join(", ");
-          conditions.push(`${fieldPath} NOT IN (${literals})`);
-        }
-        break;
-      case "$exists":
-        if (value) {
-          conditions.push(`${fieldPath} IS NOT NULL`);
-        } else {
-          conditions.push(`${fieldPath} IS NULL`);
-        }
-        break;
-      case "$contains":
-        if (typeof value === "string") {
-          conditions.push(`${fieldPath} LIKE '%${escapeString(value)}%'`);
-        } else if (Array.isArray(value)) {
-          const jsonPath = `json_extract(metadata, '$.${escapeString(field)}')`;
-          const arrayConditions = value.map((v) => {
-            return `list_contains(TRY_CAST(${jsonPath} AS VARCHAR[]), ${toSqlLiteral(v)})`;
-          });
-          conditions.push(`(${arrayConditions.join(" AND ")})`);
-        } else {
-          conditions.push(`${fieldPath} = ${toSqlLiteral(value)}`);
-        }
-        break;
-      case "$all":
-        if (Array.isArray(value) && value.length > 0) {
-          const jsonPath = `json_extract(metadata, '$.${escapeString(field)}')`;
-          const arrayConditions = value.map((v) => {
-            return `list_contains(TRY_CAST(${jsonPath} AS VARCHAR[]), ${toSqlLiteral(v)})`;
-          });
-          conditions.push(`(${arrayConditions.join(" AND ")})`);
-        }
-        break;
-      case "$not":
-        if (typeof value === "object" && value !== null) {
-          const subResult = buildOperatorCondition(field, value);
-          if (subResult) {
-            conditions.push(`NOT (${subResult})`);
-          }
-        }
-        break;
-      default:
-        throw new Error(`Unsupported operator: ${op}`);
-    }
-  }
-  if (conditions.length === 0) {
-    return null;
-  }
-  return conditions.join(" AND ");
+	const conditions = [];
+	const fieldPath = buildJsonPath(field);
+	for (const [op, value] of Object.entries(operators)) switch (op) {
+		case "$eq":
+			if (value === null) conditions.push(`${fieldPath} IS NULL`);
+			else conditions.push(`${fieldPath} = ${toSqlLiteral(value)}`);
+			break;
+		case "$ne":
+			if (value === null) conditions.push(`${fieldPath} IS NOT NULL`);
+			else conditions.push(`${fieldPath} != ${toSqlLiteral(value)}`);
+			break;
+		case "$gt":
+			conditions.push(`CAST(${fieldPath} AS DOUBLE) > ${toSqlLiteral(value)}`);
+			break;
+		case "$gte":
+			conditions.push(`CAST(${fieldPath} AS DOUBLE) >= ${toSqlLiteral(value)}`);
+			break;
+		case "$lt":
+			conditions.push(`CAST(${fieldPath} AS DOUBLE) < ${toSqlLiteral(value)}`);
+			break;
+		case "$lte":
+			conditions.push(`CAST(${fieldPath} AS DOUBLE) <= ${toSqlLiteral(value)}`);
+			break;
+		case "$in":
+			if (Array.isArray(value) && value.length > 0) {
+				const jsonPath = `json_extract(metadata, '$.${escapeString(field)}')`;
+				const literals = value.map((v) => toSqlLiteral(v)).join(", ");
+				const stringLiterals = value.map((v) => toSqlLiteral(String(v))).join(", ");
+				conditions.push(`(list_has_any(TRY_CAST(${jsonPath} AS VARCHAR[]), [${stringLiterals}]) OR ${fieldPath} IN (${literals}))`);
+			} else conditions.push("1=0");
+			break;
+		case "$nin":
+			if (Array.isArray(value) && value.length > 0) {
+				const literals = value.map((v) => toSqlLiteral(v)).join(", ");
+				conditions.push(`${fieldPath} NOT IN (${literals})`);
+			}
+			break;
+		case "$exists":
+			if (value) conditions.push(`${fieldPath} IS NOT NULL`);
+			else conditions.push(`${fieldPath} IS NULL`);
+			break;
+		case "$contains":
+			if (typeof value === "string") conditions.push(`${fieldPath} LIKE '%${escapeString(value)}%'`);
+			else if (Array.isArray(value)) {
+				const jsonPath = `json_extract(metadata, '$.${escapeString(field)}')`;
+				const arrayConditions = value.map((v) => {
+					return `list_contains(TRY_CAST(${jsonPath} AS VARCHAR[]), ${toSqlLiteral(v)})`;
+				});
+				conditions.push(`(${arrayConditions.join(" AND ")})`);
+			} else conditions.push(`${fieldPath} = ${toSqlLiteral(value)}`);
+			break;
+		case "$all":
+			if (Array.isArray(value) && value.length > 0) {
+				const jsonPath = `json_extract(metadata, '$.${escapeString(field)}')`;
+				const arrayConditions = value.map((v) => {
+					return `list_contains(TRY_CAST(${jsonPath} AS VARCHAR[]), ${toSqlLiteral(v)})`;
+				});
+				conditions.push(`(${arrayConditions.join(" AND ")})`);
+			}
+			break;
+		case "$not":
+			if (typeof value === "object" && value !== null) {
+				const subResult = buildOperatorCondition(field, value);
+				if (subResult) conditions.push(`NOT (${subResult})`);
+			}
+			break;
+		default: throw new Error(`Unsupported operator: ${op}`);
+	}
+	if (conditions.length === 0) return null;
+	return conditions.join(" AND ");
 }
-
-// src/vector/index.ts
-var DuckDBVector = class extends vector.MastraVector {
-  config;
-  instance = null;
-  initialized = false;
-  initPromise = null;
-  constructor(config) {
-    super({ id: config.id });
-    this.config = {
-      path: ":memory:",
-      dimensions: 1536,
-      metric: "cosine",
-      ...config
-    };
-  }
-  /**
-   * Initialize the database connection and load required extensions.
-   */
-  async initialize() {
-    if (this.initialized && this.instance) return;
-    if (this.initPromise) {
-      await this.initPromise;
-      if (!this.instance) {
-        this.initPromise = null;
-        this.initialized = false;
-      } else {
-        return;
-      }
-    }
-    this.initPromise = (async () => {
-      try {
-        this.instance = await nodeApi.DuckDBInstance.create(this.config.path);
-        const connection = await this.instance.connect();
-        try {
-          await connection.run("INSTALL vss;");
-          await connection.run("LOAD vss;");
-        } catch {
-          try {
-            await connection.run("LOAD vss;");
-          } catch {
-            this.logger.warn("VSS extension not available, using basic array operations");
-          }
-        }
-        this.initialized = true;
-      } catch (error) {
-        this.instance = null;
-        this.initialized = false;
-        this.initPromise = null;
-        throw error;
-      }
-    })();
-    return this.initPromise;
-  }
-  /**
-   * Get a database connection.
-   */
-  async getConnection() {
-    await this.initialize();
-    if (!this.instance) {
-      throw new Error("DuckDB instance not initialized");
-    }
-    return this.instance.connect();
-  }
-  /**
-   * Execute a SQL query and return results.
-   */
-  async runQuery(sql, params = []) {
-    const connection = await this.getConnection();
-    try {
-      let paramIndex = 0;
-      const preparedSql = sql.replace(/\?/g, () => `$${++paramIndex}`);
-      const stmt = await connection.prepare(preparedSql);
-      for (let i = 0; i < params.length; i++) {
-        chunkSMRZJTCI_cjs.bindParam(stmt, i + 1, params[i]);
-      }
-      const result = await stmt.run();
-      const rows = await result.getRows();
-      const columns = result.columnNames();
-      return rows.map((row) => {
-        const obj = {};
-        columns.forEach((col, i) => {
-          obj[col] = row[i];
-        });
-        return obj;
-      });
-    } finally {
-    }
-  }
-  /**
-   * Execute a SQL statement without returning results.
-   */
-  async runStatement(sql, params = []) {
-    const connection = await this.getConnection();
-    try {
-      if (params.length === 0) {
-        await connection.run(sql);
-      } else {
-        let paramIndex = 0;
-        const preparedSql = sql.replace(/\?/g, () => `$${++paramIndex}`);
-        const stmt = await connection.prepare(preparedSql);
-        for (let i = 0; i < params.length; i++) {
-          chunkSMRZJTCI_cjs.bindParam(stmt, i + 1, params[i]);
-        }
-        await stmt.run();
-      }
-    } finally {
-    }
-  }
-  /**
-   * Validate and escape a SQL identifier (table name, column name).
-   */
-  escapeIdentifier(name) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
-      throw new Error(`Invalid identifier: ${name}. Only alphanumeric characters and underscores are allowed.`);
-    }
-    return `"${name}"`;
-  }
-  /**
-   * Get the distance function for the configured metric.
-   */
-  getDistanceFunction() {
-    switch (this.config.metric) {
-      case "cosine":
-        return "array_cosine_distance";
-      case "euclidean":
-        return "array_distance";
-      case "dotproduct":
-        return "array_inner_product";
-      default:
-        return "array_cosine_distance";
-    }
-  }
-  /** Perform a vector similarity search with optional metadata filtering. */
-  async query(params) {
-    await this.initialize();
-    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
-    if (!queryVector) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("DUCKDB", "QUERY", "MISSING_VECTOR"),
-        text: "queryVector is required for DuckDB queries. Metadata-only queries are not supported by this vector store.",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    vector.validateTopK("DUCKDB", topK);
-    const tableName = this.escapeIdentifier(indexName);
-    const distanceFunc = this.getDistanceFunction();
-    const vectorLiteral = `[${queryVector.join(", ")}]::FLOAT[${queryVector.length}]`;
-    const { clause: filterClause } = filter ? buildFilterClause(filter) : { clause: "" };
-    const selectCols = includeVector ? "id, vector, metadata, distance" : "id, metadata, distance";
-    const sql = `
-      SELECT ${selectCols}
+//#endregion
+//#region src/vector/index.ts
+/**
+* DuckDB vector store implementation for Mastra.
+*
+* Provides embedded high-performance vector storage with HNSW indexing
+* using the DuckDB VSS extension for vector similarity search.
+*
+* Key features:
+* - Embedded database (no server required)
+* - HNSW indexing for fast similarity search
+* - SQL interface for metadata filtering
+* - Native Parquet support
+*/
+var DuckDBVector = class extends _mastra_core_vector.MastraVector {
+	config;
+	instance = null;
+	initialized = false;
+	initPromise = null;
+	constructor(config) {
+		super({ id: config.id });
+		this.config = {
+			path: ":memory:",
+			dimensions: 1536,
+			metric: "cosine",
+			...config
+		};
+	}
+	/**
+	* Initialize the database connection and load required extensions.
+	*/
+	async initialize() {
+		if (this.initialized && this.instance) return;
+		if (this.initPromise) {
+			await this.initPromise;
+			if (!this.instance) {
+				this.initPromise = null;
+				this.initialized = false;
+			} else return;
+		}
+		this.initPromise = (async () => {
+			try {
+				this.instance = await _duckdb_node_api.DuckDBInstance.create(this.config.path);
+				const connection = await this.instance.connect();
+				try {
+					await connection.run("INSTALL vss;");
+					await connection.run("LOAD vss;");
+				} catch {
+					try {
+						await connection.run("LOAD vss;");
+					} catch {
+						this.logger.warn("VSS extension not available, using basic array operations");
+					}
+				}
+				this.initialized = true;
+			} catch (error) {
+				this.instance = null;
+				this.initialized = false;
+				this.initPromise = null;
+				throw error;
+			}
+		})();
+		return this.initPromise;
+	}
+	/**
+	* Get a database connection.
+	*/
+	async getConnection() {
+		await this.initialize();
+		if (!this.instance) throw new Error("DuckDB instance not initialized");
+		return this.instance.connect();
+	}
+	/**
+	* Execute a SQL query and return results.
+	*/
+	async runQuery(sql, params = []) {
+		const connection = await this.getConnection();
+		try {
+			let paramIndex = 0;
+			const preparedSql = sql.replace(/\?/g, () => `$${++paramIndex}`);
+			const stmt = await connection.prepare(preparedSql);
+			for (let i = 0; i < params.length; i++) require_db.bindParam(stmt, i + 1, params[i]);
+			const result = await stmt.run();
+			const rows = await result.getRows();
+			const columns = result.columnNames();
+			return rows.map((row) => {
+				const obj = {};
+				columns.forEach((col, i) => {
+					obj[col] = row[i];
+				});
+				return obj;
+			});
+		} finally {}
+	}
+	/**
+	* Execute a SQL statement without returning results.
+	*/
+	async runStatement(sql, params = []) {
+		const connection = await this.getConnection();
+		try {
+			if (params.length === 0) await connection.run(sql);
+			else {
+				let paramIndex = 0;
+				const preparedSql = sql.replace(/\?/g, () => `$${++paramIndex}`);
+				const stmt = await connection.prepare(preparedSql);
+				for (let i = 0; i < params.length; i++) require_db.bindParam(stmt, i + 1, params[i]);
+				await stmt.run();
+			}
+		} finally {}
+	}
+	/**
+	* Validate and escape a SQL identifier (table name, column name).
+	*/
+	escapeIdentifier(name) {
+		if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) throw new Error(`Invalid identifier: ${name}. Only alphanumeric characters and underscores are allowed.`);
+		return `"${name}"`;
+	}
+	/**
+	* Get the distance function for the configured metric.
+	*/
+	getDistanceFunction() {
+		switch (this.config.metric) {
+			case "cosine": return "array_cosine_distance";
+			case "euclidean": return "array_distance";
+			case "dotproduct": return "array_inner_product";
+			default: return "array_cosine_distance";
+		}
+	}
+	/** Perform a vector similarity search with optional metadata filtering. */
+	async query(params) {
+		await this.initialize();
+		const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
+		if (!queryVector) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("DUCKDB", "QUERY", "MISSING_VECTOR"),
+			text: "queryVector is required for DuckDB queries. Metadata-only queries are not supported by this vector store.",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		(0, _mastra_core_vector.validateTopK)("DUCKDB", topK);
+		const tableName = this.escapeIdentifier(indexName);
+		const distanceFunc = this.getDistanceFunction();
+		const vectorLiteral = `[${queryVector.join(", ")}]::FLOAT[${queryVector.length}]`;
+		const { clause: filterClause } = filter ? buildFilterClause(filter) : { clause: "" };
+		const sql = `
+      SELECT ${includeVector ? "id, vector, metadata, distance" : "id, metadata, distance"}
       FROM (
         SELECT 
           id,
@@ -346,509 +318,440 @@ var DuckDBVector = class extends vector.MastraVector {
       ORDER BY distance ${this.config.metric === "dotproduct" ? "DESC" : "ASC"}
       LIMIT ${topK}
     `;
-    const connection = await this.getConnection();
-    const result = await connection.run(sql);
-    const rows = await result.getRows();
-    const columns = result.columnNames();
-    return rows.map((row) => {
-      const rowObj = {};
-      columns.forEach((col, i) => {
-        rowObj[col] = row[i];
-      });
-      const distance = rowObj.distance;
-      const score = this.config.metric === "cosine" ? 1 - distance : this.config.metric === "euclidean" ? 1 / (1 + distance) : distance;
-      const metadata = typeof rowObj.metadata === "string" ? JSON.parse(rowObj.metadata) : rowObj.metadata;
-      const queryResult = {
-        id: rowObj.id,
-        score,
-        metadata
-      };
-      if (includeVector && rowObj.vector) {
-        queryResult.vector = Array.isArray(rowObj.vector) ? rowObj.vector : JSON.parse(rowObj.vector);
-      }
-      return queryResult;
-    });
-  }
-  /** Insert or replace vectors with metadata. Returns the vector IDs. */
-  async upsert(params) {
-    await this.initialize();
-    const { indexName, vectors, metadata, ids } = params;
-    vector.validateUpsertInput("DUCKDB", vectors, metadata, ids);
-    const tableName = this.escapeIdentifier(indexName);
-    const vectorIds = ids || vectors.map(() => crypto.randomUUID());
-    for (let i = 0; i < vectors.length; i++) {
-      const id = vectorIds[i];
-      const vector = vectors[i];
-      const meta = metadata?.[i] || {};
-      const vectorLiteral = `[${vector.join(", ")}]::FLOAT[${vector.length}]`;
-      const metadataJson = JSON.stringify(meta);
-      const sql = `
+		const result = await (await this.getConnection()).run(sql);
+		const rows = await result.getRows();
+		const columns = result.columnNames();
+		return rows.map((row) => {
+			const rowObj = {};
+			columns.forEach((col, i) => {
+				rowObj[col] = row[i];
+			});
+			const distance = rowObj.distance;
+			const score = this.config.metric === "cosine" ? 1 - distance : this.config.metric === "euclidean" ? 1 / (1 + distance) : distance;
+			const metadata = typeof rowObj.metadata === "string" ? JSON.parse(rowObj.metadata) : rowObj.metadata;
+			const queryResult = {
+				id: rowObj.id,
+				score,
+				metadata
+			};
+			if (includeVector && rowObj.vector) queryResult.vector = Array.isArray(rowObj.vector) ? rowObj.vector : JSON.parse(rowObj.vector);
+			return queryResult;
+		});
+	}
+	/** Insert or replace vectors with metadata. Returns the vector IDs. */
+	async upsert(params) {
+		await this.initialize();
+		const { indexName, vectors, metadata, ids } = params;
+		(0, _mastra_core_vector.validateUpsertInput)("DUCKDB", vectors, metadata, ids);
+		const tableName = this.escapeIdentifier(indexName);
+		const vectorIds = ids || vectors.map(() => crypto.randomUUID());
+		for (let i = 0; i < vectors.length; i++) {
+			const id = vectorIds[i];
+			const vector = vectors[i];
+			const meta = metadata?.[i] || {};
+			const sql = `
         INSERT OR REPLACE INTO ${tableName} (id, vector, metadata)
-        VALUES (?, ${vectorLiteral}, '${metadataJson.replace(/'/g, "''")}')
+        VALUES (?, ${`[${vector.join(", ")}]::FLOAT[${vector.length}]`}, '${JSON.stringify(meta).replace(/'/g, "''")}')
       `;
-      await this.runStatement(sql, [id]);
-    }
-    return vectorIds;
-  }
-  /** Create a vector table with HNSW index for similarity search. */
-  async createIndex(params) {
-    await this.initialize();
-    const { indexName, dimension, metric } = params;
-    const tableName = this.escapeIdentifier(indexName);
-    if (metric) {
-      this.config.metric = metric;
-    }
-    const connection = await this.getConnection();
-    const createTableSql = `
+			await this.runStatement(sql, [id]);
+		}
+		return vectorIds;
+	}
+	/** Create a vector table with HNSW index for similarity search. */
+	async createIndex(params) {
+		await this.initialize();
+		const { indexName, dimension, metric } = params;
+		const tableName = this.escapeIdentifier(indexName);
+		if (metric) this.config.metric = metric;
+		const connection = await this.getConnection();
+		const createTableSql = `
       CREATE TABLE IF NOT EXISTS ${tableName} (
         id VARCHAR PRIMARY KEY,
         vector FLOAT[${dimension}],
         metadata JSON
       )
     `;
-    await connection.run(createTableSql);
-    try {
-      const indexNameStr = `${indexName}_hnsw_idx`;
-      const createIndexSql = `
-        CREATE INDEX IF NOT EXISTS "${indexNameStr}"
+		await connection.run(createTableSql);
+		try {
+			const createIndexSql = `
+        CREATE INDEX IF NOT EXISTS "${`${indexName}_hnsw_idx`}"
         ON ${tableName}
         USING HNSW (vector)
       `;
-      await connection.run(createIndexSql);
-    } catch {
-      this.logger.warn(`Could not create HNSW index for ${indexName}, falling back to linear scan`);
-    }
-  }
-  /** List all vector table names in the database. */
-  async listIndexes() {
-    await this.initialize();
-    const connection = await this.getConnection();
-    const result = await connection.run(`
+			await connection.run(createIndexSql);
+		} catch {
+			this.logger.warn(`Could not create HNSW index for ${indexName}, falling back to linear scan`);
+		}
+	}
+	/** List all vector table names in the database. */
+	async listIndexes() {
+		await this.initialize();
+		return (await (await (await this.getConnection()).run(`
       SELECT table_name
       FROM information_schema.tables
       WHERE table_schema = 'main'
         AND table_type = 'BASE TABLE'
-    `);
-    const rows = await result.getRows();
-    return rows.map((row) => row[0]);
-  }
-  /** Return dimension, row count, and metric for a vector index. */
-  async describeIndex(params) {
-    await this.initialize();
-    const { indexName } = params;
-    const tableName = this.escapeIdentifier(indexName);
-    const connection = await this.getConnection();
-    const schemaResult = await connection.run(`
+    `)).getRows()).map((row) => row[0]);
+	}
+	/** Return dimension, row count, and metric for a vector index. */
+	async describeIndex(params) {
+		await this.initialize();
+		const { indexName } = params;
+		const tableName = this.escapeIdentifier(indexName);
+		const connection = await this.getConnection();
+		const schemaRows = await (await connection.run(`
       SELECT data_type
       FROM information_schema.columns
       WHERE table_name = '${indexName}' AND column_name = 'vector'
-    `);
-    const schemaRows = await schemaResult.getRows();
-    if (schemaRows.length === 0) {
-      throw new Error(`Index "${indexName}" not found`);
-    }
-    const dataType = schemaRows[0][0];
-    const dimensionMatch = dataType.match(/\[(\d+)\]/);
-    const dimension = dimensionMatch ? parseInt(dimensionMatch[1], 10) : 0;
-    const countResult = await connection.run(`SELECT COUNT(*) as count FROM ${tableName}`);
-    const countRows = await countResult.getRows();
-    const count = Number(countRows[0]?.[0] || 0);
-    return {
-      dimension,
-      count,
-      metric: this.config.metric || "cosine"
-    };
-  }
-  /** Drop a vector table and its HNSW index. */
-  async deleteIndex(params) {
-    await this.initialize();
-    const { indexName } = params;
-    const tableName = this.escapeIdentifier(indexName);
-    const connection = await this.getConnection();
-    await connection.run(`DROP TABLE IF EXISTS ${tableName}`);
-  }
-  /** Update a vector's embedding and/or metadata by ID or filter. */
-  async updateVector(params) {
-    await this.initialize();
-    const { indexName, update } = params;
-    const tableName = this.escapeIdentifier(indexName);
-    if (!update.vector && !update.metadata) {
-      throw new Error("No updates provided");
-    }
-    const hasId = "id" in params && params.id;
-    const hasFilter = "filter" in params && params.filter;
-    if (hasId && hasFilter) {
-      throw new Error("id and filter are mutually exclusive - provide only one");
-    }
-    if (!hasId && !hasFilter) {
-      throw new Error("Either id or filter must be provided");
-    }
-    const updates = [];
-    if (update.vector) {
-      updates.push(`vector = [${update.vector.join(", ")}]::FLOAT[${update.vector.length}]`);
-    }
-    if (update.metadata) {
-      const metadataJson = JSON.stringify(update.metadata).replace(/'/g, "''");
-      updates.push(`metadata = '${metadataJson}'`);
-    }
-    if (hasId) {
-      const sql = `UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = ?`;
-      await this.runStatement(sql, [params.id]);
-    } else if (hasFilter) {
-      const filter = params.filter;
-      if (Object.keys(filter).length === 0) {
-        throw new Error("Cannot update with empty filter");
-      }
-      const { clause } = buildFilterClause(filter);
-      await this.runStatement(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE ${clause}`);
-    }
-  }
-  /** Delete a single vector by ID. */
-  async deleteVector(params) {
-    await this.initialize();
-    const { indexName, id } = params;
-    const tableName = this.escapeIdentifier(indexName);
-    const sql = `DELETE FROM ${tableName} WHERE id = ?`;
-    await this.runStatement(sql, [id]);
-  }
-  /** Delete multiple vectors by IDs or metadata filter (mutually exclusive). */
-  async deleteVectors(params) {
-    await this.initialize();
-    const { indexName, ids, filter } = params;
-    const tableName = this.escapeIdentifier(indexName);
-    if (!ids && !filter) {
-      throw new Error("Either filter or ids must be provided");
-    }
-    if (ids && filter) {
-      throw new Error("ids and filter are mutually exclusive - provide only one");
-    }
-    if (ids) {
-      if (ids.length === 0) {
-        throw new Error("Cannot delete with empty ids array");
-      }
-      const placeholders = ids.map(() => "?").join(", ");
-      const sql = `DELETE FROM ${tableName} WHERE id IN (${placeholders})`;
-      await this.runStatement(sql, ids);
-    } else if (filter) {
-      if (Object.keys(filter).length === 0) {
-        throw new Error("Cannot delete with empty filter");
-      }
-      const { clause } = buildFilterClause(filter);
-      await this.runStatement(`DELETE FROM ${tableName} WHERE ${clause}`);
-    }
-  }
-  /**
-   * Close the database connection.
-   * After closing, the vector store can be reused by calling methods that require initialization.
-   */
-  async close() {
-    if (this.instance) {
-      this.instance = null;
-      this.initialized = false;
-      this.initPromise = null;
-    }
-  }
+    `)).getRows();
+		if (schemaRows.length === 0) throw new Error(`Index "${indexName}" not found`);
+		const dimensionMatch = schemaRows[0][0].match(/\[(\d+)\]/);
+		const dimension = dimensionMatch ? parseInt(dimensionMatch[1], 10) : 0;
+		const countRows = await (await connection.run(`SELECT COUNT(*) as count FROM ${tableName}`)).getRows();
+		return {
+			dimension,
+			count: Number(countRows[0]?.[0] || 0),
+			metric: this.config.metric || "cosine"
+		};
+	}
+	/** Drop a vector table and its HNSW index. */
+	async deleteIndex(params) {
+		await this.initialize();
+		const { indexName } = params;
+		const tableName = this.escapeIdentifier(indexName);
+		await (await this.getConnection()).run(`DROP TABLE IF EXISTS ${tableName}`);
+	}
+	/** Update a vector's embedding and/or metadata by ID or filter. */
+	async updateVector(params) {
+		await this.initialize();
+		const { indexName, update } = params;
+		const tableName = this.escapeIdentifier(indexName);
+		if (!update.vector && !update.metadata) throw new Error("No updates provided");
+		const hasId = "id" in params && params.id;
+		const hasFilter = "filter" in params && params.filter;
+		if (hasId && hasFilter) throw new Error("id and filter are mutually exclusive - provide only one");
+		if (!hasId && !hasFilter) throw new Error("Either id or filter must be provided");
+		const updates = [];
+		if (update.vector) updates.push(`vector = [${update.vector.join(", ")}]::FLOAT[${update.vector.length}]`);
+		if (update.metadata) {
+			const metadataJson = JSON.stringify(update.metadata).replace(/'/g, "''");
+			updates.push(`metadata = '${metadataJson}'`);
+		}
+		if (hasId) {
+			const sql = `UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = ?`;
+			await this.runStatement(sql, [params.id]);
+		} else if (hasFilter) {
+			const filter = params.filter;
+			if (Object.keys(filter).length === 0) throw new Error("Cannot update with empty filter");
+			const { clause } = buildFilterClause(filter);
+			await this.runStatement(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE ${clause}`);
+		}
+	}
+	/** Delete a single vector by ID. */
+	async deleteVector(params) {
+		await this.initialize();
+		const { indexName, id } = params;
+		const sql = `DELETE FROM ${this.escapeIdentifier(indexName)} WHERE id = ?`;
+		await this.runStatement(sql, [id]);
+	}
+	/** Delete multiple vectors by IDs or metadata filter (mutually exclusive). */
+	async deleteVectors(params) {
+		await this.initialize();
+		const { indexName, ids, filter } = params;
+		const tableName = this.escapeIdentifier(indexName);
+		if (!ids && !filter) throw new Error("Either filter or ids must be provided");
+		if (ids && filter) throw new Error("ids and filter are mutually exclusive - provide only one");
+		if (ids) {
+			if (ids.length === 0) throw new Error("Cannot delete with empty ids array");
+			const sql = `DELETE FROM ${tableName} WHERE id IN (${ids.map(() => "?").join(", ")})`;
+			await this.runStatement(sql, ids);
+		} else if (filter) {
+			if (Object.keys(filter).length === 0) throw new Error("Cannot delete with empty filter");
+			const { clause } = buildFilterClause(filter);
+			await this.runStatement(`DELETE FROM ${tableName} WHERE ${clause}`);
+		}
+	}
+	/**
+	* Close the database connection.
+	* After closing, the vector store can be reused by calling methods that require initialization.
+	*/
+	async close() {
+		if (this.instance) {
+			this.instance = null;
+			this.initialized = false;
+			this.initPromise = null;
+		}
+	}
 };
-var OBSERVABILITY_UPGRADE_MESSAGE = "DuckDB observability storage requires `@mastra/core` with observability storage support. Upgrade `@mastra/core` to use this store.";
-var OBSERVABILITY_DELTA_POLLING_FEATURE = "observability-delta-polling";
-var DUCKDB_OBSERVABILITY_FEATURES = ["delta-polling"];
+//#endregion
+//#region src/storage/index.ts
+const OBSERVABILITY_UPGRADE_MESSAGE = "DuckDB observability storage requires `@mastra/core` with observability storage support. Upgrade `@mastra/core` to use this store.";
+const OBSERVABILITY_DELTA_POLLING_FEATURE = "observability-delta-polling";
+const DUCKDB_OBSERVABILITY_FEATURES = ["delta-polling"];
 function isObservabilityCompatibilityError(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  return error.message.includes("@mastra/core") && (error.message.includes("does not provide an export named") || error.message.includes("No matching export") || error.message.includes("Cannot find module") || error.message.includes("Cannot find package"));
+	if (!(error instanceof Error)) return false;
+	return error.message.includes("@mastra/core") && (error.message.includes("does not provide an export named") || error.message.includes("No matching export") || error.message.includes("Cannot find module") || error.message.includes("Cannot find package"));
 }
-var ObservabilityStorageDuckDB = class extends storage.ObservabilityStorage {
-  db;
-  delegate = null;
-  loadPromise = null;
-  unavailableError = null;
-  constructor(config) {
-    super();
-    this.db = config.db;
-  }
-  createUnavailableError(cause) {
-    return new error.MastraError(
-      {
-        id: "OBSERVABILITY_STORAGE_DUCKDB_CORE_UPGRADE_NOT_IMPLEMENTED",
-        domain: error.ErrorDomain.MASTRA_OBSERVABILITY,
-        category: error.ErrorCategory.SYSTEM,
-        text: OBSERVABILITY_UPGRADE_MESSAGE
-      },
-      cause
-    );
-  }
-  async loadDelegate() {
-    if (this.delegate) {
-      return this.delegate;
-    }
-    if (this.unavailableError) {
-      return null;
-    }
-    if (!this.loadPromise) {
-      this.loadPromise = import('./observability-V2KYD7UF.cjs').then(({ ObservabilityStorageDuckDB: ObservabilityStorageDuckDB2 }) => {
-        const delegate = new ObservabilityStorageDuckDB2({ db: this.db });
-        this.delegate = delegate;
-        return delegate;
-      }).catch((error) => {
-        if (isObservabilityCompatibilityError(error)) {
-          this.unavailableError = this.createUnavailableError(error);
-          return null;
-        }
-        throw error;
-      });
-    }
-    return this.loadPromise;
-  }
-  async requireDelegate() {
-    const delegate = await this.loadDelegate();
-    if (!delegate) {
-      throw this.unavailableError ?? this.createUnavailableError();
-    }
-    return delegate;
-  }
-  get observabilityStrategy() {
-    return this.delegate?.observabilityStrategy ?? {
-      preferred: "event-sourced",
-      supported: ["event-sourced"]
-    };
-  }
-  get tracingStrategy() {
-    return this.delegate?.tracingStrategy ?? this.observabilityStrategy;
-  }
-  getFeatures() {
-    if (!features.coreFeatures.has(OBSERVABILITY_DELTA_POLLING_FEATURE)) {
-      return void 0;
-    }
-    return DUCKDB_OBSERVABILITY_FEATURES;
-  }
-  async init(...args) {
-    const delegate = await this.loadDelegate();
-    if (!delegate) {
-      return;
-    }
-    return delegate.init(...args);
-  }
-  async migrateSpans(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.migrateSpans(...args);
-  }
-  async dangerouslyClearAll(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.dangerouslyClearAll(...args);
-  }
-  async createSpan(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.createSpan(...args);
-  }
-  async updateSpan(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.updateSpan(...args);
-  }
-  async getSpan(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getSpan(...args);
-  }
-  async getSpans(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getSpans(...args);
-  }
-  async getRootSpan(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getRootSpan(...args);
-  }
-  async getTrace(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getTrace(...args);
-  }
-  async getTraceLight(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getTraceLight(...args);
-  }
-  async listTraces(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.listTraces(...args);
-  }
-  async listTracesLight(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.listTracesLight(...args);
-  }
-  async listBranches(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.listBranches(...args);
-  }
-  async batchCreateSpans(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.batchCreateSpans(...args);
-  }
-  async batchUpdateSpans(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.batchUpdateSpans(...args);
-  }
-  async batchDeleteTraces(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.batchDeleteTraces(...args);
-  }
-  async batchCreateLogs(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.batchCreateLogs(...args);
-  }
-  async listLogs(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.listLogs(...args);
-  }
-  async batchCreateMetrics(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.batchCreateMetrics(...args);
-  }
-  async listMetrics(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.listMetrics(...args);
-  }
-  async getMetricAggregate(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getMetricAggregate(...args);
-  }
-  async getMetricBreakdown(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getMetricBreakdown(...args);
-  }
-  async getMetricTimeSeries(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getMetricTimeSeries(...args);
-  }
-  async getMetricPercentiles(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getMetricPercentiles(...args);
-  }
-  async getMetricNames(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getMetricNames(...args);
-  }
-  async getMetricLabelKeys(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getMetricLabelKeys(...args);
-  }
-  async getMetricLabelValues(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getMetricLabelValues(...args);
-  }
-  async getEntityTypes(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getEntityTypes(...args);
-  }
-  async getEntityNames(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getEntityNames(...args);
-  }
-  async getServiceNames(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getServiceNames(...args);
-  }
-  async getEnvironments(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getEnvironments(...args);
-  }
-  async getTags(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getTags(...args);
-  }
-  async createScore(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.createScore(...args);
-  }
-  async batchCreateScores(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.batchCreateScores(...args);
-  }
-  async listScores(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.listScores(...args);
-  }
-  async getScoreById(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getScoreById(...args);
-  }
-  async getScoreAggregate(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getScoreAggregate(...args);
-  }
-  async getScoreBreakdown(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getScoreBreakdown(...args);
-  }
-  async getScoreTimeSeries(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getScoreTimeSeries(...args);
-  }
-  async getScorePercentiles(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getScorePercentiles(...args);
-  }
-  async createFeedback(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.createFeedback(...args);
-  }
-  async batchCreateFeedback(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.batchCreateFeedback(...args);
-  }
-  async listFeedback(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.listFeedback(...args);
-  }
-  async getFeedbackAggregate(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getFeedbackAggregate(...args);
-  }
-  async getFeedbackBreakdown(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getFeedbackBreakdown(...args);
-  }
-  async getFeedbackTimeSeries(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getFeedbackTimeSeries(...args);
-  }
-  async getFeedbackPercentiles(...args) {
-    const delegate = await this.requireDelegate();
-    return delegate.getFeedbackPercentiles(...args);
-  }
+/**
+* Lazy DuckDB observability facade.
+*
+* This avoids loading the concrete observability implementation until init or first use,
+* which lets DuckDBStore degrade cleanly when paired with an older @mastra/core runtime.
+*/
+var ObservabilityStorageDuckDB = class extends _mastra_core_storage.ObservabilityStorage {
+	db;
+	delegate = null;
+	loadPromise = null;
+	unavailableError = null;
+	constructor(config) {
+		super();
+		this.db = config.db;
+	}
+	createUnavailableError(cause) {
+		return new _mastra_core_error.MastraError({
+			id: "OBSERVABILITY_STORAGE_DUCKDB_CORE_UPGRADE_NOT_IMPLEMENTED",
+			domain: _mastra_core_error.ErrorDomain.MASTRA_OBSERVABILITY,
+			category: _mastra_core_error.ErrorCategory.SYSTEM,
+			text: OBSERVABILITY_UPGRADE_MESSAGE
+		}, cause);
+	}
+	async loadDelegate() {
+		if (this.delegate) return this.delegate;
+		if (this.unavailableError) return null;
+		if (!this.loadPromise) this.loadPromise = Promise.resolve().then(() => require("./observability-Dc-V68UX.cjs")).then(({ ObservabilityStorageDuckDB }) => {
+			const delegate = new ObservabilityStorageDuckDB({ db: this.db });
+			this.delegate = delegate;
+			return delegate;
+		}).catch((error) => {
+			if (isObservabilityCompatibilityError(error)) {
+				this.unavailableError = this.createUnavailableError(error);
+				return null;
+			}
+			throw error;
+		});
+		return this.loadPromise;
+	}
+	async requireDelegate() {
+		const delegate = await this.loadDelegate();
+		if (!delegate) throw this.unavailableError ?? this.createUnavailableError();
+		return delegate;
+	}
+	get observabilityStrategy() {
+		return this.delegate?.observabilityStrategy ?? {
+			preferred: "event-sourced",
+			supported: ["event-sourced"]
+		};
+	}
+	get tracingStrategy() {
+		return this.delegate?.tracingStrategy ?? this.observabilityStrategy;
+	}
+	getFeatures() {
+		if (!_mastra_core_features.coreFeatures.has(OBSERVABILITY_DELTA_POLLING_FEATURE)) return;
+		return DUCKDB_OBSERVABILITY_FEATURES;
+	}
+	async init(...args) {
+		const delegate = await this.loadDelegate();
+		if (!delegate) return;
+		return delegate.init(...args);
+	}
+	async migrateSpans(...args) {
+		return (await this.requireDelegate()).migrateSpans(...args);
+	}
+	async dangerouslyClearAll(...args) {
+		return (await this.requireDelegate()).dangerouslyClearAll(...args);
+	}
+	async createSpan(...args) {
+		return (await this.requireDelegate()).createSpan(...args);
+	}
+	async updateSpan(...args) {
+		return (await this.requireDelegate()).updateSpan(...args);
+	}
+	async getSpan(...args) {
+		return (await this.requireDelegate()).getSpan(...args);
+	}
+	async getSpans(...args) {
+		return (await this.requireDelegate()).getSpans(...args);
+	}
+	async getRootSpan(...args) {
+		return (await this.requireDelegate()).getRootSpan(...args);
+	}
+	async getTrace(...args) {
+		return (await this.requireDelegate()).getTrace(...args);
+	}
+	async getTraceLight(...args) {
+		return (await this.requireDelegate()).getTraceLight(...args);
+	}
+	async listTraces(...args) {
+		return (await this.requireDelegate()).listTraces(...args);
+	}
+	async listTracesLight(...args) {
+		return (await this.requireDelegate()).listTracesLight(...args);
+	}
+	async listBranches(...args) {
+		return (await this.requireDelegate()).listBranches(...args);
+	}
+	async batchCreateSpans(...args) {
+		return (await this.requireDelegate()).batchCreateSpans(...args);
+	}
+	async batchUpdateSpans(...args) {
+		return (await this.requireDelegate()).batchUpdateSpans(...args);
+	}
+	async batchDeleteTraces(...args) {
+		return (await this.requireDelegate()).batchDeleteTraces(...args);
+	}
+	async batchCreateLogs(...args) {
+		return (await this.requireDelegate()).batchCreateLogs(...args);
+	}
+	async listLogs(...args) {
+		return (await this.requireDelegate()).listLogs(...args);
+	}
+	async batchCreateMetrics(...args) {
+		return (await this.requireDelegate()).batchCreateMetrics(...args);
+	}
+	async listMetrics(...args) {
+		return (await this.requireDelegate()).listMetrics(...args);
+	}
+	async getMetricAggregate(...args) {
+		return (await this.requireDelegate()).getMetricAggregate(...args);
+	}
+	async getMetricBreakdown(...args) {
+		return (await this.requireDelegate()).getMetricBreakdown(...args);
+	}
+	async getMetricTimeSeries(...args) {
+		return (await this.requireDelegate()).getMetricTimeSeries(...args);
+	}
+	async getMetricPercentiles(...args) {
+		return (await this.requireDelegate()).getMetricPercentiles(...args);
+	}
+	async getMetricNames(...args) {
+		return (await this.requireDelegate()).getMetricNames(...args);
+	}
+	async getMetricLabelKeys(...args) {
+		return (await this.requireDelegate()).getMetricLabelKeys(...args);
+	}
+	async getMetricLabelValues(...args) {
+		return (await this.requireDelegate()).getMetricLabelValues(...args);
+	}
+	async getEntityTypes(...args) {
+		return (await this.requireDelegate()).getEntityTypes(...args);
+	}
+	async getEntityNames(...args) {
+		return (await this.requireDelegate()).getEntityNames(...args);
+	}
+	async getServiceNames(...args) {
+		return (await this.requireDelegate()).getServiceNames(...args);
+	}
+	async getEnvironments(...args) {
+		return (await this.requireDelegate()).getEnvironments(...args);
+	}
+	async getTags(...args) {
+		return (await this.requireDelegate()).getTags(...args);
+	}
+	async createScore(...args) {
+		return (await this.requireDelegate()).createScore(...args);
+	}
+	async batchCreateScores(...args) {
+		return (await this.requireDelegate()).batchCreateScores(...args);
+	}
+	async listScores(...args) {
+		return (await this.requireDelegate()).listScores(...args);
+	}
+	async getScoreById(...args) {
+		return (await this.requireDelegate()).getScoreById(...args);
+	}
+	async getScoreAggregate(...args) {
+		return (await this.requireDelegate()).getScoreAggregate(...args);
+	}
+	async getScoreBreakdown(...args) {
+		return (await this.requireDelegate()).getScoreBreakdown(...args);
+	}
+	async getScoreTimeSeries(...args) {
+		return (await this.requireDelegate()).getScoreTimeSeries(...args);
+	}
+	async getScorePercentiles(...args) {
+		return (await this.requireDelegate()).getScorePercentiles(...args);
+	}
+	async createFeedback(...args) {
+		return (await this.requireDelegate()).createFeedback(...args);
+	}
+	async batchCreateFeedback(...args) {
+		return (await this.requireDelegate()).batchCreateFeedback(...args);
+	}
+	async listFeedback(...args) {
+		return (await this.requireDelegate()).listFeedback(...args);
+	}
+	async getFeedbackAggregate(...args) {
+		return (await this.requireDelegate()).getFeedbackAggregate(...args);
+	}
+	async getFeedbackBreakdown(...args) {
+		return (await this.requireDelegate()).getFeedbackBreakdown(...args);
+	}
+	async getFeedbackTimeSeries(...args) {
+		return (await this.requireDelegate()).getFeedbackTimeSeries(...args);
+	}
+	async getFeedbackPercentiles(...args) {
+		return (await this.requireDelegate()).getFeedbackPercentiles(...args);
+	}
 };
-var DuckDBStore = class extends storage.MastraCompositeStore {
-  db;
-  observabilityStore;
-  stores;
-  constructor(config = {}) {
-    const id = config.id ?? "duckdb";
-    super({ id, name: "DuckDBStore" });
-    this.db = new chunkSMRZJTCI_cjs.DuckDBConnection({ path: config.path });
-    this.observabilityStore = new ObservabilityStorageDuckDB({ db: this.db });
-    this.stores = {
-      observability: this.observabilityStore
-    };
-  }
-  /** Convenience accessor for the observability domain. */
-  get observability() {
-    return this.observabilityStore;
-  }
-  /**
-   * Release the underlying DuckDB instance so the file lock is freed.
-   * Called automatically by Mastra.shutdown(). Without this, the DuckDB
-   * native write lock persists past process exit during dev hot reloads,
-   * causing "Conflicting lock is held" errors on the next start.
-   * Safe to call more than once; subsequent calls are no-ops.
-   */
-  async close() {
-    await this.db.close();
-  }
+/**
+* DuckDB storage adapter for Mastra.
+*
+* Currently provides observability storage (traces, metrics, logs, scores, feedback).
+* Use via composition with another store for domains DuckDB doesn't yet cover.
+*
+* @example
+* ```typescript
+* // As the observability backend in a composed store
+* const storage = new MastraCompositeStore({
+*   id: 'my-store',
+*   default: new LibSQLStore({ id: 'my-store', url: 'file:./dev.db' }),
+*   domains: {
+*     observability: new DuckDBStore().observability,
+*   },
+* });
+*
+* // Or standalone (only observability domain available)
+* const duckdb = new DuckDBStore();
+* const obs = await duckdb.getStore('observability');
+* ```
+*/
+var DuckDBStore = class extends _mastra_core_storage.MastraCompositeStore {
+	db;
+	observabilityStore;
+	stores;
+	constructor(config = {}) {
+		const id = config.id ?? "duckdb";
+		super({
+			id,
+			name: "DuckDBStore"
+		});
+		this.db = new require_db.DuckDBConnection({
+			path: config.path,
+			memoryLimit: config.memoryLimit,
+			threads: config.threads
+		});
+		this.observabilityStore = new ObservabilityStorageDuckDB({ db: this.db });
+		this.stores = { observability: this.observabilityStore };
+	}
+	/** Convenience accessor for the observability domain. */
+	get observability() {
+		return this.observabilityStore;
+	}
+	/**
+	* Release the underlying DuckDB instance so the file lock is freed.
+	* Called automatically by Mastra.shutdown(). Without this, the DuckDB
+	* native write lock persists past process exit during dev hot reloads,
+	* causing "Conflicting lock is held" errors on the next start.
+	* Safe to call more than once; subsequent calls are no-ops.
+	*/
+	async close() {
+		await this.db.close();
+	}
 };
-
-Object.defineProperty(exports, "DuckDBConnection", {
-  enumerable: true,
-  get: function () { return chunkSMRZJTCI_cjs.DuckDBConnection; }
-});
+//#endregion
+exports.DuckDBConnection = require_db.DuckDBConnection;
 exports.DuckDBStore = DuckDBStore;
 exports.DuckDBVector = DuckDBVector;
 exports.ObservabilityStorageDuckDB = ObservabilityStorageDuckDB;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map