@elizaos/plugin-trajectory-logger 2.0.0-alpha.11 → 2.0.0-alpha.12

package/dist/node/index.node.js

@@ -1,1801 +1,5 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-
-// ../node_modules/drizzle-orm/entity.js
-function is(value, type) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  if (value instanceof type) {
-    return true;
-  }
-  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
-    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
-  }
-  let cls = Object.getPrototypeOf(value).constructor;
-  if (cls) {
-    while (cls) {
-      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
-        return true;
-      }
-      cls = Object.getPrototypeOf(cls);
-    }
-  }
-  return false;
-}
-var entityKind, hasOwnEntityKind;
-var init_entity = __esm(() => {
-  entityKind = Symbol.for("drizzle:entityKind");
-  hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
-});
-
-// ../node_modules/drizzle-orm/column.js
-var Column;
-var init_column = __esm(() => {
-  init_entity();
-  Column = class Column {
-    constructor(table, config) {
-      this.table = table;
-      this.config = config;
-      this.name = config.name;
-      this.keyAsName = config.keyAsName;
-      this.notNull = config.notNull;
-      this.default = config.default;
-      this.defaultFn = config.defaultFn;
-      this.onUpdateFn = config.onUpdateFn;
-      this.hasDefault = config.hasDefault;
-      this.primary = config.primaryKey;
-      this.isUnique = config.isUnique;
-      this.uniqueName = config.uniqueName;
-      this.uniqueType = config.uniqueType;
-      this.dataType = config.dataType;
-      this.columnType = config.columnType;
-      this.generated = config.generated;
-      this.generatedIdentity = config.generatedIdentity;
-    }
-    static [entityKind] = "Column";
-    name;
-    keyAsName;
-    primary;
-    notNull;
-    default;
-    defaultFn;
-    onUpdateFn;
-    hasDefault;
-    isUnique;
-    uniqueName;
-    uniqueType;
-    dataType;
-    columnType;
-    enumValues = undefined;
-    generated = undefined;
-    generatedIdentity = undefined;
-    config;
-    mapFromDriverValue(value) {
-      return value;
-    }
-    mapToDriverValue(value) {
-      return value;
-    }
-    shouldDisableInsert() {
-      return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/column-builder.js
-var ColumnBuilder;
-var init_column_builder = __esm(() => {
-  init_entity();
-  ColumnBuilder = class ColumnBuilder {
-    static [entityKind] = "ColumnBuilder";
-    config;
-    constructor(name, dataType, columnType) {
-      this.config = {
-        name,
-        keyAsName: name === "",
-        notNull: false,
-        default: undefined,
-        hasDefault: false,
-        primaryKey: false,
-        isUnique: false,
-        uniqueName: undefined,
-        uniqueType: undefined,
-        dataType,
-        columnType,
-        generated: undefined
-      };
-    }
-    $type() {
-      return this;
-    }
-    notNull() {
-      this.config.notNull = true;
-      return this;
-    }
-    default(value) {
-      this.config.default = value;
-      this.config.hasDefault = true;
-      return this;
-    }
-    $defaultFn(fn) {
-      this.config.defaultFn = fn;
-      this.config.hasDefault = true;
-      return this;
-    }
-    $default = this.$defaultFn;
-    $onUpdateFn(fn) {
-      this.config.onUpdateFn = fn;
-      this.config.hasDefault = true;
-      return this;
-    }
-    $onUpdate = this.$onUpdateFn;
-    primaryKey() {
-      this.config.primaryKey = true;
-      this.config.notNull = true;
-      return this;
-    }
-    setName(name) {
-      if (this.config.name !== "")
-        return;
-      this.config.name = name;
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/table.utils.js
-var TableName;
-var init_table_utils = __esm(() => {
-  TableName = Symbol.for("drizzle:Name");
-});
-
-// ../node_modules/drizzle-orm/tracing-utils.js
-function iife(fn, ...args) {
-  return fn(...args);
-}
-var init_tracing_utils = () => {};
-
-// ../node_modules/drizzle-orm/pg-core/unique-constraint.js
-function uniqueKeyName(table, columns) {
-  return `${table[TableName]}_${columns.join("_")}_unique`;
-}
-var init_unique_constraint = __esm(() => {
-  init_table_utils();
-});
-
-// ../node_modules/drizzle-orm/pg-core/columns/common.js
-var PgColumn, ExtraConfigColumn;
-var init_common = __esm(() => {
-  init_column();
-  init_entity();
-  init_unique_constraint();
-  PgColumn = class PgColumn extends Column {
-    constructor(table, config) {
-      if (!config.uniqueName) {
-        config.uniqueName = uniqueKeyName(table, [config.name]);
-      }
-      super(table, config);
-      this.table = table;
-    }
-    static [entityKind] = "PgColumn";
-  };
-  ExtraConfigColumn = class ExtraConfigColumn extends PgColumn {
-    static [entityKind] = "ExtraConfigColumn";
-    getSQLType() {
-      return this.getSQLType();
-    }
-    indexConfig = {
-      order: this.config.order ?? "asc",
-      nulls: this.config.nulls ?? "last",
-      opClass: this.config.opClass
-    };
-    defaultConfig = {
-      order: "asc",
-      nulls: "last",
-      opClass: undefined
-    };
-    asc() {
-      this.indexConfig.order = "asc";
-      return this;
-    }
-    desc() {
-      this.indexConfig.order = "desc";
-      return this;
-    }
-    nullsFirst() {
-      this.indexConfig.nulls = "first";
-      return this;
-    }
-    nullsLast() {
-      this.indexConfig.nulls = "last";
-      return this;
-    }
-    op(opClass) {
-      this.indexConfig.opClass = opClass;
-      return this;
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/pg-core/columns/enum.js
-function isPgEnum(obj) {
-  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
-}
-var PgEnumObjectColumn, isPgEnumSym, PgEnumColumn;
-var init_enum = __esm(() => {
-  init_entity();
-  init_common();
-  PgEnumObjectColumn = class PgEnumObjectColumn extends PgColumn {
-    static [entityKind] = "PgEnumObjectColumn";
-    enum;
-    enumValues = this.config.enum.enumValues;
-    constructor(table, config) {
-      super(table, config);
-      this.enum = config.enum;
-    }
-    getSQLType() {
-      return this.enum.enumName;
-    }
-  };
-  isPgEnumSym = Symbol.for("drizzle:isPgEnum");
-  PgEnumColumn = class PgEnumColumn extends PgColumn {
-    static [entityKind] = "PgEnumColumn";
-    enum = this.config.enum;
-    enumValues = this.config.enum.enumValues;
-    constructor(table, config) {
-      super(table, config);
-      this.enum = config.enum;
-    }
-    getSQLType() {
-      return this.enum.enumName;
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/subquery.js
-var Subquery, WithSubquery;
-var init_subquery = __esm(() => {
-  init_entity();
-  Subquery = class Subquery {
-    static [entityKind] = "Subquery";
-    constructor(sql, fields, alias, isWith = false, usedTables = []) {
-      this._ = {
-        brand: "Subquery",
-        sql,
-        selectedFields: fields,
-        alias,
-        isWith,
-        usedTables
-      };
-    }
-  };
-  WithSubquery = class WithSubquery extends Subquery {
-    static [entityKind] = "WithSubquery";
-  };
-});
-
-// ../node_modules/drizzle-orm/version.js
-var version = "0.45.1";
-var init_version = () => {};
-
-// ../node_modules/drizzle-orm/tracing.js
-var otel, rawTracer, tracer;
-var init_tracing = __esm(() => {
-  init_tracing_utils();
-  init_version();
-  tracer = {
-    startActiveSpan(name, fn) {
-      if (!otel) {
-        return fn();
-      }
-      if (!rawTracer) {
-        rawTracer = otel.trace.getTracer("drizzle-orm", version);
-      }
-      return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
-        try {
-          return fn(span);
-        } catch (e) {
-          span.setStatus({
-            code: otel2.SpanStatusCode.ERROR,
-            message: e instanceof Error ? e.message : "Unknown error"
-          });
-          throw e;
-        } finally {
-          span.end();
-        }
-      }), otel, rawTracer);
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/view-common.js
-var ViewBaseConfig;
-var init_view_common = __esm(() => {
-  ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
-});
-
-// ../node_modules/drizzle-orm/table.js
-function isTable(table) {
-  return typeof table === "object" && table !== null && IsDrizzleTable in table;
-}
-function getTableName(table) {
-  return table[TableName];
-}
-function getTableUniqueName(table) {
-  return `${table[Schema] ?? "public"}.${table[TableName]}`;
-}
-var Schema, Columns, ExtraConfigColumns, OriginalName, BaseName, IsAlias, ExtraConfigBuilder, IsDrizzleTable, Table;
-var init_table = __esm(() => {
-  init_entity();
-  init_table_utils();
-  Schema = Symbol.for("drizzle:Schema");
-  Columns = Symbol.for("drizzle:Columns");
-  ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
-  OriginalName = Symbol.for("drizzle:OriginalName");
-  BaseName = Symbol.for("drizzle:BaseName");
-  IsAlias = Symbol.for("drizzle:IsAlias");
-  ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
-  IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
-  Table = class Table {
-    static [entityKind] = "Table";
-    static Symbol = {
-      Name: TableName,
-      Schema,
-      OriginalName,
-      Columns,
-      ExtraConfigColumns,
-      BaseName,
-      IsAlias,
-      ExtraConfigBuilder
-    };
-    [TableName];
-    [OriginalName];
-    [Schema];
-    [Columns];
-    [ExtraConfigColumns];
-    [BaseName];
-    [IsAlias] = false;
-    [IsDrizzleTable] = true;
-    [ExtraConfigBuilder] = undefined;
-    constructor(name, schema, baseName) {
-      this[TableName] = this[OriginalName] = name;
-      this[Schema] = schema;
-      this[BaseName] = baseName;
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/sql/sql.js
-function isSQLWrapper(value) {
-  return value !== null && value !== undefined && typeof value.getSQL === "function";
-}
-function mergeQueries(queries) {
-  const result = { sql: "", params: [] };
-  for (const query of queries) {
-    result.sql += query.sql;
-    result.params.push(...query.params);
-    if (query.typings?.length) {
-      if (!result.typings) {
-        result.typings = [];
-      }
-      result.typings.push(...query.typings);
-    }
-  }
-  return result;
-}
-function name(value) {
-  return new Name(value);
-}
-function isDriverValueEncoder(value) {
-  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
-}
-function param(value, encoder) {
-  return new Param(value, encoder);
-}
-function sql(strings, ...params) {
-  const queryChunks = [];
-  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
-    queryChunks.push(new StringChunk(strings[0]));
-  }
-  for (const [paramIndex, param2] of params.entries()) {
-    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
-  }
-  return new SQL(queryChunks);
-}
-function placeholder(name2) {
-  return new Placeholder(name2);
-}
-function fillPlaceholders(params, values) {
-  return params.map((p) => {
-    if (is(p, Placeholder)) {
-      if (!(p.name in values)) {
-        throw new Error(`No value for placeholder "${p.name}" was provided`);
-      }
-      return values[p.name];
-    }
-    if (is(p, Param) && is(p.value, Placeholder)) {
-      if (!(p.value.name in values)) {
-        throw new Error(`No value for placeholder "${p.value.name}" was provided`);
-      }
-      return p.encoder.mapToDriverValue(values[p.value.name]);
-    }
-    return p;
-  });
-}
-function isView(view) {
-  return typeof view === "object" && view !== null && IsDrizzleView in view;
-}
-function getViewName(view) {
-  return view[ViewBaseConfig].name;
-}
-var FakePrimitiveParam, StringChunk, SQL, Name, noopDecoder, noopEncoder, noopMapper, Param, Placeholder, IsDrizzleView, View;
-var init_sql = __esm(() => {
-  init_entity();
-  init_enum();
-  init_subquery();
-  init_tracing();
-  init_view_common();
-  init_column();
-  init_table();
-  FakePrimitiveParam = class FakePrimitiveParam {
-    static [entityKind] = "FakePrimitiveParam";
-  };
-  StringChunk = class StringChunk {
-    static [entityKind] = "StringChunk";
-    value;
-    constructor(value) {
-      this.value = Array.isArray(value) ? value : [value];
-    }
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  SQL = class SQL {
-    constructor(queryChunks) {
-      this.queryChunks = queryChunks;
-      for (const chunk of queryChunks) {
-        if (is(chunk, Table)) {
-          const schemaName = chunk[Table.Symbol.Schema];
-          this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
-        }
-      }
-    }
-    static [entityKind] = "SQL";
-    decoder = noopDecoder;
-    shouldInlineParams = false;
-    usedTables = [];
-    append(query) {
-      this.queryChunks.push(...query.queryChunks);
-      return this;
-    }
-    toQuery(config) {
-      return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
-        const query = this.buildQueryFromSourceParams(this.queryChunks, config);
-        span?.setAttributes({
-          "drizzle.query.text": query.sql,
-          "drizzle.query.params": JSON.stringify(query.params)
-        });
-        return query;
-      });
-    }
-    buildQueryFromSourceParams(chunks, _config) {
-      const config = Object.assign({}, _config, {
-        inlineParams: _config.inlineParams || this.shouldInlineParams,
-        paramStartIndex: _config.paramStartIndex || { value: 0 }
-      });
-      const {
-        casing,
-        escapeName,
-        escapeParam,
-        prepareTyping,
-        inlineParams,
-        paramStartIndex
-      } = config;
-      return mergeQueries(chunks.map((chunk) => {
-        if (is(chunk, StringChunk)) {
-          return { sql: chunk.value.join(""), params: [] };
-        }
-        if (is(chunk, Name)) {
-          return { sql: escapeName(chunk.value), params: [] };
-        }
-        if (chunk === undefined) {
-          return { sql: "", params: [] };
-        }
-        if (Array.isArray(chunk)) {
-          const result = [new StringChunk("(")];
-          for (const [i, p] of chunk.entries()) {
-            result.push(p);
-            if (i < chunk.length - 1) {
-              result.push(new StringChunk(", "));
-            }
-          }
-          result.push(new StringChunk(")"));
-          return this.buildQueryFromSourceParams(result, config);
-        }
-        if (is(chunk, SQL)) {
-          return this.buildQueryFromSourceParams(chunk.queryChunks, {
-            ...config,
-            inlineParams: inlineParams || chunk.shouldInlineParams
-          });
-        }
-        if (is(chunk, Table)) {
-          const schemaName = chunk[Table.Symbol.Schema];
-          const tableName = chunk[Table.Symbol.Name];
-          return {
-            sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
-            params: []
-          };
-        }
-        if (is(chunk, Column)) {
-          const columnName = casing.getColumnCasing(chunk);
-          if (_config.invokeSource === "indexes") {
-            return { sql: escapeName(columnName), params: [] };
-          }
-          const schemaName = chunk.table[Table.Symbol.Schema];
-          return {
-            sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
-            params: []
-          };
-        }
-        if (is(chunk, View)) {
-          const schemaName = chunk[ViewBaseConfig].schema;
-          const viewName = chunk[ViewBaseConfig].name;
-          return {
-            sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
-            params: []
-          };
-        }
-        if (is(chunk, Param)) {
-          if (is(chunk.value, Placeholder)) {
-            return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-          }
-          const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
-          if (is(mappedValue, SQL)) {
-            return this.buildQueryFromSourceParams([mappedValue], config);
-          }
-          if (inlineParams) {
-            return { sql: this.mapInlineParam(mappedValue, config), params: [] };
-          }
-          let typings = ["none"];
-          if (prepareTyping) {
-            typings = [prepareTyping(chunk.encoder)];
-          }
-          return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
-        }
-        if (is(chunk, Placeholder)) {
-          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-        }
-        if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
-          return { sql: escapeName(chunk.fieldAlias), params: [] };
-        }
-        if (is(chunk, Subquery)) {
-          if (chunk._.isWith) {
-            return { sql: escapeName(chunk._.alias), params: [] };
-          }
-          return this.buildQueryFromSourceParams([
-            new StringChunk("("),
-            chunk._.sql,
-            new StringChunk(") "),
-            new Name(chunk._.alias)
-          ], config);
-        }
-        if (isPgEnum(chunk)) {
-          if (chunk.schema) {
-            return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
-          }
-          return { sql: escapeName(chunk.enumName), params: [] };
-        }
-        if (isSQLWrapper(chunk)) {
-          if (chunk.shouldOmitSQLParens?.()) {
-            return this.buildQueryFromSourceParams([chunk.getSQL()], config);
-          }
-          return this.buildQueryFromSourceParams([
-            new StringChunk("("),
-            chunk.getSQL(),
-            new StringChunk(")")
-          ], config);
-        }
-        if (inlineParams) {
-          return { sql: this.mapInlineParam(chunk, config), params: [] };
-        }
-        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
-      }));
-    }
-    mapInlineParam(chunk, { escapeString }) {
-      if (chunk === null) {
-        return "null";
-      }
-      if (typeof chunk === "number" || typeof chunk === "boolean") {
-        return chunk.toString();
-      }
-      if (typeof chunk === "string") {
-        return escapeString(chunk);
-      }
-      if (typeof chunk === "object") {
-        const mappedValueAsString = chunk.toString();
-        if (mappedValueAsString === "[object Object]") {
-          return escapeString(JSON.stringify(chunk));
-        }
-        return escapeString(mappedValueAsString);
-      }
-      throw new Error("Unexpected param value: " + chunk);
-    }
-    getSQL() {
-      return this;
-    }
-    as(alias) {
-      if (alias === undefined) {
-        return this;
-      }
-      return new SQL.Aliased(this, alias);
-    }
-    mapWith(decoder) {
-      this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
-      return this;
-    }
-    inlineParams() {
-      this.shouldInlineParams = true;
-      return this;
-    }
-    if(condition) {
-      return condition ? this : undefined;
-    }
-  };
-  Name = class Name {
-    constructor(value) {
-      this.value = value;
-    }
-    static [entityKind] = "Name";
-    brand;
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  noopDecoder = {
-    mapFromDriverValue: (value) => value
-  };
-  noopEncoder = {
-    mapToDriverValue: (value) => value
-  };
-  noopMapper = {
-    ...noopDecoder,
-    ...noopEncoder
-  };
-  Param = class Param {
-    constructor(value, encoder = noopEncoder) {
-      this.value = value;
-      this.encoder = encoder;
-    }
-    static [entityKind] = "Param";
-    brand;
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  ((sql2) => {
-    function empty() {
-      return new SQL([]);
-    }
-    sql2.empty = empty;
-    function fromList(list) {
-      return new SQL(list);
-    }
-    sql2.fromList = fromList;
-    function raw(str) {
-      return new SQL([new StringChunk(str)]);
-    }
-    sql2.raw = raw;
-    function join(chunks, separator) {
-      const result = [];
-      for (const [i, chunk] of chunks.entries()) {
-        if (i > 0 && separator !== undefined) {
-          result.push(separator);
-        }
-        result.push(chunk);
-      }
-      return new SQL(result);
-    }
-    sql2.join = join;
-    function identifier(value) {
-      return new Name(value);
-    }
-    sql2.identifier = identifier;
-    function placeholder2(name2) {
-      return new Placeholder(name2);
-    }
-    sql2.placeholder = placeholder2;
-    function param2(value, encoder) {
-      return new Param(value, encoder);
-    }
-    sql2.param = param2;
-  })(sql || (sql = {}));
-  ((SQL2) => {
-
-    class Aliased {
-      constructor(sql2, fieldAlias) {
-        this.sql = sql2;
-        this.fieldAlias = fieldAlias;
-      }
-      static [entityKind] = "SQL.Aliased";
-      isSelectionField = false;
-      getSQL() {
-        return this.sql;
-      }
-      clone() {
-        return new Aliased(this.sql, this.fieldAlias);
-      }
-    }
-    SQL2.Aliased = Aliased;
-  })(SQL || (SQL = {}));
-  Placeholder = class Placeholder {
-    constructor(name2) {
-      this.name = name2;
-    }
-    static [entityKind] = "Placeholder";
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
-  View = class View {
-    static [entityKind] = "View";
-    [ViewBaseConfig];
-    [IsDrizzleView] = true;
-    constructor({ name: name2, schema, selectedFields, query }) {
-      this[ViewBaseConfig] = {
-        name: name2,
-        originalName: name2,
-        schema,
-        selectedFields,
-        query,
-        isExisting: !query,
-        isAlias: false
-      };
-    }
-    getSQL() {
-      return new SQL([this]);
-    }
-  };
-  Column.prototype.getSQL = function() {
-    return new SQL([this]);
-  };
-  Table.prototype.getSQL = function() {
-    return new SQL([this]);
-  };
-  Subquery.prototype.getSQL = function() {
-    return new SQL([this]);
-  };
-});
-
-// ../node_modules/drizzle-orm/alias.js
-function aliasedTable(table, tableAlias) {
-  return new Proxy(table, new TableAliasProxyHandler(tableAlias, false));
-}
-function aliasedRelation(relation, tableAlias) {
-  return new Proxy(relation, new RelationTableAliasProxyHandler(tableAlias));
-}
-function aliasedTableColumn(column, tableAlias) {
-  return new Proxy(column, new ColumnAliasProxyHandler(new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false))));
-}
-function mapColumnsInAliasedSQLToAlias(query, alias) {
-  return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias), query.fieldAlias);
-}
-function mapColumnsInSQLToAlias(query, alias) {
-  return sql.join(query.queryChunks.map((c) => {
-    if (is(c, Column)) {
-      return aliasedTableColumn(c, alias);
-    }
-    if (is(c, SQL)) {
-      return mapColumnsInSQLToAlias(c, alias);
-    }
-    if (is(c, SQL.Aliased)) {
-      return mapColumnsInAliasedSQLToAlias(c, alias);
-    }
-    return c;
-  }));
-}
-var ColumnAliasProxyHandler, TableAliasProxyHandler, RelationTableAliasProxyHandler;
-var init_alias = __esm(() => {
-  init_column();
-  init_entity();
-  init_sql();
-  init_table();
-  init_view_common();
-  ColumnAliasProxyHandler = class ColumnAliasProxyHandler {
-    constructor(table) {
-      this.table = table;
-    }
-    static [entityKind] = "ColumnAliasProxyHandler";
-    get(columnObj, prop) {
-      if (prop === "table") {
-        return this.table;
-      }
-      return columnObj[prop];
-    }
-  };
-  TableAliasProxyHandler = class TableAliasProxyHandler {
-    constructor(alias, replaceOriginalName) {
-      this.alias = alias;
-      this.replaceOriginalName = replaceOriginalName;
-    }
-    static [entityKind] = "TableAliasProxyHandler";
-    get(target, prop) {
-      if (prop === Table.Symbol.IsAlias) {
-        return true;
-      }
-      if (prop === Table.Symbol.Name) {
-        return this.alias;
-      }
-      if (this.replaceOriginalName && prop === Table.Symbol.OriginalName) {
-        return this.alias;
-      }
-      if (prop === ViewBaseConfig) {
-        return {
-          ...target[ViewBaseConfig],
-          name: this.alias,
-          isAlias: true
-        };
-      }
-      if (prop === Table.Symbol.Columns) {
-        const columns = target[Table.Symbol.Columns];
-        if (!columns) {
-          return columns;
-        }
-        const proxiedColumns = {};
-        Object.keys(columns).map((key) => {
-          proxiedColumns[key] = new Proxy(columns[key], new ColumnAliasProxyHandler(new Proxy(target, this)));
-        });
-        return proxiedColumns;
-      }
-      const value = target[prop];
-      if (is(value, Column)) {
-        return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(target, this)));
-      }
-      return value;
-    }
-  };
-  RelationTableAliasProxyHandler = class RelationTableAliasProxyHandler {
-    constructor(alias) {
-      this.alias = alias;
-    }
-    static [entityKind] = "RelationTableAliasProxyHandler";
-    get(target, prop) {
-      if (prop === "sourceTable") {
-        return aliasedTable(target.sourceTable, this.alias);
-      }
-      return target[prop];
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/errors.js
-var DrizzleError, DrizzleQueryError, TransactionRollbackError;
-var init_errors = __esm(() => {
-  init_entity();
-  DrizzleError = class DrizzleError extends Error {
-    static [entityKind] = "DrizzleError";
-    constructor({ message, cause }) {
-      super(message);
-      this.name = "DrizzleError";
-      this.cause = cause;
-    }
-  };
-  DrizzleQueryError = class DrizzleQueryError extends Error {
-    constructor(query, params, cause) {
-      super(`Failed query: ${query}
-params: ${params}`);
-      this.query = query;
-      this.params = params;
-      this.cause = cause;
-      Error.captureStackTrace(this, DrizzleQueryError);
-      if (cause)
-        this.cause = cause;
-    }
-  };
-  TransactionRollbackError = class TransactionRollbackError extends DrizzleError {
-    static [entityKind] = "TransactionRollbackError";
-    constructor() {
-      super({ message: "Rollback" });
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/logger.js
-var ConsoleLogWriter, DefaultLogger, NoopLogger;
-var init_logger = __esm(() => {
-  init_entity();
-  ConsoleLogWriter = class ConsoleLogWriter {
-    static [entityKind] = "ConsoleLogWriter";
-    write(message) {
-      console.log(message);
-    }
-  };
-  DefaultLogger = class DefaultLogger {
-    static [entityKind] = "DefaultLogger";
-    writer;
-    constructor(config) {
-      this.writer = config?.writer ?? new ConsoleLogWriter;
-    }
-    logQuery(query, params) {
-      const stringifiedParams = params.map((p) => {
-        try {
-          return JSON.stringify(p);
-        } catch {
-          return String(p);
-        }
-      });
-      const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(", ")}]` : "";
-      this.writer.write(`Query: ${query}${paramsStr}`);
-    }
-  };
-  NoopLogger = class NoopLogger {
-    static [entityKind] = "NoopLogger";
-    logQuery() {}
-  };
-});
-
-// ../node_modules/drizzle-orm/query-promise.js
-var QueryPromise;
-var init_query_promise = __esm(() => {
-  init_entity();
-  QueryPromise = class QueryPromise {
-    static [entityKind] = "QueryPromise";
-    [Symbol.toStringTag] = "QueryPromise";
-    catch(onRejected) {
-      return this.then(undefined, onRejected);
-    }
-    finally(onFinally) {
-      return this.then((value) => {
-        onFinally?.();
-        return value;
-      }, (reason) => {
-        onFinally?.();
-        throw reason;
-      });
-    }
-    then(onFulfilled, onRejected) {
-      return this.execute().then(onFulfilled, onRejected);
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/utils.js
-function mapResultRow(columns, row, joinsNotNullableMap) {
-  const nullifyMap = {};
-  const result = columns.reduce((result2, { path, field }, columnIndex) => {
-    let decoder;
-    if (is(field, Column)) {
-      decoder = field;
-    } else if (is(field, SQL)) {
-      decoder = field.decoder;
-    } else if (is(field, Subquery)) {
-      decoder = field._.sql.decoder;
-    } else {
-      decoder = field.sql.decoder;
-    }
-    let node = result2;
-    for (const [pathChunkIndex, pathChunk] of path.entries()) {
-      if (pathChunkIndex < path.length - 1) {
-        if (!(pathChunk in node)) {
-          node[pathChunk] = {};
-        }
-        node = node[pathChunk];
-      } else {
-        const rawValue = row[columnIndex];
-        const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-        if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
-          const objectName = path[0];
-          if (!(objectName in nullifyMap)) {
-            nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
-          } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
-            nullifyMap[objectName] = false;
-          }
-        }
-      }
-    }
-    return result2;
-  }, {});
-  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
-    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
-      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
-        result[objectName] = null;
-      }
-    }
-  }
-  return result;
-}
-function orderSelectedFields(fields, pathPrefix) {
-  return Object.entries(fields).reduce((result, [name2, field]) => {
-    if (typeof name2 !== "string") {
-      return result;
-    }
-    const newPath = pathPrefix ? [...pathPrefix, name2] : [name2];
-    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) {
-      result.push({ path: newPath, field });
-    } else if (is(field, Table)) {
-      result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
-    } else {
-      result.push(...orderSelectedFields(field, newPath));
-    }
-    return result;
-  }, []);
-}
-function haveSameKeys(left, right) {
-  const leftKeys = Object.keys(left);
-  const rightKeys = Object.keys(right);
-  if (leftKeys.length !== rightKeys.length) {
-    return false;
-  }
-  for (const [index, key] of leftKeys.entries()) {
-    if (key !== rightKeys[index]) {
-      return false;
-    }
-  }
-  return true;
-}
-function mapUpdateSet(table, values) {
-  const entries = Object.entries(values).filter(([, value]) => value !== undefined).map(([key, value]) => {
-    if (is(value, SQL) || is(value, Column)) {
-      return [key, value];
-    } else {
-      return [key, new Param(value, table[Table.Symbol.Columns][key])];
-    }
-  });
-  if (entries.length === 0) {
-    throw new Error("No values to set");
-  }
-  return Object.fromEntries(entries);
-}
-function applyMixins(baseClass, extendedClasses) {
-  for (const extendedClass of extendedClasses) {
-    for (const name2 of Object.getOwnPropertyNames(extendedClass.prototype)) {
-      if (name2 === "constructor")
-        continue;
-      Object.defineProperty(baseClass.prototype, name2, Object.getOwnPropertyDescriptor(extendedClass.prototype, name2) || /* @__PURE__ */ Object.create(null));
-    }
-  }
-}
-function getTableColumns(table) {
-  return table[Table.Symbol.Columns];
-}
-function getViewSelectedFields(view) {
-  return view[ViewBaseConfig].selectedFields;
-}
-function getTableLikeName(table) {
-  return is(table, Subquery) ? table._.alias : is(table, View) ? table[ViewBaseConfig].name : is(table, SQL) ? undefined : table[Table.Symbol.IsAlias] ? table[Table.Symbol.Name] : table[Table.Symbol.BaseName];
-}
-function getColumnNameAndConfig(a, b) {
-  return {
-    name: typeof a === "string" && a.length > 0 ? a : "",
-    config: typeof a === "object" ? a : b
-  };
-}
-function isConfig(data) {
-  if (typeof data !== "object" || data === null)
-    return false;
-  if (data.constructor.name !== "Object")
-    return false;
-  if ("logger" in data) {
-    const type = typeof data["logger"];
-    if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined")
-      return false;
-    return true;
-  }
-  if ("schema" in data) {
-    const type = typeof data["schema"];
-    if (type !== "object" && type !== "undefined")
-      return false;
-    return true;
-  }
-  if ("casing" in data) {
-    const type = typeof data["casing"];
-    if (type !== "string" && type !== "undefined")
-      return false;
-    return true;
-  }
-  if ("mode" in data) {
-    if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== undefined)
-      return false;
-    return true;
-  }
-  if ("connection" in data) {
-    const type = typeof data["connection"];
-    if (type !== "string" && type !== "object" && type !== "undefined")
-      return false;
-    return true;
-  }
-  if ("client" in data) {
-    const type = typeof data["client"];
-    if (type !== "object" && type !== "function" && type !== "undefined")
-      return false;
-    return true;
-  }
-  if (Object.keys(data).length === 0)
-    return true;
-  return false;
-}
-var textDecoder;
-var init_utils = __esm(() => {
-  init_column();
-  init_entity();
-  init_sql();
-  init_subquery();
-  init_table();
-  init_view_common();
-  textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
-});
-
-// ../node_modules/drizzle-orm/pg-core/table.js
-var InlineForeignKeys, EnableRLS, PgTable;
-var init_table2 = __esm(() => {
-  init_entity();
-  init_table();
-  InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
-  EnableRLS = Symbol.for("drizzle:EnableRLS");
-  PgTable = class PgTable extends Table {
-    static [entityKind] = "PgTable";
-    static Symbol = Object.assign({}, Table.Symbol, {
-      InlineForeignKeys,
-      EnableRLS
-    });
-    [InlineForeignKeys] = [];
-    [EnableRLS] = false;
-    [Table.Symbol.ExtraConfigBuilder] = undefined;
-    [Table.Symbol.ExtraConfigColumns] = {};
-  };
-});
-
-// ../node_modules/drizzle-orm/pg-core/primary-keys.js
-var PrimaryKeyBuilder, PrimaryKey;
-var init_primary_keys = __esm(() => {
-  init_entity();
-  init_table2();
-  PrimaryKeyBuilder = class PrimaryKeyBuilder {
-    static [entityKind] = "PgPrimaryKeyBuilder";
-    columns;
-    name;
-    constructor(columns, name2) {
-      this.columns = columns;
-      this.name = name2;
-    }
-    build(table) {
-      return new PrimaryKey(table, this.columns, this.name);
-    }
-  };
-  PrimaryKey = class PrimaryKey {
-    constructor(table, columns, name2) {
-      this.table = table;
-      this.columns = columns;
-      this.name = name2;
-    }
-    static [entityKind] = "PgPrimaryKey";
-    columns;
-    name;
-    getName() {
-      return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/sql/expressions/conditions.js
-function bindIfParam(value, column) {
-  if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
-    return new Param(value, column);
-  }
-  return value;
-}
-function and(...unfilteredConditions) {
-  const conditions = unfilteredConditions.filter((c) => c !== undefined);
-  if (conditions.length === 0) {
-    return;
-  }
-  if (conditions.length === 1) {
-    return new SQL(conditions);
-  }
-  return new SQL([
-    new StringChunk("("),
-    sql.join(conditions, new StringChunk(" and ")),
-    new StringChunk(")")
-  ]);
-}
-function or(...unfilteredConditions) {
-  const conditions = unfilteredConditions.filter((c) => c !== undefined);
-  if (conditions.length === 0) {
-    return;
-  }
-  if (conditions.length === 1) {
-    return new SQL(conditions);
-  }
-  return new SQL([
-    new StringChunk("("),
-    sql.join(conditions, new StringChunk(" or ")),
-    new StringChunk(")")
-  ]);
-}
-function not(condition) {
-  return sql`not ${condition}`;
-}
-function inArray(column, values) {
-  if (Array.isArray(values)) {
-    if (values.length === 0) {
-      return sql`false`;
-    }
-    return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
-  }
-  return sql`${column} in ${bindIfParam(values, column)}`;
-}
-function notInArray(column, values) {
-  if (Array.isArray(values)) {
-    if (values.length === 0) {
-      return sql`true`;
-    }
-    return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
-  }
-  return sql`${column} not in ${bindIfParam(values, column)}`;
-}
-function isNull(value) {
-  return sql`${value} is null`;
-}
-function isNotNull(value) {
-  return sql`${value} is not null`;
-}
-function exists(subquery) {
-  return sql`exists ${subquery}`;
-}
-function notExists(subquery) {
-  return sql`not exists ${subquery}`;
-}
-function between(column, min, max) {
-  return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
-}
-function notBetween(column, min, max) {
-  return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
-}
-function like(column, value) {
-  return sql`${column} like ${value}`;
-}
-function notLike(column, value) {
-  return sql`${column} not like ${value}`;
-}
-function ilike(column, value) {
-  return sql`${column} ilike ${value}`;
-}
-function notIlike(column, value) {
-  return sql`${column} not ilike ${value}`;
-}
-function arrayContains(column, values) {
-  if (Array.isArray(values)) {
-    if (values.length === 0) {
-      throw new Error("arrayContains requires at least one value");
-    }
-    const array = sql`${bindIfParam(values, column)}`;
-    return sql`${column} @> ${array}`;
-  }
-  return sql`${column} @> ${bindIfParam(values, column)}`;
-}
-function arrayContained(column, values) {
-  if (Array.isArray(values)) {
-    if (values.length === 0) {
-      throw new Error("arrayContained requires at least one value");
-    }
-    const array = sql`${bindIfParam(values, column)}`;
-    return sql`${column} <@ ${array}`;
-  }
-  return sql`${column} <@ ${bindIfParam(values, column)}`;
-}
-function arrayOverlaps(column, values) {
-  if (Array.isArray(values)) {
-    if (values.length === 0) {
-      throw new Error("arrayOverlaps requires at least one value");
-    }
-    const array = sql`${bindIfParam(values, column)}`;
-    return sql`${column} && ${array}`;
-  }
-  return sql`${column} && ${bindIfParam(values, column)}`;
-}
-var eq = (left, right) => {
-  return sql`${left} = ${bindIfParam(right, left)}`;
-}, ne = (left, right) => {
-  return sql`${left} <> ${bindIfParam(right, left)}`;
-}, gt = (left, right) => {
-  return sql`${left} > ${bindIfParam(right, left)}`;
-}, gte = (left, right) => {
-  return sql`${left} >= ${bindIfParam(right, left)}`;
-}, lt = (left, right) => {
-  return sql`${left} < ${bindIfParam(right, left)}`;
-}, lte = (left, right) => {
-  return sql`${left} <= ${bindIfParam(right, left)}`;
-};
-var init_conditions = __esm(() => {
-  init_column();
-  init_entity();
-  init_table();
-  init_sql();
-});
-
-// ../node_modules/drizzle-orm/sql/expressions/select.js
-function asc(column) {
-  return sql`${column} asc`;
-}
-function desc(column) {
-  return sql`${column} desc`;
-}
-var init_select = __esm(() => {
-  init_sql();
-});
-
-// ../node_modules/drizzle-orm/sql/expressions/index.js
-var init_expressions = __esm(() => {
-  init_conditions();
-  init_select();
-});
-
-// ../node_modules/drizzle-orm/relations.js
-function getOperators() {
-  return {
-    and,
-    between,
-    eq,
-    exists,
-    gt,
-    gte,
-    ilike,
-    inArray,
-    isNull,
-    isNotNull,
-    like,
-    lt,
-    lte,
-    ne,
-    not,
-    notBetween,
-    notExists,
-    notLike,
-    notIlike,
-    notInArray,
-    or,
-    sql
-  };
-}
-function getOrderByOperators() {
-  return {
-    sql,
-    asc,
-    desc
-  };
-}
-function extractTablesRelationalConfig(schema, configHelpers) {
-  if (Object.keys(schema).length === 1 && "default" in schema && !is(schema["default"], Table)) {
-    schema = schema["default"];
-  }
-  const tableNamesMap = {};
-  const relationsBuffer = {};
-  const tablesConfig = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (is(value, Table)) {
-      const dbName = getTableUniqueName(value);
-      const bufferedRelations = relationsBuffer[dbName];
-      tableNamesMap[dbName] = key;
-      tablesConfig[key] = {
-        tsName: key,
-        dbName: value[Table.Symbol.Name],
-        schema: value[Table.Symbol.Schema],
-        columns: value[Table.Symbol.Columns],
-        relations: bufferedRelations?.relations ?? {},
-        primaryKey: bufferedRelations?.primaryKey ?? []
-      };
-      for (const column of Object.values(value[Table.Symbol.Columns])) {
-        if (column.primary) {
-          tablesConfig[key].primaryKey.push(column);
-        }
-      }
-      const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
-      if (extraConfig) {
-        for (const configEntry of Object.values(extraConfig)) {
-          if (is(configEntry, PrimaryKeyBuilder)) {
-            tablesConfig[key].primaryKey.push(...configEntry.columns);
-          }
-        }
-      }
-    } else if (is(value, Relations)) {
-      const dbName = getTableUniqueName(value.table);
-      const tableName = tableNamesMap[dbName];
-      const relations2 = value.config(configHelpers(value.table));
-      let primaryKey;
-      for (const [relationName, relation] of Object.entries(relations2)) {
-        if (tableName) {
-          const tableConfig = tablesConfig[tableName];
-          tableConfig.relations[relationName] = relation;
-          if (primaryKey) {
-            tableConfig.primaryKey.push(...primaryKey);
-          }
-        } else {
-          if (!(dbName in relationsBuffer)) {
-            relationsBuffer[dbName] = {
-              relations: {},
-              primaryKey
-            };
-          }
-          relationsBuffer[dbName].relations[relationName] = relation;
-        }
-      }
-    }
-  }
-  return { tables: tablesConfig, tableNamesMap };
-}
-function relations(table, relations2) {
-  return new Relations(table, (helpers) => Object.fromEntries(Object.entries(relations2(helpers)).map(([key, value]) => [
-    key,
-    value.withFieldName(key)
-  ])));
-}
-function createOne(sourceTable) {
-  return function one(table, config) {
-    return new One(sourceTable, table, config, config?.fields.reduce((res, f) => res && f.notNull, true) ?? false);
-  };
-}
-function createMany(sourceTable) {
-  return function many(referencedTable, config) {
-    return new Many(sourceTable, referencedTable, config);
-  };
-}
-function normalizeRelation(schema, tableNamesMap, relation) {
-  if (is(relation, One) && relation.config) {
-    return {
-      fields: relation.config.fields,
-      references: relation.config.references
-    };
-  }
-  const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
-  if (!referencedTableTsName) {
-    throw new Error(`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`);
-  }
-  const referencedTableConfig = schema[referencedTableTsName];
-  if (!referencedTableConfig) {
-    throw new Error(`Table "${referencedTableTsName}" not found in schema`);
-  }
-  const sourceTable = relation.sourceTable;
-  const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
-  if (!sourceTableTsName) {
-    throw new Error(`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`);
-  }
-  const reverseRelations = [];
-  for (const referencedTableRelation of Object.values(referencedTableConfig.relations)) {
-    if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) {
-      reverseRelations.push(referencedTableRelation);
-    }
-  }
-  if (reverseRelations.length > 1) {
-    throw relation.relationName ? new Error(`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`) : new Error(`There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`);
-  }
-  if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {
-    return {
-      fields: reverseRelations[0].config.references,
-      references: reverseRelations[0].config.fields
-    };
-  }
-  throw new Error(`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`);
-}
-function createTableRelationsHelpers(sourceTable) {
-  return {
-    one: createOne(sourceTable),
-    many: createMany(sourceTable)
-  };
-}
-function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
-  const result = {};
-  for (const [
-    selectionItemIndex,
-    selectionItem
-  ] of buildQueryResultSelection.entries()) {
-    if (selectionItem.isJson) {
-      const relation = tableConfig.relations[selectionItem.tsKey];
-      const rawSubRows = row[selectionItemIndex];
-      const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
-      result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRows, selectionItem.selection, mapColumnValue) : subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRow, selectionItem.selection, mapColumnValue));
-    } else {
-      const value = mapColumnValue(row[selectionItemIndex]);
-      const field = selectionItem.field;
-      let decoder;
-      if (is(field, Column)) {
-        decoder = field;
-      } else if (is(field, SQL)) {
-        decoder = field.decoder;
-      } else {
-        decoder = field.sql.decoder;
-      }
-      result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
-    }
-  }
-  return result;
-}
-var Relation, Relations, One, Many;
-var init_relations = __esm(() => {
-  init_table();
-  init_column();
-  init_entity();
-  init_primary_keys();
-  init_expressions();
-  init_sql();
-  Relation = class Relation {
-    constructor(sourceTable, referencedTable, relationName) {
-      this.sourceTable = sourceTable;
-      this.referencedTable = referencedTable;
-      this.relationName = relationName;
-      this.referencedTableName = referencedTable[Table.Symbol.Name];
-    }
-    static [entityKind] = "Relation";
-    referencedTableName;
-    fieldName;
-  };
-  Relations = class Relations {
-    constructor(table, config) {
-      this.table = table;
-      this.config = config;
-    }
-    static [entityKind] = "Relations";
-  };
-  One = class One extends Relation {
-    constructor(sourceTable, referencedTable, config, isNullable) {
-      super(sourceTable, referencedTable, config?.relationName);
-      this.config = config;
-      this.isNullable = isNullable;
-    }
-    static [entityKind] = "One";
-    withFieldName(fieldName) {
-      const relation = new One(this.sourceTable, this.referencedTable, this.config, this.isNullable);
-      relation.fieldName = fieldName;
-      return relation;
-    }
-  };
-  Many = class Many extends Relation {
-    constructor(sourceTable, referencedTable, config) {
-      super(sourceTable, referencedTable, config?.relationName);
-      this.config = config;
-    }
-    static [entityKind] = "Many";
-    withFieldName(fieldName) {
-      const relation = new Many(this.sourceTable, this.referencedTable, this.config);
-      relation.fieldName = fieldName;
-      return relation;
-    }
-  };
-});
-
-// ../node_modules/drizzle-orm/sql/functions/aggregate.js
-function count(expression) {
-  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
-}
-function countDistinct(expression) {
-  return sql`count(distinct ${expression})`.mapWith(Number);
-}
-function avg(expression) {
-  return sql`avg(${expression})`.mapWith(String);
-}
-function avgDistinct(expression) {
-  return sql`avg(distinct ${expression})`.mapWith(String);
-}
-function sum(expression) {
-  return sql`sum(${expression})`.mapWith(String);
-}
-function sumDistinct(expression) {
-  return sql`sum(distinct ${expression})`.mapWith(String);
-}
-function max(expression) {
-  return sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String);
-}
-function min(expression) {
-  return sql`min(${expression})`.mapWith(is(expression, Column) ? expression : String);
-}
-var init_aggregate = __esm(() => {
-  init_column();
-  init_entity();
-  init_sql();
-});
-
-// ../node_modules/drizzle-orm/sql/functions/vector.js
-function toSql(value) {
-  return JSON.stringify(value);
-}
-function l2Distance(column, value) {
-  if (Array.isArray(value)) {
-    return sql`${column} <-> ${toSql(value)}`;
-  }
-  return sql`${column} <-> ${value}`;
-}
-function l1Distance(column, value) {
-  if (Array.isArray(value)) {
-    return sql`${column} <+> ${toSql(value)}`;
-  }
-  return sql`${column} <+> ${value}`;
-}
-function innerProduct(column, value) {
-  if (Array.isArray(value)) {
-    return sql`${column} <#> ${toSql(value)}`;
-  }
-  return sql`${column} <#> ${value}`;
-}
-function cosineDistance(column, value) {
-  if (Array.isArray(value)) {
-    return sql`${column} <=> ${toSql(value)}`;
-  }
-  return sql`${column} <=> ${value}`;
-}
-function hammingDistance(column, value) {
-  if (Array.isArray(value)) {
-    return sql`${column} <~> ${toSql(value)}`;
-  }
-  return sql`${column} <~> ${value}`;
-}
-function jaccardDistance(column, value) {
-  if (Array.isArray(value)) {
-    return sql`${column} <%> ${toSql(value)}`;
-  }
-  return sql`${column} <%> ${value}`;
-}
-var init_vector = __esm(() => {
-  init_sql();
-});
-
-// ../node_modules/drizzle-orm/sql/functions/index.js
-var init_functions = __esm(() => {
-  init_aggregate();
-  init_vector();
-});
-
-// ../node_modules/drizzle-orm/sql/index.js
-var init_sql2 = __esm(() => {
-  init_expressions();
-  init_functions();
-  init_sql();
-});
-
-// ../node_modules/drizzle-orm/index.js
-var exports_drizzle_orm = {};
-__export(exports_drizzle_orm, {
-  textDecoder: () => textDecoder,
-  sumDistinct: () => sumDistinct,
-  sum: () => sum,
-  sql: () => sql,
-  relations: () => relations,
-  placeholder: () => placeholder,
-  param: () => param,
-  orderSelectedFields: () => orderSelectedFields,
-  or: () => or,
-  notLike: () => notLike,
-  notInArray: () => notInArray,
-  notIlike: () => notIlike,
-  notExists: () => notExists,
-  notBetween: () => notBetween,
-  not: () => not,
-  normalizeRelation: () => normalizeRelation,
-  noopMapper: () => noopMapper,
-  noopEncoder: () => noopEncoder,
-  noopDecoder: () => noopDecoder,
-  ne: () => ne,
-  name: () => name,
-  min: () => min,
-  max: () => max,
-  mapUpdateSet: () => mapUpdateSet,
-  mapResultRow: () => mapResultRow,
-  mapRelationalRow: () => mapRelationalRow,
-  mapColumnsInSQLToAlias: () => mapColumnsInSQLToAlias,
-  mapColumnsInAliasedSQLToAlias: () => mapColumnsInAliasedSQLToAlias,
-  lte: () => lte,
-  lt: () => lt,
-  like: () => like,
-  l2Distance: () => l2Distance,
-  l1Distance: () => l1Distance,
-  jaccardDistance: () => jaccardDistance,
-  isView: () => isView,
-  isTable: () => isTable,
-  isSQLWrapper: () => isSQLWrapper,
-  isNull: () => isNull,
-  isNotNull: () => isNotNull,
-  isDriverValueEncoder: () => isDriverValueEncoder,
-  isConfig: () => isConfig,
-  is: () => is,
-  innerProduct: () => innerProduct,
-  inArray: () => inArray,
-  ilike: () => ilike,
-  haveSameKeys: () => haveSameKeys,
-  hasOwnEntityKind: () => hasOwnEntityKind,
-  hammingDistance: () => hammingDistance,
-  gte: () => gte,
-  gt: () => gt,
-  getViewSelectedFields: () => getViewSelectedFields,
-  getViewName: () => getViewName,
-  getTableUniqueName: () => getTableUniqueName,
-  getTableName: () => getTableName,
-  getTableLikeName: () => getTableLikeName,
-  getTableColumns: () => getTableColumns,
-  getOrderByOperators: () => getOrderByOperators,
-  getOperators: () => getOperators,
-  getColumnNameAndConfig: () => getColumnNameAndConfig,
-  fillPlaceholders: () => fillPlaceholders,
-  extractTablesRelationalConfig: () => extractTablesRelationalConfig,
-  exists: () => exists,
-  eq: () => eq,
-  entityKind: () => entityKind,
-  desc: () => desc,
-  createTableRelationsHelpers: () => createTableRelationsHelpers,
-  createOne: () => createOne,
-  createMany: () => createMany,
-  countDistinct: () => countDistinct,
-  count: () => count,
-  cosineDistance: () => cosineDistance,
-  bindIfParam: () => bindIfParam,
-  between: () => between,
-  avgDistinct: () => avgDistinct,
-  avg: () => avg,
-  asc: () => asc,
-  arrayOverlaps: () => arrayOverlaps,
-  arrayContains: () => arrayContains,
-  arrayContained: () => arrayContained,
-  applyMixins: () => applyMixins,
-  and: () => and,
-  aliasedTableColumn: () => aliasedTableColumn,
-  aliasedTable: () => aliasedTable,
-  aliasedRelation: () => aliasedRelation,
-  WithSubquery: () => WithSubquery,
-  ViewBaseConfig: () => ViewBaseConfig,
-  View: () => View,
-  TransactionRollbackError: () => TransactionRollbackError,
-  TableAliasProxyHandler: () => TableAliasProxyHandler,
-  Table: () => Table,
-  Subquery: () => Subquery,
-  StringChunk: () => StringChunk,
-  Schema: () => Schema,
-  SQL: () => SQL,
-  Relations: () => Relations,
-  RelationTableAliasProxyHandler: () => RelationTableAliasProxyHandler,
-  Relation: () => Relation,
-  QueryPromise: () => QueryPromise,
-  Placeholder: () => Placeholder,
-  Param: () => Param,
-  OriginalName: () => OriginalName,
-  One: () => One,
-  NoopLogger: () => NoopLogger,
-  Name: () => Name,
-  Many: () => Many,
-  IsAlias: () => IsAlias,
-  FakePrimitiveParam: () => FakePrimitiveParam,
-  ExtraConfigColumns: () => ExtraConfigColumns,
-  ExtraConfigBuilder: () => ExtraConfigBuilder,
-  DrizzleQueryError: () => DrizzleQueryError,
-  DrizzleError: () => DrizzleError,
-  DefaultLogger: () => DefaultLogger,
-  ConsoleLogWriter: () => ConsoleLogWriter,
-  Columns: () => Columns,
-  ColumnBuilder: () => ColumnBuilder,
-  ColumnAliasProxyHandler: () => ColumnAliasProxyHandler,
-  Column: () => Column,
-  BaseName: () => BaseName
-});
-var init_drizzle_orm = __esm(() => {
-  init_alias();
-  init_column_builder();
-  init_column();
-  init_entity();
-  init_errors();
-  init_logger();
-  init_query_promise();
-  init_relations();
-  init_sql2();
-  init_subquery();
-  init_table();
-  init_utils();
-  init_view_common();
-});
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // index.ts
 import {
@@ -1804,7 +8,7 @@ import {
 import crypto from "node:crypto";
 
 // TrajectoryLoggerService.ts
-import { logger as logger2, Service } from "@elizaos/core";
+import { logger, Service } from "@elizaos/core";
 import { v4 as uuidv4 } from "uuid";
 function asNumber(value) {
   if (typeof value === "number" && Number.isFinite(value))
@@ -1881,7 +85,7 @@ class TrajectoryLoggerService extends Service {
     return this.enabled;
   }
   async getSqlHelper() {
-    const drizzle = await Promise.resolve().then(() => (init_drizzle_orm(), exports_drizzle_orm));
+    const drizzle = await import("drizzle-orm");
     return drizzle.sql;
   }
   async executeRawSql(sqlText) {
@@ -1902,13 +106,13 @@ class TrajectoryLoggerService extends Service {
       return;
     const runtime = this.runtime;
     if (!runtime?.adapter) {
-      logger2.warn("[trajectory-logger] No runtime adapter available, skipping initialization");
+      logger.warn("[trajectory-logger] No runtime adapter available, skipping initialization");
       return;
     }
     await this.ensureTablesExist();
     await this.backfillTrajectoriesMissingLlmCalls();
     this.initialized = true;
-    logger2.info("[trajectory-logger] Trajectory logger service initialized");
+    logger.info("[trajectory-logger] Trajectory logger service initialized");
   }
   async getTableColumnNames(tableName) {
     const names = new Set;
@@ -1920,9 +124,9 @@ class TrajectoryLoggerService extends Service {
           AND table_schema NOT IN ('pg_catalog', 'information_schema')
       `);
       for (const row of result.rows) {
-        const name2 = asString(pickCell(row, "column_name"));
-        if (name2)
-          names.add(name2);
+        const name = asString(pickCell(row, "column_name"));
+        if (name)
+          names.add(name);
       }
       if (names.size > 0)
         return names;
@@ -1933,9 +137,9 @@ class TrajectoryLoggerService extends Service {
     try {
       const pragma = await this.executeRawSql(`PRAGMA table_info(${safeTableName})`);
       for (const row of pragma.rows) {
-        const name2 = asString(pickCell(row, "name"));
-        if (name2)
-          names.add(name2);
+        const name = asString(pickCell(row, "name"));
+        if (name)
+          names.add(name);
       }
     } catch {}
     return names;
@@ -1975,7 +179,7 @@ class TrajectoryLoggerService extends Service {
           if (combinedMessage.includes("already exists") || combinedMessage.includes("duplicate column") || combinedMessage.includes("duplicate_column")) {
             continue;
           }
-          logger2.warn(`[trajectory-logger] Failed to add trajectories.${columnName} (non-fatal): ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`);
+          logger.warn(`[trajectory-logger] Failed to add trajectories.${columnName} (non-fatal): ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`);
         }
       }
     }
@@ -2036,7 +240,7 @@ class TrajectoryLoggerService extends Service {
       await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_batch_id ON trajectories(batch_id)`);
       await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_is_training ON trajectories(is_training_data)`);
     } catch (e) {
-      logger2.warn(`[trajectory-logger] Failed to create indexes (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
+      logger.warn(`[trajectory-logger] Failed to create indexes (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
     }
     await this.executeRawSql(`
       CREATE TABLE IF NOT EXISTS trajectory_step_index (
@@ -2092,13 +296,13 @@ class TrajectoryLoggerService extends Service {
         });
       }
       if (fixed > 0) {
-        logger2.info(`[trajectory-logger] Backfilled ${fixed} completed trajectories with synthetic LLM calls`);
+        logger.info(`[trajectory-logger] Backfilled ${fixed} completed trajectories with synthetic LLM calls`);
       }
       if (rows.rows.length >= maxRows) {
-        logger2.warn(`[trajectory-logger] Backfill hit safety cap (${maxRows}); remaining older trajectories will be fixed lazily when touched`);
+        logger.warn(`[trajectory-logger] Backfill hit safety cap (${maxRows}); remaining older trajectories will be fixed lazily when touched`);
       }
     } catch (err) {
-      logger2.warn(`[trajectory-logger] Failed to backfill trajectories missing LLM calls (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+      logger.warn(`[trajectory-logger] Failed to backfill trajectories missing LLM calls (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   normalizePurpose(value) {
@@ -2336,7 +540,7 @@ class TrajectoryLoggerService extends Service {
           updated_at = ${sqlLiteral(updatedAtIso)}
         WHERE id = ${sqlLiteral(trajectoryId)}
       `).catch((legacyErr) => {
-        logger2.warn({ err: legacyErr, trajectoryId }, `[trajectory-logger] Failed to persist trajectory update after compatibility fallback: ${modernErr instanceof Error ? modernErr.message : String(modernErr)}`);
+        logger.warn({ err: legacyErr, trajectoryId }, `[trajectory-logger] Failed to persist trajectory update after compatibility fallback: ${modernErr instanceof Error ? modernErr.message : String(modernErr)}`);
         throw legacyErr;
       });
     }
@@ -2363,7 +567,7 @@ class TrajectoryLoggerService extends Service {
     (async () => {
       const trajectoryId = await this.resolveTrajectoryId(params.stepId);
       if (!trajectoryId) {
-        logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for LLM call");
+        logger.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for LLM call");
         return;
       }
       await this.withTrajectoryWriteLock(trajectoryId, async () => {
@@ -2392,7 +596,7 @@ class TrajectoryLoggerService extends Service {
         await this.persistTrajectory(trajectoryId, trajectory, "active");
       });
     })().catch((err) => {
-      logger2.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist LLM call");
+      logger.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist LLM call");
     });
   }
   logLLMCall(stepId, details) {
@@ -2426,7 +630,7 @@ class TrajectoryLoggerService extends Service {
     (async () => {
       const trajectoryId = await this.resolveTrajectoryId(params.stepId);
       if (!trajectoryId) {
-        logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for provider access");
+        logger.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for provider access");
         return;
       }
       await this.withTrajectoryWriteLock(trajectoryId, async () => {
@@ -2446,13 +650,13 @@ class TrajectoryLoggerService extends Service {
         await this.persistTrajectory(trajectoryId, trajectory, "active");
       });
     })().catch((err) => {
-      logger2.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist provider access");
+      logger.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist provider access");
     });
   }
   logProviderAccessByTrajectoryId(trajectoryId, access) {
     const stepId = this.getCurrentStepId(trajectoryId);
     if (!stepId) {
-      logger2.debug({ trajectoryId }, "[trajectory-logger] No active step for provider access by trajectory");
+      logger.debug({ trajectoryId }, "[trajectory-logger] No active step for provider access by trajectory");
       return;
     }
     this.logProviderAccess(stepId, access);
@@ -2539,7 +743,7 @@ class TrajectoryLoggerService extends Service {
         `);
         persistedStart = true;
       } catch (legacyErr) {
-        logger2.warn({ err: legacyErr, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
+        logger.warn({ err: legacyErr, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
       }
     }
     if (persistedStart && legacyStepId) {
@@ -2547,7 +751,7 @@ class TrajectoryLoggerService extends Service {
       try {
         await this.setStepIndex(legacyStepId, trajectoryId, -1, false);
       } catch (indexErr) {
-        logger2.warn({ err: indexErr, trajectoryId, stepId: legacyStepId }, "[trajectory-logger] Failed to persist step index for trajectory start");
+        logger.warn({ err: indexErr, trajectoryId, stepId: legacyStepId }, "[trajectory-logger] Failed to persist step index for trajectory start");
       }
     }
     return trajectoryId;
@@ -2561,7 +765,7 @@ class TrajectoryLoggerService extends Service {
     this.withTrajectoryWriteLock(trajectoryId, async () => {
       const trajectory = await this.getTrajectoryById(trajectoryId);
       if (!trajectory) {
-        logger2.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
+        logger.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
         return;
       }
       const step = this.createStep(stepId, trajectory.steps.length, envState);
@@ -2570,7 +774,7 @@ class TrajectoryLoggerService extends Service {
       await this.setStepIndex(stepId, trajectoryId, step.stepNumber, true);
       await this.persistTrajectory(trajectoryId, trajectory, "active");
     }).catch((err) => {
-      logger2.warn({ err, trajectoryId, stepId }, "[trajectory-logger] Failed to persist startStep");
+      logger.warn({ err, trajectoryId, stepId }, "[trajectory-logger] Failed to persist startStep");
     });
     return stepId;
   }
@@ -2610,7 +814,7 @@ class TrajectoryLoggerService extends Service {
       this.activeStepIds.delete(trajectoryId);
       await this.persistTrajectory(trajectoryId, trajectory, "active");
     }).catch((err) => {
-      logger2.warn({ err, trajectoryId }, "[trajectory-logger] Failed to complete step");
+      logger.warn({ err, trajectoryId }, "[trajectory-logger] Failed to complete step");
     });
   }
   async endTrajectory(stepIdOrTrajectoryId, status = "completed", finalMetrics) {
@@ -2618,13 +822,13 @@ class TrajectoryLoggerService extends Service {
       return;
     const trajectoryId = await this.resolveTrajectoryId(stepIdOrTrajectoryId);
     if (!trajectoryId) {
-      logger2.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No trajectory to end");
+      logger.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No trajectory to end");
       return;
     }
     await this.withTrajectoryWriteLock(trajectoryId, async () => {
       const trajectory = await this.getTrajectoryById(trajectoryId);
       if (!trajectory) {
-        logger2.debug({ trajectoryId }, "[trajectory-logger] Trajectory not found while ending");
+        logger.debug({ trajectoryId }, "[trajectory-logger] Trajectory not found while ending");
         return;
       }
       const now = Date.now();
@@ -2837,9 +1041,9 @@ class TrajectoryLoggerService extends Service {
     if (!runtime?.adapter)
       return 0;
     const countResult = await this.executeRawSql(`SELECT count(*)::int AS cnt FROM trajectories`);
-    const count2 = asNumber(pickCell(countResult.rows[0] ?? {}, "cnt")) ?? 0;
+    const count = asNumber(pickCell(countResult.rows[0] ?? {}, "cnt")) ?? 0;
     await this.executeRawSql(`DELETE FROM trajectories`);
-    return count2;
+    return count;
   }
   sanitizeZipFolderName(value) {
     const sanitized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
@@ -2988,7 +1192,7 @@ class TrajectoryLoggerService extends Service {
           t.endTime,
           t.durationMs,
           t.steps.length,
-          t.steps.reduce((sum2, s) => sum2 + s.llmCalls.length, 0),
+          t.steps.reduce((sum, s) => sum + s.llmCalls.length, 0),
           t.totalReward,
           t.scenarioId ?? ""
         ].join(","));
@@ -3058,7 +1262,7 @@ class TrajectoryLoggerService extends Service {
   }
 }
 // action-interceptor.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger2 } from "@elizaos/core";
 var trajectoryContexts = new WeakMap;
 function setTrajectoryContext(runtime, trajectoryId, trajectoryLogger) {
   trajectoryContexts.set(runtime, { trajectoryId, logger: trajectoryLogger });
@@ -3082,7 +1286,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger3.warn({ action: action.name, trajectoryId }, "No active step for action execution");
+        logger2.warn({ action: action.name, trajectoryId }, "No active step for action execution");
         const result = await originalHandler(runtime, message, state, options, callback);
         return result ?? undefined;
       }
@@ -3102,7 +1306,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       };
       const errorHandler = (err) => {
         const error = err instanceof Error ? err.message : typeof err === "string" ? err : err.message || String(err);
-        logger3.error({ action: action.name, trajectoryId, error }, "Action execution failed");
+        logger2.error({ action: action.name, trajectoryId, error }, "Action execution failed");
         const stateSnapshot = state ? JSON.parse(JSON.stringify(state)) : null;
         loggerService.completeStep(trajectoryId, stepId, {
           actionType: action.name,
@@ -3145,7 +1349,7 @@ function wrapPluginActions(plugin, trajectoryLogger) {
 function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger3.warn({ trajectoryId }, "No active step for LLM call from action");
+    logger2.warn({ trajectoryId }, "No active step for LLM call from action");
     return;
   }
   trajectoryLogger.logLLMCall(stepId, {
@@ -3166,7 +1370,7 @@ function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
 function logProviderFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger3.warn({ trajectoryId }, "No active step for provider access from action");
+    logger2.warn({ trajectoryId }, "No active step for provider access from action");
     return;
   }
   trajectoryLogger.logProviderAccess(stepId, {
@@ -3188,7 +1392,7 @@ function wrapProviderWithLogging(provider, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger3.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
+        logger2.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
         return originalGet?.(runtime, message, state) || { text: "" };
       }
       const result = await originalGet?.(runtime, message, state) || { text: "" };
@@ -3390,14 +1594,14 @@ function toARTJSONL(trajectory) {
   return JSON.stringify(toARTTrajectory(trajectory));
 }
 function validateARTCompatibility(trajectory) {
-  const errors2 = [];
+  const errors = [];
   const warnings = [];
   if (trajectory.steps.length === 0) {
-    errors2.push("Trajectory has no steps");
+    errors.push("Trajectory has no steps");
   }
   for (const [idx, step] of trajectory.steps.entries()) {
     if (step.llmCalls.length === 0) {
-      errors2.push(`Step ${idx} has no LLM calls - can't extract messages`);
+      errors.push(`Step ${idx} has no LLM calls - can't extract messages`);
     }
     for (const llmCall of step.llmCalls) {
       if (!llmCall.userPrompt || llmCall.userPrompt.length < 10) {
@@ -3409,15 +1613,15 @@ function validateARTCompatibility(trajectory) {
     }
   }
   if (trajectory.totalReward === undefined || Number.isNaN(trajectory.totalReward)) {
-    errors2.push("Trajectory has no valid reward");
+    errors.push("Trajectory has no valid reward");
   }
   const artTraj = toARTTrajectory(trajectory);
   if (artTraj.messages.length < 2) {
     warnings.push("Trajectory converts to very few messages (< 2)");
   }
   return {
-    valid: errors2.length === 0,
-    errors: errors2,
+    valid: errors.length === 0,
+    errors,
     warnings
   };
 }
@@ -3513,7 +1717,7 @@ async function buildGameStateFromDB(_trajectoryId) {
 }
 async function recomputeTrajectoryRewards(_trajectoryIds) {}
 // integration.ts
-import { logger as logger4 } from "@elizaos/core";
+import { logger as logger3 } from "@elizaos/core";
 async function startAutonomousTick(trajectoryLogger, context) {
   const trajectoryId = await trajectoryLogger.startTrajectory(context.agentId, {
     scenarioId: context.scenarioId,
@@ -3529,17 +1733,17 @@ async function startAutonomousTick(trajectoryLogger, context) {
     openPositions: 0
   };
   trajectoryLogger.startStep(trajectoryId, envState);
-  logger4.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
+  logger3.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
   return trajectoryId;
 }
 async function endAutonomousTick(trajectoryLogger, trajectoryId, status = "completed", finalMetrics) {
   await trajectoryLogger.endTrajectory(trajectoryId, status, finalMetrics);
-  logger4.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
+  logger3.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
 }
 async function loggedLLMCall(trajectoryLogger, trajectoryId, options, llmCallFn) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger4.warn({ trajectoryId }, "No active step for LLM call");
+    logger3.warn({ trajectoryId }, "No active step for LLM call");
     const result2 = await llmCallFn();
     return result2.text;
   }
@@ -3644,13 +1848,13 @@ class RewardService {
     return (score + 1) / 2;
   }
   normalizeScoresForGroup(scores) {
-    const min2 = Math.min(...scores);
-    const max2 = Math.max(...scores);
-    const range = max2 - min2;
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const range = max - min;
     if (range === 0) {
       return scores.map(() => 0.5);
     }
-    return scores.map((s) => (s - min2) / range);
+    return scores.map((s) => (s - min) / range);
   }
 }
 function createRewardService(options = {}) {
@@ -3685,13 +1889,13 @@ var trajectoryLoggerPlugin = {
           };
         }
         const meta = message.metadata;
-        const logger5 = runtime.getService("trajectory_logger");
-        if (!logger5)
+        const logger4 = runtime.getService("trajectory_logger");
+        if (!logger4)
           return;
         let trajectoryStepId = crypto.randomUUID();
         meta.trajectoryStepId = trajectoryStepId;
         try {
-          const trajectoryId = await logger5.startTrajectory(runtime.agentId, {
+          const trajectoryId = await logger4.startTrajectory(runtime.agentId, {
             source: source ?? meta.source ?? "chat",
             metadata: {
               roomId: message.roomId,
@@ -3703,7 +1907,7 @@ var trajectoryLoggerPlugin = {
           });
           const normalizedTrajectoryId = typeof trajectoryId === "string" && trajectoryId.trim().length > 0 ? trajectoryId : null;
           if (normalizedTrajectoryId) {
-            const runtimeStepId = logger5.startStep(normalizedTrajectoryId, {
+            const runtimeStepId = logger4.startStep(normalizedTrajectoryId, {
               timestamp: Date.now(),
               agentBalance: 0,
               agentPoints: 0,
@@ -3741,12 +1945,12 @@ var trajectoryLoggerPlugin = {
         }
         if (!trajectoryStepId)
           return;
-        const logger5 = runtime.getService("trajectory_logger");
-        if (!logger5)
+        const logger4 = runtime.getService("trajectory_logger");
+        if (!logger4)
           return;
         try {
           const endTarget = pendingTrajectoryEndTargetByStepId.get(trajectoryStepId) ?? trajectoryStepId;
-          await logger5.endTrajectory(endTarget, "completed");
+          await logger4.endTrajectory(endTarget, "completed");
         } catch (err) {
           runtime.logger?.warn({
             err,
@@ -3803,4 +2007,4 @@ export {
   RewardService
 };
 
-//# debugId=FBBDF38FEFEB663664756E2164756E21
+//# debugId=C01EFBED6D31A62B64756E2164756E21