peta-orm 0.2.6 → 0.4.0

package/dist/index-qb301480.js

@@ -1,2424 +0,0 @@
-// @bun
-import {
-  AliasNode,
-  CreateTableNode,
-  CreateViewNode,
-  IdentifierNode,
-  InsertQueryNode,
-  ManyToMany,
-  MergeQueryNode,
-  NOOP_QUERY_EXECUTOR,
-  OperatorNode,
-  ParensNode,
-  Peta,
-  QueryNode,
-  RawNode,
-  SetOperationNode,
-  ValueNode,
-  WithSchemaPlugin,
-  createQueryId,
-  freeze,
-  getLast,
-  isBigInt,
-  isBoolean,
-  isDate,
-  isModelClass,
-  isNull,
-  isNumber,
-  isOperationNodeSource,
-  isString,
-  parseStringReference,
-  parseTable,
-  parseValueExpression,
-  preventAwait
-} from "./index-sm1xx8gs.js";
-import {
-  __require
-} from "./index-k18nf2r7.js";
-
-// node_modules/kysely/dist/esm/raw-builder/raw-builder.js
-class RawBuilderImpl {
-  #props;
-  constructor(props) {
-    this.#props = freeze(props);
-  }
-  get expressionType() {
-    return;
-  }
-  get isRawBuilder() {
-    return true;
-  }
-  as(alias) {
-    return new AliasedRawBuilderImpl(this, alias);
-  }
-  $castTo() {
-    return new RawBuilderImpl({ ...this.#props });
-  }
-  $notNull() {
-    return new RawBuilderImpl(this.#props);
-  }
-  withPlugin(plugin) {
-    return new RawBuilderImpl({
-      ...this.#props,
-      plugins: this.#props.plugins !== undefined ? freeze([...this.#props.plugins, plugin]) : freeze([plugin])
-    });
-  }
-  toOperationNode() {
-    return this.#toOperationNode(this.#getExecutor());
-  }
-  compile(executorProvider) {
-    return this.#compile(this.#getExecutor(executorProvider));
-  }
-  async execute(executorProvider) {
-    const executor = this.#getExecutor(executorProvider);
-    return executor.executeQuery(this.#compile(executor), this.#props.queryId);
-  }
-  #getExecutor(executorProvider) {
-    const executor = executorProvider !== undefined ? executorProvider.getExecutor() : NOOP_QUERY_EXECUTOR;
-    return this.#props.plugins !== undefined ? executor.withPlugins(this.#props.plugins) : executor;
-  }
-  #toOperationNode(executor) {
-    return executor.transformQuery(this.#props.rawNode, this.#props.queryId);
-  }
-  #compile(executor) {
-    return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
-  }
-}
-function createRawBuilder(props) {
-  return new RawBuilderImpl(props);
-}
-preventAwait(RawBuilderImpl, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
-
-class AliasedRawBuilderImpl {
-  #rawBuilder;
-  #alias;
-  constructor(rawBuilder, alias) {
-    this.#rawBuilder = rawBuilder;
-    this.#alias = alias;
-  }
-  get expression() {
-    return this.#rawBuilder;
-  }
-  get alias() {
-    return this.#alias;
-  }
-  get rawBuilder() {
-    return this.#rawBuilder;
-  }
-  toOperationNode() {
-    return AliasNode.create(this.#rawBuilder.toOperationNode(), isOperationNodeSource(this.#alias) ? this.#alias.toOperationNode() : IdentifierNode.create(this.#alias));
-  }
-}
-preventAwait(AliasedRawBuilderImpl, "don't await AliasedRawBuilder instances directly. AliasedRawBuilder should never be executed directly since it's always a part of another query.");
-
-// node_modules/kysely/dist/esm/raw-builder/sql.js
-var sql = Object.assign((sqlFragments, ...parameters) => {
-  return createRawBuilder({
-    queryId: createQueryId(),
-    rawNode: RawNode.create(sqlFragments, parameters?.map(parseParameter) ?? [])
-  });
-}, {
-  ref(columnReference) {
-    return createRawBuilder({
-      queryId: createQueryId(),
-      rawNode: RawNode.createWithChild(parseStringReference(columnReference))
-    });
-  },
-  val(value) {
-    return createRawBuilder({
-      queryId: createQueryId(),
-      rawNode: RawNode.createWithChild(parseValueExpression(value))
-    });
-  },
-  value(value) {
-    return this.val(value);
-  },
-  table(tableReference) {
-    return createRawBuilder({
-      queryId: createQueryId(),
-      rawNode: RawNode.createWithChild(parseTable(tableReference))
-    });
-  },
-  id(...ids) {
-    const fragments = new Array(ids.length + 1).fill(".");
-    fragments[0] = "";
-    fragments[fragments.length - 1] = "";
-    return createRawBuilder({
-      queryId: createQueryId(),
-      rawNode: RawNode.create(fragments, ids.map(IdentifierNode.create))
-    });
-  },
-  lit(value) {
-    return createRawBuilder({
-      queryId: createQueryId(),
-      rawNode: RawNode.createWithChild(ValueNode.createImmediate(value))
-    });
-  },
-  literal(value) {
-    return this.lit(value);
-  },
-  raw(sql2) {
-    return createRawBuilder({
-      queryId: createQueryId(),
-      rawNode: RawNode.createWithSql(sql2)
-    });
-  },
-  join(array, separator = sql`, `) {
-    const nodes = new Array(2 * array.length - 1);
-    const sep = separator.toOperationNode();
-    for (let i = 0;i < array.length; ++i) {
-      nodes[2 * i] = parseParameter(array[i]);
-      if (i !== array.length - 1) {
-        nodes[2 * i + 1] = sep;
-      }
-    }
-    return createRawBuilder({
-      queryId: createQueryId(),
-      rawNode: RawNode.createWithChildren(nodes)
-    });
-  }
-});
-function parseParameter(param) {
-  if (isOperationNodeSource(param)) {
-    return param.toOperationNode();
-  }
-  return parseValueExpression(param);
-}
-
-// node_modules/kysely/dist/esm/operation-node/operation-node-visitor.js
-class OperationNodeVisitor {
-  nodeStack = [];
-  get parentNode() {
-    return this.nodeStack[this.nodeStack.length - 2];
-  }
-  #visitors = freeze({
-    AliasNode: this.visitAlias.bind(this),
-    ColumnNode: this.visitColumn.bind(this),
-    IdentifierNode: this.visitIdentifier.bind(this),
-    SchemableIdentifierNode: this.visitSchemableIdentifier.bind(this),
-    RawNode: this.visitRaw.bind(this),
-    ReferenceNode: this.visitReference.bind(this),
-    SelectQueryNode: this.visitSelectQuery.bind(this),
-    SelectionNode: this.visitSelection.bind(this),
-    TableNode: this.visitTable.bind(this),
-    FromNode: this.visitFrom.bind(this),
-    SelectAllNode: this.visitSelectAll.bind(this),
-    AndNode: this.visitAnd.bind(this),
-    OrNode: this.visitOr.bind(this),
-    ValueNode: this.visitValue.bind(this),
-    ValueListNode: this.visitValueList.bind(this),
-    PrimitiveValueListNode: this.visitPrimitiveValueList.bind(this),
-    ParensNode: this.visitParens.bind(this),
-    JoinNode: this.visitJoin.bind(this),
-    OperatorNode: this.visitOperator.bind(this),
-    WhereNode: this.visitWhere.bind(this),
-    InsertQueryNode: this.visitInsertQuery.bind(this),
-    DeleteQueryNode: this.visitDeleteQuery.bind(this),
-    ReturningNode: this.visitReturning.bind(this),
-    CreateTableNode: this.visitCreateTable.bind(this),
-    AddColumnNode: this.visitAddColumn.bind(this),
-    ColumnDefinitionNode: this.visitColumnDefinition.bind(this),
-    DropTableNode: this.visitDropTable.bind(this),
-    DataTypeNode: this.visitDataType.bind(this),
-    OrderByNode: this.visitOrderBy.bind(this),
-    OrderByItemNode: this.visitOrderByItem.bind(this),
-    GroupByNode: this.visitGroupBy.bind(this),
-    GroupByItemNode: this.visitGroupByItem.bind(this),
-    UpdateQueryNode: this.visitUpdateQuery.bind(this),
-    ColumnUpdateNode: this.visitColumnUpdate.bind(this),
-    LimitNode: this.visitLimit.bind(this),
-    OffsetNode: this.visitOffset.bind(this),
-    OnConflictNode: this.visitOnConflict.bind(this),
-    OnDuplicateKeyNode: this.visitOnDuplicateKey.bind(this),
-    CreateIndexNode: this.visitCreateIndex.bind(this),
-    DropIndexNode: this.visitDropIndex.bind(this),
-    ListNode: this.visitList.bind(this),
-    PrimaryKeyConstraintNode: this.visitPrimaryKeyConstraint.bind(this),
-    UniqueConstraintNode: this.visitUniqueConstraint.bind(this),
-    ReferencesNode: this.visitReferences.bind(this),
-    CheckConstraintNode: this.visitCheckConstraint.bind(this),
-    WithNode: this.visitWith.bind(this),
-    CommonTableExpressionNode: this.visitCommonTableExpression.bind(this),
-    CommonTableExpressionNameNode: this.visitCommonTableExpressionName.bind(this),
-    HavingNode: this.visitHaving.bind(this),
-    CreateSchemaNode: this.visitCreateSchema.bind(this),
-    DropSchemaNode: this.visitDropSchema.bind(this),
-    AlterTableNode: this.visitAlterTable.bind(this),
-    DropColumnNode: this.visitDropColumn.bind(this),
-    RenameColumnNode: this.visitRenameColumn.bind(this),
-    AlterColumnNode: this.visitAlterColumn.bind(this),
-    ModifyColumnNode: this.visitModifyColumn.bind(this),
-    AddConstraintNode: this.visitAddConstraint.bind(this),
-    DropConstraintNode: this.visitDropConstraint.bind(this),
-    ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
-    CreateViewNode: this.visitCreateView.bind(this),
-    DropViewNode: this.visitDropView.bind(this),
-    GeneratedNode: this.visitGenerated.bind(this),
-    DefaultValueNode: this.visitDefaultValue.bind(this),
-    OnNode: this.visitOn.bind(this),
-    ValuesNode: this.visitValues.bind(this),
-    SelectModifierNode: this.visitSelectModifier.bind(this),
-    CreateTypeNode: this.visitCreateType.bind(this),
-    DropTypeNode: this.visitDropType.bind(this),
-    ExplainNode: this.visitExplain.bind(this),
-    DefaultInsertValueNode: this.visitDefaultInsertValue.bind(this),
-    AggregateFunctionNode: this.visitAggregateFunction.bind(this),
-    OverNode: this.visitOver.bind(this),
-    PartitionByNode: this.visitPartitionBy.bind(this),
-    PartitionByItemNode: this.visitPartitionByItem.bind(this),
-    SetOperationNode: this.visitSetOperation.bind(this),
-    BinaryOperationNode: this.visitBinaryOperation.bind(this),
-    UnaryOperationNode: this.visitUnaryOperation.bind(this),
-    UsingNode: this.visitUsing.bind(this),
-    FunctionNode: this.visitFunction.bind(this),
-    CaseNode: this.visitCase.bind(this),
-    WhenNode: this.visitWhen.bind(this),
-    JSONReferenceNode: this.visitJSONReference.bind(this),
-    JSONPathNode: this.visitJSONPath.bind(this),
-    JSONPathLegNode: this.visitJSONPathLeg.bind(this),
-    JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
-    TupleNode: this.visitTuple.bind(this),
-    MergeQueryNode: this.visitMergeQuery.bind(this),
-    MatchedNode: this.visitMatched.bind(this),
-    AddIndexNode: this.visitAddIndex.bind(this),
-    CastNode: this.visitCast.bind(this),
-    FetchNode: this.visitFetch.bind(this),
-    TopNode: this.visitTop.bind(this),
-    OutputNode: this.visitOutput.bind(this)
-  });
-  visitNode = (node) => {
-    this.nodeStack.push(node);
-    this.#visitors[node.kind](node);
-    this.nodeStack.pop();
-  };
-}
-
-// node_modules/kysely/dist/esm/query-compiler/default-query-compiler.js
-class DefaultQueryCompiler extends OperationNodeVisitor {
-  #sql = "";
-  #parameters = [];
-  get numParameters() {
-    return this.#parameters.length;
-  }
-  compileQuery(node) {
-    this.#sql = "";
-    this.#parameters = [];
-    this.nodeStack.splice(0, this.nodeStack.length);
-    this.visitNode(node);
-    return freeze({
-      query: node,
-      sql: this.getSql(),
-      parameters: [...this.#parameters]
-    });
-  }
-  getSql() {
-    return this.#sql;
-  }
-  visitSelectQuery(node) {
-    const wrapInParens = this.parentNode !== undefined && !ParensNode.is(this.parentNode) && !InsertQueryNode.is(this.parentNode) && !CreateTableNode.is(this.parentNode) && !CreateViewNode.is(this.parentNode) && !SetOperationNode.is(this.parentNode);
-    if (this.parentNode === undefined && node.explain) {
-      this.visitNode(node.explain);
-      this.append(" ");
-    }
-    if (wrapInParens) {
-      this.append("(");
-    }
-    if (node.with) {
-      this.visitNode(node.with);
-      this.append(" ");
-    }
-    this.append("select");
-    if (node.distinctOn) {
-      this.append(" ");
-      this.compileDistinctOn(node.distinctOn);
-    }
-    if (node.frontModifiers?.length) {
-      this.append(" ");
-      this.compileList(node.frontModifiers, " ");
-    }
-    if (node.top) {
-      this.append(" ");
-      this.visitNode(node.top);
-    }
-    if (node.selections) {
-      this.append(" ");
-      this.compileList(node.selections);
-    }
-    if (node.from) {
-      this.append(" ");
-      this.visitNode(node.from);
-    }
-    if (node.joins) {
-      this.append(" ");
-      this.compileList(node.joins, " ");
-    }
-    if (node.where) {
-      this.append(" ");
-      this.visitNode(node.where);
-    }
-    if (node.groupBy) {
-      this.append(" ");
-      this.visitNode(node.groupBy);
-    }
-    if (node.having) {
-      this.append(" ");
-      this.visitNode(node.having);
-    }
-    if (node.setOperations) {
-      this.append(" ");
-      this.compileList(node.setOperations, " ");
-    }
-    if (node.orderBy) {
-      this.append(" ");
-      this.visitNode(node.orderBy);
-    }
-    if (node.limit) {
-      this.append(" ");
-      this.visitNode(node.limit);
-    }
-    if (node.offset) {
-      this.append(" ");
-      this.visitNode(node.offset);
-    }
-    if (node.fetch) {
-      this.append(" ");
-      this.visitNode(node.fetch);
-    }
-    if (node.endModifiers?.length) {
-      this.append(" ");
-      this.compileList(this.sortSelectModifiers([...node.endModifiers]), " ");
-    }
-    if (wrapInParens) {
-      this.append(")");
-    }
-  }
-  visitFrom(node) {
-    this.append("from ");
-    this.compileList(node.froms);
-  }
-  visitSelection(node) {
-    this.visitNode(node.selection);
-  }
-  visitColumn(node) {
-    this.visitNode(node.column);
-  }
-  compileDistinctOn(expressions) {
-    this.append("distinct on (");
-    this.compileList(expressions);
-    this.append(")");
-  }
-  compileList(nodes, separator = ", ") {
-    const lastIndex = nodes.length - 1;
-    for (let i = 0;i <= lastIndex; i++) {
-      this.visitNode(nodes[i]);
-      if (i < lastIndex) {
-        this.append(separator);
-      }
-    }
-  }
-  visitWhere(node) {
-    this.append("where ");
-    this.visitNode(node.where);
-  }
-  visitHaving(node) {
-    this.append("having ");
-    this.visitNode(node.having);
-  }
-  visitInsertQuery(node) {
-    const rootQueryNode = this.nodeStack.find(QueryNode.is);
-    const isSubQuery = rootQueryNode !== node;
-    if (!isSubQuery && node.explain) {
-      this.visitNode(node.explain);
-      this.append(" ");
-    }
-    if (isSubQuery && !MergeQueryNode.is(rootQueryNode)) {
-      this.append("(");
-    }
-    if (node.with) {
-      this.visitNode(node.with);
-      this.append(" ");
-    }
-    this.append(node.replace ? "replace" : "insert");
-    if (node.ignore) {
-      this.append(" ignore");
-    }
-    if (node.top) {
-      this.append(" ");
-      this.visitNode(node.top);
-    }
-    if (node.into) {
-      this.append(" into ");
-      this.visitNode(node.into);
-    }
-    if (node.columns) {
-      this.append(" (");
-      this.compileList(node.columns);
-      this.append(")");
-    }
-    if (node.output) {
-      this.append(" ");
-      this.visitNode(node.output);
-    }
-    if (node.values) {
-      this.append(" ");
-      this.visitNode(node.values);
-    }
-    if (node.defaultValues) {
-      this.append(" ");
-      this.append("default values");
-    }
-    if (node.onConflict) {
-      this.append(" ");
-      this.visitNode(node.onConflict);
-    }
-    if (node.onDuplicateKey) {
-      this.append(" ");
-      this.visitNode(node.onDuplicateKey);
-    }
-    if (node.returning) {
-      this.append(" ");
-      this.visitNode(node.returning);
-    }
-    if (isSubQuery && !MergeQueryNode.is(rootQueryNode)) {
-      this.append(")");
-    }
-    if (node.endModifiers?.length) {
-      this.append(" ");
-      this.compileList(node.endModifiers, " ");
-    }
-  }
-  visitValues(node) {
-    this.append("values ");
-    this.compileList(node.values);
-  }
-  visitDeleteQuery(node) {
-    const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
-    if (!isSubQuery && node.explain) {
-      this.visitNode(node.explain);
-      this.append(" ");
-    }
-    if (isSubQuery) {
-      this.append("(");
-    }
-    if (node.with) {
-      this.visitNode(node.with);
-      this.append(" ");
-    }
-    this.append("delete ");
-    if (node.top) {
-      this.visitNode(node.top);
-      this.append(" ");
-    }
-    this.visitNode(node.from);
-    if (node.output) {
-      this.append(" ");
-      this.visitNode(node.output);
-    }
-    if (node.using) {
-      this.append(" ");
-      this.visitNode(node.using);
-    }
-    if (node.joins) {
-      this.append(" ");
-      this.compileList(node.joins, " ");
-    }
-    if (node.where) {
-      this.append(" ");
-      this.visitNode(node.where);
-    }
-    if (node.orderBy) {
-      this.append(" ");
-      this.visitNode(node.orderBy);
-    }
-    if (node.limit) {
-      this.append(" ");
-      this.visitNode(node.limit);
-    }
-    if (node.returning) {
-      this.append(" ");
-      this.visitNode(node.returning);
-    }
-    if (isSubQuery) {
-      this.append(")");
-    }
-    if (node.endModifiers?.length) {
-      this.append(" ");
-      this.compileList(node.endModifiers, " ");
-    }
-  }
-  visitReturning(node) {
-    this.append("returning ");
-    this.compileList(node.selections);
-  }
-  visitAlias(node) {
-    this.visitNode(node.node);
-    this.append(" as ");
-    this.visitNode(node.alias);
-  }
-  visitReference(node) {
-    if (node.table) {
-      this.visitNode(node.table);
-      this.append(".");
-    }
-    this.visitNode(node.column);
-  }
-  visitSelectAll(_) {
-    this.append("*");
-  }
-  visitIdentifier(node) {
-    this.append(this.getLeftIdentifierWrapper());
-    this.compileUnwrappedIdentifier(node);
-    this.append(this.getRightIdentifierWrapper());
-  }
-  compileUnwrappedIdentifier(node) {
-    if (!isString(node.name)) {
-      throw new Error("a non-string identifier was passed to compileUnwrappedIdentifier.");
-    }
-    this.append(this.sanitizeIdentifier(node.name));
-  }
-  visitAnd(node) {
-    this.visitNode(node.left);
-    this.append(" and ");
-    this.visitNode(node.right);
-  }
-  visitOr(node) {
-    this.visitNode(node.left);
-    this.append(" or ");
-    this.visitNode(node.right);
-  }
-  visitValue(node) {
-    if (node.immediate) {
-      this.appendImmediateValue(node.value);
-    } else {
-      this.appendValue(node.value);
-    }
-  }
-  visitValueList(node) {
-    this.append("(");
-    this.compileList(node.values);
-    this.append(")");
-  }
-  visitTuple(node) {
-    this.append("(");
-    this.compileList(node.values);
-    this.append(")");
-  }
-  visitPrimitiveValueList(node) {
-    this.append("(");
-    const { values } = node;
-    for (let i = 0;i < values.length; ++i) {
-      this.appendValue(values[i]);
-      if (i !== values.length - 1) {
-        this.append(", ");
-      }
-    }
-    this.append(")");
-  }
-  visitParens(node) {
-    this.append("(");
-    this.visitNode(node.node);
-    this.append(")");
-  }
-  visitJoin(node) {
-    this.append(JOIN_TYPE_SQL[node.joinType]);
-    this.append(" ");
-    this.visitNode(node.table);
-    if (node.on) {
-      this.append(" ");
-      this.visitNode(node.on);
-    }
-  }
-  visitOn(node) {
-    this.append("on ");
-    this.visitNode(node.on);
-  }
-  visitRaw(node) {
-    const { sqlFragments, parameters: params } = node;
-    for (let i = 0;i < sqlFragments.length; ++i) {
-      this.append(sqlFragments[i]);
-      if (params.length > i) {
-        this.visitNode(params[i]);
-      }
-    }
-  }
-  visitOperator(node) {
-    this.append(node.operator);
-  }
-  visitTable(node) {
-    this.visitNode(node.table);
-  }
-  visitSchemableIdentifier(node) {
-    if (node.schema) {
-      this.visitNode(node.schema);
-      this.append(".");
-    }
-    this.visitNode(node.identifier);
-  }
-  visitCreateTable(node) {
-    this.append("create ");
-    if (node.frontModifiers && node.frontModifiers.length > 0) {
-      this.compileList(node.frontModifiers, " ");
-      this.append(" ");
-    }
-    if (node.temporary) {
-      this.append("temporary ");
-    }
-    this.append("table ");
-    if (node.ifNotExists) {
-      this.append("if not exists ");
-    }
-    this.visitNode(node.table);
-    if (node.selectQuery) {
-      this.append(" as ");
-      this.visitNode(node.selectQuery);
-    } else {
-      this.append(" (");
-      this.compileList([...node.columns, ...node.constraints ?? []]);
-      this.append(")");
-      if (node.onCommit) {
-        this.append(" on commit ");
-        this.append(node.onCommit);
-      }
-      if (node.endModifiers && node.endModifiers.length > 0) {
-        this.append(" ");
-        this.compileList(node.endModifiers, " ");
-      }
-    }
-  }
-  visitColumnDefinition(node) {
-    if (node.ifNotExists) {
-      this.append("if not exists ");
-    }
-    this.visitNode(node.column);
-    this.append(" ");
-    this.visitNode(node.dataType);
-    if (node.unsigned) {
-      this.append(" unsigned");
-    }
-    if (node.frontModifiers && node.frontModifiers.length > 0) {
-      this.append(" ");
-      this.compileList(node.frontModifiers, " ");
-    }
-    if (node.generated) {
-      this.append(" ");
-      this.visitNode(node.generated);
-    }
-    if (node.identity) {
-      this.append(" identity");
-    }
-    if (node.defaultTo) {
-      this.append(" ");
-      this.visitNode(node.defaultTo);
-    }
-    if (node.notNull) {
-      this.append(" not null");
-    }
-    if (node.unique) {
-      this.append(" unique");
-    }
-    if (node.nullsNotDistinct) {
-      this.append(" nulls not distinct");
-    }
-    if (node.primaryKey) {
-      this.append(" primary key");
-    }
-    if (node.autoIncrement) {
-      this.append(" ");
-      this.append(this.getAutoIncrement());
-    }
-    if (node.references) {
-      this.append(" ");
-      this.visitNode(node.references);
-    }
-    if (node.check) {
-      this.append(" ");
-      this.visitNode(node.check);
-    }
-    if (node.endModifiers && node.endModifiers.length > 0) {
-      this.append(" ");
-      this.compileList(node.endModifiers, " ");
-    }
-  }
-  getAutoIncrement() {
-    return "auto_increment";
-  }
-  visitReferences(node) {
-    this.append("references ");
-    this.visitNode(node.table);
-    this.append(" (");
-    this.compileList(node.columns);
-    this.append(")");
-    if (node.onDelete) {
-      this.append(" on delete ");
-      this.append(node.onDelete);
-    }
-    if (node.onUpdate) {
-      this.append(" on update ");
-      this.append(node.onUpdate);
-    }
-  }
-  visitDropTable(node) {
-    this.append("drop table ");
-    if (node.ifExists) {
-      this.append("if exists ");
-    }
-    this.visitNode(node.table);
-    if (node.cascade) {
-      this.append(" cascade");
-    }
-  }
-  visitDataType(node) {
-    this.append(node.dataType);
-  }
-  visitOrderBy(node) {
-    this.append("order by ");
-    this.compileList(node.items);
-  }
-  visitOrderByItem(node) {
-    this.visitNode(node.orderBy);
-    if (node.direction) {
-      this.append(" ");
-      this.visitNode(node.direction);
-    }
-  }
-  visitGroupBy(node) {
-    this.append("group by ");
-    this.compileList(node.items);
-  }
-  visitGroupByItem(node) {
-    this.visitNode(node.groupBy);
-  }
-  visitUpdateQuery(node) {
-    const rootQueryNode = this.nodeStack.find(QueryNode.is);
-    const isSubQuery = rootQueryNode !== node;
-    if (!isSubQuery && node.explain) {
-      this.visitNode(node.explain);
-      this.append(" ");
-    }
-    if (isSubQuery && !MergeQueryNode.is(rootQueryNode)) {
-      this.append("(");
-    }
-    if (node.with) {
-      this.visitNode(node.with);
-      this.append(" ");
-    }
-    this.append("update ");
-    if (node.top) {
-      this.visitNode(node.top);
-      this.append(" ");
-    }
-    if (node.table) {
-      this.visitNode(node.table);
-      this.append(" ");
-    }
-    this.append("set ");
-    if (node.updates) {
-      this.compileList(node.updates);
-    }
-    if (node.output) {
-      this.append(" ");
-      this.visitNode(node.output);
-    }
-    if (node.from) {
-      this.append(" ");
-      this.visitNode(node.from);
-    }
-    if (node.joins) {
-      this.append(" ");
-      this.compileList(node.joins, " ");
-    }
-    if (node.where) {
-      this.append(" ");
-      this.visitNode(node.where);
-    }
-    if (node.limit) {
-      this.append(" ");
-      this.visitNode(node.limit);
-    }
-    if (node.returning) {
-      this.append(" ");
-      this.visitNode(node.returning);
-    }
-    if (isSubQuery && !MergeQueryNode.is(rootQueryNode)) {
-      this.append(")");
-    }
-    if (node.endModifiers?.length) {
-      this.append(" ");
-      this.compileList(node.endModifiers, " ");
-    }
-  }
-  visitColumnUpdate(node) {
-    this.visitNode(node.column);
-    this.append(" = ");
-    this.visitNode(node.value);
-  }
-  visitLimit(node) {
-    this.append("limit ");
-    this.visitNode(node.limit);
-  }
-  visitOffset(node) {
-    this.append("offset ");
-    this.visitNode(node.offset);
-  }
-  visitOnConflict(node) {
-    this.append("on conflict");
-    if (node.columns) {
-      this.append(" (");
-      this.compileList(node.columns);
-      this.append(")");
-    } else if (node.constraint) {
-      this.append(" on constraint ");
-      this.visitNode(node.constraint);
-    } else if (node.indexExpression) {
-      this.append(" (");
-      this.visitNode(node.indexExpression);
-      this.append(")");
-    }
-    if (node.indexWhere) {
-      this.append(" ");
-      this.visitNode(node.indexWhere);
-    }
-    if (node.doNothing === true) {
-      this.append(" do nothing");
-    } else if (node.updates) {
-      this.append(" do update set ");
-      this.compileList(node.updates);
-      if (node.updateWhere) {
-        this.append(" ");
-        this.visitNode(node.updateWhere);
-      }
-    }
-  }
-  visitOnDuplicateKey(node) {
-    this.append("on duplicate key update ");
-    this.compileList(node.updates);
-  }
-  visitCreateIndex(node) {
-    this.append("create ");
-    if (node.unique) {
-      this.append("unique ");
-    }
-    this.append("index ");
-    if (node.ifNotExists) {
-      this.append("if not exists ");
-    }
-    this.visitNode(node.name);
-    if (node.table) {
-      this.append(" on ");
-      this.visitNode(node.table);
-    }
-    if (node.using) {
-      this.append(" using ");
-      this.visitNode(node.using);
-    }
-    if (node.columns) {
-      this.append(" (");
-      this.compileList(node.columns);
-      this.append(")");
-    }
-    if (node.nullsNotDistinct) {
-      this.append(" nulls not distinct");
-    }
-    if (node.where) {
-      this.append(" ");
-      this.visitNode(node.where);
-    }
-  }
-  visitDropIndex(node) {
-    this.append("drop index ");
-    if (node.ifExists) {
-      this.append("if exists ");
-    }
-    this.visitNode(node.name);
-    if (node.table) {
-      this.append(" on ");
-      this.visitNode(node.table);
-    }
-    if (node.cascade) {
-      this.append(" cascade");
-    }
-  }
-  visitCreateSchema(node) {
-    this.append("create schema ");
-    if (node.ifNotExists) {
-      this.append("if not exists ");
-    }
-    this.visitNode(node.schema);
-  }
-  visitDropSchema(node) {
-    this.append("drop schema ");
-    if (node.ifExists) {
-      this.append("if exists ");
-    }
-    this.visitNode(node.schema);
-    if (node.cascade) {
-      this.append(" cascade");
-    }
-  }
-  visitPrimaryKeyConstraint(node) {
-    if (node.name) {
-      this.append("constraint ");
-      this.visitNode(node.name);
-      this.append(" ");
-    }
-    this.append("primary key (");
-    this.compileList(node.columns);
-    this.append(")");
-  }
-  visitUniqueConstraint(node) {
-    if (node.name) {
-      this.append("constraint ");
-      this.visitNode(node.name);
-      this.append(" ");
-    }
-    this.append("unique");
-    if (node.nullsNotDistinct) {
-      this.append(" nulls not distinct");
-    }
-    this.append(" (");
-    this.compileList(node.columns);
-    this.append(")");
-  }
-  visitCheckConstraint(node) {
-    if (node.name) {
-      this.append("constraint ");
-      this.visitNode(node.name);
-      this.append(" ");
-    }
-    this.append("check (");
-    this.visitNode(node.expression);
-    this.append(")");
-  }
-  visitForeignKeyConstraint(node) {
-    if (node.name) {
-      this.append("constraint ");
-      this.visitNode(node.name);
-      this.append(" ");
-    }
-    this.append("foreign key (");
-    this.compileList(node.columns);
-    this.append(") ");
-    this.visitNode(node.references);
-    if (node.onDelete) {
-      this.append(" on delete ");
-      this.append(node.onDelete);
-    }
-    if (node.onUpdate) {
-      this.append(" on update ");
-      this.append(node.onUpdate);
-    }
-  }
-  visitList(node) {
-    this.compileList(node.items);
-  }
-  visitWith(node) {
-    this.append("with ");
-    if (node.recursive) {
-      this.append("recursive ");
-    }
-    this.compileList(node.expressions);
-  }
-  visitCommonTableExpression(node) {
-    this.visitNode(node.name);
-    this.append(" as ");
-    if (isBoolean(node.materialized)) {
-      if (!node.materialized) {
-        this.append("not ");
-      }
-      this.append("materialized ");
-    }
-    this.visitNode(node.expression);
-  }
-  visitCommonTableExpressionName(node) {
-    this.visitNode(node.table);
-    if (node.columns) {
-      this.append("(");
-      this.compileList(node.columns);
-      this.append(")");
-    }
-  }
-  visitAlterTable(node) {
-    this.append("alter table ");
-    this.visitNode(node.table);
-    this.append(" ");
-    if (node.renameTo) {
-      this.append("rename to ");
-      this.visitNode(node.renameTo);
-    }
-    if (node.setSchema) {
-      this.append("set schema ");
-      this.visitNode(node.setSchema);
-    }
-    if (node.addConstraint) {
-      this.visitNode(node.addConstraint);
-    }
-    if (node.dropConstraint) {
-      this.visitNode(node.dropConstraint);
-    }
-    if (node.columnAlterations) {
-      this.compileColumnAlterations(node.columnAlterations);
-    }
-    if (node.addIndex) {
-      this.visitNode(node.addIndex);
-    }
-    if (node.dropIndex) {
-      this.visitNode(node.dropIndex);
-    }
-  }
-  visitAddColumn(node) {
-    this.append("add column ");
-    this.visitNode(node.column);
-  }
-  visitRenameColumn(node) {
-    this.append("rename column ");
-    this.visitNode(node.column);
-    this.append(" to ");
-    this.visitNode(node.renameTo);
-  }
-  visitDropColumn(node) {
-    this.append("drop column ");
-    this.visitNode(node.column);
-  }
-  visitAlterColumn(node) {
-    this.append("alter column ");
-    this.visitNode(node.column);
-    this.append(" ");
-    if (node.dataType) {
-      if (this.announcesNewColumnDataType()) {
-        this.append("type ");
-      }
-      this.visitNode(node.dataType);
-      if (node.dataTypeExpression) {
-        this.append("using ");
-        this.visitNode(node.dataTypeExpression);
-      }
-    }
-    if (node.setDefault) {
-      this.append("set default ");
-      this.visitNode(node.setDefault);
-    }
-    if (node.dropDefault) {
-      this.append("drop default");
-    }
-    if (node.setNotNull) {
-      this.append("set not null");
-    }
-    if (node.dropNotNull) {
-      this.append("drop not null");
-    }
-  }
-  visitModifyColumn(node) {
-    this.append("modify column ");
-    this.visitNode(node.column);
-  }
-  visitAddConstraint(node) {
-    this.append("add ");
-    this.visitNode(node.constraint);
-  }
-  visitDropConstraint(node) {
-    this.append("drop constraint ");
-    if (node.ifExists) {
-      this.append("if exists ");
-    }
-    this.visitNode(node.constraintName);
-    if (node.modifier === "cascade") {
-      this.append(" cascade");
-    } else if (node.modifier === "restrict") {
-      this.append(" restrict");
-    }
-  }
-  visitSetOperation(node) {
-    this.append(node.operator);
-    this.append(" ");
-    if (node.all) {
-      this.append("all ");
-    }
-    this.visitNode(node.expression);
-  }
-  visitCreateView(node) {
-    this.append("create ");
-    if (node.orReplace) {
-      this.append("or replace ");
-    }
-    if (node.materialized) {
-      this.append("materialized ");
-    }
-    if (node.temporary) {
-      this.append("temporary ");
-    }
-    this.append("view ");
-    if (node.ifNotExists) {
-      this.append("if not exists ");
-    }
-    this.visitNode(node.name);
-    this.append(" ");
-    if (node.columns) {
-      this.append("(");
-      this.compileList(node.columns);
-      this.append(") ");
-    }
-    if (node.as) {
-      this.append("as ");
-      this.visitNode(node.as);
-    }
-  }
-  visitDropView(node) {
-    this.append("drop ");
-    if (node.materialized) {
-      this.append("materialized ");
-    }
-    this.append("view ");
-    if (node.ifExists) {
-      this.append("if exists ");
-    }
-    this.visitNode(node.name);
-    if (node.cascade) {
-      this.append(" cascade");
-    }
-  }
-  visitGenerated(node) {
-    this.append("generated ");
-    if (node.always) {
-      this.append("always ");
-    }
-    if (node.byDefault) {
-      this.append("by default ");
-    }
-    this.append("as ");
-    if (node.identity) {
-      this.append("identity");
-    }
-    if (node.expression) {
-      this.append("(");
-      this.visitNode(node.expression);
-      this.append(")");
-    }
-    if (node.stored) {
-      this.append(" stored");
-    }
-  }
-  visitDefaultValue(node) {
-    this.append("default ");
-    this.visitNode(node.defaultValue);
-  }
-  visitSelectModifier(node) {
-    if (node.rawModifier) {
-      this.visitNode(node.rawModifier);
-    } else {
-      this.append(SELECT_MODIFIER_SQL[node.modifier]);
-    }
-    if (node.of) {
-      this.append(" of ");
-      this.compileList(node.of, ", ");
-    }
-  }
-  visitCreateType(node) {
-    this.append("create type ");
-    this.visitNode(node.name);
-    if (node.enum) {
-      this.append(" as enum ");
-      this.visitNode(node.enum);
-    }
-  }
-  visitDropType(node) {
-    this.append("drop type ");
-    if (node.ifExists) {
-      this.append("if exists ");
-    }
-    this.visitNode(node.name);
-  }
-  visitExplain(node) {
-    this.append("explain");
-    if (node.options || node.format) {
-      this.append(" ");
-      this.append(this.getLeftExplainOptionsWrapper());
-      if (node.options) {
-        this.visitNode(node.options);
-        if (node.format) {
-          this.append(this.getExplainOptionsDelimiter());
-        }
-      }
-      if (node.format) {
-        this.append("format");
-        this.append(this.getExplainOptionAssignment());
-        this.append(node.format);
-      }
-      this.append(this.getRightExplainOptionsWrapper());
-    }
-  }
-  visitDefaultInsertValue(_) {
-    this.append("default");
-  }
-  visitAggregateFunction(node) {
-    this.append(node.func);
-    this.append("(");
-    if (node.distinct) {
-      this.append("distinct ");
-    }
-    this.compileList(node.aggregated);
-    if (node.orderBy) {
-      this.append(" ");
-      this.visitNode(node.orderBy);
-    }
-    this.append(")");
-    if (node.filter) {
-      this.append(" filter(");
-      this.visitNode(node.filter);
-      this.append(")");
-    }
-    if (node.over) {
-      this.append(" ");
-      this.visitNode(node.over);
-    }
-  }
-  visitOver(node) {
-    this.append("over(");
-    if (node.partitionBy) {
-      this.visitNode(node.partitionBy);
-      if (node.orderBy) {
-        this.append(" ");
-      }
-    }
-    if (node.orderBy) {
-      this.visitNode(node.orderBy);
-    }
-    this.append(")");
-  }
-  visitPartitionBy(node) {
-    this.append("partition by ");
-    this.compileList(node.items);
-  }
-  visitPartitionByItem(node) {
-    this.visitNode(node.partitionBy);
-  }
-  visitBinaryOperation(node) {
-    this.visitNode(node.leftOperand);
-    this.append(" ");
-    this.visitNode(node.operator);
-    this.append(" ");
-    this.visitNode(node.rightOperand);
-  }
-  visitUnaryOperation(node) {
-    this.visitNode(node.operator);
-    if (!this.isMinusOperator(node.operator)) {
-      this.append(" ");
-    }
-    this.visitNode(node.operand);
-  }
-  isMinusOperator(node) {
-    return OperatorNode.is(node) && node.operator === "-";
-  }
-  visitUsing(node) {
-    this.append("using ");
-    this.compileList(node.tables);
-  }
-  visitFunction(node) {
-    this.append(node.func);
-    this.append("(");
-    this.compileList(node.arguments);
-    this.append(")");
-  }
-  visitCase(node) {
-    this.append("case");
-    if (node.value) {
-      this.append(" ");
-      this.visitNode(node.value);
-    }
-    if (node.when) {
-      this.append(" ");
-      this.compileList(node.when, " ");
-    }
-    if (node.else) {
-      this.append(" else ");
-      this.visitNode(node.else);
-    }
-    this.append(" end");
-    if (node.isStatement) {
-      this.append(" case");
-    }
-  }
-  visitWhen(node) {
-    this.append("when ");
-    this.visitNode(node.condition);
-    if (node.result) {
-      this.append(" then ");
-      this.visitNode(node.result);
-    }
-  }
-  visitJSONReference(node) {
-    this.visitNode(node.reference);
-    this.visitNode(node.traversal);
-  }
-  visitJSONPath(node) {
-    if (node.inOperator) {
-      this.visitNode(node.inOperator);
-    }
-    this.append("'$");
-    for (const pathLeg of node.pathLegs) {
-      this.visitNode(pathLeg);
-    }
-    this.append("'");
-  }
-  visitJSONPathLeg(node) {
-    const isArrayLocation = node.type === "ArrayLocation";
-    this.append(isArrayLocation ? "[" : ".");
-    this.append(String(node.value));
-    if (isArrayLocation) {
-      this.append("]");
-    }
-  }
-  visitJSONOperatorChain(node) {
-    for (let i = 0, len = node.values.length;i < len; i++) {
-      if (i === len - 1) {
-        this.visitNode(node.operator);
-      } else {
-        this.append("->");
-      }
-      this.visitNode(node.values[i]);
-    }
-  }
-  visitMergeQuery(node) {
-    if (node.with) {
-      this.visitNode(node.with);
-      this.append(" ");
-    }
-    this.append("merge ");
-    if (node.top) {
-      this.visitNode(node.top);
-      this.append(" ");
-    }
-    this.append("into ");
-    this.visitNode(node.into);
-    if (node.using) {
-      this.append(" ");
-      this.visitNode(node.using);
-    }
-    if (node.whens) {
-      this.append(" ");
-      this.compileList(node.whens, " ");
-    }
-    if (node.output) {
-      this.append(" ");
-      this.visitNode(node.output);
-    }
-    if (node.endModifiers?.length) {
-      this.append(" ");
-      this.compileList(node.endModifiers, " ");
-    }
-  }
-  visitMatched(node) {
-    if (node.not) {
-      this.append("not ");
-    }
-    this.append("matched");
-    if (node.bySource) {
-      this.append(" by source");
-    }
-  }
-  visitAddIndex(node) {
-    this.append("add ");
-    if (node.unique) {
-      this.append("unique ");
-    }
-    this.append("index ");
-    this.visitNode(node.name);
-    if (node.columns) {
-      this.append(" (");
-      this.compileList(node.columns);
-      this.append(")");
-    }
-    if (node.using) {
-      this.append(" using ");
-      this.visitNode(node.using);
-    }
-  }
-  visitCast(node) {
-    this.append("cast(");
-    this.visitNode(node.expression);
-    this.append(" as ");
-    this.visitNode(node.dataType);
-    this.append(")");
-  }
-  visitFetch(node) {
-    this.append("fetch next ");
-    this.visitNode(node.rowCount);
-    this.append(` rows ${node.modifier}`);
-  }
-  visitOutput(node) {
-    this.append("output ");
-    this.compileList(node.selections);
-  }
-  visitTop(node) {
-    this.append(`top(${node.expression})`);
-    if (node.modifiers) {
-      this.append(` ${node.modifiers}`);
-    }
-  }
-  append(str) {
-    this.#sql += str;
-  }
-  appendValue(parameter) {
-    this.addParameter(parameter);
-    this.append(this.getCurrentParameterPlaceholder());
-  }
-  getLeftIdentifierWrapper() {
-    return '"';
-  }
-  getRightIdentifierWrapper() {
-    return '"';
-  }
-  getCurrentParameterPlaceholder() {
-    return "$" + this.numParameters;
-  }
-  getLeftExplainOptionsWrapper() {
-    return "(";
-  }
-  getExplainOptionAssignment() {
-    return " ";
-  }
-  getExplainOptionsDelimiter() {
-    return ", ";
-  }
-  getRightExplainOptionsWrapper() {
-    return ")";
-  }
-  sanitizeIdentifier(identifier) {
-    const leftWrap = this.getLeftIdentifierWrapper();
-    const rightWrap = this.getRightIdentifierWrapper();
-    let sanitized = "";
-    for (const c of identifier) {
-      sanitized += c;
-      if (c === leftWrap) {
-        sanitized += leftWrap;
-      } else if (c === rightWrap) {
-        sanitized += rightWrap;
-      }
-    }
-    return sanitized;
-  }
-  addParameter(parameter) {
-    this.#parameters.push(parameter);
-  }
-  appendImmediateValue(value) {
-    if (isString(value)) {
-      this.append(`'${value}'`);
-    } else if (isNumber(value) || isBoolean(value)) {
-      this.append(value.toString());
-    } else if (isNull(value)) {
-      this.append("null");
-    } else if (isDate(value)) {
-      this.appendImmediateValue(value.toISOString());
-    } else if (isBigInt(value)) {
-      this.appendImmediateValue(value.toString());
-    } else {
-      throw new Error(`invalid immediate value ${value}`);
-    }
-  }
-  sortSelectModifiers(arr) {
-    arr.sort((left, right) => left.modifier && right.modifier ? SELECT_MODIFIER_PRIORITY[left.modifier] - SELECT_MODIFIER_PRIORITY[right.modifier] : 1);
-    return freeze(arr);
-  }
-  compileColumnAlterations(columnAlterations) {
-    this.compileList(columnAlterations);
-  }
-  announcesNewColumnDataType() {
-    return true;
-  }
-}
-var SELECT_MODIFIER_SQL = freeze({
-  ForKeyShare: "for key share",
-  ForNoKeyUpdate: "for no key update",
-  ForUpdate: "for update",
-  ForShare: "for share",
-  NoWait: "nowait",
-  SkipLocked: "skip locked",
-  Distinct: "distinct"
-});
-var SELECT_MODIFIER_PRIORITY = freeze({
-  ForKeyShare: 1,
-  ForNoKeyUpdate: 1,
-  ForUpdate: 1,
-  ForShare: 1,
-  NoWait: 2,
-  SkipLocked: 2,
-  Distinct: 0
-});
-var JOIN_TYPE_SQL = freeze({
-  InnerJoin: "inner join",
-  LeftJoin: "left join",
-  RightJoin: "right join",
-  FullJoin: "full join",
-  LateralInnerJoin: "inner join lateral",
-  LateralLeftJoin: "left join lateral",
-  Using: "using"
-});
-
-// node_modules/kysely/dist/esm/query-compiler/compiled-query.js
-var CompiledQuery = freeze({
-  raw(sql2, parameters = []) {
-    return freeze({
-      sql: sql2,
-      query: RawNode.createWithSql(sql2),
-      parameters: freeze(parameters)
-    });
-  }
-});
-
-// node_modules/kysely/dist/esm/dialect/dialect-adapter-base.js
-class DialectAdapterBase {
-  get supportsCreateIfNotExists() {
-    return true;
-  }
-  get supportsTransactionalDdl() {
-    return false;
-  }
-  get supportsReturning() {
-    return false;
-  }
-  get supportsOutput() {
-    return false;
-  }
-}
-
-// node_modules/kysely/dist/esm/dialect/sqlite/sqlite-query-compiler.js
-var ID_WRAP_REGEX = /"/g;
-
-class SqliteQueryCompiler extends DefaultQueryCompiler {
-  getCurrentParameterPlaceholder() {
-    return "?";
-  }
-  getLeftExplainOptionsWrapper() {
-    return "";
-  }
-  getRightExplainOptionsWrapper() {
-    return "";
-  }
-  getLeftIdentifierWrapper() {
-    return '"';
-  }
-  getRightIdentifierWrapper() {
-    return '"';
-  }
-  getAutoIncrement() {
-    return "autoincrement";
-  }
-  sanitizeIdentifier(identifier) {
-    return identifier.replace(ID_WRAP_REGEX, '""');
-  }
-  visitDefaultInsertValue(_) {
-    this.append("null");
-  }
-}
-
-// node_modules/kysely/dist/esm/plugin/noop-plugin.js
-class NoopPlugin {
-  transformQuery(args) {
-    return args.node;
-  }
-  async transformResult(args) {
-    return args.result;
-  }
-}
-
-// node_modules/kysely/dist/esm/migration/migrator.js
-var DEFAULT_MIGRATION_TABLE = "kysely_migration";
-var DEFAULT_MIGRATION_LOCK_TABLE = "kysely_migration_lock";
-var DEFAULT_ALLOW_UNORDERED_MIGRATIONS = false;
-var MIGRATION_LOCK_ID = "migration_lock";
-var NO_MIGRATIONS = freeze({ __noMigrations__: true });
-
-class Migrator {
-  #props;
-  constructor(props) {
-    this.#props = freeze(props);
-  }
-  async getMigrations() {
-    const executedMigrations = await this.#doesTableExists(this.#migrationTable) ? await this.#props.db.withPlugin(this.#schemaPlugin).selectFrom(this.#migrationTable).select(["name", "timestamp"]).$narrowType().execute() : [];
-    const migrations = await this.#resolveMigrations();
-    return migrations.map(({ name, ...migration }) => {
-      const executed = executedMigrations.find((it) => it.name === name);
-      return {
-        name,
-        migration,
-        executedAt: executed ? new Date(executed.timestamp) : undefined
-      };
-    });
-  }
-  async migrateToLatest() {
-    return this.#migrate(() => ({ direction: "Up", step: Infinity }));
-  }
-  async migrateTo(targetMigrationName) {
-    return this.#migrate(({ migrations, executedMigrations, pendingMigrations }) => {
-      if (targetMigrationName === NO_MIGRATIONS) {
-        return { direction: "Down", step: Infinity };
-      }
-      if (!migrations.find((m) => m.name === targetMigrationName)) {
-        throw new Error(`migration "${targetMigrationName}" doesn't exist`);
-      }
-      const executedIndex = executedMigrations.indexOf(targetMigrationName);
-      const pendingIndex = pendingMigrations.findIndex((m) => m.name === targetMigrationName);
-      if (executedIndex !== -1) {
-        return {
-          direction: "Down",
-          step: executedMigrations.length - executedIndex - 1
-        };
-      } else if (pendingIndex !== -1) {
-        return { direction: "Up", step: pendingIndex + 1 };
-      } else {
-        throw new Error(`migration "${targetMigrationName}" isn't executed or pending`);
-      }
-    });
-  }
-  async migrateUp() {
-    return this.#migrate(() => ({ direction: "Up", step: 1 }));
-  }
-  async migrateDown() {
-    return this.#migrate(() => ({ direction: "Down", step: 1 }));
-  }
-  async#migrate(getMigrationDirectionAndStep) {
-    try {
-      await this.#ensureMigrationTablesExists();
-      return await this.#runMigrations(getMigrationDirectionAndStep);
-    } catch (error) {
-      if (error instanceof MigrationResultSetError) {
-        return error.resultSet;
-      }
-      return { error };
-    }
-  }
-  get #migrationTableSchema() {
-    return this.#props.migrationTableSchema;
-  }
-  get #migrationTable() {
-    return this.#props.migrationTableName ?? DEFAULT_MIGRATION_TABLE;
-  }
-  get #migrationLockTable() {
-    return this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE;
-  }
-  get #allowUnorderedMigrations() {
-    return this.#props.allowUnorderedMigrations ?? DEFAULT_ALLOW_UNORDERED_MIGRATIONS;
-  }
-  get #schemaPlugin() {
-    if (this.#migrationTableSchema) {
-      return new WithSchemaPlugin(this.#migrationTableSchema);
-    }
-    return new NoopPlugin;
-  }
-  async#ensureMigrationTablesExists() {
-    await this.#ensureMigrationTableSchemaExists();
-    await this.#ensureMigrationTableExists();
-    await this.#ensureMigrationLockTableExists();
-    await this.#ensureLockRowExists();
-  }
-  async#ensureMigrationTableSchemaExists() {
-    if (!this.#migrationTableSchema) {
-      return;
-    }
-    if (!await this.#doesSchemaExists()) {
-      try {
-        await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-      } catch (error) {
-        if (!await this.#doesSchemaExists()) {
-          throw error;
-        }
-      }
-    }
-  }
-  async#ensureMigrationTableExists() {
-    if (!await this.#doesTableExists(this.#migrationTable)) {
-      try {
-        if (this.#migrationTableSchema) {
-          await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-        }
-        await this.#createIfNotExists(this.#props.db.schema.withPlugin(this.#schemaPlugin).createTable(this.#migrationTable).addColumn("name", "varchar(255)", (col) => col.notNull().primaryKey()).addColumn("timestamp", "varchar(255)", (col) => col.notNull()));
-      } catch (error) {
-        if (!await this.#doesTableExists(this.#migrationTable)) {
-          throw error;
-        }
-      }
-    }
-  }
-  async#ensureMigrationLockTableExists() {
-    if (!await this.#doesTableExists(this.#migrationLockTable)) {
-      try {
-        await this.#createIfNotExists(this.#props.db.schema.withPlugin(this.#schemaPlugin).createTable(this.#migrationLockTable).addColumn("id", "varchar(255)", (col) => col.notNull().primaryKey()).addColumn("is_locked", "integer", (col) => col.notNull().defaultTo(0)));
-      } catch (error) {
-        if (!await this.#doesTableExists(this.#migrationLockTable)) {
-          throw error;
-        }
-      }
-    }
-  }
-  async#ensureLockRowExists() {
-    if (!await this.#doesLockRowExists()) {
-      try {
-        await this.#props.db.withPlugin(this.#schemaPlugin).insertInto(this.#migrationLockTable).values({ id: MIGRATION_LOCK_ID, is_locked: 0 }).execute();
-      } catch (error) {
-        if (!await this.#doesLockRowExists()) {
-          throw error;
-        }
-      }
-    }
-  }
-  async#doesSchemaExists() {
-    const schemas = await this.#props.db.introspection.getSchemas();
-    return schemas.some((it) => it.name === this.#migrationTableSchema);
-  }
-  async#doesTableExists(tableName) {
-    const schema = this.#migrationTableSchema;
-    const tables = await this.#props.db.introspection.getTables({
-      withInternalKyselyTables: true
-    });
-    return tables.some((it) => it.name === tableName && (!schema || it.schema === schema));
-  }
-  async#doesLockRowExists() {
-    const lockRow = await this.#props.db.withPlugin(this.#schemaPlugin).selectFrom(this.#migrationLockTable).where("id", "=", MIGRATION_LOCK_ID).select("id").executeTakeFirst();
-    return !!lockRow;
-  }
-  async#runMigrations(getMigrationDirectionAndStep) {
-    const adapter = this.#props.db.getExecutor().adapter;
-    const lockOptions = freeze({
-      lockTable: this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE,
-      lockRowId: MIGRATION_LOCK_ID,
-      lockTableSchema: this.#props.migrationTableSchema
-    });
-    const run = async (db) => {
-      try {
-        await adapter.acquireMigrationLock(db, lockOptions);
-        const state = await this.#getState(db);
-        if (state.migrations.length === 0) {
-          return { results: [] };
-        }
-        const { direction, step } = getMigrationDirectionAndStep(state);
-        if (step <= 0) {
-          return { results: [] };
-        }
-        if (direction === "Down") {
-          return await this.#migrateDown(db, state, step);
-        } else if (direction === "Up") {
-          return await this.#migrateUp(db, state, step);
-        }
-        return { results: [] };
-      } finally {
-        await adapter.releaseMigrationLock(db, lockOptions);
-      }
-    };
-    if (adapter.supportsTransactionalDdl) {
-      return this.#props.db.transaction().execute(run);
-    } else {
-      return this.#props.db.connection().execute(run);
-    }
-  }
-  async#getState(db) {
-    const migrations = await this.#resolveMigrations();
-    const executedMigrations = await this.#getExecutedMigrations(db);
-    this.#ensureNoMissingMigrations(migrations, executedMigrations);
-    if (!this.#allowUnorderedMigrations) {
-      this.#ensureMigrationsInOrder(migrations, executedMigrations);
-    }
-    const pendingMigrations = this.#getPendingMigrations(migrations, executedMigrations);
-    return freeze({
-      migrations,
-      executedMigrations,
-      lastMigration: getLast(executedMigrations),
-      pendingMigrations
-    });
-  }
-  #getPendingMigrations(migrations, executedMigrations) {
-    return migrations.filter((migration) => {
-      return !executedMigrations.includes(migration.name);
-    });
-  }
-  async#resolveMigrations() {
-    const allMigrations = await this.#props.provider.getMigrations();
-    return Object.keys(allMigrations).sort().map((name) => ({
-      ...allMigrations[name],
-      name
-    }));
-  }
-  async#getExecutedMigrations(db) {
-    const executedMigrations = await db.withPlugin(this.#schemaPlugin).selectFrom(this.#migrationTable).select(["name", "timestamp"]).$narrowType().execute();
-    const nameComparator = this.#props.nameComparator || ((a, b) => a.localeCompare(b));
-    return executedMigrations.sort((a, b) => {
-      if (a.timestamp === b.timestamp) {
-        return nameComparator(a.name, b.name);
-      }
-      return new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime();
-    }).map((it) => it.name);
-  }
-  #ensureNoMissingMigrations(migrations, executedMigrations) {
-    for (const executed of executedMigrations) {
-      if (!migrations.some((it) => it.name === executed)) {
-        throw new Error(`corrupted migrations: previously executed migration ${executed} is missing`);
-      }
-    }
-  }
-  #ensureMigrationsInOrder(migrations, executedMigrations) {
-    for (let i = 0;i < executedMigrations.length; ++i) {
-      if (migrations[i].name !== executedMigrations[i]) {
-        throw new Error(`corrupted migrations: expected previously executed migration ${executedMigrations[i]} to be at index ${i} but ${migrations[i].name} was found in its place. New migrations must always have a name that comes alphabetically after the last executed migration.`);
-      }
-    }
-  }
-  async#migrateDown(db, state, step) {
-    const migrationsToRollback = state.executedMigrations.slice().reverse().slice(0, step).map((name) => {
-      return state.migrations.find((it) => it.name === name);
-    });
-    const results = migrationsToRollback.map((migration) => {
-      return {
-        migrationName: migration.name,
-        direction: "Down",
-        status: "NotExecuted"
-      };
-    });
-    for (let i = 0;i < results.length; ++i) {
-      const migration = migrationsToRollback[i];
-      try {
-        if (migration.down) {
-          await migration.down(db);
-          await db.withPlugin(this.#schemaPlugin).deleteFrom(this.#migrationTable).where("name", "=", migration.name).execute();
-          results[i] = {
-            migrationName: migration.name,
-            direction: "Down",
-            status: "Success"
-          };
-        }
-      } catch (error) {
-        results[i] = {
-          migrationName: migration.name,
-          direction: "Down",
-          status: "Error"
-        };
-        throw new MigrationResultSetError({
-          error,
-          results
-        });
-      }
-    }
-    return { results };
-  }
-  async#migrateUp(db, state, step) {
-    const migrationsToRun = state.pendingMigrations.slice(0, step);
-    const results = migrationsToRun.map((migration) => {
-      return {
-        migrationName: migration.name,
-        direction: "Up",
-        status: "NotExecuted"
-      };
-    });
-    for (let i = 0;i < results.length; i++) {
-      const migration = state.pendingMigrations[i];
-      try {
-        await migration.up(db);
-        await db.withPlugin(this.#schemaPlugin).insertInto(this.#migrationTable).values({
-          name: migration.name,
-          timestamp: new Date().toISOString()
-        }).execute();
-        results[i] = {
-          migrationName: migration.name,
-          direction: "Up",
-          status: "Success"
-        };
-      } catch (error) {
-        results[i] = {
-          migrationName: migration.name,
-          direction: "Up",
-          status: "Error"
-        };
-        throw new MigrationResultSetError({
-          error,
-          results
-        });
-      }
-    }
-    return { results };
-  }
-  async#createIfNotExists(qb) {
-    if (this.#props.db.getExecutor().adapter.supportsCreateIfNotExists) {
-      qb = qb.ifNotExists();
-    }
-    await qb.execute();
-  }
-}
-
-class MigrationResultSetError extends Error {
-  #resultSet;
-  constructor(result) {
-    super();
-    this.#resultSet = result;
-  }
-  get resultSet() {
-    return this.#resultSet;
-  }
-}
-
-// node_modules/kysely/dist/esm/dialect/sqlite/sqlite-introspector.js
-class SqliteIntrospector {
-  #db;
-  constructor(db) {
-    this.#db = db;
-  }
-  async getSchemas() {
-    return [];
-  }
-  async getTables(options = { withInternalKyselyTables: false }) {
-    return await this.#getTableMetadata(options);
-  }
-  async getMetadata(options) {
-    return {
-      tables: await this.getTables(options)
-    };
-  }
-  #tablesQuery(qb, options) {
-    let tablesQuery = qb.selectFrom("sqlite_master").where("type", "in", ["table", "view"]).where("name", "not like", "sqlite_%").select(["name", "sql", "type"]).orderBy("name");
-    if (!options.withInternalKyselyTables) {
-      tablesQuery = tablesQuery.where("name", "!=", DEFAULT_MIGRATION_TABLE).where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
-    }
-    return tablesQuery;
-  }
-  async#getTableMetadata(options) {
-    const tablesResult = await this.#tablesQuery(this.#db, options).execute();
-    const tableMetadata = await this.#db.with("table_list", (qb) => this.#tablesQuery(qb, options)).selectFrom([
-      "table_list as tl",
-      sql`pragma_table_info(tl.name)`.as("p")
-    ]).select([
-      "tl.name as table",
-      "p.cid",
-      "p.name",
-      "p.type",
-      "p.notnull",
-      "p.dflt_value",
-      "p.pk"
-    ]).orderBy(["tl.name", "p.cid"]).execute();
-    const columnsByTable = {};
-    for (const row of tableMetadata) {
-      columnsByTable[row.table] ??= [];
-      columnsByTable[row.table].push(row);
-    }
-    return tablesResult.map(({ name, sql: sql2, type }) => {
-      let autoIncrementCol = sql2?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.trimStart()?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
-      const columns = columnsByTable[name] ?? [];
-      if (!autoIncrementCol) {
-        const pkCols = columns.filter((r) => r.pk > 0);
-        if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === "integer") {
-          autoIncrementCol = pkCols[0].name;
-        }
-      }
-      return {
-        name,
-        isView: type === "view",
-        columns: columns.map((col) => ({
-          name: col.name,
-          dataType: col.type,
-          isNullable: !col.notnull,
-          isAutoIncrementing: col.name === autoIncrementCol,
-          hasDefaultValue: col.dflt_value != null,
-          comment: undefined
-        }))
-      };
-    });
-  }
-}
-
-// node_modules/kysely/dist/esm/dialect/sqlite/sqlite-adapter.js
-class SqliteAdapter extends DialectAdapterBase {
-  get supportsTransactionalDdl() {
-    return false;
-  }
-  get supportsReturning() {
-    return true;
-  }
-  async acquireMigrationLock(_db, _opt) {}
-  async releaseMigrationLock(_db, _opt) {}
-}
-
-// src/migrations/runner.ts
-class MigrationRunner {
-  #db;
-  #table;
-  constructor(db, table = "_peta_migrations") {
-    this.#db = db;
-    this.#table = table;
-  }
-  async ensureTable() {
-    await this.#db.schema.createTable(this.#table).ifNotExists().addColumn("name", "varchar", (c) => c.notNull().primaryKey()).addColumn("applied_at", "timestamp", (c) => c.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
-  }
-  async getCompleted() {
-    try {
-      const rows = await this.#db.selectFrom(this.#table).select(["name", "applied_at"]).orderBy("name", "asc").execute();
-      return rows.map((r) => ({ name: r.name, appliedAt: r.applied_at }));
-    } catch {
-      return [];
-    }
-  }
-  async up(migrations) {
-    await this.ensureTable();
-    const completed = await this.getCompleted();
-    const completedNames = new Set(completed.map((r) => r.name));
-    const pending = migrations.filter((m) => !completedNames.has(m.name)).sort(byName);
-    for (const m of pending) {
-      await m.up(this.#db);
-      await this.#db.insertInto(this.#table).values({ name: m.name, applied_at: new Date().toISOString() }).execute();
-    }
-  }
-  async down(migrations) {
-    const completed = await this.getCompleted();
-    if (completed.length === 0 || migrations.length === 0)
-      return;
-    const applied = migrations.filter((m) => completed.some((r) => r.name === m.name)).sort(byName).reverse();
-    const lastBatch = applied[0]?.name;
-    if (!lastBatch)
-      return;
-    for (const m of applied) {
-      await m.down(this.#db);
-      await this.#db.deleteFrom(this.#table).where("name", "=", m.name).execute();
-    }
-  }
-  async status(migrations) {
-    const completed = await this.getCompleted();
-    const completedNames = new Set(completed.map((r) => r.name));
-    const pending = migrations.filter((m) => !completedNames.has(m.name)).sort(byName);
-    return { completed, pending };
-  }
-}
-function byName(a, b) {
-  return a.name.localeCompare(b.name);
-}
-
-// src/migrations/generator.ts
-class MigrationGenerator {
-  generateInitialMigration(models, options = {}) {
-    const name = options.name ?? "Initial";
-    const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
-    const parts = [];
-    const indexParts = [];
-    const warnings = [];
-    const registeredTables = new Set([...models.values()].map((m) => m.table).filter(Boolean));
-    for (const [, modelClass] of models) {
-      const table = modelClass.table;
-      if (!table)
-        continue;
-      const cols = modelClass.columns;
-      parts.push(this.#generateCreateTable(table, cols));
-      for (const [colName, col] of Object.entries(cols)) {
-        if (col.hasConstraint("index") && !col.isPrimaryKey && !col.isUnique) {
-          indexParts.push(this.#generateCreateIndex(table, colName));
-        }
-      }
-      for (const [relName, rel] of Object.entries(modelClass.relations ?? {})) {
-        if (rel instanceof ManyToMany) {
-          const through = rel.throughTable;
-          if (!registeredTables.has(through)) {
-            warnings.push(`// \u26A0 Detected ManyToMany "${modelClass.name}.${relName}" references table "${through}" ` + `but no model is registered for it.
-` + `//   Add a model class with static override table = "${through}" to include the pivot ` + `table in the generated migration.`);
-          }
-        }
-      }
-    }
-    const upBody = [...parts, ...indexParts].join(`
-
-`);
-    const downTables = [...models.values()].filter((m) => m.table).map((m) => `  await db.schema.dropTable("${m.table}").ifExists().execute()`);
-    const warningBlock = warnings.length > 0 ? `  // Warnings:
-${warnings.join(`
-`)}
-
-` : "";
-    return `import type { Kysely } from "kysely"
-import { sql } from "kysely"
-
-export async function up(db: Kysely<any>): Promise<void> {
-${warningBlock}${upBody}
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-${downTables.join(`
-`)}
-}
-`;
-  }
-  #generateCreateTable(table, columns) {
-    const lines = [];
-    lines.push(`  await db.schema.createTable("${table}").ifNotExists()`);
-    for (const [name, col] of Object.entries(columns)) {
-      const typeSql = this.#mapType(col);
-      const cb = this.#columnCallback(col);
-      lines.push(`    .addColumn("${name}", "${typeSql}"${cb})`);
-    }
-    lines.push("    .execute()");
-    return lines.join(`
-`);
-  }
-  #generateCreateIndex(table, column) {
-    return [
-      `  await db.schema.createIndex("${table}_${column}_index")`,
-      `    .on("${table}")`,
-      `    .column("${column}")`,
-      "    .execute()"
-    ].join(`
-`);
-  }
-  #columnCallback(col) {
-    const calls = [];
-    if (col.isPrimaryKey) {
-      if (col.dataType === "integer") {
-        calls.push("autoIncrement()");
-      }
-      calls.push("primaryKey()");
-    }
-    if (!col.isNullable && !col.isPrimaryKey) {
-      calls.push("notNull()");
-    }
-    const dv = col.defaultValue;
-    if (dv !== undefined && typeof dv !== "function") {
-      calls.push(`defaultTo(${JSON.stringify(dv)})`);
-    }
-    if (col.isUnique && !col.isPrimaryKey) {
-      calls.push("unique()");
-    }
-    const refConstraint = col.constraints.find((c) => c.type === "references");
-    if (refConstraint?.args[0]) {
-      const targetClass = typeof refConstraint.args[0] === "function" ? refConstraint.args[0]() : refConstraint.args[0];
-      const targetTable = targetClass?.table;
-      const targetColumns = refConstraint.args[1];
-      if (typeof targetTable === "string" && targetTable && targetColumns?.length) {
-        calls.push(`references("${targetTable}.${targetColumns[0]}")`);
-      }
-    }
-    if (calls.length === 0)
-      return "";
-    const str = calls.join(".");
-    return `, (c) => c.${str}`;
-  }
-  #mapType(col) {
-    switch (col.dataType) {
-      case "integer":
-      case "smallint":
-      case "bigint":
-      case "text":
-      case "boolean":
-      case "timestamp":
-      case "date":
-      case "float":
-      case "double":
-      case "uuid":
-        return col.dataType;
-      case "string": {
-        const max = col.args[0];
-        return max != null ? `varchar(${max})` : "varchar";
-      }
-      case "json":
-      case "jsonb":
-        return "json";
-      case "decimal": {
-        const p = col.args[0];
-        const s = col.args[1];
-        return p != null ? `decimal(${p}, ${s ?? 0})` : "decimal";
-      }
-      case "enum": {
-        return "text";
-      }
-      default:
-        return col.dataType;
-    }
-  }
-}
-
-// src/migrations/config.ts
-import { Database } from "bun:sqlite";
-
-// node_modules/kysely-bun-sqlite/dist/index.js
-var BunSqliteDriver = class {
-  #config;
-  #connectionMutex = new ConnectionMutex;
-  #db;
-  #connection;
-  constructor(config) {
-    this.#config = { ...config };
-  }
-  async init() {
-    this.#db = this.#config.database;
-    this.#connection = new BunSqliteConnection(this.#db);
-    if (this.#config.onCreateConnection) {
-      await this.#config.onCreateConnection(this.#connection);
-    }
-  }
-  async acquireConnection() {
-    await this.#connectionMutex.lock();
-    return this.#connection;
-  }
-  async beginTransaction(connection) {
-    await connection.executeQuery(CompiledQuery.raw("begin"));
-  }
-  async commitTransaction(connection) {
-    await connection.executeQuery(CompiledQuery.raw("commit"));
-  }
-  async rollbackTransaction(connection) {
-    await connection.executeQuery(CompiledQuery.raw("rollback"));
-  }
-  async releaseConnection() {
-    this.#connectionMutex.unlock();
-  }
-  async destroy() {
-    this.#db?.close();
-  }
-};
-var BunSqliteConnection = class {
-  #db;
-  constructor(db) {
-    this.#db = db;
-  }
-  executeQuery(compiledQuery) {
-    const { sql: sql2, parameters } = compiledQuery;
-    const stmt = this.#db.prepare(sql2);
-    if (stmt.columnNames.length > 0) {
-      return Promise.resolve({
-        rows: stmt.all(parameters)
-      });
-    }
-    const results = stmt.run(parameters);
-    return Promise.resolve({
-      insertId: BigInt(results.lastInsertRowid),
-      numAffectedRows: BigInt(results.changes),
-      rows: []
-    });
-  }
-  async* streamQuery(compiledQuery) {
-    const { sql: sql2, parameters } = compiledQuery;
-    const stmt = this.#db.prepare(sql2);
-    if (!("iterator" in stmt)) {
-      throw new Error("bun:sqlite supports streaming in 1.1.31 or above. Please upgrade to use streaming.");
-    }
-    for await (const row of stmt.iterate(parameters)) {
-      yield { rows: [row] };
-    }
-  }
-};
-var ConnectionMutex = class {
-  #promise;
-  #resolve;
-  async lock() {
-    while (this.#promise) {
-      await this.#promise;
-    }
-    this.#promise = new Promise((resolve) => {
-      this.#resolve = resolve;
-    });
-  }
-  unlock() {
-    const resolve = this.#resolve;
-    this.#promise = undefined;
-    this.#resolve = undefined;
-    resolve?.();
-  }
-};
-var BunSqliteDialect = class {
-  #config;
-  constructor(config) {
-    this.#config = { ...config };
-  }
-  createDriver() {
-    return new BunSqliteDriver(this.#config);
-  }
-  createQueryCompiler() {
-    return new SqliteQueryCompiler;
-  }
-  createAdapter() {
-    return new SqliteAdapter;
-  }
-  createIntrospector(db) {
-    return new SqliteIntrospector(db);
-  }
-};
-
-// src/migrations/config.ts
-import { readdirSync } from "fs";
-import { resolve } from "path";
-function defineConfig(config) {
-  return config;
-}
-async function resolveModels(models) {
-  if (Array.isArray(models))
-    return models;
-  const resolved = [];
-  const bunModule = await Promise.resolve(globalThis.Bun).catch(() => null);
-  const Glob = bunModule?.Glob ?? null;
-  if (!Glob)
-    throw new Error("String models pattern requires Bun");
-  let matched = false;
-  for await (const file of new Glob(models).scan()) {
-    matched = true;
-    const mod = await import(resolve(file));
-    for (const value of Object.values(mod)) {
-      if (isModelClass(value))
-        resolved.push(value);
-    }
-  }
-  if (!matched) {
-    try {
-      const mod = await import(resolve(models));
-      for (const value of Object.values(mod)) {
-        if (isModelClass(value))
-          resolved.push(value);
-      }
-    } catch {}
-  }
-  return resolved;
-}
-async function loadConfig() {
-  const candidates = ["peta.config.ts", "peta.config.js", "peta.config.mjs"];
-  let config;
-  for (const file of candidates) {
-    try {
-      const mod = await import(resolve(file));
-      if (mod.default) {
-        config = mod.default;
-        break;
-      }
-    } catch {
-      continue;
-    }
-  }
-  if (!config) {
-    throw new Error(`No peta.config.ts found in current directory. Create one:
-
-  import { defineConfig } from "peta-orm/migrator"
-  export default defineConfig({
-    migrationsDir: "./migrations",
-    models: [],
-  })`);
-  }
-  const db = new Database(":memory:");
-  const peta = new Peta({ dialect: new BunSqliteDialect({ database: db }) });
-  const models = await resolveModels(config.models);
-  peta.registerAll(...models);
-  return {
-    peta,
-    migrationsDir: config.migrationsDir,
-    getKysely: () => peta.kysely,
-    getModels: () => peta.models
-  };
-}
-async function loadMigrationFiles(dir) {
-  let entries;
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return [];
-  }
-  const files = [];
-  for (const entry of entries.sort()) {
-    if (!entry.endsWith(".ts") && !entry.endsWith(".js"))
-      continue;
-    if (entry.startsWith("."))
-      continue;
-    const abs = resolve(dir, entry);
-    const mod = await import(abs);
-    if (typeof mod.up === "function" && typeof mod.down === "function") {
-      files.push({ name: entry.replace(/\.(ts|js)$/, ""), up: mod.up, down: mod.down });
-    }
-  }
-  return files;
-}
-
-export { MigrationRunner, MigrationGenerator, defineConfig, loadConfig, loadMigrationFiles };