'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
function escapeString(value) {
  return value.replace(/'/g, "''");
}
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))}'`;
}
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: [] };
}
function buildJsonPath(field) {
  const parts = field.split(".");
  const jsonPath = "$." + parts.map((p) => escapeString(p)).join(".");
  return `json_extract_string(metadata, '${jsonPath}')`;
}
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 ");
}

// 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}
      FROM (
        SELECT 
          id,
          ${includeVector ? "vector," : ""}
          metadata,
          ${distanceFunc}(vector, ${vectorLiteral}) as distance
        FROM ${tableName}
        ${filterClause ? `WHERE ${filterClause}` : ""}
      ) subq
      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 = `
        INSERT OR REPLACE INTO ${tableName} (id, vector, metadata)
        VALUES (?, ${vectorLiteral}, '${metadataJson.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 = `
      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}"
        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(`
      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(`
      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;
    }
  }
};
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"];
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"));
}
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 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);
  }
};
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();
  }
};

Object.defineProperty(exports, "DuckDBConnection", {
  enumerable: true,
  get: function () { return chunkSMRZJTCI_cjs.DuckDBConnection; }
});
exports.DuckDBStore = DuckDBStore;
exports.DuckDBVector = DuckDBVector;
exports.ObservabilityStorageDuckDB = ObservabilityStorageDuckDB;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map